Grcov report - event_determination.rs

1

//! Unified Event Determination

2

//!

3

//! This module provides the single source of truth for what

4

//! events occurred in a frame. It combines window state changes

5

//! with events from all managers (scroll, text input, etc.).

6

7

use azul_core::{

8

    dom::{DomId, DomNodeId},

9

    events::{

10

        deduplicate_synthetic_events, EventData, EventProvider, EventSource, EventType,

11

        KeyModifiers, KeyboardEventData, MouseButton, MouseEventData, ScrollDeltaMode,

12

        ScrollEventData, SyntheticEvent, WindowEventData,

13

},

14

    geom::{LogicalPosition, LogicalRect},

15

    id::NodeId,

16

    styled_dom::NodeHierarchyItemId,

17

    task::{Instant, SystemTick},

18

    window::{CursorPosition, WindowPosition},

19

};

20

21

use std::collections::BTreeSet;

22

23

use crate::window_state::FullWindowState;

24

25

/// Unified event determination from all sources.

26

///

27

/// This is the **single source of truth** for what events occurred in a frame.

28

///

29

/// It combines:

30

///

31

/// 1. Window state changes (resize, move, theme, etc.)

32

/// 2. Manager-reported events (scroll, text input, focus, hover)

33

/// 3. Deduplicates by node + event type

34

///

35

/// ## Architecture

36

///

37

/// ```text

38

/// Platform Input

39

///     ↓

40

/// Update Window State + Managers (record_sample, record_input, etc.)

41

///     ↓

42

/// determine_events_from_managers() ← Query all managers (immutable)

43

///     ↓

44

/// Vec<SyntheticEvent> (deduplicated)

45

///     ↓

46

/// dispatch_events() ← Route to callbacks

47

///     ↓

48

/// Invoke callbacks

49

/// ```

50

///

51

/// ## Arguments

52

///

53

/// All arguments are **immutable** references - no state is modified here.

54

/// State changes happen earlier via `record_sample()`, `record_input()`, etc.

55

///

56

/// - `current_state` - Current window state (after platform updates)

57

/// - `previous_state` - Window state from previous frame

58

/// - `managers` - All managers that can provide events

59

/// - `timestamp` - Current time for event timestamps

60

///

61

/// ## Returns

62

///

63

/// - Vector of `SyntheticEvents`, deduplicated and ready for dispatch.

64

// Instant is a ref-counted FFI clock handle threaded through the event loop by value.

65

#[allow(clippy::needless_pass_by_value)]

66

9

pub fn determine_events_from_managers(

67

9

    current_state: &FullWindowState,

68

9

    previous_state: &FullWindowState,

69

9

    managers: &[&dyn EventProvider],

70

9

    timestamp: Instant,

71

9

) -> Vec<SyntheticEvent> {

72

9

    let mut events = Vec::new();

73

74

    // 1. Detect window state changes (simple diffing)

75

9

    events.extend(detect_window_state_events(

76

9

        current_state,

77

9

        previous_state,

78

9

        timestamp.clone(),

79

));

80

81

    // 2. Query all managers for their pending events

82

275

    for manager in managers {

83

266

        events.extend(manager.get_pending_events(timestamp.clone()));

84

266

85

86

    // 3. Deduplicate by (node, event_type)

87

9

    deduplicate_synthetic_events(events)

88

9

89

90

/// Detect window-level events by comparing states.

91

///

92

/// This is a simple sub-function that only handles window-level changes:

93

///

94

/// - Window resized

95

/// - Window moved

96

/// - Theme changed

97

/// - Mouse entered/left window

98

/// - Window focus changed

99

///

100

/// Node-level events (hover, focus, scroll, text) come from managers.

101

#[allow(clippy::cast_precision_loss)] // bounded graphics/coord/counter/fixed-point cast

102

25

fn detect_window_state_events(

103

25

    current: &FullWindowState,

104

25

    previous: &FullWindowState,

105

25

    timestamp: Instant,

106

25

) -> Vec<SyntheticEvent> {

107

25

    let mut events = Vec::new();

108

109

    // Window resized

110

25

    if current.size != previous.size {

111

6

        events.push(SyntheticEvent::new(

112

6

            EventType::WindowResize,

113

6

            EventSource::User,

114

6

            DomNodeId {

115

6

                dom: DomId { inner: 0 },

116

6

                node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::ZERO)),

117

6

},

118

6

            timestamp.clone(),

119

6

            EventData::Window(WindowEventData {

120

6

                size: Some(LogicalRect {

121

6

                    origin: LogicalPosition { x: 0.0, y: 0.0 },

122

6

                    size: current.size.dimensions,

123

6

}),

124

6

                position: None,

125

6

}),

126

6

));

127

19

128

129

    // Window moved

130

25

    if current.position != previous.position {

131

4

        let position = match current.position {

132

2

            WindowPosition::Initialized(phys_pos)

133

3

            | WindowPosition::RelativeToParentWindow(phys_pos) => Some(LogicalPosition {

134

3

                x: phys_pos.x as f32,

135

3

                y: phys_pos.y as f32,

136

3

}),

137

1

            WindowPosition::Uninitialized => None,

138

};

139

140

4

        if let Some(pos) = position {

141

3

            events.push(SyntheticEvent::new(

142

3

                EventType::WindowMove,

143

3

                EventSource::User,

144

3

                DomNodeId {

145

3

                    dom: DomId { inner: 0 },

146

3

                    node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::ZERO)),

147

3

},

148

3

                timestamp.clone(),

149

3

                EventData::Window(WindowEventData {

150

3

                    size: None,

151

3

                    position: Some(pos),

152

3

}),

153

3

));

154

3

155

21

156

157

    // Theme changed

158

25

    if current.theme != previous.theme {

159

3

        events.push(SyntheticEvent::new(

160

3

            EventType::ThemeChange,

161

3

            EventSource::User,

162

3

            DomNodeId {

163

3

                dom: DomId { inner: 0 },

164

3

                node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::ZERO)),

165

3

},

166

3

            timestamp.clone(),

167

3

            EventData::None,

168

3

));

169

22

170

171

    // Mouse entered window

172

25

    let prev_mouse_in_window = matches!(

173

25

        previous.mouse_state.cursor_position,

174

        CursorPosition::InWindow(_)

175

);

176

25

    let curr_mouse_in_window = matches!(

177

25

        current.mouse_state.cursor_position,

178

        CursorPosition::InWindow(_)

179

);

180

181

25

    if curr_mouse_in_window && !prev_mouse_in_window {

182

2

        events.push(SyntheticEvent::new(

183

2

            EventType::MouseEnter,

184

2

            EventSource::User,

185

2

            DomNodeId {

186

2

                dom: DomId { inner: 0 },

187

2

                node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::ZERO)),

188

2

},

189

2

            timestamp.clone(),

190

2

            EventData::None,

191

2

));

192

23

193

194

    // Mouse left window

195

25

    if !curr_mouse_in_window && prev_mouse_in_window {

196

1

        events.push(SyntheticEvent::new(

197

1

            EventType::MouseLeave,

198

1

            EventSource::User,

199

1

            DomNodeId {

200

1

                dom: DomId { inner: 0 },

201

1

                node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::ZERO)),

202

1

},

203

1

            timestamp,

204

1

            EventData::None,

205

1

));

206

24

207

208

25

    events

209

25

210

211

/// Get all hovered node IDs from the hover manager for a given frame.

212

///

213

/// `frame_index` 0 = current frame, 1 = previous frame, etc.

214

/// Returns a `BTreeSet` of all `NodeIds` that are hovered (the full hover chain).

215

377

