web_event_translate.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/input_events.hpp>
#include <pulp/view/overlay_dismissal.hpp>
#include <pulp/view/pointer_dispatch.hpp>
#include <pulp/view/ui_components.hpp>
#include <pulp/view/view.hpp>
#include <pulp/view/window_host.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
 
namespace pulp::view::web {
 
// ── Coordinate mapping ──────────────────────────────────────────────────────

struct ViewportMapping {
    float css_width = 0;
    float css_height = 0;
    float design_width = 0;
    float design_height = 0;
    bool top_align = false;
 
    bool has_design_viewport() const {
        return design_width > 0.0f && design_height > 0.0f &&
               css_width > 0.0f && css_height > 0.0f;
    }

    bool transform(float& sx, float& sy, float& tx, float& ty) const {
        if (!has_design_viewport()) return false;
        return WindowHost::compute_design_viewport_transform(
            css_width, css_height, design_width, design_height, sx, sy, tx, ty,
            top_align);
    }
};

inline Point css_to_root(const ViewportMapping& mapping, Point css) {
    float sx = 1, sy = 1, tx = 0, ty = 0;
    if (!mapping.transform(sx, sy, tx, ty) || sx <= 0.0f || sy <= 0.0f)
        return css;
    return {(css.x - tx) / sx, (css.y - ty) / sy};
}

inline Point root_to_css(const ViewportMapping& mapping, Point root) {
    float sx = 1, sy = 1, tx = 0, ty = 0;
    if (!mapping.transform(sx, sy, tx, ty) || sx <= 0.0f || sy <= 0.0f)
        return root;
    return {root.x * sx + tx, root.y * sy + ty};
}
 
// ── Backing store ───────────────────────────────────────────────────────────

struct BackingStore {
    uint32_t width = 0;         
    uint32_t height = 0;        
    float scale_factor = 1.0f;  
};

inline BackingStore compute_backing_store(float css_width, float css_height,
                                          float device_pixel_ratio) {
    const float dpr = device_pixel_ratio > 0.0f ? device_pixel_ratio : 1.0f;
    BackingStore store;
    store.width = static_cast<uint32_t>(
        std::lround(static_cast<double>(std::max(0.0f, css_width)) * dpr));
    store.height = static_cast<uint32_t>(
        std::lround(static_cast<double>(std::max(0.0f, css_height)) * dpr));
    store.scale_factor = dpr;
    return store;
}
 
// ── Raw browser event shapes ────────────────────────────────────────────────

enum class BrowserPointerPhase : uint8_t { down, move, up, cancel };

enum class BrowserPointerType : uint8_t { mouse, touch, pen };

enum class BrowserDeltaMode : uint8_t { pixel = 0, line = 1, page = 2 };
 
struct BrowserModifiers {
    bool ctrl = false;
    bool shift = false;
    bool alt = false;
    bool meta = false;
};
 
struct BrowserPointerEvent {
    float css_x = 0;
    float css_y = 0;
    int button = 0;   
    int buttons = 0;  
    int pointer_id = 0;
    bool is_primary = true;
    int click_count = 1;  
    BrowserPointerPhase phase = BrowserPointerPhase::down;
    BrowserPointerType pointer_type = BrowserPointerType::mouse;
    float pressure = 0.5f;
    BrowserModifiers modifiers;
};
 
struct BrowserWheelEvent {
    float css_x = 0;
    float css_y = 0;
    float delta_x = 0;
    float delta_y = 0;
    BrowserDeltaMode delta_mode = BrowserDeltaMode::pixel;
    BrowserModifiers modifiers;
};
 
struct BrowserKeyEvent {
    std::string key;  
    bool is_down = true;
    bool is_repeat = false;
    BrowserModifiers modifiers;
};
 
// ── Translation ─────────────────────────────────────────────────────────────

inline constexpr float kWheelLinePixels = 16.0f;
inline constexpr float kWheelPageFallbackPixels = 400.0f;

inline uint16_t translate_modifiers(const BrowserModifiers& mods) {
    uint16_t out = kModNone;
    if (mods.shift) out |= kModShift;
    if (mods.ctrl) out |= kModCtrl;
    if (mods.alt) out |= kModAlt;
    if (mods.meta) out |= static_cast<uint16_t>(kModMeta | kModCmd);
    return out;
}
 
inline MouseButton translate_button(int w3c_button) {
    switch (w3c_button) {
        case 1: return MouseButton::middle;
        case 2: return MouseButton::right;
        case 0: return MouseButton::left;
        default: return MouseButton::left;
    }
}
 
inline PointerType translate_pointer_type(BrowserPointerType type) {
    switch (type) {
        case BrowserPointerType::touch: return PointerType::touch;
        case BrowserPointerType::pen: return PointerType::pen;
        default: return PointerType::mouse;
    }
}

inline MouseEvent translate_pointer(const BrowserPointerEvent& event,
                                    const ViewportMapping& mapping) {
    const Point root = css_to_root(mapping, {event.css_x, event.css_y});
    const bool button_held = event.buttons != 0;
 
    MouseEvent out;
    out.position = root;
    out.window_position = root;
    out.button = translate_button(event.button);
    out.modifiers = translate_modifiers(event.modifiers);
    out.pointer_id = event.is_primary ? 0 : event.pointer_id;
    out.click_count = std::max(1, event.click_count);
    out.pointer_type = translate_pointer_type(event.pointer_type);
    out.pressure = event.pressure;
 
    switch (event.phase) {
        case BrowserPointerPhase::down:
            out.is_down = true;
            out.phase = MousePhase::press;
            break;
        case BrowserPointerPhase::move:
            out.is_down = button_held;
            out.phase = button_held ? MousePhase::drag : MousePhase::hover;
            break;
        case BrowserPointerPhase::up:
            out.is_down = false;
            out.phase = MousePhase::release;
            break;
        case BrowserPointerPhase::cancel:
            out.is_down = false;
            out.phase = MousePhase::release;
            out.is_cancelled = true;
            break;
    }
    return out;
}

inline MouseEvent translate_wheel(const BrowserWheelEvent& event,
                                  const ViewportMapping& mapping) {
    float unit = 1.0f;
    if (event.delta_mode == BrowserDeltaMode::line) {
        unit = kWheelLinePixels;
    } else if (event.delta_mode == BrowserDeltaMode::page) {
        unit = mapping.css_height > 0.0f ? mapping.css_height
                                         : kWheelPageFallbackPixels;
    }
 
    const Point root = css_to_root(mapping, {event.css_x, event.css_y});
 
    MouseEvent out;
    out.position = root;
    out.window_position = root;
    out.modifiers = translate_modifiers(event.modifiers);
    out.is_wheel = true;
    out.scroll_delta_x = event.delta_x * unit;
    out.scroll_delta_y = event.delta_y * unit;
    return out;
}

inline KeyCode translate_key_code(const std::string& key) {
    if (key.size() == 1) {
        const unsigned char ch = static_cast<unsigned char>(key[0]);
        if (ch >= 'A' && ch <= 'Z')
            return static_cast<KeyCode>(ch - 'A' + 'a');
        if ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == ' ' ||
            ch == ';' || ch == '\'')
            return static_cast<KeyCode>(ch);
        return KeyCode::unknown;
    }
    if (key == "ArrowLeft") return KeyCode::left;
    if (key == "ArrowRight") return KeyCode::right;
    if (key == "ArrowUp") return KeyCode::up;
    if (key == "ArrowDown") return KeyCode::down;
    if (key == "Home") return KeyCode::home;
    if (key == "End") return KeyCode::end_;
    if (key == "PageUp") return KeyCode::page_up;
    if (key == "PageDown") return KeyCode::page_down;
    if (key == "Backspace") return KeyCode::backspace;
    if (key == "Delete") return KeyCode::delete_;
    if (key == "Tab") return KeyCode::tab;
    if (key == "Enter") return KeyCode::enter;
    if (key == "Escape") return KeyCode::escape;
    if (key.size() >= 2 && key[0] == 'F') {
        const std::string digits = key.substr(1);
        if (digits.find_first_not_of("0123456789") == std::string::npos) {
            const int n = std::stoi(digits);
            if (n >= 1 && n <= 12)
                return static_cast<KeyCode>(static_cast<int>(KeyCode::f1) + n - 1);
        }
    }
    return KeyCode::unknown;
}
 
