falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
6180 Commits
16 Branches
3.6GB
Tree: 5db3077f25
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5db3077f25'
${ noResults }
Carla/source/utils/JucePluginWindow.hpp

582 lines
24KB
Raw Blame History 

  1. /*

  2.  * Juce Plugin Window Helper

  3.  * Copyright (C) 2013-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 2 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 doc/GPL.txt file.

  16.  */

  17. 

  18. #ifndef JUCE_PLUGIN_WINDOW_HPP_INCLUDED

  19. #define JUCE_PLUGIN_WINDOW_HPP_INCLUDED

  20. 

  21. #include "CarlaJuceUtils.hpp"

  22. #include "CarlaVst2Utils.hpp"

  23. #include "CarlaVst3Utils.hpp"

  24. 

  25. #include "AppConfig.h"

  26. #include "juce_gui_basics/juce_gui_basics.h"

  27. 

  28. #if defined(CARLA_OS_LINUX) && defined(HAVE_X11)

  29. # include <X11/Xlib.h>

  30. #elif defined(CARLA_OS_MAC)

  31. # define Component CocoaComponent

  32. # define MemoryBlock CocoaMemoryBlock

  33. # define Point CocoaPoint

  34. # import <Cocoa/Cocoa.h>

  35. # undef Component

  36. # undef MemoryBlock

  37. # undef Point

  38. #endif

  39. 

  40. // -----------------------------------------------------------------------

  41. 

  42. namespace juce {

  43. 

  44. class JucePluginWindow : public DialogWindow

  45. {

  46. public:

  47.     JucePluginWindow(const uintptr_t parentId, const bool isStandalone,

  48.                      AEffect* const vst2effect, v3_plugin_view** const vst3view)

  49.         : DialogWindow("JucePluginWindow", Colour(50, 50, 200), true, false),

  50.           fIsStandalone(isStandalone),

  51.           fClosed(false),

  52.           fShown(false),

  53.           fTransientId(parentId),

  54.           fLastKeys(),

  55.           fVst2Effect(vst2effect),

  56.           fVst3View(vst3view)

  57.     {

  58.         carla_zeroStruct(fLastKeys);

  59.         setVisible(false);

  60.         setOpaque(true);

  61.         setResizable(false, false);

  62.         setUsingNativeTitleBar(true);

  63.     }

  64. 

  65.     void show(Component* const comp)

  66.     {

  67.         fClosed = false;

  68.         fShown = true;

  69. 

  70.         centreWithSize(comp->getWidth(), comp->getHeight());

  71.         setContentNonOwned(comp, true);

  72. 

  73.         if (! isOnDesktop())

  74.             addToDesktop();

  75. 

  76. #ifndef CARLA_OS_LINUX

  77.         setAlwaysOnTop(true);

  78. #endif

  79.         setTransient();

  80.         setVisible(true);

  81.         toFront(true);

  82. 

  83. #ifndef CARLA_OS_LINUX

  84.         postCommandMessage(0);

  85. #endif

  86.     }

  87. 

  88.     bool keyPressed (const KeyPress& key) override

  89.     {

  90.         if (DialogWindow::keyPressed (key))

  91.             return true;

  92. 

  93.         if (fVst2Effect != nullptr)

  94.         {

  95.             const int juceKeyCode = key.getKeyCode();

  96.             int vstKeyIndex = 0;

  97.             int vstKeyValue = 0;

  98. 

  99.             do {

  100.                 /**/ if (juceKeyCode == KeyPress::spaceKey)     vstKeyValue =  7;

  101.                 else if (juceKeyCode == KeyPress::escapeKey)    vstKeyValue =  6;

  102.                 else if (juceKeyCode == KeyPress::returnKey)    vstKeyValue = 19; // NOTE: 4 is '\r' while 19 is '\n'

  103.                 else if (juceKeyCode == KeyPress::tabKey)       vstKeyValue =  2;

  104. 

  105.                 else if (juceKeyCode == KeyPress::deleteKey)    vstKeyValue = 22;

  106.                 else if (juceKeyCode == KeyPress::backspaceKey) vstKeyValue =  1;

  107.                 else if (juceKeyCode == KeyPress::insertKey)    vstKeyValue = 21;

  108. 

  109.                 else if (juceKeyCode == KeyPress::upKey)        vstKeyValue = 12;

  110.                 else if (juceKeyCode == KeyPress::downKey)      vstKeyValue = 14;

  111.                 else if (juceKeyCode == KeyPress::leftKey)      vstKeyValue = 11;

  112.                 else if (juceKeyCode == KeyPress::rightKey)     vstKeyValue = 13;

  113.                 else if (juceKeyCode == KeyPress::pageUpKey)    vstKeyValue = 15;

  114.                 else if (juceKeyCode == KeyPress::pageDownKey)  vstKeyValue = 16;

  115.                 else if (juceKeyCode == KeyPress::homeKey)      vstKeyValue = 10;

  116.                 else if (juceKeyCode == KeyPress::endKey)       vstKeyValue =  9;

  117. 

  118.                 else if (juceKeyCode == KeyPress::F1Key)  vstKeyValue = 40;

  119.                 else if (juceKeyCode == KeyPress::F2Key)  vstKeyValue = 41;

  120.                 else if (juceKeyCode == KeyPress::F3Key)  vstKeyValue = 42;

  121.                 else if (juceKeyCode == KeyPress::F4Key)  vstKeyValue = 43;

  122.                 else if (juceKeyCode == KeyPress::F5Key)  vstKeyValue = 44;

  123.                 else if (juceKeyCode == KeyPress::F6Key)  vstKeyValue = 45;

  124.                 else if (juceKeyCode == KeyPress::F7Key)  vstKeyValue = 46;

  125.                 else if (juceKeyCode == KeyPress::F8Key)  vstKeyValue = 47;

  126.                 else if (juceKeyCode == KeyPress::F9Key)  vstKeyValue = 48;

  127.                 else if (juceKeyCode == KeyPress::F10Key) vstKeyValue = 49;

  128.                 else if (juceKeyCode == KeyPress::F11Key) vstKeyValue = 50;

  129.                 else if (juceKeyCode == KeyPress::F12Key) vstKeyValue = 51;

  130. 

  131.                 else if (juceKeyCode == KeyPress::F13Key) break;

  132.                 else if (juceKeyCode == KeyPress::F14Key) break;

  133.                 else if (juceKeyCode == KeyPress::F15Key) break;

  134.                 else if (juceKeyCode == KeyPress::F16Key) break;

  135.                 else if (juceKeyCode == KeyPress::F17Key) break;

  136.                 else if (juceKeyCode == KeyPress::F18Key) break;

  137.                 else if (juceKeyCode == KeyPress::F19Key) break;

  138.                 else if (juceKeyCode == KeyPress::F20Key) break;

  139.                 else if (juceKeyCode == KeyPress::F21Key) break;

  140.                 else if (juceKeyCode == KeyPress::F22Key) break;

  141.                 else if (juceKeyCode == KeyPress::F23Key) break;

  142.                 else if (juceKeyCode == KeyPress::F24Key) break;

  143.                 else if (juceKeyCode == KeyPress::F25Key) break;

  144.                 else if (juceKeyCode == KeyPress::F26Key) break;

  145.                 else if (juceKeyCode == KeyPress::F27Key) break;

  146.                 else if (juceKeyCode == KeyPress::F28Key) break;

  147.                 else if (juceKeyCode == KeyPress::F29Key) break;

  148.                 else if (juceKeyCode == KeyPress::F30Key) break;

  149.                 else if (juceKeyCode == KeyPress::F31Key) break;

  150.                 else if (juceKeyCode == KeyPress::F32Key) break;

  151.                 else if (juceKeyCode == KeyPress::F33Key) break;

  152.                 else if (juceKeyCode == KeyPress::F34Key) break;

  153.                 else if (juceKeyCode == KeyPress::F35Key) break;

  154. 

  155.                 else if (juceKeyCode == KeyPress::numberPad0) vstKeyValue = 24;

  156.                 else if (juceKeyCode == KeyPress::numberPad1) vstKeyValue = 25;

  157.                 else if (juceKeyCode == KeyPress::numberPad2) vstKeyValue = 26;

  158.                 else if (juceKeyCode == KeyPress::numberPad3) vstKeyValue = 27;

  159.                 else if (juceKeyCode == KeyPress::numberPad4) vstKeyValue = 28;

  160.                 else if (juceKeyCode == KeyPress::numberPad5) vstKeyValue = 29;

  161.                 else if (juceKeyCode == KeyPress::numberPad6) vstKeyValue = 30;

  162.                 else if (juceKeyCode == KeyPress::numberPad7) vstKeyValue = 31;

  163.                 else if (juceKeyCode == KeyPress::numberPad8) vstKeyValue = 32;

  164.                 else if (juceKeyCode == KeyPress::numberPad9) vstKeyValue = 33;

  165. 

  166.                 else if (juceKeyCode == KeyPress::numberPadAdd)          vstKeyValue = 35;

  167.                 else if (juceKeyCode == KeyPress::numberPadSubtract)     vstKeyValue = 37;

  168.                 else if (juceKeyCode == KeyPress::numberPadMultiply)     vstKeyValue = 34;

  169.                 else if (juceKeyCode == KeyPress::numberPadDivide)       vstKeyValue = 39;

  170.                 else if (juceKeyCode == KeyPress::numberPadSeparator)    vstKeyValue = 36;

  171.                 else if (juceKeyCode == KeyPress::numberPadDecimalPoint) vstKeyValue = 38;

  172.                 else if (juceKeyCode == KeyPress::numberPadEquals)       vstKeyValue = 57;

  173. 

  174.                 else if (juceKeyCode == KeyPress::numberPadDelete) break;

  175. 

  176.                 else if (juceKeyCode == KeyPress::playKey) break;

  177.                 else if (juceKeyCode == KeyPress::stopKey) break;

  178.                 else if (juceKeyCode == KeyPress::fastForwardKey) break;

  179.                 else if (juceKeyCode == KeyPress::rewindKey) break;

  180. 

  181.                 else vstKeyIndex = juceKeyCode;

  182.             } while (false);

  183. 

  184.             fLastKeys.vst2.index = vstKeyIndex;

  185.             fLastKeys.vst2.value = vstKeyValue;

  186.             return fVst2Effect->dispatcher (fVst2Effect, effEditKeyDown, vstKeyIndex, vstKeyValue, nullptr, 0.0f) != 0;

  187.         }

  188. 

  189.         if (fVst3View != nullptr)

  190.         {

  191.             const int juceKeyCode = key.getKeyCode();

  192.             const int juceKeyMods = key.getModifiers().getRawFlags();

  193.             int16_t vst3KeyChar = 0;

  194.             int16_t vst3KeyCode = 0;

  195.             int16_t vst3KeyMods = 0;

  196. 

  197.             // KEY_NEXT 8

  198.             // KEY_SELECT 17

  199.             // KEY_SELECT 18

  200.             // KEY_SNAPSHOT 20

  201.             // KEY_HELP 23

  202.             // KEY_NUMLOCK 52

  203.             // KEY_SCROLL 53

  204.             // KEY_VOLUME_UP 63

  205.             // KEY_VOLUME_DOWN 64

  206. 

  207.             do {

  208.                 /**/ if (juceKeyCode == KeyPress::spaceKey)

  209.                 {

  210.                     vst3KeyChar = ' ';

  211.                     vst3KeyCode = 7;

  212.                 }

  213.                 else if (juceKeyCode == KeyPress::escapeKey)

  214.                 {

  215.                     vst3KeyCode = 6;

  216.                 }

  217.                 else if (juceKeyCode == KeyPress::returnKey)

  218.                 {

  219.                     vst3KeyChar = '\n';

  220.                     vst3KeyCode = 19; // NOTE: 4 is '\r' while 19 is '\n'

  221.                 }

  222.                 else if (juceKeyCode == KeyPress::tabKey)

  223.                 {

  224.                     vst3KeyChar = '\t';

  225.                     vst3KeyCode = 2;

  226.                 }

  227. 

  228.                 else if (juceKeyCode == KeyPress::deleteKey)    vst3KeyCode = 22;

  229.                 else if (juceKeyCode == KeyPress::backspaceKey) vst3KeyCode = 1;

  230.                 else if (juceKeyCode == KeyPress::insertKey)    vst3KeyCode = 21;

  231. 

  232.                 else if (juceKeyCode == KeyPress::upKey)       vst3KeyCode = 12;

  233.                 else if (juceKeyCode == KeyPress::downKey)     vst3KeyCode = 14;

  234.                 else if (juceKeyCode == KeyPress::leftKey)     vst3KeyCode = 11;

  235.                 else if (juceKeyCode == KeyPress::rightKey)    vst3KeyCode = 13;

  236.                 else if (juceKeyCode == KeyPress::pageUpKey)   vst3KeyCode = 15;

  237.                 else if (juceKeyCode == KeyPress::pageDownKey) vst3KeyCode = 16;

  238.                 else if (juceKeyCode == KeyPress::homeKey)     vst3KeyCode = 10;

  239.                 else if (juceKeyCode == KeyPress::endKey)      vst3KeyCode = 9;

  240. 

  241.                 else if (juceKeyCode == KeyPress::F1Key)  vst3KeyCode = 40;

  242.                 else if (juceKeyCode == KeyPress::F2Key)  vst3KeyCode = 41;

  243.                 else if (juceKeyCode == KeyPress::F3Key)  vst3KeyCode = 42;

  244.                 else if (juceKeyCode == KeyPress::F4Key)  vst3KeyCode = 43;

  245.                 else if (juceKeyCode == KeyPress::F5Key)  vst3KeyCode = 44;

  246.                 else if (juceKeyCode == KeyPress::F6Key)  vst3KeyCode = 45;

  247.                 else if (juceKeyCode == KeyPress::F7Key)  vst3KeyCode = 46;

  248.                 else if (juceKeyCode == KeyPress::F8Key)  vst3KeyCode = 47;

  249.                 else if (juceKeyCode == KeyPress::F9Key)  vst3KeyCode = 48;

  250.                 else if (juceKeyCode == KeyPress::F10Key) vst3KeyCode = 49;

  251.                 else if (juceKeyCode == KeyPress::F11Key) vst3KeyCode = 50;

  252.                 else if (juceKeyCode == KeyPress::F12Key) vst3KeyCode = 51;

  253. 

  254.                 else if (juceKeyCode == KeyPress::F13Key) vst3KeyCode = 65;

  255.                 else if (juceKeyCode == KeyPress::F14Key) vst3KeyCode = 66;

  256.                 else if (juceKeyCode == KeyPress::F15Key) vst3KeyCode = 67;

  257.                 else if (juceKeyCode == KeyPress::F16Key) vst3KeyCode = 68;

  258.                 else if (juceKeyCode == KeyPress::F17Key) vst3KeyCode = 69;

  259.                 else if (juceKeyCode == KeyPress::F18Key) vst3KeyCode = 70;

  260.                 else if (juceKeyCode == KeyPress::F19Key) vst3KeyCode = 71;

  261.                 else if (juceKeyCode == KeyPress::F20Key) break;

  262.                 else if (juceKeyCode == KeyPress::F21Key) break;

  263.                 else if (juceKeyCode == KeyPress::F22Key) break;

  264.                 else if (juceKeyCode == KeyPress::F23Key) break;

  265.                 else if (juceKeyCode == KeyPress::F24Key) break;

  266.                 else if (juceKeyCode == KeyPress::F25Key) break;

  267.                 else if (juceKeyCode == KeyPress::F26Key) break;

  268.                 else if (juceKeyCode == KeyPress::F27Key) break;

  269.                 else if (juceKeyCode == KeyPress::F28Key) break;

  270.                 else if (juceKeyCode == KeyPress::F29Key) break;

  271.                 else if (juceKeyCode == KeyPress::F30Key) break;

  272.                 else if (juceKeyCode == KeyPress::F31Key) break;

  273.                 else if (juceKeyCode == KeyPress::F32Key) break;

  274.                 else if (juceKeyCode == KeyPress::F33Key) break;

  275.                 else if (juceKeyCode == KeyPress::F34Key) break;

  276.                 else if (juceKeyCode == KeyPress::F35Key) break;

  277. 

  278.                 else if (juceKeyCode == KeyPress::numberPad0) vst3KeyCode = 24;

  279.                 else if (juceKeyCode == KeyPress::numberPad1) vst3KeyCode = 25;

  280.                 else if (juceKeyCode == KeyPress::numberPad2) vst3KeyCode = 26;

  281.                 else if (juceKeyCode == KeyPress::numberPad3) vst3KeyCode = 27;

  282.                 else if (juceKeyCode == KeyPress::numberPad4) vst3KeyCode = 28;

  283.                 else if (juceKeyCode == KeyPress::numberPad5) vst3KeyCode = 29;

  284.                 else if (juceKeyCode == KeyPress::numberPad6) vst3KeyCode = 30;

  285.                 else if (juceKeyCode == KeyPress::numberPad7) vst3KeyCode = 31;

  286.                 else if (juceKeyCode == KeyPress::numberPad8) vst3KeyCode = 32;

  287.                 else if (juceKeyCode == KeyPress::numberPad9) vst3KeyCode = 33;

  288. 

  289.                 else if (juceKeyCode == KeyPress::numberPadAdd)          vst3KeyCode = 35;

  290.                 else if (juceKeyCode == KeyPress::numberPadSubtract)     vst3KeyCode = 37;

  291.                 else if (juceKeyCode == KeyPress::numberPadMultiply)     vst3KeyCode = 34;

  292.                 else if (juceKeyCode == KeyPress::numberPadDivide)       vst3KeyCode = 39;

  293.                 else if (juceKeyCode == KeyPress::numberPadSeparator)    vst3KeyCode = 36;

  294.                 else if (juceKeyCode == KeyPress::numberPadDecimalPoint) vst3KeyCode = 38;

  295.                 else if (juceKeyCode == KeyPress::numberPadEquals)       vst3KeyCode = 57;

  296. 

  297.                 else if (juceKeyCode == KeyPress::numberPadDelete) break;

  298. 

  299.                 else if (juceKeyCode == KeyPress::playKey)        vst3KeyCode = 59;

  300.                 else if (juceKeyCode == KeyPress::stopKey)        vst3KeyCode = 60;

  301.                 else if (juceKeyCode == KeyPress::fastForwardKey) vst3KeyCode = 62;

  302.                 else if (juceKeyCode == KeyPress::rewindKey)      vst3KeyCode = 61;

  303. 

  304.                 else

  305.                 {

  306.                     vst3KeyChar = static_cast<int16_t>(juceKeyCode);

  307. 

  308.                     if ((juceKeyCode >= 0x30 && juceKeyCode <= 0x39) || (juceKeyCode >= 0x41 && juceKeyCode <= 0x5A))

  309.                         vst3KeyCode = static_cast<int16_t>(juceKeyCode - 0x30 + 128);

  310.                 }

  311.             } while (false);

  312. 

  313.             if (juceKeyMods & ModifierKeys::shiftModifier)

  314.                 vst3KeyMods |= 1 << 0;

  315.             if (juceKeyMods & ModifierKeys::altModifier)

  316.                 vst3KeyMods |= 1 << 1;

  317.             if (juceKeyMods & ModifierKeys::commandModifier)

  318.                 vst3KeyMods |= 1 << 2;

  319. #if JUCE_MAC || JUCE_IOS

  320.             if (juceKeyMods & ModifierKeys::ctrlModifier)

  321.                 vst3KeyMods |= 1 << 3;

  322. #endif

  323. 

  324.             fLastKeys.vst3.keychar = vst3KeyChar;

  325.             fLastKeys.vst3.keycode = vst3KeyCode;

  326.             fLastKeys.vst3.keymods = vst3KeyMods;

  327.             return v3_cpp_obj(fVst3View)->on_key_down (fVst3View, vst3KeyChar, vst3KeyCode, vst3KeyMods) == V3_TRUE;

  328.         }

  329. 

  330.         if (Component* const comp = getContentComponent())

  331.             return comp->keyPressed (key);

  332. 

  333.         return false;

  334.     }

  335. 

  336.     bool keyStateChanged (bool isKeyDown) override

  337.     {

  338.         if (DialogWindow::keyStateChanged (isKeyDown))

  339.             return true;

  340. 

  341.         if (fVst2Effect != nullptr && (fLastKeys.vst2.index != 0 || fLastKeys.vst2.value != 0) && ! isKeyDown)

  342.         {

  343.             const int vstKeyIndex = fLastKeys.vst2.index;

  344.             const int vstKeyValue = fLastKeys.vst2.value;

  345.             fLastKeys.vst2.index = fLastKeys.vst2.value = 0;

  346.             return fVst2Effect->dispatcher (fVst2Effect, effEditKeyUp, vstKeyIndex, vstKeyValue, nullptr, 0.0f) != 0;

  347.         }

  348. 

  349.         if (fVst3View != nullptr && (fLastKeys.vst3.keychar != 0 || fLastKeys.vst3.keycode != 0) && ! isKeyDown)

  350.         {

  351.             const int16_t vst3KeyChar = fLastKeys.vst3.keychar;

  352.             const int16_t vst3KeyCode = fLastKeys.vst3.keycode;

  353.             const int16_t vst3KeyMods = fLastKeys.vst3.keymods;

  354.             fLastKeys.vst3.keychar = fLastKeys.vst3.keycode = fLastKeys.vst3.keymods = 0;

  355.             return v3_cpp_obj(fVst3View)->on_key_up (fVst3View, vst3KeyChar, vst3KeyCode, vst3KeyMods) == V3_TRUE;

  356.         }

  357. 

  358.         if (Component* const comp = getContentComponent())

  359.             return comp->keyStateChanged (isKeyDown);

  360. 

  361.         return false;

  362.     }

  363. 

  364.     void modifierKeysChanged (const ModifierKeys& modifiers) override

  365.     {

  366.         DialogWindow::modifierKeysChanged (modifiers);

  367. 

  368.         if (fVst2Effect != nullptr)

  369.         {

  370.             const int oldRawFlags = fLastKeys.vst2.rmods;

  371.             const int newRawFlags = modifiers.getRawFlags();

  372. 

  373.             if ((oldRawFlags & ModifierKeys::shiftModifier) != (newRawFlags & ModifierKeys::shiftModifier))

  374.             {

  375.                 fVst2Effect->dispatcher (fVst2Effect,

  376.                                          (newRawFlags & ModifierKeys::shiftModifier) ? effEditKeyDown : effEditKeyUp,

  377.                                          0, 54, nullptr, 0.0f);

  378.             }

  379. 

  380.             if ((oldRawFlags & ModifierKeys::ctrlModifier) != (newRawFlags & ModifierKeys::ctrlModifier))

  381.             {

  382.                 fVst2Effect->dispatcher (fVst2Effect,

  383.                                          (newRawFlags & ModifierKeys::ctrlModifier) ? effEditKeyDown : effEditKeyUp,

  384.                                          0, 55, nullptr, 0.0f);

  385.             }

  386. 

  387.             if ((oldRawFlags & ModifierKeys::altModifier) != (newRawFlags & ModifierKeys::altModifier))

  388.             {

  389.                 fVst2Effect->dispatcher (fVst2Effect,

  390.                                          (newRawFlags & ModifierKeys::altModifier) ? effEditKeyDown : effEditKeyUp,

  391.                                          0, 56, nullptr, 0.0f);

  392.             }

  393. 

  394.             if ((oldRawFlags & ModifierKeys::popupMenuClickModifier) != (newRawFlags & ModifierKeys::popupMenuClickModifier))

  395.             {

  396.                 fVst2Effect->dispatcher (fVst2Effect,

  397.                                          (newRawFlags & ModifierKeys::popupMenuClickModifier) ? effEditKeyDown : effEditKeyUp,

  398.                                          0, 58, nullptr, 0.0f);

  399.             }

  400. 

  401.             fLastKeys.vst2.rmods = newRawFlags;

  402.         }

  403. 

  404.         if (fVst3View != nullptr)

  405.         {

  406.             const int oldRawFlags = fLastKeys.vst3.rmods;

  407.             const int newRawFlags = modifiers.getRawFlags();

  408. 

  409.             if ((oldRawFlags & ModifierKeys::shiftModifier) != (newRawFlags & ModifierKeys::shiftModifier))

  410.             {

  411.                 if (newRawFlags & ModifierKeys::shiftModifier)

  412.                     v3_cpp_obj(fVst3View)->on_key_down (fVst3View, 0, 54, fLastKeys.vst3.keymods);

  413.                 else

  414.                     v3_cpp_obj(fVst3View)->on_key_up (fVst3View, 0, 54, fLastKeys.vst3.keymods);

  415.             }

  416. 

  417.             if ((oldRawFlags & ModifierKeys::ctrlModifier) != (newRawFlags & ModifierKeys::ctrlModifier))

  418.             {

  419.                 if (newRawFlags & ModifierKeys::ctrlModifier)

  420.                     v3_cpp_obj(fVst3View)->on_key_down (fVst3View, 0, 55, fLastKeys.vst3.keymods);

  421.                 else

  422.                     v3_cpp_obj(fVst3View)->on_key_up (fVst3View, 0, 55, fLastKeys.vst3.keymods);

  423.             }

  424. 

  425.             if ((oldRawFlags & ModifierKeys::altModifier) != (newRawFlags & ModifierKeys::altModifier))

  426.             {

  427.                 if (newRawFlags & ModifierKeys::altModifier)

  428.                     v3_cpp_obj(fVst3View)->on_key_down (fVst3View, 0, 56, fLastKeys.vst3.keymods);

  429.                 else

  430.                     v3_cpp_obj(fVst3View)->on_key_up (fVst3View, 0, 56, fLastKeys.vst3.keymods);

  431.             }

  432. 

  433.             if ((oldRawFlags & ModifierKeys::popupMenuClickModifier) != (newRawFlags & ModifierKeys::popupMenuClickModifier))

  434.             {

  435.                 if (newRawFlags & ModifierKeys::popupMenuClickModifier)

  436.                     v3_cpp_obj(fVst3View)->on_key_down (fVst3View, 0, 58, fLastKeys.vst3.keymods);

  437.                 else

  438.                     v3_cpp_obj(fVst3View)->on_key_up (fVst3View, 0, 58, fLastKeys.vst3.keymods);

  439.             }

  440. 

  441.             fLastKeys.vst3.rmods = newRawFlags;

  442.         }

  443.     }

  444. 

  445.     void focusGained (const FocusChangeType cause) override

  446.     {

  447.         DialogWindow::focusGained (cause);

  448. 

  449.         if (fVst3View != nullptr)

  450.             v3_cpp_obj(fVst3View)->on_focus (fVst3View, true);

  451.     }

  452. 

  453.     void focusLost (const FocusChangeType cause) override

  454.     {

  455.         if (fVst3View != nullptr)

  456.             v3_cpp_obj(fVst3View)->on_focus (fVst3View, false);

  457. 

  458.         DialogWindow::focusLost (cause);

  459.     }

  460. 

  461.     void hide()

  462.     {

  463.         setVisible(false);

  464. 

  465.         if (isOnDesktop())

  466.             removeFromDesktop();

  467. 

  468.         clearContentComponent();

  469.     }

  470. 

  471.     bool wasClosedByUser() const noexcept

  472.     {

  473.         return fClosed;

  474.     }

  475. 

  476. protected:

  477.     void closeButtonPressed() override

  478.     {

  479.         fClosed = true;

  480.     }

  481. 

  482.     bool escapeKeyPressed() override

  483.     {

  484.         fClosed = true;

  485.         return true;

  486.     }

  487. 

  488.     int getDesktopWindowStyleFlags() const override

  489.     {

  490.         int wflags = 0;

  491.         wflags |= ComponentPeer::windowHasCloseButton;

  492.         wflags |= ComponentPeer::windowHasDropShadow;

  493.         wflags |= ComponentPeer::windowHasTitleBar;

  494.         if (fIsStandalone)

  495.             wflags |= ComponentPeer::windowAppearsOnTaskbar;

  496.         return wflags;

  497.     }

  498. 

  499. #ifndef CARLA_OS_LINUX

  500.     void handleCommandMessage(const int comamndId) override

  501.     {

  502.         CARLA_SAFE_ASSERT_RETURN(comamndId == 0,);

  503. 

  504.         if (fShown)

  505.         {

  506.             fShown = false;

  507.             setAlwaysOnTop(false);

  508.         }

  509.     }

  510. #endif

  511. 

  512. private:

  513.     const bool fIsStandalone;

  514.     volatile bool fClosed;

  515.     bool fShown;

  516.     const uintptr_t fTransientId;

  517.     union {

  518.         struct {

  519.             int index;

  520.             int value;

  521.             int rmods;

  522.         } vst2;

  523. 

  524.         struct {

  525.             int16_t keychar;

  526.             int16_t keycode;

  527.             int16_t keymods;

  528.             int rmods;

  529.         } vst3;

  530.     } fLastKeys;

  531.     AEffect* const fVst2Effect;

  532.     v3_plugin_view** const fVst3View;

  533. 

  534.     void setTransient()

  535.     {

  536.         if (fTransientId == 0)

  537.             return;

  538. 

  539. #if defined(CARLA_OS_LINUX) && defined(HAVE_X11)

  540.         Display* const display = XWindowSystem::getInstance()->getDisplay();

  541.         CARLA_SAFE_ASSERT_RETURN(display != nullptr,);

  542. 

  543.         ::Window window = (::Window)getWindowHandle();

  544. 

  545.         CARLA_SAFE_ASSERT_RETURN(window != 0,);

  546. 

  547.         XSetTransientForHint(display, window, static_cast<::Window>(fTransientId));

  548. #endif

  549. 

  550. #ifdef CARLA_OS_MAC

  551.         NSView* const view = (NSView*)getWindowHandle();

  552.         CARLA_SAFE_ASSERT_RETURN(view != nullptr,);

  553. 

  554.         NSWindow* const window = [view window];

  555.         CARLA_SAFE_ASSERT_RETURN(window != nullptr,);

  556. 

  557.         NSWindow* const parentWindow = [NSApp windowWithWindowNumber:fTransientId];

  558.         CARLA_SAFE_ASSERT_RETURN(parentWindow != nullptr,);

  559. 

  560.         [parentWindow addChildWindow:window

  561.                              ordered:NSWindowAbove];

  562. #endif

  563. 

  564. #ifdef CARLA_OS_WIN

  565.         const HWND window = (HWND)getWindowHandle();

  566.         CARLA_SAFE_ASSERT_RETURN(window != nullptr,);

  567. 

  568.         SetWindowLongPtr(window, GWLP_HWNDPARENT, static_cast<LONG_PTR>(fTransientId));

  569. #endif

  570.     }

  571. 

  572.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(JucePluginWindow)

  573. };

  574. 

  575. } // namespace juce

  576. 

  577. using juce::JucePluginWindow;

  578. 

  579. // -----------------------------------------------------------------------

  580. 

  581. #endif // JUCE_PLUGIN_WINDOW_HPP_INCLUDED