DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 20 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.
1070 Commits
12 Branches
44MB
Tree: 2c98fe7388
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2c98fe7388'
${ noResults }
Cardinal/src/CardinalUI.cpp

869 lines
28KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021-2022 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. #include <app/MenuBar.hpp>

  19. #include <app/Scene.hpp>

  20. #include <asset.hpp>

  21. #include <context.hpp>

  22. #include <engine/Engine.hpp>

  23. #include <helpers.hpp>

  24. #include <patch.hpp>

  25. #include <settings.hpp>

  26. #include <string.hpp>

  27. #include <system.hpp>

  28. #include <ui/Button.hpp>

  29. #include <ui/MenuItem.hpp>

  30. #include <ui/MenuSeparator.hpp>

  31. #include <window/Window.hpp>

  32. 

  33. #ifdef NDEBUG

  34. # undef DEBUG

  35. #endif

  36. 

  37. #include <Application.hpp>

  38. #include "AsyncDialog.hpp"

  39. #include "PluginContext.hpp"

  40. #include "WindowParameters.hpp"

  41. 

  42. GLFWAPI int glfwGetKeyScancode(int) { return 0; }

  43. 

  44. GLFWAPI const char* glfwGetClipboardString(GLFWwindow*)

  45. {

  46.     CardinalPluginContext* const context = static_cast<CardinalPluginContext*>(APP);

  47.     DISTRHO_SAFE_ASSERT_RETURN(context != nullptr, nullptr);

  48.     DISTRHO_SAFE_ASSERT_RETURN(context->ui != nullptr, nullptr);

  49. 

  50.     size_t dataSize;

  51.     return static_cast<const char*>(context->ui->getClipboard(dataSize));

  52. }

  53. 

  54. GLFWAPI void glfwSetClipboardString(GLFWwindow*, const char* const text)

  55. {

  56.     DISTRHO_SAFE_ASSERT_RETURN(text != nullptr,);

  57. 

  58.     CardinalPluginContext* const context = static_cast<CardinalPluginContext*>(APP);

  59.     DISTRHO_SAFE_ASSERT_RETURN(context != nullptr,);

  60.     DISTRHO_SAFE_ASSERT_RETURN(context->ui != nullptr,);

  61. 

  62.     context->ui->setClipboard(nullptr, text, std::strlen(text)+1);

  63. }

  64. 

  65. GLFWAPI void glfwSetCursor(GLFWwindow*, GLFWcursor* const cursor)

  66. {

  67.     CardinalPluginContext* const context = static_cast<CardinalPluginContext*>(APP);

  68.     DISTRHO_SAFE_ASSERT_RETURN(context != nullptr,);

  69.     DISTRHO_SAFE_ASSERT_RETURN(context->ui != nullptr,);

  70. 

  71.     context->ui->setCursor(cursor != nullptr ? kMouseCursorDiagonal : kMouseCursorArrow);

  72. }

  73. 

  74. GLFWAPI double glfwGetTime(void)

  75. {

  76.     CardinalPluginContext* const context = static_cast<CardinalPluginContext*>(APP);

  77.     DISTRHO_SAFE_ASSERT_RETURN(context != nullptr, 0.0);

  78.     DISTRHO_SAFE_ASSERT_RETURN(context->ui != nullptr, 0.0);

  79. 

  80.     return context->ui->getApp().getTime();

  81. }

  82. 

  83. GLFWAPI const char* glfwGetKeyName(const int key, int)

  84. {

  85.     switch (key)

  86.     {

  87.     case '\"': return "\"";

  88.     case '\'': return "\'";

  89.     case '\\': return "\\";

  90.     case ' ': return " ";

  91.     case '!': return "!";

  92.     case '#': return "#";

  93.     case '$': return "$";

  94.     case '%': return "%";

  95.     case '&': return "&";

  96.     case '(': return "(";

  97.     case ')': return ")";

  98.     case '*': return "*";

  99.     case '+': return "+";

  100.     case ',': return ",";

  101.     case '-': return "-";

  102.     case '.': return ".";

  103.     case '/': return "/";

  104.     case '0': return "0";

  105.     case '1': return "1";

  106.     case '2': return "2";

  107.     case '3': return "3";

  108.     case '4': return "4";

  109.     case '5': return "5";

  110.     case '6': return "6";

  111.     case '7': return "7";

  112.     case '8': return "8";

  113.     case '9': return "9";

  114.     case ':': return ":";

  115.     case ';': return ";";

  116.     case '<': return "<";

  117.     case '=': return "=";

  118.     case '>': return ">";

  119.     case '?': return "?";

  120.     case '@': return "@";

  121.     /* Rack expects lowercase, forced below

  122.     case 'A': return "A";

  123.     case 'B': return "B";

  124.     case 'C': return "C";

  125.     case 'D': return "D";

  126.     case 'E': return "E";

  127.     case 'F': return "F";

  128.     case 'G': return "G";

  129.     case 'H': return "H";

  130.     case 'I': return "I";

  131.     case 'J': return "J";

  132.     case 'K': return "K";

  133.     case 'L': return "L";

  134.     case 'M': return "M";

  135.     case 'N': return "N";

  136.     case 'O': return "O";

  137.     case 'P': return "P";

  138.     case 'Q': return "Q";

  139.     case 'R': return "R";

  140.     case 'S': return "S";

  141.     case 'T': return "T";

  142.     case 'U': return "U";

  143.     case 'V': return "V";

  144.     case 'W': return "W";

  145.     case 'X': return "X";

  146.     case 'Y': return "Y";

  147.     case 'Z': return "Z";

  148.     */

  149.     case '[': return "[";

  150.     case ']': return "]";

  151.     case '^': return "^";

  152.     case '_': return "_";

  153.     case '`': return "`";

  154.     case 'a': case 'A': return "a";

  155.     case 'b': case 'B': return "b";

  156.     case 'c': case 'C': return "c";

  157.     case 'd': case 'D': return "d";

  158.     case 'e': case 'E': return "e";

  159.     case 'f': case 'F': return "f";

  160.     case 'g': case 'G': return "g";

  161.     case 'h': case 'H': return "h";

  162.     case 'i': case 'I': return "i";

  163.     case 'j': case 'J': return "j";

  164.     case 'k': case 'K': return "k";

  165.     case 'l': case 'L': return "l";

  166.     case 'm': case 'M': return "m";

  167.     case 'n': case 'N': return "n";

  168.     case 'o': case 'O': return "o";

  169.     case 'p': case 'P': return "p";

  170.     case 'q': case 'Q': return "q";

  171.     case 'r': case 'R': return "r";

  172.     case 's': case 'S': return "s";

  173.     case 't': case 'T': return "t";

  174.     case 'u': case 'U': return "u";

  175.     case 'v': case 'V': return "v";

  176.     case 'w': case 'W': return "w";

  177.     case 'x': case 'X': return "x";

  178.     case 'y': case 'Y': return "y";

  179.     case 'z': case 'Z': return "z";

  180.     default: return nullptr;

  181.     }

  182. }

  183. 

  184. namespace rack {

  185. namespace app {

  186.     widget::Widget* createMenuBar(bool isStandalone);

  187. }

  188. namespace window {

  189.     void WindowSetPluginUI(Window* window, DISTRHO_NAMESPACE::UI* ui);

  190.     void WindowSetMods(Window* window, int mods);

  191. }

  192. }

  193. 

  194. START_NAMESPACE_DISTRHO

  195. 

  196. // -----------------------------------------------------------------------------------------------------------

  197. 

  198. bool CardinalPluginContext::addIdleCallback(IdleCallback* const cb) const

  199. {

  200.     if (ui == nullptr)

  201.         return false;

  202. 

  203.     ui->addIdleCallback(cb);

  204.     return true;

  205. }

  206. 

  207. void CardinalPluginContext::removeIdleCallback(IdleCallback* const cb) const

  208. {

  209.     if (ui == nullptr)

  210.         return;

  211. 

  212.     ui->removeIdleCallback(cb);

  213. }

  214. 

  215. void handleHostParameterDrag(const CardinalPluginContext* pcontext, uint index, bool started)

  216. {

  217.     DISTRHO_SAFE_ASSERT_RETURN(pcontext->ui != nullptr,);

  218. 

  219.     if (started)

  220.     {

  221.         pcontext->ui->editParameter(index, true);

  222.         pcontext->ui->setParameterValue(index, pcontext->parameters[index]);

  223.     }

  224.     else

  225.     {

  226.         pcontext->ui->editParameter(index, false);

  227.     }

  228. }

  229. 

  230. // -----------------------------------------------------------------------------------------------------------

  231. 

  232. class CardinalUI : public CardinalBaseUI,

  233.                    public WindowParametersCallback

  234. {

  235.     rack::math::Vec lastMousePos;

  236.     WindowParameters windowParameters;

  237.     int rateLimitStep = 0;

  238.     int8_t counterForSelfFocus = 0;

  239. 

  240.     struct ScopedContext {

  241.         CardinalPluginContext* const context;

  242. 

  243.         ScopedContext(CardinalUI* const ui)

  244.             : context(ui->context)

  245.         {

  246.             rack::contextSet(context);

  247.             WindowParametersRestore(context->window);

  248.         }

  249. 

  250.         ScopedContext(CardinalUI* const ui, const int mods)

  251.             : context(ui->context)

  252.         {

  253.             rack::contextSet(context);

  254.             rack::window::WindowSetMods(context->window, mods);

  255.             WindowParametersRestore(context->window);

  256.         }

  257. 

  258.         ~ScopedContext()

  259.         {

  260.             if (context->window != nullptr)

  261.                 WindowParametersSave(context->window);

  262.         }

  263.     };

  264. 

  265. public:

  266.     CardinalUI()

  267.         : CardinalBaseUI(1228, 666)

  268.     {

  269.         Window& window(getWindow());

  270. 

  271.         window.setIgnoringKeyRepeat(true);

  272.         context->nativeWindowId = window.getNativeWindowHandle();

  273. 

  274.         const double scaleFactor = getScaleFactor();

  275. 

  276.         setGeometryConstraints(648 * scaleFactor, 538 * scaleFactor);

  277. 

  278.         if (scaleFactor != 1.0)

  279.             setSize(1228 * scaleFactor, 666 * scaleFactor);

  280. 

  281.         rack::contextSet(context);

  282. 

  283.         rack::window::WindowSetPluginUI(context->window, this);

  284. 

  285.         if (rack::widget::Widget* const menuBar = context->scene->menuBar)

  286.         {

  287.             context->scene->removeChild(menuBar);

  288.             delete menuBar;

  289.         }

  290. 

  291.         context->scene->menuBar = rack::app::createMenuBar(getApp().isStandalone());

  292.         context->scene->addChildBelow(context->scene->menuBar, context->scene->rackScroll);

  293. 

  294.         // hide "Browse VCV Library" button

  295.         rack::widget::Widget* const browser = context->scene->browser->children.back();

  296.         rack::widget::Widget* const headerLayout = browser->children.front();

  297.         rack::widget::Widget* const libraryButton = headerLayout->children.back();

  298.         libraryButton->hide();

  299. 

  300.         // Report to user if something is wrong with the installation

  301.         std::string errorMessage;

  302. 

  303.         if (rack::asset::systemDir.empty())

  304.         {

  305.             errorMessage = "Failed to locate Cardinal plugin bundle.\n"

  306.                            "Install Cardinal with its plugin bundle folder intact and try again.";

  307.         }

  308.         else if (! rack::system::exists(rack::asset::systemDir))

  309.         {

  310.             errorMessage = rack::string::f("System directory \"%s\" does not exist. "

  311.                                            "Make sure Cardinal was downloaded and installed correctly.",

  312.                                            rack::asset::systemDir.c_str());

  313.         }

  314. 

  315.         if (! errorMessage.empty())

  316.         {

  317.             static bool shown = false;

  318. 

  319.             if (! shown)

  320.             {

  321.                 shown = true;

  322.                 asyncDialog::create(errorMessage.c_str());

  323.             }

  324.         }

  325. 

  326.         context->window->step();

  327. 

  328.         rack::contextSet(nullptr);

  329. 

  330.         WindowParametersSetCallback(context->window, this);

  331.     }

  332. 

  333.     ~CardinalUI() override

  334.     {

  335.         rack::contextSet(context);

  336. 

  337.         context->nativeWindowId = 0;

  338. 

  339.         if (rack::widget::Widget* const menuBar = context->scene->menuBar)

  340.         {

  341.             context->scene->removeChild(menuBar);

  342.             delete menuBar;

  343.         }

  344. 

  345.         context->scene->menuBar = rack::app::createMenuBar();

  346.         context->scene->addChildBelow(context->scene->menuBar, context->scene->rackScroll);

  347. 

  348.         rack::window::WindowSetPluginUI(context->window, nullptr);

  349. 

  350.         rack::contextSet(nullptr);

  351.     }

  352. 

  353.     void onNanoDisplay() override

  354.     {

  355.         const ScopedContext sc(this);

  356.         context->window->step();

  357.     }

  358. 

  359.     void uiIdle() override

  360.     {

  361.         if (counterForSelfFocus >= 0 && ++counterForSelfFocus == 5)

  362.         {

  363.             counterForSelfFocus = -1;

  364.             getWindow().focus();

  365.         }

  366. 

  367.         if (filebrowserhandle != nullptr && fileBrowserIdle(filebrowserhandle))

  368.         {

  369.             {

  370.                 const char* const path = fileBrowserGetPath(filebrowserhandle);

  371. 

  372.                 const ScopedContext sc(this);

  373.                 filebrowseraction(path != nullptr ? strdup(path) : nullptr);

  374.             }

  375. 

  376.             fileBrowserClose(filebrowserhandle);

  377.             filebrowseraction = nullptr;

  378.             filebrowserhandle = nullptr;

  379.         }

  380. 

  381.         if (windowParameters.rateLimit != 0 && ++rateLimitStep % (windowParameters.rateLimit * 2))

  382.             return;

  383. 

  384.         rateLimitStep = 0;

  385.         repaint();

  386.     }

  387. 

  388.     void WindowParametersChanged(const WindowParameterList param, float value) override

  389.     {

  390.         float mult = 1.0f;

  391. 

  392.         switch (param)

  393.         {

  394.         case kWindowParameterShowTooltips:

  395.             windowParameters.tooltips = value > 0.5f;

  396.             break;

  397.         case kWindowParameterCableOpacity:

  398.             mult = 100.0f;

  399.             windowParameters.cableOpacity = value;

  400.             break;

  401.         case kWindowParameterCableTension:

  402.             mult = 100.0f;

  403.             windowParameters.cableTension = value;

  404.             break;

  405.         case kWindowParameterRackBrightness:

  406.             mult = 100.0f;

  407.             windowParameters.rackBrightness = value;

  408.             break;

  409.         case kWindowParameterHaloBrightness:

  410.             mult = 100.0f;

  411.             windowParameters.haloBrightness = value;

  412.             break;

  413.         case kWindowParameterKnobMode:

  414.             switch (static_cast<int>(value + 0.5f))

  415.             {

  416.             case rack::settings::KNOB_MODE_LINEAR:

  417.                 value = 0;

  418.                 windowParameters.knobMode = rack::settings::KNOB_MODE_LINEAR;

  419.                 break;

  420.             case rack::settings::KNOB_MODE_ROTARY_ABSOLUTE:

  421.                 value = 1;

  422.                 windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_ABSOLUTE;

  423.                 break;

  424.             case rack::settings::KNOB_MODE_ROTARY_RELATIVE:

  425.                 value = 2;

  426.                 windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_RELATIVE;

  427.                 break;

  428.             }

  429.             break;

  430.         case kWindowParameterWheelKnobControl:

  431.             windowParameters.knobScroll = value > 0.5f;

  432.             break;

  433.         case kWindowParameterWheelSensitivity:

  434.             mult = 1000.0f;

  435.             windowParameters.knobScrollSensitivity = value;

  436.             break;

  437.         case kWindowParameterLockModulePositions:

  438.             windowParameters.lockModules = value > 0.5f;

  439.             break;

  440.         case kWindowParameterUpdateRateLimit:

  441.             windowParameters.rateLimit = static_cast<int>(value + 0.5f);

  442.             rateLimitStep = 0;

  443.             break;

  444.         case kWindowParameterBrowserSort:

  445.             windowParameters.browserSort = static_cast<int>(value + 0.5f);

  446.             break;

  447.         case kWindowParameterBrowserZoom:

  448.             windowParameters.browserZoom = value;

  449.             value = std::pow(2.f, value) * 100.0f;

  450.             break;

  451.         case kWindowParameterInvertZoom:

  452.             windowParameters.invertZoom = value > 0.5f;

  453.             break;

  454.         default:

  455.             return;

  456.         }

  457. 

  458.         setParameterValue(kModuleParameters + param + 1, value * mult);

  459.     }

  460. 

  461. protected:

  462.    /* --------------------------------------------------------------------------------------------------------

  463.     * DSP/Plugin Callbacks */

  464. 

  465.    /**

  466.       A parameter has changed on the plugin side.

  467.       This is called by the host to inform the UI about parameter changes.

  468.     */

  469.     void parameterChanged(const uint32_t index, const float value) override

  470.     {

  471.         // host mapped parameters + bypass

  472.         if (index <= kModuleParameters)

  473.             return;

  474. 

  475.         switch (index - kModuleParameters - 1)

  476.         {

  477.         case kWindowParameterShowTooltips:

  478.             windowParameters.tooltips = value > 0.5f;

  479.             break;

  480.         case kWindowParameterCableOpacity:

  481.             windowParameters.cableOpacity = value / 100.0f;

  482.             break;

  483.         case kWindowParameterCableTension:

  484.             windowParameters.cableTension = value / 100.0f;

  485.             break;

  486.         case kWindowParameterRackBrightness:

  487.             windowParameters.rackBrightness = value / 100.0f;

  488.             break;

  489.         case kWindowParameterHaloBrightness:

  490.             windowParameters.haloBrightness = value / 100.0f;

  491.             break;

  492.         case kWindowParameterKnobMode:

  493.             switch (static_cast<int>(value + 0.5f))

  494.             {

  495.             case 0:

  496.                 windowParameters.knobMode = rack::settings::KNOB_MODE_LINEAR;

  497.                 break;

  498.             case 1:

  499.                 windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_ABSOLUTE;

  500.                 break;

  501.             case 2:

  502.                 windowParameters.knobMode = rack::settings::KNOB_MODE_ROTARY_RELATIVE;

  503.                 break;

  504.             }

  505.             break;

  506.         case kWindowParameterWheelKnobControl:

  507.             windowParameters.knobScroll = value > 0.5f;

  508.             break;

  509.         case kWindowParameterWheelSensitivity:

  510.             windowParameters.knobScrollSensitivity = value / 1000.0f;

  511.             break;

  512.         case kWindowParameterLockModulePositions:

  513.             windowParameters.lockModules = value > 0.5f;

  514.             break;

  515.         case kWindowParameterUpdateRateLimit:

  516.             windowParameters.rateLimit = static_cast<int>(value + 0.5f);

  517.             rateLimitStep = 0;

  518.             break;

  519.         case kWindowParameterBrowserSort:

  520.             windowParameters.browserSort = static_cast<int>(value + 0.5f);

  521.             break;

  522.         case kWindowParameterBrowserZoom:

  523.             // round up to nearest valid value

  524.             {

  525.                 float rvalue = value - 1.0f;

  526. 

  527.                 if (rvalue <= 25.0f)

  528.                     rvalue = -2.0f;

  529.                 else if (rvalue <= 35.0f)

  530.                     rvalue = -1.5f;

  531.                 else if (rvalue <= 50.0f)

  532.                     rvalue = -1.0f;

  533.                 else if (rvalue <= 71.0f)

  534.                     rvalue = -0.5f;

  535.                 else if (rvalue <= 100.0f)

  536.                     rvalue = 0.0f;

  537.                 else if (rvalue <= 141.0f)

  538.                     rvalue = 0.5f;

  539.                 else if (rvalue <= 200.0f)

  540.                     rvalue = 1.0f;

  541.                 else

  542.                     rvalue = 0.0f;

  543. 

  544.                 windowParameters.browserZoom = rvalue;

  545.             }

  546.             break;

  547.         case kWindowParameterInvertZoom:

  548.             windowParameters.invertZoom = value > 0.5f;

  549.             break;

  550.         default:

  551.             return;

  552.         }

  553. 

  554.         WindowParametersSetValues(context->window, windowParameters);

  555.     }

  556. 

  557.     void stateChanged(const char* const key, const char* const value) override

  558.     {

  559.         if (std::strcmp(key, "windowSize") != 0)

  560.             return;

  561. 

  562.         int width = 0;

  563.         int height = 0;

  564.         std::sscanf(value, "%i:%i", &width, &height);

  565. 

  566.         if (width > 0 && height > 0)

  567.         {

  568.             const double scaleFactor = getScaleFactor();

  569.             setSize(width * scaleFactor, height * scaleFactor);

  570.         }

  571.     }

  572. 

  573.     // -------------------------------------------------------------------------------------------------------

  574. 

  575.     static int glfwMods(const uint mod) noexcept

  576.     {

  577.         int mods = 0;

  578. 

  579.         if (mod & kModifierControl)

  580.             mods |= GLFW_MOD_CONTROL;

  581.         if (mod & kModifierShift)

  582.             mods |= GLFW_MOD_SHIFT;

  583.         if (mod & kModifierAlt)

  584.             mods |= GLFW_MOD_ALT;

  585.         if (mod & kModifierSuper)

  586.             mods |= GLFW_MOD_SUPER;

  587. 

  588.         /*

  589.         if (glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS)

  590.             mods |= GLFW_MOD_SHIFT;

  591.         if (glfwGetKey(win, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS)

  592.             mods |= GLFW_MOD_CONTROL;

  593.         if (glfwGetKey(win, GLFW_KEY_LEFT_ALT) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_ALT) == GLFW_PRESS)

  594.             mods |= GLFW_MOD_ALT;

  595.         if (glfwGetKey(win, GLFW_KEY_LEFT_SUPER) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_SUPER) == GLFW_PRESS)

  596.             mods |= GLFW_MOD_SUPER;

  597.         */

  598. 

  599.         return mods;

  600.     }

  601. 

  602.     bool onMouse(const MouseEvent& ev) override

  603.     {

  604.         const int action = ev.press ? GLFW_PRESS : GLFW_RELEASE;

  605.         int mods = glfwMods(ev.mod);

  606. 

  607.         int button;

  608. 

  609.         switch (ev.button)

  610.         {

  611.         case 1: button = GLFW_MOUSE_BUTTON_LEFT;   break;

  612.         case 2: button = GLFW_MOUSE_BUTTON_RIGHT;  break;

  613.         case 3: button = GLFW_MOUSE_BUTTON_MIDDLE; break;

  614.         default:

  615.             button = ev.button;

  616.             break;

  617.         }

  618. 

  619.        #ifdef DISTRHO_OS_MAC

  620.         // Remap Ctrl-left click to right click on macOS

  621.         if (button == GLFW_MOUSE_BUTTON_LEFT && (mods & RACK_MOD_MASK) == GLFW_MOD_CONTROL) {

  622.             button = GLFW_MOUSE_BUTTON_RIGHT;

  623.             mods &= ~GLFW_MOD_CONTROL;

  624.         }

  625.         // Remap Ctrl-shift-left click to middle click on macOS

  626.         if (button == GLFW_MOUSE_BUTTON_LEFT && (mods & RACK_MOD_MASK) == (GLFW_MOD_CONTROL | GLFW_MOD_SHIFT)) {

  627.             button = GLFW_MOUSE_BUTTON_MIDDLE;

  628.             mods &= ~(GLFW_MOD_CONTROL | GLFW_MOD_SHIFT);

  629.         }

  630.        #endif

  631. 

  632.         const ScopedContext sc(this, mods);

  633.         return context->event->handleButton(lastMousePos, button, action, mods);

  634.     }

  635. 

  636.     bool onMotion(const MotionEvent& ev) override

  637.     {

  638.         const rack::math::Vec mousePos = rack::math::Vec(ev.pos.getX(), ev.pos.getY()).div(getScaleFactor()).round();

  639.         const rack::math::Vec mouseDelta = mousePos.minus(lastMousePos);

  640. 

  641.         lastMousePos = mousePos;

  642. 

  643.         const ScopedContext sc(this, glfwMods(ev.mod));

  644.         return context->event->handleHover(mousePos, mouseDelta);

  645.     }

  646. 

  647.     bool onScroll(const ScrollEvent& ev) override

  648.     {

  649.         rack::math::Vec scrollDelta = rack::math::Vec(ev.delta.getX(), ev.delta.getY());

  650. #ifndef DISTRHO_OS_MAC

  651.         scrollDelta = scrollDelta.mult(50.0);

  652. #endif

  653. 

  654.         const int mods = glfwMods(ev.mod);

  655.         const ScopedContext sc(this, mods);

  656.         return context->event->handleScroll(lastMousePos, scrollDelta);

  657.     }

  658. 

  659.     bool onCharacterInput(const CharacterInputEvent& ev) override

  660.     {

  661.         if (ev.character < ' ' || ev.character >= kKeyDelete)

  662.             return false;

  663. 

  664.         const int mods = glfwMods(ev.mod);

  665.         const ScopedContext sc(this, mods);

  666.         return context->event->handleText(lastMousePos, ev.character);

  667.     }

  668. 

  669.     bool onKeyboard(const KeyboardEvent& ev) override

  670.     {

  671.         const int action = ev.press ? GLFW_PRESS : GLFW_RELEASE;

  672.         const int mods = glfwMods(ev.mod);

  673. 

  674.         /* These are unsupported in pugl right now

  675.         #define GLFW_KEY_KP_0               320

  676.         #define GLFW_KEY_KP_1               321

  677.         #define GLFW_KEY_KP_2               322

  678.         #define GLFW_KEY_KP_3               323

  679.         #define GLFW_KEY_KP_4               324

  680.         #define GLFW_KEY_KP_5               325

  681.         #define GLFW_KEY_KP_6               326

  682.         #define GLFW_KEY_KP_7               327

  683.         #define GLFW_KEY_KP_8               328

  684.         #define GLFW_KEY_KP_9               329

  685.         #define GLFW_KEY_KP_DECIMAL         330

  686.         #define GLFW_KEY_KP_DIVIDE          331

  687.         #define GLFW_KEY_KP_MULTIPLY        332

  688.         #define GLFW_KEY_KP_SUBTRACT        333

  689.         #define GLFW_KEY_KP_ADD             334

  690.         #define GLFW_KEY_KP_ENTER           335

  691.         #define GLFW_KEY_KP_EQUAL           336

  692.         */

  693. 

  694.         int key;

  695.         switch (ev.key)

  696.         {

  697.         case '\r': key = GLFW_KEY_ENTER; break;

  698.         case '\t': key = GLFW_KEY_TAB; break;

  699.         case kKeyBackspace: key = GLFW_KEY_BACKSPACE; break;

  700.         case kKeyEscape: key = GLFW_KEY_ESCAPE; break;

  701.         case kKeyDelete: key = GLFW_KEY_DELETE; break;

  702.         case kKeyF1: key = GLFW_KEY_F1; break;

  703.         case kKeyF2: key = GLFW_KEY_F2; break;

  704.         case kKeyF3: key = GLFW_KEY_F3; break;

  705.         case kKeyF4: key = GLFW_KEY_F4; break;

  706.         case kKeyF5: key = GLFW_KEY_F5; break;

  707.         case kKeyF6: key = GLFW_KEY_F6; break;

  708.         case kKeyF7: key = GLFW_KEY_F7; break;

  709.         case kKeyF8: key = GLFW_KEY_F8; break;

  710.         case kKeyF9: key = GLFW_KEY_F9; break;

  711.         case kKeyF10: key = GLFW_KEY_F10; break;

  712.         case kKeyF11: key = GLFW_KEY_F11; break;

  713.         case kKeyF12: key = GLFW_KEY_F12; break;

  714.         case kKeyLeft: key = GLFW_KEY_LEFT; break;

  715.         case kKeyUp: key = GLFW_KEY_UP; break;

  716.         case kKeyRight: key = GLFW_KEY_RIGHT; break;

  717.         case kKeyDown: key = GLFW_KEY_DOWN; break;

  718.         case kKeyPageUp: key = GLFW_KEY_PAGE_UP; break;

  719.         case kKeyPageDown: key = GLFW_KEY_PAGE_DOWN; break;

  720.         case kKeyHome: key = GLFW_KEY_HOME; break;

  721.         case kKeyEnd: key = GLFW_KEY_END; break;

  722.         case kKeyInsert: key = GLFW_KEY_INSERT; break;

  723.         case kKeyShiftL: key = GLFW_KEY_LEFT_SHIFT; break;

  724.         case kKeyShiftR: key = GLFW_KEY_RIGHT_SHIFT; break;

  725.         case kKeyControlL: key = GLFW_KEY_LEFT_CONTROL; break;

  726.         case kKeyControlR: key = GLFW_KEY_RIGHT_CONTROL; break;

  727.         case kKeyAltL: key = GLFW_KEY_LEFT_ALT; break;

  728.         case kKeyAltR: key = GLFW_KEY_RIGHT_ALT; break;

  729.         case kKeySuperL: key = GLFW_KEY_LEFT_SUPER; break;

  730.         case kKeySuperR: key = GLFW_KEY_RIGHT_SUPER; break;

  731.         case kKeyMenu: key = GLFW_KEY_MENU; break;

  732.         case kKeyCapsLock: key = GLFW_KEY_CAPS_LOCK; break;

  733.         case kKeyScrollLock: key = GLFW_KEY_SCROLL_LOCK; break;

  734.         case kKeyNumLock: key = GLFW_KEY_NUM_LOCK; break;

  735.         case kKeyPrintScreen: key = GLFW_KEY_PRINT_SCREEN; break;

  736.         case kKeyPause: key = GLFW_KEY_PAUSE; break;

  737.         default:

  738.             // glfw expects uppercase

  739.             if (ev.key >= 'a' && ev.key <= 'z')

  740.                 key = ev.key - ('a' - 'A');

  741.             else

  742.                 key = ev.key;

  743.             break;

  744.         }

  745. 

  746.         const ScopedContext sc(this, mods);

  747.         return context->event->handleKey(lastMousePos, key, ev.keycode, action, mods);

  748.     }

  749. 

  750.     void onResize(const ResizeEvent& ev) override

  751.     {

  752.         UI::onResize(ev);

  753. 

  754.         if (context->window != nullptr)

  755.             context->window->setSize(rack::math::Vec(ev.size.getWidth(), ev.size.getHeight()));

  756. 

  757.         const double scaleFactor = getScaleFactor();

  758.         char sizeString[64];

  759.         std::snprintf(sizeString, sizeof(sizeString), "%d:%d",

  760.                       (int)(ev.size.getWidth() / scaleFactor), (int)(ev.size.getHeight() / scaleFactor));

  761.         setState("windowSize", sizeString);

  762.     }

  763. 

  764.     void uiFocus(const bool focus, const CrossingMode mode) override

  765.     {

  766.         if (focus)

  767.         {

  768.             if (mode == kCrossingNormal)

  769.                 getWindow().focus();

  770.         }

  771.         else

  772.         {

  773.             const ScopedContext sc(this, 0);

  774.             context->event->handleLeave();

  775.         }

  776.     }

  777. 

  778.     void uiFileBrowserSelected(const char* const filename) override

  779.     {

  780.         if (filename == nullptr)

  781.             return;

  782. 

  783.         rack::contextSet(context);

  784.         WindowParametersRestore(context->window);

  785. 

  786.         std::string sfilename = filename;

  787. 

  788.         if (saving)

  789.         {

  790.             const bool uncompressed = savingUncompressed;

  791.             savingUncompressed = false;

  792. 

  793.             if (rack::system::getExtension(sfilename) != ".vcv")

  794.                 sfilename += ".vcv";

  795. 

  796.             try {

  797.                 if (uncompressed)

  798.                 {

  799.                     context->engine->prepareSave();

  800. 

  801.                     if (json_t* const rootJ = context->patch->toJson())

  802.                     {

  803.                         if (FILE* const file = std::fopen(sfilename.c_str(), "w"))

  804.                         {

  805.                             json_dumpf(rootJ, file, JSON_INDENT(2));

  806.                             std::fclose(file);

  807.                         }

  808.                         json_decref(rootJ);

  809.                     }

  810.                 }

  811.                 else

  812.                 {

  813.                     context->patch->save(sfilename);

  814.                 }

  815.             }

  816.             catch (rack::Exception& e) {

  817.                 std::string message = rack::string::f("Could not save patch: %s", e.what());

  818.                 asyncDialog::create(message.c_str());

  819.                 return;

  820.             }

  821.         }

  822.         else

  823.         {

  824.             try {

  825.                 context->patch->load(sfilename);

  826.             } catch (rack::Exception& e) {

  827.                 std::string message = rack::string::f("Could not load patch: %s", e.what());

  828.                 asyncDialog::create(message.c_str());

  829.                 return;

  830.             }

  831.         }

  832. 

  833.         context->patch->path = sfilename;

  834.         context->history->setSaved();

  835.     }

  836. 

  837. #if 0

  838.     void uiReshape(const uint width, const uint height) override

  839.     {

  840.         glEnable(GL_BLEND);

  841.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  842.         glMatrixMode(GL_PROJECTION);

  843.         glLoadIdentity();

  844.         glOrtho(0.0, width, 0.0, height, -1.0, 1.0);

  845.         glViewport(0, 0, width, height);

  846.         glMatrixMode(GL_MODELVIEW);

  847.         glLoadIdentity();

  848.     }

  849. #endif

  850. 

  851. private:

  852.    /**

  853.       Set our UI class as non-copyable and add a leak detector just in case.

  854.     */

  855.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CardinalUI)

  856. };

  857. 

  858. /* ------------------------------------------------------------------------------------------------------------

  859.  * UI entry point, called by DPF to create a new UI instance. */

  860. 

  861. UI* createUI()

  862. {

  863.     return new CardinalUI();

  864. }

  865. 

  866. // -----------------------------------------------------------------------------------------------------------

  867. 

  868. END_NAMESPACE_DISTRHO