sola/qwindowkit.git

			@@ -5,15 +5,9 @@

			#include <QtGui/QGuiApplication>

			#include "qwkglobal_p.h"
			#include "systemwindow_p.h"
			namespace QWK {

			#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
			static const struct QWK_Hook {
			QWK_Hook() {
			qputenv("QT_MAC_WANTS_LAYER", "1");
			}
			} g_hook{};
			#endif

			struct NSWindowProxy {
			NSWindowProxy(NSWindow *macWindow) {
			@@ -104,9 +98,10 @@
			nswindow.hasShadow = YES;
			nswindow.showsToolbarButton = NO;
			nswindow.movableByWindowBackground = NO;
			//nswindow.movable = NO; // This line causes the window in the wrong position when become fullscreen.
			// For some unknown reason, we don't need the following hack in Qt versions below or
			// equal to 6.2.4.
			nswindow.movable = NO; // This line causes the window in the wrong position when
			// become fullscreen.
			// For some unknown reason, we don't need the following hack in Qt versions below or
			// equal to 6.2.4.
			#if (QT_VERSION > QT_VERSION_CHECK(6, 2, 4))
			[nswindow standardWindowButton:NSWindowCloseButton].hidden = (visible ? NO : YES);
			[nswindow standardWindowButton:NSWindowMiniaturizeButton].hidden = (visible ? NO : YES);
			@@ -214,15 +209,6 @@
			return [nsview window];
			}

			static inline void cleanupProxy() {
			if (g_proxyList()->isEmpty()) {
			return;
			}
			const auto &data = *g_proxyList();
			qDeleteAll(data);
			g_proxyList()->clear();
			}

			static inline NSWindowProxy *ensureWindowProxy(const WId windowId) {
			auto it = g_proxyList()->find(windowId);
			if (it == g_proxyList()->end()) {
			@@ -230,18 +216,151 @@
			const auto proxy = new NSWindowProxy(nswindow);
			it = g_proxyList()->insert(windowId, proxy);
			}
			static bool cleanerInstalled = false;
			if (!cleanerInstalled) {
			cleanerInstalled = true;
			qAddPostRoutine(cleanupProxy);
			}
			return it.value();
			}

			CocoaWindowContext::CocoaWindowContext() {
			static inline void releaseWindowProxy(const WId windowId) {
			if (const auto proxy = g_proxyList()->take(windowId)) {
			delete proxy;
			}
			}

			class CocoaWindowEventFilter : public QObject {
			public:
			explicit CocoaWindowEventFilter(AbstractWindowContext context, QObject parent = nullptr);
			~CocoaWindowEventFilter() override;

			enum WindowStatus {
			Idle,
			WaitingRelease,
			PreparingMove,
			Moving,
			};

			protected:
			bool eventFilter(QObject object, QEvent event) override;

			private:
			AbstractWindowContext *m_context;
			bool m_cursorShapeChanged;
			WindowStatus m_windowStatus;
			};

			CocoaWindowEventFilter::CocoaWindowEventFilter(AbstractWindowContext context, QObject parent)
			: QObject(parent), m_context(context), m_cursorShapeChanged(false), m_windowStatus(Idle) {
			m_context->window()->installEventFilter(this);
			}

			CocoaWindowEventFilter::~CocoaWindowEventFilter() = default;

			bool CocoaWindowEventFilter::eventFilter(QObject obj, QEvent event) {
			Q_UNUSED(obj)
			auto type = event->type();
			if (type < QEvent::MouseButtonPress \|\| type > QEvent::MouseMove) {
			return false;
			}
			auto host = m_context->host();
			auto window = m_context->window();
			auto delegate = m_context->delegate();
			auto me = static_cast<const QMouseEvent *>(event);

			QPoint scenePos = getMouseEventScenePos(me);
			QPoint globalPos = getMouseEventGlobalPos(me);

			bool inTitleBar = m_context->isInTitleBarDraggableArea(scenePos);
			switch (type) {
			case QEvent::MouseButtonPress: {
			switch (me->button()) {
			case Qt::LeftButton: {
			if (inTitleBar) {
			// If we call startSystemMove() now but release the mouse without actual
			// movement, there will be no MouseReleaseEvent, so we defer it when the
			// mouse is actually moving for the first time
			m_windowStatus = PreparingMove;
			event->accept();
			return true;
			}
			break;
			}
			case Qt::RightButton: {
			m_context->showSystemMenu(globalPos);
			break;
			}
			default:
			break;
			}
			m_windowStatus = WaitingRelease;
			break;
			}

			case QEvent::MouseButtonRelease: {
			switch (m_windowStatus) {
			case PreparingMove:
			case Moving: {
			m_windowStatus = Idle;
			event->accept();
			return true;
			}
			case WaitingRelease: {
			m_windowStatus = Idle;
			break;
			}
			default: {
			if (inTitleBar) {
			event->accept();
			return true;
			}
			break;
			}
			}
			break;
			}

			case QEvent::MouseMove: {
			switch (m_windowStatus) {
			case Moving: {
			return true;
			}
			case PreparingMove: {
			m_windowStatus = Moving;
			startSystemMove(window);
			event->accept();
			return true;
			}
			default:
			break;
			}
			break;
			}

			case QEvent::MouseButtonDblClick: {
			if (me->button() == Qt::LeftButton && inTitleBar &&
			!delegate->isHostSizeFixed(host)) {
			Qt::WindowStates windowState = delegate->getWindowState(host);
			if (!(windowState & Qt::WindowFullScreen)) {
			if (windowState & Qt::WindowMaximized) {
			delegate->setWindowState(host, windowState & ~Qt::WindowMaximized);
			} else {
			delegate->setWindowState(host, windowState \| Qt::WindowMaximized);
			}
			event->accept();
			return true;
			}
			}
			break;
			}

			default:
			break;
			}
			return false;
			}

			CocoaWindowContext::CocoaWindowContext() : AbstractWindowContext() {
			}

			CocoaWindowContext::~CocoaWindowContext() {
			releaseWindowProxy(windowId);
			}

			QString CocoaWindowContext::key() const {
			@@ -249,17 +368,48 @@
			}

			void CocoaWindowContext::virtual_hook(int id, void *data) {
			switch (id) {
			case ShowSystemMenuHook: {
			// TODO: mac system menu
			return;
			}

			case SystemButtonAreaChangedHook: {
			// TODO: mac system button rect updated
			return;
			}

			case WindowAttributeChangedHook: {
			auto args = static_cast<void **>(data);
			const auto &key = static_cast<const QString >(args[0]);
			const auto &newVar = static_cast<const QVariant >(args[1]);
			const auto &oldVar = static_cast<const QVariant >(args[2]);

			if (key == QStringLiteral("no-system-buttons")) {
			if (newVar.toBool()) {
			// TODO: set off
			} else {
			// TODO: set on
			}
			}
			break;
			}

			default:
			break;
			}
			AbstractWindowContext::virtual_hook(id, data);
			}

			bool CocoaWindowContext::setupHost() {
			#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
			m_windowHandle->setProperty("_q_mac_wantsLayer", 1);
			#endif
			WId winId = m_windowHandle->winId();
			ensureWindowProxy(winId)->setSystemTitleBarVisible(false);
			// Cache window ID
			windowId = winId;
			return true;
			void CocoaWindowContext::winIdChanged(QWindow *oldWindow) {
			releaseWindowProxy(windowId);
			if (!m_windowHandle) {
			return;
			}

			windowId = m_windowHandle->winId();
			ensureWindowProxy(windowId)->setSystemTitleBarVisible(false);
			cocoaWindowEventFilter = std::make_unique<CocoaWindowEventFilter>(this, this);
			}

			}