Widget.hpp

Go to the documentation of this file.

#pragma once
#include <list>
 
#include <common.hpp>
#include <math.hpp>
#include <window/Window.hpp>
#include <color.hpp>
#include <widget/event.hpp>
#include <weakptr.hpp>
 
 
namespace rack {
namespace widget {
 

struct Widget : WeakBase {
    math::Rect box = math::Rect(math::Vec(), math::Vec(INFINITY, INFINITY));
    Widget* parent = NULL;
    std::list<Widget*> children;
    bool visible = true;
    bool requestedDelete = false;
 
    virtual ~Widget();
 
    math::Rect getBox();
    void setBox(math::Rect box);
    math::Vec getPosition();
    void setPosition(math::Vec pos);
    math::Vec getSize();
    void setSize(math::Vec size);
    widget::Widget* getParent();
    bool isVisible();
    void setVisible(bool visible);
    void show() {
        setVisible(true);
    }
    void show() {…}

    void hide() {
        setVisible(false);
    }
    void hide() {…}

    void requestDelete();

    virtual math::Rect getChildrenBoundingBox();
    virtual math::Rect getVisibleChildrenBoundingBox();
    bool isDescendantOf(Widget* ancestor);
    virtual math::Vec getRelativeOffset(math::Vec v, Widget* ancestor);
    math::Vec getAbsoluteOffset(math::Vec v) {
        return getRelativeOffset(v, NULL);
    }
    math::Vec getAbsoluteOffset(math::Vec v) {…}

    virtual float getRelativeZoom(Widget* ancestor);
    float getAbsoluteZoom() {
        return getRelativeZoom(NULL);
    }
    float getAbsoluteZoom() {…}

    virtual math::Rect getViewport(math::Rect r = math::Rect::inf());
 
    template <class T>
    T* getAncestorOfType() {
        if (!parent)
            return NULL;
        T* p = dynamic_cast<T*>(parent);
        if (p)
            return p;
        return parent->getAncestorOfType<T>();
    }
    T* getAncestorOfType() {…}
 
    template <class T>
    T* getFirstDescendantOfType() {
        for (Widget* child : children) {
            T* c = dynamic_cast<T*>(child);
            if (c)
                return c;
            c = child->getFirstDescendantOfType<T>();
            if (c)
                return c;
        }
        return NULL;
    }
    T* getFirstDescendantOfType() {…}

    bool hasChild(Widget* child);
    void addChild(Widget* child);
    void addChildBottom(Widget* child);
    void addChildBelow(Widget* child, Widget* sibling);
    void addChildAbove(Widget* child, Widget* sibling);
    void removeChild(Widget* child);
    void clearChildren();

    virtual void step();
 
    struct DrawArgs {
        NVGcontext* vg = NULL;
        math::Rect clipBox;
        NVGLUframebuffer* fb = NULL;
    };
    struct DrawArgs {…};

    virtual void draw(const DrawArgs& args);
    DEPRECATED virtual void draw(NVGcontext* vg) {}

    virtual void drawLayer(const DrawArgs& args, int layer);

    void drawChild(Widget* child, const DrawArgs& args, int layer = 0);
 
    // Events

    template <typename TMethod, class TEvent>
    void recurseEvent(TMethod f, const TEvent& e) {
        for (auto it = children.rbegin(); it != children.rend(); it++) {
            // Stop propagation if requested
            if (!e.isPropagating())
                break;
            Widget* child = *it;
            // Don't filter child by visibility. Typically only position events need to be filtered by visibility.
            // if (!child->visible)
            //  continue;
 
            // Clone event for (currently) no reason
            TEvent e2 = e;
            // Call child event handler
            (child->*f)(e2);
        }
    }
    void recurseEvent(TMethod f, const TEvent& e) {…}

    template <typename TMethod, class TEvent>
    void recursePositionEvent(TMethod f, const TEvent& e) {
        for (auto it = children.rbegin(); it != children.rend(); it++) {
            // Stop propagation if requested
            if (!e.isPropagating())
                break;
            Widget* child = *it;
            // Filter child by visibility and position
            if (!child->visible)
                continue;
            if (!child->box.contains(e.pos))
                continue;
 
            // Clone event and adjust its position
            TEvent e2 = e;
            e2.pos = e.pos.minus(child->box.pos);
            // Call child event handler
            (child->*f)(e2);
        }
    }
    void recursePositionEvent(TMethod f, const TEvent& e) {…}
 
    using BaseEvent = widget::BaseEvent;

    struct PositionBaseEvent {
        math::Vec pos;
    };
    struct PositionBaseEvent {…};

