event.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
#include <set>
 
#include <common.hpp>
#include <math.hpp>
 
 

#if defined ARCH_MAC
    #define RACK_MOD_CTRL GLFW_MOD_SUPER
    #define RACK_MOD_CTRL_NAME "⌘"
#else
    #define RACK_MOD_CTRL GLFW_MOD_CONTROL
    #define RACK_MOD_CTRL_NAME "Ctrl"
#endif
 
#define RACK_MOD_SHIFT GLFW_MOD_SHIFT
#define RACK_MOD_SHIFT_NAME "Shift"
 
#define RACK_MOD_ALT GLFW_MOD_ALT
#define RACK_MOD_ALT_NAME "Alt"

#define RACK_MOD_MASK (GLFW_MOD_SHIFT | GLFW_MOD_CONTROL | GLFW_MOD_ALT | GLFW_MOD_SUPER)

#define RACK_HELD 3
 
 
namespace rack {
namespace widget {
 
 
struct Widget;
 

std::string getKeyName(int key);
std::string getKeyCommandName(int key, int mods = 0);
 

struct EventContext {
    bool propagating = true;
    bool consumed = false;
    Widget* target = NULL;
};
struct EventContext {…};
 

struct BaseEvent {
    EventContext* context = NULL;

    void stopPropagating() const {
        if (!context)
            return;
        context->propagating = false;
    }
    void stopPropagating() const  {…}
    bool isPropagating() const {
        if (!context)
            return true;
        return context->propagating;
    }
    bool isPropagating() const  {…}

    void setTarget(Widget* w) const {
        if (!context)
            return;
        context->target = w;
    }
    void setTarget(Widget* w) const  {…}
    Widget* getTarget() const {
        if (!context)
            return NULL;
        return context->target;
    }
    Widget* getTarget() const  {…}

    void consume(Widget* w) const {
        if (!context)
            return;
        context->propagating = false;
        context->consumed = true;
        context->target = w;
    }
    void consume(Widget* w) const  {…}
    void unconsume() const {
        if (!context)
            return;
        context->consumed = false;
    }
    void unconsume() const  {…}
    bool isConsumed() const {
        if (!context)
            return false;
        return context->consumed;
    }
    bool isConsumed() const  {…}
};
struct BaseEvent {…};
 
 
struct EventState {
    Widget* rootWidget = NULL;
    Widget* hoveredWidget = NULL;
    Widget* draggedWidget = NULL;
    int dragButton = 0;
    Widget* dragHoveredWidget = NULL;
    Widget* selectedWidget = NULL;
    double lastClickTime = -INFINITY;
    Widget* lastClickedWidget = NULL;
    std::set<int> heldKeys;
 
    Widget* getRootWidget() {
        return rootWidget;
    }
    Widget* getRootWidget() {…}
    Widget* getHoveredWidget() {
        return hoveredWidget;
    }
    Widget* getHoveredWidget() {…}
    Widget* getDraggedWidget() {
        return draggedWidget;
    }
    Widget* getDraggedWidget() {…}
    Widget* getDragHoveredWidget() {
        return dragHoveredWidget;
    }
    Widget* getDragHoveredWidget() {…}
    Widget* getSelectedWidget() {
        return selectedWidget;
    }
    Widget* getSelectedWidget() {…}
 
    void setHoveredWidget(Widget* w);
    void setDraggedWidget(Widget* w, int button);
    void setDragHoveredWidget(Widget* w);
    void setSelectedWidget(Widget* w);
    DEPRECATED void setHovered(Widget* w) {setHoveredWidget(w);}
    DEPRECATED void setDragged(Widget* w, int button) {setDraggedWidget(w, button);}
    DEPRECATED void setDragHovered(Widget* w) {setDragHoveredWidget(w);}
    DEPRECATED void setSelected(Widget* w) {setSelectedWidget(w);}
    void finalizeWidget(Widget* w);
 
    bool handleButton(math::Vec pos, int button, int action, int mods);
    bool handleHover(math::Vec pos, math::Vec mouseDelta);
    bool handleLeave();
    bool handleScroll(math::Vec pos, math::Vec scrollDelta);
    bool handleText(math::Vec pos, uint32_t codepoint);
    bool handleKey(math::Vec pos, int key, int scancode, int action, int mods);
    bool handleDrop(math::Vec pos, const std::vector<std::string>& paths);
    bool handleDirty();
};
struct EventState {…};
 
 
} // namespace widget
} // namespace rack