fn get_all_hovered_nodes(

216

377

    hover_manager: &crate::managers::hover::HoverManager,

217

377

    frame_index: usize,

218

377

) -> BTreeSet<(DomId, NodeId)> {

219

    use crate::managers::hover::InputPointId;

220

    // MWA-C-hover: walk EVERY hit DOM, not just DomId 0 — the old

221

    // root-DOM-only read meant MouseEnter/MouseLeave never fired for nodes

222

    // inside VirtualView / iframe child DOMs.

223

377

    hover_manager

224

377

        .get_frame(&InputPointId::Mouse, frame_index)

225

377

        .map(|ht| {

226

63

            ht.hovered_nodes

227

63

                .iter()

228

63

                .flat_map(|(dom_id, hit)| {

229

62

                    hit.regular_hit_test_nodes

230

62

                        .keys()

231

132

                        .map(move |node_id| (*dom_id, *node_id))

232

62

})

233

63

                .collect()

234

63

})

235

377

        .unwrap_or_default()

236

377

237

238

/// Comprehensive event determination including mouse, keyboard, and gesture events.

239

///

240

/// This is the primary event determination function.

241

/// It generates `SyntheticEvents` for all event types including:

242

///

243

/// - Mouse button events (down/up for left/right/middle)

244

/// - Mouse movement (`MouseOver`)

245

/// - Keyboard events (VirtualKeyDown/Up)

246

/// - Window state changes (resize, move, theme, focus)

247

/// - Gesture events (`DragStart`, Drag, `DragEnd`, `DoubleClick`, `LongPress`, Swipe, Pinch, Rotate, Pen)

248

/// - File drop events (`HoveredFile`, `DroppedFile`)

249

///

250

/// ## Arguments

251

///

252

/// * `current_state` - Current window state

253

/// * `previous_state` - Previous window state

254

/// * `hover_manager` - For hover/mouse enter/leave detection

255

/// * `focus_manager` - For focus event detection

256

/// * `file_drop_manager` - For file drop detection

257

/// * `gesture_manager` - Optional gesture detection

258

/// * `managers` - Additional managers (scroll, text, etc.) that implement `EventProvider`

259

/// * `timestamp` - Current time

260

///

261

/// ## Returns

262

///

263

/// - Deduplicated vector of `SyntheticEvents` ready for dispatch

264

#[allow(clippy::cast_precision_loss)] // bounded graphics/coord/counter/fixed-point cast

265

// Instant is a ref-counted FFI clock handle threaded through the event loop by value.

266

#[allow(clippy::needless_pass_by_value)]

267

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

268

/// `EventProvider` for the window's pending STRUCTURAL edit (C11): emits one

269

/// `EventType::DocumentEdit` targeted at the changeset's node, once per

270

/// changeset id. Constructed per pass by

271

/// `LayoutWindow::document_edit_event_provider`; the dispatcher marks the

272

/// notification delivered after determination, so subsequent passes stay

273

/// silent while the same edit is pending.

274

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

275

pub struct DocumentEditEventProvider {

276

    /// (changeset target node, changeset id), if an edit is pending.

277

    pub pending: Option<(DomNodeId, u64)>,

278

    /// True once this changeset's notification has been delivered.

279

    pub already_notified: bool,

280

281

282

impl EventProvider for DocumentEditEventProvider {

283

36

    fn get_pending_events(&self, timestamp: Instant) -> Vec<SyntheticEvent> {

284

36

        match self.pending {

285

18

            Some((target, id)) if !self.already_notified => vec![SyntheticEvent::new(

286

18

                EventType::DocumentEdit,

287

18

                EventSource::User,

288

18

                target,

289

18

                timestamp,

290

18

                EventData::DocumentEdit(azul_core::events::DocumentEditEventData {

291

18

                    changeset_id: id,

292

18

}),

293

)],

294

18

            _ => Vec::new(),

295

296

36

297

298

299

182

pub fn determine_all_events(

300

182

    current_state: &FullWindowState,

301

182

    previous_state: &FullWindowState,

302

182

    hover_manager: &crate::managers::hover::HoverManager,

303

182

    focus_manager: &crate::managers::focus_cursor::FocusManager,

304

182

    file_drop_manager: &crate::managers::file_drop::FileDropManager,

305

182

    gesture_manager: Option<&crate::managers::gesture::GestureAndDragManager>,

306

182

    managers: &[&dyn EventProvider],

307

182

    wheel_delta: Option<LogicalPosition>,

308

182

    timestamp: Instant,

309

182

) -> Vec<SyntheticEvent> {

310

182

    let mut events = Vec::new();

311

312

    // Get root node for window-level events

313

182

    let root_node = DomNodeId {

314

182

        dom: DomId { inner: 0 },

315

182

        node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::ZERO)),

316

182

};

317

318

    // Helper: get cursor position

319

182

    let cursor_pos = current_state

320

182

        .mouse_state

321

182

        .cursor_position

322

182

        .get_position()

323

182

        .unwrap_or(LogicalPosition { x: 0.0, y: 0.0 });

324

325

    // Helper: build key modifiers from keyboard state

326

182

    let modifiers = KeyModifiers {

327

182

        shift: current_state.keyboard_state.shift_down(),

328

182

        ctrl: current_state.keyboard_state.ctrl_down(),

329

182

        alt: current_state.keyboard_state.alt_down(),

330

182

        meta: current_state.keyboard_state.super_down(),

331

182

};

332

333

    // Helper: compute mouse buttons bitmask

334

182

    let buttons: u8 = u8::from(current_state.mouse_state.left_down)

335

182

        | (if current_state.mouse_state.right_down { 2 } else { 0 })

336

182

        | (if current_state.mouse_state.middle_down { 4 } else { 0 });

337

338

    // Helper: get deepest hovered node as the event target for mouse events.

339

    // Multi-DOM aware: targets VirtualView / iframe child DOMs (higher DomId,

340

    // composited on top) when the cursor is over them, not just the root DOM.

341

    // For single-DOM apps only DomId 0 is ever hit, so this is unchanged.

342

182

    let mouse_target = hover_manager

343

182

        .current_hover_node_full()

344

182

        .unwrap_or(root_node);

345

346

    // Helper: build MouseEventData for a specific button

347

182

    let make_mouse_data = |button: MouseButton| -> EventData {

348

43

        EventData::Mouse(MouseEventData {

349

43

            position: cursor_pos,

350

43

            button,

351

43

            buttons,

352

43

            modifiers,

353

43

})

354

43

};

355

356

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

357

    // Mouse Button Events (with proper EventData::Mouse and per-button types)

358

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

359

360

182

    let current_mouse_down = current_state.mouse_state.mouse_down();

361

182

    let previous_mouse_down = previous_state.mouse_state.mouse_down();

362

363

546

    for (curr_down, prev_down, button) in [

364

182

365

182

            current_state.mouse_state.left_down,

366

182

            previous_state.mouse_state.left_down,

367

182

            MouseButton::Left,

368

182

),

369

182

370

182

            current_state.mouse_state.right_down,

371

182

            previous_state.mouse_state.right_down,

372

182

            MouseButton::Right,

373

182

),

374

182

375

182

            current_state.mouse_state.middle_down,

376

182

            previous_state.mouse_state.middle_down,

377

182

            MouseButton::Middle,

378

182

),

379

] {

380

546

        if curr_down && !prev_down {

381

10

            events.push(SyntheticEvent::new(

382

10

                EventType::MouseDown,

383

10

                EventSource::User,

384

10

                mouse_target,

385

10

                timestamp.clone(),

386

10

                make_mouse_data(button),

387

10

));

388

536

389

546

        if !curr_down && prev_down {

390

11

            events.push(SyntheticEvent::new(

391

11

                EventType::MouseUp,

392

11

                EventSource::User,

393

11

                mouse_target,

394

11

                timestamp.clone(),

395

11

                make_mouse_data(button),

396

11

));

397

535

398

399

400

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

401

    // Click synthesis: if left mouse released on the same node as down

402

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

403

    // Note: proper click synthesis requires tracking mousedown target across frames.

404

    // For now, if left mouse was released and the hover node hasn't changed, emit Click.

405

182

    if !current_state.mouse_state.left_down && previous_state.mouse_state.left_down {

406

9

        let prev_hover = hover_manager.previous_hover_node_full();

407

9

        let curr_hover = hover_manager.current_hover_node_full();

408

9

        if prev_hover == curr_hover && curr_hover.is_some() {

409

5

            events.push(SyntheticEvent::new(

410

5

                EventType::Click,

411

5

                EventSource::User,

412

5

                mouse_target,

413

5

                timestamp.clone(),

414

5

                make_mouse_data(MouseButton::Left),

415

5

));

416

8

417

173

418

419

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

420

    // Mouse Movement Events

421

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

422

423

182

    let current_in_window = matches!(

424

182

        current_state.mouse_state.cursor_position,

425

        CursorPosition::InWindow(_)

426

);

427

182

    let previous_in_window = matches!(

428

182

        previous_state.mouse_state.cursor_position,

429

        CursorPosition::InWindow(_)

430

);

431

432

182

    if current_in_window {

433

33

        let current_pos = current_state.mouse_state.cursor_position.get_position();

434

33

        let previous_pos = previous_state.mouse_state.cursor_position.get_position();

435

436

        // MouseOver fires on ANY mouse movement (targeted at hovered node)

437

33

        if current_pos != previous_pos {

438

9

            events.push(SyntheticEvent::new(

439

9

                EventType::MouseOver,

440

9

                EventSource::User,

441

9

                mouse_target,

442

9

                timestamp.clone(),

443

9

                make_mouse_data(MouseButton::Left), // MouseOver doesn't care about button

444

9

));

445

24

446

149

447

448

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

449

    // Touch Events  (TouchStart / TouchMove / TouchEnd)

450

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

451

//

452

    // `FullWindowState::touch_state` is what EVERY platform backend writes on a

453

    // touch — X11 `XI_TouchBegin/Update/End`, `wl_touch`, `WM_TOUCH`, UIKit,

454

    // Android `MotionEvent` — and NOTHING read it. `EventType::TouchStart` and

455

    // friends existed, `HoverEventFilter::TouchStart` was bound to real

456

    // handlers by the slider, split-pane and map widgets, and not one of them

457

    // could fire on any platform: the touch half of the event surface was

458

    // WRITE-ONLY. It is also why the headless E2E touch ops answered `ok` while

459

    // determining nothing at all.

460

//

461

    // Targeting: a finger is a pointer of its own, so the target is the node

462

    // under THAT point (`HoverManager` keyed by `InputPointId::Touch(id)`) when

463

    // the host published a hit test for it, falling back to the mouse target —

464

    // the same fallback the pen path uses.

465

//

466

    // `TouchCancel` is deliberately NOT derived here: `TouchState` carries no

467

    // cancel channel (a cancelled point and a lifted point are the same state

468

    // delta), so guessing one would put a fabricated event on the same footing

469

    // as a real one. The debug op refuses by name instead.

470

//

471

    // KNOWN LIMIT: `deduplicate_synthetic_events` coalesces by (target,

472

    // event_type), so two fingers landing on the SAME node produce one

473

    // `TouchStart`, not two. That is pre-existing engine policy (it collapses

474

    // two simultaneous MouseDowns the same way) and is left alone here; a

475

    // multi-touch test must give each finger its own target, or read the

476

    // per-finger state off `GestureAndDragManager`, which does track sessions

477

    // individually.

478

479

        use crate::managers::hover::InputPointId;

480

        use azul_core::events::TouchEventData;

481

482

182

        let previous_points = previous_state.touch_state.touch_points.as_ref();

483

182

        let current_points = current_state.touch_state.touch_points.as_ref();

484

485

182

        if !previous_points.is_empty() || !current_points.is_empty() {

486

6

            let target_of = |id: u64| {

487

6

                hover_manager

488

6

                    .hover_node_full_for(&InputPointId::Touch(id))

489

6

                    .unwrap_or(mouse_target)

490

6

};

491

6

            let touch_data = |p: &azul_core::window::TouchPoint| {

492

6

                EventData::Touch(TouchEventData {

493

6

                    id: p.id,

494

6

                    position: p.position,

495

6

                    force: p.force,

496

6

})

497

6

};

498

499

11

            for point in current_points {

500

5

                match previous_points.iter().find(|q| q.id == point.id) {

501

1

                    None => events.push(SyntheticEvent::new(

502

1

                        EventType::TouchStart,

503

1

                        EventSource::User,

504

1

                        target_of(point.id),

505

1

                        timestamp.clone(),

506

1

                        touch_data(point),

507

)),

508

4

                    Some(before) if before.position != point.position => {

509

2

                        events.push(SyntheticEvent::new(

510

2

                            EventType::TouchMove,

511

2

                            EventSource::User,

512

2

                            target_of(point.id),

513

2

                            timestamp.clone(),

514

2

                            touch_data(point),

515

2

));

516

2

517

2

                    Some(_) => {}

518

519

520

13

            for point in previous_points {

521

7

                if !current_points.iter().any(|p| p.id == point.id) {

522

3

                    events.push(SyntheticEvent::new(

523

3

                        EventType::TouchEnd,

524

3

                        EventSource::User,

525

3

                        target_of(point.id),

526

3

                        timestamp.clone(),

527

3

                        touch_data(point),

528

3

));

529

4

530

531

176

532

533

534

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

535

    // Wheel / trackpad scroll  →  Scroll event on the hovered node

536

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

537

    // The platform recorded a wheel delta this pass. The scroll-physics path

538

    // handles scroll *containers*; here we additionally fire a W3C-style Scroll

539

    // event at the hovered node so widgets that treat the wheel specially (the

540

    // map zooms) get a `HoverEventFilter::Scroll` callback. The delta itself is

541

    // read back by the callback via `CallbackInfo::get_scroll_delta`.

542

182

    if let Some(delta) = wheel_delta {

543

6

        if delta.x != 0.0 || delta.y != 0.0 {

544

4

            events.push(SyntheticEvent::new(

545

4

                EventType::Scroll,

546

4

                EventSource::User,

547

4

                mouse_target,

548

4

                timestamp.clone(),

549

4

                EventData::Scroll(ScrollEventData {

550

4

                    delta,

551

4

                    delta_mode: ScrollDeltaMode::Pixel,

552

4

}),

553

4

));

554

4

555

176

556

557

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

558

    // Per-Node MouseEnter/MouseLeave (W3C compliant)

559

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

560

    // Compare FULL hover chains between current and previous frames.

561

    // Nodes that gained hover get MouseEnter, nodes that lost hover get MouseLeave.

562

563

182

        let current_hovered = get_all_hovered_nodes(hover_manager, 0);

564

182

        let previous_hovered = get_all_hovered_nodes(hover_manager, 1);

565

566

        // Nodes that lost hover -> MouseLeave

567

182

        for (dom_id, node_id) in previous_hovered.difference(&current_hovered) {

568

4

            events.push(SyntheticEvent::new(

569

4

                EventType::MouseLeave,

570

4

                EventSource::User,

571

4

                DomNodeId {

572

4

                    dom: *dom_id,

573

4

                    node: NodeHierarchyItemId::from_crate_internal(Some(*node_id)),

574

4

},

575

4

                timestamp.clone(),

576

4

                EventData::None,

577

4

));

578

4

579

580

        // Nodes that gained hover -> MouseEnter

581

182

        for (dom_id, node_id) in current_hovered.difference(&previous_hovered) {

582

19

            events.push(SyntheticEvent::new(

583

19

                EventType::MouseEnter,

584

19

                EventSource::User,

585

19

                DomNodeId {

586

19

                    dom: *dom_id,

587

19

                    node: NodeHierarchyItemId::from_crate_internal(Some(*node_id)),

588

19

},

589

19

                timestamp.clone(),

590

19

                EventData::None,

591

19

));

592

19

593

594

595

    // Window-level mouse enter/leave (cursor enters/exits OS window)

596

182

    if current_in_window && !previous_in_window {

597

4

        events.push(SyntheticEvent::new(

598

4

            EventType::MouseEnter,

599

4

            EventSource::User,

600

4

            root_node,

601

4

            timestamp.clone(),

602

4

            EventData::None,

603

4

));

604

178

605

182

    if !current_in_window && previous_in_window {

606

1

        events.push(SyntheticEvent::new(

607

1

            EventType::MouseLeave,

608

1

            EventSource::User,

609

1

            root_node,

610

1

            timestamp.clone(),

611

1

            EventData::None,

612

1

));

613

181

614

615

    // Keyboard Events

616

    // W3C: Keyboard events target the focused element, falling back to root

617

618

182

    let focus_target = focus_manager

619

182

        .get_focused_node()

620

182

        .copied()

621

182

        .unwrap_or(root_node);

622

623

182

    let current_key = current_state

624

182

        .keyboard_state

625

182

        .current_virtual_keycode

626

182

        .into_option();

627

182

    let previous_key = previous_state

628

182

        .keyboard_state

629

182

        .current_virtual_keycode

630

182

        .into_option();

631

632

    // KeyDown: Fires when a new key is pressed

633

    // Case 1: New key pressed (current != previous)

634

    // Case 2: Same key pressed again after release (current.is_some() && previous.is_none())

635

182

    let keyboard_data = EventData::Keyboard(KeyboardEventData {

636

182

        key_code: current_key.map_or(0, |k| k as u32),

637

182

        char_code: None, // Character is available from the keyboard state

638

182

        modifiers,

639

        repeat: false,

640

});

641

642

182

    if current_key.is_some() && (current_key != previous_key || previous_key.is_none()) {

643

20

        events.push(SyntheticEvent::new(

644

20

            EventType::KeyDown,

645

20

            EventSource::User,

646

20

            focus_target,

647

20

            timestamp.clone(),

648

20

            keyboard_data,

649

20

));

650

162

651

182

    let key_up_data = EventData::Keyboard(KeyboardEventData {

652

182

        key_code: previous_key.map_or(0, |k| k as u32),

653

182

        char_code: None,

654

182

        modifiers,

655

        repeat: false,

656

});

657

658

182

    if previous_key.is_some() && current_key.is_none() {

659

16

        events.push(SyntheticEvent::new(

660

16

            EventType::KeyUp,

661

16

            EventSource::User,

662

16

            focus_target,

663

16

            timestamp.clone(),

664

16

            key_up_data,

665

16

));

666

166

667

668

    // Window State Events

669

670

    // Window resize

671

182

    if current_state.size.dimensions != previous_state.size.dimensions {

672

9

        events.push(SyntheticEvent::new(

673

9

            EventType::WindowResize,

674

9

            EventSource::User,

675

9

            root_node,

676

9

            timestamp.clone(),

677

9

            EventData::Window(WindowEventData {

678

9

                size: Some(LogicalRect {

679

9

                    origin: LogicalPosition { x: 0.0, y: 0.0 },

680

9

                    size: current_state.size.dimensions,

681

9

}),

682

9

                position: None,

683

9

}),

684

9

));

685

173

686

687

    // Window moved

688

182

    if current_state.position != previous_state.position {

689

3

        if let WindowPosition::Initialized(phys_pos) = current_state.position {

690

2

            events.push(SyntheticEvent::new(

691

2

                EventType::WindowMove,

692

2

                EventSource::User,

693

2

                root_node,

694

2

                timestamp.clone(),

695

2

                EventData::Window(WindowEventData {

696

2

                    size: None,

697

2

                    position: Some(LogicalPosition {

698

2

                        x: phys_pos.x as f32,

699

2

                        y: phys_pos.y as f32,

700

2

}),

701

2

}),

702

2

));

703

3

704

179

705

706

    // Window frame transition (minimize / maximize / restore / fullscreen).

707

//

708

    // The backends have kept `flags.frame` in sync for a long time, and both

709

    // the Win32 and macOS handlers carried a comment claiming the app's

710

    // Maximize/Restore callbacks fired as a result. They did not: nothing

711

    // derived an event from this field, so no callback could ever observe a

712

    // frame transition.

713

182

    if current_state.flags.frame != previous_state.flags.frame {

714

5

        events.push(SyntheticEvent::new(

715

5

            EventType::WindowFrameChanged,

716

5

            EventSource::User,

717

5

            root_node,

718

5

            timestamp.clone(),

719

5

            EventData::None,

720

5

));

721

177

722

723

    // Window close requested

724

182

    if current_state.flags.close_requested && !previous_state.flags.close_requested {

725

1

        events.push(SyntheticEvent::new(

726

1

            EventType::WindowClose,

727

1

            EventSource::User,

728

1

            root_node,

729

1

            timestamp.clone(),

730

1

            EventData::None,

731

1

));

732

181

733

734

    // Window focus changed

735

182

    if current_state.window_focused && !previous_state.window_focused {

736

2

        events.push(SyntheticEvent::new(

737

2

            EventType::WindowFocusIn,

738

2

            EventSource::User,

739

2

            root_node,

740

2

            timestamp.clone(),

741

2

            EventData::None,

742

2

));

743

180

744

182

    if !current_state.window_focused && previous_state.window_focused {

745

3

        events.push(SyntheticEvent::new(

746

3

            EventType::WindowFocusOut,

747

3

            EventSource::User,

748

3

            root_node,

749

3

            timestamp.clone(),

750

3

            EventData::None,

751

3

));

752

179

753

754

    // Theme changed

755

182

    if current_state.theme != previous_state.theme {

756

1

        events.push(SyntheticEvent::new(

757

1

            EventType::ThemeChange,

758

1

            EventSource::User,

759

1

            root_node,

760

1

            timestamp.clone(),

761

1

            EventData::None,

762

1

));

763

181

764

765

    // DPI changed (moved to a different-DPI monitor, or system DPI setting changed)

766

182

    if current_state.size.dpi != previous_state.size.dpi {

767

3

        events.push(SyntheticEvent::new(

768

3

            EventType::WindowDpiChanged,

769

3

            EventSource::User,

770

3

            root_node,

771

3

            timestamp.clone(),

772

3

            EventData::None,

773

3

));

774

179

775

776

    // Monitor changed (window moved to a different monitor)

777

182

    if current_state.monitor_id != previous_state.monitor_id

778

3

        && current_state.monitor_id != azul_css::corety::OptionU32::None

779

2

        && previous_state.monitor_id != azul_css::corety::OptionU32::None

780

1

781

1

        events.push(SyntheticEvent::new(

782

1

            EventType::WindowMonitorChanged,

783

1

            EventSource::User,

784

1

            root_node,

785

1

            timestamp.clone(),

786

1

            EventData::None,

787

1

));

788

181

789

790

    // File Drop Events

791

//

792

    // FileHover fires while a file is hovered over the window; FileHoverCancel

793

    // fires once when that hover ends without a drop. Both depend on platform

794

    // backends calling `file_drop_manager.set_hovered_file(Some/None)` from

795

    // their drag-enter / drag-leave handlers (macOS `draggingEntered` /

796

    // `draggingExited`, Windows OLE `IDropTarget::DragEnter` / `DragLeave`).

797

798

    // MWA-B7: target the node UNDER the drag position (mouse_target already

799

    // falls back to the root when nothing is hovered). Targeting the root

800

    // unconditionally made per-node drop targets impossible — a DroppedFile

801

    // callback registered on any non-root node could never fire.

802

182

    if file_drop_manager.get_hovered_file().is_some() {

803

3

        events.push(SyntheticEvent::new(

804

3

            EventType::FileHover,

805

3

            EventSource::User,

806

3

            mouse_target,

807

3

            timestamp.clone(),

808

3

            EventData::None,

809

3

));

810

179

    } else if file_drop_manager.hover_was_cancelled() {

811

1

        events.push(SyntheticEvent::new(

812

1

            EventType::FileHoverCancel,

813

1

            EventSource::User,

814

1

            mouse_target,

815

1

            timestamp.clone(),

816

1

            EventData::None,

817

1

));

818

178

819

820

182

    if file_drop_manager.get_dropped_file().is_some() {

821

3

        events.push(SyntheticEvent::new(

822

3

            EventType::FileDrop,

823

3

            EventSource::User,

824

3

            mouse_target,

825

3

            timestamp.clone(),

826

3

            EventData::None,

827

3

));

828

179

829

830

    // Pen / Stylus Events (W3C PointerEvent, pointerType "pen")

831

    // Diff the gesture manager's pen state; `pen_event_pending` gates one diff per

832

    // update (the event loop clears it after this pass, like the sensor manager).

833

    // Targets the hovered node (pen-as-pointer); full pen data via CallbackInfo.

834

182

    if let Some(manager) = gesture_manager {

835

106

        if manager.pen_event_pending {

836

6

            let pen_data = make_mouse_data(MouseButton::Left);

837

6

            match (manager.get_previous_pen_state(), manager.get_pen_state()) {

838

1

                (None, Some(_)) => events.push(SyntheticEvent::new(

839

1

                    EventType::PenEnter,

840

1

                    EventSource::User,

841

1

                    mouse_target,

842

1

                    timestamp.clone(),

843

1

                    pen_data,

844

)),

845

1

                (Some(_), None) => events.push(SyntheticEvent::new(

846

1

                    EventType::PenLeave,

847

1

                    EventSource::User,

848

1

                    mouse_target,

849

1

                    timestamp.clone(),

850

1

                    pen_data,

851

)),

852

4

                (Some(p), Some(c)) => {

853

4

                    if !p.in_contact && c.in_contact {

854

1

                        events.push(SyntheticEvent::new(

855

1

                            EventType::PenDown,

856

1

                            EventSource::User,

857

1

                            mouse_target,

858

1

                            timestamp.clone(),

859

1

                            pen_data.clone(),

860

1

));

861

3

                    } else if p.in_contact && !c.in_contact {

862

1

                        events.push(SyntheticEvent::new(

863

1

                            EventType::PenUp,

864

1

                            EventSource::User,

865

1

                            mouse_target,

866

1

                            timestamp.clone(),

867

1

                            pen_data.clone(),

868

1

));

869

2

870

4

                    if p.position != c.position {

871

1

                        events.push(SyntheticEvent::new(

872

1

                            EventType::PenMove,

873

1

                            EventSource::User,

874

1

                            mouse_target,

875

1

                            timestamp.clone(),

876

1

                            pen_data,

877

1

));

878

3

879

880

                (None, None) => {}

881

882

100

883

76

884

885

    // Gesture Events

886

887

182

    if let Some(manager) = gesture_manager {

888

106

        let event_was_mouse_release = !current_mouse_down && previous_mouse_down;

889

890

        // Detect DragStart (targeted at hovered node)

891

106

        if manager.detect_drag().is_some()

892

            && !manager.is_dragging() {

893

                events.push(SyntheticEvent::new(

894

                    EventType::DragStart,

895

                    EventSource::User,

896

                    mouse_target,

897

                    timestamp.clone(),

898

                    make_mouse_data(MouseButton::Left),

899

));

900

106

901

902

        // Detect Drag (continuous movement, targeted at hovered node)

903

106

        if manager.is_dragging() && current_mouse_down {

904

            let current_pos = current_state.mouse_state.cursor_position.get_position();

905

            let previous_pos = previous_state.mouse_state.cursor_position.get_position();

906

907

            if current_pos != previous_pos {

908

                events.push(SyntheticEvent::new(

909

                    EventType::Drag,

910

                    EventSource::User,

911

                    mouse_target,

912

                    timestamp.clone(),

913

                    make_mouse_data(MouseButton::Left),

914

));

915

916

106

917

918

        // Detect DragEnd (targeted at hovered node)

919

106

        if manager.is_dragging() && event_was_mouse_release {

920

            events.push(SyntheticEvent::new(

921

                EventType::DragEnd,

922

                EventSource::User,

923

                mouse_target,

924

                timestamp.clone(),

925

                make_mouse_data(MouseButton::Left),

926

));

927

928

            // When mouse is released during a node drag, generate a Drop event

929

            // on the current drop target (the node under the cursor)

930

            if manager.is_node_drag_active() {

931

                events.push(SyntheticEvent::new(

932

                    EventType::Drop,

933

                    EventSource::User,

934

                    mouse_target, // W3C: Drop targets the node under cursor

935

                    timestamp.clone(),

936

                    make_mouse_data(MouseButton::Left),

937

));

938

939

106

940

941

        // Detect DragEnter/DragOver/DragLeave events on drop targets

942

        // W3C: These fire ON the drop target node (the node UNDER the cursor)

943

106

        if manager.is_node_drag_active() && current_mouse_down {

944

            let current_hover = hover_manager.current_hover_node();

945

            let previous_hover = hover_manager.previous_hover_node();

946

947

            // If the hover node changed, generate DragLeave on old + DragEnter on new

948

            if current_hover != previous_hover {

949

                if let Some(prev_node) = previous_hover {

950

                    events.push(SyntheticEvent::new(

951

                        EventType::DragLeave,

952

                        EventSource::User,

953

                        DomNodeId {

954

                            dom: root_node.dom,

955

                            node: NodeHierarchyItemId::from_crate_internal(Some(prev_node)),

956

},

957

                        timestamp.clone(),

958

                        EventData::None,

959

));

960

961

                if let Some(curr_node) = current_hover {

962

                    events.push(SyntheticEvent::new(

963

                        EventType::DragEnter,

964

                        EventSource::User,

965

                        DomNodeId {

966

                            dom: root_node.dom,

967

                            node: NodeHierarchyItemId::from_crate_internal(Some(curr_node)),

968

},

969

                        timestamp.clone(),

970

                        EventData::None,

971

));

972

973

974

975

            // DragOver fires continuously while hovering a drop target

976

            if let Some(curr_node) = current_hover {

977

                events.push(SyntheticEvent::new(

978

                    EventType::DragOver,

979

                    EventSource::User,

980

                    DomNodeId {

981

                        dom: root_node.dom,

982

                        node: NodeHierarchyItemId::from_crate_internal(Some(curr_node)),

983

},

984

                    timestamp.clone(),

985

                    EventData::None,

986

));

987

988

106

989

990

        // Detect DoubleClick (targeted at hovered node)

991

106

        if manager.detect_double_click() {

992

1

            events.push(SyntheticEvent::new(

993

1

                EventType::DoubleClick,

994

1

                EventSource::User,

995

1

                mouse_target,

996

1

                timestamp.clone(),

997

1

                make_mouse_data(MouseButton::Left),

998

1

));

999

105

1000

1001

        // Detect LongPress (targeted at hovered node)

1002

106

        if let Some(long_press) = manager.detect_long_press() {

1003

2

            if !long_press.callback_invoked {

1004

1

                events.push(SyntheticEvent::new(

1005

1

                    EventType::LongPress,

1006

1

                    EventSource::User,

1007

1

                    mouse_target,

1008

1

                    timestamp.clone(),

1009

1

                    make_mouse_data(MouseButton::Left),

1010

1

));

1011

1

1012

104

1013

1014

        // Detect Swipe gestures (targeted at hovered node)

1015

106

        if let Some(direction) = manager.detect_swipe_direction() {

1016

            use crate::managers::gesture::GestureDirection;

1017

4

            let event_type = match direction {

1018

1

                GestureDirection::Left => EventType::SwipeLeft,

1019

1

                GestureDirection::Right => EventType::SwipeRight,

1020

1

                GestureDirection::Up => EventType::SwipeUp,

1021

1

                GestureDirection::Down => EventType::SwipeDown,

1022

};

1023

4

            events.push(SyntheticEvent::new(

1024

4

                event_type,

1025

4

                EventSource::User,

1026

4

                mouse_target,

1027

4

                timestamp.clone(),

1028

4

                EventData::None,

1029

));

1030

102

1031

1032

        // Detect Pinch gestures (targeted at hovered node)

1033

106

        if let Some(pinch) = manager.detect_pinch() {

1034

8

            let event_type = if pinch.scale < 1.0 {

1035

4

                EventType::PinchIn

1036

            } else {

1037

4

                EventType::PinchOut

1038

};

1039

8

            events.push(SyntheticEvent::new(

1040

8

                event_type,

1041

8

                EventSource::User,

1042

8

                mouse_target,

1043

8

                timestamp.clone(),

1044

8

                EventData::None,

1045

));

1046

98

1047

1048

        // Detect Rotation gestures (targeted at hovered node)

1049

106

        if let Some(rotation) = manager.detect_rotation() {

1050

7

            let event_type = if rotation.angle_radians > 0.0 {

1051

2

                EventType::RotateClockwise

1052

            } else {

1053

5

                EventType::RotateCounterClockwise

1054

};

1055

7

            events.push(SyntheticEvent::new(

1056

7

                event_type,

1057

7

                EventSource::User,

1058

7

                mouse_target,

1059

7

                timestamp.clone(),

1060

7

                EventData::None,

1061

));

1062

99

1063

1064

        // Detect Pen events (targeted at hovered node)

1065

106

        if let Some(pen_state) = manager.get_pen_state() {

1066

7

            if pen_state.in_contact {

1067

5

                let current_pos = current_state.mouse_state.cursor_position.get_position();

1068

5

                let previous_pos = previous_state.mouse_state.cursor_position.get_position();

1069

1070

5

                if current_pos != previous_pos {

1071

1

                    events.push(SyntheticEvent::new(

1072

1

                        EventType::TouchMove, // Use TouchMove as fallback

1073

1

                        EventSource::User,

1074

1

                        mouse_target,

1075

1

                        timestamp.clone(),

1076

1

                        EventData::None,

1077

1

));

1078

4

1079

2

1080

99

1081

76

1082

1083

    // Manager Events (Scroll, Text Input, etc.)

1084

1085

703

    for manager in managers {

1086

521

        events.extend(manager.get_pending_events(timestamp.clone()));

1087

521

1088

1089

    // Deduplication

1090

1091

182

    deduplicate_synthetic_events(events)

1092

182

1093

1094

#[cfg(test)]

1095

mod tests {

1096

    use super::*;

1097

    use azul_core::window::{

1098

        VirtualKeyCode, VirtualKeyCodeVec,

1099

        OptionVirtualKeyCode,

1100

};

1101

1102

18

    fn ts() -> Instant { Instant::Tick(SystemTick::new(0)) }

1103

1104

30

    fn default_state() -> FullWindowState {

1105

30

        FullWindowState::default()

1106

30

1107

1108

10

    fn state_with_key(vk: VirtualKeyCode) -> FullWindowState {

1109

10

        let mut s = default_state();

1110

10

        s.keyboard_state.current_virtual_keycode = OptionVirtualKeyCode::Some(vk);

1111

10

        s.keyboard_state.pressed_virtual_keycodes = VirtualKeyCodeVec::from_vec(vec![vk]);

1112

10

1113

10

1114

1115

2

    fn state_with_left_down(x: f32, y: f32) -> FullWindowState {

1116

2

        let mut s = default_state();

1117

2

        s.mouse_state.cursor_position = CursorPosition::InWindow(LogicalPosition::new(x, y));

1118

2

        s.mouse_state.left_down = true;

1119

2

1120

2

1121

1122

4

    fn state_with_cursor(x: f32, y: f32) -> FullWindowState {

1123

4

        let mut s = default_state();

1124

4

        s.mouse_state.cursor_position = CursorPosition::InWindow(LogicalPosition::new(x, y));

1125

4

1126

4

1127

1128

18

    fn empty_providers() -> Vec<&'static dyn EventProvider> { vec![] }

1129

1130

18

    fn run_determine(

1131

18

        current: &FullWindowState,

1132

18

        previous: &FullWindowState,

1133

18

    ) -> Vec<SyntheticEvent> {

1134

18

        let focus = crate::managers::focus_cursor::FocusManager::new();

1135

18

        let hover = crate::managers::hover::HoverManager::new();

1136

18

        let filedrop = crate::managers::file_drop::FileDropManager::new();

1137

18

        let providers = empty_providers();

1138

18

        determine_all_events(current, previous, &hover, &focus, &filedrop, None, &providers, None, ts())

1139

18

1140

1141

    // === Touch tests ===

1142

//

1143

    // Regression guard for a hole that made the whole touch surface

1144

    // write-only: every backend wrote `FullWindowState.touch_state` and

1145

    // `determine_all_events` never read it, so `HoverEventFilter::TouchStart`

1146

    // handlers (slider, split-pane, map) could not fire on ANY platform.

1147

1148

9

    fn n_of(events: &[SyntheticEvent], ty: EventType) -> usize {

1149

9

        events.iter().filter(|e| e.event_type == ty).count()

1150

9

1151

1152

6

    fn state_with_touch(points: &[(u64, f32, f32)]) -> FullWindowState {

1153

        use azul_core::window::{TouchPoint, TouchPointVec};

1154

6

        let mut s = default_state();

1155

6

        let pts: Vec<TouchPoint> = points

1156

6

            .iter()

1157

6

            .map(|(id, x, y)| TouchPoint {

1158

8

                id: *id,

1159

8

                position: LogicalPosition::new(*x, *y),

1160

                force: 0.5,

1161

8

})

1162

6

            .collect();

1163

6

        s.touch_state.num_touches = pts.len();

1164

6

        s.touch_state.touch_points = TouchPointVec::from_vec(pts);

1165

6

1166

6

1167

1168

    #[test]

1169

1

    fn touch_start_fires_for_a_newly_down_point() {

1170

1

        let events = run_determine(&state_with_touch(&[(1, 10.0, 20.0)]), &default_state());

1171

1

        let ts: Vec<_> = events

1172

1

            .iter()

1173

1

            .filter(|e| e.event_type == EventType::TouchStart)

1174

1

            .collect();

1175

1

        assert_eq!(ts.len(), 1);

1176

1

        match &ts[0].data {

1177

1

            EventData::Touch(t) => {

1178

1

                assert_eq!(t.id, 1);

1179

1

                assert_eq!(t.position, LogicalPosition::new(10.0, 20.0));

1180

1181

            other => panic!("TouchStart must carry EventData::Touch, got {other:?}"),

1182

1183

1

1184

1185

    #[test]

1186

1

    fn touch_move_fires_only_when_the_point_moved() {

1187

1

        let held = state_with_touch(&[(1, 10.0, 20.0)]);

1188

1

        assert_eq!(n_of(&run_determine(&held, &held), EventType::TouchMove), 0);

1189

1190

1

        let moved = state_with_touch(&[(1, 11.0, 20.0)]);

1191

1

        assert_eq!(n_of(&run_determine(&moved, &held), EventType::TouchMove), 1);

1192

1

        assert_eq!(n_of(&run_determine(&moved, &held), EventType::TouchStart), 0);

1193

1

1194

1195

    #[test]

1196

1

    fn touch_end_fires_for_a_point_that_disappeared() {

1197

1

        let down = state_with_touch(&[(1, 10.0, 20.0), (2, 30.0, 40.0)]);

1198

1

        let one_left = state_with_touch(&[(2, 30.0, 40.0)]);

1199

1

        let events = run_determine(&one_left, &down);

1200

1

        assert_eq!(n_of(&events, EventType::TouchEnd), 1);

1201

1

        let ended = events

1202

1

            .iter()

1203

1

            .find(|e| e.event_type == EventType::TouchEnd)

1204

1

            .expect("a TouchEnd exists");

1205

1

        match &ended.data {

1206

1

            EventData::Touch(t) => assert_eq!(t.id, 1),

1207

            other => panic!("TouchEnd must carry EventData::Touch, got {other:?}"),

1208

1209

1

1210

1211

    #[test]

1212

1

    fn no_touch_events_without_a_touch_state_delta() {

1213

1

        let events = run_determine(&default_state(), &default_state());

1214

1

        assert_eq!(n_of(&events, EventType::TouchStart), 0);

1215

1

        assert_eq!(n_of(&events, EventType::TouchMove), 0);

1216

1

        assert_eq!(n_of(&events, EventType::TouchEnd), 0);

1217

1

1218

1219

    #[test]

1220

1

    fn touch_cancel_is_never_synthesised() {

1221

        // `TouchState` has no cancel channel; lifting every point is

1222

        // indistinguishable from a cancel, so the determination emits TouchEnd

1223

        // and the debug op refuses `touch_cancel` by name rather than letting a

1224

        // cancellation test go green on end semantics.

1225

//

1226

        // Both fingers resolve to the SAME target here (no per-touch hit test

1227

        // is published in this fixture, so both fall back to the root), and

1228

        // `deduplicate_synthetic_events` coalesces by (target, event_type) —

1229

        // pre-existing engine policy, the same thing that collapses two

1230

        // simultaneous MouseDowns. So one TouchEnd survives, and zero

1231

        // TouchCancels, which is the property under test.

1232

1

        let down = state_with_touch(&[(1, 10.0, 20.0), (2, 30.0, 40.0)]);

1233

1

        let events = run_determine(&default_state(), &down);

1234

1

        assert_eq!(n_of(&events, EventType::TouchEnd), 1);

1235

1

        assert_eq!(n_of(&events, EventType::TouchCancel), 0);

1236

1

1237

1238

    // === Keyboard tests ===

1239

1240

    #[test]

1241

1

    fn keydown_fires_when_key_newly_pressed() {

1242

1

        let events = run_determine(&state_with_key(VirtualKeyCode::A), &default_state());

1243

1

        let kd: Vec<_> = events.iter().filter(|e| e.event_type == EventType::KeyDown).collect();

1244

1

        assert_eq!(kd.len(), 1);

1245

1

        assert!(matches!(kd[0].data, EventData::Keyboard(_)));

1246

1

1247

1248

    #[test]

1249

1

    fn keydown_skipped_when_same_key_held() {

1250

1

        let s = state_with_key(VirtualKeyCode::A);

1251

1

        let events = run_determine(&s, &s);

1252

1

        let kd = events.iter().filter(|e| e.event_type == EventType::KeyDown).count();

1253

1

        assert_eq!(kd, 0, "KeyDown should not fire when same key held");

1254

1

1255

1256

    #[test]

1257

1

    fn keydown_fires_for_different_key() {

1258

1

        let events = run_determine(

1259

1

            &state_with_key(VirtualKeyCode::B),

1260

1

            &state_with_key(VirtualKeyCode::A),

1261

);

1262

1

        let kd = events.iter().filter(|e| e.event_type == EventType::KeyDown).count();

1263

1

        assert_eq!(kd, 1);

1264

1

1265

1266

    #[test]

1267

1

    fn keyup_fires_when_key_released() {

1268

1

        let events = run_determine(&default_state(), &state_with_key(VirtualKeyCode::A));

1269

1

        let ku: Vec<_> = events.iter().filter(|e| e.event_type == EventType::KeyUp).collect();

1270

1

        assert_eq!(ku.len(), 1);

1271

1

        assert!(matches!(ku[0].data, EventData::Keyboard(_)));

1272

1

1273

1274

    #[test]

1275

1

    fn backspace_keydown_has_keyboard_data() {

1276

1

        let events = run_determine(&state_with_key(VirtualKeyCode::Back), &default_state());

1277

1

        let kd: Vec<_> = events.iter().filter(|e| e.event_type == EventType::KeyDown).collect();

1278

1

        assert_eq!(kd.len(), 1);

1279

1

        match &kd[0].data {

1280

1

            EventData::Keyboard(kb) => assert_eq!(kb.key_code, VirtualKeyCode::Back as u32),

1281

            other => panic!("Expected Keyboard data, got {other:?}"),

1282

1283

1

1284

1285

    // === Mouse tests ===

1286

1287

    #[test]

1288

1

    fn mousedown_fires_on_left_press() {

1289

1

        let events = run_determine(

1290

1

            &state_with_left_down(100.0, 200.0),

1291

1

            &state_with_cursor(100.0, 200.0),

1292

);

1293

1

        let md = events.iter().filter(|e| e.event_type == EventType::MouseDown).count();

1294

1

        assert_eq!(md, 1);

1295

1

1296

1297

    #[test]

1298

1

    fn mouseup_fires_on_left_release() {

1299

1

        let events = run_determine(

1300

1

            &state_with_cursor(100.0, 200.0),

1301

1

            &state_with_left_down(100.0, 200.0),

1302

);

1303

1

        let mu = events.iter().filter(|e| e.event_type == EventType::MouseUp).count();

1304

1

        assert_eq!(mu, 1);

1305

1

1306

1307

    #[test]

1308

1

    fn no_events_when_state_unchanged() {

1309

1

        let s = default_state();

1310

1

        let events = run_determine(&s, &s);

1311

1

        assert!(events.is_empty(), "Got {} events when state unchanged", events.len());

1312

1

1313

1314

    #[test]

1315

1

    fn mouseover_fires_on_cursor_move() {

1316

1

        let events = run_determine(

1317

1

            &state_with_cursor(150.0, 250.0),

1318

1

            &state_with_cursor(100.0, 200.0),

1319

);

1320

1

        let mo = events.iter().filter(|e| e.event_type == EventType::MouseOver).count();

1321

1

        assert_eq!(mo, 1);

1322

1

1323

1324

    #[test]

1325

1

    fn key_repeat_fires_keydown_when_previous_cleared() {

1326

        // Simulates what the platform layer does for key repeat:

1327

        // previous has current_virtual_keycode=None (cleared by platform),

1328

        // current has Some(Left). This should fire KeyDown even though

1329

        // the key was already pressed in the previous frame.

1330

1

        let mut previous = state_with_key(VirtualKeyCode::Left);

1331

        // Platform clears this for repeat detection:

1332

1

        previous.keyboard_state.current_virtual_keycode = OptionVirtualKeyCode::None;

1333

1334

1

        let current = state_with_key(VirtualKeyCode::Left);

1335

1336

1

        let events = run_determine(&current, &previous);

1337

1

        let kd = events.iter().filter(|e| e.event_type == EventType::KeyDown).count();

1338

1

        assert_eq!(kd, 1, "Key repeat should fire KeyDown when previous is cleared");

1339

1

1340

1341

    #[test]

1342

1

    fn key_repeat_skipped_when_previous_not_cleared() {

1343

        // Without the platform fix: both previous and current have Same(Left).

1344

        // KeyDown should NOT fire (this documents the limitation that the

1345

        // platform layer MUST clear previous for repeats).

1346

1

        let previous = state_with_key(VirtualKeyCode::Left);

1347

1

        let current = state_with_key(VirtualKeyCode::Left);

1348

1349

1

        let events = run_determine(&current, &previous);

1350

1

        let kd = events.iter().filter(|e| e.event_type == EventType::KeyDown).count();

1351

1

        assert_eq!(kd, 0, "Without platform clearing, repeat is not detected");

1352

1

1353

1354

1355

#[cfg(test)]

1356

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

1357

mod autotest_generated {

1358

    use azul_core::{

1359

        geom::{LogicalSize, PhysicalPositionI32},

1360

        hit_test::{FullHitTest, HitTest, HitTestItem},

1361

        window::{

1362

            OptionVirtualKeyCode, VirtualKeyCode, VirtualKeyCodeVec, WindowTheme,

1363

},

1364

};

1365

    use azul_css::{corety::OptionU32, AzString};

1366

1367

    use super::*;

1368

    use crate::managers::{

1369

        file_drop::FileDropManager,

1370

        focus_cursor::FocusManager,

1371

        gesture::{

1372

            DetectedLongPress, DetectedPinch, DetectedRotation, GestureAndDragManager,

1373

            GestureDirection, NativeGestureEvent,

1374

},

1375

        hover::{HoverManager, InputPointId},

1376

};

1377

1378

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

1379

    // Fixtures

1380

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

1381

1382

    fn ts(tick: u64) -> Instant {

1383

        Instant::Tick(SystemTick::new(tick))

1384

1385

1386

    fn node(dom: usize, n: usize) -> DomNodeId {

1387

        DomNodeId {

1388

            dom: DomId { inner: dom },

1389

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

1390

1391

1392

1393

    fn root() -> DomNodeId {

1394

        node(0, 0)

1395

1396

1397

    fn ev(event_type: EventType, target: DomNodeId, tick: u64) -> SyntheticEvent {

1398

        SyntheticEvent::new(

1399

            event_type,

1400

            EventSource::User,

1401

            target,

1402

            ts(tick),

1403

            EventData::None,

1404

1405

1406

1407

    fn hit_item() -> HitTestItem {

1408

        HitTestItem {

1409

            point_in_viewport: LogicalPosition::new(0.0, 0.0),

1410

            point_relative_to_item: LogicalPosition::new(0.0, 0.0),

1411

            is_focusable: false,

1412

            is_virtual_view_hit: None,

1413

            hit_depth: 0,

1414

1415

1416

1417

    /// A hit test where `(dom, node)` pairs are "regular" hits.

1418

    fn hits(pairs: &[(usize, usize)]) -> FullHitTest {

1419

        let mut ht = FullHitTest::empty(None);

1420

        for (dom, n) in pairs {

1421

            ht.hovered_nodes

1422

                .entry(DomId { inner: *dom })

1423

                .or_insert_with(HitTest::empty)

1424

                .regular_hit_test_nodes

1425

                .insert(NodeId::new(*n), hit_item());

1426

1427

ht

1428

1429

1430

    /// Hover manager with `previous` recorded first, so it lands at frame 1.

1431

    fn hover_with(previous: FullHitTest, current: FullHitTest) -> HoverManager {

1432

        let mut hm = HoverManager::new();

1433

        hm.push_hit_test(InputPointId::Mouse, previous);

1434

        hm.push_hit_test(InputPointId::Mouse, current);

1435

hm

1436

1437

1438

    fn state() -> FullWindowState {

1439

        FullWindowState::default()

1440

1441

1442

    fn cursor_at(x: f32, y: f32) -> FullWindowState {

1443

        let mut s = state();

1444

        s.mouse_state.cursor_position = CursorPosition::InWindow(LogicalPosition::new(x, y));

1445

1446

1447

1448

    /// Test-only `EventProvider` that replays a fixed list of events.

1449

    struct StaticProvider(Vec<SyntheticEvent>);

1450

1451

    impl EventProvider for StaticProvider {

1452

        fn get_pending_events(&self, _timestamp: Instant) -> Vec<SyntheticEvent> {

1453

            self.0.clone()

1454

1455

1456

1457

    /// Test-only `EventProvider` that stamps events with the timestamp it is handed.

1458

    struct EchoProvider(DomNodeId);

1459

1460

    impl EventProvider for EchoProvider {

1461

        fn get_pending_events(&self, timestamp: Instant) -> Vec<SyntheticEvent> {

1462

            vec![SyntheticEvent::new(

1463

                EventType::Scroll,

1464

                EventSource::User,

1465

                self.0,

1466

                timestamp,

1467

                EventData::None,

1468

)]

1469

1470

1471

1472

    fn count(events: &[SyntheticEvent], ty: EventType) -> usize {

1473

        events.iter().filter(|e| e.event_type == ty).count()

1474

1475

1476

    fn only(events: &[SyntheticEvent], ty: EventType) -> SyntheticEvent {

1477

        let matching: Vec<_> = events.iter().filter(|e| e.event_type == ty).collect();

1478

        assert_eq!(

1479

            matching.len(),

1480

1,

1481

            "expected exactly one {ty:?}, got {matching:?}"

1482

);

1483

        matching[0].clone()

1484

1485

1486

    /// `determine_all_events` with default managers and no providers.

1487

    fn run(

1488

        current: &FullWindowState,

1489

        previous: &FullWindowState,

1490

        hover: &HoverManager,

1491

        gesture: Option<&GestureAndDragManager>,

1492

        wheel: Option<LogicalPosition>,

1493

    ) -> Vec<SyntheticEvent> {

1494

        let focus = FocusManager::new();

1495

        let file_drop = FileDropManager::new();

1496

        let providers: Vec<&dyn EventProvider> = Vec::new();

1497

        determine_all_events(

1498

            current,

1499

            previous,

1500

            hover,

1501

            &focus,

1502

            &file_drop,

1503

            gesture,

1504

            &providers,

1505

            wheel,

1506

            ts(0),

1507

1508

1509

1510

    /// `determine_all_events` with an empty hover manager and no gestures.

1511

    fn run_plain(current: &FullWindowState, previous: &FullWindowState) -> Vec<SyntheticEvent> {

1512

        run(current, previous, &HoverManager::new(), None, None)

1513

1514

1515

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

1516

    // get_all_hovered_nodes  (numeric: zero / min_max / overflow)

1517

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

1518

1519

    #[test]

1520

    fn hovered_nodes_empty_manager_is_empty_at_frame_zero() {

1521

        let hm = HoverManager::new();

1522

        assert!(get_all_hovered_nodes(&hm, 0).is_empty());

1523

1524

1525

    #[test]

1526

    fn hovered_nodes_frame_index_usize_max_does_not_panic() {

1527

        let hm = hover_with(hits(&[(0, 1)]), hits(&[(0, 2)]));

1528

        // VecDeque::get(usize::MAX) must return None, not index out of bounds.

1529

        assert!(get_all_hovered_nodes(&hm, usize::MAX).is_empty());

1530

        assert!(get_all_hovered_nodes(&hm, usize::MAX - 1).is_empty());

1531

1532

1533

    #[test]

1534

    fn hovered_nodes_frame_index_past_history_is_empty() {

1535

        let hm = hover_with(hits(&[(0, 1)]), hits(&[(0, 2)]));

1536

        assert_eq!(get_all_hovered_nodes(&hm, 0).len(), 1);

1537

        assert_eq!(get_all_hovered_nodes(&hm, 1).len(), 1);

1538

        assert!(get_all_hovered_nodes(&hm, 2).is_empty());

1539

        assert!(get_all_hovered_nodes(&hm, 100).is_empty());

1540

1541

1542

    #[test]

1543

    fn hovered_nodes_history_is_capped_at_five_frames() {

1544

        let mut hm = HoverManager::new();

1545

        for i in 0..8_usize {

1546

            hm.push_hit_test(InputPointId::Mouse, hits(&[(0, i)]));

1547

1548

        // Most recent push is frame 0.

1549

        assert!(get_all_hovered_nodes(&hm, 0).contains(&(DomId { inner: 0 }, NodeId::new(7))));

1550

        // Ring buffer keeps 5 frames: nodes 7,6,5,4,3.

1551

        assert!(get_all_hovered_nodes(&hm, 4).contains(&(DomId { inner: 0 }, NodeId::new(3))));

1552

        assert!(

1553

            get_all_hovered_nodes(&hm, 5).is_empty(),

1554

            "frame 5 must have been evicted by the 5-frame cap"

1555

);

1556

1557

1558

    #[test]

1559

    fn hovered_nodes_walks_every_hit_dom_not_just_the_root() {

1560

        let hm = hover_with(

1561

            FullHitTest::empty(None),

1562

            hits(&[(0, 1), (0, 2), (7, 3), (usize::MAX, 4)]),

1563

);

1564

        let set = get_all_hovered_nodes(&hm, 0);

1565

        assert_eq!(set.len(), 4);

1566

        assert!(set.contains(&(DomId { inner: 0 }, NodeId::new(1))));

1567

        assert!(set.contains(&(DomId { inner: 7 }, NodeId::new(3))));

1568

        assert!(set.contains(&(DomId { inner: usize::MAX }, NodeId::new(4))));

1569

1570

1571

    #[test]

1572

    fn hovered_nodes_accepts_extreme_node_ids() {

1573

        // NodeId is a plain usize index here; no encoding happens in this

1574

        // function, so even usize::MAX must round-trip untouched.

1575

        let hm = hover_with(

1576

            FullHitTest::empty(None),

1577

            hits(&[(0, 0), (0, usize::MAX), (0, usize::MAX - 1)]),

1578

);

1579

        let set = get_all_hovered_nodes(&hm, 0);

1580

        assert_eq!(set.len(), 3);

1581

        assert!(set.contains(&(DomId { inner: 0 }, NodeId::new(usize::MAX))));

1582

        assert!(set.contains(&(DomId { inner: 0 }, NodeId::ZERO)));

1583

1584

1585

    #[test]

1586

    fn hovered_nodes_ignores_non_regular_hits() {

1587

        let mut ht = FullHitTest::empty(None);

1588

        let mut hit = HitTest::empty();

1589

        hit.cursor_hit_test_nodes.insert(

1590

            NodeId::new(9),

1591

            azul_core::hit_test::CursorHitTestItem {

1592

                cursor_type: azul_core::hit_test::CursorType::Default,

1593

                hit_depth: 0,

1594

                point_in_viewport: LogicalPosition::new(0.0, 0.0),

1595

},

1596

);

1597

        ht.hovered_nodes.insert(DomId { inner: 0 }, hit);

1598

        let mut hm = HoverManager::new();

1599

        hm.push_hit_test(InputPointId::Mouse, ht);

1600

        assert!(

1601

            get_all_hovered_nodes(&hm, 0).is_empty(),

1602

            "only regular hits count as hovered"

1603

);

1604

1605

1606

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

1607

    // detect_window_state_events

1608

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

1609

1610

    #[test]

1611

    fn window_state_identical_states_yield_no_events() {

1612

        let s = state();

1613

        assert!(detect_window_state_events(&s, &s, ts(0)).is_empty());

1614

1615

1616

    #[test]

1617

    fn window_resize_reports_the_current_dimensions() {

1618

        let mut current = state();

1619

        current.size.dimensions = LogicalSize::new(1234.0, 5678.0);

1620

        let events = detect_window_state_events(&current, &state(), ts(0));

1621

        let e = only(&events, EventType::WindowResize);

1622

        match e.data {

1623

            EventData::Window(w) => {

1624

                let rect = w.size.expect("resize carries a size");

1625

                assert_eq!(rect.origin.x, 0.0);

1626

                assert_eq!(rect.size.width, 1234.0);

1627

                assert_eq!(rect.size.height, 5678.0);

1628

1629

            other => panic!("expected Window data, got {other:?}"),

1630

1631

1632

1633

    #[test]

1634

    fn window_resize_below_the_quantization_step_is_not_a_resize() {

1635

        // LogicalSize::eq quantizes to 1/1000, so a sub-milli-pixel change is

1636

        // *not* a size change and must not spam WindowResize every frame.

1637

        let previous = state();

1638

        let mut current = state();

1639

        current.size.dimensions = LogicalSize::new(640.0004, 480.0);

1640

        assert!(detect_window_state_events(&current, &previous, ts(0)).is_empty());

1641

1642

        current.size.dimensions = LogicalSize::new(640.5, 480.0);

1643

        assert_eq!(

1644

            count(

1645

                &detect_window_state_events(&current, &previous, ts(0)),

1646

                EventType::WindowResize

1647

),

1648

1649

);

1650

1651

1652

    #[test]

1653

    fn window_resize_nan_dimensions_are_stable_and_do_not_panic() {

1654

        let mut nan = state();

1655

        nan.size.dimensions = LogicalSize::new(f32::NAN, f32::NAN);

1656

        // quantize() maps NaN to a single sentinel, so NaN == NaN: a window

1657

        // stuck at NaN must not emit a resize on every single frame.

1658

        assert!(

1659

            detect_window_state_events(&nan, &nan.clone(), ts(0)).is_empty(),

1660

            "NaN size compared against itself must not fire a resize"

1661

);

1662

1663

        // ...but a real -> NaN transition still reports (and forwards the NaN).

1664

        let events = detect_window_state_events(&nan, &state(), ts(0));

1665

        let e = only(&events, EventType::WindowResize);

1666

        match e.data {

1667

            EventData::Window(w) => {

1668

                assert!(w.size.expect("size").size.width.is_nan());

1669

1670

            other => panic!("expected Window data, got {other:?}"),

1671

1672

1673

1674

    #[test]

1675

    fn window_resize_infinite_dimensions_do_not_panic() {

1676

        let mut current = state();

1677

        current.size.dimensions = LogicalSize::new(f32::INFINITY, f32::NEG_INFINITY);

1678

        let events = detect_window_state_events(&current, &state(), ts(0));

1679

        assert_eq!(count(&events, EventType::WindowResize), 1);

1680

1681

1682

    #[test]

1683

    fn window_move_saturates_extreme_i32_coordinates_into_f32() {

1684

        let mut current = state();

1685

        current.position = WindowPosition::Initialized(PhysicalPositionI32 {

1686

            x: i32::MIN,

1687

            y: i32::MAX,

1688

});

1689

        let events = detect_window_state_events(&current, &state(), ts(0));

1690

        let e = only(&events, EventType::WindowMove);

1691

        match e.data {

1692

            EventData::Window(w) => {

1693

                let pos = w.position.expect("move carries a position");

1694

                assert_eq!(pos.x, i32::MIN as f32);

1695

                // i32::MAX is not representable in f32: it rounds *up* to 2^31.

1696

                assert_eq!(pos.y, 2_147_483_648.0_f32);

1697

1698

            other => panic!("expected Window data, got {other:?}"),

1699

1700

1701

1702

    #[test]

1703

    fn window_move_to_uninitialized_emits_nothing() {

1704

        let previous = {

1705

            let mut s = state();

1706

            s.position = WindowPosition::Initialized(PhysicalPositionI32 { x: 5, y: 5 });

1707

1708

};

1709

        // current.position == Uninitialized: state *changed*, but there is no

1710

        // position to report, so no event.

1711

        let events = detect_window_state_events(&state(), &previous, ts(0));

1712

        assert_eq!(count(&events, EventType::WindowMove), 0);

1713

1714

1715

    #[test]

1716

    fn window_move_fires_for_relative_child_window_positions() {

1717

        let mut current = state();

1718

        current.position =

1719

            WindowPosition::RelativeToParentWindow(PhysicalPositionI32 { x: -3, y: 9 });

1720

        let events = detect_window_state_events(&current, &state(), ts(0));

1721

        let e = only(&events, EventType::WindowMove);

1722

        match e.data {

1723

            EventData::Window(w) => {

1724

                let pos = w.position.expect("position");

1725

                assert_eq!(pos.x, -3.0);

1726

                assert_eq!(pos.y, 9.0);

1727

1728

            other => panic!("expected Window data, got {other:?}"),

1729

1730

1731

1732

    #[test]

1733

    fn window_theme_change_emits_exactly_one_theme_event() {

1734

        let mut current = state();

1735

        current.theme = WindowTheme::DarkMode;

1736

        let events = detect_window_state_events(&current, &state(), ts(0));

1737

        assert_eq!(events.len(), 1);

1738

        assert_eq!(events[0].event_type, EventType::ThemeChange);

1739

        assert_eq!(events[0].target, root());

1740

1741

1742

    #[test]

1743

    fn window_mouse_enter_leave_transitions_are_exclusive() {

1744

        let inside = cursor_at(1.0, 1.0);

1745

        let outside = {

1746

            let mut s = state();

1747

            s.mouse_state.cursor_position =

1748

                CursorPosition::OutOfWindow(LogicalPosition::new(1.0, 1.0));

1749

1750

};

1751

        let uninit = state();

1752

1753

        let enter = detect_window_state_events(&inside, &uninit, ts(0));

1754

        assert_eq!(count(&enter, EventType::MouseEnter), 1);

1755

        assert_eq!(count(&enter, EventType::MouseLeave), 0);

1756

1757

        let leave = detect_window_state_events(&outside, &inside, ts(0));

1758

        assert_eq!(count(&leave, EventType::MouseLeave), 1);

1759

        assert_eq!(count(&leave, EventType::MouseEnter), 0);

1760

1761

        // OutOfWindow -> Uninitialized: neither is "in window", so nothing fires.

1762

        let neither = detect_window_state_events(&uninit, &outside, ts(0));

1763

        assert!(neither.is_empty());

1764

1765

1766

    #[test]

1767

    fn window_state_events_all_target_the_root_node() {

1768

        let mut current = cursor_at(10.0, 10.0);

1769

        current.size.dimensions = LogicalSize::new(800.0, 600.0);

1770

        current.position = WindowPosition::Initialized(PhysicalPositionI32 { x: 1, y: 2 });

1771

        current.theme = WindowTheme::DarkMode;

1772

1773

        let events = detect_window_state_events(&current, &state(), ts(7));

1774

        assert_eq!(events.len(), 4, "resize + move + theme + mouse-enter");

1775

        assert!(events.iter().all(|e| e.target == root()));

1776

        assert!(events.iter().all(|e| e.timestamp == ts(7)));

1777

        assert!(events.iter().all(|e| e.source == EventSource::User));

1778

1779

1780

    #[test]

1781

    fn min_dimensions_change_resizes_in_one_detector_but_not_the_other() {

1782

        // detect_window_state_events compares the whole WindowSize (incl. the

1783

        // min/max constraints), determine_all_events compares only `.dimensions`.

1784

        // Documenting the divergence: a min-size-only change resizes in one and

1785

        // not in the other.

1786

        let mut current = state();

1787

        current.size.min_dimensions = Some(LogicalSize::new(100.0, 100.0)).into();

1788

1789

        let differ = detect_window_state_events(&current, &state(), ts(0));

1790

        assert_eq!(count(&differ, EventType::WindowResize), 1);

1791

1792

        let all = run_plain(&current, &state());

1793

        assert_eq!(

1794

            count(&all, EventType::WindowResize),

1795

0,

1796

            "determine_all_events only diffs `size.dimensions`"

1797

);

1798

1799

1800

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

1801

    // determine_events_from_managers

1802

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

1803

1804

    #[test]

1805

    fn from_managers_no_change_no_providers_is_empty() {

1806

        let s = state();

1807

        let providers: Vec<&dyn EventProvider> = Vec::new();

1808

        assert!(determine_events_from_managers(&s, &s, &providers, ts(0)).is_empty());

1809

1810

1811

    #[test]

1812

    fn from_managers_collapses_a_flood_of_identical_events() {

1813

        let s = state();

1814

        let target = node(0, 4);

1815

        let provider = StaticProvider((0..5_000).map(|i| ev(EventType::Scroll, target, i)).collect());

1816

        let providers: Vec<&dyn EventProvider> = vec![&provider];

1817

        let events = determine_events_from_managers(&s, &s, &providers, ts(0));

1818

        assert_eq!(events.len(), 1, "same (target, type) must coalesce");

1819

        assert_eq!(events[0].event_type, EventType::Scroll);

1820

1821

1822

    #[test]

1823

    fn from_managers_dedup_keeps_the_latest_timestamp() {

1824

        let s = state();

1825

        let target = node(0, 4);

1826

        let provider = StaticProvider(vec![

1827

            ev(EventType::Scroll, target, 1),

1828

            ev(EventType::Scroll, target, 9),

1829

            ev(EventType::Scroll, target, 5),

1830

]);

1831

        let providers: Vec<&dyn EventProvider> = vec![&provider];

1832

        let events = determine_events_from_managers(&s, &s, &providers, ts(0));

1833

        assert_eq!(events.len(), 1);

1834

        assert_eq!(events[0].timestamp, ts(9));

1835

1836

1837

    #[test]

1838

    fn from_managers_dedup_survives_u64_max_timestamps() {

1839

        let s = state();

1840

        let target = node(0, 4);

1841

        let provider = StaticProvider(vec![

1842

            ev(EventType::Scroll, target, u64::MAX),

1843

            ev(EventType::Scroll, target, 0),

1844

]);

1845

        let providers: Vec<&dyn EventProvider> = vec![&provider];

1846

        let events = determine_events_from_managers(&s, &s, &providers, ts(0));

1847

        assert_eq!(events.len(), 1);

1848

        assert_eq!(events[0].timestamp, ts(u64::MAX));

1849

1850

1851

    #[test]

1852

    fn from_managers_provider_event_dedups_against_the_window_event() {

1853

        let mut current = state();

1854

        current.theme = WindowTheme::DarkMode;

1855

        // The provider claims the exact same (root, ThemeChange) slot.

1856

        let provider = StaticProvider(vec![ev(EventType::ThemeChange, root(), 3)]);

1857

        let providers: Vec<&dyn EventProvider> = vec![&provider];

1858

        let events = determine_events_from_managers(&current, &state(), &providers, ts(0));

1859

        assert_eq!(events.len(), 1);

1860

        assert_eq!(events[0].event_type, EventType::ThemeChange);

1861

        assert_eq!(events[0].timestamp, ts(3), "the later timestamp wins");

1862

1863

1864

    /// PORTED 2026-08-20 from the deleted `layout/tests/event_determination.rs`

1865

    /// (`test_determine_events_deduplicates`). That file was gated behind

1866

    /// `DISABLED_event_tests`, a feature no job enabled, and it could not have

1867

    /// compiled anyway — it glob-imported `azul_layout::event_determination::*`

1868

    /// for `EventProvider`/`SyntheticEvent`/`EventType`, which live in

1869

    /// `azul_core::events`. Its scenario lives here instead, where it runs in

1870

    /// `cargo test --lib`: TWO DISTINCT provider objects claiming the same

1871

    /// (target, event_type) slot must collapse to one event. The sibling

1872

    /// `from_managers_dedup_keeps_the_latest_timestamp` covers one provider

1873

    /// emitting duplicates; this covers the across-providers case.

1874

    #[test]

1875

    fn two_distinct_providers_colliding_on_one_slot_dedup() {

1876

        let s = state();

1877

        let a = StaticProvider(vec![ev(EventType::Input, root(), 0)]);

1878

        let b = StaticProvider(vec![ev(EventType::Input, root(), 0)]);

1879

        let providers: Vec<&dyn EventProvider> = vec![&a, &b];

1880

        let events = determine_events_from_managers(&s, &s, &providers, ts(0));

1881

        assert_eq!(events.len(), 1, "two providers, one slot: {events:?}");

1882

        assert_eq!(events[0].event_type, EventType::Input);

1883

1884

1885

    #[test]

1886

    fn from_managers_forwards_its_timestamp_to_every_provider() {

1887

        let s = state();

1888

        let provider = EchoProvider(node(0, 2));

1889

        let providers: Vec<&dyn EventProvider> = vec![&provider];

1890

        let events = determine_events_from_managers(&s, &s, &providers, ts(4242));

1891

        assert_eq!(events.len(), 1);

1892

        assert_eq!(events[0].timestamp, ts(4242));

1893

1894

1895

    #[test]

1896

    fn from_managers_many_providers_with_distinct_targets_all_survive() {

1897

        let s = state();

1898

        let owned: Vec<StaticProvider> = (0..256_usize)

1899

            .map(|i| StaticProvider(vec![ev(EventType::Scroll, node(i % 4, i), 0)]))

1900

            .collect();

1901

        let providers: Vec<&dyn EventProvider> =

1902

            owned.iter().map(|p| p as &dyn EventProvider).collect();

1903

        let events = determine_events_from_managers(&s, &s, &providers, ts(0));

1904

        assert_eq!(events.len(), 256);

1905

1906

1907

    #[test]

1908

    fn from_managers_empty_provider_lists_are_harmless() {

1909

        let s = state();

1910

        let empty = StaticProvider(Vec::new());

1911

        let providers: Vec<&dyn EventProvider> = vec![&empty, &empty, &empty];

1912

        assert!(determine_events_from_managers(&s, &s, &providers, ts(0)).is_empty());

1913

1914

1915

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

1916

    // determine_all_events - mouse buttons / bitmask

1917

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

1918

1919

    #[test]

1920

    fn all_buttons_pressed_at_once_reports_a_full_bitmask() {

1921

        let mut current = cursor_at(10.0, 10.0);

1922

        current.mouse_state.left_down = true;

1923

        current.mouse_state.right_down = true;

1924

        current.mouse_state.middle_down = true;

1925

1926

        let events = run_plain(&current, &cursor_at(10.0, 10.0));

1927

        // NOTE: the three per-button MouseDowns share (target, MouseDown), so

1928

        // deduplication collapses them into a single event - the first (Left).

1929

        let down = only(&events, EventType::MouseDown);

1930

        match down.data {

1931

            EventData::Mouse(m) => {

1932

                assert_eq!(m.buttons, 0b0000_0111, "left|right|middle bitmask");

1933

                assert_eq!(m.button, MouseButton::Left);

1934

                assert_eq!(m.position, LogicalPosition::new(10.0, 10.0));

1935

1936

            other => panic!("expected Mouse data, got {other:?}"),

1937

1938

1939

1940

    #[test]

1941

    fn releasing_every_button_clears_the_bitmask() {

1942

        let mut previous = cursor_at(10.0, 10.0);

1943

        previous.mouse_state.left_down = true;

1944

        previous.mouse_state.right_down = true;

1945

        previous.mouse_state.middle_down = true;

1946

1947

        let events = run_plain(&cursor_at(10.0, 10.0), &previous);

1948

        let up = only(&events, EventType::MouseUp);

1949

        match up.data {

1950

            EventData::Mouse(m) => assert_eq!(m.buttons, 0),

1951

            other => panic!("expected Mouse data, got {other:?}"),

1952

1953

1954

1955

    #[test]

1956

    fn mouse_events_carry_the_live_modifier_state() {

1957

        let mut current = cursor_at(0.0, 0.0);

1958

        current.keyboard_state.pressed_virtual_keycodes = VirtualKeyCodeVec::from_vec(vec![

1959

            VirtualKeyCode::LShift,

1960

            VirtualKeyCode::RControl,

1961

            VirtualKeyCode::LAlt,

1962

            VirtualKeyCode::LWin,

1963

]);

1964

        current.mouse_state.left_down = true;

1965

1966

        let events = run_plain(&current, &cursor_at(0.0, 0.0));

1967

        let down = only(&events, EventType::MouseDown);

1968

        match down.data {

1969

            EventData::Mouse(m) => {

1970

                assert!(m.modifiers.shift && m.modifiers.ctrl && m.modifiers.alt && m.modifiers.meta);

1971

1972

            other => panic!("expected Mouse data, got {other:?}"),

1973

1974

1975

1976

    #[test]

1977

    fn mouse_position_falls_back_to_origin_when_the_cursor_is_unknown() {

1978

        // cursor_position is Uninitialized -> get_position() is None -> (0,0).

1979

        let mut current = state();

1980

        current.mouse_state.left_down = true;

1981

        let events = run_plain(&current, &state());

1982

        let down = only(&events, EventType::MouseDown);

1983

        match down.data {

1984

            EventData::Mouse(m) => assert_eq!(m.position, LogicalPosition::new(0.0, 0.0)),

1985

            other => panic!("expected Mouse data, got {other:?}"),

1986

1987

1988

1989

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

1990

    // determine_all_events - wheel delta (numeric edges)

1991

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

1992

1993

    #[test]

1994

    fn wheel_delta_none_emits_no_scroll() {

1995

        let s = state();

1996

        assert_eq!(

1997

            count(&run(&s, &s, &HoverManager::new(), None, None), EventType::Scroll),

1998

1999

);

2000

2001

2002

    #[test]

2003

    fn wheel_delta_zero_emits_no_scroll() {

2004

        let s = state();

2005

        let events = run(

2006

&s,

2007

&s,

2008

            &HoverManager::new(),

2009

            None,

2010

            Some(LogicalPosition::new(0.0, 0.0)),

2011

);

2012

        assert_eq!(count(&events, EventType::Scroll), 0);

2013

2014

2015

    #[test]

2016

    fn wheel_delta_negative_zero_emits_no_scroll() {

2017

        // IEEE-754: -0.0 == 0.0, so a signed-zero delta must stay silent.

2018

        let s = state();

2019

        let events = run(

2020

&s,

2021

&s,

2022

            &HoverManager::new(),

2023

            None,

2024

            Some(LogicalPosition::new(-0.0, -0.0)),

2025

);

2026

        assert_eq!(count(&events, EventType::Scroll), 0);

2027

2028

2029

    #[test]

2030

    fn wheel_delta_nan_still_emits_a_scroll_and_forwards_the_nan() {

2031

        // NaN != 0.0 is true, so a NaN delta *does* fire. Assert it is passed

2032

        // through untouched rather than silently turning into 0.

2033

        let s = state();

2034

        let events = run(

2035

&s,

2036

&s,

2037

            &HoverManager::new(),

2038

            None,

2039

            Some(LogicalPosition::new(f32::NAN, f32::NAN)),

2040

);

2041

        let scroll = only(&events, EventType::Scroll);

2042

        match scroll.data {

2043

            EventData::Scroll(sd) => {

2044

                assert!(sd.delta.x.is_nan() && sd.delta.y.is_nan());

2045

                assert_eq!(sd.delta_mode, ScrollDeltaMode::Pixel);

2046

2047

            other => panic!("expected Scroll data, got {other:?}"),

2048

2049

2050

2051

    #[test]

2052

    fn wheel_delta_infinite_is_forwarded_without_saturation() {

2053

        let s = state();

2054

        let events = run(

2055

&s,

2056

&s,

2057

            &HoverManager::new(),

2058

            None,

2059

            Some(LogicalPosition::new(f32::INFINITY, f32::NEG_INFINITY)),

2060

);

2061

        let scroll = only(&events, EventType::Scroll);

2062

        match scroll.data {

2063

            EventData::Scroll(sd) => {

2064

                assert_eq!(sd.delta.x, f32::INFINITY);

2065

                assert_eq!(sd.delta.y, f32::NEG_INFINITY);

2066

2067

            other => panic!("expected Scroll data, got {other:?}"),

2068

2069

2070

2071

    #[test]

2072

    fn wheel_scroll_targets_the_hovered_node_not_the_root() {

2073

        let s = state();

2074

        let hm = hover_with(hits(&[(2, 6)]), hits(&[(2, 6)]));

2075

        let events = run(

2076

&s,

2077

&s,

2078

            &hm,

2079

            None,

2080

            Some(LogicalPosition::new(0.0, -120.0)),

2081

);

2082

        let scroll = only(&events, EventType::Scroll);

2083

        assert_eq!(scroll.target, node(2, 6));

2084

2085

2086

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

2087

    // determine_all_events - cursor movement + f32 quantization

2088

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

2089

2090

    #[test]

2091

    fn mouseover_ignores_sub_quantum_cursor_jitter() {

2092

        // LogicalPosition::eq quantizes to 1/1000 px: a 0.4 micro-pixel move is

2093

        // no move at all, and must not wake the whole event pipeline.

2094

        let events = run_plain(&cursor_at(100.0004, 0.0), &cursor_at(100.0, 0.0));

2095

        assert_eq!(count(&events, EventType::MouseOver), 0);

2096

2097

        let events = run_plain(&cursor_at(100.5, 0.0), &cursor_at(100.0, 0.0));

2098

        assert_eq!(count(&events, EventType::MouseOver), 1);

2099

2100

2101

    #[test]

2102

    fn mouseover_treats_saturating_far_coordinates_as_unchanged() {

2103

        // quantize() saturates on f32 -> i64: 1e30 and f32::MAX both land on

2104

        // i64::MAX, so this "move" is invisible to the comparison. Deterministic

2105

        // and panic-free is what matters here.

2106

        let events = run_plain(&cursor_at(1e30, 0.0), &cursor_at(f32::MAX, 0.0));

2107

        assert!(events.is_empty(), "got {events:?}");

2108

2109

2110

    #[test]

2111

    fn mouseover_nan_cursor_positions_do_not_panic_or_thrash() {

2112

        let events = run_plain(&cursor_at(f32::NAN, f32::NAN), &cursor_at(f32::NAN, f32::NAN));

2113

        assert_eq!(

2114

            count(&events, EventType::MouseOver),

2115

0,

2116

            "a NaN cursor stuck in place must not fire MouseOver every frame"

2117

);

2118

2119

        // NaN -> real coordinate is a genuine move.

2120

        let events = run_plain(&cursor_at(5.0, 5.0), &cursor_at(f32::NAN, f32::NAN));

2121

        assert_eq!(count(&events, EventType::MouseOver), 1);

2122

2123

2124

    #[test]

2125

    fn mouseover_never_fires_while_the_cursor_is_outside_the_window() {

2126

        let mut current = state();

2127

        current.mouse_state.cursor_position =

2128

            CursorPosition::OutOfWindow(LogicalPosition::new(9.0, 9.0));

2129

        let events = run_plain(&current, &state());

2130

        assert_eq!(count(&events, EventType::MouseOver), 0);

2131

2132

2133

    #[test]

2134

    fn entering_the_window_emits_mouse_enter_at_the_root() {

2135

        let events = run_plain(&cursor_at(3.0, 3.0), &state());

2136

        let enter = only(&events, EventType::MouseEnter);

2137

        assert_eq!(enter.target, root());

2138

        // Uninitialized -> InWindow is also a position change.

2139

        assert_eq!(count(&events, EventType::MouseOver), 1);

2140

2141

2142

    #[test]

2143

    fn leaving_the_window_emits_mouse_leave_at_the_root() {

2144

        let mut current = state();

2145

        current.mouse_state.cursor_position =

2146

            CursorPosition::OutOfWindow(LogicalPosition::new(3.0, 3.0));

2147

        let events = run_plain(&current, &cursor_at(3.0, 3.0));

2148

        let leave = only(&events, EventType::MouseLeave);

2149

        assert_eq!(leave.target, root());

2150

2151

2152

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

2153

    // determine_all_events - per-node hover chain (W3C enter/leave)

2154

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

2155

2156

    #[test]

2157

    fn hover_chain_diff_emits_leave_for_lost_and_enter_for_gained_nodes() {

2158

        let s = state();

2159

        let hm = hover_with(hits(&[(0, 1), (0, 3)]), hits(&[(0, 1), (0, 5)]));

2160

        let events = run(&s, &s, &hm, None, None);

2161

2162

        let leave = only(&events, EventType::MouseLeave);

2163

        assert_eq!(leave.target, node(0, 3));

2164

        let enter = only(&events, EventType::MouseEnter);

2165

        assert_eq!(enter.target, node(0, 5));

2166

        // Node 1 stayed hovered -> no event for it.

2167

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

2168

2169

2170

    #[test]

2171

    fn hover_chain_diff_spans_child_doms() {

2172

        let s = state();

2173

        let hm = hover_with(FullHitTest::empty(None), hits(&[(0, 1), (9, 2)]));

2174

        let events = run(&s, &s, &hm, None, None);

2175

        assert_eq!(count(&events, EventType::MouseEnter), 2);

2176

        assert!(events.iter().any(|e| e.target == node(9, 2)));

2177

        assert!(events.iter().any(|e| e.target == node(0, 1)));

2178

2179

2180

    #[test]

2181

    fn hover_chain_enter_targets_round_trip_through_the_1_based_encoding() {

2182

        // NodeHierarchyItemId stores `index + 1`; make sure the edge indices

2183

        // survive the encode/decode round-trip in the emitted target.

2184

        for id in [0_usize, 1, 12_345, usize::MAX - 1] {

2185

            let s = state();

2186

            let hm = hover_with(FullHitTest::empty(None), hits(&[(0, id)]));

2187

            let events = run(&s, &s, &hm, None, None);

2188

            let enter = only(&events, EventType::MouseEnter);

2189

            assert_eq!(

2190

                enter.target.node.into_crate_internal(),

2191

                Some(NodeId::new(id)),

2192

                "target NodeId must decode back to {id}"

2193

);

2194

2195

2196

2197

    #[test]

2198

    fn node_level_and_window_level_enter_collapse_at_the_root() {

2199

        // Node 0 of DOM 0 *is* the root target, so its per-node MouseEnter and

2200

        // the window-level MouseEnter share a dedup slot.

2201

        let hm = hover_with(FullHitTest::empty(None), hits(&[(0, 0)]));

2202

        let events = run(&cursor_at(1.0, 1.0), &state(), &hm, None, None);

2203

        assert_eq!(count(&events, EventType::MouseEnter), 1);

2204

2205

2206

    #[test]

2207

    fn an_unchanged_hover_chain_emits_no_enter_or_leave() {

2208

        let s = state();

2209

        let hm = hover_with(hits(&[(0, 1), (4, 2)]), hits(&[(0, 1), (4, 2)]));

2210

        let events = run(&s, &s, &hm, None, None);

2211

        assert!(events.is_empty(), "got {events:?}");

2212

2213

2214

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

2215

    // determine_all_events - click synthesis

2216

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

2217

2218

    #[test]

2219

    fn click_is_synthesized_when_release_lands_on_the_press_node() {

2220

        let mut previous = cursor_at(20.0, 20.0);

2221

        previous.mouse_state.left_down = true;

2222

        let hm = hover_with(hits(&[(0, 8)]), hits(&[(0, 8)]));

2223

2224

        let events = run(&cursor_at(20.0, 20.0), &previous, &hm, None, None);

2225

        let click = only(&events, EventType::Click);

2226

        assert_eq!(click.target, node(0, 8));

2227

        assert_eq!(count(&events, EventType::MouseUp), 1);

2228

2229

2230

    #[test]

2231

    fn no_click_when_the_hover_node_changed_between_press_and_release() {

2232

        let mut previous = cursor_at(20.0, 20.0);

2233

        previous.mouse_state.left_down = true;

2234

        let hm = hover_with(hits(&[(0, 3)]), hits(&[(0, 5)]));

2235

2236

        let events = run(&cursor_at(20.0, 20.0), &previous, &hm, None, None);

2237

        assert_eq!(count(&events, EventType::Click), 0);

2238

2239

2240

    #[test]

2241

    fn no_click_when_nothing_is_hovered() {

2242

        let mut previous = cursor_at(20.0, 20.0);

2243

        previous.mouse_state.left_down = true;

2244

        // Empty hover manager: prev == curr == None, but None is not a node.

2245

        let events = run_plain(&cursor_at(20.0, 20.0), &previous);

2246

        assert_eq!(count(&events, EventType::Click), 0);

2247

        assert_eq!(count(&events, EventType::MouseUp), 1);

2248

2249

2250

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

2251

    // determine_all_events - keyboard

2252

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

2253

2254

    #[test]

2255

    fn keyboard_events_target_the_focused_node() {

2256

        let mut current = state();

2257

        current.keyboard_state.current_virtual_keycode =

2258

            OptionVirtualKeyCode::Some(VirtualKeyCode::A);

2259

        let mut focus = FocusManager::new();

2260

        focus.set_focused_node(Some(node(3, 11)));

2261

2262

        let hover = HoverManager::new();

2263

        let file_drop = FileDropManager::new();

2264

        let providers: Vec<&dyn EventProvider> = Vec::new();

2265

        let events = determine_all_events(

2266

            &current,

2267

            &state(),

2268

            &hover,

2269

            &focus,

2270

            &file_drop,

2271

            None,

2272

            &providers,

2273

            None,

2274

            ts(0),

2275

);

2276

        let down = only(&events, EventType::KeyDown);

2277

        assert_eq!(down.target, node(3, 11));

2278

2279

2280

    #[test]

2281

    fn keyup_reports_the_previous_keycode_not_zero() {

2282

        let mut previous = state();

2283

        previous.keyboard_state.current_virtual_keycode =

2284

            OptionVirtualKeyCode::Some(VirtualKeyCode::F12);

2285

        let events = run_plain(&state(), &previous);

2286

        let up = only(&events, EventType::KeyUp);

2287

        match up.data {

2288

            EventData::Keyboard(k) => {

2289

                assert_eq!(k.key_code, VirtualKeyCode::F12 as u32);

2290

                assert!(!k.repeat);

2291

                assert!(k.char_code.is_none());

2292

2293

            other => panic!("expected Keyboard data, got {other:?}"),

2294

2295

2296

2297

    #[test]

2298

    fn no_keyboard_events_when_no_key_is_involved() {

2299

        let s = state();

2300

        let events = run_plain(&s, &s);

2301

        assert_eq!(count(&events, EventType::KeyDown), 0);

2302

        assert_eq!(count(&events, EventType::KeyUp), 0);

2303

2304

2305

    #[test]

2306

    fn swapping_keys_in_one_frame_emits_keydown_but_no_keyup() {

2307

        // Documented behaviour: KeyUp only fires on Some -> None. A direct

2308

        // A -> B swap therefore emits KeyDown(B) and *drops* the KeyUp(A).

2309

        let mut current = state();

2310

        current.keyboard_state.current_virtual_keycode =

2311

            OptionVirtualKeyCode::Some(VirtualKeyCode::B);

2312

        let mut previous = state();

2313

        previous.keyboard_state.current_virtual_keycode =

2314

            OptionVirtualKeyCode::Some(VirtualKeyCode::A);

2315

2316

        let events = run_plain(&current, &previous);

2317

        assert_eq!(count(&events, EventType::KeyDown), 1);

2318

        assert_eq!(count(&events, EventType::KeyUp), 0);

2319

2320

2321

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

2322

    // determine_all_events - window state

2323

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

2324

2325

    #[test]

2326

    fn dpi_change_emits_a_dpi_event_at_the_u32_extremes() {

2327

        let mut current = state();

2328

        current.size.dpi = u32::MAX;

2329

        let mut previous = state();

2330

        previous.size.dpi = 0;

2331

2332

        let events = run_plain(&current, &previous);

2333

        assert_eq!(count(&events, EventType::WindowDpiChanged), 1);

2334

        assert_eq!(count(&events, EventType::WindowResize), 0);

2335

2336

2337

    #[test]

2338

    fn monitor_change_needs_a_known_monitor_on_both_sides() {

2339

        let mut current = state();

2340

        current.monitor_id = OptionU32::Some(2);

2341

2342

        // None -> Some(2): the window learned its monitor, that is not a move.

2343

        let events = run_plain(&current, &state());

2344

        assert_eq!(count(&events, EventType::WindowMonitorChanged), 0);

2345

2346

        let mut previous = state();

2347

        previous.monitor_id = OptionU32::Some(1);

2348

        let events = run_plain(&current, &previous);

2349

        assert_eq!(count(&events, EventType::WindowMonitorChanged), 1);

2350

2351

        // Some(u32::MAX) -> None: still not a monitor change.

2352

        let mut max = state();

2353

        max.monitor_id = OptionU32::Some(u32::MAX);

2354

        let events = run_plain(&state(), &max);

2355

        assert_eq!(count(&events, EventType::WindowMonitorChanged), 0);

2356

2357

2358

    /// A maximize / restore / minimize / fullscreen transition must reach the

2359

    /// app. Nothing derived an event from `flags.frame` before, so no callback

2360

    /// could observe one — while two backends carried comments claiming they

2361

    /// could.

2362

    #[test]

2363

    fn a_frame_transition_emits_exactly_one_event_per_change() {

2364

        use azul_core::window::WindowFrame;

2365

2366

        let normal = state();

2367

        let mut maximized = state();

2368

        maximized.flags.frame = WindowFrame::Maximized;

2369

2370

        let events = run_plain(&maximized, &normal);

2371

        assert_eq!(count(&events, EventType::WindowFrameChanged), 1);

2372

2373

        // Still maximized on the next frame -> no repeat.

2374

        let events = run_plain(&maximized, &maximized.clone());

2375

        assert_eq!(count(&events, EventType::WindowFrameChanged), 0);

2376

2377

        // And back again is its own transition.

2378

        let events = run_plain(&normal, &maximized);

2379

        assert_eq!(count(&events, EventType::WindowFrameChanged), 1);

2380

2381

        // Every distinct frame reachable from Normal is a transition.

2382

        for frame in [

2383

            WindowFrame::Minimized,

2384

            WindowFrame::Maximized,

2385

            WindowFrame::Fullscreen,

2386

] {

2387

            let mut to = state();

2388

            to.flags.frame = frame;

2389

            assert_eq!(

2390

                count(&run_plain(&to, &normal), EventType::WindowFrameChanged),

2391

1,

2392

                "Normal -> {frame:?} must be one event"

2393

);

2394

2395

2396

2397

    #[test]

2398

    fn close_request_emits_window_close_once() {

2399

        let mut current = state();

2400

        current.flags.close_requested = true;

2401

        let events = run_plain(&current, &state());

2402

        assert_eq!(count(&events, EventType::WindowClose), 1);

2403

        // Still requested on the next frame -> no repeat.

2404

        let events = run_plain(&current, &current.clone());

2405

        assert_eq!(count(&events, EventType::WindowClose), 0);

2406

2407

2408

    #[test]

2409

    fn window_focus_transitions_emit_focus_in_and_out() {

2410

        let unfocused = {

2411

            let mut s = state();

2412

            s.window_focused = false;

2413

2414

};

2415

        let events = run_plain(&unfocused, &state());

2416

        assert_eq!(count(&events, EventType::WindowFocusOut), 1);

2417

2418

        let events = run_plain(&state(), &unfocused);

2419

        assert_eq!(count(&events, EventType::WindowFocusIn), 1);

2420

2421

2422

    #[test]

2423

    fn determine_all_events_ignores_relative_child_window_moves() {

2424

        // Divergence from detect_window_state_events, which *does* report it.

2425

        let mut current = state();

2426

        current.position =

2427

            WindowPosition::RelativeToParentWindow(PhysicalPositionI32 { x: 4, y: 4 });

2428

        let events = run_plain(&current, &state());

2429

        assert_eq!(count(&events, EventType::WindowMove), 0);

2430

2431

2432

    #[test]

2433

    fn determine_all_events_accepts_a_u64_max_timestamp() {

2434

        let mut current = state();

2435

        current.theme = WindowTheme::DarkMode;

2436

        let hover = HoverManager::new();

2437

        let focus = FocusManager::new();

2438

        let file_drop = FileDropManager::new();

2439

        let providers: Vec<&dyn EventProvider> = Vec::new();

2440

        let events = determine_all_events(

2441

            &current,

2442

            &state(),

2443

            &hover,

2444

            &focus,

2445

            &file_drop,

2446

            None,

2447

            &providers,

2448

            None,

2449

            ts(u64::MAX),

2450

);

2451

        let theme = only(&events, EventType::ThemeChange);

2452

        assert_eq!(theme.timestamp, ts(u64::MAX));

2453

2454

2455

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

2456

    // determine_all_events - file drop

2457

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

2458

2459

    fn run_with_file_drop(file_drop: &FileDropManager) -> Vec<SyntheticEvent> {

2460

        let s = state();

2461

        let hover = HoverManager::new();

2462

        let focus = FocusManager::new();

2463

        let providers: Vec<&dyn EventProvider> = Vec::new();

2464

        determine_all_events(

2465

&s,

2466

&s,

2467

            &hover,

2468

            &focus,

2469

            file_drop,

2470

            None,

2471

            &providers,

2472

            None,

2473

            ts(0),

2474

2475

2476

2477

    #[test]

2478

    fn hovering_a_file_emits_file_hover_and_suppresses_the_cancel() {

2479

        let mut fd = FileDropManager::new();

2480

        fd.set_hovered_file(Some(AzString::from(String::from("/tmp/a.png"))));

2481

        fd.set_hovered_file(None); // latches hover_cancelled

2482

        fd.set_hovered_file(Some(AzString::from(String::from("/tmp/b.png"))));

2483

        assert!(fd.hover_was_cancelled(), "flag is still latched");

2484

2485

        let events = run_with_file_drop(&fd);

2486

        assert_eq!(count(&events, EventType::FileHover), 1);

2487

        assert_eq!(

2488

            count(&events, EventType::FileHoverCancel),

2489

0,

2490

            "an active hover must win over the stale cancel flag"

2491

);

2492

2493

2494

    #[test]

2495

    fn a_cancelled_hover_emits_file_hover_cancel() {

2496

        let mut fd = FileDropManager::new();

2497

        fd.set_hovered_file(Some(AzString::from(String::from("/tmp/a.png"))));

2498

        fd.set_hovered_file(None);

2499

2500

        let events = run_with_file_drop(&fd);

2501

        assert_eq!(count(&events, EventType::FileHoverCancel), 1);

2502

        assert_eq!(count(&events, EventType::FileHover), 0);

2503

2504

2505

    #[test]

2506

    fn an_empty_path_still_counts_as_a_hovered_file() {

2507

        let mut fd = FileDropManager::new();

2508

        fd.set_hovered_file(Some(AzString::from(String::new())));

2509

        let events = run_with_file_drop(&fd);

2510

        assert_eq!(count(&events, EventType::FileHover), 1);

2511

2512

2513

    #[test]

2514

    fn pathological_file_paths_do_not_panic() {

2515

        // 256 KiB of text, an interior NUL, an RTL override and astral-plane

2516

        // codepoints - the event pass must not touch the bytes at all.

2517

        let mut path = "\u{202e}🎉\u{0}".repeat(4);

2518

        path.push_str(&"ß".repeat(256 * 1024));

2519

        let mut fd = FileDropManager::new();

2520

        fd.set_dropped_file(Some(AzString::from(path)));

2521

        fd.set_hovered_file(Some(AzString::from(String::from("\u{feff}"))));

2522

2523

        let events = run_with_file_drop(&fd);

2524

        assert_eq!(count(&events, EventType::FileDrop), 1);

2525

        assert_eq!(count(&events, EventType::FileHover), 1);

2526

2527

2528

    #[test]

2529

    fn a_multi_file_drop_still_emits_exactly_one_file_drop_event() {

2530

        let mut fd = FileDropManager::new();

2531

        fd.set_dropped_files(

2532

            (0..1000)

2533

                .map(|i| AzString::from(format!("/tmp/{i}.bin")))

2534

                .collect(),

2535

);

2536

        let events = run_with_file_drop(&fd);

2537

        assert_eq!(count(&events, EventType::FileDrop), 1);

2538

2539

2540

    #[test]

2541

    fn file_events_target_the_hovered_node() {

2542

        let s = state();

2543

        let hover = hover_with(hits(&[(1, 4)]), hits(&[(1, 4)]));

2544

        let focus = FocusManager::new();

2545

        let mut fd = FileDropManager::new();

2546

        fd.set_dropped_file(Some(AzString::from(String::from("/tmp/x"))));

2547

        let providers: Vec<&dyn EventProvider> = Vec::new();

2548

        let events = determine_all_events(

2549

            &s, &s, &hover, &focus, &fd, None, &providers, None, ts(0),

2550

);

2551

        let drop = only(&events, EventType::FileDrop);

2552

        assert_eq!(drop.target, node(1, 4));

2553

2554

2555

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

2556

    // determine_all_events - gestures (native injection)

2557

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

2558

2559

    fn pinch(scale: f32) -> GestureAndDragManager {

2560

        let mut g = GestureAndDragManager::new();

2561

        g.inject_native_gesture(NativeGestureEvent::Pinch(DetectedPinch {

2562

            scale,

2563

            center: LogicalPosition::new(0.0, 0.0),

2564

            initial_distance: 0.0,

2565

            current_distance: 0.0,

2566

            duration_ms: 0,

2567

        }));

2568

2569

2570

2571

    fn rotation(angle_radians: f32) -> GestureAndDragManager {

2572

        let mut g = GestureAndDragManager::new();

2573

        g.inject_native_gesture(NativeGestureEvent::Rotation(DetectedRotation {

2574

            angle_radians,

2575

            center: LogicalPosition::new(0.0, 0.0),

2576

            duration_ms: 0,

2577

        }));

2578

2579

2580

2581

    #[test]

2582

    fn pinch_scale_below_one_is_pinch_in_at_and_above_one_is_pinch_out() {

2583

        let s = state();

2584

        for (scale, expected) in [

2585

            (0.0_f32, EventType::PinchIn),

2586

            (0.999_999, EventType::PinchIn),

2587

            (f32::NEG_INFINITY, EventType::PinchIn),

2588

            (1.0, EventType::PinchOut),

2589

            (1.000_001, EventType::PinchOut),

2590

            (f32::INFINITY, EventType::PinchOut),

2591

] {

2592

            let g = pinch(scale);

2593

            let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2594

            assert_eq!(count(&events, expected), 1, "scale {scale} -> {expected:?}");

2595

2596

2597

2598

    #[test]

2599

    fn pinch_scale_nan_is_deterministic_and_does_not_panic() {

2600

        // `pinch.scale < 1.0` is false for NaN, so NaN classifies as PinchOut.

2601

        // The point is that it is *deterministic* and never panics.

2602

        let s = state();

2603

        let g = pinch(f32::NAN);

2604

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2605

        assert_eq!(count(&events, EventType::PinchOut), 1);

2606

        assert_eq!(count(&events, EventType::PinchIn), 0);

2607

2608

2609

    #[test]

2610

    fn rotation_sign_selects_the_direction_including_signed_zero_and_nan() {

2611

        let s = state();

2612

        for (angle, expected) in [

2613

            (0.1_f32, EventType::RotateClockwise),

2614

            (f32::INFINITY, EventType::RotateClockwise),

2615

            (-0.1, EventType::RotateCounterClockwise),

2616

            (0.0, EventType::RotateCounterClockwise),

2617

            (-0.0, EventType::RotateCounterClockwise),

2618

            (f32::NAN, EventType::RotateCounterClockwise),

2619

            (f32::NEG_INFINITY, EventType::RotateCounterClockwise),

2620

] {

2621

            let g = rotation(angle);

2622

            let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2623

            assert_eq!(count(&events, expected), 1, "angle {angle} -> {expected:?}");

2624

2625

2626

2627

    #[test]

2628

    fn every_swipe_direction_maps_to_its_own_event_type() {

2629

        let s = state();

2630

        for (dir, expected) in [

2631

            (GestureDirection::Left, EventType::SwipeLeft),

2632

            (GestureDirection::Right, EventType::SwipeRight),

2633

            (GestureDirection::Up, EventType::SwipeUp),

2634

            (GestureDirection::Down, EventType::SwipeDown),

2635

] {

2636

            let mut g = GestureAndDragManager::new();

2637

            g.inject_native_gesture(NativeGestureEvent::Swipe(dir));

2638

            let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2639

            assert_eq!(count(&events, expected), 1, "{dir:?} -> {expected:?}");

2640

            assert_eq!(events.len(), 1);

2641

2642

2643

2644

    #[test]

2645

    fn long_press_is_suppressed_once_the_callback_ran() {

2646

        let s = state();

2647

        for (invoked, expected) in [(false, 1_usize), (true, 0)] {

2648

            let mut g = GestureAndDragManager::new();

2649

            g.inject_native_gesture(NativeGestureEvent::LongPress(DetectedLongPress {

2650

                position: LogicalPosition::new(1.0, 1.0),

2651

                duration_ms: u64::MAX,

2652

                callback_invoked: invoked,

2653

                session_id: 0,

2654

            }));

2655

            let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2656

            assert_eq!(count(&events, EventType::LongPress), expected);

2657

2658

2659

2660

    #[test]

2661

    fn a_double_click_fires_exactly_one_event() {

2662

        let s = state();

2663

        let mut g = GestureAndDragManager::new();

2664

        g.inject_native_gesture(NativeGestureEvent::DoubleClick);

2665

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2666

        assert_eq!(count(&events, EventType::DoubleClick), 1);

2667

2668

2669

    #[test]

2670

    fn a_fresh_gesture_manager_produces_no_gesture_events() {

2671

        let s = state();

2672

        let g = GestureAndDragManager::new();

2673

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2674

        assert!(events.is_empty(), "got {events:?}");

2675

2676

2677

    #[test]

2678

    fn gesture_events_target_the_hovered_node() {

2679

        let s = state();

2680

        let hm = hover_with(hits(&[(3, 12)]), hits(&[(3, 12)]));

2681

        let g = pinch(0.5);

2682

        let events = run(&s, &s, &hm, Some(&g), None);

2683

        let e = only(&events, EventType::PinchIn);

2684

        assert_eq!(e.target, node(3, 12));

2685

2686

2687

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

2688

    // determine_all_events - pen / stylus diffing

2689

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

2690

2691

    #[test]

2692

    fn pen_events_require_the_pending_flag() {

2693

        let s = state();

2694

        let mut g = GestureAndDragManager::new();

2695

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 0.5, (0.0, 0.0), true, false, false, 1);

2696

        g.clear_pen_event_pending();

2697

2698

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2699

        assert_eq!(count(&events, EventType::PenEnter), 0);

2700

        assert_eq!(count(&events, EventType::PenDown), 0);

2701

2702

2703

    #[test]

2704

    fn pen_entering_proximity_emits_pen_enter() {

2705

        let s = state();

2706

        let mut g = GestureAndDragManager::new();

2707

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 0.0, (0.0, 0.0), false, false, false, 1);

2708

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2709

        assert_eq!(count(&events, EventType::PenEnter), 1);

2710

        assert_eq!(count(&events, EventType::PenLeave), 0);

2711

2712

2713

    #[test]

2714

    fn pen_leaving_proximity_emits_pen_leave() {

2715

        let s = state();

2716

        let mut g = GestureAndDragManager::new();

2717

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 0.0, (0.0, 0.0), false, false, false, 1);

2718

        g.clear_pen_state();

2719

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2720

        assert_eq!(count(&events, EventType::PenLeave), 1);

2721

        assert_eq!(count(&events, EventType::PenEnter), 0);

2722

2723

2724

    #[test]

2725

    fn pen_contact_transitions_emit_pen_down_then_pen_up() {

2726

        let s = state();

2727

        let mut g = GestureAndDragManager::new();

2728

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 0.0, (0.0, 0.0), false, false, false, 1);

2729

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 1.0, (0.0, 0.0), true, false, false, 1);

2730

        let down = run(&s, &s, &HoverManager::new(), Some(&g), None);

2731

        assert_eq!(count(&down, EventType::PenDown), 1);

2732

        assert_eq!(count(&down, EventType::PenMove), 0, "position did not change");

2733

2734

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 0.0, (0.0, 0.0), false, false, false, 1);

2735

        let up = run(&s, &s, &HoverManager::new(), Some(&g), None);

2736

        assert_eq!(count(&up, EventType::PenUp), 1);

2737

        assert_eq!(count(&up, EventType::PenDown), 0);

2738

2739

2740

    #[test]

2741

    fn pen_movement_emits_pen_move() {

2742

        let s = state();

2743

        let mut g = GestureAndDragManager::new();

2744

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 1.0, (0.0, 0.0), true, false, false, 1);

2745

        g.update_pen_state(LogicalPosition::new(40.0, 90.0), 1.0, (0.0, 0.0), true, false, false, 1);

2746

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2747

        assert_eq!(count(&events, EventType::PenMove), 1);

2748

2749

2750

    #[test]

2751

    fn a_pen_stuck_at_nan_does_not_emit_a_phantom_pen_move() {

2752

        // LogicalPosition::eq quantizes NaN to a single sentinel, so NaN == NaN

2753

        // and a stuck-at-NaN pen must stay quiet instead of firing every frame.

2754

        let s = state();

2755

        let mut g = GestureAndDragManager::new();

2756

        let nan = LogicalPosition::new(f32::NAN, f32::NAN);

2757

        g.update_pen_state(nan, 1.0, (f32::NAN, f32::NAN), true, false, false, 1);

2758

        g.update_pen_state(nan, 1.0, (f32::NAN, f32::NAN), true, false, false, 1);

2759

        let events = run(&s, &s, &HoverManager::new(), Some(&g), None);

2760

        assert_eq!(count(&events, EventType::PenMove), 0);

2761

        assert!(events.is_empty(), "got {events:?}");

2762

2763

2764

    #[test]

2765

    fn a_pen_in_contact_emits_touch_move_when_the_cursor_moves() {

2766

        let mut g = GestureAndDragManager::new();

2767

        g.update_pen_state(LogicalPosition::new(1.0, 1.0), 1.0, (0.0, 0.0), true, false, false, 1);

2768

        g.clear_pen_event_pending(); // isolate the TouchMove path from PenEnter

2769

2770

        let events = run(

2771

            &cursor_at(50.0, 50.0),

2772

            &cursor_at(10.0, 10.0),

2773

            &HoverManager::new(),

2774

            Some(&g),

2775

            None,

2776

);

2777

        assert_eq!(count(&events, EventType::TouchMove), 1);

2778

2779

2780

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

2781

    // determine_all_events - manager providers + dedup

2782

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

2783

2784

    #[test]

2785

    fn provider_events_are_appended_and_deduplicated() {

2786

        let s = state();

2787

        let hover = HoverManager::new();

2788

        let focus = FocusManager::new();

2789

        let file_drop = FileDropManager::new();

2790

        let target = node(0, 42);

2791

        let provider = StaticProvider(vec![

2792

            ev(EventType::Scroll, target, 2),

2793

            ev(EventType::Scroll, target, 8),

2794

            ev(EventType::KeyDown, target, 1),

2795

]);

2796

        let providers: Vec<&dyn EventProvider> = vec![&provider];

2797

2798

        let events = determine_all_events(

2799

&s,

2800

&s,

2801

            &hover,

2802

            &focus,

2803

            &file_drop,

2804

            None,

2805

            &providers,

2806

            None,

2807

            ts(0),

2808

);

2809

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

2810

        assert_eq!(only(&events, EventType::Scroll).timestamp, ts(8));

2811

2812

2813

    #[test]

2814

    fn a_provider_can_collide_with_a_wheel_scroll_on_the_same_node() {

2815

        let s = state();

2816

        let hover = HoverManager::new();

2817

        let focus = FocusManager::new();

2818

        let file_drop = FileDropManager::new();

2819

        // Same (root, Scroll) slot as the wheel-generated event.

2820

        let provider = StaticProvider(vec![ev(EventType::Scroll, root(), u64::MAX)]);

2821

        let providers: Vec<&dyn EventProvider> = vec![&provider];

2822

2823

        let events = determine_all_events(

2824

&s,

2825

&s,

2826

            &hover,

2827

            &focus,

2828

            &file_drop,

2829

            None,

2830

            &providers,

2831

            Some(LogicalPosition::new(0.0, -1.0)),

2832

            ts(0),

2833

);

2834

        assert_eq!(count(&events, EventType::Scroll), 1);

2835

        assert_eq!(

2836

            events[0].timestamp,

2837

            ts(u64::MAX),

2838

            "dedup keeps the later timestamp"

2839

);

2840

2841

2842

    #[test]

2843

    fn a_completely_idle_frame_produces_nothing() {

2844

        let s = state();

2845

        let g = GestureAndDragManager::new();

2846

        let hover = HoverManager::new();

2847

        let focus = FocusManager::new();

2848

        let file_drop = FileDropManager::new();

2849

        let empty = StaticProvider(Vec::new());

2850

        let providers: Vec<&dyn EventProvider> = vec![&empty];

2851

        let events = determine_all_events(

2852

&s,

2853

&s,

2854

            &hover,

2855

            &focus,

2856

            &file_drop,

2857

            Some(&g),

2858

            &providers,

2859

            None,

2860

            ts(0),

2861

);

2862

        assert!(events.is_empty(), "got {events:?}");

2863

2864