inline KeyEvent translate_key(const BrowserKeyEvent& event) {
    KeyEvent out;
    out.key = translate_key_code(event.key);
    out.modifiers = translate_modifiers(event.modifiers);
    out.is_down = event.is_down;
    out.is_repeat = event.is_repeat;
    return out;
}

inline std::string text_for_key(const BrowserKeyEvent& event) {
    if (!event.is_down) return {};
    if (event.modifiers.ctrl || event.modifiers.meta) return {};
    if (event.key.empty()) return {};
    if (event.key.size() == 1) {
        const unsigned char ch = static_cast<unsigned char>(event.key[0]);
        return (ch >= 0x20 && ch != 0x7f) ? event.key : std::string{};
    }
    if (static_cast<unsigned char>(event.key[0]) & 0x80) return event.key;
    return {};
}
 
// ── View-tree routing ───────────────────────────────────────────────────────

class WebInputRouter {
public:
    explicit WebInputRouter(View& root) : root_(root) {}
 
    void set_mapping(const ViewportMapping& mapping) { mapping_ = mapping; }
    const ViewportMapping& mapping() const { return mapping_; }

    void set_dirty_callback(std::function<void()> cb) {
        on_dirty_ = std::move(cb);
    }

    void invalidate() {
        drag_targets_.clear();
        hover_target_ = nullptr;
        focus_target_ = nullptr;
    }
 
