Grcov report - text

1

//! Single-line text input widget with placeholder and two-way data binding.

2

//!

3

//! The main entry point is [`TextInput`], which holds the editable state

4

//! ([`TextInputState`]) together with per-platform default styles.  Call

5

//! [`TextInput::dom()`] to obtain a renderable [`Dom`] node.

6

//!

7

//! The widget is a `contenteditable` host: the container carries the flag and

8

//! the tab index, so the engine's `TextEditManager` owns the caret, the

9

//! selection and the buffer. Caret and selection are display-list items driven

10

//! by that manager — the widget contributes no cursor node — and edits run

11

//! through `record_text_input` / `apply_text_changeset`. [`TextInputState`] is a

12

//! *mirror* of that state, refreshed from the engine's changesets so the public

13

//! callbacks keep the shape existing hosts bind against.

14

//!

15

//! Both the value and the placeholder are `<p>` blocks wrapping a bare text

16

//! node: a [`NodeType::Text`](azul_core::dom::NodeType::Text) node is always

17

//! inline-level and owns no rect, so box-model properties on one are inert and

18

//! nothing bounds or clips the line.

19

//!

20

//! For higher-level text-input management (IME, clipboard, undo) see

21

//! `layout/src/managers/text_input.rs`.

22

23

use alloc::{string::String, vec::Vec};

24

25

use azul_core::{

26

    callbacks::{CoreCallback, CoreCallbackData, Update},

27

    dom::{Dom, DomNodeId},

28

    refany::RefAny,

29

    task::OptionTimerId,

30

};

31

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

32

use azul_css::{

33

    dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec},

34

    props::{

35

        basic::*,

36

        layout::*,

37

        property::{CssProperty, *},

38

        style::*,

39

},

40

*,

41

};

42

use azul_css::css::BoxOrStatic;

43

44

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

45

46

const BACKGROUND_COLOR: ColorU = ColorU {

47

    r: 255,

48

    g: 255,

49

    b: 255,

50

    a: 255,

51

}; // white

52

const BLACK: ColorU = ColorU {

53

    r: 0,

54

    g: 0,

55

    b: 0,

56

    a: 255,

57

};

58

const TEXT_COLOR: StyleTextColor = StyleTextColor { inner: BLACK }; // black

59

const COLOR_9B9B9B: ColorU = ColorU {

60

    r: 155,

61

    g: 155,

62

    b: 155,

63

    a: 255,

64

}; // #9b9b9b

65

const COLOR_4286F4: ColorU = ColorU {

66

    r: 66,

67

    g: 134,

68

    b: 244,

69

    a: 255,

70

}; // #4286f4

71

const COLOR_4C4C4C: ColorU = ColorU {

72

    r: 76,

73

    g: 76,

74

    b: 76,

75

    a: 255,

76

}; // #4C4C4C

77

78

const BACKGROUND_THEME_LIGHT: &[StyleBackgroundContent] =

79

    &[StyleBackgroundContent::Color(BACKGROUND_COLOR)];

80

const BACKGROUND_COLOR_LIGHT: StyleBackgroundContentVec =

81

    StyleBackgroundContentVec::from_const_slice(BACKGROUND_THEME_LIGHT);

82

83

const SANS_SERIF_STR: &str = "system:ui";

84

const SANS_SERIF: AzString = AzString::from_const_str(SANS_SERIF_STR);

85

const SANS_SERIF_FAMILIES: &[StyleFontFamily] = &[StyleFontFamily::System(SANS_SERIF)];

86

const SANS_SERIF_FAMILY: StyleFontFamilyVec =

87

    StyleFontFamilyVec::from_const_slice(SANS_SERIF_FAMILIES);

88

89

// -- container style

90

91

#[cfg(target_os = "windows")]

92

static TEXT_INPUT_CONTAINER_PROPS: &[CssPropertyWithConditions] = &[

93

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Relative)),

94

    CssPropertyWithConditions::simple(CssProperty::const_cursor(StyleCursor::Text)),

95

    CssPropertyWithConditions::simple(CssProperty::const_box_sizing(LayoutBoxSizing::BorderBox)),

96

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(1))),

97

    CssPropertyWithConditions::simple(CssProperty::const_background_content(

98

        BACKGROUND_COLOR_LIGHT,

99

)),

100

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

101

        inner: COLOR_4C4C4C,

102

    })),

103

    CssPropertyWithConditions::simple(CssProperty::const_padding_left(

104

        LayoutPaddingLeft::const_px(2),

105

)),

106

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

107

        LayoutPaddingRight::const_px(2),

108

)),

109

    CssPropertyWithConditions::simple(CssProperty::const_padding_top(LayoutPaddingTop::const_px(

110

1,

111

    ))),

112

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

113

        LayoutPaddingBottom::const_px(1),

114

)),

115

    // border: 1px solid #484c52;

116

    CssPropertyWithConditions::simple(CssProperty::const_border_top_width(

117

        LayoutBorderTopWidth::const_px(1),

118

)),

119

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_width(

120

        LayoutBorderBottomWidth::const_px(1),

121

)),

122

    CssPropertyWithConditions::simple(CssProperty::const_border_left_width(

123

        LayoutBorderLeftWidth::const_px(1),

124

)),

125

    CssPropertyWithConditions::simple(CssProperty::const_border_right_width(

126

        LayoutBorderRightWidth::const_px(1),

127

)),

128

    CssPropertyWithConditions::simple(CssProperty::const_border_top_style(StyleBorderTopStyle {

129

        inner: BorderStyle::Inset,

130

    })),

131

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_style(

132

        StyleBorderBottomStyle {

133

            inner: BorderStyle::Inset,

134

},

135

)),

136

    CssPropertyWithConditions::simple(CssProperty::const_border_left_style(StyleBorderLeftStyle {

137

        inner: BorderStyle::Inset,

138

    })),

139

    CssPropertyWithConditions::simple(CssProperty::const_border_right_style(

140

        StyleBorderRightStyle {

141

            inner: BorderStyle::Inset,

142

},

143

)),

144

    CssPropertyWithConditions::simple(CssProperty::const_border_top_color(StyleBorderTopColor {

145

        inner: COLOR_9B9B9B,

146

    })),

147

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_color(

148

        StyleBorderBottomColor {

149

            inner: COLOR_9B9B9B,

150

},

151

)),

152

    CssPropertyWithConditions::simple(CssProperty::const_border_left_color(StyleBorderLeftColor {

153

        inner: COLOR_9B9B9B,

154

    })),

155

    CssPropertyWithConditions::simple(CssProperty::const_border_right_color(

156

        StyleBorderRightColor {

157

            inner: COLOR_9B9B9B,

158

},

159

)),

160

    CssPropertyWithConditions::simple(CssProperty::const_overflow_x(LayoutOverflow::Hidden)),

161

    CssPropertyWithConditions::simple(CssProperty::const_overflow_y(LayoutOverflow::Hidden)),

162

    CssPropertyWithConditions::simple(CssProperty::const_justify_content(

163

        LayoutJustifyContent::Center,

164

)),

165

    // Hover(border-color: #4c4c4c;)

166

    CssPropertyWithConditions::on_hover(CssProperty::const_border_top_color(StyleBorderTopColor {

167

        inner: COLOR_4C4C4C,

168

    })),

169

    CssPropertyWithConditions::on_hover(CssProperty::const_border_bottom_color(

170

        StyleBorderBottomColor {

171

            inner: COLOR_4C4C4C,

172

},

173

)),

174

    CssPropertyWithConditions::on_hover(CssProperty::const_border_left_color(

175

        StyleBorderLeftColor {

176

            inner: COLOR_4C4C4C,

177

},

178

)),

179

    CssPropertyWithConditions::on_hover(CssProperty::const_border_right_color(

180

        StyleBorderRightColor {

181

            inner: COLOR_4C4C4C,

182

},

183

)),

184

    // Focus(border-color: #4286f4;)

185

    CssPropertyWithConditions::on_focus(CssProperty::const_border_top_color(StyleBorderTopColor {

186

        inner: COLOR_4286F4,

187

    })),

188

    CssPropertyWithConditions::on_focus(CssProperty::const_border_bottom_color(

189

        StyleBorderBottomColor {

190

            inner: COLOR_4286F4,

191

},

192

)),

193

    CssPropertyWithConditions::on_focus(CssProperty::const_border_left_color(

194

        StyleBorderLeftColor {

195

            inner: COLOR_4286F4,

196

},

197

)),

198

    CssPropertyWithConditions::on_focus(CssProperty::const_border_right_color(

199

        StyleBorderRightColor {

200

            inner: COLOR_4286F4,

201

},

202

)),

203

];

204

205

#[cfg(target_os = "linux")]

206

static TEXT_INPUT_CONTAINER_PROPS: &[CssPropertyWithConditions] = &[

207

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Relative)),

208

    CssPropertyWithConditions::simple(CssProperty::const_cursor(StyleCursor::Text)),

209

    CssPropertyWithConditions::simple(CssProperty::const_box_sizing(LayoutBoxSizing::BorderBox)),

210

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(11))),

211

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(1))),

212

    CssPropertyWithConditions::simple(CssProperty::const_background_content(

213

        BACKGROUND_COLOR_LIGHT,

214

)),

215

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

216

        inner: COLOR_4C4C4C,

217

    })),

218

    CssPropertyWithConditions::simple(CssProperty::const_padding_left(

219

        LayoutPaddingLeft::const_px(2),

220

)),

221

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

222

        LayoutPaddingRight::const_px(2),

223

)),

224

    CssPropertyWithConditions::simple(CssProperty::const_padding_top(LayoutPaddingTop::const_px(

225

1,

226

    ))),

227

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

228

        LayoutPaddingBottom::const_px(1),

229

)),

230

    // border: 1px solid #484c52;

231

    CssPropertyWithConditions::simple(CssProperty::const_border_top_width(

232

        LayoutBorderTopWidth::const_px(1),

233

)),

234

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_width(

235

        LayoutBorderBottomWidth::const_px(1),

236

)),

237

    CssPropertyWithConditions::simple(CssProperty::const_border_left_width(

238

        LayoutBorderLeftWidth::const_px(1),

239

)),

240

    CssPropertyWithConditions::simple(CssProperty::const_border_right_width(

241

        LayoutBorderRightWidth::const_px(1),

242

)),

243

    CssPropertyWithConditions::simple(CssProperty::const_border_top_style(StyleBorderTopStyle {

244

        inner: BorderStyle::Inset,

245

    })),

246

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_style(

247

        StyleBorderBottomStyle {

248

            inner: BorderStyle::Inset,

249

},

250

)),

251

    CssPropertyWithConditions::simple(CssProperty::const_border_left_style(StyleBorderLeftStyle {

252

        inner: BorderStyle::Inset,

253

    })),

254

    CssPropertyWithConditions::simple(CssProperty::const_border_right_style(

255

        StyleBorderRightStyle {

256

            inner: BorderStyle::Inset,

257

},

258

)),

259

    CssPropertyWithConditions::simple(CssProperty::const_border_top_color(StyleBorderTopColor {

260

        inner: COLOR_9B9B9B,

261

    })),

262

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_color(

263

        StyleBorderBottomColor {

264

            inner: COLOR_9B9B9B,

265

},

266

)),

267

    CssPropertyWithConditions::simple(CssProperty::const_border_left_color(StyleBorderLeftColor {

268

        inner: COLOR_9B9B9B,

269

    })),

270

    CssPropertyWithConditions::simple(CssProperty::const_border_right_color(

271

        StyleBorderRightColor {

272

            inner: COLOR_9B9B9B,

273

},

274

)),

275

    CssPropertyWithConditions::simple(CssProperty::const_overflow_x(LayoutOverflow::Hidden)),

276

    CssPropertyWithConditions::simple(CssProperty::const_overflow_y(LayoutOverflow::Hidden)),

277

    CssPropertyWithConditions::simple(CssProperty::const_text_align(StyleTextAlign::Left)),

278

    CssPropertyWithConditions::simple(CssProperty::const_justify_content(

279

        LayoutJustifyContent::Center,

280

)),

281

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

282

    // Hover(border-color: #4286f4;)

283

    CssPropertyWithConditions::on_hover(CssProperty::const_border_top_color(StyleBorderTopColor {

284

        inner: COLOR_4286F4,

285

    })),

286

    CssPropertyWithConditions::on_hover(CssProperty::const_border_bottom_color(

287

        StyleBorderBottomColor {

288

            inner: COLOR_4286F4,

289

},

290

)),

291

    CssPropertyWithConditions::on_hover(CssProperty::const_border_left_color(

292

        StyleBorderLeftColor {

293

            inner: COLOR_4286F4,

294

},

295

)),

296

    CssPropertyWithConditions::on_hover(CssProperty::const_border_right_color(

297

        StyleBorderRightColor {

298

            inner: COLOR_4286F4,

299

},

300

)),

301

    // Focus(border-color: #4286f4;)

302

    CssPropertyWithConditions::on_focus(CssProperty::const_border_top_color(StyleBorderTopColor {

303

        inner: COLOR_4286F4,

304

    })),

305

    CssPropertyWithConditions::on_focus(CssProperty::const_border_bottom_color(

306

        StyleBorderBottomColor {

307

            inner: COLOR_4286F4,

308

},

309

)),

310

    CssPropertyWithConditions::on_focus(CssProperty::const_border_left_color(

311

        StyleBorderLeftColor {

312

            inner: COLOR_4286F4,

313

},

314

)),

315

    CssPropertyWithConditions::on_focus(CssProperty::const_border_right_color(

316

        StyleBorderRightColor {

317

            inner: COLOR_4286F4,

318

},

319

)),

320

];

321

322

// Mobile (Android / iOS) inherit the macOS-style container — same flex

323

// box-sizing and background; touch-target padding is the user's concern.

324

#[cfg(not(any(target_os = "windows", target_os = "linux")))]

325

static TEXT_INPUT_CONTAINER_PROPS: &[CssPropertyWithConditions] = &[

326

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Relative)),

327

    CssPropertyWithConditions::simple(CssProperty::const_cursor(StyleCursor::Text)),

328

    CssPropertyWithConditions::simple(CssProperty::const_box_sizing(LayoutBoxSizing::BorderBox)),

329

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(1))),

330

    CssPropertyWithConditions::simple(CssProperty::const_background_content(

331

        BACKGROUND_COLOR_LIGHT,

332

)),

333

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

334

        inner: COLOR_4C4C4C,

335

    })),

336

    CssPropertyWithConditions::simple(CssProperty::const_padding_left(

337

        LayoutPaddingLeft::const_px(2),

338

)),

339

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

340

        LayoutPaddingRight::const_px(2),

341

)),

342

    CssPropertyWithConditions::simple(CssProperty::const_padding_top(LayoutPaddingTop::const_px(

343

1,

344

    ))),

345

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

346

        LayoutPaddingBottom::const_px(1),

347

)),

348

    // border: 1px solid #484c52;

349

    CssPropertyWithConditions::simple(CssProperty::const_border_top_width(

350

        LayoutBorderTopWidth::const_px(1),

351

)),

352

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_width(

353

        LayoutBorderBottomWidth::const_px(1),

354

)),

355

    CssPropertyWithConditions::simple(CssProperty::const_border_left_width(

356

        LayoutBorderLeftWidth::const_px(1),

357

)),

358

    CssPropertyWithConditions::simple(CssProperty::const_border_right_width(

359

        LayoutBorderRightWidth::const_px(1),

360

)),

361

    CssPropertyWithConditions::simple(CssProperty::const_border_top_style(StyleBorderTopStyle {

362

        inner: BorderStyle::Inset,

363

    })),

364

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_style(

365

        StyleBorderBottomStyle {

366

            inner: BorderStyle::Inset,

367

},

368

)),

369

    CssPropertyWithConditions::simple(CssProperty::const_border_left_style(StyleBorderLeftStyle {

370

        inner: BorderStyle::Inset,

371

    })),

372

    CssPropertyWithConditions::simple(CssProperty::const_border_right_style(

373

        StyleBorderRightStyle {

374

            inner: BorderStyle::Inset,

375

},

376

)),

377

    CssPropertyWithConditions::simple(CssProperty::const_border_top_color(StyleBorderTopColor {

378

        inner: COLOR_9B9B9B,

379

    })),

380

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_color(

381

        StyleBorderBottomColor {

382

            inner: COLOR_9B9B9B,

383

},

384

)),

385

    CssPropertyWithConditions::simple(CssProperty::const_border_left_color(StyleBorderLeftColor {

386

        inner: COLOR_9B9B9B,

387

    })),

388

    CssPropertyWithConditions::simple(CssProperty::const_border_right_color(

389

        StyleBorderRightColor {

390

            inner: COLOR_9B9B9B,

391

},

392

)),

393

    CssPropertyWithConditions::simple(CssProperty::const_overflow_x(LayoutOverflow::Hidden)),

394

    CssPropertyWithConditions::simple(CssProperty::const_overflow_y(LayoutOverflow::Hidden)),

395

    CssPropertyWithConditions::simple(CssProperty::const_text_align(StyleTextAlign::Left)),

