273 lines
11 KiB
C++
273 lines
11 KiB
C++
/*
|
|
* DISTRHO Cardinal Plugin
|
|
* Copyright (C) 2021 Filipe Coelho <falktx@falktx.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 3 of
|
|
* the License, or any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* For a full copy of the GNU General Public License see the LICENSE file.
|
|
*/
|
|
|
|
#define PRIVATE
|
|
#include <common.hpp>
|
|
|
|
#undef PRIVATE
|
|
#include <rack.hpp>
|
|
|
|
using namespace rack;
|
|
|
|
namespace rack {
|
|
namespace settings {
|
|
bool cpuMeter = false;
|
|
}
|
|
Exception::Exception(const char* format, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, format);
|
|
msg = string::fV(format, args);
|
|
va_end(args);
|
|
}
|
|
namespace asset {
|
|
std::string plugin(plugin::Plugin* plugin, std::string filename) { return {}; }
|
|
std::string system(std::string filename) { return {}; }
|
|
}
|
|
namespace engine {
|
|
float Engine::getParamValue(Module* module, int paramId) { return 0.0f; }
|
|
float Engine::getParamSmoothValue(Module* module, int paramId) { return 0.0f; }
|
|
void Engine::setParamValue(Module* module, int paramId, float value) {}
|
|
void Engine::setParamSmoothValue(Module* module, int paramId, float value) {}
|
|
}
|
|
}
|
|
|
|
namespace rack {
|
|
namespace app {
|
|
|
|
Knob::Knob() {}
|
|
Knob::~Knob() {}
|
|
void Knob::initParamQuantity() {}
|
|
void Knob::onHover(const HoverEvent& e) {}
|
|
void Knob::onButton(const ButtonEvent& e) {}
|
|
void Knob::onDragStart(const DragStartEvent& e) {}
|
|
void Knob::onDragEnd(const DragEndEvent& e) {}
|
|
void Knob::onDragMove(const DragMoveEvent& e) {}
|
|
void Knob::onDragLeave(const DragLeaveEvent& e) {}
|
|
void Knob::onHoverScroll(const HoverScrollEvent& e) {}
|
|
void Knob::onLeave(const LeaveEvent& e) {}
|
|
|
|
void LightWidget::draw(const DrawArgs& args) {}
|
|
void LightWidget::drawLayer(const DrawArgs& args, int layer) {}
|
|
void LightWidget::drawBackground(const DrawArgs& args) {}
|
|
void LightWidget::drawLight(const DrawArgs& args) {}
|
|
void LightWidget::drawHalo(const DrawArgs& args) {}
|
|
|
|
ModuleLightWidget::~ModuleLightWidget() {}
|
|
engine::Light* ModuleLightWidget::getLight(int colorId) { return nullptr; }
|
|
engine::LightInfo* ModuleLightWidget::getLightInfo() { return nullptr; }
|
|
void ModuleLightWidget::createTooltip() {}
|
|
void ModuleLightWidget::destroyTooltip() {}
|
|
void ModuleLightWidget::step() {}
|
|
void ModuleLightWidget::onHover(const HoverEvent& e) {}
|
|
void ModuleLightWidget::onEnter(const EnterEvent& e) {}
|
|
void ModuleLightWidget::onLeave(const LeaveEvent& e) {}
|
|
|
|
ModuleWidget::ModuleWidget() {}
|
|
ModuleWidget::~ModuleWidget() {}
|
|
plugin::Model* ModuleWidget::getModel() { return nullptr; }
|
|
void ModuleWidget::setModel(plugin::Model* model) {}
|
|
engine::Module* ModuleWidget::getModule() { return nullptr; }
|
|
void ModuleWidget::setModule(engine::Module* module) {}
|
|
widget::Widget* ModuleWidget::getPanel() { return nullptr; }
|
|
void ModuleWidget::setPanel(widget::Widget* panel) {}
|
|
void ModuleWidget::setPanel(std::shared_ptr<window::Svg> svg) {}
|
|
void ModuleWidget::addParam(ParamWidget* param) {}
|
|
void ModuleWidget::addInput(PortWidget* input) {}
|
|
void ModuleWidget::addOutput(PortWidget* output) {}
|
|
ParamWidget* ModuleWidget::getParam(int paramId) { return nullptr; }
|
|
PortWidget* ModuleWidget::getInput(int portId) { return nullptr; }
|
|
PortWidget* ModuleWidget::getOutput(int portId) { return nullptr; }
|
|
std::vector<ParamWidget*> ModuleWidget::getParams() { return {}; }
|
|
std::vector<PortWidget*> ModuleWidget::getPorts() { return {}; }
|
|
std::vector<PortWidget*> ModuleWidget::getInputs() { return {}; }
|
|
std::vector<PortWidget*> ModuleWidget::getOutputs() { return {}; }
|
|
void ModuleWidget::draw(const DrawArgs& args) {}
|
|
void ModuleWidget::drawLayer(const DrawArgs& args, int layer) {}
|
|
void ModuleWidget::onHover(const HoverEvent& e) {}
|
|
void ModuleWidget::onHoverKey(const HoverKeyEvent& e) {}
|
|
void ModuleWidget::onButton(const ButtonEvent& e) {}
|
|
void ModuleWidget::onDragStart(const DragStartEvent& e) {}
|
|
void ModuleWidget::onDragEnd(const DragEndEvent& e) {}
|
|
void ModuleWidget::onDragMove(const DragMoveEvent& e) {}
|
|
void ModuleWidget::onDragHover(const DragHoverEvent& e) {}
|
|
json_t* ModuleWidget::toJson() { return nullptr; }
|
|
void ModuleWidget::fromJson(json_t* rootJ) {}
|
|
bool ModuleWidget::pasteJsonAction(json_t* rootJ) { return false; }
|
|
void ModuleWidget::copyClipboard() {}
|
|
bool ModuleWidget::pasteClipboardAction() { return false; }
|
|
void ModuleWidget::load(std::string filename) {}
|
|
void ModuleWidget::loadAction(std::string filename) {}
|
|
void ModuleWidget::loadTemplate() {}
|
|
void ModuleWidget::loadDialog() {}
|
|
void ModuleWidget::save(std::string filename) {}
|
|
void ModuleWidget::saveTemplate() {}
|
|
void ModuleWidget::saveTemplateDialog() {}
|
|
bool ModuleWidget::hasTemplate() { return false; }
|
|
void ModuleWidget::clearTemplate() {}
|
|
void ModuleWidget::clearTemplateDialog() {}
|
|
void ModuleWidget::saveDialog() {}
|
|
void ModuleWidget::disconnect() {}
|
|
void ModuleWidget::resetAction() {}
|
|
void ModuleWidget::randomizeAction() {}
|
|
void ModuleWidget::appendDisconnectActions(history::ComplexAction* complexAction) {}
|
|
void ModuleWidget::disconnectAction() {}
|
|
void ModuleWidget::cloneAction(bool cloneCables) {}
|
|
void ModuleWidget::bypassAction(bool bypassed) {}
|
|
void ModuleWidget::removeAction() {}
|
|
void ModuleWidget::createContextMenu() {}
|
|
math::Vec& ModuleWidget::dragOffset() { static math::Vec r; return r; }
|
|
bool& ModuleWidget::dragEnabled() { static bool r; return r; }
|
|
math::Vec& ModuleWidget::oldPos() { static math::Vec r; return r; }
|
|
engine::Module* ModuleWidget::releaseModule() { return nullptr; }
|
|
|
|
int MultiLightWidget::getNumColors() { return 0; }
|
|
void MultiLightWidget::addBaseColor(NVGcolor baseColor) {}
|
|
void MultiLightWidget::setBrightnesses(const std::vector<float>& brightnesses) {}
|
|
|
|
ParamWidget::ParamWidget() {}
|
|
ParamWidget::~ParamWidget() {}
|
|
engine::ParamQuantity* ParamWidget::getParamQuantity() { return nullptr; }
|
|
void ParamWidget::createTooltip() {}
|
|
void ParamWidget::destroyTooltip() {}
|
|
void ParamWidget::step() {}
|
|
void ParamWidget::draw(const DrawArgs& args) {}
|
|
void ParamWidget::onButton(const ButtonEvent& e) {}
|
|
void ParamWidget::onDoubleClick(const DoubleClickEvent& e) {}
|
|
void ParamWidget::onEnter(const EnterEvent& e) {}
|
|
void ParamWidget::onLeave(const LeaveEvent& e) {}
|
|
void ParamWidget::createContextMenu() {}
|
|
void ParamWidget::resetAction() {}
|
|
|
|
PortWidget::PortWidget() {}
|
|
PortWidget::~PortWidget() {}
|
|
engine::Port* PortWidget::getPort() { return nullptr; }
|
|
engine::PortInfo* PortWidget::getPortInfo() { return nullptr; }
|
|
void PortWidget::createTooltip() {}
|
|
void PortWidget::destroyTooltip() {}
|
|
void PortWidget::createContextMenu() {}
|
|
void PortWidget::deleteTopCableAction() {}
|
|
void PortWidget::step() {}
|
|
void PortWidget::draw(const DrawArgs& args) {}
|
|
void PortWidget::onButton(const ButtonEvent& e) {}
|
|
void PortWidget::onEnter(const EnterEvent& e) {}
|
|
void PortWidget::onLeave(const LeaveEvent& e) {}
|
|
void PortWidget::onDragStart(const DragStartEvent& e) {}
|
|
void PortWidget::onDragEnd(const DragEndEvent& e) {}
|
|
void PortWidget::onDragDrop(const DragDropEvent& e) {}
|
|
void PortWidget::onDragEnter(const DragEnterEvent& e) {}
|
|
void PortWidget::onDragLeave(const DragLeaveEvent& e) {}
|
|
|
|
SliderKnob::SliderKnob() {}
|
|
void SliderKnob::onHover(const HoverEvent& e) {}
|
|
void SliderKnob::onButton(const ButtonEvent& e) {}
|
|
|
|
SvgKnob::SvgKnob() {}
|
|
void SvgKnob::setSvg(std::shared_ptr<window::Svg> svg) {}
|
|
void SvgKnob::onChange(const ChangeEvent& e) {}
|
|
|
|
SvgPort::SvgPort() {}
|
|
void SvgPort::setSvg(std::shared_ptr<window::Svg> svg) {}
|
|
|
|
SvgScrew::SvgScrew() {}
|
|
void SvgScrew::setSvg(std::shared_ptr<window::Svg> svg) {}
|
|
|
|
SvgSlider::SvgSlider() {}
|
|
void SvgSlider::setBackgroundSvg(std::shared_ptr<window::Svg> svg) {}
|
|
void SvgSlider::setHandleSvg(std::shared_ptr<window::Svg> svg) {}
|
|
void SvgSlider::setHandlePos(math::Vec minHandlePos, math::Vec maxHandlePos) {}
|
|
void SvgSlider::setHandlePosCentered(math::Vec minHandlePosCentered, math::Vec maxHandlePosCentered) {}
|
|
void SvgSlider::onChange(const ChangeEvent& e) {}
|
|
|
|
}
|
|
|
|
namespace engine {
|
|
|
|
std::string LightInfo::getName() { return name; }
|
|
std::string LightInfo::getDescription() { return description; }
|
|
|
|
}
|
|
|
|
namespace widget {
|
|
|
|
FramebufferWidget::FramebufferWidget() {}
|
|
FramebufferWidget::~FramebufferWidget() {}
|
|
void FramebufferWidget::setDirty(bool dirty) {}
|
|
int FramebufferWidget::getImageHandle() { return 0; }
|
|
NVGLUframebuffer* FramebufferWidget::getFramebuffer() { return nullptr; }
|
|
math::Vec FramebufferWidget::getFramebufferSize() { return {}; }
|
|
void FramebufferWidget::deleteFramebuffer() {}
|
|
void FramebufferWidget::step() {}
|
|
void FramebufferWidget::draw(const DrawArgs& args) {}
|
|
void FramebufferWidget::render(math::Vec scale, math::Vec offsetF, math::Rect clipBox) {}
|
|
void FramebufferWidget::drawFramebuffer() {}
|
|
void FramebufferWidget::onDirty(const DirtyEvent& e) {}
|
|
void FramebufferWidget::onContextCreate(const ContextCreateEvent& e) {}
|
|
void FramebufferWidget::onContextDestroy(const ContextDestroyEvent& e) {}
|
|
|
|
SvgWidget::SvgWidget() {}
|
|
void SvgWidget::wrap() {}
|
|
void SvgWidget::setSvg(std::shared_ptr<window::Svg> svg) {}
|
|
void SvgWidget::draw(const DrawArgs& args) {}
|
|
|
|
Widget::~Widget() {}
|
|
math::Rect Widget::getBox() { return {}; }
|
|
void Widget::setBox(math::Rect box) {}
|
|
math::Vec Widget::getPosition() { return {}; }
|
|
void Widget::setPosition(math::Vec pos) {}
|
|
math::Vec Widget::getSize() { return {}; }
|
|
void Widget::setSize(math::Vec size) {}
|
|
widget::Widget* Widget::getParent() { return nullptr; }
|
|
bool Widget::isVisible() { return false; }
|
|
void Widget::setVisible(bool visible) {}
|
|
void Widget::requestDelete() {}
|
|
math::Rect Widget::getChildrenBoundingBox() { return {}; }
|
|
math::Rect Widget::getVisibleChildrenBoundingBox() { return {}; }
|
|
bool Widget::isDescendantOf(Widget* ancestor) { return false; }
|
|
math::Vec Widget::getRelativeOffset(math::Vec v, Widget* ancestor) { return {}; }
|
|
float Widget::getRelativeZoom(Widget* ancestor) { return 0.0f; }
|
|
math::Rect Widget::getViewport(math::Rect r) { return {}; }
|
|
bool Widget::hasChild(Widget* child) { return false; }
|
|
void Widget::addChild(Widget* child) {}
|
|
void Widget::addChildBottom(Widget* child) {}
|
|
void Widget::addChildBelow(Widget* child, Widget* sibling) {}
|
|
void Widget::addChildAbove(Widget* child, Widget* sibling) {}
|
|
void Widget::removeChild(Widget* child) {}
|
|
void Widget::clearChildren() {}
|
|
void Widget::step() {}
|
|
void Widget::draw(const DrawArgs& args) {}
|
|
void Widget::drawLayer(const DrawArgs& args, int layer) {}
|
|
void Widget::drawChild(Widget* child, const DrawArgs& args, int layer) {}
|
|
|
|
}
|
|
|
|
namespace window {
|
|
|
|
Svg::~Svg() {}
|
|
void Svg::loadFile(const std::string& filename) {}
|
|
void Svg::loadString(const std::string& str) {}
|
|
math::Vec Svg::getSize() { return {}; }
|
|
int Svg::getNumShapes() { return 0; }
|
|
int Svg::getNumPaths() { return 0; }
|
|
int Svg::getNumPoints() { return 0; }
|
|
void Svg::draw(NVGcontext* vg) {}
|
|
std::shared_ptr<Svg> Svg::load(const std::string& filename) { return {}; }
|
|
|
|
}
|
|
|
|
}
|