    struct HoverEvent : BaseEvent, PositionBaseEvent {
        math::Vec mouseDelta;
    };
    struct HoverEvent : BaseEvent, PositionBaseEvent {…};
    virtual void onHover(const HoverEvent& e) {
        recursePositionEvent(&Widget::onHover, e);
    }
    virtual void onHover(const HoverEvent& e) {…}

    struct ButtonEvent : BaseEvent, PositionBaseEvent {
        int button;
        int action;
        int mods;
    };
    struct ButtonEvent : BaseEvent, PositionBaseEvent {…};
    virtual void onButton(const ButtonEvent& e) {
        recursePositionEvent(&Widget::onButton, e);
    }
    virtual void onButton(const ButtonEvent& e) {…}

    struct DoubleClickEvent : BaseEvent {};
    virtual void onDoubleClick(const DoubleClickEvent& e) {}

    struct KeyBaseEvent {
        int key;
        int scancode;
        std::string keyName;
        int action;
        int mods;
        bool isKeyCommand(int key, int mods = 0) const;
    };
    struct KeyBaseEvent {…};

    struct HoverKeyEvent : BaseEvent, PositionBaseEvent, KeyBaseEvent {};
    virtual void onHoverKey(const HoverKeyEvent& e) {
        recursePositionEvent(&Widget::onHoverKey, e);
    }
    virtual void onHoverKey(const HoverKeyEvent& e) {…}

    struct TextBaseEvent {
        uint32_t codepoint;
    };
    struct TextBaseEvent {…};

    struct HoverTextEvent : BaseEvent, PositionBaseEvent, TextBaseEvent {};
    virtual void onHoverText(const HoverTextEvent& e) {
        recursePositionEvent(&Widget::onHoverText, e);
    }
    virtual void onHoverText(const HoverTextEvent& e) {…}

    struct HoverScrollEvent : BaseEvent, PositionBaseEvent {
        math::Vec scrollDelta;
    };
    struct HoverScrollEvent : BaseEvent, PositionBaseEvent {…};
    virtual void onHoverScroll(const HoverScrollEvent& e) {
        recursePositionEvent(&Widget::onHoverScroll, e);
    }
    virtual void onHoverScroll(const HoverScrollEvent& e) {…}

    struct EnterEvent : BaseEvent {};
    virtual void onEnter(const EnterEvent& e) {}

    struct LeaveEvent : BaseEvent {};
    virtual void onLeave(const LeaveEvent& e) {}

    struct SelectEvent : BaseEvent {};
    virtual void onSelect(const SelectEvent& e) {}

    struct DeselectEvent : BaseEvent {};
    virtual void onDeselect(const DeselectEvent& e) {}

    struct SelectKeyEvent : BaseEvent, KeyBaseEvent {};
    virtual void onSelectKey(const SelectKeyEvent& e) {}

    struct SelectTextEvent : BaseEvent, TextBaseEvent {};
    virtual void onSelectText(const SelectTextEvent& e) {}
 
    struct DragBaseEvent : BaseEvent {
        int button;
    };
    struct DragBaseEvent : BaseEvent {…};

    struct DragStartEvent : DragBaseEvent {};
    virtual void onDragStart(const DragStartEvent& e) {}

    struct DragEndEvent : DragBaseEvent {};
    virtual void onDragEnd(const DragEndEvent& e) {}

    struct DragMoveEvent : DragBaseEvent {
        math::Vec mouseDelta;
    };
    struct DragMoveEvent : DragBaseEvent {…};
    virtual void onDragMove(const DragMoveEvent& e) {}

    struct DragHoverEvent : DragBaseEvent, PositionBaseEvent {
        Widget* origin = NULL;
        math::Vec mouseDelta;
    };
    struct DragHoverEvent : DragBaseEvent, PositionBaseEvent {…};
    virtual void onDragHover(const DragHoverEvent& e) {
        recursePositionEvent(&Widget::onDragHover, e);
    }
    virtual void onDragHover(const DragHoverEvent& e) {…}

    struct DragEnterEvent : DragBaseEvent {
        Widget* origin = NULL;
    };
    struct DragEnterEvent : DragBaseEvent {…};
    virtual void onDragEnter(const DragEnterEvent& e) {}

    struct DragLeaveEvent : DragBaseEvent {
        Widget* origin = NULL;
    };
    struct DragLeaveEvent : DragBaseEvent {…};
    virtual void onDragLeave(const DragLeaveEvent& e) {}

    struct DragDropEvent : DragBaseEvent {
        Widget* origin = NULL;
    };
    struct DragDropEvent : DragBaseEvent {…};
    virtual void onDragDrop(const DragDropEvent& e) {}

