DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
Browse Source

Add new file, delete old one 

Signed-off-by: falkTX <falktx@falktx.com>
pull/457/head
falkTX 1 year ago
parent
3a3885e2bc
commit
fffc4a3d66
Signed by: falkTX <falktx@falktx.com> GPG Key ID: CDBAA37ABC74FBA0
2 changed files with 193 additions and 503 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +193
    -0
      dgl/src/Stub.cpp
  2. +0
    -503
      examples/EmbedExternalUI/NativeWindow.hpp

+ 193
- 0
dgl/src/Stub.cpp View File

@@ -0,0 +1,193 @@
/*
* DISTRHO Plugin Framework (DPF)
* Copyright (C) 2012-2024 Filipe Coelho <falktx@falktx.com>
*
* Permission to use, copy, modify, and/or distribute this software for any purpose with
* or without fee is hereby granted, provided that the above copyright notice and this
* permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
* TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include "Color.hpp"
#include "SubWidgetPrivateData.hpp"
#include "TopLevelWidgetPrivateData.hpp"
#include "WidgetPrivateData.hpp"
#include "WindowPrivateData.hpp"

START_NAMESPACE_DGL

// --------------------------------------------------------------------------------------------------------------------

static void notImplemented(const char* const name)
{
d_stderr2("stub function not implemented: %s", name);
}

// --------------------------------------------------------------------------------------------------------------------
// Color

void Color::setFor(const GraphicsContext&, bool)
{
notImplemented("Color::setFor");
}

// --------------------------------------------------------------------------------------------------------------------
// Line

template<typename T>
void Line<T>::draw(const GraphicsContext& context, T)
{
notImplemented("Line::draw");
}

template<typename T>
void Line<T>::draw()
{
notImplemented("Line::draw");
}

template class Line<double>;
template class Line<float>;
template class Line<int>;
template class Line<uint>;
template class Line<short>;
template class Line<ushort>;

// --------------------------------------------------------------------------------------------------------------------
// Circle

template<typename T>
void Circle<T>::draw(const GraphicsContext&)
{
notImplemented("Circle::draw");
}

template<typename T>
void Circle<T>::drawOutline(const GraphicsContext&, T)
{
notImplemented("Circle::drawOutline");
}

template<typename T>
void Circle<T>::draw()
{
notImplemented("Circle::draw");
}

template<typename T>
void Circle<T>::drawOutline()
{
notImplemented("Circle::drawOutline");
}

template class Circle<double>;
template class Circle<float>;
template class Circle<int>;
template class Circle<uint>;
template class Circle<short>;
template class Circle<ushort>;

// --------------------------------------------------------------------------------------------------------------------
// Triangle

template<typename T>
void Triangle<T>::draw(const GraphicsContext&)
{
notImplemented("Triangle::draw");
}

template<typename T>
void Triangle<T>::drawOutline(const GraphicsContext&, T)
{
notImplemented("Triangle::drawOutline");
}

template<typename T>
void Triangle<T>::draw()
{
notImplemented("Triangle::draw");
}

template<typename T>
void Triangle<T>::drawOutline()
{
notImplemented("Triangle::drawOutline");
}

template class Triangle<double>;
template class Triangle<float>;
template class Triangle<int>;
template class Triangle<uint>;
template class Triangle<short>;
template class Triangle<ushort>;

// --------------------------------------------------------------------------------------------------------------------
// Rectangle

template<typename T>
void Rectangle<T>::draw(const GraphicsContext&)
{
notImplemented("Rectangle::draw");
}

template<typename T>
void Rectangle<T>::drawOutline(const GraphicsContext&, T)
{
notImplemented("Rectangle::drawOutline");
}

template<typename T>
void Rectangle<T>::draw()
{
notImplemented("Rectangle::draw");
}

template<typename T>
void Rectangle<T>::drawOutline()
{
notImplemented("Rectangle::drawOutline");
}

template class Rectangle<double>;
template class Rectangle<float>;
template class Rectangle<int>;
template class Rectangle<uint>;
template class Rectangle<short>;
template class Rectangle<ushort>;

// --------------------------------------------------------------------------------------------------------------------

void SubWidget::PrivateData::display(uint, uint, double)
{
}

// --------------------------------------------------------------------------------------------------------------------

void TopLevelWidget::PrivateData::display()
{
}

// --------------------------------------------------------------------------------------------------------------------

void Window::PrivateData::renderToPicture(const char*, const GraphicsContext&, uint, uint)
{
notImplemented("Window::PrivateData::renderToPicture");
}

// --------------------------------------------------------------------------------------------------------------------

const GraphicsContext& Window::PrivateData::getGraphicsContext() const noexcept
{
GraphicsContext& context((GraphicsContext&)graphicsContext);
return context;
}

// --------------------------------------------------------------------------------------------------------------------

END_NAMESPACE_DGL

+ 0
- 503
examples/EmbedExternalUI/NativeWindow.hpp View File

@@ -1,503 +0,0 @@
/*
* DISTRHO Plugin Framework (DPF)
* Copyright (C) 2012-2024 Filipe Coelho <falktx@falktx.com>
*
* Permission to use, copy, modify, and/or distribute this software for any purpose with
* or without fee is hereby granted, provided that the above copyright notice and this
* permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
* TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include "DistrhoUI.hpp"

#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
# import <Cocoa/Cocoa.h>
#elif defined(DISTRHO_OS_WINDOWS)
# define WIN32_CLASS_NAME "DPF-EmbedExternalExampleUI"
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
#else
# include <sys/types.h>
# include <X11/Xatom.h>
# include <X11/Xlib.h>
# include <X11/Xutil.h>
# define X11Key_Escape 9
#endif

#if defined(DISTRHO_OS_MAC)
# ifndef __MAC_10_12
# define NSEventMaskAny NSAnyEventMask
# define NSWindowStyleMaskClosable NSClosableWindowMask
# define NSWindowStyleMaskMiniaturizable NSMiniaturizableWindowMask
# define NSWindowStyleMaskResizable NSResizableWindowMask
# define NSWindowStyleMaskTitled NSTitledWindowMask
# endif
@interface NSExternalWindow : NSWindow
@end
@implementation NSExternalWindow {
@public
bool closed;
bool standalone;
}
- (BOOL)canBecomeKeyWindow { return YES; }
- (BOOL)canBecomeMainWindow { return standalone ? YES : NO; }
- (BOOL)windowShouldClose:(id)_ { closed = true; return YES; }
@end
#endif

START_NAMESPACE_DISTRHO

// --------------------------------------------------------------------------------------------------------------------

struct NativeWindow {
struct Callbacks {
virtual ~Callbacks() {}
virtual void nativeHide() = 0;
virtual void nativeResize(uint width, uint height) = 0;
};

Callbacks* const fCallbacks;
const bool fIsStandalone;
const bool fIsEmbed;
bool fIsVisible;

#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
NSView* fView;
NSExternalWindow* fWindow;
#elif defined(DISTRHO_OS_WINDOWS)
::HWND fWindow;
#else
::Display* fDisplay;
::Window fWindow;
#endif

NativeWindow(Callbacks* callbacks,
const char* title,
uintptr_t parentWindowHandle,
uint width,
uint height,
bool isStandalone);
~NativeWindow();
void idle();
void focus();
void setSize(uint width, uint height);
void setTitle(const char* title);
void setTransientParentWindow(uintptr_t winId);
void setVisible(bool visible);

void hide()
{
fCallbacks->nativeHide();
}

uintptr_t getNativeWindowHandle() const noexcept
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
return (uintptr_t)fView;
#elif defined(DISTRHO_OS_WINDOWS)
return (uintptr_t)fWindow;
#else
return (uintptr_t)fWindow;
#endif
}
};

// --------------------------------------------------------------------------------------------------------------------

NativeWindow::NativeWindow(Callbacks* const callbacks,
const char* const title,
const uintptr_t parentWindowHandle,
const uint width,
const uint height,
const bool isStandalone)
: fCallbacks(callbacks),
fIsStandalone(isStandalone),
fIsEmbed(parentWindowHandle != 0),
fIsVisible(parentWindowHandle != 0),
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
fView(nullptr),
fWindow(nullptr)
#elif defined(DISTRHO_OS_WINDOWS)
fWindow(nullptr)
#else
fDisplay(nullptr),
fWindow(0)
#endif
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
NSAutoreleasePool* const pool = [[NSAutoreleasePool alloc] init];
[NSApplication sharedApplication];

if (standalone)
{
[NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
[NSApp activateIgnoringOtherApps:YES];
}

fView = [NSView new];
DISTRHO_SAFE_ASSERT_RETURN(fView != nullptr,);

[fView setFrame:NSMakeRect(0, 0, width, height)];
[fView setAutoresizesSubviews:YES];
[fView setWantsLayer:YES];
[[fView layer] setBackgroundColor:[[NSColor blueColor] CGColor]];

if (fIsEmbed)
{
[fView retain];
[(NSView*)parentWindowHandle addSubview:fView];
}
else
{
const ulong styleMask = NSWindowStyleMaskClosable
| NSWindowStyleMaskMiniaturizable
| NSWindowStyleMaskResizable
| NSWindowStyleMaskTitled;

fWindow = [[[NSExternalWindow alloc]
initWithContentRect:[fView frame]
styleMask:styleMask
backing:NSBackingStoreBuffered
defer:NO] retain];
DISTRHO_SAFE_ASSERT_RETURN(fWindow != nullptr,);

fWindow->closed = false; // is this needed?
fWindow->standalone = standalone;
[fWindow setIsVisible:NO];

if (NSString* const nsTitle = [[NSString alloc]
initWithBytes:title
length:std::strlen(title)
encoding:NSUTF8StringEncoding])
{
[fWindow setTitle:nsTitle];
[nsTitle release];
}

[fWindow setContentView:fView];
[fWindow setContentSize:NSMakeSize(width, height)];
[fWindow makeFirstResponder:fView];
}

[pool release];
#elif defined(DISTRHO_OS_WINDOWS)
WNDCLASS windowClass = {};
windowClass.style = CS_OWNDC;
windowClass.lpfnWndProc = DefWindowProc;
windowClass.hInstance = nullptr;
windowClass.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
windowClass.hCursor = LoadCursor(nullptr, IDC_ARROW);
windowClass.lpszClassName = WIN32_CLASS_NAME;
DISTRHO_SAFE_ASSERT_RETURN(RegisterClass(&windowClass),);

const int winFlags = fIsEmbed
? WS_CHILD | WS_VISIBLE
: WS_POPUPWINDOW | WS_CAPTION | WS_SIZEBOX;

RECT rect = { 0, 0, static_cast<LONG>(width), static_cast<LONG>(height) };
AdjustWindowRectEx(&rect, winFlags, FALSE, WS_EX_TOPMOST);

fWindow = CreateWindowEx(WS_EX_TOPMOST,
WIN32_CLASS_NAME,
title,
winFlags,
CW_USEDEFAULT, CW_USEDEFAULT,
rect.right - rect.left,
rect.bottom - rect.top,
(HWND)parentWindowHandle,
nullptr, nullptr, nullptr);
DISTRHO_SAFE_ASSERT_RETURN(fWindow != nullptr,);

SetWindowLongPtr(fWindow, GWLP_USERDATA, (LONG_PTR)this);
#else
fDisplay = XOpenDisplay(nullptr);
DISTRHO_SAFE_ASSERT_RETURN(fDisplay != nullptr,);

const ::Window parent = fIsEmbed
? (::Window)parentWindowHandle
: RootWindow(fDisplay, DefaultScreen(fDisplay));

fWindow = XCreateSimpleWindow(fDisplay, parent, 0, 0, width, height, 0, 0, 0);
DISTRHO_SAFE_ASSERT_RETURN(fWindow != 0,);

XSizeHints sizeHints = {};
sizeHints.flags = PMinSize;
sizeHints.min_width = width;
sizeHints.min_height = height;
XSetNormalHints(fDisplay, fWindow, &sizeHints);
XStoreName(fDisplay, fWindow, title);

if (fIsEmbed)
{
// start with window mapped, so host can access it
XMapWindow(fDisplay, fWindow);
}
else
{
// grab Esc key for auto-close
XGrabKey(fDisplay, X11Key_Escape, AnyModifier, fWindow, 1, GrabModeAsync, GrabModeAsync);

// destroy window on close
Atom wmDelete = XInternAtom(fDisplay, "WM_DELETE_WINDOW", True);
XSetWMProtocols(fDisplay, fWindow, &wmDelete, 1);

// set pid WM hint
const pid_t pid = getpid();
const Atom _nwp = XInternAtom(fDisplay, "_NET_WM_PID", False);
XChangeProperty(fDisplay, fWindow, _nwp, XA_CARDINAL, 32, PropModeReplace, (const uchar*)&pid, 1);

// set the window to both dialog and normal to produce a decorated floating dialog
// order is important: DIALOG needs to come before NORMAL
const Atom _wt = XInternAtom(fDisplay, "_NET_WM_WINDOW_TYPE", False);
const Atom _wts[2] = {
XInternAtom(fDisplay, "_NET_WM_WINDOW_TYPE_DIALOG", False),
XInternAtom(fDisplay, "_NET_WM_WINDOW_TYPE_NORMAL", False)
};
XChangeProperty(fDisplay, fWindow, _wt, XA_ATOM, 32, PropModeReplace, (const uchar*)&_wts, 2);
}
#endif
}

NativeWindow::~NativeWindow()
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
if (fView != nullptr)
{
if (fWindow != nil)
[fWindow close];

[fView release];

if (fWindow != nil)
[fWindow release];
}
#elif defined(DISTRHO_OS_WINDOWS)
if (fWindow != nullptr)
DestroyWindow(fWindow);

UnregisterClass(WIN32_CLASS_NAME, nullptr);
#else
if (fDisplay != nullptr)
{
if (fWindow != 0)
XDestroyWindow(fDisplay, fWindow);

XCloseDisplay(fDisplay);
}
#endif
}

void NativeWindow::idle()
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
if (fIsStandalone)
{
NSAutoreleasePool* const pool = [[NSAutoreleasePool alloc] init];
NSDate* const date = [NSDate distantPast];

for (NSEvent* event;;)
{
event = [NSApp
nextEventMatchingMask:NSEventMaskAny
untilDate:date
inMode:NSDefaultRunLoopMode
dequeue:YES];

if (event == nil)
break;

[NSApp sendEvent:event];
}

if (fWindow->closed)
{
fWindow->closed = false;
close();
}

[pool release];
}
#elif defined(DISTRHO_OS_WINDOWS)
if (fIsStandalone && fWindow != nullptr)
{
MSG msg;
if (::GetMessage(&msg, nullptr, 0, 0) > 0)
{
d_stdout("msg %u %u", msg.message, WM_SIZING);

switch (msg.message)
{
case WM_SYSCOMMAND:
if (msg.wParam != SC_CLOSE)
break;
// fall-through
case WM_QUIT:
hide();
return;
case WM_SIZING:
break;
}

TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
#else
if (fDisplay != nullptr)
{
for (XEvent event; XPending(fDisplay) > 0;)
{
XNextEvent(fDisplay, &event);

if (! fIsVisible)
continue;

switch (event.type)
{
case ClientMessage:
if (char* const type = XGetAtomName(fDisplay, event.xclient.message_type))
{
if (std::strcmp(type, "WM_PROTOCOLS") == 0)
hide();
}
break;

case KeyRelease:
if (event.xkey.keycode == X11Key_Escape)
hide();
break;
}
}
}
#endif
}

void NativeWindow::focus()
{
d_stdout("focus");
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
DISTRHO_SAFE_ASSERT_RETURN(fWindow != nullptr,);

[fWindow orderFrontRegardless];
[fWindow makeKeyWindow];
[fWindow makeFirstResponder:fView];
#elif defined(DISTRHO_OS_WINDOWS)
DISTRHO_SAFE_ASSERT_RETURN(fWindow != nullptr,);

SetForegroundWindow(fWindow);
SetActiveWindow(fWindow);
SetFocus(fWindow);
#else
DISTRHO_SAFE_ASSERT_RETURN(fWindow != 0,);

XRaiseWindow(fDisplay, fWindow);
#endif
}

void NativeWindow::setSize(uint width, uint height)
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
NSRect rect = [fView frame];
rect.size = CGSizeMake((CGFloat)width, (CGFloat)height);
[fView setFrame:rect];
#elif defined(DISTRHO_OS_WINDOWS)
if (fWindow != nullptr)
SetWindowPos(fWindow,
HWND_TOP,
0, 0,
width, height,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER);
#else
if (fWindow != 0)
XResizeWindow(fDisplay, fWindow, width, height);
#endif
}

void NativeWindow::setTitle(const char* const title)
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
if (fWindow != nil)
{
if (NSString* const nsTitle = [[NSString alloc]
initWithBytes:title
length:strlen(title)
encoding:NSUTF8StringEncoding])
{
[fWindow setTitle:nsTitle];
[nsTitle release];
}
}
#elif defined(DISTRHO_OS_WINDOWS)
#else
DISTRHO_SAFE_ASSERT_RETURN(fWindow != 0,);

XStoreName(fDisplay, fWindow, title);
#endif
}

void NativeWindow::setTransientParentWindow(const uintptr_t winId)
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
#elif defined(DISTRHO_OS_WINDOWS)
#else
DISTRHO_SAFE_ASSERT_RETURN(fWindow != 0,);

XSetTransientForHint(fDisplay, fWindow, (::Window)winId);
#endif
}

void NativeWindow::setVisible(const bool visible)
{
fIsVisible = visible;

#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
DISTRHO_SAFE_ASSERT_RETURN(fView != nullptr,);

if (fWindow != nil)
{
[fWindow setIsVisible:(visible ? YES : NO)];

if (fIsStandalone)
[fWindow makeMainWindow];

[fWindow makeKeyAndOrderFront:fWindow];
}
else
{
[fView setHidden:(visible ? NO : YES)];
}
#elif defined(DISTRHO_OS_WINDOWS)
DISTRHO_SAFE_ASSERT_RETURN(fWindow != nullptr,);

ShowWindow(fWindow, visible ? SW_SHOWNORMAL : SW_HIDE);
#else
DISTRHO_SAFE_ASSERT_RETURN(fWindow != 0,);

if (visible)
XMapRaised(fDisplay, fWindow);
else
XUnmapWindow(fDisplay, fWindow);
#endif
}

// --------------------------------------------------------------------------------------------------------------------

END_NAMESPACE_DISTRHO

Write Preview
Loading…
Cancel
Save