    View* focused_view() const { return focus_target_; }
    View* drag_target() const {
        if (drag_targets_.empty()) return nullptr;
        const auto& capture = drag_targets_.begin()->second;
        return capture.lifetime.expired() ? nullptr : capture.target;
    }
 
    bool handle_pointer(const BrowserPointerEvent& event) {
        const MouseEvent me = translate_pointer(event, mapping_);
        switch (event.phase) {
            case BrowserPointerPhase::down:
                return pointer_down(me, event.pointer_id);
            case BrowserPointerPhase::move:
                return pointer_move(me, event.pointer_id);
            case BrowserPointerPhase::up:
                return pointer_up(me, event.pointer_id, false);
            case BrowserPointerPhase::cancel:
                return pointer_up(me, event.pointer_id, true);
        }
        return false;
    }
 
    bool handle_wheel(const BrowserWheelEvent& event) {
        MouseEvent me = translate_wheel(event, mapping_);
        View* target = root_.hit_test(me.position);
        if (!target) {
            // An empty patch of a scroll pane has no hit-testable child under
            // it; route to the scroll container the pointer is over so the
            // wheel works anywhere in the pane without clicking first.
            target = find_wheel_scroll_view_at(root_, me.position);
            if (!target) return false;
            target->on_mouse_event(me);
            target->layout_children();
            mark_dirty();
            return true;
        }
        target->on_mouse_event(me);
        target->on_wheel(me.scroll_delta_y);
        mark_dirty();
        return true;
    }
 
    bool handle_key(const BrowserKeyEvent& event) {
        const KeyEvent ke = translate_key(event);
        // Escape runs the shared dismissal policy before focused-view
        // delivery, matching every other host: a modal, an open ComboBox
        // dropdown, then the generalized overlay slot. Without it a popover
        // whose trigger never took focus could only be closed with the mouse.
        if (ke.is_down && ke.key == KeyCode::escape &&
            route_escape_to_active_overlay(root_, ke.modifiers, ke.is_repeat) !=
                OverlayEscapeResult::none) {
            mark_dirty();
            return true;
        }
        View* target = focus_target_ ? focus_target_ : &root_;
        bool handled = target->on_key_event(ke);
 
        const std::string text = text_for_key(event);
        if (!text.empty() && focus_target_) {
            TextInputEvent te;
            te.text = text;
            focus_target_->on_text_input(te);
            handled = true;
        }
        if (handled) mark_dirty();
        return handled;
    }

