pointer_dispatch.hpp

Go to the documentation of this file.

#pragma once
 
// Platform-agnostic pointer routing shared by the window hosts.
//
// The coordinate walk and the context-menu lookup used to live inside the macOS
// hosts, which meant they could only be exercised by running a real NSView. They
// are pure view-tree logic, so they live here and each platform host calls in.
 
// Re-exported, not used here: this is an installed public header, and a
// consumer reaching the overlay-dismissal verbs through it keeps compiling.
// IWYU pragma: export
#include <pulp/view/overlay_dismissal.hpp>
#include <pulp/view/view.hpp>
 
#include <cstdint>
#include <functional>
#include <string>
 
namespace pulp::view {

Point point_to_local(Point root_pos, View* target, View* root);

void dispatch_dom_pointer_event(View& root, View* target,
                                const MouseEvent& event, bool moving,
                                bool bubble = true);

bool dispatch_context_menu(View& root, Point root_pos);

bool dispatch_context_menu(View& root, View* target, Point root_pos);

bool should_yield_to_gesture(View& root, const MouseEvent& event);

bool yield_to_gesture_with_handoff(View& root, View*& drag_target,
                                   const MouseEvent& event,
                                   int click_count = 1);

bool transfer_input_focus(View& root, View* target);

View* focused_input_under_root(View& root);

struct PointerAttributes {
    PointerType type = PointerType::mouse;
    float pressure = 0.5f;  
    int pointer_id = 0;
    float altitude_angle = 0.0f;  
    float azimuth_angle = 0.0f;   
    float movement_x = 0.0f;     
    float movement_y = 0.0f;     
    bool has_movement_delta = false;  
};

void deliver_mouse_drag(View& root, View* target, Point root_pt,
                        uint16_t modifiers, int click_count = 1,
                        PointerType pointer_type = PointerType::mouse,
                        float pressure = 0.5f);

void deliver_mouse_drag(View& root, View* target, Point root_pt,
                        uint16_t modifiers, int click_count,
                        PointerType pointer_type, float pressure,
                        MouseButton button);

void deliver_mouse_drag(View& root, View* target, Point root_pt,
                        uint16_t modifiers, int click_count,
                        MouseButton button, const PointerAttributes& pointer);

void deliver_hover_move(View& root, Point root_pt, uint16_t modifiers = 0);

void deliver_hover_move(View& root, Point root_pt, uint16_t modifiers,
                        const PointerAttributes& pointer);

struct WheelHost {
    std::function<void()> request_repaint;
};

void deliver_mouse_wheel(View& root, Point root_pt,
                         float scroll_delta_x, float scroll_delta_y,
                         const WheelHost& host);

void deliver_mouse_wheel(View& root, Point root_pt,
                         float scroll_delta_x, float scroll_delta_y,
                         uint16_t modifiers, const WheelHost& host);

bool deliver_mouse_down(View& root, View* target, Point root_pt,
                        uint16_t modifiers, int click_count = 1,
                        bool bubble = true);

bool deliver_mouse_down(View& root, View* target, Point root_pt,
                        uint16_t modifiers, int click_count, bool bubble,
                        MouseButton button);

struct MouseDownHost {
    std::function<bool()> should_continue;
};

bool deliver_mouse_down(View& root, View* target, Point root_pt,
                        uint16_t modifiers, int click_count, bool bubble,
                        MouseButton button, const MouseDownHost& host);

bool deliver_mouse_down(View& root, View* target, Point root_pt,
                        uint16_t modifiers, int click_count, bool bubble,
                        MouseButton button, const MouseDownHost& host,
                        const PointerAttributes& pointer);

struct MouseUpHost {
    std::function<void(const std::function<void()>& click_handler,
                       const std::string& clicked_id,
                       uint16_t modifiers)>
        fire_click;
};

void deliver_mouse_up(View& root, View* target, Point root_pt,
                      uint16_t modifiers, int click_count,
                      const MouseUpHost& host);

void deliver_mouse_up(View& root, View* target, Point root_pt,
                      uint16_t modifiers, int click_count,
                      const MouseUpHost& host, MouseButton button);

void deliver_mouse_up(View& root, View* target, Point root_pt,
                      uint16_t modifiers, int click_count,
                      const MouseUpHost& host, MouseButton button,
                      const PointerAttributes& pointer);

void deliver_mouse_cancel(View& root, View* target, Point root_pt,
                          uint16_t modifiers, int click_count,
                          MouseButton button,
                          const PointerAttributes& pointer = {});

void deliver_gesture_handoff(View& root, View* target, Point root_pt,
                             uint16_t modifiers, int click_count);
 
}  // namespace pulp::view