source/modules/distrho/src/DistrhoUIInternal.hpp

   1 /*
   2  * DISTRHO Plugin Framework (DPF)
   3  * Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any purpose with
   6  * or without fee is hereby granted, provided that the above copyright notice and this
   7  * permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
  10  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
  11  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  13  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #ifndef DISTRHO_UI_INTERNAL_HPP_INCLUDED
  18 #define DISTRHO_UI_INTERNAL_HPP_INCLUDED
  19
  20 #include "DistrhoUIPrivateData.hpp"
  21
  22 START_NAMESPACE_DISTRHO
  23
  24 // -----------------------------------------------------------------------
  25 // Static data, see DistrhoUI.cpp
  26
  27 extern const char* g_nextBundlePath;
  28 #if DISTRHO_PLUGIN_HAS_EXTERNAL_UI
  29 extern uintptr_t   g_nextWindowId;
  30 extern double      g_nextScaleFactor;
  31 #endif
  32
  33 // -----------------------------------------------------------------------
  34 // UI exporter class
  35
  36 class UIExporter
  37 {
  38     // -------------------------------------------------------------------
  39     // UI Widget and its private data
  40
  41     UI* ui;
  42     UI::PrivateData* uiData;
  43
  44     // -------------------------------------------------------------------
  45
  46 public:
  47     UIExporter(void* const callbacksPtr,
  48                const uintptr_t winId,
  49                const double sampleRate,
  50                const editParamFunc editParamCall,
  51                const setParamFunc setParamCall,
  52                const setStateFunc setStateCall,
  53                const sendNoteFunc sendNoteCall,
  54                const setSizeFunc setSizeCall,
  55                const fileRequestFunc fileRequestCall,
  56                const char* const bundlePath = nullptr,
  57                void* const dspPtr = nullptr,
  58                const double scaleFactor = 0.0,
  59                const uint32_t bgColor = 0,
  60                const uint32_t fgColor = 0xffffffff)
  61         : ui(nullptr),
  62           uiData(new UI::PrivateData())
  63     {
  64         uiData->sampleRate = sampleRate;
  65         uiData->bundlePath = bundlePath != nullptr ? strdup(bundlePath) : nullptr;
  66         uiData->dspPtr = dspPtr;
  67
  68         uiData->bgColor = bgColor;
  69         uiData->fgColor = fgColor;
  70         uiData->scaleFactor = scaleFactor;
  71         uiData->winId = winId;
  72
  73         uiData->callbacksPtr            = callbacksPtr;
  74         uiData->editParamCallbackFunc   = editParamCall;
  75         uiData->setParamCallbackFunc    = setParamCall;
  76         uiData->setStateCallbackFunc    = setStateCall;
  77         uiData->sendNoteCallbackFunc    = sendNoteCall;
  78         uiData->setSizeCallbackFunc     = setSizeCall;
  79         uiData->fileRequestCallbackFunc = fileRequestCall;
  80
  81         g_nextBundlePath  = bundlePath;
  82 #if DISTRHO_PLUGIN_HAS_EXTERNAL_UI
  83         g_nextWindowId    = winId;
  84         g_nextScaleFactor = scaleFactor;
  85 #endif
  86         UI::PrivateData::s_nextPrivateData = uiData;
  87
  88         UI* const uiPtr = createUI();
  89
  90         g_nextBundlePath  = nullptr;
  91 #if DISTRHO_PLUGIN_HAS_EXTERNAL_UI
  92         g_nextWindowId    = 0;
  93         g_nextScaleFactor = 0.0;
  94 #else
  95         // enter context called in the PluginWindow constructor, see DistrhoUIPrivateData.hpp
  96         uiData->window->leaveContext();
  97 #endif
  98         UI::PrivateData::s_nextPrivateData = nullptr;
  99
 100         DISTRHO_SAFE_ASSERT_RETURN(uiPtr != nullptr,);
 101         ui = uiPtr;
 102         uiData->initializing = false;
 103
 104 #if !DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 105         // unused
 106         (void)bundlePath;
 107 #endif
 108     }
 109
 110     ~UIExporter()
 111     {
 112         quit();
 113 #if !DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 114         uiData->window->enterContextForDeletion();
 115 #endif
 116         delete ui;
 117         delete uiData;
 118     }
 119
 120     // -------------------------------------------------------------------
 121
 122     uint getWidth() const noexcept
 123     {
 124         return uiData->window->getWidth();
 125     }
 126
 127     uint getHeight() const noexcept
 128     {
 129         return uiData->window->getHeight();
 130     }
 131
 132     double getScaleFactor() const noexcept
 133     {
 134         return uiData->window->getScaleFactor();
 135     }
 136
 137     bool getGeometryConstraints(uint& minimumWidth, uint& minimumHeight, bool& keepAspectRatio) const noexcept
 138     {
 139 #if DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 140         uiData->window->getGeometryConstraints(minimumWidth, minimumHeight, keepAspectRatio);
 141 #else
 142         const DGL_NAMESPACE::Size<uint> size(uiData->window->getGeometryConstraints(keepAspectRatio));
 143         minimumWidth = size.getWidth();
 144         minimumHeight = size.getHeight();
 145 #endif
 146         return true;
 147     }
 148
 149     bool isResizable() const noexcept
 150     {
 151         return uiData->window->isResizable();
 152     }
 153
 154     bool isVisible() const noexcept
 155     {
 156         return uiData->window->isVisible();
 157     }
 158
 159     uintptr_t getNativeWindowHandle() const noexcept
 160     {
 161         return uiData->window->getNativeWindowHandle();
 162     }
 163
 164     uint getBackgroundColor() const noexcept
 165     {
 166         DISTRHO_SAFE_ASSERT_RETURN(uiData != nullptr, 0);
 167
 168         return uiData->bgColor;
 169     }
 170
 171     uint getForegroundColor() const noexcept
 172     {
 173         DISTRHO_SAFE_ASSERT_RETURN(uiData != nullptr, 0xffffffff);
 174
 175         return uiData->fgColor;
 176     }
 177
 178     // -------------------------------------------------------------------
 179
 180     uint32_t getParameterOffset() const noexcept
 181     {
 182         DISTRHO_SAFE_ASSERT_RETURN(uiData != nullptr, 0);
 183
 184         return uiData->parameterOffset;
 185     }
 186
 187     // -------------------------------------------------------------------
 188
 189     void parameterChanged(const uint32_t index, const float value)
 190     {
 191         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);
 192
 193         ui->parameterChanged(index, value);
 194     }
 195
 196 #if DISTRHO_PLUGIN_WANT_PROGRAMS
 197     void programLoaded(const uint32_t index)
 198     {
 199         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);
 200
 201         ui->programLoaded(index);
 202     }
 203 #endif
 204
 205 #if DISTRHO_PLUGIN_WANT_STATE
 206     void stateChanged(const char* const key, const char* const value)
 207     {
 208         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);
 209         DISTRHO_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
 210         DISTRHO_SAFE_ASSERT_RETURN(value != nullptr,);
 211
 212         ui->stateChanged(key, value);
 213     }
 214 #endif
 215
 216     // -------------------------------------------------------------------
 217
 218 #if DISTRHO_UI_IS_STANDALONE
 219     void exec(DGL_NAMESPACE::IdleCallback* const cb)
 220     {
 221         DISTRHO_SAFE_ASSERT_RETURN(cb != nullptr,);
 222
 223         uiData->window->show();
 224         uiData->window->focus();
 225         uiData->app.addIdleCallback(cb);
 226         uiData->app.exec();
 227     }
 228
 229     void exec_idle()
 230     {
 231         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr, );
 232
 233         ui->uiIdle();
 234     }
 235
 236     void showAndFocus()
 237     {
 238         uiData->window->show();
 239         uiData->window->focus();
 240     }
 241 #endif
 242
 243     bool plugin_idle()
 244     {
 245         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr, false);
 246
 247         uiData->app.idle();
 248         ui->uiIdle();
 249         return ! uiData->app.isQuitting();
 250     }
 251
 252     void focus()
 253     {
 254         uiData->window->focus();
 255     }
 256
 257     void quit()
 258     {
 259         uiData->window->close();
 260         uiData->app.quit();
 261     }
 262
 263     // -------------------------------------------------------------------
 264
 265 #if defined(DISTRHO_PLUGIN_TARGET_VST3) && (defined(DISTRHO_OS_MAC) || defined(DISTRHO_OS_WINDOWS))
 266     void idleForVST3()
 267     {
 268         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);
 269
 270         uiData->app.triggerIdleCallbacks();
 271         ui->uiIdle();
 272     }
 273
 274 # if !DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 275     void addIdleCallbackForVST3(IdleCallback* const cb, const uint timerFrequencyInMs)
 276     {
 277         uiData->window->addIdleCallback(cb, timerFrequencyInMs);
 278     }
 279
 280     void removeIdleCallbackForVST3(IdleCallback* const cb)
 281     {
 282         uiData->window->removeIdleCallback(cb);
 283     }
 284 # endif
 285 #endif
 286
 287     // -------------------------------------------------------------------
 288
 289     void setWindowOffset(const int x, const int y)
 290     {
 291 #if DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 292         // TODO
 293         (void)x; (void)y;
 294 #else
 295         uiData->window->setOffset(x, y);
 296 #endif
 297     }
 298
 299 #ifdef DISTRHO_PLUGIN_TARGET_VST3
 300     void setWindowSizeForVST3(const uint width, const uint height)
 301     {
 302 # if DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 303         ui->setSize(width, height);
 304 # else
 305         uiData->window->setSizeForVST3(width, height);
 306 # endif
 307     }
 308 #endif
 309
 310     void setWindowTitle(const char* const uiTitle)
 311     {
 312         uiData->window->setTitle(uiTitle);
 313     }
 314
 315     void setWindowTransientWinId(const uintptr_t transientParentWindowHandle)
 316     {
 317 #if DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 318         ui->setTransientWindowId(transientParentWindowHandle);
 319 #else
 320         uiData->window->setTransientParent(transientParentWindowHandle);
 321 #endif
 322     }
 323
 324     bool setWindowVisible(const bool yesNo)
 325     {
 326         uiData->window->setVisible(yesNo);
 327
 328         return ! uiData->app.isQuitting();
 329     }
 330
 331 #if !DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 332     bool handlePluginKeyboardVST(const bool press, const bool special, const uint keychar, const uint keycode, const uint16_t mods)
 333     {
 334         using namespace DGL_NAMESPACE;
 335
 336         Widget::KeyboardEvent ev;
 337         ev.mod     = mods;
 338         ev.press   = press;
 339         ev.key     = keychar;
 340         ev.keycode = keycode;
 341
 342         // keyboard events must always be lowercase
 343         if (ev.key >= 'A' && ev.key <= 'Z')
 344             ev.key += 'a' - 'A'; // A-Z -> a-z
 345
 346         const bool ret = ui->onKeyboard(ev);
 347
 348         if (press && !special && (mods & (kModifierControl|kModifierAlt|kModifierSuper)) == 0)
 349         {
 350             Widget::CharacterInputEvent cev;
 351             cev.mod       = mods;
 352             cev.character = keychar;
 353             cev.keycode   = keycode;
 354
 355             // if shift modifier is on, convert a-z -> A-Z for character input
 356             if (cev.character >= 'a' && cev.character <= 'z' && (mods & kModifierShift) != 0)
 357                 cev.character -= 'a' - 'A';
 358
 359             ui->onCharacterInput(cev);
 360         }
 361
 362         return ret;
 363     }
 364 #endif
 365
 366     // -------------------------------------------------------------------
 367
 368     void notifyScaleFactorChanged(const double scaleFactor)
 369     {
 370         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);
 371
 372         ui->uiScaleFactorChanged(scaleFactor);
 373     }
 374
 375 #if !DISTRHO_PLUGIN_HAS_EXTERNAL_UI
 376     void notifyFocusChanged(const bool focus)
 377     {
 378         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);
 379
 380         ui->uiFocus(focus, DGL_NAMESPACE::kCrossingNormal);
 381     }
 382 #endif
 383
 384     void setSampleRate(const double sampleRate, const bool doCallback = false)
 385     {
 386         DISTRHO_SAFE_ASSERT_RETURN(ui != nullptr,);
 387         DISTRHO_SAFE_ASSERT_RETURN(uiData != nullptr,);
 388         DISTRHO_SAFE_ASSERT(sampleRate > 0.0);
 389
 390         if (d_isEqual(uiData->sampleRate, sampleRate))
 391             return;
 392
 393         uiData->sampleRate = sampleRate;
 394
 395         if (doCallback)
 396             ui->sampleRateChanged(sampleRate);
 397     }
 398
 399     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(UIExporter)
 400 };
 401
 402 // -----------------------------------------------------------------------
 403
 404 END_NAMESPACE_DISTRHO
 405
 406 #endif // DISTRHO_UI_INTERNAL_HPP_INCLUDED