RackWidget.hpp

Go to the documentation of this file.

#pragma once
#include <app/common.hpp>
#include <widget/OpaqueWidget.hpp>
#include <widget/FramebufferWidget.hpp>
#include <ui/Menu.hpp>
#include <app/RailWidget.hpp>
#include <app/ModuleWidget.hpp>
#include <app/CableWidget.hpp>
#include <app/PortWidget.hpp>
#include <app/ParamWidget.hpp>
#include <history.hpp>
 
#include <set>
 
 
namespace rack {
namespace app {
 
 
struct RackWidget : widget::OpaqueWidget {
    struct Internal;
    Internal* internal;
 
    ParamWidget* touchedParam = NULL;
 
    PRIVATE RackWidget();
    PRIVATE ~RackWidget();
 
    void step() override;
    void draw(const DrawArgs& args) override;
 
    void onHover(const HoverEvent& e) override;
    void onHoverKey(const HoverKeyEvent& e) override;
    void onButton(const ButtonEvent& e) override;
    void onDragStart(const DragStartEvent& e) override;
    void onDragEnd(const DragEndEvent& e) override;
    void onDragHover(const DragHoverEvent& e) override;
 
    // Rack methods
 
    widget::Widget* getModuleContainer();
    widget::Widget* getPlugContainer();
    widget::Widget* getCableContainer();
    math::Vec getMousePos();
 
    void clear();
    void mergeJson(json_t* rootJ);
    void fromJson(json_t* rootJ);
    void pasteJsonAction(json_t* rootJ);
    void pasteModuleJsonAction(json_t* moduleJ);
    void pasteClipboardAction();
 
    // Module methods
 
    void addModule(ModuleWidget* mw);
    void addModuleAtMouse(ModuleWidget* mw);
    void removeModule(ModuleWidget* mw);
    ModuleWidget* getModule(int64_t moduleId);
    std::vector<ModuleWidget*> getModules();
    bool hasModules();
 
    // Module position methods
 
    bool requestModulePos(ModuleWidget* mw, math::Vec pos);
    void setModulePosNearest(ModuleWidget* mw, math::Vec pos);
    void setModulePosForce(ModuleWidget* mw, math::Vec pos);
    void setModulePosSqueeze(ModuleWidget* mw, math::Vec pos);
    PRIVATE void squeezeModulePos(ModuleWidget* mw, math::Vec pos);
    PRIVATE void unsqueezeModulePos(ModuleWidget* mw);
    void updateModuleOldPositions();
    history::ComplexAction* getModuleDragAction();
 
    // Module selection methods
 
    void updateSelectionFromRect();
    void selectAll();
    void deselectAll();
    void select(ModuleWidget* mw, bool selected = true);
    bool hasSelection();
    const std::set<ModuleWidget*>& getSelected();
    bool isSelected(ModuleWidget* mw);
    json_t* selectionToJson(bool cables = true);
    void loadSelection(std::string path);
    void loadSelectionDialog();
    void saveSelection(std::string path);
    void saveSelectionDialog();
    void copyClipboardSelection();
    void resetSelectionAction();
    void randomizeSelectionAction();
    void disconnectSelectionAction();
    void cloneSelectionAction(bool cloneCables = true);
    void bypassSelectionAction(bool bypassed);
    bool isSelectionBypassed();
    void deleteSelectionAction();
    bool requestSelectionPos(math::Vec delta);
    void setSelectionPosNearest(math::Vec delta);
    void appendSelectionContextMenu(ui::Menu* menu);
 
    // Cable methods
 
    void clearCables();
    void clearCablesAction();
    void clearCablesOnPort(PortWidget* port);
    void addCable(CableWidget* cw);
    void removeCable(CableWidget* cw);
    DEPRECATED CableWidget* getIncompleteCable();
    PlugWidget* getTopPlug(PortWidget* port);
    CableWidget* getTopCable(PortWidget* port);
    CableWidget* getCable(int64_t cableId);
    CableWidget* getCable(PortWidget* outputPort, PortWidget* inputPort);
    std::vector<CableWidget*> getCables();
    std::vector<CableWidget*> getCompleteCables();
    std::vector<CableWidget*> getIncompleteCables();
    std::vector<CableWidget*> getCablesOnPort(PortWidget* port);
    std::vector<CableWidget*> getCompleteCablesOnPort(PortWidget* port);
    int getNextCableColorId();
    void setNextCableColorId(int id);
    NVGcolor getNextCableColor();
    ParamWidget* getTouchedParam();
    void setTouchedParam(ParamWidget* pw);
 
    PRIVATE void updateExpanders();
};
 
 
} // namespace app
} // namespace rack