DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
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.
189 Commits
1 Branch
299MB
Tree: 6ecedf2754
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6ecedf2754'
${ noResults }
DPF-Plugins/plugins/ProM/DistrhoUIProM.cpp

318 lines
8.5KB
Raw Blame History 

  1. /*

  2.  * DISTRHO ProM Plugin

  3.  * Copyright (C) 2015-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 Lesser General Public

  7.  * License as published by the Free Software Foundation.

  8.  *

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

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

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

  12.  * GNU Lesser General Public License for more details.

  13.  *

  14.  * For a full copy of the license see the LICENSE file.

  15.  */

  16. 

  17. /* s/private/public/ as workaround old projectM versions */

  18. #define private public

  19. #include "libprojectM/projectM.hpp"

  20. #undef private

  21. 

  22. #ifndef PROJECTM_DATA_DIR

  23. #include "libprojectM/projectM-opengl.h"

  24. #endif

  25. 

  26. #include "DistrhoPluginProM.hpp"

  27. #include "DistrhoUIProM.hpp"

  28. 

  29. #include "DistrhoPluginUtils.hpp"

  30. 

  31. START_NAMESPACE_DISTRHO

  32. 

  33. // -----------------------------------------------------------------------

  34. 

  35. DistrhoUIProM::DistrhoUIProM()

  36.     : UI(512, 512),

  37.       fPM(nullptr),

  38.       fResizeHandle(this)

  39. {

  40.     const double scaleFactor = getScaleFactor();

  41. 

  42.     if (d_isNotZero(scaleFactor))

  43.         setSize(512*scaleFactor, 512*scaleFactor);

  44. 

  45.     setGeometryConstraints(256*scaleFactor, 256*scaleFactor, true);

  46. 

  47.     // no need to show resize handle if window is user-resizable

  48.     // if (isResizable())

  49.     //     fResizeHandle.hide();

  50. }

  51. 

  52. DistrhoUIProM::~DistrhoUIProM()

  53. {

  54.     if (fPM == nullptr)

  55.         return;

  56. 

  57.     if (DistrhoPluginProM* const dspPtr = (DistrhoPluginProM*)getPluginInstancePointer())

  58.     {

  59.         const MutexLocker csm(dspPtr->fMutex);

  60.         dspPtr->fPM = nullptr;

  61.     }

  62. }

  63. 

  64. // -----------------------------------------------------------------------

  65. // DSP Callbacks

  66. 

  67. void DistrhoUIProM::parameterChanged(uint32_t, float)

  68. {

  69. }

  70. 

  71. // -----------------------------------------------------------------------

  72. // UI Callbacks

  73. 

  74. void DistrhoUIProM::uiIdle()

  75. {

  76.     if (fPM == nullptr)

  77.         return;

  78. 

  79.     repaint();

  80. 

  81.     if (DistrhoPluginProM* const dspPtr = (DistrhoPluginProM*)getPluginInstancePointer())

  82.     {

  83.         if (dspPtr->fPM != nullptr)

  84.             return;

  85. 

  86.         const MutexLocker csm(dspPtr->fMutex);

  87.         dspPtr->fPM = fPM;

  88.     }

  89. }

  90. 

  91. void DistrhoUIProM::uiReshape(const uint width, const uint height)

  92. {

  93.     UI::uiReshape(width, height);

  94. 

  95.     if (fPM == nullptr)

  96.     {

  97. #ifdef PROJECTM_DATA_DIR

  98.         fPM = new projectM(PROJECTM_DATA_DIR "/config.inp");

  99. #else

  100.         if (const char* const bundlePath = getBundlePath())

  101.         {

  102.             const String datadir(getResourcePath(bundlePath));

  103.             d_stdout("ProM datadir: '%s'", datadir.buffer());

  104. 

  105.             projectM::Settings settings;

  106.             settings.presetURL    = datadir + DISTRHO_OS_SEP_STR "presets";

  107.             settings.titleFontURL = datadir + DISTRHO_OS_SEP_STR "fonts" DISTRHO_OS_SEP_STR "Vera.ttf";

  108.             settings.menuFontURL  = datadir + DISTRHO_OS_SEP_STR "fonts" DISTRHO_OS_SEP_STR "VeraMono.ttf";

  109.             settings.datadir      = datadir;

  110.             fPM = new projectM(settings);

  111.         }

  112.         else

  113.         {

  114.             d_stderr2("ProM: failed to find bundle path, UI will be empty");

  115.         }

  116. #endif

  117.     }

  118. 

  119.     if (fPM != nullptr)

  120.         fPM->projectM_resetGL(width, height);

  121. }

  122. 

  123. // -----------------------------------------------------------------------

  124. // Widget Callbacks

  125. 

  126. void DistrhoUIProM::onDisplay()

  127. {

  128.     if (fPM == nullptr)

  129.         return;

  130. 

  131.     fPM->renderFrame();

  132. 

  133.     // some projectM versions do not turn off the last set GL program

  134.     glUseProgram(0);

  135. }

  136. 

  137. static projectMKeycode dgl2pmkey(const DGL_NAMESPACE::Key key) noexcept

  138. {

  139.     switch (key)

  140.     {

  141.     case DGL_NAMESPACE::kKeyBackspace:

  142.         return PROJECTM_K_BACKSPACE;

  143.     case DGL_NAMESPACE::kKeyEscape:

  144.         return PROJECTM_K_ESCAPE;

  145.     case DGL_NAMESPACE::kKeyDelete:

  146.         return PROJECTM_K_DELETE;

  147.     case DGL_NAMESPACE::kKeyF1:

  148.         return PROJECTM_K_F1;

  149.     case DGL_NAMESPACE::kKeyF2:

  150.         return PROJECTM_K_F2;

  151.     case DGL_NAMESPACE::kKeyF3:

  152.         return PROJECTM_K_F3;

  153.     case DGL_NAMESPACE::kKeyF4:

  154.         return PROJECTM_K_F4;

  155.     case DGL_NAMESPACE::kKeyF5:

  156.         return PROJECTM_K_F5;

  157.     case DGL_NAMESPACE::kKeyF6:

  158.         return PROJECTM_K_F6;

  159.     case DGL_NAMESPACE::kKeyF7:

  160.         return PROJECTM_K_F7;

  161.     case DGL_NAMESPACE::kKeyF8:

  162.         return PROJECTM_K_F8;

  163.     case DGL_NAMESPACE::kKeyF9:

  164.         return PROJECTM_K_F9;

  165.     case DGL_NAMESPACE::kKeyF10:

  166.         return PROJECTM_K_F10;

  167.     case DGL_NAMESPACE::kKeyF11:

  168.         return PROJECTM_K_F11;

  169.     case DGL_NAMESPACE::kKeyF12:

  170.         return PROJECTM_K_F12;

  171.     case DGL_NAMESPACE::kKeyLeft:

  172.         return PROJECTM_K_LEFT;

  173.     case DGL_NAMESPACE::kKeyUp:

  174.         return PROJECTM_K_UP;

  175.     case DGL_NAMESPACE::kKeyRight:

  176.         return PROJECTM_K_RIGHT;

  177.     case DGL_NAMESPACE::kKeyDown:

  178.         return PROJECTM_K_DOWN;

  179.     case DGL_NAMESPACE::kKeyPageUp:

  180.         return PROJECTM_K_PAGEUP;

  181.     case DGL_NAMESPACE::kKeyPageDown:

  182.         return PROJECTM_K_PAGEDOWN;

  183.     case DGL_NAMESPACE::kKeyHome:

  184.         return PROJECTM_K_HOME;

  185.     case DGL_NAMESPACE::kKeyEnd:

  186.         return PROJECTM_K_END;

  187.     case DGL_NAMESPACE::kKeyInsert:

  188.         return PROJECTM_K_INSERT;

  189.     case DGL_NAMESPACE::kKeyShiftL:

  190.         return PROJECTM_K_LSHIFT;

  191.     case DGL_NAMESPACE::kKeyShiftR:

  192.         return PROJECTM_K_RSHIFT;

  193.     case DGL_NAMESPACE::kKeyControlL:

  194.         return PROJECTM_K_LCTRL;

  195.     case DGL_NAMESPACE::kKeyControlR:

  196.     case DGL_NAMESPACE::kKeyAltL:

  197.     case DGL_NAMESPACE::kKeyAltR:

  198.     case DGL_NAMESPACE::kKeySuperL:

  199.     case DGL_NAMESPACE::kKeySuperR:

  200.     case DGL_NAMESPACE::kKeyMenu:

  201.     case DGL_NAMESPACE::kKeyCapsLock:

  202.     case DGL_NAMESPACE::kKeyScrollLock:

  203.     case DGL_NAMESPACE::kKeyNumLock:

  204.     case DGL_NAMESPACE::kKeyPrintScreen:

  205.     case DGL_NAMESPACE::kKeyPause:

  206.         break;

  207.     }

  208. 

  209.     return PROJECTM_K_NONE;

  210. }

  211. 

  212. bool DistrhoUIProM::onKeyboard(const KeyboardEvent& ev)

  213. {

  214.     if (fPM == nullptr)

  215.         return false;

  216. 

  217. #ifdef HAVE_PROJECTM_TEXT_FUNCTIONS

  218.     // special handling for text

  219.     if (fPM->isTextInputActive(true) && !ev.press)

  220.     {

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

  222.         {

  223.             std::string key;

  224.             key += static_cast<char>(ev.key);

  225.             fPM->setSearchText(key);

  226.             return true;

  227.         }

  228.         else if (ev.key == DGL_NAMESPACE::kKeyBackspace)

  229.         {

  230.             fPM->deleteSearchText();

  231.             return true;

  232.         }

  233.     }

  234. #endif

  235. 

  236.     projectMKeycode pmKey = PROJECTM_K_NONE;

  237. 

  238.     if (ev.key >= kKeyF1)

  239.     {

  240.         pmKey = dgl2pmkey(static_cast<DGL_NAMESPACE::Key>(ev.key));

  241.     }

  242.     else if ((ev.key >= PROJECTM_K_0 && ev.key <= PROJECTM_K_9) ||

  243.              (ev.key >= PROJECTM_K_A && ev.key <= PROJECTM_K_Z) ||

  244.              (ev.key >= PROJECTM_K_a && ev.key <= PROJECTM_K_z))

  245.     {

  246.         pmKey = static_cast<projectMKeycode>(ev.key);

  247. 

  248.         if (ev.key >= PROJECTM_K_A && ev.key <= PROJECTM_K_Z && (ev.mod & DGL_NAMESPACE::kModifierShift))

  249.             pmKey = static_cast<projectMKeycode>(pmKey + (PROJECTM_K_a - PROJECTM_K_A));

  250.     }

  251.     else

  252.     {

  253.         /* missing:

  254.          * PROJECTM_K_CAPSLOCK

  255.          */

  256.         switch (ev.key)

  257.         {

  258.         case DGL_NAMESPACE::kKeyBackspace:

  259.             pmKey = PROJECTM_K_BACKSPACE;

  260.             break;

  261.         case DGL_NAMESPACE::kKeyEscape:

  262.             pmKey = PROJECTM_K_ESCAPE;

  263.             break;

  264.         case DGL_NAMESPACE::kKeyDelete:

  265.             pmKey = PROJECTM_K_DELETE;

  266.             break;

  267.         case '\r':

  268.             pmKey = PROJECTM_K_RETURN;

  269.             break;

  270. #ifdef HAVE_PROJECTM_TEXT_FUNCTIONS

  271.         case '/':

  272.             pmKey = PROJECTM_K_SLASH;

  273.             break;

  274.         case '\\':

  275.             pmKey = PROJECTM_K_BACKSLASH;

  276.             break;

  277. #endif

  278.         case '+':

  279.             pmKey = PROJECTM_K_PLUS;

  280.             break;

  281.         case '-':

  282.             pmKey = PROJECTM_K_MINUS;

  283.             break;

  284.         case '=':

  285.             pmKey = PROJECTM_K_EQUALS;

  286.             break;

  287.         default:

  288.             // d_stdout("Unhandled key %u %u %c", ev.keycode, ev.key, ev.key);

  289.             break;

  290.         }

  291.     }

  292. 

  293.     if (pmKey == PROJECTM_K_NONE)

  294.         return false;

  295. 

  296.     fPM->default_key_handler(ev.press ? PROJECTM_KEYUP : PROJECTM_KEYDOWN, pmKey);

  297.     return true;

  298. }

  299. 

  300. bool DistrhoUIProM::onMouse(const MouseEvent& ev)

  301. {

  302.     if (ev.press)

  303.         getWindow().focus();

  304. 

  305.     return false;

  306. }

  307. 

  308. // -----------------------------------------------------------------------

  309. 

  310. UI* createUI()

  311. {

  312.     return new DistrhoUIProM();

  313. }

  314. 

  315. // -----------------------------------------------------------------------

  316. 

  317. END_NAMESPACE_DISTRHO