DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 18 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
398 Commits
6 Branches
280MB
Tree: 866fd16b10
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '866fd16b10'
${ noResults }
Cardinal/lv2export/dep2.cpp

273 lines
11KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 3 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the LICENSE file.

  16.  */

  17. 

  18. #define PRIVATE

  19. #include <common.hpp>

  20. 

  21. #undef PRIVATE

  22. #include <rack.hpp>

  23. 

  24. using namespace rack;

  25. 

  26. namespace rack {

  27. namespace settings {

  28. bool cpuMeter = false;

  29. }

  30. Exception::Exception(const char* format, ...)

  31. {

  32.     va_list args;

  33.     va_start(args, format);

  34.     msg = string::fV(format, args);

  35.     va_end(args);

  36. }

  37. namespace asset {

  38. std::string plugin(plugin::Plugin* plugin, std::string filename) { return {}; }

  39. std::string system(std::string filename) { return {}; }

  40. }

  41. namespace engine {

  42. float Engine::getParamValue(Module* module, int paramId) { return 0.0f; }

  43. float Engine::getParamSmoothValue(Module* module, int paramId) { return 0.0f; }

  44. void Engine::setParamValue(Module* module, int paramId, float value) {}

  45. void Engine::setParamSmoothValue(Module* module, int paramId, float value) {}

  46. }

  47. }

  48. 

  49. namespace rack {

  50. namespace app {

  51. 

  52. Knob::Knob() {}

  53. Knob::~Knob() {}

  54. void Knob::initParamQuantity() {}

  55. void Knob::onHover(const HoverEvent& e) {}

  56. void Knob::onButton(const ButtonEvent& e) {}

  57. void Knob::onDragStart(const DragStartEvent& e) {}

  58. void Knob::onDragEnd(const DragEndEvent& e) {}

  59. void Knob::onDragMove(const DragMoveEvent& e) {}

  60. void Knob::onDragLeave(const DragLeaveEvent& e) {}

  61. void Knob::onHoverScroll(const HoverScrollEvent& e) {}

  62. void Knob::onLeave(const LeaveEvent& e) {}

  63. 

  64. void LightWidget::draw(const DrawArgs& args) {}

  65. void LightWidget::drawLayer(const DrawArgs& args, int layer) {}

  66. void LightWidget::drawBackground(const DrawArgs& args) {}

  67. void LightWidget::drawLight(const DrawArgs& args) {}

  68. void LightWidget::drawHalo(const DrawArgs& args) {}

  69. 

  70. ModuleLightWidget::~ModuleLightWidget() {}

  71. engine::Light* ModuleLightWidget::getLight(int colorId) { return nullptr; }

  72. engine::LightInfo* ModuleLightWidget::getLightInfo() { return nullptr; }

  73. void ModuleLightWidget::createTooltip() {}

  74. void ModuleLightWidget::destroyTooltip() {}

  75. void ModuleLightWidget::step() {}

  76. void ModuleLightWidget::onHover(const HoverEvent& e) {}

  77. void ModuleLightWidget::onEnter(const EnterEvent& e) {}

  78. void ModuleLightWidget::onLeave(const LeaveEvent& e) {}

  79. 

  80. ModuleWidget::ModuleWidget() {}

  81. ModuleWidget::~ModuleWidget() {}

  82. plugin::Model* ModuleWidget::getModel() { return nullptr; }

  83. void ModuleWidget::setModel(plugin::Model* model) {}

  84. engine::Module* ModuleWidget::getModule() { return nullptr; }

  85. void ModuleWidget::setModule(engine::Module* module) {}

  86. widget::Widget* ModuleWidget::getPanel() { return nullptr; }

  87. void ModuleWidget::setPanel(widget::Widget* panel) {}

  88. void ModuleWidget::setPanel(std::shared_ptr<window::Svg> svg) {}

  89. void ModuleWidget::addParam(ParamWidget* param) {}

  90. void ModuleWidget::addInput(PortWidget* input) {}

  91. void ModuleWidget::addOutput(PortWidget* output) {}

  92. ParamWidget* ModuleWidget::getParam(int paramId) { return nullptr; }

  93. PortWidget* ModuleWidget::getInput(int portId) { return nullptr; }

  94. PortWidget* ModuleWidget::getOutput(int portId) { return nullptr; }

  95. std::vector<ParamWidget*> ModuleWidget::getParams() { return {}; }

  96. std::vector<PortWidget*> ModuleWidget::getPorts() { return {}; }

  97. std::vector<PortWidget*> ModuleWidget::getInputs() { return {}; }

  98. std::vector<PortWidget*> ModuleWidget::getOutputs() { return {}; }

  99. void ModuleWidget::draw(const DrawArgs& args) {}

  100. void ModuleWidget::drawLayer(const DrawArgs& args, int layer) {}

  101. void ModuleWidget::onHover(const HoverEvent& e) {}

  102. void ModuleWidget::onHoverKey(const HoverKeyEvent& e) {}

  103. void ModuleWidget::onButton(const ButtonEvent& e) {}

  104. void ModuleWidget::onDragStart(const DragStartEvent& e) {}

  105. void ModuleWidget::onDragEnd(const DragEndEvent& e) {}

  106. void ModuleWidget::onDragMove(const DragMoveEvent& e) {}

  107. void ModuleWidget::onDragHover(const DragHoverEvent& e) {}

  108. json_t* ModuleWidget::toJson() { return nullptr; }

  109. void ModuleWidget::fromJson(json_t* rootJ) {}

  110. bool ModuleWidget::pasteJsonAction(json_t* rootJ) { return false; }

  111. void ModuleWidget::copyClipboard() {}

  112. bool ModuleWidget::pasteClipboardAction() { return false; }

  113. void ModuleWidget::load(std::string filename) {}

  114. void ModuleWidget::loadAction(std::string filename) {}

  115. void ModuleWidget::loadTemplate() {}

  116. void ModuleWidget::loadDialog() {}

  117. void ModuleWidget::save(std::string filename) {}

  118. void ModuleWidget::saveTemplate() {}

  119. void ModuleWidget::saveTemplateDialog() {}

  120. bool ModuleWidget::hasTemplate() { return false; }

  121. void ModuleWidget::clearTemplate() {}

  122. void ModuleWidget::clearTemplateDialog() {}

  123. void ModuleWidget::saveDialog() {}

  124. void ModuleWidget::disconnect() {}

  125. void ModuleWidget::resetAction() {}

  126. void ModuleWidget::randomizeAction() {}

  127. void ModuleWidget::appendDisconnectActions(history::ComplexAction* complexAction) {}

  128. void ModuleWidget::disconnectAction() {}

  129. void ModuleWidget::cloneAction(bool cloneCables) {}

  130. void ModuleWidget::bypassAction(bool bypassed) {}

  131. void ModuleWidget::removeAction() {}

  132. void ModuleWidget::createContextMenu() {}

  133. math::Vec& ModuleWidget::dragOffset() { static math::Vec r; return r; }

  134. bool& ModuleWidget::dragEnabled() { static bool r; return r; }

  135. math::Vec& ModuleWidget::oldPos() { static math::Vec r; return r; }

  136. engine::Module* ModuleWidget::releaseModule() { return nullptr; }

  137. 

  138. int MultiLightWidget::getNumColors() { return 0; }

  139. void MultiLightWidget::addBaseColor(NVGcolor baseColor) {}

  140. void MultiLightWidget::setBrightnesses(const std::vector<float>& brightnesses) {}

  141. 

  142. ParamWidget::ParamWidget() {}

  143. ParamWidget::~ParamWidget() {}

  144. engine::ParamQuantity* ParamWidget::getParamQuantity() { return nullptr; }

  145. void ParamWidget::createTooltip() {}

  146. void ParamWidget::destroyTooltip() {}

  147. void ParamWidget::step() {}

  148. void ParamWidget::draw(const DrawArgs& args) {}

  149. void ParamWidget::onButton(const ButtonEvent& e) {}

  150. void ParamWidget::onDoubleClick(const DoubleClickEvent& e) {}

  151. void ParamWidget::onEnter(const EnterEvent& e) {}

  152. void ParamWidget::onLeave(const LeaveEvent& e) {}

  153. void ParamWidget::createContextMenu() {}

  154. void ParamWidget::resetAction() {}

  155. 

  156. PortWidget::PortWidget() {}

  157. PortWidget::~PortWidget() {}

  158. engine::Port* PortWidget::getPort() { return nullptr; }

  159. engine::PortInfo* PortWidget::getPortInfo() { return nullptr; }

  160. void PortWidget::createTooltip() {}

  161. void PortWidget::destroyTooltip() {}

  162. void PortWidget::createContextMenu() {}

  163. void PortWidget::deleteTopCableAction() {}

  164. void PortWidget::step() {}

  165. void PortWidget::draw(const DrawArgs& args) {}

  166. void PortWidget::onButton(const ButtonEvent& e) {}

  167. void PortWidget::onEnter(const EnterEvent& e) {}

  168. void PortWidget::onLeave(const LeaveEvent& e) {}

  169. void PortWidget::onDragStart(const DragStartEvent& e) {}

  170. void PortWidget::onDragEnd(const DragEndEvent& e) {}

  171. void PortWidget::onDragDrop(const DragDropEvent& e) {}

  172. void PortWidget::onDragEnter(const DragEnterEvent& e) {}

  173. void PortWidget::onDragLeave(const DragLeaveEvent& e) {}

  174. 

  175. SliderKnob::SliderKnob() {}

  176. void SliderKnob::onHover(const HoverEvent& e) {}

  177. void SliderKnob::onButton(const ButtonEvent& e) {}

  178. 

  179. SvgKnob::SvgKnob() {}

  180. void SvgKnob::setSvg(std::shared_ptr<window::Svg> svg) {}

  181. void SvgKnob::onChange(const ChangeEvent& e) {}

  182. 

  183. SvgPort::SvgPort() {}

  184. void SvgPort::setSvg(std::shared_ptr<window::Svg> svg) {}

  185. 

  186. SvgScrew::SvgScrew() {}

  187. void SvgScrew::setSvg(std::shared_ptr<window::Svg> svg) {}

  188. 

  189. SvgSlider::SvgSlider() {}

  190. void SvgSlider::setBackgroundSvg(std::shared_ptr<window::Svg> svg) {}

  191. void SvgSlider::setHandleSvg(std::shared_ptr<window::Svg> svg) {}

  192. void SvgSlider::setHandlePos(math::Vec minHandlePos, math::Vec maxHandlePos) {}

  193. void SvgSlider::setHandlePosCentered(math::Vec minHandlePosCentered, math::Vec maxHandlePosCentered) {}

  194. void SvgSlider::onChange(const ChangeEvent& e) {}

  195. 

  196. }

  197. 

  198. namespace engine {

  199. 

  200. std::string LightInfo::getName() { return name; }

  201. std::string LightInfo::getDescription() { return description; }

  202. 

  203. }

  204. 

  205. namespace widget {

  206. 

  207. FramebufferWidget::FramebufferWidget() {}

  208. FramebufferWidget::~FramebufferWidget() {}

  209. void FramebufferWidget::setDirty(bool dirty) {}

  210. int FramebufferWidget::getImageHandle() { return 0; }

  211. NVGLUframebuffer* FramebufferWidget::getFramebuffer() { return nullptr; }

  212. math::Vec FramebufferWidget::getFramebufferSize() { return {}; }

  213. void FramebufferWidget::deleteFramebuffer() {}

  214. void FramebufferWidget::step() {}

  215. void FramebufferWidget::draw(const DrawArgs& args) {}

  216. void FramebufferWidget::render(math::Vec scale, math::Vec offsetF, math::Rect clipBox) {}

  217. void FramebufferWidget::drawFramebuffer() {}

  218. void FramebufferWidget::onDirty(const DirtyEvent& e) {}

  219. void FramebufferWidget::onContextCreate(const ContextCreateEvent& e) {}

  220. void FramebufferWidget::onContextDestroy(const ContextDestroyEvent& e) {}

  221. 

  222. SvgWidget::SvgWidget() {}

  223. void SvgWidget::wrap() {}

  224. void SvgWidget::setSvg(std::shared_ptr<window::Svg> svg) {}

  225. void SvgWidget::draw(const DrawArgs& args) {}

  226. 

  227. Widget::~Widget() {}

  228. math::Rect Widget::getBox() { return {}; }

  229. void Widget::setBox(math::Rect box) {}

  230. math::Vec Widget::getPosition() { return {}; }

  231. void Widget::setPosition(math::Vec pos) {}

  232. math::Vec Widget::getSize() { return {}; }

  233. void Widget::setSize(math::Vec size) {}

  234. widget::Widget* Widget::getParent() { return nullptr; }

  235. bool Widget::isVisible() { return false; }

  236. void Widget::setVisible(bool visible) {}

  237. void Widget::requestDelete() {}

  238. math::Rect Widget::getChildrenBoundingBox() { return {}; }

  239. math::Rect Widget::getVisibleChildrenBoundingBox() { return {}; }

  240. bool Widget::isDescendantOf(Widget* ancestor) { return false; }

  241. math::Vec Widget::getRelativeOffset(math::Vec v, Widget* ancestor) { return {}; }

  242. float Widget::getRelativeZoom(Widget* ancestor) { return 0.0f; }

  243. math::Rect Widget::getViewport(math::Rect r) { return {}; }

  244. bool Widget::hasChild(Widget* child) { return false; }

  245. void Widget::addChild(Widget* child) {}

  246. void Widget::addChildBottom(Widget* child) {}

  247. void Widget::addChildBelow(Widget* child, Widget* sibling) {}

  248. void Widget::addChildAbove(Widget* child, Widget* sibling) {}

  249. void Widget::removeChild(Widget* child) {}

  250. void Widget::clearChildren() {}

  251. void Widget::step() {}

  252. void Widget::draw(const DrawArgs& args) {}

  253. void Widget::drawLayer(const DrawArgs& args, int layer) {}

  254. void Widget::drawChild(Widget* child, const DrawArgs& args, int layer) {}

  255. 

  256. }

  257. 

  258. namespace window {

  259. 

  260. Svg::~Svg() {}

  261. void Svg::loadFile(const std::string& filename) {}

  262. void Svg::loadString(const std::string& str) {}

  263. math::Vec Svg::getSize() { return {}; }

  264. int Svg::getNumShapes() { return 0; }

  265. int Svg::getNumPaths() { return 0; }

  266. int Svg::getNumPoints() { return 0; }

  267. void Svg::draw(NVGcontext* vg) {}

  268. std::shared_ptr<Svg> Svg::load(const std::string& filename) { return {}; }

  269. 

  270. }

  271. 

  272. }