    bool handle_text(const std::string& text) {
        if (text.empty() || !focus_target_) return false;
        TextInputEvent te;
        te.text = text;
        focus_target_->on_text_input(te);
        mark_dirty();
        return true;
    }
 
private:
    static bool in_tree(View* needle, View* root) {
        if (!needle || !root) return false;
        if (needle == root) return true;
        for (size_t i = 0; i < root->child_count(); ++i)
            if (in_tree(needle, root->child_at(i))) return true;
        return false;
    }
 
    void clear_cached_target(
        View* target,
        const std::weak_ptr<const std::uint64_t>& lifetime) {
        if (focus_target_ == target) {
            focus_target_ = nullptr;
            if (!lifetime.expired()) {
                target->on_focus_changed(false);
                if (!lifetime.expired()) target->release_input_focus();
            }
        }
        if (hover_target_ == target) hover_target_ = nullptr;
    }
 
    void mark_dirty() {
        if (on_dirty_) on_dirty_();
    }
 
    void set_focus(View* target) {
        if (focus_target_ == target) return;
        if (focus_target_) {
            focus_target_->on_focus_changed(false);
            focus_target_->release_input_focus();
        }
        focus_target_ = target;
        if (focus_target_) {
            focus_target_->on_focus_changed(true);
            focus_target_->claim_input_focus();
        }
    }
 
    bool pointer_down(const MouseEvent& me, int raw_pointer_id) {
        // The generalized overlay slot is consulted through the one shared
        // policy, exactly as the macOS and Windows hosts do. This host used to
        // hand-roll a reduced version of it against the process-global
        // `View::active_overlay_` shim mirror, which cost it three behaviours
        // the other hosts have: a press INSIDE the overlay was not routed into
        // the overlay's subtree (so an absolutely-positioned popover child lost
        // the click to whatever sibling occupied that pixel), an overlay that
        // opted to consume the dismissing press did not get to (so one click
        // both closed the popover and mutated the underlay), and the slot was
        // read process-wide rather than from this root.
        const auto overlay_press =
            route_press_to_active_overlay(root_, me.window_position);
        if (overlay_press.consume_press) {
            mark_dirty();
            return true;
        }
 
        View* target =
            overlay_press.routing == OverlayPressRouting::routed
                ? overlay_press.target
                : root_.hit_test(me.window_position);
 
        // The overlay-aware context-menu overload, so a right-click inside a
        // popover reaches the popover rather than the sibling beneath it.
        if (me.button == MouseButton::right &&
            dispatch_context_menu(root_, target, me.window_position)) {
            mark_dirty();
            return true;
        }
        ComboBox::notify_global_click(target);
        if (!target) {
            set_focus(nullptr);
            mark_dirty();
            return false;
        }
 
        set_focus(target->focusable() ? target : nullptr);
 
        const auto lifetime = target->import_binding_lifetime_token();
        const auto target_is_live = [&] {
            return !lifetime.expired() && in_tree(target, &root_);
        };
        MouseEvent local_event = me;
        local_event.position = point_to_local(me.window_position, target, &root_);
        dispatch_dom_pointer_event(root_, target, local_event, false);
        if (target_is_live()) target->on_mouse_down(local_event.position);
        if (target_is_live())
            drag_targets_[raw_pointer_id] = {target, lifetime};
        else
            clear_cached_target(target, lifetime);
        mark_dirty();
        return true;
    }
 