396

    CssPropertyWithConditions::simple(CssProperty::const_justify_content(

397

        LayoutJustifyContent::Center,

398

)),

399

    // Hover(border-color: #4286f4;)

400

    CssPropertyWithConditions::on_hover(CssProperty::const_border_top_color(StyleBorderTopColor {

401

        inner: COLOR_4286F4,

402

    })),

403

    CssPropertyWithConditions::on_hover(CssProperty::const_border_bottom_color(

404

        StyleBorderBottomColor {

405

            inner: COLOR_4286F4,

406

},

407

)),

408

    CssPropertyWithConditions::on_hover(CssProperty::const_border_left_color(

409

        StyleBorderLeftColor {

410

            inner: COLOR_4286F4,

411

},

412

)),

413

    CssPropertyWithConditions::on_hover(CssProperty::const_border_right_color(

414

        StyleBorderRightColor {

415

            inner: COLOR_4286F4,

416

},

417

)),

418

    // Focus(border-color: #4286f4;)

419

    CssPropertyWithConditions::on_focus(CssProperty::const_border_top_color(StyleBorderTopColor {

420

        inner: COLOR_4286F4,

421

    })),

422

    CssPropertyWithConditions::on_focus(CssProperty::const_border_bottom_color(

423

        StyleBorderBottomColor {

424

            inner: COLOR_4286F4,

425

},

426

)),

427

    CssPropertyWithConditions::on_focus(CssProperty::const_border_left_color(

428

        StyleBorderLeftColor {

429

            inner: COLOR_4286F4,

430

},

431

)),

432

    CssPropertyWithConditions::on_focus(CssProperty::const_border_right_color(

433

        StyleBorderRightColor {

434

            inner: COLOR_4286F4,

435

},

436

)),

437

];

438

439

// -- label style

440

//

441

// The label is the `<p>` block wrapping the value text, so it is the box that

442

// bounds the line and clips against the container's `overflow: hidden`.

443

// `white-space: pre` keeps a single-line field on one line and preserves the

444

// spaces the user typed.

445

446

#[cfg(target_os = "windows")]

447

static TEXT_INPUT_LABEL_PROPS: &[CssPropertyWithConditions] = &[

448

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Block)),

449

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

450

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Relative)),

451

    CssPropertyWithConditions::simple(CssProperty::const_overflow_x(LayoutOverflow::Hidden)),

452

    CssPropertyWithConditions::simple(CssProperty::const_overflow_y(LayoutOverflow::Hidden)),

453

    CssPropertyWithConditions::simple(CssProperty::WhiteSpace(StyleWhiteSpaceValue::Exact(

454

        StyleWhiteSpace::Pre,

455

    ))),

456

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(11))),

457

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

458

        inner: COLOR_4C4C4C,

459

    })),

460

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

461

];

462

463

#[cfg(target_os = "linux")]

464

static TEXT_INPUT_LABEL_PROPS: &[CssPropertyWithConditions] = &[

465

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Block)),

466

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

467

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Relative)),

468

    CssPropertyWithConditions::simple(CssProperty::const_overflow_x(LayoutOverflow::Hidden)),

469

    CssPropertyWithConditions::simple(CssProperty::const_overflow_y(LayoutOverflow::Hidden)),

470

    CssPropertyWithConditions::simple(CssProperty::WhiteSpace(StyleWhiteSpaceValue::Exact(

471

        StyleWhiteSpace::Pre,

472

    ))),

473

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(11))),

474

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

475

        inner: COLOR_4C4C4C,

476

    })),

477

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

478

];

479

480

#[cfg(not(any(target_os = "windows", target_os = "linux")))]

481

static TEXT_INPUT_LABEL_PROPS: &[CssPropertyWithConditions] = &[

482

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Block)),

483

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

484

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Relative)),

485

    CssPropertyWithConditions::simple(CssProperty::const_overflow_x(LayoutOverflow::Hidden)),

486

    CssPropertyWithConditions::simple(CssProperty::const_overflow_y(LayoutOverflow::Hidden)),

487

    CssPropertyWithConditions::simple(CssProperty::WhiteSpace(StyleWhiteSpaceValue::Exact(

488

        StyleWhiteSpace::Pre,

489

    ))),

490

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(11))),

491

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

492

        inner: COLOR_4C4C4C,

493

    })),

494

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

495

];

496

497

// --- placeholder

498

//

499

// An absolutely-positioned `<p>` overlay inside the editable container. It is

500

// marked `contenteditable="false"` so the engine's inheritance walk stops at it

501

// and the prompt never becomes part of the buffer, and it is toggled with

502

// `display` as well as `opacity`: a hidden-but-laid-out overlay would still own

503

// the container's first inline layout, which is what

504

// `LayoutWindow::reshape_text_node` picks up when it looks for the IFC to write

505

// an edit into.

506

507

#[cfg(target_os = "windows")]

508

static TEXT_INPUT_PLACEHOLDER_PROPS: &[CssPropertyWithConditions] = &[

509

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Block)),

510

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

511

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Absolute)),

512

    CssPropertyWithConditions::simple(CssProperty::const_top(LayoutTop::const_px(2))),

513

    CssPropertyWithConditions::simple(CssProperty::const_left(LayoutLeft::const_px(2))),

514

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(11))),

515

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

516

        inner: COLOR_4C4C4C,

517

    })),

518

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

519

    CssPropertyWithConditions::simple(CssProperty::const_opacity(StyleOpacity::const_new(100))),

520

];

521

522

#[cfg(target_os = "linux")]

523

static TEXT_INPUT_PLACEHOLDER_PROPS: &[CssPropertyWithConditions] = &[

524

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Block)),

525

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

526

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Absolute)),

527

    CssPropertyWithConditions::simple(CssProperty::const_top(LayoutTop::const_px(2))),

528

    CssPropertyWithConditions::simple(CssProperty::const_left(LayoutLeft::const_px(2))),

529

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(11))),

530

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

531

        inner: COLOR_4C4C4C,

532

    })),

533

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

534

    CssPropertyWithConditions::simple(CssProperty::const_opacity(StyleOpacity::const_new(100))),

535

];

536

537

#[cfg(not(any(target_os = "windows", target_os = "linux")))]

538

static TEXT_INPUT_PLACEHOLDER_PROPS: &[CssPropertyWithConditions] = &[

539

    CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Block)),

540

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

541

    CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Absolute)),

542

    CssPropertyWithConditions::simple(CssProperty::const_top(LayoutTop::const_px(2))),

543

    CssPropertyWithConditions::simple(CssProperty::const_left(LayoutLeft::const_px(2))),

544

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(11))),

545

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

546

        inner: COLOR_4C4C4C,

547

    })),

548

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

549

    CssPropertyWithConditions::simple(CssProperty::const_opacity(StyleOpacity::const_new(100))),

550

];

551

552

/// Single-line text input widget with platform-native styling.

553

///

554

/// Use [`TextInput::create()`] to build an instance, configure it with the

555

/// `with_*` / `set_*` builder methods, and call [`TextInput::dom()`] to

556

/// obtain a renderable DOM tree.

557

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

558

#[repr(C)]

559

pub struct TextInput {

560

    pub text_input_state: TextInputStateWrapper,

561

    pub placeholder_style: CssPropertyWithConditionsVec,

562

    pub container_style: CssPropertyWithConditionsVec,

563

    pub label_style: CssPropertyWithConditionsVec,

564

565

566

/// Editable state of a text input (text buffer, cursor position, selection).

567

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

568

#[repr(C)]

569

pub struct TextInputState {

570

    pub text: U32Vec, // Vec<char>

571

    pub placeholder: OptionString,

572

    pub max_len: usize,

573

    pub selection: OptionTextInputSelection,

574

    pub cursor_pos: usize,

575

576

577

/// [`TextInputState`] together with optional user callbacks and cursor animation state.

578

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

579

#[repr(C)]

580

pub struct TextInputStateWrapper {

581

    pub inner: TextInputState,

582

    pub on_text_input: OptionTextInputOnTextInput,

583

    pub on_virtual_key_down: OptionTextInputOnVirtualKeyDown,

584

    pub on_focus_lost: OptionTextInputOnFocusLost,

585

    pub update_text_input_before_calling_focus_lost_fn: bool,

586

    pub update_text_input_before_calling_vk_down_fn: bool,

587

    pub cursor_animation: OptionTimerId,

588

589

590

/// Return value from a text-input callback indicating whether the framework

591

/// should update and whether the input was valid.

592

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

593

#[repr(C)]

594

pub struct OnTextInputReturn {

595

    pub update: Update,

596

    pub valid: TextInputValid,

597

598

599

/// Whether the text input accepted or rejected the most recent edit.

600

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

601

#[repr(C)]

602

pub enum TextInputValid {

603

    Yes,

604

No,

605

606

607

// The text input field has a special return which specifies

608

// whether the text input should handle the character

609

pub type TextInputOnTextInputCallbackType =

610

