////  DesktopScriptingInterface.h//  interface/src/scripting////  Created by David Rowe on 25 Aug 2015.//  Copyright 2015 High Fidelity, Inc.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html//  SPDX-License-Identifier: Apache-2.0// #include "DesktopScriptingInterface.h" #include <QWindow>#include <QScreen> #include <shared/QtHelpers.h> #include "Application.h"#include "MainWindow.h"#include <display-plugins/CompositorHelper.h>#include <DependencyManager.h>#include <OffscreenUi.h> /*@jsdoc * The possible docking locations of an <code>InteractiveWindow</code>. * @typedef {object} InteractiveWindow.DockAreas * @property {InteractiveWindow.DockArea} TOP - Dock to the top edge of the Interface window. * @property {InteractiveWindow.DockArea} BOTTOM - Dock to the bottom edge of the Interface window. * @property {InteractiveWindow.DockArea} LEFT - Dock to the left edge of the Interface window. * @property {InteractiveWindow.DockArea} RIGHT - Dock to the right edge of the Interface window. */static const QVariantMap DOCK_AREA {    { "TOP", DockArea::TOP },    { "BOTTOM", DockArea::BOTTOM },    { "LEFT", DockArea::LEFT },    { "RIGHT", DockArea::RIGHT }}; /*@jsdoc * The possible relative position anchors of an <code>InteractiveWindow</code> relative to the Interface window. * @typedef {object} InteractiveWindow.RelativePositionAnchors * @property {InteractiveWindow.RelativePositionAnchor} NO_ANCHOR - Position is not relative to any part of the Interface  *     window. * @property {InteractiveWindow.RelativePositionAnchor} TOP_LEFT - Position is offset from the top left of the Interface window. * @property {InteractiveWindow.RelativePositionAnchor} TOP_RIGHT - Position is offset from the top right of the Interface  *     window. * @property {InteractiveWindow.RelativePositionAnchor} BOTTOM_RIGHT - Position offset from the bottom right of the Interface  *     window. * @property {InteractiveWindow.RelativePositionAnchor} BOTTOM_LEFT - Position is offset from the bottom left of the Interface  *     window. */static const QVariantMap RELATIVE_POSITION_ANCHOR {    { "NO_ANCHOR", RelativePositionAnchor::NO_ANCHOR },    { "TOP_LEFT", RelativePositionAnchor::TOP_LEFT },    { "TOP_RIGHT", RelativePositionAnchor::TOP_RIGHT },    { "BOTTOM_RIGHT", RelativePositionAnchor::BOTTOM_RIGHT },    { "BOTTOM_LEFT", RelativePositionAnchor::BOTTOM_LEFT }}; DesktopScriptingInterface::DesktopScriptingInterface(QObject* parent, bool restricted)     : QObject(parent), _restricted(restricted) { } int DesktopScriptingInterface::getWidth() {    QSize size = qApp->getWindow()->windowHandle()->screen()->virtualSize();    return size.width();}int DesktopScriptingInterface::getHeight() {    QSize size = qApp->getWindow()->windowHandle()->screen()->virtualSize();    return size.height();} /*@jsdoc * The possible display modes for an <code>InteractiveWindow</code>. * @typedef {object} InteractiveWindow.PresentationModes * @property {InteractiveWindow.PresentationMode} VIRTUAL - The window is displayed inside Interface: in the desktop window in  *     desktop mode or on the HUD surface in HMD mode. * @property {InteractiveWindow.PresentationMode} NATIVE - The window is displayed separately from the Interface window, as its  *     own separate window. */QVariantMap DesktopScriptingInterface::getPresentationMode() {    static QVariantMap presentationModes {        { "VIRTUAL", Virtual },        { "NATIVE", Native }    };    return presentationModes;} QVariantMap DesktopScriptingInterface::getDockArea() {    return DOCK_AREA;} QVariantMap DesktopScriptingInterface::getRelativePositionAnchor() {    return RELATIVE_POSITION_ANCHOR;} void DesktopScriptingInterface::setHUDAlpha(float alpha) {    qApp->getApplicationCompositor().setAlpha(alpha);} void DesktopScriptingInterface::show(const QString& path, const QString&  title) {    auto offscreenUI = DependencyManager::get<OffscreenUi>();    if (!offscreenUI) {        return;    }     if (QThread::currentThread() != thread()) {        QMetaObject::invokeMethod(this, "show", Qt::QueuedConnection, Q_ARG(QString, path), Q_ARG(QString, title));        return;    }    offscreenUI->show(path, title);} InteractiveWindowPointer DesktopScriptingInterface::createWindow(const QString& sourceUrl, const QVariantMap& properties) {    if (QThread::currentThread() != thread()) {        InteractiveWindowPointer interactiveWindow = nullptr;        BLOCKING_INVOKE_METHOD(this, "createWindowOnThread",            Q_RETURN_ARG(InteractiveWindowPointer, interactiveWindow),            Q_ARG(QString, sourceUrl),            Q_ARG(QVariantMap, properties),            Q_ARG(QThread*, QThread::currentThread()));        return interactiveWindow;    }      // The offscreen surface already validates against non-local QML sources, but we also need to ensure that     // if we create top level QML, like dock widgets or other types of QQuickView containing desktop windows     // that the source URL is permitted    const auto& urlValidator = OffscreenQmlSurface::getUrlValidator();    if (!urlValidator(sourceUrl)) {        return nullptr;    }     return new InteractiveWindow(sourceUrl, properties, _restricted);} InteractiveWindowPointer DesktopScriptingInterface::createWindowOnThread(const QString& sourceUrl, const QVariantMap& properties, QThread* targetThread) {    // The offscreen surface already validates against non-local QML sources, but we also need to ensure that     // if we create top level QML, like dock widgets or other types of QQuickView containing desktop windows     // that the source URL is permitted    const auto& urlValidator = OffscreenQmlSurface::getUrlValidator();    if (!urlValidator(sourceUrl)) {        return nullptr;    }    InteractiveWindowPointer window = new InteractiveWindow(sourceUrl, properties, _restricted);    window->moveToThread(targetThread);    return window;}