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.
133 Commits
1 Branch
299MB
Tree: 5c201852b6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5c201852b6'
${ noResults }
DPF-Plugins/plugins/ProM/DistrhoUIProM.cpp

381 lines
10KB
Raw Blame History 

  1. /*

  2.  * DISTRHO ProM Plugin

  3.  * Copyright (C) 2015-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 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. #include "libprojectM/projectM-opengl.h"

  18. #include "libprojectM/projectM.hpp"

  19. 

  20. #include "DistrhoPluginProM.hpp"

  21. #include "DistrhoUIProM.hpp"

  22. 

  23. #ifndef DISTRHO_OS_WINDOWS

  24. # include <dlfcn.h>

  25. #endif

  26. 

  27. #ifdef DISTRHO_OS_WINDOWS

  28. static HINSTANCE hInstance = nullptr;

  29. 

  30. DISTRHO_PLUGIN_EXPORT

  31. BOOL WINAPI DllMain(HINSTANCE hInst, DWORD reason, LPVOID)

  32. {

  33.     if (reason == DLL_PROCESS_ATTACH)

  34.         hInstance = hInst;

  35.     return 1;

  36. }

  37. #endif

  38. 

  39. START_NAMESPACE_DISTRHO

  40. 

  41. // -----------------------------------------------------------------------

  42. 

  43. static String getCurrentExecutableDataDir()

  44. {

  45.     static String datadir;

  46. 

  47.     if (datadir.isNotEmpty())

  48.         return datadir;

  49. 

  50. #ifdef DISTRHO_OS_WINDOWS

  51.     CHAR filename[MAX_PATH + 256];

  52.     filename[0] = '\0';

  53.     GetModuleFileName(hInstance, filename, sizeof(filename));

  54. 

  55.     datadir = String(filename);

  56.     datadir.truncate(datadir.rfind('\\'));

  57. #else

  58.     Dl_info info;

  59.     dladdr((void*)getCurrentExecutableDataDir, &info);

  60. 

  61.     datadir = String(info.dli_fname);

  62.     datadir.truncate(datadir.rfind('/'));

  63. 

  64. # ifdef DISTRHO_OS_MAC

  65.     if (datadir.endsWith("/MacOS"))

  66.     {

  67.         datadir.truncate(datadir.rfind('/'));

  68.         datadir += "/Resources";

  69.     }

  70.     else

  71. # endif

  72. #endif

  73.     {

  74.         datadir += "/resources";

  75.     }

  76. 

  77.     return datadir;

  78. }

  79. 

  80. // -----------------------------------------------------------------------

  81. 

  82. DistrhoUIProM::DistrhoUIProM()

  83.     : UI(512, 512),

  84.       fPM(nullptr),

  85.       fResizeHandle(this)

  86. {

  87.     // const double scaleFactor = getScaleFactor();

  88.     // if (d_isNotZero(scaleFactor))

  89.     //    setSize(512*scaleFactor, 512*scaleFactor)

  90.     setGeometryConstraints(256, 256, true);

  91. 

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

  93.     // if (isResizable())

  94.     //     fResizeHandle.hide();

  95. }

  96. 

  97. DistrhoUIProM::~DistrhoUIProM()

  98. {

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

  100.     {

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

  102.         dspPtr->fPM = nullptr;

  103.     }

  104. }

  105. 

  106. // -----------------------------------------------------------------------

  107. // DSP Callbacks

  108. 

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

  110. {

  111. }

  112. 

  113. // -----------------------------------------------------------------------

  114. // UI Callbacks

  115. 

  116. void DistrhoUIProM::uiIdle()

  117. {

  118.     if (fPM == nullptr)

  119.         return;

  120. 

  121.     repaint();

  122. 

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

  124.     {

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

  126.             return;

  127. 

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

  129.         dspPtr->fPM = fPM;

  130.     }

  131. }

  132. 

  133. void DistrhoUIProM::uiReshape(uint width, uint height)

  134. {

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

  136. 

  137.     if (fPM == nullptr)

  138.     {

  139. #ifdef PROJECTM_DATA_DIR

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

  141. #else

  142.         const String datadir(getCurrentExecutableDataDir());

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

  144. 

  145.         projectM::Settings settings;

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

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

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

  149.         settings.datadir      = datadir;

  150.         fPM = new projectM(settings);

  151. #endif

  152.     }

  153. 

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

  155. }

  156. 

  157. // -----------------------------------------------------------------------

  158. // Widget Callbacks

  159. 

  160. void DistrhoUIProM::onDisplay()

  161. {

  162.     if (fPM == nullptr)

  163.         return;

  164. 

  165.     fPM->renderFrame();

  166. 

  167.     // turn off shaders at the end of the drawing cycle, so other things can draw properly

  168.     glUseProgram(0);

  169. }

  170. 

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

  172. {

  173.     switch (key)

  174.     {

  175.     case DGL_NAMESPACE::kKeyBackspace:

  176.         return PROJECTM_K_BACKSPACE;

  177.     case DGL_NAMESPACE::kKeyEscape:

  178.         return PROJECTM_K_ESCAPE;

  179.     case DGL_NAMESPACE::kKeyDelete:

  180.         return PROJECTM_K_DELETE;

  181.     case DGL_NAMESPACE::kKeyF1:

  182.         return PROJECTM_K_F1;

  183.     case DGL_NAMESPACE::kKeyF2:

  184.         return PROJECTM_K_F2;

  185.     case DGL_NAMESPACE::kKeyF3:

  186.         return PROJECTM_K_F3;

  187.     case DGL_NAMESPACE::kKeyF4:

  188.         return PROJECTM_K_F4;

  189.     case DGL_NAMESPACE::kKeyF5:

  190.         return PROJECTM_K_F5;

  191.     case DGL_NAMESPACE::kKeyF6:

  192.         return PROJECTM_K_F6;

  193.     case DGL_NAMESPACE::kKeyF7:

  194.         return PROJECTM_K_F7;

  195.     case DGL_NAMESPACE::kKeyF8:

  196.         return PROJECTM_K_F8;

  197.     case DGL_NAMESPACE::kKeyF9:

  198.         return PROJECTM_K_F9;

  199.     case DGL_NAMESPACE::kKeyF10:

  200.         return PROJECTM_K_F10;

  201.     case DGL_NAMESPACE::kKeyF11:

  202.         return PROJECTM_K_F11;

  203.     case DGL_NAMESPACE::kKeyF12:

  204.         return PROJECTM_K_F12;

  205.     case DGL_NAMESPACE::kKeyLeft:

  206.         return PROJECTM_K_LEFT;

  207.     case DGL_NAMESPACE::kKeyUp:

  208.         return PROJECTM_K_UP;

  209.     case DGL_NAMESPACE::kKeyRight:

  210.         return PROJECTM_K_RIGHT;

  211.     case DGL_NAMESPACE::kKeyDown:

  212.         return PROJECTM_K_DOWN;

  213.     case DGL_NAMESPACE::kKeyPageUp:

  214.         return PROJECTM_K_PAGEUP;

  215.     case DGL_NAMESPACE::kKeyPageDown:

  216.         return PROJECTM_K_PAGEDOWN;

  217.     case DGL_NAMESPACE::kKeyHome:

  218.         return PROJECTM_K_HOME;

  219.     case DGL_NAMESPACE::kKeyEnd:

  220.         return PROJECTM_K_END;

  221.     case DGL_NAMESPACE::kKeyInsert:

  222.         return PROJECTM_K_INSERT;

  223.     case DGL_NAMESPACE::kKeyShiftL:

  224.         return PROJECTM_K_LSHIFT;

  225.     case DGL_NAMESPACE::kKeyShiftR:

  226.         return PROJECTM_K_RSHIFT;

  227.     case DGL_NAMESPACE::kKeyControlL:

  228.         return PROJECTM_K_LCTRL;

  229.     case DGL_NAMESPACE::kKeyControlR:

  230.     case DGL_NAMESPACE::kKeyAltL:

  231.     case DGL_NAMESPACE::kKeyAltR:

  232.     case DGL_NAMESPACE::kKeySuperL:

  233.     case DGL_NAMESPACE::kKeySuperR:

  234.     case DGL_NAMESPACE::kKeyMenu:

  235.     case DGL_NAMESPACE::kKeyCapsLock:

  236.     case DGL_NAMESPACE::kKeyScrollLock:

  237.     case DGL_NAMESPACE::kKeyNumLock:

  238.     case DGL_NAMESPACE::kKeyPrintScreen:

  239.     case DGL_NAMESPACE::kKeyPause:

  240.         break;

  241.     }

  242. 

  243.     return PROJECTM_K_NONE;

  244. }

  245. 

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

  247. {

  248.     if (fPM == nullptr)

  249.         return false;

  250. 

  251. #if 0

  252.     if (ev.press && (ev.key == '1' || ev.key == '+' || ev.key == '-'))

  253.     {

  254.         if (ev.key == '1')

  255.         {

  256.             if (getWidth() != 512 || getHeight() != 512)

  257.                 setSize(512, 512);

  258.         }

  259.         else if (ev.key == '+')

  260.         {

  261.             /**/ if (getWidth() < 1100 && getHeight() < 1100)

  262.                 setSize(getWidth()+100, getHeight()+100);

  263.             else if (getWidth() != 1100 || getHeight() != 1100)

  264.                     setSize(1100, 1100);

  265.         }

  266.         else if (ev.key == '-')

  267.         {

  268.             /**/ if (getWidth() >= 200 && getHeight() >= 200)

  269.                 setSize(getWidth()-100, getHeight()-100);

  270.             else if (getWidth() != 100 || getHeight() != 100)

  271.                 setSize(100, 100);

  272.         }

  273. 

  274.         return true;

  275.     }

  276. #endif

  277. 

  278.     // special handling for text

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

  280.     {

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

  282.         {

  283.             std::string key;

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

  285.             fPM->setSearchText(key);

  286.             return true;

  287.         }

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

  289.         {

  290.             fPM->deleteSearchText();

  291.             return true;

  292.         }

  293.     }

  294. 

  295.     projectMKeycode pmKey = PROJECTM_K_NONE;

  296. 

  297.     if (ev.key >= kKeyF1)

  298.     {

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

  300.     }

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

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

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

  304.     {

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

  306. 

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

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

  309.     }

  310.     else

  311.     {

  312.         /* missing:

  313.          * PROJECTM_K_CAPSLOCK

  314.          */

  315.         switch (ev.key)

  316.         {

  317.         case DGL_NAMESPACE::kKeyBackspace:

  318.             pmKey = PROJECTM_K_BACKSPACE;

  319.             break;

  320.         case DGL_NAMESPACE::kKeyEscape:

  321.             pmKey = PROJECTM_K_ESCAPE;

  322.             break;

  323.         case DGL_NAMESPACE::kKeyDelete:

  324.             pmKey = PROJECTM_K_DELETE;

  325.             break;

  326.         case '\r':

  327.             pmKey = PROJECTM_K_RETURN;

  328.             break;

  329.         case '/':

  330.             pmKey = PROJECTM_K_SLASH;

  331.             break;

  332.         case '\\':

  333.             pmKey = PROJECTM_K_BACKSLASH;

  334.             break;

  335.         case '+':

  336.             pmKey = PROJECTM_K_PLUS;

  337.             break;

  338.         case '-':

  339.             pmKey = PROJECTM_K_MINUS;

  340.             break;

  341.         case '=':

  342.             pmKey = PROJECTM_K_EQUALS;

  343.             break;

  344.         default:

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

  346.             break;

  347.         }

  348.     }

  349. 

  350.     if (pmKey == PROJECTM_K_NONE)

  351.         return false;

  352. 

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

  354.     return true;

  355. }

  356. 

  357. bool DistrhoUIProM::onSpecial(const SpecialEvent& ev)

  358. {

  359.     if (fPM == nullptr)

  360.         return false;

  361. 

  362.     const projectMKeycode pmKey = dgl2pmkey(ev.key);

  363. 

  364.     if (pmKey == PROJECTM_K_NONE)

  365.         return false;

  366. 

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

  368.     return true;

  369. }

  370. 

  371. // -----------------------------------------------------------------------

  372. 

  373. UI* createUI()

  374. {

  375.     return new DistrhoUIProM();

  376. }

  377. 

  378. // -----------------------------------------------------------------------

  379. 

  380. END_NAMESPACE_DISTRHO