--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DPF-Prymula-audioplugins/dpf/dgl/src/pugl-extra/haiku.cpp	Mon Oct 16 21:53:34 2023 +0200
@@ -0,0 +1,402 @@
+// Copyright 2012-2022 David Robillard <d@drobilla.net>
+// Copyright 2021-2022 Filipe Coelho <falktx@falktx.com>
+// SPDX-License-Identifier: ISC
+
+#include "haiku.h"
+
+#include "../pugl-upstream/src/internal.h"
+
+class PuglHaikuView : public BView
+{
+    PuglView* const view;
+
+public:
+    PuglHaikuView(PuglView* const v)
+        : BView(NULL, B_FULL_UPDATE_ON_RESIZE|B_FRAME_EVENTS|B_NAVIGABLE|B_INPUT_METHOD_AWARE),
+          view(v) {}
+
+protected:
+    void GetPreferredSize(float* width, float* height) override
+    {
+        d_stdout("%s %i", __func__, __LINE__);
+        if (width != nullptr)
+            *width = view->frame.width;
+        if (height != nullptr)
+            *height = view->frame.height;
+        d_stdout("%s %i", __func__, __LINE__);
+    }
+};
+
+class PuglHaikuWindow : public BWindow
+{
+    PuglView* const view;
+
+public:
+    PuglHaikuWindow(PuglView* const v)
+        : BWindow(BRect(1.0f), "DPF-Window", B_TITLED_WINDOW, 0x0),
+          view(v) {}
+
+// protected:
+//     bool QuitRequested() override
+//     {
+//         d_stdout("%s %i", __func__, __LINE__);
+//         if (puglView->closeFunc) {
+//             puglView->closeFunc(puglView);
+//             puglView->redisplay = false;
+//         }
+//         needsQuit = false;
+//         d_stdout("%s %i", __func__, __LINE__);
+//         return true;
+//     }
+};
+
+BApplication* s_app = NULL;
+
+PuglWorldInternals*
+puglInitWorldInternals(const PuglWorldType type, const PuglWorldFlags flags)
+{
+  if (!s_app) {
+    status_t status;
+    s_app = new BApplication("application/x-vnd.pugl-application", &status);
+    
+    if (status != B_OK) {
+      delete s_app;
+      return NULL;
+    }
+  }
+
+  PuglWorldInternals* impl =
+    (PuglWorldInternals*)calloc(1, sizeof(PuglWorldInternals));
+
+  impl->app = s_app;
+  return impl;
+}
+
+void*
+puglGetNativeWorld(PuglWorld* const world)
+{
+  return world->impl->app;
+}
+
+PuglInternals*
+puglInitViewInternals(PuglWorld* const world)
+{
+  PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals));
+
+  return impl;
+}
+
+PuglStatus
+puglRealize(PuglView* const view)
+{
+  PuglInternals* const impl    = view->impl;
+  PuglStatus           st      = PUGL_SUCCESS;
+
+  // Ensure that we're unrealized and that a reasonable backend has been set
+  if (impl->view) {
+    return PUGL_FAILURE;
+  }
+  if (!view->backend || !view->backend->configure) {
+    return PUGL_BAD_BACKEND;
+  }
+
+  // Set the size to the default if it has not already been set
+  if (view->frame.width <= 0.0 || view->frame.height <= 0.0) {
+    const PuglViewSize defaultSize = view->sizeHints[PUGL_DEFAULT_SIZE];
+    if (!defaultSize.width || !defaultSize.height) {
+      return PUGL_BAD_CONFIGURATION;
+    }
+
+    view->frame.width  = defaultSize.width;
+    view->frame.height = defaultSize.height;
+  }
+
+  // Center top-level windows if a position has not been set
+  if (!view->parent && !view->frame.x && !view->frame.y) {
+    // TODO
+  }
+
+  if (!view->parent) {
+    impl->window = new PuglHaikuWindow(view);
+    impl->window->Lock();
+  }
+
+  impl->view = new PuglHaikuView(view);
+
+  if (view->parent) {
+    BView* const pview = (BView*)view->parent;
+    pview->AddChild(impl->view);
+  } else {
+    impl->window->AddChild(impl->view);
+  }
+
+  // Configure and create the backend
+  if ((st = view->backend->configure(view)) || (st = view->backend->create(view))) {
+    view->backend->destroy(view);
+    return st;
+  }
+
+  if (view->title) {
+    puglSetWindowTitle(view, view->title);
+  }
+
+  if (view->transientParent) {
+    puglSetTransientParent(view, view->transientParent);
+  }
+
+  puglDispatchSimpleEvent(view, PUGL_CREATE);
+
+  if (impl->window) {
+    impl->window->Unlock();
+  }
+
+  return PUGL_SUCCESS;
+}
+
+PuglStatus
+puglShow(PuglView* const view)
+{
+  PuglInternals* const impl = view->impl;
+  if (impl->window) {
+    impl->window->Show();
+  } else {
+    impl->view->Show();
+  }
+  return PUGL_SUCCESS;
+}
+
+PuglStatus
+puglHide(PuglView* const view)
+{
+  PuglInternals* const impl = view->impl;
+  if (impl->window) {
+    impl->window->Hide();
+  } else {
+    impl->view->Hide();
+  }
+  return PUGL_SUCCESS;
+}
+
+void
+puglFreeViewInternals(PuglView* const view)
+{
+  if (view && view->impl) {
+    PuglInternals* const impl = view->impl;
+    if (view->backend) {
+      view->backend->destroy(view);
+    }
+    if (impl->view) {
+      if (impl->window) {
+        impl->window->RemoveChild(impl->view);
+      }
+      delete impl->view;
+      delete impl->window;
+    }
+    free(impl);
+  }
+}
+
+void
+puglFreeWorldInternals(PuglWorld* const world)
+{
+//   if (world->impl->app != nullptr && world->impl->app->CountWindows() == 0) {
+//     delete world->impl->app;
+//     s_app = NULL;
+//   }
+  free(world->impl);
+}
+
+PuglStatus
+puglGrabFocus(PuglView*)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+double
+puglGetScaleFactor(const PuglView* const view)
+{
+  return 1.0;
+}
+
+double
+puglGetTime(const PuglWorld* const world)
+{
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return ((double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0) -
+         world->startTime;
+}
+
+PuglStatus
+puglUpdate(PuglWorld* const world, const double timeout)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+PuglStatus
+puglPostRedisplay(PuglView* const view)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+PuglStatus
+puglPostRedisplayRect(PuglView* const view, const PuglRect rect)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+PuglNativeView
+puglGetNativeView(PuglView* const view)
+{
+  return 0;
+}
+
+PuglStatus
+puglSetWindowTitle(PuglView* const view, const char* const title)
+{
+  puglSetString(&view->title, title);
+  return PUGL_UNSUPPORTED;
+}
+
+PuglStatus
+puglSetSizeHint(PuglView* const    view,
+                const PuglSizeHint hint,
+                const PuglSpan     width,
+                const PuglSpan     height)
+{
+  view->sizeHints[hint].width  = width;
+  view->sizeHints[hint].height = height;
+  return PUGL_SUCCESS;
+}
+
+PuglStatus
+puglStartTimer(PuglView* const view, const uintptr_t id, const double timeout)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+PuglStatus
+puglStopTimer(PuglView* const view, const uintptr_t id)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+PuglStatus
+puglPaste(PuglView* const view)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+PuglStatus
+puglAcceptOffer(PuglView* const                 view,
+                const PuglDataOfferEvent* const offer,
+                const uint32_t                  typeIndex)
+{
+  return PUGL_UNSUPPORTED;
+}
+
+uint32_t
+puglGetNumClipboardTypes(const PuglView* const view)
+{
+  return 0u;
+}
+
+const char*
+puglGetClipboardType(const PuglView* const view, const uint32_t typeIndex)
+{
+  return NULL;
+}
+
+const void*
+puglGetClipboard(PuglView* const view,
+                 const uint32_t  typeIndex,
+                 size_t* const   len)
+{
+  return NULL;
+}
+
+PuglStatus
+puglSetClipboard(PuglView* const   view,
+                 const char* const type,
+                 const void* const data,
+                 const size_t      len)
+{
+  return PUGL_FAILURE;
+}
+
+PuglStatus
+puglSetCursor(PuglView* const view, const PuglCursor cursor)
+{
+  return PUGL_FAILURE;
+}
+
+PuglStatus
+puglSetTransientParent(PuglView* const view, const PuglNativeView parent)
+{
+  return PUGL_FAILURE;
+}
+
+PuglStatus
+puglSetPosition(PuglView* const view, const int x, const int y)
+{
+  return PUGL_FAILURE;
+}
+
+#if 0
+PuglStatus
+puglGrabFocus(PuglView* view)
+{
+    view->impl->bView->MakeFocus(true);
+    return PUGL_SUCCESS;
+}
+
+// extras follow
+
+void
+puglRaiseWindow(PuglView* view)
+{
+}
+
+void
+puglSetWindowSize(PuglView* view, unsigned int width, unsigned int height)
+{
+    bView->ResizeTo(width, height);
+
+    if (bWindow != nullptr && bWindow->LockLooper())
+    {
+        bWindow->MoveTo(50, 50);
+        bWindow->ResizeTo(width, height);
+
+        if (! forced)
+            bWindow->Flush();
+
+        bWindow->UnlockLooper();
+    }
+    // TODO resizable
+}
+
+void setVisible(const bool yesNo)
+{
+    if (bWindow != nullptr)
+    {
+        if (bWindow->LockLooper())
+        {
+            if (yesNo)
+                bWindow->Show();
+            else
+                bWindow->Hide();
+
+            // TODO use flush?
+            bWindow->Sync();
+            bWindow->UnlockLooper();
+        }
+    }
+    else
+    {
+        if (yesNo)
+            bView->Show();
+        else
+            bView->Hide();
+    }
+}
+#endif