source/modules/dgl/src/Window.cpp

   1 /*
   2  * DISTRHO Plugin Framework (DPF)
   3  * Copyright (C) 2012-2022 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 "WindowPrivateData.hpp"
  18 #include "../TopLevelWidget.hpp"
  19
  20 #include "pugl.hpp"
  21
  22 START_NAMESPACE_DGL
  23
  24 // -----------------------------------------------------------------------
  25 // ScopedGraphicsContext
  26
  27 Window::ScopedGraphicsContext::ScopedGraphicsContext(Window& win)
  28     : window(win),
  29       ppData(nullptr),
  30       active(puglBackendEnter(window.pData->view)) {}
  31
  32 Window::ScopedGraphicsContext::ScopedGraphicsContext(Window& win, Window& transientWin)
  33     : window(win),
  34       ppData(transientWin.pData),
  35       active(false)
  36 {
  37     puglBackendLeave(ppData->view);
  38     active = puglBackendEnter(window.pData->view);
  39 }
  40
  41 Window::ScopedGraphicsContext::~ScopedGraphicsContext()
  42 {
  43     done();
  44 }
  45
  46 void Window::ScopedGraphicsContext::done()
  47 {
  48     if (active)
  49     {
  50         puglBackendLeave(window.pData->view);
  51         active = false;
  52     }
  53
  54     if (ppData != nullptr)
  55     {
  56         puglBackendEnter(ppData->view);
  57         ppData = nullptr;
  58     }
  59 }
  60
  61 // -----------------------------------------------------------------------
  62 // Window
  63
  64 Window::Window(Application& app)
  65     : pData(new PrivateData(app, this))
  66 {
  67     pData->initPost();
  68 }
  69
  70 Window::Window(Application& app, Window& transientParentWindow)
  71     : pData(new PrivateData(app, this, transientParentWindow.pData))
  72 {
  73     pData->initPost();
  74 }
  75
  76 Window::Window(Application& app,
  77                const uintptr_t parentWindowHandle,
  78                const double scaleFactor,
  79                const bool resizable)
  80     : pData(new PrivateData(app, this, parentWindowHandle, scaleFactor, resizable))
  81 {
  82     pData->initPost();
  83 }
  84
  85 Window::Window(Application& app,
  86                const uintptr_t parentWindowHandle,
  87                const uint width,
  88                const uint height,
  89                const double scaleFactor,
  90                const bool resizable)
  91     : pData(new PrivateData(app, this, parentWindowHandle, width, height, scaleFactor, resizable, false))
  92 {
  93     pData->initPost();
  94 }
  95
  96 Window::Window(Application& app,
  97                const uintptr_t parentWindowHandle,
  98                const uint width,
  99                const uint height,
 100                const double scaleFactor,
 101                const bool resizable,
 102                const bool isVST3,
 103                const bool doPostInit)
 104     : pData(new PrivateData(app, this, parentWindowHandle, width, height, scaleFactor, resizable, isVST3))
 105 {
 106     if (doPostInit)
 107         pData->initPost();
 108 }
 109
 110 Window::~Window()
 111 {
 112     delete pData;
 113 }
 114
 115 bool Window::isEmbed() const noexcept
 116 {
 117     return pData->isEmbed;
 118 }
 119
 120 bool Window::isVisible() const noexcept
 121 {
 122     return pData->isVisible;
 123 }
 124
 125 void Window::setVisible(const bool visible)
 126 {
 127     if (visible)
 128         pData->show();
 129     else
 130         pData->hide();
 131 }
 132
 133 void Window::show()
 134 {
 135     pData->show();
 136 }
 137
 138 void Window::hide()
 139 {
 140     pData->hide();
 141 }
 142
 143 void Window::close()
 144 {
 145     pData->close();
 146 }
 147
 148 bool Window::isResizable() const noexcept
 149 {
 150     return puglGetViewHint(pData->view, PUGL_RESIZABLE) == PUGL_TRUE;
 151 }
 152
 153 void Window::setResizable(const bool resizable)
 154 {
 155     pData->setResizable(resizable);
 156 }
 157
 158 int Window::getOffsetX() const noexcept
 159 {
 160     DISTRHO_SAFE_ASSERT_RETURN(pData->view != nullptr, 0);
 161
 162     return puglGetFrame(pData->view).x;
 163 }
 164
 165 int Window::getOffsetY() const noexcept
 166 {
 167     DISTRHO_SAFE_ASSERT_RETURN(pData->view != nullptr, 0);
 168
 169     return puglGetFrame(pData->view).y;
 170 }
 171
 172 Point<int> Window::getOffset() const noexcept
 173 {
 174     DISTRHO_SAFE_ASSERT_RETURN(pData->view != nullptr, Point<int>());
 175
 176     const PuglRect rect = puglGetFrame(pData->view);
 177     return Point<int>(rect.x, rect.y);
 178 }
 179
 180 void Window::setOffsetX(const int x)
 181 {
 182     setOffset(x, getOffsetY());
 183 }
 184
 185 void Window::setOffsetY(const int y)
 186 {
 187     setOffset(getOffsetX(), y);
 188 }
 189
 190 void Window::setOffset(const int x, const int y)
 191 {
 192     puglSetPosition(pData->view, x, y);
 193 }
 194
 195 void Window::setOffset(const Point<int>& offset)
 196 {
 197     setOffset(offset.getX(), offset.getY());
 198 }
 199
 200 uint Window::getWidth() const noexcept
 201 {
 202     DISTRHO_SAFE_ASSERT_RETURN(pData->view != nullptr, 0);
 203
 204     const double width = puglGetFrame(pData->view).width;
 205     DISTRHO_SAFE_ASSERT_RETURN(width >= 0.0, 0);
 206     return static_cast<uint>(width + 0.5);
 207 }
 208
 209 uint Window::getHeight() const noexcept
 210 {
 211     DISTRHO_SAFE_ASSERT_RETURN(pData->view != nullptr, 0);
 212
 213     const double height = puglGetFrame(pData->view).height;
 214     DISTRHO_SAFE_ASSERT_RETURN(height >= 0.0, 0);
 215     return static_cast<uint>(height + 0.5);
 216 }
 217
 218 Size<uint> Window::getSize() const noexcept
 219 {
 220     DISTRHO_SAFE_ASSERT_RETURN(pData->view != nullptr, Size<uint>());
 221
 222     const PuglRect rect = puglGetFrame(pData->view);
 223     DISTRHO_SAFE_ASSERT_RETURN(rect.width >= 0.0, Size<uint>());
 224     DISTRHO_SAFE_ASSERT_RETURN(rect.height >= 0.0, Size<uint>());
 225     return Size<uint>(static_cast<uint>(rect.width + 0.5),
 226                       static_cast<uint>(rect.height + 0.5));
 227 }
 228
 229 void Window::setWidth(const uint width)
 230 {
 231     setSize(width, getHeight());
 232 }
 233
 234 void Window::setHeight(const uint height)
 235 {
 236     setSize(getWidth(), height);
 237 }
 238
 239 void Window::setSize(uint width, uint height)
 240 {
 241     DISTRHO_SAFE_ASSERT_UINT2_RETURN(width > 1 && height > 1, width, height,);
 242
 243     if (pData->isEmbed)
 244     {
 245         const double scaleFactor = pData->scaleFactor;
 246         uint minWidth = pData->minWidth;
 247         uint minHeight = pData->minHeight;
 248
 249         if (pData->autoScaling && scaleFactor != 1.0)
 250         {
 251             minWidth *= scaleFactor;
 252             minHeight *= scaleFactor;
 253         }
 254
 255         // handle geometry constraints here
 256         if (width < minWidth)
 257             width = minWidth;
 258
 259         if (height < minHeight)
 260             height = minHeight;
 261
 262         if (pData->keepAspectRatio)
 263         {
 264             const double ratio = static_cast<double>(pData->minWidth)
 265                                / static_cast<double>(pData->minHeight);
 266             const double reqRatio = static_cast<double>(width)
 267                                   / static_cast<double>(height);
 268
 269             if (d_isNotEqual(ratio, reqRatio))
 270             {
 271                 // fix width
 272                 if (reqRatio > ratio)
 273                     width = static_cast<uint>(height * ratio + 0.5);
 274                 // fix height
 275                 else
 276                     height = static_cast<uint>(static_cast<double>(width) / ratio + 0.5);
 277             }
 278         }
 279     }
 280
 281     if (pData->usesSizeRequest)
 282     {
 283         DISTRHO_SAFE_ASSERT_RETURN(pData->topLevelWidgets.size() != 0,);
 284
 285         TopLevelWidget* const topLevelWidget = pData->topLevelWidgets.front();
 286         DISTRHO_SAFE_ASSERT_RETURN(topLevelWidget != nullptr,);
 287
 288         topLevelWidget->requestSizeChange(width, height);
 289     }
 290     else
 291     {
 292         puglSetSizeAndDefault(pData->view, width, height);
 293     }
 294 }
 295
 296 void Window::setSize(const Size<uint>& size)
 297 {
 298     setSize(size.getWidth(), size.getHeight());
 299 }
 300
 301 const char* Window::getTitle() const noexcept
 302 {
 303     return puglGetWindowTitle(pData->view);
 304 }
 305
 306 void Window::setTitle(const char* const title)
 307 {
 308     if (pData->view != nullptr)
 309         puglSetWindowTitle(pData->view, title);
 310 }
 311
 312 bool Window::isIgnoringKeyRepeat() const noexcept
 313 {
 314     return puglGetViewHint(pData->view, PUGL_IGNORE_KEY_REPEAT) == PUGL_TRUE;
 315 }
 316
 317 void Window::setIgnoringKeyRepeat(const bool ignore) noexcept
 318 {
 319     puglSetViewHint(pData->view, PUGL_IGNORE_KEY_REPEAT, ignore);
 320 }
 321
 322 const void* Window::getClipboard(size_t& dataSize)
 323 {
 324     return pData->getClipboard(dataSize);
 325 }
 326
 327 bool Window::setClipboard(const char* const mimeType, const void* const data, const size_t dataSize)
 328 {
 329     return puglSetClipboard(pData->view, mimeType != nullptr ? mimeType : "text/plain", data, dataSize) == PUGL_SUCCESS;
 330 }
 331
 332 bool Window::setCursor(const MouseCursor cursor)
 333 {
 334     return puglSetCursor(pData->view, static_cast<PuglCursor>(cursor)) == PUGL_SUCCESS;
 335 }
 336
 337 bool Window::addIdleCallback(IdleCallback* const callback, const uint timerFrequencyInMs)
 338 {
 339     DISTRHO_SAFE_ASSERT_RETURN(callback != nullptr, false)
 340
 341     return pData->addIdleCallback(callback, timerFrequencyInMs);
 342 }
 343
 344 bool Window::removeIdleCallback(IdleCallback* const callback)
 345 {
 346     DISTRHO_SAFE_ASSERT_RETURN(callback != nullptr, false)
 347
 348     return pData->removeIdleCallback(callback);
 349 }
 350
 351 Application& Window::getApp() const noexcept
 352 {
 353     return pData->app;
 354 }
 355
 356 #ifndef DPF_TEST_WINDOW_CPP
 357 const GraphicsContext& Window::getGraphicsContext() const noexcept
 358 {
 359     return pData->getGraphicsContext();
 360 }
 361 #endif
 362
 363 uintptr_t Window::getNativeWindowHandle() const noexcept
 364 {
 365     return puglGetNativeView(pData->view);
 366 }
 367
 368 double Window::getScaleFactor() const noexcept
 369 {
 370     return pData->scaleFactor;
 371 }
 372
 373 void Window::focus()
 374 {
 375     pData->focus();
 376 }
 377
 378 #ifndef DGL_FILE_BROWSER_DISABLED
 379 bool Window::openFileBrowser(const FileBrowserOptions& options)
 380 {
 381     return pData->openFileBrowser(options);
 382 }
 383 #endif
 384
 385 void Window::repaint() noexcept
 386 {
 387     if (pData->view == nullptr)
 388         return;
 389
 390     puglPostRedisplay(pData->view);
 391 }
 392
 393 void Window::repaint(const Rectangle<uint>& rect) noexcept
 394 {
 395     if (pData->view == nullptr)
 396         return;
 397
 398     PuglRect prect = {
 399         static_cast<PuglCoord>(rect.getX()),
 400         static_cast<PuglCoord>(rect.getY()),
 401         static_cast<PuglSpan>(rect.getWidth()),
 402         static_cast<PuglSpan>(rect.getHeight()),
 403     };
 404     if (pData->autoScaling)
 405     {
 406         const double autoScaleFactor = pData->autoScaleFactor;
 407
 408         prect.x *= autoScaleFactor;
 409         prect.y *= autoScaleFactor;
 410         prect.width *= autoScaleFactor;
 411         prect.height *= autoScaleFactor;
 412     }
 413     puglPostRedisplayRect(pData->view, prect);
 414 }
 415
 416 void Window::renderToPicture(const char* const filename)
 417 {
 418     pData->filenameToRenderInto = strdup(filename);
 419 }
 420
 421 void Window::runAsModal(bool blockWait)
 422 {
 423     pData->runAsModal(blockWait);
 424 }
 425
 426 Size<uint> Window::getGeometryConstraints(bool& keepAspectRatio)
 427 {
 428     keepAspectRatio = pData->keepAspectRatio;
 429     return Size<uint>(pData->minWidth, pData->minHeight);
 430 }
 431
 432 void Window::setGeometryConstraints(uint minimumWidth,
 433                                     uint minimumHeight,
 434                                     const bool keepAspectRatio,
 435                                     const bool automaticallyScale,
 436                                     const bool resizeNowIfAutoScaling)
 437 {
 438     DISTRHO_SAFE_ASSERT_RETURN(minimumWidth > 0,);
 439     DISTRHO_SAFE_ASSERT_RETURN(minimumHeight > 0,);
 440
 441     pData->minWidth = minimumWidth;
 442     pData->minHeight = minimumHeight;
 443     pData->autoScaling = automaticallyScale;
 444     pData->keepAspectRatio = keepAspectRatio;
 445
 446     if (pData->view == nullptr)
 447         return;
 448
 449     const double scaleFactor = pData->scaleFactor;
 450
 451     if (automaticallyScale && scaleFactor != 1.0)
 452     {
 453         minimumWidth *= scaleFactor;
 454         minimumHeight *= scaleFactor;
 455     }
 456
 457     puglSetGeometryConstraints(pData->view, minimumWidth, minimumHeight, keepAspectRatio);
 458
 459     if (scaleFactor != 1.0 && automaticallyScale && resizeNowIfAutoScaling)
 460     {
 461         const Size<uint> size(getSize());
 462
 463         setSize(static_cast<uint>(size.getWidth() * scaleFactor + 0.5),
 464                 static_cast<uint>(size.getHeight() * scaleFactor + 0.5));
 465     }
 466 }
 467
 468 void Window::setTransientParent(const uintptr_t transientParentWindowHandle)
 469 {
 470     puglSetTransientParent(pData->view, transientParentWindowHandle);
 471 }
 472
 473 std::vector<ClipboardDataOffer> Window::getClipboardDataOfferTypes()
 474 {
 475     std::vector<ClipboardDataOffer> offerTypes;
 476
 477     if (const uint32_t numTypes = puglGetNumClipboardTypes(pData->view))
 478     {
 479         offerTypes.reserve(numTypes);
 480
 481         for (uint32_t i=0; i<numTypes; ++i)
 482         {
 483             const ClipboardDataOffer offer = { i + 1, puglGetClipboardType(pData->view, i) };
 484             offerTypes.push_back(offer);
 485         }
 486     }
 487
 488     return offerTypes;
 489 }
 490
 491 uint32_t Window::onClipboardDataOffer()
 492 {
 493     std::vector<ClipboardDataOffer> offers(getClipboardDataOfferTypes());
 494
 495     for (std::vector<ClipboardDataOffer>::iterator it=offers.begin(), end=offers.end(); it != end;++it)
 496     {
 497         const ClipboardDataOffer offer = *it;
 498         if (std::strcmp(offer.type, "text/plain") == 0)
 499             return offer.id;
 500     }
 501
 502     return 0;
 503 }
 504
 505 bool Window::onClose()
 506 {
 507     return true;
 508 }
 509
 510 void Window::onFocus(bool, CrossingMode)
 511 {
 512 }
 513
 514 void Window::onReshape(uint, uint)
 515 {
 516     puglFallbackOnResize(pData->view);
 517 }
 518
 519 void Window::onScaleFactorChanged(double)
 520 {
 521 }
 522
 523 #ifndef DGL_FILE_BROWSER_DISABLED
 524 void Window::onFileSelected(const char*)
 525 {
 526 }
 527 #endif
 528
 529 // -----------------------------------------------------------------------
 530
 531 END_NAMESPACE_DGL