source/modules/dgl/src/ApplicationPrivateData.cpp

   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 #include "ApplicationPrivateData.hpp"
  18 #include "../Window.hpp"
  19
  20 #include "pugl.hpp"
  21
  22 #include <ctime>
  23
  24 START_NAMESPACE_DGL
  25
  26 typedef std::list<DGL_NAMESPACE::Window*>::reverse_iterator WindowListReverseIterator;
  27
  28 static d_ThreadHandle getCurrentThreadHandle() noexcept
  29 {
  30 #ifdef DISTRHO_OS_WINDOWS
  31     return GetCurrentThread();
  32 #else
  33     return pthread_self();
  34 #endif
  35 }
  36
  37 static bool isThisTheMainThread(const d_ThreadHandle mainThreadHandle) noexcept
  38 {
  39 #ifdef DISTRHO_OS_WINDOWS
  40     return GetCurrentThread() == mainThreadHandle; // IsGUIThread ?
  41 #else
  42     return pthread_equal(getCurrentThreadHandle(), mainThreadHandle) != 0;
  43 #endif
  44 }
  45
  46 // --------------------------------------------------------------------------------------------------------------------
  47
  48 const char* Application::getClassName() const noexcept
  49 {
  50     return puglGetClassName(pData->world);
  51 }
  52
  53 // --------------------------------------------------------------------------------------------------------------------
  54
  55 Application::PrivateData::PrivateData(const bool standalone)
  56     : world(puglNewWorld(standalone ? PUGL_PROGRAM : PUGL_MODULE,
  57                          standalone ? PUGL_WORLD_THREADS : 0x0)),
  58       isStandalone(standalone),
  59       isQuitting(false),
  60       isQuittingInNextCycle(false),
  61       isStarting(true),
  62       visibleWindows(0),
  63       mainThreadHandle(getCurrentThreadHandle()),
  64       windows(),
  65       idleCallbacks()
  66 {
  67     DISTRHO_SAFE_ASSERT_RETURN(world != nullptr,);
  68
  69     puglSetWorldHandle(world, this);
  70 #ifndef __EMSCRIPTEN__
  71     puglSetClassName(world, DISTRHO_MACRO_AS_STRING(DGL_NAMESPACE));
  72 #endif
  73 }
  74
  75 Application::PrivateData::~PrivateData()
  76 {
  77     DISTRHO_SAFE_ASSERT(isStarting || isQuitting);
  78     DISTRHO_SAFE_ASSERT(visibleWindows == 0);
  79
  80     windows.clear();
  81     idleCallbacks.clear();
  82
  83     if (world != nullptr)
  84         puglFreeWorld(world);
  85 }
  86
  87 // --------------------------------------------------------------------------------------------------------------------
  88
  89 void Application::PrivateData::oneWindowShown() noexcept
  90 {
  91     if (++visibleWindows == 1)
  92     {
  93         isQuitting = false;
  94         isStarting = false;
  95     }
  96 }
  97
  98 void Application::PrivateData::oneWindowClosed() noexcept
  99 {
 100     DISTRHO_SAFE_ASSERT_RETURN(visibleWindows != 0,);
 101
 102     if (--visibleWindows == 0)
 103         isQuitting = true;
 104 }
 105
 106 // --------------------------------------------------------------------------------------------------------------------
 107
 108 void Application::PrivateData::idle(const uint timeoutInMs)
 109 {
 110     if (isQuittingInNextCycle)
 111     {
 112         quit();
 113         isQuittingInNextCycle = false;
 114     }
 115
 116     if (world != nullptr)
 117     {
 118         const double timeoutInSeconds = timeoutInMs != 0
 119                                       ? static_cast<double>(timeoutInMs) / 1000.0
 120                                       : 0.0;
 121
 122         puglUpdate(world, timeoutInSeconds);
 123     }
 124
 125     triggerIdleCallbacks();
 126 }
 127
 128 void Application::PrivateData::triggerIdleCallbacks()
 129 {
 130     for (std::list<IdleCallback*>::iterator it = idleCallbacks.begin(), ite = idleCallbacks.end(); it != ite; ++it)
 131     {
 132         IdleCallback* const idleCallback(*it);
 133         idleCallback->idleCallback();
 134     }
 135 }
 136
 137 void Application::PrivateData::quit()
 138 {
 139     if (! isThisTheMainThread(mainThreadHandle))
 140     {
 141         if (! isQuittingInNextCycle)
 142         {
 143             isQuittingInNextCycle = true;
 144             return;
 145         }
 146     }
 147
 148     isQuitting = true;
 149
 150 #ifndef DPF_TEST_APPLICATION_CPP
 151     for (WindowListReverseIterator rit = windows.rbegin(), rite = windows.rend(); rit != rite; ++rit)
 152     {
 153         DGL_NAMESPACE::Window* const window(*rit);
 154         window->close();
 155     }
 156 #endif
 157 }
 158
 159 double Application::PrivateData::getTime() const
 160 {
 161     DISTRHO_SAFE_ASSERT_RETURN(world != nullptr, 0.0);
 162
 163     return puglGetTime(world);
 164 }
 165
 166 void Application::PrivateData::setClassName(const char* const name)
 167 {
 168     DISTRHO_SAFE_ASSERT_RETURN(world != nullptr,);
 169     DISTRHO_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0',);
 170
 171     puglSetClassName(world, name);
 172 }
 173
 174 // --------------------------------------------------------------------------------------------------------------------
 175
 176 END_NAMESPACE_DGL