    extern "C" fn(RefAny, CallbackInfo, TextInputState) -> OnTextInputReturn;

611

impl_widget_callback!(

612

    TextInputOnTextInput,

613

    OptionTextInputOnTextInput,

614

    TextInputOnTextInputCallback,

615

    TextInputOnTextInputCallbackType

616

);

617

618

azul_core::impl_managed_callback! {

619

    wrapper:        TextInputOnTextInputCallback,

620

    info_ty:        CallbackInfo,

621

    return_ty:      OnTextInputReturn,

622

    default_ret:    OnTextInputReturn { update: Update::DoNothing, valid: TextInputValid::Yes },

623

    invoker_static: TEXT_INPUT_ON_TEXT_INPUT_INVOKER,

624

    invoker_ty:     AzTextInputOnTextInputCallbackInvoker,

625

    thunk_fn:       az_text_input_on_text_input_callback_thunk,

626

    setter_fn:      AzApp_setTextInputOnTextInputCallbackInvoker,

627

    from_handle_fn: AzTextInputOnTextInputCallback_createFromHostHandle,

628

    extra_args:     [ state: TextInputState ],

629

630

631

pub type TextInputOnVirtualKeyDownCallbackType =

632

    extern "C" fn(RefAny, CallbackInfo, TextInputState) -> OnTextInputReturn;

633

impl_widget_callback!(

634

    TextInputOnVirtualKeyDown,

635

    OptionTextInputOnVirtualKeyDown,

636

    TextInputOnVirtualKeyDownCallback,

637

    TextInputOnVirtualKeyDownCallbackType

638

);

639

640

azul_core::impl_managed_callback! {

641

    wrapper:        TextInputOnVirtualKeyDownCallback,

642

    info_ty:        CallbackInfo,

643

    return_ty:      OnTextInputReturn,

644

    default_ret:    OnTextInputReturn { update: Update::DoNothing, valid: TextInputValid::Yes },

645

    invoker_static: TEXT_INPUT_ON_VIRTUAL_KEY_DOWN_INVOKER,

646

    invoker_ty:     AzTextInputOnVirtualKeyDownCallbackInvoker,

647

    thunk_fn:       az_text_input_on_virtual_key_down_callback_thunk,

648

    setter_fn:      AzApp_setTextInputOnVirtualKeyDownCallbackInvoker,

649

    from_handle_fn: AzTextInputOnVirtualKeyDownCallback_createFromHostHandle,

650

    extra_args:     [ state: TextInputState ],

651

652

653

pub type TextInputOnFocusLostCallbackType =

654

    extern "C" fn(RefAny, CallbackInfo, TextInputState) -> Update;

655

impl_widget_callback!(

656

    TextInputOnFocusLost,

657

    OptionTextInputOnFocusLost,

658

    TextInputOnFocusLostCallback,

659

    TextInputOnFocusLostCallbackType

660

);

661

662

azul_core::impl_managed_callback! {

663

    wrapper:        TextInputOnFocusLostCallback,

664

    info_ty:        CallbackInfo,

665

    return_ty:      Update,

666

    default_ret:    Update::DoNothing,

667

    invoker_static: TEXT_INPUT_ON_FOCUS_LOST_INVOKER,

668

    invoker_ty:     AzTextInputOnFocusLostCallbackInvoker,

669

    thunk_fn:       az_text_input_on_focus_lost_callback_thunk,

670

    setter_fn:      AzApp_setTextInputOnFocusLostCallbackInvoker,

671

    from_handle_fn: AzTextInputOnFocusLostCallback_createFromHostHandle,

672

    extra_args:     [ state: TextInputState ],

673

674

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

675

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

676

#[repr(C, u8)]

677

pub enum TextInputSelection {

678

    All,

679

    FromTo(TextInputSelectionRange),

680

681

682

azul_css::impl_option!(

683

    TextInputSelection,

684

    OptionTextInputSelection,

685

    copy = false,

686

    [Debug, Clone, Hash, PartialEq, Eq]

687

);

688

689

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

690

#[repr(C)]

691

pub struct TextInputSelectionRange {

692

    pub dir_from: usize,

693

    pub dir_to: usize,

694

695

696

impl Default for TextInput {

697

441

    fn default() -> Self {

698

441

        Self {

699

441

            text_input_state: TextInputStateWrapper::default(),

700

441

            placeholder_style: CssPropertyWithConditionsVec::from_const_slice(

701

441

                TEXT_INPUT_PLACEHOLDER_PROPS,

702

441

),

703

441

            container_style: CssPropertyWithConditionsVec::from_const_slice(

704

441

                TEXT_INPUT_CONTAINER_PROPS,

705

441

),

706

441

            label_style: CssPropertyWithConditionsVec::from_const_slice(TEXT_INPUT_LABEL_PROPS),

707

441

708

441

709

710

711

impl Default for TextInputState {

712

616

    fn default() -> Self {

713

616

        Self {

714

616

            text: Vec::new().into(),

715

616

            placeholder: None.into(),

716

616

            max_len: 50,

717

616

            selection: None.into(),

718

616

            cursor_pos: 0,

719

616

720

616

721

722

723

impl TextInputState {

724

187

    #[must_use] pub fn get_text(&self) -> String {

725

187

        self.text

726

187

            .iter()

727

51267

            .filter_map(|c| core::char::from_u32(*c))

728

187

            .collect()

729

187

730

731

732

impl Default for TextInputStateWrapper {

733

441

    fn default() -> Self {

734

441

        Self {

735

441

            inner: TextInputState::default(),

736

441

            on_text_input: None.into(),

737

441

            on_virtual_key_down: None.into(),

738

441

            on_focus_lost: None.into(),

739

441

            update_text_input_before_calling_focus_lost_fn: true,

740

441

            update_text_input_before_calling_vk_down_fn: true,

741

441

            cursor_animation: None.into(),

742

441

743

441

744

745

746

impl TextInput {

747

299

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

748

299

        Self::default()

749

299

750

751

140

    #[must_use] pub fn with_text(mut self, text: AzString) -> Self {

752

140

        self.set_text(text);

753

140

        self

754

140

755

756

    // owned AzString passed by value per the azul FFI / api.json setter convention.

757

    #[allow(clippy::needless_pass_by_value)]

758

204

    pub fn set_text(&mut self, text: AzString) {

759

204

        self.text_input_state.inner.text = text

760

204

            .as_str()

761

204

            .chars()

762

100717

            .map(|c| c as u32)

763

204

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

764

204

            .into();

765

204

766

767

70

    pub fn set_placeholder(&mut self, placeholder: AzString) {

768

70

        self.text_input_state.inner.placeholder = Some(placeholder).into();

769

70

770

771

47

    #[must_use] pub fn with_placeholder(mut self, placeholder: AzString) -> Self {

772

47

        self.set_placeholder(placeholder);

773

47

        self

774

47

775

776

68

    pub fn set_on_text_input<C: Into<TextInputOnTextInputCallback>>(

777

68

        &mut self,

778

68

        refany: RefAny,

779

68

        callback: C,

780

68

) {

781

68

        self.text_input_state.on_text_input = Some(TextInputOnTextInput {

782

68

            callback: callback.into(),

783

68

            refany,

784

68

})

785

68

        .into();

786

68

787

788

    #[must_use]

789

5

    pub fn with_on_text_input<C: Into<TextInputOnTextInputCallback>>(

790

5

        mut self,

791

5

        refany: RefAny,

792

5

        callback: C,

793

5

    ) -> Self {

794

5

        self.set_on_text_input(refany, callback);

795

5

        self

796

5

797

798

13

    pub fn set_on_virtual_key_down<C: Into<TextInputOnVirtualKeyDownCallback>>(

799

13

        &mut self,

800

13

        refany: RefAny,

801

13

        callback: C,

802

13

) {

803

13

        self.text_input_state.on_virtual_key_down = Some(TextInputOnVirtualKeyDown {

804

13

            callback: callback.into(),

805

13

            refany,

806

13

})

807

13

        .into();

808

13

809

810

    #[must_use]

811

8

    pub fn with_on_virtual_key_down<C: Into<TextInputOnVirtualKeyDownCallback>>(

812

8

        mut self,

813

8

        refany: RefAny,

814

8

        callback: C,

815

8

    ) -> Self {

816

8

        self.set_on_virtual_key_down(refany, callback);

817

8

        self

818

8

819

820

64

    pub fn set_on_focus_lost<C: Into<TextInputOnFocusLostCallback>>(

821

64

        &mut self,

822

64

        refany: RefAny,

823

64

        callback: C,

824

64

) {

825

64

        self.text_input_state.on_focus_lost = Some(TextInputOnFocusLost {

826

64

            callback: callback.into(),

827

64

            refany,

828

64

})

829

64

        .into();

830

64

831

832

    #[must_use]

833

6

    pub fn with_on_focus_lost<C: Into<TextInputOnFocusLostCallback>>(

834

6

        mut self,

835

6

        refany: RefAny,

836

6

        callback: C,

837

6

    ) -> Self {

838

6

        self.set_on_focus_lost(refany, callback);

839

6

        self

840

6

841

842

6

    pub fn set_placeholder_style(&mut self, style: CssPropertyWithConditionsVec) {

843

6

        self.placeholder_style = style;

844

6

845

846

4

    #[must_use] pub fn with_placeholder_style(mut self, style: CssPropertyWithConditionsVec) -> Self {

847

4

        self.set_placeholder_style(style);

848

4

        self

849

4

850

851

7

    pub fn set_container_style(&mut self, style: CssPropertyWithConditionsVec) {

852

7

        self.container_style = style;

853

7

854

855

3

    #[must_use] pub fn with_container_style(mut self, style: CssPropertyWithConditionsVec) -> Self {

856

3

        self.set_container_style(style);

857

3

        self

858

3

859

860

5

    pub fn set_label_style(&mut self, style: CssPropertyWithConditionsVec) {

861

5

        self.label_style = style;

862

5

863

864

3

    #[must_use] pub fn with_label_style(mut self, style: CssPropertyWithConditionsVec) -> Self {

865

3

        self.set_label_style(style);

866

3

        self

867

3

868

869

    #[must_use]

870

4

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

871

4

        let mut s = Self::default();

872

4

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

873

4

874

4

875

876

    /// Renders the widget.

877

///

878

    /// The container is the `contenteditable` host — the flag, the tab index and

879

    /// the focus callbacks all sit on it, because focus events do not bubble and

880

    /// the engine records an edit against the *focused* node. Its two children

881

    /// are `<p>` blocks wrapping a bare text node each; nothing else is emitted,

882

    /// in particular no caret node (the engine paints the caret and the

883

    /// selection from its display list).

884

166

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

885

        use azul_core::{

886

            callbacks::CoreCallbackData,

887

            dom::{

888

                AttributeType, DomVec, EventFilter, FocusEventFilter, HoverEventFilter,

889

                IdOrClass::Class, TabIndex,

890

},

891

};

892

893

166

        self.text_input_state.inner.cursor_pos = self.text_input_state.inner.text.len();

894

895

166

        let label_text: String = self

896

166

            .text_input_state

897

166

            .inner

898

166

            .text

899

166

            .iter()

900

50835

            .filter_map(|s| core::char::from_u32(*s))

901

166

            .collect();

902

903

166

        let placeholder = self

904

166

            .text_input_state

905

166

            .inner

906

166

            .placeholder

907

166

            .as_ref()

908

166

            .map(|s| s.as_str().to_string())

909

166

            .unwrap_or_default();

910

911

166

        let mut placeholder_style = self.placeholder_style;

912

166

        if !self.text_input_state.inner.text.is_empty() {

913

124

            placeholder_style = hidden_placeholder_style(&placeholder_style);

914

124

915

916

166

        let state_ref = RefAny::new(self.text_input_state);

917

918

166

        Dom::create_div()

919

166

            .with_ids_and_classes(vec![Class("__azul-native-text-input-container".into())].into())

920

166

            .with_css_props(self.container_style)

921

166

            .with_tab_index(TabIndex::Auto)

922

166

            .with_contenteditable(true)

923

166

            .with_dataset(Some(state_ref.clone()).into())

924

166

            .with_callbacks(

925

166

                vec![

926

166

                    CoreCallbackData {

927

166

                        event: EventFilter::Focus(FocusEventFilter::FocusReceived),

928

166

                        refany: state_ref.clone(),

929

166

                        callback: CoreCallback {

930

166

                            cb: default_on_focus_received as usize,

931

166

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

932

166

},

933

166

},

934

166

                    CoreCallbackData {

935

166

                        event: EventFilter::Focus(FocusEventFilter::FocusLost),

936

166

                        refany: state_ref.clone(),

937

166

                        callback: CoreCallback {

938

166

                            cb: default_on_focus_lost as usize,

939

166

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

940

166

},

941

166

},

942

166

                    CoreCallbackData {

943

166

                        event: EventFilter::Focus(FocusEventFilter::TextInput),

944

166

                        refany: state_ref.clone(),

945

166

                        callback: CoreCallback {

946

166

                            cb: default_on_text_input as usize,

947

166

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

948

166

},

949

166

},

950

166

                    CoreCallbackData {

951

166

                        event: EventFilter::Focus(FocusEventFilter::VirtualKeyDown),

952

166

                        refany: state_ref.clone(),

953

166

                        callback: CoreCallback {

954

166

                            cb: default_on_virtual_key_down as usize,

955

166

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

956

166

},

957

166

},

958

166

                    CoreCallbackData {

959

166

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

960

166

                        refany: state_ref,

961

166

                        callback: CoreCallback {

962

166

                            cb: default_on_mouse_hover as usize,

963

166

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

964

166

},

965

166

},

966

967

166

                .into(),

968

969

166

            .with_children(

970

166

                vec![

971

166

                    Dom::create_p()

972

166

                        .with_ids_and_classes(

973

166

                            vec![Class("__azul-native-text-input-placeholder".into())].into(),

974

975

166

                        .with_css_props(placeholder_style)

976

                        // appended, never `with_attributes`: that one replaces the

977

                        // whole vector, classes included

978

166

                        .with_attribute(AttributeType::ContentEditable(false))

979

166

                        .with_children(DomVec::from_vec(vec![Dom::create_text_do_not_use_without_block_level_wrapper(placeholder)])),

980

166

                    Dom::create_p()

981

166

                        .with_ids_and_classes(

982

166

                            vec![Class("__azul-native-text-input-label".into())].into(),

983

984

166

                        .with_css_props(self.label_style)

985

166

                        .with_children(DomVec::from_vec(vec![Dom::create_text_do_not_use_without_block_level_wrapper(label_text)])),

986

987

166

                .into(),

988

989

166

990

991

992

/// `style` with the placeholder taken out of the flow: `display: none` on top

993

/// of `opacity: 0`, so a hidden prompt owns neither pixels nor an inline layout.

994

124

fn hidden_placeholder_style(

995

124

    style: &CssPropertyWithConditionsVec,

996

124

) -> CssPropertyWithConditionsVec {

997

124

    let mut props = style.as_ref().to_vec();

998

124

    props.push(CssPropertyWithConditions::simple(CssProperty::const_display(

999

124

        LayoutDisplay::None,

1000

    )));

1001

124

    props.push(CssPropertyWithConditions::simple(CssProperty::const_opacity(

1002

124

        StyleOpacity::const_new(0),

1003

    )));

1004

124

    CssPropertyWithConditionsVec::from_vec(props)

1005

124

1006

1007

/// The placeholder `<p>` and the value `<p>`, in that order.

1008

///

1009

/// Both handlers and tests resolve them through the same hierarchy hops the

1010

/// container's own layout guarantees; a subtree of any other shape yields

1011

/// `None` and every handler bails out.

1012

29

fn label_nodes(info: &CallbackInfo) -> Option<(DomNodeId, DomNodeId)> {

1013

29

    let placeholder = info.get_first_child(info.get_hit_node())?;

1014

27

    let label = info.get_next_sibling(placeholder)?;

1015

26

    Some((placeholder, label))

1016

29

1017

1018

/// Shows or hides the placeholder prompt.

1019

13

fn set_placeholder_visible(info: &mut CallbackInfo, placeholder: DomNodeId, visible: bool) {

1020

13

    let (display, opacity) = if visible {

1021

1

        (LayoutDisplay::Block, StyleOpacity::const_new(100))

1022

    } else {

1023

12

        (LayoutDisplay::None, StyleOpacity::const_new(0))

1024

};

1025

13

    info.set_css_property(placeholder, CssProperty::const_opacity(opacity));

1026

13

    info.set_css_property(placeholder, CssProperty::const_display(display));

1027

13

1028

1029

/// Adopts the engine's text for `node` into the widget's mirror.

1030

///

1031

/// The engine owns the buffer, so its answer wins — except that an empty answer

1032

/// is ambiguous: `get_text_before_textinput` also yields nothing for a node

1033

/// whose text sits under a block wrapper it does not descend into. An empty

1034

/// read therefore never clears a non-empty mirror.

1035

33

fn adopt_engine_text(state: &mut TextInputState, info: &CallbackInfo, node: DomNodeId) {

1036

33

    let Some(text) = info.get_node_text_content(node) else {

1037

        return;

1038

};

1039

33

    if text.is_empty() && !state.text.is_empty() {

1040

6

        return;

1041

27

1042

49

    state.text = text.chars().map(|c| c as u32).collect::<Vec<_>>().into();

1043

33

1044

1045

/// The engine's selection, in the widget's public shape.

1046

///

1047

/// Offsets are byte offsets into the value, matching the cursor positions the

1048

/// engine reports; a range that spans the whole buffer collapses to

1049

/// [`TextInputSelection::All`].

1050

47

fn engine_selection(

1051

47

    info: &CallbackInfo,

1052

47

    node: DomNodeId,

1053

47

    len: usize,

1054

47

) -> Option<TextInputSelection> {

1055

47

    let ranges = info.get_node_selection_ranges(node);

1056

47

    let range = *ranges.as_ref().first()?;

1057

    let dir_from = range.start.cluster_id.start_byte_in_run as usize;

1058

    let dir_to = range.end.cluster_id.start_byte_in_run as usize;

1059

    if len != 0 && dir_from == 0 && dir_to >= len {

1060

        return Some(TextInputSelection::All);

1061

1062

    Some(TextInputSelection::FromTo(TextInputSelectionRange {

1063

        dir_from,

1064

        dir_to,

1065

}))

1066

47

1067

1068

/// Mirrors the insertion the engine is about to apply.

1069

///

1070

/// The engine inserts at the caret, so the mirror does too whenever the caret

1071

/// is readable and lands on a character boundary; otherwise it appends, which

1072

/// is where the caret sits for every append-only path. `cursor_pos` stays a

1073

/// byte offset, as it has always been.

1074

23

fn mirror_insertion(state: &mut TextInputState, inserted: &str, caret: Option<usize>) {

1075

23

    let text = state.get_text();

1076

23

    let at = caret

1077

23

        .filter(|at| *at <= text.len() && text.is_char_boundary(*at))

1078

23

        .unwrap_or(text.len());

1079

1080

23

    let mut next = String::with_capacity(text.len() + inserted.len());

1081

23

    next.push_str(&text[..at]);

1082

23

    next.push_str(inserted);

1083

23

    next.push_str(&text[at..]);

1084

1085

217

    state.text = next.chars().map(|c| c as u32).collect::<Vec<_>>().into();

1086

23

    state.cursor_pos = at.saturating_add(inserted.len());

1087

23

1088

1089

/// The caret's byte offset inside the edited node, if the engine has one.

1090

15

fn engine_caret(info: &CallbackInfo, node: DomNodeId) -> Option<usize> {

1091

15

    info.get_node_cursor_position(node)

1092

15

        .map(|c| c.cluster_id.start_byte_in_run as usize)

1093

15

1094

1095

6

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

1096

6

    let Some(mut text_input) = text_input.downcast_mut::<TextInputStateWrapper>() else {

1097

1

        return Update::DoNothing;

1098

};

1099

1100

5

    let text_input = &mut *text_input;

1101

1102

5

    let Some(placeholder_text_node_id) = info.get_first_child(info.get_hit_node()) else {

1103

2

        return Update::DoNothing;

1104

};

1105

1106

3

    let container = info.get_hit_node();

1107

3

    adopt_engine_text(&mut text_input.inner, &info, container);

1108

1109

    // hide the placeholder text

1110

3

    if text_input.inner.text.is_empty() {

1111

1

        set_placeholder_visible(&mut info, placeholder_text_node_id, false);

1112

2

1113

1114

    // The engine seeds the caret at the end of the value when focus lands on a

1115

    // contenteditable host; the mirror follows it.

1116

3

    let end_of_text = text_input.inner.text.len();

1117

3

    text_input.inner.cursor_pos = engine_caret(&info, container).unwrap_or(end_of_text);

1118

1119

3

    Update::DoNothing

1120

6

1121

1122

6

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

1123

6

    let Some(mut text_input) = text_input.downcast_mut::<TextInputStateWrapper>() else {

1124

1

        return Update::DoNothing;

1125

};

1126

1127

5

    let text_input = &mut *text_input;

1128

1129

5

    let Some(placeholder_text_node_id) = info.get_first_child(info.get_hit_node()) else {

1130

1

        return Update::DoNothing;

1131

};

1132

1133

4

    let container = info.get_hit_node();

1134

4

    adopt_engine_text(&mut text_input.inner, &info, container);

1135

1136

    // show the placeholder text

1137

4

    if text_input.inner.text.is_empty() {

1138

1

        set_placeholder_visible(&mut info, placeholder_text_node_id, true);

1139

3

1140

1141

    // rustc doesn't understand the borrowing lifetime here

1142

4

    let text_input = &mut *text_input;

1143

4

    let onfocuslost = &mut text_input.on_focus_lost;

1144

4

    let inner = text_input.inner.clone();

1145

1146

4

    match onfocuslost.as_mut() {

1147

1

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

1148

1

            (callback.cb)(refany.clone(), info, inner)

1149

1150

3

        None => Update::DoNothing,

1151

1152

6

1153

1154

15

extern "C" fn default_on_text_input(text_input: RefAny, info: CallbackInfo) -> Update {

1155

15

    default_on_text_input_inner(text_input, info).unwrap_or(Update::DoNothing)

1156

15

1157

1158

17

fn default_on_text_input_inner(mut text_input: RefAny, mut info: CallbackInfo) -> Option<Update> {

1159

17

    let mut text_input = text_input.downcast_mut::<TextInputStateWrapper>()?;

1160

1161

    // The engine records the edit before the callbacks run and applies it after

1162

    // them; this handler only observes it and mirrors it into the widget state.

1163

    // An `Input` WITHOUT a pending record is a post-edit NOTIFICATION: an edit

1164

    // committed outside the record pipeline (deletion, programmatic edit) that

1165

    // is already applied — adopt it and inform the user hook; `valid` cannot

1166

    // veto what already happened.

1167

16

    let inserted_text = info

1168

16

        .get_text_changeset()

1169

16

        .map(|c| c.inserted_text.as_str().to_string())

1170

16

        .unwrap_or_default();

1171

1172

16

    let (placeholder_node_id, _label_node_id) = label_nodes(&info)?;

1173

14

    let container = info.get_hit_node();

1174

1175

14

    if inserted_text.is_empty() {

1176

        // Idempotent: a notification that changed nothing observable (a

1177

        // spurious Input, an edit already mirrored) stays a strict no-op, so

1178

        // the no-changeset pins keep holding.

1179

2

        let before = text_input.inner.get_text();

1180

2

        adopt_engine_text(&mut text_input.inner, &info, container);

1181

2

        if text_input.inner.get_text() == before {

1182

2

            return None;

1183

1184

        let len = text_input.inner.get_text().len();

1185

        text_input.inner.selection = engine_selection(&info, container, len).into();

1186

        // A field deleted to empty shows its placeholder again.

1187

        set_placeholder_visible(&mut info, placeholder_node_id, len == 0);

1188

        let result = {

1189

            let text_input = &mut *text_input;

1190

            let inner_clone = text_input.inner.clone();

1191

            match text_input.on_text_input.as_mut() {

1192

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

1193

                    (callback.cb)(refany.clone(), info, inner_clone)

1194

1195

                None => OnTextInputReturn {

1196

                    update: Update::DoNothing,

1197

                    valid: TextInputValid::Yes,

1198

},

1199

1200

};

1201

        return Some(result.update);

1202

12

1203

1204

    // A single-line field never accepts a line separator: veto insertions

1205

    // carrying one (paste with newlines; the engine's Enter line break is

1206

    // already vetoed in the key handler).

1207

12

    if inserted_text.contains('\n') {

1208

        info.prevent_default();

1209

        return Some(Update::DoNothing);

1210

12

1211

1212

12

    let caret = engine_caret(&info, container);

1213

12

    adopt_engine_text(&mut text_input.inner, &info, container);

1214

1215

12

    let result = {

1216

        // rustc doesn't understand the borrowing lifetime here

1217

12

        let text_input = &mut *text_input;

1218

12

        let ontextinput = &mut text_input.on_text_input;

1219

1220

        // inner_clone has the new text

1221

12

        let mut inner_clone = text_input.inner.clone();

1222

12

        mirror_insertion(&mut inner_clone, &inserted_text, caret);

1223

12

        let len = inner_clone.get_text().len();

1224

12

        inner_clone.selection = engine_selection(&info, container, len).into();

1225

1226

12

        match ontextinput.as_mut() {

1227

2

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

1228

2

                (callback.cb)(refany.clone(), info, inner_clone)

1229

1230

10

            None => OnTextInputReturn {

1231

10

                update: Update::DoNothing,

1232

10

                valid: TextInputValid::Yes,

1233

10

},

1234

1235

};

1236

1237

12

    if result.valid == TextInputValid::Yes {

1238

11

        // hide the placeholder text

1239

11

        set_placeholder_visible(&mut info, placeholder_node_id, false);

1240

11

1241

11

        mirror_insertion(&mut text_input.inner, &inserted_text, caret);

1242

11

        let len = text_input.inner.get_text().len();

1243

11

        text_input.inner.selection = engine_selection(&info, container, len).into();

1244

11

    } else {

1245

1

        // The engine applies the recorded changeset once the callbacks return,

1246

1

        // unless one of them vetoes it.

1247

1

        info.prevent_default();

1248

1

1249

1250

12

    Some(result.update)

1251

17

1252

1253

14

extern "C" fn default_on_virtual_key_down(text_input: RefAny, info: CallbackInfo) -> Update {

1254

14

    default_on_virtual_key_down_inner(text_input, info).unwrap_or(Update::DoNothing)

1255

14

1256

1257

15

fn default_on_virtual_key_down_inner(

1258

15

    mut text_input: RefAny,

1259

15

    mut info: CallbackInfo,

1260

15

) -> Option<Update> {

1261

15

    let mut text_input = text_input.downcast_mut::<TextInputStateWrapper>()?;

1262

14

    let keyboard_state = info.get_current_keyboard_state();

1263

1264

14

    let keycode = keyboard_state.current_virtual_keycode.into_option()?;

1265

13

    let (_placeholder_node_id, _label_node_id) = label_nodes(&info)?;

1266

1267

12

    let container = info.get_hit_node();

1268

12

    adopt_engine_text(&mut text_input.inner, &info, container);

1269

1270

    // Editing keys (Backspace, Delete, the arrows, Enter) are the engine's

1271

    // default actions; this handler only forwards the key to the user's hook

1272

    // and lets a rejection stop the default from running.

1273

12

    let result = {

1274

        // rustc doesn't understand the borrowing lifetime here

1275

12

        let text_input = &mut *text_input;

1276

12

        let mut inner_clone = text_input.inner.clone();

1277

12

        let len = inner_clone.get_text().len();

1278

12

        inner_clone.selection = engine_selection(&info, container, len).into();

1279

12

        match text_input.on_virtual_key_down.as_mut() {

1280

5

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

1281

5

                (callback.cb)(refany.clone(), info, inner_clone)

1282

1283

7

            None => OnTextInputReturn {

1284

7

                update: Update::DoNothing,

1285

7

                valid: TextInputValid::Yes,

1286

7

},

1287

1288

};

1289

1290

12

    let len = text_input.inner.get_text().len();

1291

12

    text_input.inner.selection = engine_selection(&info, container, len).into();

1292

1293

12

    if result.valid == TextInputValid::No {

1294

1

        info.prevent_default();

1295

11

1296

1297

    // Single-line field: Enter must never edit the value. The engine-side

1298

    // default in this host (white-space:pre) is a literal "\n" insert, so it

1299

    // is vetoed here; activation semantics stay with the user's hook above.

1300

11

    if matches!(

1301

12

        keycode,

1302

        azul_core::window::VirtualKeyCode::Return | azul_core::window::VirtualKeyCode::NumpadEnter

1303

1

) {

1304

1

        info.prevent_default();

1305

11

1306

1307

12

    Some(result.update)

1308

15

1309

1310

2

extern "C" fn default_on_mouse_hover(mut text_input: RefAny, _info: CallbackInfo) -> Update {

1311

2

    let Some(_text_input) = text_input.downcast_mut::<TextInputStateWrapper>() else {

1312

1

        return Update::DoNothing;

1313

};

1314

1315

1

    Update::DoNothing

1316

2

1317

1318

#[cfg(all(test, feature = "std"))]

1319

#[allow(clippy::too_many_lines, clippy::float_cmp)]

1320

mod autotest_generated {

1321

    use std::{

1322

        collections::{BTreeMap, HashMap},

1323

        sync::{Arc, Mutex},

1324

};

1325

1326

    use azul_core::{

1327

        dom::{

1328

            AttributeType, DomId, DomNodeId, EventFilter, FocusEventFilter, HoverEventFilter,

1329

            IdOrClass, NodeId, NodeType, TabIndex,

1330

},

1331

        geom::{LogicalRect, OptionLogicalPosition},

1332

        gl::OptionGlContextPtr,

1333

        hit_test::ScrollPosition,

1334

        refany::OptionRefAny,

1335

        resources::RendererResources,

1336

        styled_dom::{NodeHierarchyItemId, StyledDom},

1337

        window::{MonitorVec, RawWindowHandle, VirtualKeyCode},

1338

};

1339

    use rust_fontconfig::FcFontCache;

1340

1341

    use super::*;

1342

    #[cfg(feature = "icu")]

1343

    use crate::icu::IcuLocalizerHandle;

1344

    use crate::{

1345

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

1346

        managers::text_input::PendingTextEdit,

1347

        solver3::{display_list::DisplayList, layout_tree::LayoutTree},

1348

        window::{DomLayoutResult, LayoutWindow},

1349

        window_state::FullWindowState,

1350

};

1351

1352

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

1353

    // Sample data

1354

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

1355

1356

    /// Strings the buffer has to survive a `set_text` -> `get_text` round-trip on.

1357

    /// Deliberately loaded with cases where "length" is ambiguous: the buffer counts

1358

    /// *scalars*, `str::len()` counts *bytes*, and a human counts *graphemes* — three

1359

    /// numbers that only agree for pure ASCII.

1360

    const HOSTILE: [&str; 20] = [

1361

"",

1362

        " ",

1363

        "a",

1364

        "hello world",

1365

        "\0",           // a lone NUL is a perfectly good scalar

1366

        "a\0b",         // ... and it survives in the middle of a string, too

1367

        "\u{7f}",       // largest 1-byte scalar

1368

        "\u{80}",       // smallest 2-byte scalar

1369

        "\u{7ff}",      // largest 2-byte scalar

1370

        "\u{800}",      // smallest 3-byte scalar

1371

        "\u{ffff}",     // largest 3-byte scalar (and a non-character)

1372

        "\u{10000}",    // smallest 4-byte scalar

1373

        "\u{10ffff}",   // the largest scalar that exists at all

1374

        "é",

1375

        "e\u{301}",     // e + COMBINING ACUTE: 2 scalars, 1 grapheme

1376

        "👨‍👩‍👧‍👦", // ZWJ family: 7 scalars, 1 grapheme, 25 bytes

1377

        "日本語",

1378

        "مرحبا",        // RTL

1379

        "\u{200b}",     // zero-width space: invisible, but still one scalar

1380

        "\r\n\t",

1381

];

1382

1383

    /// `u32` code units that are **not** Unicode scalars, so `char::from_u32` rejects

1384

    /// every one of them. The buffer is a `U32Vec`, so nothing stops them from being

1385

    /// in there — `get_text` is the only thing standing between them and a `String`.

1386

    const NON_SCALAR_UNITS: [u32; 6] = [

1387

        0xD800,      // leading surrogate

1388

        0xDC00,      // trailing surrogate

1389

        0xDFFF,      // last surrogate

1390

        0x0011_0000, // one past the last scalar

1391

        0xFFFF_FFFE,

1392

        u32::MAX,

1393

];

1394

1395

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

1396

    // Widget fixtures

1397

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

1398

1399

    /// A `TextInput` whose buffer holds *raw* code units — the only way to build a

1400

    /// state that `set_text` could never produce (it goes through `char`).

1401

    fn input_with_units(units: &[u32]) -> TextInput {

1402

        let mut input = TextInput::create();

1403

        input.text_input_state.inner.text = units.to_vec().into();

1404

        input

1405

1406

1407

    /// Renders `input` and hands back both the flattened DOM *and* the very `RefAny`

1408

    /// the widget registered on its own handlers. Driving the handlers with these two

1409

    /// is the real wiring: nothing is rebuilt by hand, so a mismatch between what

1410

    /// `dom()` stores and what the handlers expect cannot hide behind the fixture.

1411

    fn rendered(input: TextInput) -> (StyledDom, RefAny) {

1412

        let dom = input.dom();

1413

        let state = dom.root.callbacks.as_ref()[0].refany.clone();

1414

        (StyledDom::create_from_dom(dom), state)

1415

1416

1417

    /// The `TextInputState` currently sitting behind a widget-state payload.

1418

    fn state_of(state: &RefAny) -> TextInputState {

1419

        let mut state = state.clone();

1420

        let wrapper = state

1421

            .downcast_ref::<TextInputStateWrapper>()

1422

            .expect("the widget state must still be a TextInputStateWrapper");

1423

        wrapper.inner.clone()

1424

1425

1426

    /// Reaches into the live widget state — used to plant a cursor position that

1427

    /// `dom()` would otherwise have already normalised away.

1428

    fn poke(state: &RefAny, f: impl FnOnce(&mut TextInputStateWrapper)) {

1429

        let mut state = state.clone();

1430

        let mut wrapper = state

1431

            .downcast_mut::<TextInputStateWrapper>()

1432

            .expect("the widget state must still be a TextInputStateWrapper");

1433

        f(&mut wrapper);

1434

1435

1436

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

1437

    // Recording hooks

1438

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

1439

1440

    /// A user payload that records every state it is handed and answers with a

1441

    /// canned verdict. It arrives as the `refany` argument — a *shared* clone of

1442

    /// what the test still holds — so the test reads back exactly what the widget

1443

    /// passed, with no global state involved.

1444

    struct Recorder {

1445

        seen: Vec<TextInputState>,

1446

        update: Update,

1447

        valid: TextInputValid,

1448

1449

1450

    fn recorder(update: Update, valid: TextInputValid) -> RefAny {

1451

        RefAny::new(Recorder {

1452

            seen: Vec::new(),

1453

            update,

1454

            valid,

1455

})

1456

1457

1458

    fn recorded(probe: &RefAny) -> Vec<TextInputState> {

1459

        let mut probe = probe.clone();

1460

        let log = probe

1461

            .downcast_ref::<Recorder>()

1462

            .expect("the user payload must still be a Recorder");

1463

        log.seen.clone()

1464

1465

1466

    extern "C" fn record_text_input(

1467

        mut data: RefAny,

1468

        _: CallbackInfo,

1469

        state: TextInputState,

1470

    ) -> OnTextInputReturn {

1471

        let Some(mut log) = data.downcast_mut::<Recorder>() else {

1472

            return OnTextInputReturn {

1473

                update: Update::DoNothing,

1474

                valid: TextInputValid::Yes,

1475

};

1476

};

1477

        log.seen.push(state);

1478

        OnTextInputReturn {

1479

            update: log.update,

1480

            valid: log.valid,

1481

1482

1483

1484

    // Deliberately *not* the same body as `record_text_input`: two hooks with

1485

    // byte-identical bodies can be folded onto a single symbol by the linker, and

1486

    // the two slots have to stay distinguishable by function pointer.

1487

    extern "C" fn record_virtual_key(

1488

        mut data: RefAny,

1489

        _: CallbackInfo,

1490

        state: TextInputState,

1491

    ) -> OnTextInputReturn {

1492

        match data.downcast_mut::<Recorder>() {

1493

            Some(mut log) => {

1494

                let answer = OnTextInputReturn {

1495

                    update: log.update,

1496

                    valid: log.valid,

1497

};

1498

                log.seen.push(state);

1499

                answer

1500

1501

            None => OnTextInputReturn {

1502

                update: Update::RefreshDom,

1503

                valid: TextInputValid::No,

1504

},

1505

1506

1507

1508

    extern "C" fn record_focus_lost(

1509

        mut data: RefAny,

1510

        _: CallbackInfo,

1511

        state: TextInputState,

1512

    ) -> Update {

1513

        data.downcast_mut::<Recorder>().map_or(Update::RefreshDom, |mut log| {

1514

            log.seen.push(state);

1515

            log.update

1516

})

1517

1518

1519

    /// A `Callback`-shaped (2-argument) function — the shape FFI bindings hand in,

1520

    /// which the `From<Callback>` arm *transmutes* into the 3-argument widget slot.

1521

    /// Never invoked; only its address is ever compared.

1522

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

1523

        Update::DoNothing

1524

1525

1526

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

1527

    // CallbackInfo harness

1528

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

1529

1530

    /// The container is always the flattened root of `TextInput::dom()`.

1531

    const CONTAINER: usize = 0;

1532

1533

    fn dom_node(idx: usize) -> DomNodeId {

1534

        DomNodeId {

1535

            dom: DomId::ROOT_ID,

1536

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

1537

1538

1539

1540

    /// A `DomNodeId` whose node component is `None` — the "nothing concrete was hit"

1541

    /// case. `CallbackInfo::set_css_property` *panics* on such an id, so every

1542

    /// handler has to bail out before it ever gets there.

1543

    fn node_none() -> DomNodeId {

1544

        DomNodeId {

1545

            dom: DomId::ROOT_ID,

1546

            node: NodeHierarchyItemId::NONE,

1547

1548

1549

1550

    fn inner_id(node: DomNodeId) -> NodeId {

1551

        node.node

1552

            .into_crate_internal()

1553

            .expect("expected a concrete node id")

1554

1555

1556

    /// A `DomLayoutResult` carrying only a `styled_dom`: the text-input handlers

1557

    /// reach only `get_hit_node` / `get_first_child` / `get_next_sibling`, all of

1558

    /// which read the node hierarchy alone — no real layout (and no font) needed.

1559

    fn layout_result(styled_dom: StyledDom) -> DomLayoutResult {

1560

        DomLayoutResult {

1561

            styled_dom,

1562

            layout_tree: LayoutTree {

1563

                nodes: Vec::new(),

1564

                warm: Vec::new(),

1565

                cold: Vec::new(),

1566

                root: 0,

1567

                dom_to_layout: BTreeMap::new(),

1568

                children_arena: Vec::new(),

1569

                children_offsets: Vec::new(),

1570

                subtree_needs_intrinsic: Vec::new(),

1571

},

1572

            calculated_positions: Vec::new(),

1573

            viewport: LogicalRect::zero(),

1574

            display_list: Arc::new(DisplayList::default()),

1575

            scroll_ids: HashMap::new(),

1576

            scroll_id_to_node_id: HashMap::new(),

1577

1578

1579

1580

    /// Everything a default handler can read out of the window.

1581

    struct Env {

1582

        styled_dom: StyledDom,

1583

        hit: DomNodeId,

1584

        keycode: Option<VirtualKeyCode>,

1585

        changeset: Option<PendingTextEdit>,

1586

1587

1588

    impl Env {

1589

        fn new(styled_dom: StyledDom) -> Self {

1590

            Self {

1591

                styled_dom,

1592

                hit: dom_node(CONTAINER),

1593

                keycode: None,

1594

                changeset: None,

1595

1596

1597

1598

        fn hit(mut self, hit: DomNodeId) -> Self {

1599

            self.hit = hit;

1600

            self

1601

1602

1603

        fn key(mut self, keycode: VirtualKeyCode) -> Self {

1604

            self.keycode = Some(keycode);

1605

            self

1606

1607

1608

        fn insert(mut self, text: &str) -> Self {

1609

            self.changeset = Some(PendingTextEdit {

1610

                node: dom_node(CONTAINER),

1611

                inserted_text: text.into(),

1612

                old_text: AzString::from(""),

1613

});

1614

            self

1615

1616

1617

1618

    /// The container's two `<p>` children plus the value's bare text leaf,

1619

    /// resolved through the *same* API the handlers use — so no test has to

1620

    /// hard-code a flattened index.

1621

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

1622

    struct Nodes {

1623

        placeholder: Option<DomNodeId>,

1624

        label: Option<DomNodeId>,

1625

        label_text: Option<DomNodeId>,

1626

1627

1628

    /// Runs `f` with a real `CallbackInfo` over a window holding `env.styled_dom` as

1629

    /// the root DOM. Returns `f`'s value, every change the handler pushed onto the

1630

    /// transaction log, and the resolved child node ids.

1631

    fn run<R>(env: Env, f: impl FnOnce(CallbackInfo) -> R) -> (R, Vec<CallbackChange>, Nodes) {

1632

        let mut layout_window =

1633

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

1634

        layout_window

1635

            .layout_results

1636

            .insert(DomId::ROOT_ID, layout_result(env.styled_dom));

1637

        if let Some(changeset) = env.changeset {

1638

            layout_window.text_input_manager.set_changeset(changeset);

1639

1640

        let layout_window = layout_window;

1641

1642

        let renderer_resources = RendererResources::default();

1643

        let previous_window_state: Option<FullWindowState> = None;

1644

        let mut current_window_state = FullWindowState::default();

1645

        current_window_state.keyboard_state.current_virtual_keycode = env.keycode.into();

1646

        let gl_context = OptionGlContextPtr::None;

1647

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

1648

            BTreeMap::new();

1649

        let window_handle = RawWindowHandle::Unsupported;

1650

        let system_callbacks = ExternalSystemCallbacks::rust_internal();

1651

1652

        let ref_data = CallbackInfoRefData {

1653

            layout_window: &layout_window,

1654

            renderer_resources: &renderer_resources,

1655

            previous_window_state: &previous_window_state,

1656

            current_window_state: &current_window_state,

1657

            gl_context: &gl_context,

1658

            current_scroll_manager: &scroll_states,

1659

            current_window_handle: &window_handle,

1660

            system_callbacks: &system_callbacks,

1661

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

1662

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

1663

            #[cfg(feature = "icu")]

1664

            icu_localizer: IcuLocalizerHandle::default(),

1665

            ctx: OptionRefAny::None,

1666

};

1667

1668

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

1669

1670

        let probe = CallbackInfo::new(

1671

            &ref_data,

1672

            &changes,

1673

            dom_node(CONTAINER),

1674

            OptionLogicalPosition::None,

1675

            OptionLogicalPosition::None,

1676

);

1677

        let placeholder = probe.get_first_child(dom_node(CONTAINER));

1678

        let label = placeholder.and_then(|p| probe.get_next_sibling(p));

1679

        let label_text = label.and_then(|l| probe.get_first_child(l));

1680

        let nodes = Nodes {

1681

            placeholder,

1682

            label,

1683

            label_text,

1684

};

1685

1686

        let info = CallbackInfo::new(

1687

            &ref_data,

1688

            &changes,

1689

            env.hit,

1690

            OptionLogicalPosition::None,

1691

            OptionLogicalPosition::None,

1692

);

1693

1694

        let r = f(info);

1695

        let pushed = info.take_changes();

1696

        (r, pushed, nodes)

1697

1698

1699

    /// Every `(node, opacity)` pair pushed onto the transaction log, in push order.

1700

    fn pushed_opacities(changes: &[CallbackChange]) -> Vec<(NodeId, f32)> {

1701

        changes

1702

            .iter()

1703

            .filter_map(|c| match c {

1704

                CallbackChange::ChangeNodeCssProperties {

1705

                    node_id, properties, ..

1706

                } => {

1707

                    let o = properties.as_ref().iter().find_map(|p| match p {

1708

                        CssProperty::Opacity(o) => o.get_property().map(|o| o.inner.normalized()),

1709

                        _ => None,

1710

                    })?;

1711

                    Some((*node_id, o))

1712

1713

                _ => None,

1714

})

1715

            .collect()

1716

1717

1718

    /// Every `(node, text)` repaint pushed onto the transaction log, in push order.

1719

    fn pushed_texts(changes: &[CallbackChange]) -> Vec<(DomNodeId, String)> {

1720

        changes

1721

            .iter()

1722

            .filter_map(|c| match c {

1723

                CallbackChange::ChangeNodeText { node_id, text } => {

1724

                    Some((*node_id, text.as_str().to_string()))

1725

1726

                _ => None,

1727

})

1728

            .collect()

1729

1730

1731

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

1732

    // DOM probes

1733

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

1734

1735

    /// Flattened child indices of `TextInput::dom()`.

1736

    const PLACEHOLDER_CHILD: usize = 0;

1737

    const LABEL_CHILD: usize = 1;

1738

1739

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

1740

        node.root

1741

            .get_ids_and_classes()

1742

            .as_ref()

1743

            .iter()

1744

            .filter_map(|c| match c {

1745

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

1746

                IdOrClass::Id(_) => None,

1747

})

1748

            .collect()

1749

1750

1751

    /// The text a `<p>` label wraps, looking through the block wrapper the

1752

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

1753

    fn text_of(node: &Dom) -> String {

1754

        assert!(

1755

            matches!(node.root.get_node_type(), NodeType::P),

1756

            "widget text must be wrapped in a <p> block"

1757

);

1758

        match node.children.as_ref() {

1759

            [only] => only

1760

                .root

1761

                .get_node_type()

1762

                .format()

1763

                .expect("expected a bare text leaf"),

1764

            other => panic!("a label <p> wraps exactly one text node, found {}", other.len()),

1765

1766

1767

1768

    /// Every `NodeType::Text` node in `node`'s subtree that is not a bare leaf

1769

    /// under a `<p>`: css props, callbacks, a tab index, a dataset or children

1770

    /// on a text node are all inert, because a text node owns no rect.

1771

    fn text_nodes_carrying_state(node: &Dom, parent_is_p: bool, bad: &mut Vec<String>) {

1772

        if let NodeType::Text(t) = node.root.get_node_type() {

1773

            let carries = !node.root.get_style().is_empty()

1774

                || !node.root.get_callbacks().as_ref().is_empty()

1775

                || node.root.get_tab_index().is_some()

1776

                || node.root.get_dataset().is_some()

1777

                || !node.children.as_ref().is_empty()

1778

                || !parent_is_p;

1779

            if carries {

1780

                bad.push(t.as_ref().as_str().to_string());

1781

1782

1783

        let is_p = matches!(node.root.get_node_type(), NodeType::P);

1784

        for c in node.children.as_ref() {

1785

            text_nodes_carrying_state(c, is_p, bad);

1786

1787

1788

1789

    fn dataset_state(dom: &Dom) -> TextInputState {

1790

        let mut dataset = dom

1791

            .root

1792

            .get_dataset()

1793

            .cloned()

1794

            .expect("TextInput::dom must attach its state as the container's dataset");

1795

        let wrapper = dataset

1796

            .downcast_ref::<TextInputStateWrapper>()

1797

            .expect("the dataset must be a TextInputStateWrapper");

1798

        wrapper.inner.clone()

1799

1800

1801

    /// `n` properties lifted off the default container style — an easy way to mint

1802

    /// pairwise-distinct style vectors without hard-coding any CSS.

1803

    fn style(n: usize) -> CssPropertyWithConditionsVec {

1804

        let all: Vec<CssPropertyWithConditions> =

1805

            TextInput::default().container_style.as_ref().to_vec();

1806

        assert!(n <= all.len(), "not enough default properties to slice");

1807

        CssPropertyWithConditionsVec::from_vec(all.into_iter().take(n).collect())

1808

1809

1810

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

1811

    // TextInputState::get_text

1812

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

1813

1814

    #[test]

1815

    fn get_text_on_a_default_state_is_the_empty_string() {

1816

        let state = TextInputState::default();

1817

        assert_eq!(state.get_text(), "");

1818

        assert!(state.text.is_empty());

1819

        assert_eq!(state.cursor_pos, 0);

1820

        assert!(state.placeholder.is_none());

1821

        assert!(state.selection.is_none());

1822

1823

1824

    #[test]

1825

    fn get_text_round_trips_every_hostile_string() {

1826

        // The buffer stores one `u32` per scalar, so the round-trip must be exact for

1827

        // anything `chars()` can produce — combining marks, ZWJ sequences, embedded

1828

        // NULs and the very last scalar included.

1829

        for s in HOSTILE {

1830

            let input = TextInput::create().with_text(s.into());

1831

            assert_eq!(

1832

                input.text_input_state.inner.get_text(),

1833

s,

1834

                "the buffer did not round-trip {s:?}",

1835

);

1836

1837

1838

1839

    #[test]

1840

    fn get_text_silently_drops_code_units_that_are_not_unicode_scalars() {

1841

        // `get_text` is a `filter_map(char::from_u32)`: junk in the buffer is skipped,

1842

        // not escaped and not panicked on. Pin that, because "skip" is the difference

1843

        // between a lossy read and a crash on FFI-provided buffers.

1844

        for unit in NON_SCALAR_UNITS {

1845

            let state = TextInputState {

1846

                text: vec![u32::from('A'), unit, u32::from('B')].into(),

1847

                ..TextInputState::default()

1848

};

1849

            assert_eq!(

1850

                state.get_text(),

1851

                "AB",

1852

                "code unit {unit:#x} was not dropped from the rendered text",

1853

);

1854

            assert_eq!(

1855

                state.text.len(),

1856

3,

1857

                "get_text must not mutate the buffer it reads",

1858

);

1859

1860

1861

1862

    #[test]

1863

    fn get_text_on_a_buffer_of_nothing_but_junk_is_empty_and_does_not_panic() {

1864

        let state = TextInputState {

1865

            text: NON_SCALAR_UNITS.to_vec().into(),

1866

            ..TextInputState::default()

1867

};

1868

        assert_eq!(state.get_text(), "");

1869

        assert_eq!(state.text.len(), NON_SCALAR_UNITS.len());

1870

1871

1872

    #[test]

1873

    fn get_text_never_yields_more_chars_than_the_buffer_holds() {

1874

        // The one invariant that holds for *any* buffer contents: filtering can only

1875

        // ever shrink. A `get_text` that grew would mean the buffer and the rendered

1876

        // label disagree about how far the cursor can travel.

1877

        let mut units: Vec<u32> = Vec::new();

1878

        for (i, unit) in NON_SCALAR_UNITS.iter().enumerate() {

1879

            units.push(u32::from('x'));

1880

            units.push(*unit);

1881

            units.push(0x1F600 + i as u32);

1882

1883

        let state = TextInputState {

1884

            text: units.clone().into(),

1885

            ..TextInputState::default()

1886

};

1887

        let rendered = state.get_text();

1888

        assert!(

1889

            rendered.chars().count() <= state.text.len(),

1890

            "get_text produced {} chars from a {}-unit buffer",

1891

            rendered.chars().count(),

1892

            state.text.len(),

1893

);

1894

        assert_eq!(rendered.chars().count(), units.len() - NON_SCALAR_UNITS.len());

1895

1896

1897

    #[test]

1898

    fn get_text_is_pure() {

1899

        let state = TextInputState {

1900

            text: vec![u32::from('a'), 0xD800, u32::from('b')].into(),

1901

            ..TextInputState::default()

1902

};

1903

        let before = state.clone();

1904

        assert_eq!(state.get_text(), state.get_text());

1905

        assert_eq!(state, before, "get_text mutated the state it was given");

1906

1907

1908

    #[test]

1909

    fn get_text_on_a_very_large_buffer_does_not_panic() {

1910

        let n = 50_000;

1911

        let state = TextInputState {

1912

            text: core::iter::repeat_n(u32::from('ß'), n).collect::<Vec<_>>().into(),

1913

            ..TextInputState::default()

1914

};

1915

        let text = state.get_text();

1916

        assert_eq!(text.chars().count(), n);

1917

        // 'ß' is two bytes: byte length and scalar count are *not* the same number.

1918

        assert_eq!(text.len(), n * 2);

1919

1920

1921

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

1922

    // TextInput::set_text / with_text

1923

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

1924

1925

    #[test]

1926

    fn with_text_is_exactly_set_text() {

1927

        for s in HOSTILE {

1928

            let mut a = TextInput::create();

1929

            a.set_text(s.into());

1930

            let b = TextInput::create().with_text(s.into());

1931

            assert_eq!(a, b, "with_text and set_text disagree on {s:?}");

1932

1933

1934

1935

    #[test]

1936

    fn set_text_stores_one_code_unit_per_scalar_not_per_byte() {

1937

        // The classic off-by-UTF-8 bug: storing `s.len()` units for a string whose

1938

        // scalar count is smaller. Every non-ASCII entry in the table has a byte

1939

        // length strictly greater than its scalar count.

1940

        for s in HOSTILE {

1941

            let input = TextInput::create().with_text(s.into());

1942

            assert_eq!(

1943

                input.text_input_state.inner.text.len(),

1944

                s.chars().count(),

1945

                "the buffer length for {s:?} is not the scalar count",

1946

);

1947

1948

1949

        let family = "👨‍👩‍👧‍👦";

1950

        let input = TextInput::create().with_text(family.into());

1951

        assert_eq!(input.text_input_state.inner.text.len(), 7);

1952

        assert_eq!(family.len(), 25, "the ZWJ family is 25 bytes, not 7");

1953

1954

1955

    #[test]

1956

    fn set_text_stores_the_scalar_values_verbatim() {

1957

        let input = TextInput::create().with_text("aé\u{10ffff}".into());

1958

        assert_eq!(

1959

            input.text_input_state.inner.text.as_slice(),

1960

            &[0x61, 0xE9, 0x0010_FFFF],

1961

);

1962

1963

1964

    #[test]

1965

    fn set_text_replaces_rather_than_appends() {

1966

        let mut input = TextInput::create();

1967

        input.set_text("first".into());

1968

        input.set_text("second".into());

1969

        assert_eq!(input.text_input_state.inner.get_text(), "second");

1970

        assert_eq!(input.text_input_state.inner.text.len(), 6);

1971

1972

1973

    #[test]

1974

    fn set_text_with_an_empty_string_clears_the_buffer() {

1975

        let mut input = TextInput::create().with_text("something".into());

1976

        input.set_text("".into());

1977

        assert!(input.text_input_state.inner.text.is_empty());

1978

        assert_eq!(input.text_input_state.inner.get_text(), "");

1979

        assert_eq!(input, TextInput::create(), "clearing did not restore a fresh widget");

1980

1981

1982

    #[test]

1983

    fn set_text_does_not_enforce_max_len() {

1984

        // KNOWN GAP: `max_len` defaults to 50 and is never read anywhere in this

1985

        // module — not by `set_text`, not by the text-input handler. A 200-char

1986

        // assignment is stored whole. Pinned so that adding enforcement later shows

1987

        // up as a deliberate change rather than a silent one.

1988

        let long: String = "x".repeat(200);

1989

        let input = TextInput::create().with_text(long.clone().into());

1990

        assert_eq!(input.text_input_state.inner.max_len, 50);

1991

        assert_eq!(input.text_input_state.inner.text.len(), 200);

1992

        assert_eq!(input.text_input_state.inner.get_text(), long);

1993

1994

1995

    #[test]

1996

    fn set_text_leaves_the_cursor_where_it_was() {

1997

        // `set_text` writes the buffer and nothing else: the cursor is only

1998

        // reconciled by `dom()` / the focus handler. A widget built with text but

1999

        // never rendered therefore reports a cursor of 0 over a non-empty buffer.

2000

        let input = TextInput::create().with_text("hello".into());

2001

        assert_eq!(input.text_input_state.inner.cursor_pos, 0);

2002

        assert_eq!(input.text_input_state.inner.text.len(), 5);

2003

2004

2005

    #[test]

2006

    fn set_text_touches_nothing_but_the_buffer() {

2007

        let mut input = TextInput::create()

2008

            .with_placeholder("type here".into())

2009

            .with_placeholder_style(style(3));

2010

        let before = input.clone();

2011

        input.set_text("abc".into());

2012

2013

        assert_eq!(

2014

            input.text_input_state.inner.placeholder.as_ref().map(|s| s.as_str().to_string()),

2015

            Some("type here".to_string()),

2016

);

2017

        assert_eq!(input.placeholder_style, before.placeholder_style);

2018

        assert_eq!(input.container_style, before.container_style);

2019

        assert_eq!(input.label_style, before.label_style);

2020

        assert_eq!(input.text_input_state.inner.max_len, before.text_input_state.inner.max_len);

2021

        assert!(input.text_input_state.inner.selection.is_none());

2022

2023

2024

    #[test]

2025

    fn with_text_on_a_very_large_string_does_not_panic() {

2026

        let n = 50_000;

2027

        let long: String = "a".repeat(n);

2028

        let input = TextInput::create().with_text(long.into());

2029

        assert_eq!(input.text_input_state.inner.text.len(), n);

2030

2031

2032

    #[test]

2033

    fn set_text_is_idempotent() {

2034

        for s in HOSTILE {

2035

            let mut input = TextInput::create();

2036

            input.set_text(s.into());

2037

            let once = input.clone();

2038

            input.set_text(s.into());

2039

            assert_eq!(input, once, "re-assigning {s:?} changed the widget");

2040

2041

2042

2043

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

2044

    // TextInput::set_placeholder / with_placeholder

2045

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

2046

2047

    #[test]

2048

    fn placeholder_is_absent_on_a_fresh_widget() {

2049

        assert!(TextInput::create().text_input_state.inner.placeholder.is_none());

2050

2051

2052

    #[test]

2053

    fn with_placeholder_is_exactly_set_placeholder_and_stores_the_string_verbatim() {

2054

        for s in HOSTILE {

2055

            let mut a = TextInput::create();

2056

            a.set_placeholder(s.into());

2057

            let b = TextInput::create().with_placeholder(s.into());

2058

            assert_eq!(a, b, "with_placeholder and set_placeholder disagree on {s:?}");

2059

2060

            assert_eq!(

2061

                a.text_input_state.inner.placeholder.as_ref().map(|p| p.as_str()),

2062

                Some(s),

2063

                "the placeholder {s:?} was not stored byte-for-byte",

2064

);

2065

2066

2067

2068

    #[test]

2069

    fn set_placeholder_overwrites_a_previous_placeholder_and_never_clears_it() {

2070

        let mut input = TextInput::create();

2071

        input.set_placeholder("first".into());

2072

        input.set_placeholder("".into());

2073

        // An empty placeholder is still *a* placeholder, not the absence of one.

2074

        assert_eq!(

2075

            input.text_input_state.inner.placeholder.as_ref().map(|p| p.as_str()),

2076

            Some(""),

2077

);

2078

2079

2080

    #[test]

2081

    fn set_placeholder_does_not_touch_the_text_buffer() {

2082

        let mut input = TextInput::create().with_text("abc".into());

2083

        input.set_placeholder("hint".into());

2084

        assert_eq!(input.text_input_state.inner.get_text(), "abc");

2085

2086

2087

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

2088

    // Style setters

2089

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

2090

2091

    #[test]

2092

    fn each_style_setter_writes_exactly_one_slot() {

2093

        let marker = style(1);

2094

2095

        let mut a = TextInput::create();

2096

        a.set_placeholder_style(marker.clone());

2097

        assert_eq!(a.placeholder_style, marker);

2098

        assert_eq!(a.container_style, TextInput::create().container_style);

2099

        assert_eq!(a.label_style, TextInput::create().label_style);

2100

2101

        let mut b = TextInput::create();

2102

        b.set_container_style(marker.clone());

2103

        assert_eq!(b.container_style, marker);

2104

        assert_eq!(b.placeholder_style, TextInput::create().placeholder_style);

2105

        assert_eq!(b.label_style, TextInput::create().label_style);

2106

2107

        let mut c = TextInput::create();

2108

        c.set_label_style(marker.clone());

2109

        assert_eq!(c.label_style, marker);

2110

        assert_eq!(c.placeholder_style, TextInput::create().placeholder_style);

2111

        assert_eq!(c.container_style, TextInput::create().container_style);

2112

2113

2114

    #[test]

2115

    fn the_with_style_builders_are_exactly_their_setters() {

2116

        let s = style(2);

2117

2118

        let mut a = TextInput::create();

2119

        a.set_placeholder_style(s.clone());

2120

        assert_eq!(a, TextInput::create().with_placeholder_style(s.clone()));

2121

2122

        let mut b = TextInput::create();

2123

        b.set_container_style(s.clone());

2124

        assert_eq!(b, TextInput::create().with_container_style(s.clone()));

2125

2126

        let mut c = TextInput::create();

2127

        c.set_label_style(s.clone());

2128

        assert_eq!(c, TextInput::create().with_label_style(s));

2129

2130

2131

    #[test]

2132

    fn style_setters_accept_an_empty_vector_and_survive_rendering() {

2133

        let empty = CssPropertyWithConditionsVec::from_vec(Vec::new());

2134

        let input = TextInput::create()

2135

            .with_placeholder_style(empty.clone())

2136

            .with_container_style(empty.clone())

2137

            .with_label_style(empty.clone());

2138

        assert!(input.container_style.is_empty());

2139

2140

        // Stripping every declared property must not stop the widget from rendering.

2141

        let dom = input.dom();

2142

        assert_eq!(dom.children.as_ref().len(), 2);

2143

2144

2145

    #[test]

2146

    fn style_setters_overwrite_rather_than_merge() {

2147

        let mut input = TextInput::create();

2148

        input.set_container_style(style(4));

2149

        input.set_container_style(style(1));

2150

        assert_eq!(input.container_style.len(), 1);

2151

2152

2153

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

2154

    // Callback setters

2155

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

2156

2157

    #[test]

2158

    fn set_on_text_input_stores_the_fn_pointer_and_the_payload_verbatim() {

2159

        let mut input = TextInput::create();

2160

        input.set_on_text_input(

2161

            RefAny::new(0xDEAD_BEEF_u32),

2162

            record_text_input as TextInputOnTextInputCallbackType,

2163

);

2164

2165

        let slot = input

2166

            .text_input_state

2167

            .on_text_input

2168

            .as_ref()

2169

            .expect("set_on_text_input stored nothing");

2170

        assert_eq!(

2171

            slot.callback.cb as *const () as usize,

2172

            record_text_input as TextInputOnTextInputCallbackType as *const () as usize,

2173

            "the fn pointer was mangled on the way in",

2174

);

2175

2176

        let mut payload = slot.refany.clone();

2177

        assert_eq!(

2178

            *payload.downcast_ref::<u32>().expect("the payload changed type"),

2179

            0xDEAD_BEEF,

2180

);

2181

        assert!(

2182

            payload.downcast_ref::<u64>().is_none(),

2183

            "the payload must not be readable as a differently-typed value",

2184

);

2185

2186

2187

    #[test]

2188

    fn set_on_virtual_key_down_and_set_on_focus_lost_store_their_own_slots() {

2189

        let mut input = TextInput::create();

2190

        input.set_on_virtual_key_down(

2191

            RefAny::new(1_u8),

2192

            record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

2193

);

2194

        input.set_on_focus_lost(

2195

            RefAny::new(2_u8),

2196

            record_focus_lost as TextInputOnFocusLostCallbackType,

2197

);

2198

2199

        assert!(

2200

            input.text_input_state.on_text_input.as_ref().is_none(),

2201

            "the text-input slot was filled in by an unrelated setter",

2202

);

2203

        assert_eq!(

2204

            input

2205

                .text_input_state

2206

                .on_virtual_key_down

2207

                .as_ref()

2208

                .expect("the virtual-key slot is empty")

2209

                .callback

2210

                .cb as *const () as usize,

2211

            record_virtual_key as TextInputOnVirtualKeyDownCallbackType as *const () as usize,

2212

);

2213

        assert_eq!(

2214

            input

2215

                .text_input_state

2216

                .on_focus_lost

2217

                .as_ref()

2218

                .expect("the focus-lost slot is empty")

2219

                .callback

2220

                .cb as *const () as usize,

2221

            record_focus_lost as TextInputOnFocusLostCallbackType as *const () as usize,

2222

);

2223

2224

2225

    #[test]

2226

    fn the_with_callback_builders_are_exactly_their_setters() {

2227

        let payload = RefAny::new(7_u16);

2228

2229

        let mut a = TextInput::create();

2230

        a.set_on_text_input(payload.clone(), record_text_input as TextInputOnTextInputCallbackType);

2231

        assert_eq!(

2232

a,

2233

            TextInput::create().with_on_text_input(

2234

                payload.clone(),

2235

                record_text_input as TextInputOnTextInputCallbackType,

2236

),

2237

);

2238

2239

        let mut b = TextInput::create();

2240

        b.set_on_virtual_key_down(

2241

            payload.clone(),

2242

            record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

2243

);

2244

        assert_eq!(

2245

b,

2246

            TextInput::create().with_on_virtual_key_down(

2247

                payload.clone(),

2248

                record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

2249

),

2250

);

2251

2252

        let mut c = TextInput::create();

2253

        c.set_on_focus_lost(payload.clone(), record_focus_lost as TextInputOnFocusLostCallbackType);

2254

        assert_eq!(

2255

c,

2256

            TextInput::create()

2257

                .with_on_focus_lost(payload, record_focus_lost as TextInputOnFocusLostCallbackType),

2258

);

2259

2260

2261

    #[test]

2262

    fn setting_a_callback_twice_replaces_it_rather_than_stacking() {

2263

        let mut input = TextInput::create();

2264

        input.set_on_text_input(

2265

            RefAny::new(1_u8),

2266

            record_text_input as TextInputOnTextInputCallbackType,

2267

);

2268

        input.set_on_text_input(

2269

            RefAny::new(2_u8),

2270

            record_virtual_key as TextInputOnTextInputCallbackType,

2271

);

2272

2273

        let slot = input.text_input_state.on_text_input.as_ref().expect("slot is empty");

2274

        assert_eq!(

2275

            slot.callback.cb as *const () as usize,

2276

            record_virtual_key as TextInputOnTextInputCallbackType as *const () as usize,

2277

            "the second assignment did not win",

2278

);

2279

        let mut payload = slot.refany.clone();

2280

        assert_eq!(*payload.downcast_ref::<u8>().expect("wrong payload type"), 2);

2281

2282

2283

    #[test]

2284

    fn a_generic_two_argument_callback_is_accepted_through_the_ffi_conversion() {

2285

        // FFI bindings hand in a `Callback` (2 args) which the `From<Callback>` arm

2286

        // transmutes into the 3-argument widget slot. It must survive being stored

2287

        // and read back — only the *address* is meaningful, so that is all we check.

2288

        let generic = Callback {

2289

            cb: generic_shaped,

2290

            ctx: OptionRefAny::None,

2291

};

2292

        let input = TextInput::create().with_on_text_input(RefAny::new(0_u8), generic);

2293

        assert_eq!(

2294

            input

2295

                .text_input_state

2296

                .on_text_input

2297

                .as_ref()

2298

                .expect("the transmuted callback was dropped")

2299

                .callback

2300

                .cb as *const () as usize,

2301

            generic_shaped as *const () as usize,

2302

);

2303

2304

2305

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

2306

    // TextInput::create / swap_with_default

2307

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

2308

2309

    #[test]

2310

    fn create_is_default_and_is_pure() {

2311

        assert_eq!(TextInput::create(), TextInput::default());

2312

        assert_eq!(TextInput::create(), TextInput::create());

2313

2314

2315

    #[test]

2316

    fn create_starts_empty_with_no_hooks_and_no_running_animation() {

2317

        let input = TextInput::create();

2318

        assert!(input.text_input_state.inner.text.is_empty());

2319

        assert!(input.text_input_state.inner.placeholder.is_none());

2320

        assert!(input.text_input_state.inner.selection.is_none());

2321

        assert_eq!(input.text_input_state.inner.cursor_pos, 0);

2322

        assert_eq!(input.text_input_state.inner.max_len, 50);

2323

        assert!(input.text_input_state.on_text_input.as_ref().is_none());

2324

        assert!(input.text_input_state.on_virtual_key_down.as_ref().is_none());

2325

        assert!(input.text_input_state.on_focus_lost.as_ref().is_none());

2326

        assert!(input.text_input_state.cursor_animation.is_none());

2327

        assert!(input.text_input_state.update_text_input_before_calling_focus_lost_fn);

2328

        assert!(input.text_input_state.update_text_input_before_calling_vk_down_fn);

2329

        assert!(!input.container_style.is_empty());

2330

2331

2332

    #[test]

2333

    fn swap_with_default_returns_the_old_widget_and_leaves_a_fresh_one_behind() {

2334

        let mut input = TextInput::create()

2335

            .with_text("typed".into())

2336

            .with_placeholder("hint".into());

2337

        let old = input.swap_with_default();

2338

2339

        assert_eq!(old.text_input_state.inner.get_text(), "typed");

2340

        assert_eq!(input, TextInput::create(), "what was left behind is not a fresh widget");

2341

2342

2343

    #[test]

2344

    fn swapping_twice_round_trips_the_original_widget() {

2345

        let mut a = TextInput::create().with_text("abc".into());

2346

        let mut b = a.swap_with_default(); // a = default, b = "abc"

2347

        let c = b.swap_with_default(); // b = default, c = "abc"

2348

2349

        assert_eq!(c, TextInput::create().with_text("abc".into()));

2350

        assert_eq!(a, TextInput::create());

2351

        assert_eq!(b, TextInput::create());

2352

2353

2354

    #[test]

2355

    fn swap_with_default_moves_the_hooks_out_rather_than_copying_them() {

2356

        let probe = recorder(Update::DoNothing, TextInputValid::Yes);

2357

        let mut input = TextInput::create().with_on_text_input(

2358

            probe.clone(),

2359

            record_text_input as TextInputOnTextInputCallbackType,

2360

);

2361

2362

        let old = input.swap_with_default();

2363

2364

        assert!(

2365

            old.text_input_state.on_text_input.as_ref().is_some(),

2366

            "the hook vanished during the swap",

2367

);

2368

        // A duplicated hook would fire twice, and a duplicated RefAny would

2369

        // double-free its payload.

2370

        assert!(

2371

            input.text_input_state.on_text_input.as_ref().is_none(),

2372

            "the hook was copied instead of moved",

2373

);

2374

        // The payload is still alive and still typed after the move (a double-freed

2375

        // RefAny would not survive the downcast inside `recorded`).

2376

        assert!(recorded(&probe).is_empty(), "the hook fired during a swap");

2377

2378

2379

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

2380

    // TextInput::dom

2381

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

2382

2383

    #[test]

2384

    fn dom_builds_a_container_with_a_placeholder_block_and_a_value_block() {

2385

        let dom = TextInput::create().dom();

2386

2387

        assert_eq!(classes(&dom), vec!["__azul-native-text-input-container"]);

2388

        assert_eq!(dom.children.as_ref().len(), 2);

2389

2390

        let placeholder = &dom.children.as_ref()[PLACEHOLDER_CHILD];

2391

        let label = &dom.children.as_ref()[LABEL_CHILD];

2392

        assert_eq!(classes(placeholder), vec!["__azul-native-text-input-placeholder"]);

2393

        assert_eq!(classes(label), vec!["__azul-native-text-input-label"]);

2394

2395

        for block in [placeholder, label] {

2396

            assert!(matches!(block.root.get_node_type(), NodeType::P));

2397

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

2398

            assert!(matches!(

2399

                block.children.as_ref()[0].root.get_node_type(),

2400

                NodeType::Text(_),

2401

));

2402

2403

2404

2405

    #[test]

2406

    fn dom_emits_no_cursor_node() {

2407

        // The caret and the selection are display-list items driven by the

2408

        // engine's TextEditManager; a widget-owned cursor div resolved against

2409

        // the container and never tracked the caret.

2410

        fn walk(node: &Dom, out: &mut Vec<String>) {

2411

            out.extend(classes(node));

2412

            for c in node.children.as_ref() {

2413

                walk(c, out);

2414

2415

2416

        let mut all = Vec::new();

2417

        walk(&TextInput::create().with_text("typed".into()).dom(), &mut all);

2418

        assert!(

2419

            !all.iter().any(|c| c.contains("cursor")),

2420

            "the widget still emits a cursor node: {all:?}",

2421

);

2422

2423

2424

    #[test]

2425

    fn dom_carries_no_state_on_any_text_node() {

2426

        // A NodeType::Text node is unconditionally inline-level and owns no

2427

        // rect, so css props / callbacks / a tab index / a dataset / children on

2428

        // one are all inert. Every text node must be a bare leaf under a <p>.

2429

        for input in [

2430

            TextInput::create(),

2431

            TextInput::create().with_text("typed".into()).with_placeholder("hint".into()),

2432

] {

2433

            let mut bad = Vec::new();

2434

            text_nodes_carrying_state(&input.dom(), false, &mut bad);

2435

            assert!(bad.is_empty(), "text nodes carrying inert state: {bad:?}");

2436

2437

2438

2439

    #[test]

2440

    fn dom_marks_the_container_as_keyboard_focusable_and_editable() {

2441

        // Focus events do not bubble and the engine records an edit against the

2442

        // FOCUSED node, so the tab index and the contenteditable flag have to

2443

        // sit on the same node the handlers are attached to.

2444

        let dom = TextInput::create().dom();

2445

        assert_eq!(dom.root.get_tab_index(), Some(TabIndex::Auto));

2446

        assert!(dom.root.is_contenteditable());

2447

2448

2449

    #[test]

2450

    fn dom_keeps_the_placeholder_out_of_the_editable_content() {

2451

        // Everything inside a contenteditable host is editable content unless a

2452

        // node blocks the inheritance walk; the prompt must never be typed into.

2453

        let dom = TextInput::create().with_placeholder("hint".into()).dom();

2454

        let placeholder = &dom.children.as_ref()[PLACEHOLDER_CHILD];

2455

        assert!(

2456

            placeholder

2457

                .root

2458

                .attributes()

2459

                .as_ref()

2460

                .iter()

2461

                .any(|a| matches!(a, AttributeType::ContentEditable(false))),

2462

            "the placeholder is inside the editable host and does not opt out",

2463

);

2464

        assert!(!dom.children.as_ref()[LABEL_CHILD]

2465

            .root

2466

            .attributes()

2467

            .as_ref()

2468

            .iter()

2469

            .any(|a| matches!(a, AttributeType::ContentEditable(_))));

2470

2471

2472

    #[test]

2473

    fn dom_hides_the_placeholder_when_the_buffer_is_not_empty() {

2474

        let hidden = TextInput::create().with_text("typed".into()).dom();

2475

        let shown = TextInput::create().dom();

2476

2477

        let display = |node: &Dom| -> Option<CssProperty> {

2478

            node.root

2479

                .style

2480

                .iter_inline_properties()

2481

                .map(|(p, _)| p.clone())

2482

                .filter(|p| matches!(p, CssProperty::Display(_)))

2483

                .last()

2484

};

2485

2486

        assert_eq!(

2487

            display(&hidden.children.as_ref()[PLACEHOLDER_CHILD]),

2488

            Some(CssProperty::const_display(LayoutDisplay::None)),

2489

);

2490

        assert_ne!(

2491

            display(&shown.children.as_ref()[PLACEHOLDER_CHILD]),

2492

            Some(CssProperty::const_display(LayoutDisplay::None)),

2493

);

2494

2495

2496

    #[test]

2497

    fn dom_registers_exactly_the_five_default_handlers_over_one_shared_state() {

2498

        let dom = TextInput::create().dom();

2499

        let callbacks = dom.root.callbacks.as_ref();

2500

2501

        let events: Vec<EventFilter> = callbacks.iter().map(|c| c.event).collect();

2502

        assert_eq!(

2503

            events,

2504

            vec![

2505

                EventFilter::Focus(FocusEventFilter::FocusReceived),

2506

                EventFilter::Focus(FocusEventFilter::FocusLost),

2507

                EventFilter::Focus(FocusEventFilter::TextInput),

2508

                EventFilter::Focus(FocusEventFilter::VirtualKeyDown),

2509

                EventFilter::Hover(HoverEventFilter::MouseOver),

2510

],

2511

);

2512

2513

        let targets: Vec<usize> = callbacks.iter().map(|c| c.callback.cb).collect();

2514

        assert_eq!(

2515

            targets,

2516

            vec![

2517

                default_on_focus_received as usize,

2518

                default_on_focus_lost as usize,

2519

                default_on_text_input as usize,

2520

                default_on_virtual_key_down as usize,

2521

                default_on_mouse_hover as usize,

2522

],

2523

            "the handlers are wired to the wrong events",

2524

);

2525

2526

        // All five handlers plus the dataset must share ONE state; separate copies

2527

        // would let the focus handler and the text handler drift apart.

2528

        for c in callbacks {

2529

            assert_eq!(c.refany, callbacks[0].refany, "a handler got its own state copy");

2530

2531

        assert_eq!(

2532

            dom.root.get_dataset().expect("no dataset attached"),

2533

            &callbacks[0].refany,

2534

);

2535

2536

2537

    #[test]

2538

    fn dom_renders_the_buffer_into_the_label_and_the_placeholder_into_its_own_node() {

2539

        let dom = TextInput::create()

2540

            .with_text("typed".into())

2541

            .with_placeholder("hint".into())

2542

            .dom();

2543

2544

        assert_eq!(text_of(&dom.children.as_ref()[PLACEHOLDER_CHILD]), "hint");

2545

        assert_eq!(text_of(&dom.children.as_ref()[LABEL_CHILD]), "typed");

2546

2547

2548

    #[test]

2549

    fn dom_without_a_placeholder_still_renders_an_empty_placeholder_node() {

2550

        // The handlers navigate `container -> first child -> next sibling`; dropping

2551

        // the placeholder node when unset would make the label unreachable.

2552

        let dom = TextInput::create().with_text("typed".into()).dom();

2553

        assert_eq!(dom.children.as_ref().len(), 2);

2554

        assert_eq!(text_of(&dom.children.as_ref()[PLACEHOLDER_CHILD]), "");

2555

2556

2557

    #[test]

2558

    fn dom_passes_hostile_text_and_placeholder_through_unchanged() {

2559

        for s in HOSTILE {

2560

            let dom = TextInput::create()

2561

                .with_text(s.into())

2562

                .with_placeholder(s.into())

2563

                .dom();

2564

            assert_eq!(text_of(&dom.children.as_ref()[LABEL_CHILD]), s, "label mangled {s:?}");

2565

            assert_eq!(

2566

                text_of(&dom.children.as_ref()[PLACEHOLDER_CHILD]),

2567

s,

2568

                "placeholder mangled {s:?}",

2569

);

2570

2571

2572

2573

    #[test]

2574

    fn dom_syncs_the_cursor_to_the_end_of_the_buffer() {

2575

        for s in HOSTILE {

2576

            let dom = TextInput::create().with_text(s.into()).dom();

2577

            assert_eq!(

2578

                dataset_state(&dom).cursor_pos,

2579

                s.chars().count(),

2580

                "the cursor was not parked at the end of {s:?}",

2581

);

2582

2583

2584

2585

    #[test]

2586

    fn dom_measures_the_cursor_in_code_units_which_can_outrun_the_rendered_text() {

2587

        // KNOWN GAP: `dom()` sets `cursor_pos = text.len()` (code units), while the

2588

        // label only renders the units that are valid scalars. A buffer holding junk

2589

        // therefore ends up with a cursor past the end of what is on screen.

2590

        let dom = input_with_units(&[u32::from('a'), 0xD800, u32::from('b')]).dom();

2591

        assert_eq!(dataset_state(&dom).cursor_pos, 3);

2592

        assert_eq!(text_of(&dom.children.as_ref()[LABEL_CHILD]), "ab");

2593

2594

2595

    #[test]

2596

    fn dom_on_a_very_large_buffer_does_not_panic() {

2597

        let n = 50_000;

2598

        let long: String = "x".repeat(n);

2599

        let dom = TextInput::create().with_text(long.into()).dom();

2600

        assert_eq!(text_of(&dom.children.as_ref()[LABEL_CHILD]).len(), n);

2601

        assert_eq!(dataset_state(&dom).cursor_pos, n);

2602

2603

2604

    #[test]

2605

    fn dom_keeps_the_configured_styles_on_the_nodes_they_were_set_for() {

2606

        let placeholder_style = style(1);

2607

        let label_style = style(2);

2608

        let container_style = style(3);

2609

        let dom = TextInput::create()

2610

            .with_placeholder_style(placeholder_style.clone())

2611

            .with_label_style(label_style.clone())

2612

            .with_container_style(container_style.clone())

2613

            .dom();

2614

2615

        let inline = |node: &Dom| -> Vec<CssProperty> {

2616

            node.root.style.iter_inline_properties().map(|(p, _)| p.clone()).collect()

2617

};

2618

        let declared = |v: &CssPropertyWithConditionsVec| -> Vec<CssProperty> {

2619

            v.as_ref().iter().map(|p| p.property.clone()).collect()

2620

};

2621

2622

        assert_eq!(inline(&dom), declared(&container_style));

2623

        assert_eq!(

2624

            inline(&dom.children.as_ref()[PLACEHOLDER_CHILD]),

2625

            declared(&placeholder_style),

2626

);

2627

        assert_eq!(inline(&dom.children.as_ref()[LABEL_CHILD]), declared(&label_style));

2628

2629

2630

    #[test]

2631

    fn the_rendered_tree_flattens_to_the_shape_the_handlers_navigate() {

2632

        let (styled_dom, _) = rendered(TextInput::create());

2633

        let ((), _, nodes) = run(Env::new(styled_dom), |_| ());

2634

2635

        let placeholder = nodes.placeholder.expect("the container has no first child");

2636

        let label = nodes.label.expect("the placeholder has no next sibling");

2637

        let label_text = nodes.label_text.expect("the value block has no text leaf");

2638

2639

        assert_ne!(placeholder, label);

2640

        assert_ne!(label, label_text);

2641

        assert_ne!(placeholder, label_text);

2642

        assert_ne!(placeholder, dom_node(CONTAINER));

2643

2644

2645

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

2646

    // default_on_focus_received

2647

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

2648

2649

    #[test]

2650

    fn focus_received_with_a_foreign_payload_is_an_inert_no_op() {

2651

        let (styled_dom, _) = rendered(TextInput::create());

2652

        let foreign = RefAny::new(0xDEAD_BEEF_u32);

2653

        let (update, changes, _) = run(Env::new(styled_dom), |info| {

2654

            default_on_focus_received(foreign.clone(), info)

2655

});

2656

        assert_eq!(update, Update::DoNothing);

2657

        assert!(changes.is_empty(), "a foreign payload still produced {changes:?}");

2658

2659

2660

    #[test]

2661

    fn focus_received_on_a_node_with_no_children_bails_out_before_touching_css() {

2662

        // `set_css_property` panics on a `None` node id, and the widget only has a

2663

        // placeholder to hide if the hit node actually has children. Both escapes have

2664

        // to happen before the css write.

2665

        let (styled_dom, state) = rendered(TextInput::create());

2666

        let (update, changes, nodes) = run(Env::new(styled_dom).hit(node_none()), |info| {

2667

            default_on_focus_received(state.clone(), info)

2668

});

2669

        assert_eq!(update, Update::DoNothing);

2670

        assert!(changes.is_empty());

2671

        assert!(nodes.placeholder.is_some(), "the fixture itself is malformed");

2672

2673

2674

    #[test]

2675

    fn focus_received_on_the_value_text_leaf_is_a_no_op() {

2676

        // The bare text leaf is the one node in the tree with no children.

2677

        let (probe_dom, _) = rendered(TextInput::create());

2678

        let (_, _, nodes) = run(Env::new(probe_dom), |_| ());

2679

        let leaf = nodes.label_text.expect("no value text leaf");

2680

2681

        let (styled_dom, state) = rendered(TextInput::create());

2682

        let (update, changes, _) = run(Env::new(styled_dom).hit(leaf), |info| {

2683

            default_on_focus_received(state.clone(), info)

2684

});

2685

        assert_eq!(update, Update::DoNothing);

2686

        assert!(changes.is_empty(), "a childless hit node still pushed {changes:?}");

2687

2688

2689

    #[test]

2690

    fn focus_received_hides_the_placeholder_only_while_the_buffer_is_empty() {

2691

        let (styled_dom, state) = rendered(TextInput::create());

2692

        let (update, changes, nodes) = run(Env::new(styled_dom), |info| {

2693

            default_on_focus_received(state.clone(), info)

2694

});

2695

        assert_eq!(update, Update::DoNothing);

2696

        assert_eq!(

2697

            pushed_opacities(&changes),

2698

            vec![(inner_id(nodes.placeholder.expect("no placeholder")), 0.0)],

2699

            "focusing an empty input did not hide its placeholder",

2700

);

2701

2702

        let (styled_dom, state) = rendered(TextInput::create().with_text("typed".into()));

2703

        let (update, changes, _) = run(Env::new(styled_dom), |info| {

2704

            default_on_focus_received(state.clone(), info)

2705

});

2706

        assert_eq!(update, Update::DoNothing);

2707

        assert!(

2708

            changes.is_empty(),

2709

            "focusing a non-empty input touched the placeholder anyway: {changes:?}",

2710

);

2711

2712

2713

    #[test]

2714

    fn focus_received_reparks_the_cursor_at_the_end_of_the_buffer() {

2715

        let (styled_dom, state) = rendered(TextInput::create().with_text("hello".into()));

2716

        // Plant a cursor that is both stale and out of range.

2717

        poke(&state, |w| w.inner.cursor_pos = usize::MAX);

2718

2719

        let (_, _, _) = run(Env::new(styled_dom), |info| {

2720

            default_on_focus_received(state.clone(), info)

2721

});

2722

        assert_eq!(state_of(&state).cursor_pos, 5);

2723

2724

2725

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

2726

    // default_on_focus_lost

2727

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

2728

2729

    #[test]

2730

    fn focus_lost_shows_the_placeholder_only_while_the_buffer_is_empty() {

2731

        let (styled_dom, state) = rendered(TextInput::create());

2732

        let (update, changes, nodes) =

2733

            run(Env::new(styled_dom), |info| default_on_focus_lost(state.clone(), info));

2734

        assert_eq!(update, Update::DoNothing);

2735

        assert_eq!(

2736

            pushed_opacities(&changes),

2737

            vec![(inner_id(nodes.placeholder.expect("no placeholder")), 1.0)],

2738

            "blurring an empty input did not bring its placeholder back",

2739

);

2740

2741

        let (styled_dom, state) = rendered(TextInput::create().with_text("typed".into()));

2742

        let (_, changes, _) =

2743

            run(Env::new(styled_dom), |info| default_on_focus_lost(state.clone(), info));

2744

        assert!(

2745

            changes.is_empty(),

2746

            "blurring a non-empty input revealed the placeholder over the text: {changes:?}",

2747

);

2748

2749

2750

    #[test]

2751

    fn focus_lost_hands_the_hook_the_live_state_and_returns_its_verdict() {

2752

        let probe = recorder(Update::RefreshDomAllWindows, TextInputValid::Yes);

2753

        let (styled_dom, state) = rendered(

2754

            TextInput::create()

2755

                .with_text("typed".into())

2756

                .with_on_focus_lost(probe.clone(), record_focus_lost as TextInputOnFocusLostCallbackType),

2757

);

2758

2759

        let (update, _, _) =

2760

            run(Env::new(styled_dom), |info| default_on_focus_lost(state.clone(), info));

2761

2762

        assert_eq!(update, Update::RefreshDomAllWindows, "the hook's Update was swallowed");

2763

        let seen = recorded(&probe);

2764

        assert_eq!(seen.len(), 1, "the hook fired {} times, expected once", seen.len());

2765

        assert_eq!(seen[0].get_text(), "typed");

2766

        assert_eq!(seen[0].cursor_pos, 5, "the hook saw a cursor that dom() should have synced");

2767

2768

2769

    #[test]

2770

    fn focus_lost_without_a_hook_reports_no_work_to_do() {

2771

        let (styled_dom, state) = rendered(TextInput::create().with_text("typed".into()));

2772

        let (update, _, _) =

2773

            run(Env::new(styled_dom), |info| default_on_focus_lost(state.clone(), info));

2774

        assert_eq!(update, Update::DoNothing);

2775

2776

2777

    #[test]

2778

    fn focus_lost_on_a_none_hit_node_skips_the_hook_entirely() {

2779

        // The early return sits *above* the hook dispatch, so a blur that cannot find

2780

        // its placeholder never reaches user code. Worth pinning: a user hook that

2781

        // commits a form would otherwise fire on a malformed hit.

2782

        let probe = recorder(Update::RefreshDom, TextInputValid::Yes);

2783

        let (styled_dom, state) = rendered(TextInput::create().with_on_focus_lost(

2784

            probe.clone(),

2785

            record_focus_lost as TextInputOnFocusLostCallbackType,

2786

));

2787

2788

        let (update, changes, _) = run(Env::new(styled_dom).hit(node_none()), |info| {

2789

            default_on_focus_lost(state.clone(), info)

2790

});

2791

2792

        assert_eq!(update, Update::DoNothing);

2793

        assert!(changes.is_empty());

2794

        assert!(recorded(&probe).is_empty(), "the hook fired on a hit node that does not exist");

2795

2796

2797

    #[test]

2798

    fn focus_lost_with_a_foreign_payload_is_an_inert_no_op() {

2799

        let (styled_dom, _) = rendered(TextInput::create());

2800

        let foreign = RefAny::new("not a text input".to_string());

2801

        let (update, changes, _) = run(Env::new(styled_dom), |info| {

2802

            default_on_focus_lost(foreign.clone(), info)

2803

});

2804

        assert_eq!(update, Update::DoNothing);

2805

        assert!(changes.is_empty());

2806

2807

2808

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

2809

    // default_on_text_input

2810

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

2811

2812

    #[test]

2813

    fn text_input_without_a_pending_changeset_does_nothing() {

2814

        let (styled_dom, state) = rendered(TextInput::create());

2815

        let (update, changes, _) =

2816

            run(Env::new(styled_dom), |info| default_on_text_input(state.clone(), info));

2817

        assert_eq!(update, Update::DoNothing);

2818

        assert!(changes.is_empty());

2819

        assert_eq!(state_of(&state).get_text(), "");

2820

2821

2822

    #[test]

2823

    fn text_input_with_an_empty_insertion_does_nothing() {

2824

        let (styled_dom, state) = rendered(TextInput::create().with_text("abc".into()));

2825

        let (update, changes, _) = run(Env::new(styled_dom).insert(""), |info| {

2826

            default_on_text_input(state.clone(), info)

2827

});

2828

        assert_eq!(update, Update::DoNothing);

2829

        assert!(changes.is_empty(), "an empty insertion still repainted: {changes:?}");

2830

        assert_eq!(state_of(&state).get_text(), "abc");

2831

        assert_eq!(state_of(&state).cursor_pos, 3);

2832

2833

2834

    #[test]

2835

    fn text_input_mirrors_the_insertion_and_hides_the_placeholder() {

2836

        let (styled_dom, state) = rendered(TextInput::create().with_placeholder("hint".into()));

2837

        let (update, changes, nodes) = run(Env::new(styled_dom).insert("hi"), |info| {

2838

            default_on_text_input(state.clone(), info)

2839

});

2840

2841

        assert_eq!(update, Update::DoNothing, "no hook is installed, so nothing needs redrawing");

2842

        assert_eq!(state_of(&state).get_text(), "hi");

2843

        assert_eq!(state_of(&state).cursor_pos, 2);

2844

2845

        assert_eq!(

2846

            pushed_opacities(&changes),

2847

            vec![(inner_id(nodes.placeholder.expect("no placeholder")), 0.0)],

2848

);

2849

        assert!(

2850

            pushed_texts(&changes).is_empty(),

2851

            "the widget repainted the value itself; the engine owns the buffer: {changes:?}",

2852

);

2853

2854

2855

    #[test]

2856

    fn text_input_appends_to_an_existing_buffer_rather_than_replacing_it() {

2857

        let (styled_dom, state) = rendered(TextInput::create().with_text("ab".into()));

2858

        let (_, changes, _) = run(Env::new(styled_dom).insert("cd"), |info| {

2859

            default_on_text_input(state.clone(), info)

2860

});

2861

        assert_eq!(state_of(&state).get_text(), "abcd");

2862

        assert!(pushed_texts(&changes).is_empty());

2863

2864

2865

    #[test]

2866

    fn text_input_hands_the_hook_a_preview_that_already_contains_the_insertion() {

2867

        // The hook is a *validator*: it has to see the would-be result, not the state

2868

        // before the edit, or it can never reject an edit for what it produces.

2869

        let probe = recorder(Update::RefreshDom, TextInputValid::Yes);

2870

        let (styled_dom, state) = rendered(

2871

            TextInput::create()

2872

                .with_text("ab".into())

2873

                .with_on_text_input(probe.clone(), record_text_input as TextInputOnTextInputCallbackType),

2874

);

2875

2876

        let (update, _, _) = run(Env::new(styled_dom).insert("c"), |info| {

2877

            default_on_text_input(state.clone(), info)

2878

});

2879

2880

        assert_eq!(update, Update::RefreshDom, "the hook's Update was swallowed");

2881

        let seen = recorded(&probe);

2882

        assert_eq!(seen.len(), 1);

2883

        assert_eq!(seen[0].get_text(), "abc", "the hook was shown the pre-edit buffer");

2884

        assert_eq!(seen[0].cursor_pos, 3);

2885

2886

2887

    #[test]

2888

    fn text_input_rejected_by_the_hook_leaves_the_buffer_and_the_screen_untouched() {

2889

        let probe = recorder(Update::RefreshDomAllWindows, TextInputValid::No);

2890

        let (styled_dom, state) = rendered(

2891

            TextInput::create()

2892

                .with_text("ab".into())

2893

                .with_placeholder("hint".into())

2894

                .with_on_text_input(probe.clone(), record_text_input as TextInputOnTextInputCallbackType),

2895

);

2896

2897

        let (update, changes, _) = run(Env::new(styled_dom).insert("c"), |info| {

2898

            default_on_text_input(state.clone(), info)

2899

});

2900

2901

        assert_eq!(update, Update::RefreshDomAllWindows, "a rejected edit still reports its Update");

2902

        assert_eq!(state_of(&state).get_text(), "ab", "a rejected edit was applied anyway");

2903

        assert_eq!(state_of(&state).cursor_pos, 2, "a rejected edit still moved the cursor");

2904

        assert!(

2905

            changes

2906

                .iter()

2907

                .all(|c| matches!(c, CallbackChange::PreventDefault)),

2908

            "a rejected edit still repainted the widget: {changes:?}",

2909

);

2910

        assert!(

2911

            changes

2912

                .iter()

2913

                .any(|c| matches!(c, CallbackChange::PreventDefault)),

2914

            "a rejected edit did not stop the engine from applying the changeset",

2915

);

2916

2917

2918

    #[test]

2919

    fn text_input_advances_the_cursor_by_utf8_byte_length_not_by_scalar_count() {

2920

        // KNOWN GAP: the cursor is advanced by `inserted_text.len()` — the *byte*

2921

        // length of the insertion — while the buffer grows by one unit per scalar.

2922

        // For anything outside ASCII the two disagree, and the cursor ends up past

2923

        // the end of the buffer it indexes into.

2924

        let (styled_dom, state) = rendered(TextInput::create());

2925

        let (_, _, _) = run(Env::new(styled_dom).insert("é"), |info| {

2926

            default_on_text_input(state.clone(), info)

2927

});

2928

2929

        let after = state_of(&state);

2930

        assert_eq!(after.get_text(), "é");

2931

        assert_eq!(after.text.len(), 1, "the buffer holds one scalar");

2932

        assert_eq!(after.cursor_pos, 2, "but the cursor moved by the two UTF-8 bytes");

2933

        assert!(

2934

            after.cursor_pos > after.text.len(),

2935

            "the cursor is expected to overshoot here; see the KNOWN GAP above",

2936

);

2937

2938

2939

    #[test]

2940

    fn text_input_recomputes_the_cursor_rather_than_accumulating_a_stale_one() {

2941

        // The cursor is derived from the insertion point every time, so a stale

2942

        // value planted by a host cannot survive — nor overflow.

2943

        let (styled_dom, state) = rendered(TextInput::create());

2944

        poke(&state, |w| w.inner.cursor_pos = usize::MAX);

2945

2946

        let (update, _, _) = run(Env::new(styled_dom).insert("abc"), |info| {

2947

            default_on_text_input(state.clone(), info)

2948

});

2949

2950

        assert_eq!(update, Update::DoNothing);

2951

        assert_eq!(state_of(&state).cursor_pos, 3);

2952

        assert_eq!(state_of(&state).get_text(), "abc");

2953

2954

2955

    #[test]

2956

    fn text_input_accepts_astral_combining_and_multi_scalar_insertions() {

2957

        for s in ["\u{10ffff}", "e\u{301}", "👨‍👩‍👧‍👦", "日本語", "\0"] {

2958

            let (styled_dom, state) = rendered(TextInput::create());

2959

            let (_, changes, _) = run(Env::new(styled_dom).insert(s), |info| {

2960

                default_on_text_input(state.clone(), info)

2961

});

2962

            assert_eq!(state_of(&state).get_text(), s, "the buffer mangled {s:?}");

2963

            assert_eq!(state_of(&state).text.len(), s.chars().count());

2964

            assert!(pushed_texts(&changes).is_empty());

2965

2966

2967

2968

    #[test]

2969

    fn text_input_on_a_wrong_shaped_subtree_changes_nothing() {

2970

        // Hitting the label means `first child -> next sibling` walks off the end of

2971

        // the tree. The handler has to give up *before* mutating the buffer, or the

2972

        // model and the screen would silently diverge.

2973

        let (probe_dom, _) = rendered(TextInput::create());

2974

        let (_, _, nodes) = run(Env::new(probe_dom), |_| ());

2975

        let label = nodes.label.expect("no label");

2976

2977

        let (styled_dom, state) = rendered(TextInput::create().with_text("ab".into()));

2978

        let (result, changes, _) = run(Env::new(styled_dom).hit(label).insert("c"), |info| {

2979

            default_on_text_input_inner(state.clone(), info)

2980

});

2981

2982

        assert_eq!(result, None, "the handler claimed to have handled a malformed tree");

2983

        assert!(changes.is_empty());

2984

        assert_eq!(state_of(&state).get_text(), "ab", "the buffer changed anyway");

2985

2986

2987

    #[test]

2988

    fn text_input_on_a_none_hit_node_changes_nothing() {

2989

        let (styled_dom, state) = rendered(TextInput::create().with_text("ab".into()));

2990

        let (update, changes, _) = run(Env::new(styled_dom).hit(node_none()).insert("c"), |info| {

2991

            default_on_text_input(state.clone(), info)

2992

});

2993

        assert_eq!(update, Update::DoNothing);

2994

        assert!(changes.is_empty());

2995

        assert_eq!(state_of(&state).get_text(), "ab");

2996

2997

2998

    #[test]

2999

    fn text_input_with_a_foreign_payload_is_an_inert_no_op() {

3000

        let (styled_dom, _) = rendered(TextInput::create());

3001

        let foreign = RefAny::new(0_u8);

3002

        let (result, changes, _) = run(Env::new(styled_dom).insert("a"), |info| {

3003

            default_on_text_input_inner(foreign.clone(), info)

3004

});

3005

        assert_eq!(result, None);

3006

        assert!(changes.is_empty());

3007

3008

3009

    #[test]

3010

    fn text_input_ignores_max_len() {

3011

        // KNOWN GAP (same root cause as `set_text_does_not_enforce_max_len`): typing

3012

        // past `max_len` is accepted, one changeset at a time.

3013

        let (styled_dom, state) = rendered(TextInput::create());

3014

        let filler: String = "x".repeat(80);

3015

        let (_, _, _) = run(Env::new(styled_dom).insert(&filler), |info| {

3016

            default_on_text_input(state.clone(), info)

3017

});

3018

        let after = state_of(&state);

3019

        assert_eq!(after.max_len, 50);

3020

        assert_eq!(after.text.len(), 80);

3021

3022

3023

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

3024

    // default_on_virtual_key_down

3025

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

3026

3027

    #[test]

3028

    fn virtual_key_down_without_a_pressed_key_does_nothing() {

3029

        let probe = recorder(Update::RefreshDom, TextInputValid::Yes);

3030

        let (styled_dom, state) = rendered(

3031

            TextInput::create().with_text("ab".into()).with_on_virtual_key_down(

3032

                probe.clone(),

3033

                record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

3034

),

3035

);

3036

3037

        let (update, changes, _) = run(Env::new(styled_dom), |info| {

3038

            default_on_virtual_key_down(state.clone(), info)

3039

});

3040

3041

        assert_eq!(update, Update::DoNothing);

3042

        assert!(changes.is_empty());

3043

        assert!(recorded(&probe).is_empty(), "the hook fired without a key being down");

3044

        assert_eq!(state_of(&state).get_text(), "ab");

3045

3046

3047

    #[test]

3048

    fn backspace_is_the_engines_default_action_not_the_widgets() {

3049

        // Deletion is `SystemChange::ApplySelectionOp` on the engine side; a

3050

        // widget that also popped its own buffer would double-delete.

3051

        let (styled_dom, state) = rendered(TextInput::create().with_text("abc".into()));

3052

        let (update, changes, _) =

3053

            run(Env::new(styled_dom).key(VirtualKeyCode::Back), |info| {

3054

                default_on_virtual_key_down(state.clone(), info)

3055

});

3056

3057

        assert_eq!(update, Update::DoNothing);

3058

        assert!(changes.is_empty(), "backspace still mutated the DOM: {changes:?}");

3059

        assert_eq!(state_of(&state).get_text(), "abc", "the widget deleted behind the engine");

3060

3061

3062

    #[test]

3063

    fn every_key_reaches_the_hook_and_leaves_the_buffer_alone() {

3064

        for key in [VirtualKeyCode::A, VirtualKeyCode::Back, VirtualKeyCode::Return] {

3065

            let probe = recorder(Update::RefreshDom, TextInputValid::Yes);

3066

            let (styled_dom, state) = rendered(

3067

                TextInput::create().with_text("ab".into()).with_on_virtual_key_down(

3068

                    probe.clone(),

3069

                    record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

3070

),

3071

);

3072

3073

            let (update, changes, _) = run(Env::new(styled_dom).key(key), |info| {

3074

                default_on_virtual_key_down(state.clone(), info)

3075

});

3076

3077

            assert_eq!(update, Update::RefreshDom, "{key:?} swallowed the hook's Update");

3078

            if matches!(key, VirtualKeyCode::Return) {

3079

                // Single-line field: Enter must never edit the value, so the

3080

                // handler vetoes the engine's "\n" default — and nothing else.

3081

                assert_eq!(changes.len(), 1, "Return must veto exactly once: {changes:?}");

3082

                assert!(

3083

                    matches!(changes[0], CallbackChange::PreventDefault),

3084

                    "Return must veto the engine line break, and only that: {changes:?}"

3085

);

3086

            } else {

3087

                assert!(changes.is_empty(), "{key:?} repainted the value: {changes:?}");

3088

3089

            assert_eq!(state_of(&state).get_text(), "ab");

3090

            assert_eq!(recorded(&probe).len(), 1, "the hook must see {key:?} too");

3091

3092

3093

3094

    #[test]

3095

    fn a_rejecting_hook_vetoes_the_engines_default_and_keeps_its_update() {

3096

        let probe = recorder(Update::RefreshDomAllWindows, TextInputValid::No);

3097

        let (styled_dom, state) = rendered(

3098

            TextInput::create().with_text("abc".into()).with_on_virtual_key_down(

3099

                probe.clone(),

3100

                record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

3101

),

3102

);

3103

3104

        let (update, changes, _) = run(Env::new(styled_dom).key(VirtualKeyCode::Back), |info| {

3105

            default_on_virtual_key_down(state.clone(), info)

3106

});

3107

3108

        assert_eq!(update, Update::RefreshDomAllWindows);

3109

        assert_eq!(

3110

            changes.len(),

3111

1,

3112

            "a veto must push nothing but the preventDefault: {changes:?}",

3113

);

3114

        assert!(matches!(changes[0], CallbackChange::PreventDefault));

3115

        assert_eq!(state_of(&state).get_text(), "abc");

3116

        assert_eq!(state_of(&state).cursor_pos, 3);

3117

3118

3119

    #[test]

3120

    fn the_virtual_key_hook_is_shown_the_state_from_before_the_key_is_handled() {

3121

        // The hook runs first so that it can veto; that means it necessarily sees

3122

        // the pre-edit buffer. Pinned because "which side of the edit does the

3123

        // hook see" is exactly the thing a refactor gets wrong.

3124

        let probe = recorder(Update::DoNothing, TextInputValid::Yes);

3125

        let (styled_dom, state) = rendered(

3126

            TextInput::create().with_text("abc".into()).with_on_virtual_key_down(

3127

                probe.clone(),

3128

                record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

3129

),

3130

);

3131

3132

        let (_, _, _) = run(Env::new(styled_dom).key(VirtualKeyCode::Back), |info| {

3133

            default_on_virtual_key_down(state.clone(), info)

3134

});

3135

3136

        let seen = recorded(&probe);

3137

        assert_eq!(seen.len(), 1);

3138

        assert_eq!(seen[0].get_text(), "abc");

3139

        assert_eq!(seen[0].cursor_pos, 3);

3140

3141

3142

    #[test]

3143

    fn virtual_key_down_on_a_none_hit_node_skips_the_hook_entirely() {

3144

        let probe = recorder(Update::RefreshDom, TextInputValid::Yes);

3145

        let (styled_dom, state) = rendered(

3146

            TextInput::create().with_text("abc".into()).with_on_virtual_key_down(

3147

                probe.clone(),

3148

                record_virtual_key as TextInputOnVirtualKeyDownCallbackType,

3149

),

3150

);

3151

3152

        let (result, changes, _) = run(

3153

            Env::new(styled_dom).hit(node_none()).key(VirtualKeyCode::Back),

3154

            |info| default_on_virtual_key_down_inner(state.clone(), info),

3155

);

3156

3157

        assert_eq!(result, None);

3158

        assert!(changes.is_empty());

3159

        assert!(recorded(&probe).is_empty(), "the hook fired on a hit node that does not exist");

3160

        assert_eq!(state_of(&state).get_text(), "abc");

3161

3162

3163

    #[test]

3164

    fn virtual_key_down_with_a_foreign_payload_is_an_inert_no_op() {

3165

        let (styled_dom, _) = rendered(TextInput::create());

3166

        let foreign = RefAny::new(vec![1_u32, 2, 3]);

3167

        let (update, changes, _) = run(Env::new(styled_dom).key(VirtualKeyCode::Back), |info| {

3168

            default_on_virtual_key_down(foreign.clone(), info)

3169

});

3170

        assert_eq!(update, Update::DoNothing);

3171

        assert!(changes.is_empty());

3172

3173

3174

    #[test]

3175

    fn repeated_key_presses_are_idempotent_on_the_widget_state() {

3176

        // Six backspaces over a three-scalar buffer: the widget must not move a

3177

        // single unit — every one of them belongs to the engine.

3178

        let (_, state) = rendered(TextInput::create().with_text("abc".into()));

3179

        for i in 0..6 {

3180

            // The tree shape does not depend on what the buffer holds, so a fresh

3181

            // container is enough to navigate; the live state is `state`.

3182

            let (styled_dom, _) = rendered(TextInput::create());

3183

            let (update, _, _) = run(Env::new(styled_dom).key(VirtualKeyCode::Back), |info| {

3184

                default_on_virtual_key_down(state.clone(), info)

3185

});

3186

            assert_eq!(update, Update::DoNothing, "backspace #{i} reported work to do");

3187

3188

        let after = state_of(&state);

3189

        assert_eq!(after.get_text(), "abc");

3190

        assert_eq!(after.cursor_pos, 3);

3191

3192

3193

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

3194

    // default_on_mouse_hover

3195

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

3196

3197

    #[test]

3198

    fn mouse_hover_is_inert_for_every_payload_and_every_hit_node() {

3199

        let (styled_dom, state) = rendered(TextInput::create().with_text("abc".into()));

3200

        let (update, changes, _) =

3201

            run(Env::new(styled_dom), |info| default_on_mouse_hover(state.clone(), info));

3202

        assert_eq!(update, Update::DoNothing);

3203

        assert!(changes.is_empty());

3204

        assert_eq!(state_of(&state).get_text(), "abc", "hovering edited the buffer");

3205

3206

        let (styled_dom, _) = rendered(TextInput::create());

3207

        let foreign = RefAny::new(0_u8);

3208

        let (update, changes, _) = run(Env::new(styled_dom).hit(node_none()), |info| {

3209

            default_on_mouse_hover(foreign.clone(), info)

3210

});

3211

        assert_eq!(update, Update::DoNothing);

3212

        assert!(changes.is_empty());

3213

3214