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

384 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 (fPM == nullptr)

  100.         return;

  101. 

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

  103.     {

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

  105.         dspPtr->fPM = nullptr;

  106.     }

  107. }

  108. 

  109. // -----------------------------------------------------------------------

  110. // DSP Callbacks

  111. 

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

  113. {

  114. }

  115. 

  116. // -----------------------------------------------------------------------

  117. // UI Callbacks

  118. 

  119. void DistrhoUIProM::uiIdle()

  120. {

  121.     if (fPM == nullptr)

  122.         return;

  123. 

  124.     repaint();

  125. 

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

  127.     {

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

  129.             return;

  130. 

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

  132.         dspPtr->fPM = fPM;

  133.     }

  134. }

  135. 

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

  137. {

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

  139. 

  140.     if (fPM == nullptr)

  141.     {

  142. #ifdef PROJECTM_DATA_DIR

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

  144. #else

  145.         const String datadir(getCurrentExecutableDataDir());

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

  147. 

  148.         projectM::Settings settings;

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

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

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

  152.         settings.datadir      = datadir;

  153.         fPM = new projectM(settings);

  154. #endif

  155.     }

  156. 

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

  158. }

  159. 

  160. // -----------------------------------------------------------------------

  161. // Widget Callbacks

  162. 

  163. void DistrhoUIProM::onDisplay()

  164. {

  165.     if (fPM == nullptr)

  166.         return;

  167. 

  168.     fPM->renderFrame();

  169. 

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

  171.     glUseProgram(0);

  172. }

  173. 

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

  175. {

  176.     switch (key)

  177.     {

  178.     case DGL_NAMESPACE::kKeyBackspace:

  179.         return PROJECTM_K_BACKSPACE;

  180.     case DGL_NAMESPACE::kKeyEscape:

  181.         return PROJECTM_K_ESCAPE;

  182.     case DGL_NAMESPACE::kKeyDelete:

  183.         return PROJECTM_K_DELETE;

  184.     case DGL_NAMESPACE::kKeyF1:

  185.         return PROJECTM_K_F1;

  186.     case DGL_NAMESPACE::kKeyF2:

  187.         return PROJECTM_K_F2;

  188.     case DGL_NAMESPACE::kKeyF3:

  189.         return PROJECTM_K_F3;

  190.     case DGL_NAMESPACE::kKeyF4:

  191.         return PROJECTM_K_F4;

  192.     case DGL_NAMESPACE::kKeyF5:

  193.         return PROJECTM_K_F5;

  194.     case DGL_NAMESPACE::kKeyF6:

  195.         return PROJECTM_K_F6;

  196.     case DGL_NAMESPACE::kKeyF7:

  197.         return PROJECTM_K_F7;

  198.     case DGL_NAMESPACE::kKeyF8:

  199.         return PROJECTM_K_F8;

  200.     case DGL_NAMESPACE::kKeyF9:

  201.         return PROJECTM_K_F9;

  202.     case DGL_NAMESPACE::kKeyF10:

  203.         return PROJECTM_K_F10;

  204.     case DGL_NAMESPACE::kKeyF11:

  205.         return PROJECTM_K_F11;

  206.     case DGL_NAMESPACE::kKeyF12:

  207.         return PROJECTM_K_F12;

  208.     case DGL_NAMESPACE::kKeyLeft:

  209.         return PROJECTM_K_LEFT;

  210.     case DGL_NAMESPACE::kKeyUp:

  211.         return PROJECTM_K_UP;

  212.     case DGL_NAMESPACE::kKeyRight:

  213.         return PROJECTM_K_RIGHT;

  214.     case DGL_NAMESPACE::kKeyDown:

  215.         return PROJECTM_K_DOWN;

  216.     case DGL_NAMESPACE::kKeyPageUp:

  217.         return PROJECTM_K_PAGEUP;

  218.     case DGL_NAMESPACE::kKeyPageDown:

  219.         return PROJECTM_K_PAGEDOWN;

  220.     case DGL_NAMESPACE::kKeyHome:

  221.         return PROJECTM_K_HOME;

  222.     case DGL_NAMESPACE::kKeyEnd:

  223.         return PROJECTM_K_END;

  224.     case DGL_NAMESPACE::kKeyInsert:

  225.         return PROJECTM_K_INSERT;

  226.     case DGL_NAMESPACE::kKeyShiftL:

  227.         return PROJECTM_K_LSHIFT;

  228.     case DGL_NAMESPACE::kKeyShiftR:

  229.         return PROJECTM_K_RSHIFT;

  230.     case DGL_NAMESPACE::kKeyControlL:

  231.         return PROJECTM_K_LCTRL;

  232.     case DGL_NAMESPACE::kKeyControlR:

  233.     case DGL_NAMESPACE::kKeyAltL:

  234.     case DGL_NAMESPACE::kKeyAltR:

  235.     case DGL_NAMESPACE::kKeySuperL:

  236.     case DGL_NAMESPACE::kKeySuperR:

  237.     case DGL_NAMESPACE::kKeyMenu:

  238.     case DGL_NAMESPACE::kKeyCapsLock:

  239.     case DGL_NAMESPACE::kKeyScrollLock:

  240.     case DGL_NAMESPACE::kKeyNumLock:

  241.     case DGL_NAMESPACE::kKeyPrintScreen:

  242.     case DGL_NAMESPACE::kKeyPause:

  243.         break;

  244.     }

  245. 

  246.     return PROJECTM_K_NONE;

  247. }

  248. 

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

  250. {

  251.     if (fPM == nullptr)

  252.         return false;

  253. 

  254. #if 0

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

  256.     {

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

  258.         {

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

  260.                 setSize(512, 512);

  261.         }

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

  263.         {

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

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

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

  267.                     setSize(1100, 1100);

  268.         }

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

  270.         {

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

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

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

  274.                 setSize(100, 100);

  275.         }

  276. 

  277.         return true;

  278.     }

  279. #endif

  280. 

  281.     // special handling for text

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

  283.     {

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

  285.         {

  286.             std::string key;

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

  288.             fPM->setSearchText(key);

  289.             return true;

  290.         }

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

  292.         {

  293.             fPM->deleteSearchText();

  294.             return true;

  295.         }

  296.     }

  297. 

  298.     projectMKeycode pmKey = PROJECTM_K_NONE;

  299. 

  300.     if (ev.key >= kKeyF1)

  301.     {

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

  303.     }

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

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

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

  307.     {

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

  309. 

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

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

  312.     }

  313.     else

  314.     {

  315.         /* missing:

  316.          * PROJECTM_K_CAPSLOCK

  317.          */

  318.         switch (ev.key)

  319.         {

  320.         case DGL_NAMESPACE::kKeyBackspace:

  321.             pmKey = PROJECTM_K_BACKSPACE;

  322.             break;

  323.         case DGL_NAMESPACE::kKeyEscape:

  324.             pmKey = PROJECTM_K_ESCAPE;

  325.             break;

  326.         case DGL_NAMESPACE::kKeyDelete:

  327.             pmKey = PROJECTM_K_DELETE;

  328.             break;

  329.         case '\r':

  330.             pmKey = PROJECTM_K_RETURN;

  331.             break;

  332.         case '/':

  333.             pmKey = PROJECTM_K_SLASH;

  334.             break;

  335.         case '\\':

  336.             pmKey = PROJECTM_K_BACKSLASH;

  337.             break;

  338.         case '+':

  339.             pmKey = PROJECTM_K_PLUS;

  340.             break;

  341.         case '-':

  342.             pmKey = PROJECTM_K_MINUS;

  343.             break;

  344.         case '=':

  345.             pmKey = PROJECTM_K_EQUALS;

  346.             break;

  347.         default:

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

  349.             break;

  350.         }

  351.     }

  352. 

  353.     if (pmKey == PROJECTM_K_NONE)

  354.         return false;

  355. 

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

  357.     return true;

  358. }

  359. 

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

  361. {

  362.     if (fPM == nullptr)

  363.         return false;

  364. 

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

  366. 

  367.     if (pmKey == PROJECTM_K_NONE)

  368.         return false;

  369. 

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

  371.     return true;

  372. }

  373. 

  374. // -----------------------------------------------------------------------

  375. 

  376. UI* createUI()

  377. {

  378.     return new DistrhoUIProM();

  379. }

  380. 

  381. // -----------------------------------------------------------------------

  382. 

  383. END_NAMESPACE_DISTRHO