    bool pointer_move(const MouseEvent& me, int raw_pointer_id) {
        auto capture = drag_targets_.find(raw_pointer_id);
        if (capture != drag_targets_.end()) {
            const auto lifetime = capture->second.lifetime;
            View* captured = capture->second.target;
            if (lifetime.expired() || !in_tree(captured, &root_)) {
                drag_targets_.erase(capture);
                clear_cached_target(captured, lifetime);
                return false;
            }
            const auto captured_is_live = [&] {
                return !lifetime.expired() && in_tree(captured, &root_);
            };
            MouseEvent local_event = me;
            local_event.position =
                point_to_local(me.window_position, captured, &root_);
            local_event.is_down = true;
            local_event.phase = MousePhase::drag;
 
            dispatch_dom_pointer_event(root_, captured, local_event, true);
            if (captured_is_live())
                captured->on_mouse_drag(local_event.position);
            if (captured_is_live()) {
                if (local_event.pointer_type == PointerType::mouse) {
                    if (captured->on_drag)
                        captured->on_drag(local_event.position);
                } else if (captured->on_pointer_move) {
                    captured->on_pointer_move(local_event);
                }
            }
            if (!captured_is_live()) {
                drag_targets_.erase(raw_pointer_id);
                // Comparing an invalidated pointer is safe; invoking focus or
                // hover callbacks on it is not. The lifetime token lets a
                // detached-but-retained view release its focus ownership while
                // avoiding a dereference if the callback destroyed it.
                clear_cached_target(captured, lifetime);
            }
            mark_dirty();
            return true;
        }
 
        View* target = root_.hit_test(me.window_position);
        if (target != hover_target_) {
            if (hover_target_) hover_target_->set_hovered(false);
            hover_target_ = target;
            if (hover_target_) hover_target_->set_hovered(true);
            mark_dirty();
        }
        if (!target) return false;
 
        MouseEvent local_event = me;
        local_event.position = point_to_local(me.window_position, target, &root_);
        dispatch_dom_pointer_event(root_, target, local_event, true);
        target->on_hover_move(local_event.position);
        mark_dirty();
        return true;
    }
 
    bool pointer_up(const MouseEvent& me, int raw_pointer_id, bool cancelled) {
        auto capture = drag_targets_.find(raw_pointer_id);
        if (capture == drag_targets_.end()) return false;
        const auto lifetime = capture->second.lifetime;
        View* target = capture->second.target;
        if (lifetime.expired() || !in_tree(target, &root_)) {
            drag_targets_.erase(capture);
            clear_cached_target(target, lifetime);
            return false;
        }
        drag_targets_.erase(raw_pointer_id);
 
        MouseEvent local_event = me;
        local_event.position = point_to_local(me.window_position, target, &root_);
        dispatch_dom_pointer_event(root_, target, local_event, false);
        if (!lifetime.expired() && in_tree(target, &root_)) {
            if (cancelled)
                target->on_mouse_cancel(local_event.position);
            else
                target->on_mouse_up(local_event.position);
        } else {
            clear_cached_target(target, lifetime);
        }
        mark_dirty();
        return true;
    }
 
    View& root_;
    ViewportMapping mapping_;
    std::function<void()> on_dirty_;
    struct PointerCapture {
        View* target = nullptr;
        std::weak_ptr<const std::uint64_t> lifetime;
    };
    std::unordered_map<int, PointerCapture> drag_targets_;
    View* hover_target_ = nullptr;
    View* focus_target_ = nullptr;
};
 
// ── Host installation (Emscripten only) ─────────────────────────────────────

void install_browser_window_host(std::string canvas_selector = "#canvas");

void install_web_input_listeners(const std::string& canvas_selector,
                                 WebInputRouter& router);
void remove_web_input_listeners(const std::string& canvas_selector);

void notify_browser_host_resized(float css_width, float css_height);

bool browser_host_gpu_available();

float device_pixel_ratio();
bool canvas_css_size(const std::string& canvas_selector, float& css_width,
                     float& css_height);

void set_canvas_size(const std::string& canvas_selector,
                     const BackingStore& backing, float css_width,
                     float css_height);

void set_canvas_visible(const std::string& canvas_selector, bool visible);
 
}  // namespace pulp::view::web