# Conflicts: # interface/src/scripting/DesktopScriptingInterface.h # interface/src/ui/InteractiveWindow.h
Showing the changes to interface/src/ui/InteractiveWindow.cpp (1 of 41 files). Show all
Unified · Split
| @@ -0,0 +1,418 @@ | |||
| 1 | // | ||
| 2 | // InteractiveWindow.cpp | ||
| 3 | // libraries/ui/src | ||
| 4 | // | ||
| 5 | // Created by Thijs Wenker on 2018-06-25 | ||
| 6 | // Copyright 2018 High Fidelity, Inc. | ||
| 7 | // | ||
| 8 | // Distributed under the Apache License, Version 2.0. | ||
| 9 | // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html | ||
| 10 | // | ||
| 11 | |||
| 12 | #include "InteractiveWindow.h" | ||
| 13 | |||
| 14 | #include "Application.h" | ||
| 15 | #include <QtQml/QQmlContext> | ||
| 16 | #include <QtCore/QThread> | ||
| 17 | #include <QtGui/QGuiApplication> | ||
| 18 | #include <QtQuick/QQuickWindow> | ||
| 19 | #include <QQuickView> | ||
| 20 | |||
| 21 | #include <DependencyManager.h> | ||
| 22 | #include <DockWidget.h> | ||
| 23 | #include <RegisteredMetaTypes.h> | ||
| 24 | |||
| 25 | #include "OffscreenUi.h" | ||
| 26 | #include "shared/QtHelpers.h" | ||
| 27 | #include "MainWindow.h" | ||
| 28 | |||
| 29 | #ifdef Q_OS_WIN | ||
| 30 | #include <WinUser.h> | ||
| 31 | #endif | ||
| 32 | |||
| 33 | static auto CONTENT_WINDOW_QML = QUrl("InteractiveWindow.qml"); | ||
| 34 | |||
| 35 | static const char* const FLAGS_PROPERTY = "flags"; | ||
| 36 | static const char* const SOURCE_PROPERTY = "source"; | ||
| 37 | static const char* const TITLE_PROPERTY = "title"; | ||
| 38 | static const char* const POSITION_PROPERTY = "position"; | ||
| 39 | static const char* const INTERACTIVE_WINDOW_POSITION_PROPERTY = "interactiveWindowPosition"; | ||
| 40 | static const char* const SIZE_PROPERTY = "size"; | ||
| 41 | static const char* const INTERACTIVE_WINDOW_SIZE_PROPERTY = "interactiveWindowSize"; | ||
| 42 | static const char* const VISIBLE_PROPERTY = "visible"; | ||
| 43 | static const char* const INTERACTIVE_WINDOW_VISIBLE_PROPERTY = "interactiveWindowVisible"; | ||
| 44 | static const char* const EVENT_BRIDGE_PROPERTY = "eventBridge"; | ||
| 45 | static const char* const PRESENTATION_MODE_PROPERTY = "presentationMode"; | ||
| 46 | static const char* const DOCKED_PROPERTY = "presentationWindowInfo"; | ||
| 47 | static const char* const DOCK_AREA_PROPERTY = "dockArea"; | ||
| 48 | |||
| 49 | static const QStringList KNOWN_SCHEMES = QStringList() << "http" << "https" << "file" << "about" << "atp" << "qrc"; | ||
| 50 | |||
| 51 | static const int DEFAULT_HEIGHT = 60; | ||
| 52 | |||
| 53 | static void dockWidgetDeleter(DockWidget* dockWidget) { | ||
| 54 | dockWidget->deleteLater(); | ||
| 55 | } | ||
| 56 | |||
| 57 | void registerInteractiveWindowMetaType(QScriptEngine* engine) { | ||
| 58 | qScriptRegisterMetaType(engine, interactiveWindowPointerToScriptValue, interactiveWindowPointerFromScriptValue); | ||
| 59 | } | ||
| 60 | |||
| 61 | QScriptValue interactiveWindowPointerToScriptValue(QScriptEngine* engine, const InteractiveWindowPointer& in) { | ||
| 62 | return engine->newQObject(in, QScriptEngine::ScriptOwnership); | ||
| 63 | } | ||
| 64 | |||
| 65 | void interactiveWindowPointerFromScriptValue(const QScriptValue& object, InteractiveWindowPointer& out) { | ||
| 66 | if (const auto interactiveWindow = qobject_cast<InteractiveWindowPointer>(object.toQObject())) { | ||
| 67 | out = interactiveWindow; | ||
| 68 | } | ||
| 69 | } | ||
| 70 | |||
| 71 | /**jsdoc | ||
| 72 | * A set of properties used when creating an <code>InteractiveWindow</code>. | ||
| 73 | * @typedef {object} InteractiveWindow.Properties | ||
| 74 | * @property {string} [title="InteractiveWindow] - The title of the window. | ||
| 75 | * @property {Vec2} [position] - The initial position of the window, in pixels. | ||
| 76 | * @property {Vec2} [size] - The initial size of the window, in pixels | ||
| 77 | * @property {boolean} [visible=true] - <code>true</code> to make the window visible when created, <code>false</code> to make | ||
| 78 | * it invisible. | ||
| 79 | * @property {InteractiveWindow.PresentationMode} [presentationMode=Desktop.PresentationMode.VIRTUAL] - | ||
| 80 | * <code>Desktop.PresentationMode.VIRTUAL</code> to display the window inside Interface, <code>.NATIVE</code> to display it | ||
| 81 | * as its own separate window. | ||
| 82 | * @property {InteractiveWindow.Flags} [flags=0] - Window behavior flags, set at window creation. Possible flag values are | ||
| 83 | * provided as {@link Desktop|Desktop.ALWAYS_ON_TOP} and {@link Desktop|Desktop.CLOSE_BUTTON_HIDES}. | ||
| 84 | */ | ||
| 85 | InteractiveWindow::InteractiveWindow(const QString& sourceUrl, const QVariantMap& properties) { | ||
| 86 | bool docked = false; | ||
| 87 | InteractiveWindowPresentationMode presentationMode = InteractiveWindowPresentationMode::Native; | ||
| 88 | |||
| 89 | if (properties.contains(PRESENTATION_MODE_PROPERTY)) { | ||
| 90 | presentationMode = (InteractiveWindowPresentationMode) properties[PRESENTATION_MODE_PROPERTY].toInt(); | ||
| 91 | } | ||
| 92 | |||
| 93 | if (properties.contains(DOCKED_PROPERTY) && presentationMode == InteractiveWindowPresentationMode::Native) { | ||
| 94 | QVariantMap nativeWindowInfo = properties[DOCKED_PROPERTY].toMap(); | ||
| 95 | Qt::DockWidgetArea dockArea = Qt::TopDockWidgetArea; | ||
| 96 | QString title; | ||
| 97 | QSize windowSize(DEFAULT_HEIGHT, DEFAULT_HEIGHT); | ||
| 98 | |||
| 99 | if (properties.contains(TITLE_PROPERTY)) { | ||
| 100 | title = properties[TITLE_PROPERTY].toString(); | ||
| 101 | } | ||
| 102 | if (properties.contains(SIZE_PROPERTY)) { | ||
| 103 | const auto size = vec2FromVariant(properties[SIZE_PROPERTY]); | ||
| 104 | windowSize = QSize(size.x, size.y); | ||
| 105 | } | ||
| 106 | |||
| 107 | auto mainWindow = qApp->getWindow(); | ||
| 108 | _dockWidget = std::shared_ptr<DockWidget>(new DockWidget(title, mainWindow), dockWidgetDeleter); | ||
| 109 | |||
| 110 | if (nativeWindowInfo.contains(DOCK_AREA_PROPERTY)) { | ||
| 111 | DockArea dockedArea = (DockArea) nativeWindowInfo[DOCK_AREA_PROPERTY].toInt(); | ||
| 112 | switch (dockedArea) { | ||
| 113 | case DockArea::TOP: | ||
| 114 | dockArea = Qt::TopDockWidgetArea; | ||
| 115 | _dockWidget->setFixedHeight(windowSize.height()); | ||
| 116 | break; | ||
| 117 | case DockArea::BOTTOM: | ||
| 118 | dockArea = Qt::BottomDockWidgetArea; | ||
| 119 | _dockWidget->setFixedHeight(windowSize.height()); | ||
| 120 | break; | ||
| 121 | case DockArea::LEFT: | ||
| 122 | dockArea = Qt::LeftDockWidgetArea; | ||
| 123 | _dockWidget->setFixedWidth(windowSize.width()); | ||
| 124 | break; | ||
| 125 | case DockArea::RIGHT: | ||
| 126 | dockArea = Qt::RightDockWidgetArea; | ||
| 127 | _dockWidget->setFixedWidth(windowSize.width()); | ||
| 128 | break; | ||
| 129 | |||
| 130 | default: | ||
| 131 | _dockWidget->setFixedHeight(DEFAULT_HEIGHT); | ||
| 132 | break; | ||
| 133 | } | ||
| 134 | } | ||
| 135 | |||
| 136 | auto quickView = _dockWidget->getQuickView(); | ||
| 137 | QObject::connect(quickView.get(), &QQuickView::statusChanged, [&, this] (QQuickView::Status status) { | ||
| 138 | if (status == QQuickView::Ready) { | ||
| 139 | QQuickItem* rootItem = _dockWidget->getRootItem(); | ||
| 140 | QObject::connect(rootItem, SIGNAL(sendToScript(QVariant)), this, SLOT(qmlToScript(const QVariant&)), Qt::QueuedConnection); | ||
| 141 | } | ||
| 142 | }); | ||
| 143 | _dockWidget->setSource(QUrl(sourceUrl)); | ||
| 144 | mainWindow->addDockWidget(dockArea, _dockWidget.get()); | ||
| 145 | _dockedWindow = docked; | ||
| 146 | } else { | ||
| 147 | auto offscreenUi = DependencyManager::get<OffscreenUi>(); | ||
| 148 | // Build the event bridge and wrapper on the main thread | ||
| 149 | offscreenUi->loadInNewContext(CONTENT_WINDOW_QML, [&](QQmlContext* context, QObject* object) { | ||
| 150 | _qmlWindow = object; | ||
| 151 | context->setContextProperty(EVENT_BRIDGE_PROPERTY, this); | ||
| 152 | if (properties.contains(FLAGS_PROPERTY)) { | ||
| 153 | object->setProperty(FLAGS_PROPERTY, properties[FLAGS_PROPERTY].toUInt()); | ||
| 154 | } | ||
| 155 | if (properties.contains(PRESENTATION_MODE_PROPERTY)) { | ||
| 156 | object->setProperty(PRESENTATION_MODE_PROPERTY, properties[PRESENTATION_MODE_PROPERTY].toInt()); | ||
| 157 | } | ||
| 158 | if (properties.contains(TITLE_PROPERTY)) { | ||
| 159 | object->setProperty(TITLE_PROPERTY, properties[TITLE_PROPERTY].toString()); | ||
| 160 | } | ||
| 161 | if (properties.contains(SIZE_PROPERTY)) { | ||
| 162 | const auto size = vec2FromVariant(properties[SIZE_PROPERTY]); | ||
| 163 | object->setProperty(INTERACTIVE_WINDOW_SIZE_PROPERTY, QSize(size.x, size.y)); | ||
| 164 | } | ||
| 165 | if (properties.contains(POSITION_PROPERTY)) { | ||
| 166 | const auto position = vec2FromVariant(properties[POSITION_PROPERTY]); | ||
| 167 | object->setProperty(INTERACTIVE_WINDOW_POSITION_PROPERTY, QPointF(position.x, position.y)); | ||
| 168 | } | ||
| 169 | if (properties.contains(VISIBLE_PROPERTY)) { | ||
| 170 | object->setProperty(VISIBLE_PROPERTY, properties[INTERACTIVE_WINDOW_VISIBLE_PROPERTY].toBool()); | ||
| 171 | } | ||
| 172 | |||
| 173 | connect(object, SIGNAL(sendToScript(QVariant)), this, SLOT(qmlToScript(const QVariant&)), Qt::QueuedConnection); | ||
| 174 | connect(object, SIGNAL(interactiveWindowPositionChanged()), this, SIGNAL(positionChanged()), Qt::QueuedConnection); | ||
| 175 | connect(object, SIGNAL(interactiveWindowSizeChanged()), this, SIGNAL(sizeChanged()), Qt::QueuedConnection); | ||
| 176 | connect(object, SIGNAL(interactiveWindowVisibleChanged()), this, SIGNAL(visibleChanged()), Qt::QueuedConnection); | ||
| 177 | connect(object, SIGNAL(presentationModeChanged()), this, SIGNAL(presentationModeChanged()), Qt::QueuedConnection); | ||
| 178 | connect(object, SIGNAL(titleChanged()), this, SIGNAL(titleChanged()), Qt::QueuedConnection); | ||
| 179 | connect(object, SIGNAL(windowClosed()), this, SIGNAL(closed()), Qt::QueuedConnection); | ||
| 180 | connect(object, SIGNAL(selfDestruct()), this, SLOT(close()), Qt::QueuedConnection); | ||
| 181 | |||
| 182 | #ifdef Q_OS_WIN | ||
| 183 | connect(object, SIGNAL(nativeWindowChanged()), this, SLOT(parentNativeWindowToMainWindow()), Qt::QueuedConnection); | ||
| 184 | connect(object, SIGNAL(interactiveWindowVisibleChanged()), this, SLOT(parentNativeWindowToMainWindow()), Qt::QueuedConnection); | ||
| 185 | connect(object, SIGNAL(presentationModeChanged()), this, SLOT(parentNativeWindowToMainWindow()), Qt::QueuedConnection); | ||
| 186 | #endif | ||
| 187 | |||
| 188 | QUrl sourceURL{ sourceUrl }; | ||
| 189 | // If the passed URL doesn't correspond to a known scheme, assume it's a local file path | ||
| 190 | if (!KNOWN_SCHEMES.contains(sourceURL.scheme(), Qt::CaseInsensitive)) { | ||
| 191 | sourceURL = QUrl::fromLocalFile(sourceURL.toString()).toString(); | ||
| 192 | } | ||
| 193 | object->setProperty(SOURCE_PROPERTY, sourceURL); | ||
| 194 | }); | ||
| 195 | } | ||
| 196 | } | ||
| 197 | |||
| 198 | InteractiveWindow::~InteractiveWindow() { | ||
| 199 | close(); | ||
| 200 | } | ||
| 201 | |||
| 202 | void InteractiveWindow::sendToQml(const QVariant& message) { | ||
| 203 | // Forward messages received from the script on to QML | ||
| 204 | if (_dockedWindow) { | ||
| 205 | QQuickItem* rootItem = _dockWidget->getRootItem(); | ||
| 206 | if (rootItem) { | ||
| 207 | QMetaObject::invokeMethod(_qmlWindow, "fromScript", Qt::QueuedConnection, Q_ARG(QVariant, message)); | ||
| 208 | } | ||
| 209 | } else { | ||
| 210 | QMetaObject::invokeMethod(_qmlWindow, "fromScript", Qt::QueuedConnection, Q_ARG(QVariant, message)); | ||
| 211 | } | ||
| 212 | } | ||
| 213 | |||
| 214 | void InteractiveWindow::emitScriptEvent(const QVariant& scriptMessage) { | ||
| 215 | if (QThread::currentThread() != thread()) { | ||
| 216 | QMetaObject::invokeMethod(this, "emitScriptEvent", Qt::QueuedConnection, Q_ARG(QVariant, scriptMessage)); | ||
| 217 | } else { | ||
| 218 | emit scriptEventReceived(scriptMessage); | ||
| 219 | } | ||
| 220 | } | ||
| 221 | |||
| 222 | void InteractiveWindow::emitWebEvent(const QVariant& webMessage) { | ||
| 223 | if (QThread::currentThread() != thread()) { | ||
| 224 | QMetaObject::invokeMethod(this, "emitWebEvent", Qt::QueuedConnection, Q_ARG(QVariant, webMessage)); | ||
| 225 | } else { | ||
| 226 | emit webEventReceived(webMessage); | ||
| 227 | } | ||
| 228 | } | ||
| 229 | |||
| 230 | void InteractiveWindow::close() { | ||
| 231 | if (QThread::currentThread() != thread()) { | ||
| 232 | QMetaObject::invokeMethod(this, "close"); | ||
| 233 | return; | ||
| 234 | } | ||
| 235 | |||
| 236 | if (_qmlWindow) { | ||
| 237 | _qmlWindow->deleteLater(); | ||
| 238 | } | ||
| 239 | |||
| 240 | qApp->getWindow()->removeDockWidget(_dockWidget.get()); | ||
| 241 | _dockWidget = nullptr; | ||
| 242 | _qmlWindow = nullptr; | ||
| 243 | } | ||
| 244 | |||
| 245 | void InteractiveWindow::show() { | ||
| 246 | if (QThread::currentThread() != thread()) { | ||
| 247 | QMetaObject::invokeMethod(this, "show"); | ||
| 248 | return; | ||
| 249 | } | ||
| 250 | |||
| 251 | if (_qmlWindow) { | ||
| 252 | QMetaObject::invokeMethod(_qmlWindow, "show", Qt::DirectConnection); | ||
| 253 | } | ||
| 254 | } | ||
| 255 | |||
| 256 | void InteractiveWindow::raise() { | ||
| 257 | if (QThread::currentThread() != thread()) { | ||
| 258 | QMetaObject::invokeMethod(this, "raise"); | ||
| 259 | return; | ||
| 260 | } | ||
| 261 | |||
| 262 | if (_qmlWindow) { | ||
| 263 | QMetaObject::invokeMethod(_qmlWindow, "raiseWindow", Qt::DirectConnection); | ||
| 264 | } | ||
| 265 | } | ||
| 266 | |||
| 267 | void InteractiveWindow::qmlToScript(const QVariant& message) { | ||
| 268 | if (message.canConvert<QJSValue>()) { | ||
| 269 | emit fromQml(qvariant_cast<QJSValue>(message).toVariant()); | ||
| 270 | } else if (message.canConvert<QString>()) { | ||
| 271 | emit fromQml(message.toString()); | ||
| 272 | } else { | ||
| 273 | qWarning() << "Unsupported message type " << message; | ||
| 274 | } | ||
| 275 | } | ||
| 276 | |||
| 277 | void InteractiveWindow::setVisible(bool visible) { | ||
| 278 | if (QThread::currentThread() != thread()) { | ||
| 279 | QMetaObject::invokeMethod(this, "setVisible", Q_ARG(bool, visible)); | ||
| 280 | return; | ||
| 281 | } | ||
| 282 | |||
| 283 | if (!_qmlWindow.isNull()) { | ||
| 284 | _qmlWindow->setProperty(INTERACTIVE_WINDOW_VISIBLE_PROPERTY, visible); | ||
| 285 | } | ||
| 286 | } | ||
| 287 | |||
| 288 | bool InteractiveWindow::isVisible() const { | ||
| 289 | if (QThread::currentThread() != thread()) { | ||
| 290 | bool result = false; | ||
| 291 | BLOCKING_INVOKE_METHOD(const_cast<InteractiveWindow*>(this), "isVisible", Q_RETURN_ARG(bool, result)); | ||
| 292 | return result; | ||
| 293 | } | ||
| 294 | |||
| 295 | if (_qmlWindow.isNull()) { | ||
| 296 | return false; | ||
| 297 | } | ||
| 298 | |||
| 299 | return _qmlWindow->property(INTERACTIVE_WINDOW_VISIBLE_PROPERTY).toBool(); | ||
| 300 | } | ||
| 301 | |||
| 302 | glm::vec2 InteractiveWindow::getPosition() const { | ||
| 303 | if (QThread::currentThread() != thread()) { | ||
| 304 | glm::vec2 result; | ||
| 305 | BLOCKING_INVOKE_METHOD(const_cast<InteractiveWindow*>(this), "getPosition", Q_RETURN_ARG(glm::vec2, result)); | ||
| 306 | return result; | ||
| 307 | } | ||
| 308 | |||
| 309 | if (_qmlWindow.isNull()) { | ||
| 310 | return {}; | ||
| 311 | } | ||
| 312 | |||
| 313 | return toGlm(_qmlWindow->property(INTERACTIVE_WINDOW_POSITION_PROPERTY).toPointF()); | ||
| 314 | } | ||
| 315 | |||
| 316 | void InteractiveWindow::setPosition(const glm::vec2& position) { | ||
| 317 | if (QThread::currentThread() != thread()) { | ||
| 318 | QMetaObject::invokeMethod(this, "setPosition", Q_ARG(const glm::vec2&, position)); | ||
| 319 | return; | ||
| 320 | } | ||
| 321 | |||
| 322 | if (!_qmlWindow.isNull()) { | ||
| 323 | _qmlWindow->setProperty(INTERACTIVE_WINDOW_POSITION_PROPERTY, QPointF(position.x, position.y)); | ||
| 324 | QMetaObject::invokeMethod(_qmlWindow, "updateInteractiveWindowPositionForMode", Qt::DirectConnection); | ||
| 325 | } | ||
| 326 | } | ||
| 327 | |||
| 328 | glm::vec2 InteractiveWindow::getSize() const { | ||
| 329 | if (QThread::currentThread() != thread()) { | ||
| 330 | glm::vec2 result; | ||
| 331 | BLOCKING_INVOKE_METHOD(const_cast<InteractiveWindow*>(this), "getSize", Q_RETURN_ARG(glm::vec2, result)); | ||
| 332 | return result; | ||
| 333 | } | ||
| 334 | |||
| 335 | if (_qmlWindow.isNull()) { | ||
| 336 | return {}; | ||
| 337 | } | ||
| 338 | return toGlm(_qmlWindow->property(INTERACTIVE_WINDOW_SIZE_PROPERTY).toSize()); | ||
| 339 | } | ||
| 340 | |||
| 341 | void InteractiveWindow::setSize(const glm::vec2& size) { | ||
| 342 | if (QThread::currentThread() != thread()) { | ||
| 343 | QMetaObject::invokeMethod(this, "setSize", Q_ARG(const glm::vec2&, size)); | ||
| 344 | return; | ||
| 345 | } | ||
| 346 | |||
| 347 | if (!_qmlWindow.isNull()) { | ||
| 348 | _qmlWindow->setProperty(INTERACTIVE_WINDOW_SIZE_PROPERTY, QSize(size.x, size.y)); | ||
| 349 | QMetaObject::invokeMethod(_qmlWindow, "updateInteractiveWindowSizeForMode", Qt::DirectConnection); | ||
| 350 | } | ||
| 351 | } | ||
| 352 | |||
| 353 | QString InteractiveWindow::getTitle() const { | ||
| 354 | if (QThread::currentThread() != thread()) { | ||
| 355 | QString result; | ||
| 356 | BLOCKING_INVOKE_METHOD(const_cast<InteractiveWindow*>(this), "getTitle", Q_RETURN_ARG(QString, result)); | ||
| 357 | return result; | ||
| 358 | } | ||
| 359 | |||
| 360 | if (_qmlWindow.isNull()) { | ||
| 361 | return QString(); | ||
| 362 | } | ||
| 363 | return _qmlWindow->property(TITLE_PROPERTY).toString(); | ||
| 364 | } | ||
| 365 | |||
| 366 | void InteractiveWindow::setTitle(const QString& title) { | ||
| 367 | if (QThread::currentThread() != thread()) { | ||
| 368 | QMetaObject::invokeMethod(this, "setTitle", Q_ARG(const QString&, title)); | ||
| 369 | return; | ||
| 370 | } | ||
| 371 | |||
| 372 | if (!_qmlWindow.isNull()) { | ||
| 373 | _qmlWindow->setProperty(TITLE_PROPERTY, title); | ||
| 374 | } | ||
| 375 | } | ||
| 376 | |||
| 377 | int InteractiveWindow::getPresentationMode() const { | ||
| 378 | if (QThread::currentThread() != thread()) { | ||
| 379 | int result; | ||
| 380 | BLOCKING_INVOKE_METHOD(const_cast<InteractiveWindow*>(this), "getPresentationMode", | ||
| 381 | Q_RETURN_ARG(int, result)); | ||
| 382 | return result; | ||
| 383 | } | ||
| 384 | |||
| 385 | if (_qmlWindow.isNull()) { | ||
| 386 | return Virtual; | ||
| 387 | } | ||
| 388 | return _qmlWindow->property(PRESENTATION_MODE_PROPERTY).toInt(); | ||
| 389 | } | ||
| 390 | |||
| 391 | void InteractiveWindow::parentNativeWindowToMainWindow() { | ||
| 392 | #ifdef Q_OS_WIN | ||
| 393 | if (QThread::currentThread() != thread()) { | ||
| 394 | QMetaObject::invokeMethod(this, "parentNativeWindowToMainWindow"); | ||
| 395 | return; | ||
| 396 | } | ||
| 397 | if (_qmlWindow.isNull()) { | ||
| 398 | return; | ||
| 399 | } | ||
| 400 | const auto nativeWindowProperty = _qmlWindow->property("nativeWindow"); | ||
| 401 | if (nativeWindowProperty.isNull() || !nativeWindowProperty.isValid()) { | ||
| 402 | return; | ||
| 403 | } | ||
| 404 | const auto nativeWindow = qvariant_cast<QQuickWindow*>(nativeWindowProperty); | ||
| 405 | SetWindowLongPtr((HWND)nativeWindow->winId(), GWLP_HWNDPARENT, (LONG)MainWindow::findMainWindow()->winId()); | ||
| 406 | #endif | ||
| 407 | } | ||
| 408 | |||
| 409 | void InteractiveWindow::setPresentationMode(int presentationMode) { | ||
| 410 | if (QThread::currentThread() != thread()) { | ||
| 411 | QMetaObject::invokeMethod(this, "setPresentationMode", Q_ARG(int, presentationMode)); | ||
| 412 | return; | ||
| 413 | } | ||
| 414 | |||
| 415 | if (!_qmlWindow.isNull()) { | ||
| 416 | _qmlWindow->setProperty(PRESENTATION_MODE_PROPERTY, presentationMode); | ||
| 417 | } | ||
| 418 | } | ||