    struct PathDropEvent : BaseEvent, PositionBaseEvent {
        PathDropEvent(const std::vector<std::string>& paths) : paths(paths) {}

        const std::vector<std::string>& paths;
    };
    struct PathDropEvent : BaseEvent, PositionBaseEvent {…};
    virtual void onPathDrop(const PathDropEvent& e) {
        recursePositionEvent(&Widget::onPathDrop, e);
    }
    virtual void onPathDrop(const PathDropEvent& e) {…}

    struct ActionEvent : BaseEvent {};
    virtual void onAction(const ActionEvent& e) {}

    struct ChangeEvent : BaseEvent {};
    virtual void onChange(const ChangeEvent& e) {}

    struct DirtyEvent : BaseEvent {};
    virtual void onDirty(const DirtyEvent& e) {
        recurseEvent(&Widget::onDirty, e);
    }
    virtual void onDirty(const DirtyEvent& e) {…}

    struct RepositionEvent : BaseEvent {};
    virtual void onReposition(const RepositionEvent& e) {}

    struct ResizeEvent : BaseEvent {};
    virtual void onResize(const ResizeEvent& e) {}

    struct AddEvent : BaseEvent {};
    virtual void onAdd(const AddEvent& e) {}

    struct RemoveEvent : BaseEvent {};
    virtual void onRemove(const RemoveEvent& e) {}

    struct ShowEvent : BaseEvent {};
    virtual void onShow(const ShowEvent& e) {
        recurseEvent(&Widget::onShow, e);
    }
    virtual void onShow(const ShowEvent& e) {…}

    struct HideEvent : BaseEvent {};
    virtual void onHide(const HideEvent& e) {
        recurseEvent(&Widget::onHide, e);
    }
    virtual void onHide(const HideEvent& e) {…}

    struct ContextCreateEvent : BaseEvent {
        NVGcontext* vg;
    };
    struct ContextCreateEvent : BaseEvent {…};
    virtual void onContextCreate(const ContextCreateEvent& e) {
        recurseEvent(&Widget::onContextCreate, e);
    }
    virtual void onContextCreate(const ContextCreateEvent& e) {…}

    struct ContextDestroyEvent : BaseEvent {
        NVGcontext* vg;
    };
    struct ContextDestroyEvent : BaseEvent {…};
    virtual void onContextDestroy(const ContextDestroyEvent& e) {
        recurseEvent(&Widget::onContextDestroy, e);
    }
    virtual void onContextDestroy(const ContextDestroyEvent& e) {…}
};
struct Widget : WeakBase {…};
 
 
} // namespace widget

namespace event {
using Base = widget::BaseEvent;
using PositionBase = widget::Widget::PositionBaseEvent;
using KeyBase = widget::Widget::KeyBaseEvent;
using TextBase = widget::Widget::TextBaseEvent;
using Hover = widget::Widget::HoverEvent;
using Button = widget::Widget::ButtonEvent;
using DoubleClick = widget::Widget::DoubleClickEvent;
using HoverKey = widget::Widget::HoverKeyEvent;
using HoverText = widget::Widget::HoverTextEvent;
using HoverScroll = widget::Widget::HoverScrollEvent;
using Enter = widget::Widget::EnterEvent;
using Leave = widget::Widget::LeaveEvent;
using Select = widget::Widget::SelectEvent;
using Deselect = widget::Widget::DeselectEvent;
using SelectKey = widget::Widget::SelectKeyEvent;
using SelectText = widget::Widget::SelectTextEvent;
using DragBase = widget::Widget::DragBaseEvent;
using DragStart = widget::Widget::DragStartEvent;
using DragEnd = widget::Widget::DragEndEvent;
using DragMove = widget::Widget::DragMoveEvent;
using DragHover = widget::Widget::DragHoverEvent;
using DragEnter = widget::Widget::DragEnterEvent;
using DragLeave = widget::Widget::DragLeaveEvent;
using DragDrop = widget::Widget::DragDropEvent;
using PathDrop = widget::Widget::PathDropEvent;
using Action = widget::Widget::ActionEvent;
using Change = widget::Widget::ChangeEvent;
using Dirty = widget::Widget::DirtyEvent;
using Reposition = widget::Widget::RepositionEvent;
using Resize = widget::Widget::ResizeEvent;
using Add = widget::Widget::AddEvent;
using Remove = widget::Widget::RemoveEvent;
using Show = widget::Widget::ShowEvent;
using Hide = widget::Widget::HideEvent;
}
namespace event {…}
 
 
} // namespace rack