Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-25 21:35:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

checking to see if I did something blocking the build

Browse source
This commit is contained in:
milad 2019-07-22 15:39:03 -07:00
parent de233e456e
commit dec176b921
7 changed files with 647 additions and 429 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
browserUI/warning.qml Normal file
View file

@ -0,0 +1,67 @@
Rectangle {
id:permissionsContainer
visible:false
color: "#000000"
width: parent.width
anchors.top: buttons.bottom
height:40
z:100
gradient: Gradient {
GradientStop { position: 0.0; color: "black" }
GradientStop { position: 1.0; color: "grey" }
}
RalewayLight {
id: permissionsInfo
anchors.right:permissionsRow.left
anchors.rightMargin: 32
anchors.topMargin:8
anchors.top:parent.top
text: "This site wants to use your microphone/camera"
size: 18
color: hifi.colors.white
}
Row {
id: permissionsRow
spacing: 4
anchors.top:parent.top
anchors.topMargin: 8
anchors.right: parent.right
visible: true
z:101
Button {
id:allow
text: "Allow"
color: hifi.buttons.blue
colorScheme: root.colorScheme
width: 120
enabled: true
onClicked: root.allowPermissions();
z:101
}
Button {
id:block
text: "Block"
color: hifi.buttons.red
colorScheme: root.colorScheme
width: 120
enabled: true
onClicked: root.hidePermissionsBar();
z:101
}
}
}
function hidePermissionsBar(){
permissionsContainer.visible=false;
}
function allowPermissions(){
webview.grantFeaturePermission(permissionsBar.securityOrigin, permissionsBar.feature, true);
hidePermissionsBar();
}

9
interface/resources/qml/controls/+webengine/FlickableWebViewCore.qml
View file

@ -5,6 +5,7 @@ import QtWebChannel 1.0
import QtQuick.Controls 2.2 import QtQuick.Controls 2.2
import stylesUit 1.0 as StylesUIt import stylesUit 1.0 as StylesUIt
import "../hifi/PermissionPopup.qml" as PermissionPopup
Item { Item {
id: flick id: flick
@ -140,8 +141,14 @@ Item {
}); });
} }
PermissionPopup {
id: permissionPopup
}
onFeaturePermissionRequested: { onFeaturePermissionRequested: {
grantFeaturePermission(securityOrigin, feature, false); console.log("Requesting permissions:")
permissionPopup.visible = true;
// grantFeaturePermission(securityOrigin, feature, false);
} }
//disable popup //disable popup

82
interface/resources/qml/hifi/PermissionPopup.qml Normal file
View file

@ -0,0 +1,82 @@
import QtQuick 2.5
import controlsUit 1.0 as HifiControls
import stylesUit 1.0 as HifiStyles
import "../windows" as Windows
import "../."
Item {
id: root
width: 600
height: 200
z:100
HifiConstants { id: hifi }
// anchors.top: buttons.bottom
Rectangle {
id: mainContainer
width: root.width
height: root.height
color: hifi.colors.white
Row {
id: webAccessHeaderContainer
height: root.height * 0.30
RalewayLight {
id: webAccessHeaderText
text: "WEB CAMERA ACCESS REQUEST"
width: mainContainer.width
horizontalAlignment: Text.AlignHCenter
anchors.bottom: parent.bottom
font.bold: true
color: hifi.colors.black
size: 17
}
}
Row {
id: webAccessInfoContainer
anchors.top: webAccessHeaderContainer.bottom
anchors.topMargin: 10
RalewayLight {
width: mainContainer.width
id: webAccessInfoText
horizontalAlignment: Text.AlignHCenter
text: "This domain is requesting access to your web camera and microphone"
size: 17
color: hifi.colors.black
}
}
Rectangle {
id: permissionsButtonRow
color: "#AAAAAA"
anchors.topMargin: 10
height: 50
width: leftButton.width + rightButton.width + (this.space * 3)
anchors.top: webAccessInfoContainer.bottom
anchors.horizontalCenter: webAccessInfoContainer.horizontalCenter
anchors.verticalCenter: webAccessInfoContainer.verticalCenter
property real space: 5
Button {
anchors.left: permissionsButtonRow.left
id: leftButton
anchors.leftMargin: permissionsButtonRow.space
text: "Yes allow access"
color: hifi.buttons.blue
colorScheme: root.colorScheme
enabled: true
width: 155
}
Button {
id: rightButton
anchors.left: leftButton.right
anchors.leftMargin: permissionsButtonRow.space
text: "Don't Allow"
color: hifi.buttons.red
colorScheme: root.colorScheme
enabled: true
}
}
}
}

34
interface/resources/qml/hifi/PermissionPopupBackground.qml Normal file
View file

@ -0,0 +1,34 @@
import QtQuick 2.5
import controlsUit 1.0
import stylesUit 1.0
import "../windows"
import "../."
Rectangle {
id: permissionPopupBackground
anchors.fill: parent
color: QT.rgba(0, 0, 0, 0.7);
HifiConstants { id: hifi }
PermissionPopup {
id: permissionPopupItem
visible: false
Component.onCompleted: {
console.log("\n\n TESTING!! \n\n")
}
}
onFeaturePermissionRequested: {
permissionPopupItem.onLeftButtonClicked = function() {
console.log("TEST FOR PERMISSIONS :: LEFT CLICKED");
grantFeaturePermission(securityOrigin, feature, true);
.visible = false;
}
permissionPopupItem.onRightButtonClicked = function() {
console.log("TEST FOR PERMISSIONS :: RIGHT CLICKED");
grantFeaturePermission(securityOrigin, feature, false);
permissionPopupBackground.visible = false;
}
permissionPopupBackground.visible = true;
}
}

454
interface/src/Menu.cpp
View file

@ -56,6 +56,12 @@
#include "scripting/RenderScriptingInterface.h" #include "scripting/RenderScriptingInterface.h"
/*
QSharedPointer<OffscreenUi> getOff() {
return DependencyManager::get<OffscreenUi>();
}
*/
extern bool DEV_DECIMATE_TEXTURES; extern bool DEV_DECIMATE_TEXTURES;
Menu* Menu::getInstance() { Menu* Menu::getInstance() {
@ -76,45 +82,44 @@ Menu::Menu() {
addActionToQMenuAndActionHash(fileMenu, MenuOption::Login); addActionToQMenuAndActionHash(fileMenu, MenuOption::Login);
// connect to the appropriate signal of the AccountManager so that we can change the Login/Logout menu item // connect to the appropriate signal of the AccountManager so that we can change the Login/Logout menu item
connect(accountManager.data(), &AccountManager::profileChanged, connect(accountManager.data(), &AccountManager::profileChanged, dialogsManager.data(),
dialogsManager.data(), &DialogsManager::toggleLoginDialog); &DialogsManager::toggleLoginDialog);
connect(accountManager.data(), &AccountManager::logoutComplete, connect(accountManager.data(), &AccountManager::logoutComplete, dialogsManager.data(),
dialogsManager.data(), &DialogsManager::toggleLoginDialog); &DialogsManager::toggleLoginDialog);
} }
// File > Quit // File > Quit
addActionToQMenuAndActionHash(fileMenu, MenuOption::Quit, Qt::CTRL | Qt::Key_Q, qApp, SLOT(quit()), QAction::QuitRole); addActionToQMenuAndActionHash(fileMenu, MenuOption::Quit, Qt::CTRL | Qt::Key_Q, qApp, SLOT(quit()), QAction::QuitRole);
// Edit menu ---------------------------------- // Edit menu ----------------------------------
MenuWrapper* editMenu = addMenu("Edit"); MenuWrapper* editMenu = addMenu("Edit");
// Edit > Cut // Edit > Cut
auto cutAction = addActionToQMenuAndActionHash(editMenu, "Cut", QKeySequence::Cut); auto cutAction = addActionToQMenuAndActionHash(editMenu, "Cut", QKeySequence::Cut);
connect(cutAction, &QAction::triggered, [] { connect(cutAction, &QAction::triggered, [] {
QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_X, Qt::ControlModifier); QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_X, Qt::ControlModifier);
QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent);
}); });
// Edit > Copy // Edit > Copy
auto copyAction = addActionToQMenuAndActionHash(editMenu, "Copy", QKeySequence::Copy); auto copyAction = addActionToQMenuAndActionHash(editMenu, "Copy", QKeySequence::Copy);
connect(copyAction, &QAction::triggered, [] { connect(copyAction, &QAction::triggered, [] {
QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_C, Qt::ControlModifier); QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_C, Qt::ControlModifier);
QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent);
}); });
// Edit > Paste // Edit > Paste
auto pasteAction = addActionToQMenuAndActionHash(editMenu, "Paste", QKeySequence::Paste); auto pasteAction = addActionToQMenuAndActionHash(editMenu, "Paste", QKeySequence::Paste);
connect(pasteAction, &QAction::triggered, [] { connect(pasteAction, &QAction::triggered, [] {
QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_V, Qt::ControlModifier); QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_V, Qt::ControlModifier);
QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent);
}); });
// Edit > Delete // Edit > Delete
auto deleteAction = addActionToQMenuAndActionHash(editMenu, "Delete", QKeySequence::Delete); auto deleteAction = addActionToQMenuAndActionHash(editMenu, "Delete", QKeySequence::Delete);
connect(deleteAction, &QAction::triggered, [] { connect(deleteAction, &QAction::triggered, [] {
QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_Delete, Qt::NoModifier); QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_Delete, Qt::NoModifier);
QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent);
}); });
editMenu->addSeparator(); editMenu->addSeparator();
@ -133,8 +138,7 @@ Menu::Menu() {
editMenu->addSeparator(); editMenu->addSeparator();
// Edit > Asset Browser // Edit > Asset Browser
auto assetServerAction = addActionToQMenuAndActionHash(editMenu, MenuOption::AssetServer, auto assetServerAction = addActionToQMenuAndActionHash(editMenu, MenuOption::AssetServer, Qt::CTRL | Qt::SHIFT | Qt::Key_A,
Qt::CTRL | Qt::SHIFT | Qt::Key_A,
qApp, SLOT(showAssetServerWidget())); qApp, SLOT(showAssetServerWidget()));
{ {
auto nodeList = DependencyManager::get<NodeList>(); auto nodeList = DependencyManager::get<NodeList>();
@ -145,9 +149,7 @@ Menu::Menu() {
// Edit > Avatar Packager // Edit > Avatar Packager
#ifndef Q_OS_ANDROID #ifndef Q_OS_ANDROID
action = addActionToQMenuAndActionHash(editMenu, MenuOption::AvatarPackager); action = addActionToQMenuAndActionHash(editMenu, MenuOption::AvatarPackager);
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] { DependencyManager::get<AvatarPackager>()->open(); });
DependencyManager::get<AvatarPackager>()->open();
});
#endif #endif
// Edit > Reload All Content // Edit > Reload All Content
@ -162,7 +164,6 @@ Menu::Menu() {
QActionGroup* displayModeGroup = new QActionGroup(displayModeMenu); QActionGroup* displayModeGroup = new QActionGroup(displayModeMenu);
displayModeGroup->setExclusive(true); displayModeGroup->setExclusive(true);
// View menu ---------------------------------- // View menu ----------------------------------
MenuWrapper* viewMenu = addMenu("View"); MenuWrapper* viewMenu = addMenu("View");
QActionGroup* cameraModeGroup = new QActionGroup(viewMenu); QActionGroup* cameraModeGroup = new QActionGroup(viewMenu);
@ -171,31 +172,29 @@ Menu::Menu() {
cameraModeGroup->setExclusive(true); cameraModeGroup->setExclusive(true);
// View > First Person // View > First Person
auto firstPersonAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash( auto firstPersonAction = cameraModeGroup->addAction(
viewMenu, MenuOption::FirstPerson, 0, addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FirstPerson, 0, true, qApp, SLOT(cameraMenuChanged())));
true, qApp, SLOT(cameraMenuChanged())));
firstPersonAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); firstPersonAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup));
// View > Third Person // View > Third Person
auto thirdPersonAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash( auto thirdPersonAction = cameraModeGroup->addAction(
viewMenu, MenuOption::ThirdPerson, 0, addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::ThirdPerson, 0, false, qApp, SLOT(cameraMenuChanged())));
false, qApp, SLOT(cameraMenuChanged())));
thirdPersonAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); thirdPersonAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup));
// View > Mirror // View > Mirror
auto viewMirrorAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash( auto viewMirrorAction =
viewMenu, MenuOption::FullscreenMirror, 0, cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FullscreenMirror, 0, false,
false, qApp, SLOT(cameraMenuChanged()))); qApp, SLOT(cameraMenuChanged())));
viewMirrorAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); viewMirrorAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup));
viewMenu->addSeparator(); viewMenu->addSeparator();
// View > Center Player In View // View > Center Player In View
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CenterPlayerInView, addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CenterPlayerInView, 0, true, qApp,
0, true, qApp, SLOT(rotationModeChanged())); SLOT(rotationModeChanged()));
// View > Enter First Person Mode in HMD // View > Enter First Person Mode in HMD
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FirstPersonHMD, 0, true); addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FirstPersonHMD, 0, true);
@ -210,21 +209,19 @@ Menu::Menu() {
// Navigate > Copy Address // Navigate > Copy Address
auto addressManager = DependencyManager::get<AddressManager>(); auto addressManager = DependencyManager::get<AddressManager>();
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyAddress, 0, addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyAddress, 0, addressManager.data(), SLOT(copyAddress()));
addressManager.data(), SLOT(copyAddress()));
// Navigate > Copy Path // Navigate > Copy Path
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyPath, 0, addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyPath, 0, addressManager.data(), SLOT(copyPath()));
addressManager.data(), SLOT(copyPath()));
// Navigate > Start-up Location // Navigate > Start-up Location
MenuWrapper* startupLocationMenu = navigateMenu->addMenu(MenuOption::StartUpLocation); MenuWrapper* startupLocationMenu = navigateMenu->addMenu(MenuOption::StartUpLocation);
QActionGroup* startupLocatiopnGroup = new QActionGroup(startupLocationMenu); QActionGroup* startupLocatiopnGroup = new QActionGroup(startupLocationMenu);
startupLocatiopnGroup->setExclusive(true); startupLocatiopnGroup->setExclusive(true);
startupLocatiopnGroup->addAction(addCheckableActionToQMenuAndActionHash(startupLocationMenu, MenuOption::HomeLocation, 0, startupLocatiopnGroup->addAction(
false)); addCheckableActionToQMenuAndActionHash(startupLocationMenu, MenuOption::HomeLocation, 0, false));
startupLocatiopnGroup->addAction(addCheckableActionToQMenuAndActionHash(startupLocationMenu, MenuOption::LastLocation, 0, startupLocatiopnGroup->addAction(
true)); addCheckableActionToQMenuAndActionHash(startupLocationMenu, MenuOption::LastLocation, 0, true));
// Settings menu ---------------------------------- // Settings menu ----------------------------------
MenuWrapper* settingsMenu = addMenu("Settings"); MenuWrapper* settingsMenu = addMenu("Settings");
@ -234,20 +231,20 @@ Menu::Menu() {
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
if (!qApp->getLoginDialogPoppedUp()) { if (!qApp->getLoginDialogPoppedUp()) {
qApp->showDialog(QString("hifi/dialogs/GeneralPreferencesDialog.qml"), qApp->showDialog(QString("hifi/dialogs/GeneralPreferencesDialog.qml"),
QString("hifi/tablet/TabletGeneralPreferences.qml"), "GeneralPreferencesDialog"); QString("hifi/tablet/TabletGeneralPreferences.qml"), "GeneralPreferencesDialog");
} }
}); });
// Settings > Controls... // Settings > Controls...
action = addActionToQMenuAndActionHash(settingsMenu, "Controls..."); action = addActionToQMenuAndActionHash(settingsMenu, "Controls...");
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system"); auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system");
auto hmd = DependencyManager::get<HMDScriptingInterface>(); auto hmd = DependencyManager::get<HMDScriptingInterface>();
tablet->pushOntoStack("hifi/tablet/ControllerSettings.qml"); tablet->pushOntoStack("hifi/tablet/ControllerSettings.qml");
if (!hmd->getShouldShowTablet()) { if (!hmd->getShouldShowTablet()) {
hmd->toggleShouldShowTablet(); hmd->toggleShouldShowTablet();
} }
}); });
// Settings > Audio... // Settings > Audio...
@ -275,16 +272,30 @@ Menu::Menu() {
} }
}); });
action = addActionToQMenuAndActionHash(editMenu, "Test Permissions");
connect(action, &QAction::triggered, [] {
auto logMessage = [=](QQmlContext* context, QObject* newObject) {
qCDebug(interfaceapp) << "Testing permissions setting";
};
qCDebug(interfaceapp) << "\n\nTesting permissions setting\n\n";
static const QUrl url{ "hifi/Permission.qml" };
DependencyManager::get<OffscreenUi>()->show(url, "AssetServer", logMessage);
});
// Settings > Security... // Settings > Security...
action = addActionToQMenuAndActionHash(settingsMenu, "Security..."); action = addActionToQMenuAndActionHash(settingsMenu, "Security...");
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system"); auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system");
auto hmd = DependencyManager::get<HMDScriptingInterface>(); auto hmd = DependencyManager::get<HMDScriptingInterface>();
tablet->pushOntoStack("hifi/dialogs/security/Security.qml"); tablet->pushOntoStack("hifi/dialogs/security/Security.qml");
if (!hmd->getShouldShowTablet()) { if (!hmd->getShouldShowTablet()) {
hmd->toggleShouldShowTablet(); hmd->toggleShouldShowTablet();
} }
}); });
// Settings > Developer Menu // Settings > Developer Menu
@ -295,28 +306,26 @@ Menu::Menu() {
// Developer menu ---------------------------------- // Developer menu ----------------------------------
MenuWrapper* developerMenu = addMenu("Developer", "Developer"); MenuWrapper* developerMenu = addMenu("Developer", "Developer");
// Developer > Scripting >>> // Developer > Scripting >>>
MenuWrapper* scriptingOptionsMenu = developerMenu->addMenu("Scripting"); MenuWrapper* scriptingOptionsMenu = developerMenu->addMenu("Scripting");
// Developer > Scripting > Console... // Developer > Scripting > Console...
addActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::Console, Qt::CTRL | Qt::ALT | Qt::Key_J, addActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::Console, Qt::CTRL | Qt::ALT | Qt::Key_J,
DependencyManager::get<StandAloneJSConsole>().data(), DependencyManager::get<StandAloneJSConsole>().data(), SLOT(toggleConsole()), QAction::NoRole,
SLOT(toggleConsole()),
QAction::NoRole,
UNSPECIFIED_POSITION); UNSPECIFIED_POSITION);
// Developer > Scripting > API Debugger // Developer > Scripting > API Debugger
action = addActionToQMenuAndActionHash(scriptingOptionsMenu, "API Debugger"); action = addActionToQMenuAndActionHash(scriptingOptionsMenu, "API Debugger");
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
QUrl defaultScriptsLoc = PathUtils::defaultScriptsLocation(); QUrl defaultScriptsLoc = PathUtils::defaultScriptsLocation();
defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/utilities/tools/currentAPI.js"); defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/utilities/tools/currentAPI.js");
DependencyManager::get<ScriptEngines>()->loadScript(defaultScriptsLoc.toString()); DependencyManager::get<ScriptEngines>()->loadScript(defaultScriptsLoc.toString());
}); });
// Developer > Scripting > Entity Script Server Log // Developer > Scripting > Entity Script Server Log
auto essLogAction = addActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::EntityScriptServerLog, 0, auto essLogAction = addActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::EntityScriptServerLog, 0, qApp,
qApp, SLOT(toggleEntityScriptServerLogDialog())); SLOT(toggleEntityScriptServerLogDialog()));
{ {
auto nodeList = DependencyManager::get<NodeList>(); auto nodeList = DependencyManager::get<NodeList>();
QObject::connect(nodeList.data(), &NodeList::canRezChanged, essLogAction, [essLogAction] { QObject::connect(nodeList.data(), &NodeList::canRezChanged, essLogAction, [essLogAction] {
@ -327,56 +336,53 @@ Menu::Menu() {
} }
// Developer > Scripting > Script Log (HMD friendly)... // Developer > Scripting > Script Log (HMD friendly)...
addActionToQMenuAndActionHash(scriptingOptionsMenu, "Script Log (HMD friendly)...", Qt::NoButton, addActionToQMenuAndActionHash(scriptingOptionsMenu, "Script Log (HMD friendly)...", Qt::NoButton, qApp,
qApp, SLOT(showScriptLogs())); SLOT(showScriptLogs()));
// Developer > Scripting > Verbose Logging // Developer > Scripting > Verbose Logging
addCheckableActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::VerboseLogging, 0, false, addCheckableActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::VerboseLogging, 0, false, qApp,
qApp, SLOT(updateVerboseLogging())); SLOT(updateVerboseLogging()));
// Developer > Scripting > Enable Speech Control API // Developer > Scripting > Enable Speech Control API
#if defined(Q_OS_MAC) || defined(Q_OS_WIN) #if defined(Q_OS_MAC) || defined(Q_OS_WIN)
auto speechRecognizer = DependencyManager::get<SpeechRecognizer>(); auto speechRecognizer = DependencyManager::get<SpeechRecognizer>();
QAction* speechRecognizerAction = addCheckableActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::ControlWithSpeech, QAction* speechRecognizerAction =
Qt::CTRL | Qt::SHIFT | Qt::Key_C, addCheckableActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::ControlWithSpeech,
speechRecognizer->getEnabled(), Qt::CTRL | Qt::SHIFT | Qt::Key_C, speechRecognizer->getEnabled(),
speechRecognizer.data(), speechRecognizer.data(), SLOT(setEnabled(bool)), UNSPECIFIED_POSITION);
SLOT(setEnabled(bool)),
UNSPECIFIED_POSITION);
connect(speechRecognizer.data(), SIGNAL(enabledUpdated(bool)), speechRecognizerAction, SLOT(setChecked(bool))); connect(speechRecognizer.data(), SIGNAL(enabledUpdated(bool)), speechRecognizerAction, SLOT(setChecked(bool)));
#endif #endif
// Developer > UI >>> // Developer > UI >>>
MenuWrapper* uiOptionsMenu = developerMenu->addMenu("UI"); MenuWrapper* uiOptionsMenu = developerMenu->addMenu("UI");
action = addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::DesktopTabletToToolbar, 0, action = addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::DesktopTabletToToolbar, 0,
qApp->getDesktopTabletBecomesToolbarSetting()); qApp->getDesktopTabletBecomesToolbarSetting());
// Developer > UI > Show Overlays // Developer > UI > Show Overlays
addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::Overlays, 0, true); addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::Overlays, 0, true);
// Developer > UI > Desktop Tablet Becomes Toolbar // Developer > UI > Desktop Tablet Becomes Toolbar
connect(action, &QAction::triggered, [action] { connect(action, &QAction::triggered, [action] { qApp->setDesktopTabletBecomesToolbarSetting(action->isChecked()); });
qApp->setDesktopTabletBecomesToolbarSetting(action->isChecked());
}); // Developer > UI > HMD Tablet Becomes Toolbar
// Developer > UI > HMD Tablet Becomes Toolbar
action = addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::HMDTabletToToolbar, 0, action = addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::HMDTabletToToolbar, 0,
qApp->getHmdTabletBecomesToolbarSetting()); qApp->getHmdTabletBecomesToolbarSetting());
connect(action, &QAction::triggered, [action] { connect(action, &QAction::triggered, [action] { qApp->setHmdTabletBecomesToolbarSetting(action->isChecked()); });
qApp->setHmdTabletBecomesToolbarSetting(action->isChecked());
});
// Developer > Render >>> // Developer > Render >>>
MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render"); MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render");
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AntiAliasing, 0, RenderScriptingInterface::getInstance()->getAntialiasingEnabled(), addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AntiAliasing, 0,
RenderScriptingInterface::getInstance(), SLOT(setAntialiasingEnabled(bool))); RenderScriptingInterface::getInstance()->getAntialiasingEnabled(),
RenderScriptingInterface::getInstance(), SLOT(setAntialiasingEnabled(bool)));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Shadows, 0, RenderScriptingInterface::getInstance()->getShadowsEnabled(), addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Shadows, 0,
RenderScriptingInterface::getInstance(), SLOT(setShadowsEnabled(bool))); RenderScriptingInterface::getInstance()->getShadowsEnabled(),
RenderScriptingInterface::getInstance(), SLOT(setShadowsEnabled(bool)));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AmbientOcclusion, 0, RenderScriptingInterface::getInstance()->getAmbientOcclusionEnabled(), addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AmbientOcclusion, 0,
RenderScriptingInterface::getInstance(), SLOT(setAmbientOcclusionEnabled(bool))); RenderScriptingInterface::getInstance()->getAmbientOcclusionEnabled(),
RenderScriptingInterface::getInstance(), SLOT(setAmbientOcclusionEnabled(bool)));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::WorldAxes); addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::WorldAxes);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DefaultSkybox, 0, true); addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DefaultSkybox, 0, true);
@ -398,7 +404,8 @@ Menu::Menu() {
MenuWrapper* textureMenu = renderOptionsMenu->addMenu(MenuOption::RenderMaxTextureMemory); MenuWrapper* textureMenu = renderOptionsMenu->addMenu(MenuOption::RenderMaxTextureMemory);
QActionGroup* textureGroup = new QActionGroup(textureMenu); QActionGroup* textureGroup = new QActionGroup(textureMenu);
textureGroup->setExclusive(true); textureGroup->setExclusive(true);
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTextureAutomatic, 0, true)); textureGroup->addAction(
addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTextureAutomatic, 0, true));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture4MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture4MB, 0, false));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture64MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture64MB, 0, false));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture256MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture256MB, 0, false));
@ -411,7 +418,7 @@ Menu::Menu() {
connect(textureGroup, &QActionGroup::triggered, [textureGroup] { connect(textureGroup, &QActionGroup::triggered, [textureGroup] {
auto checked = textureGroup->checkedAction(); auto checked = textureGroup->checkedAction();
auto text = checked->text(); auto text = checked->text();
gpu::Context::Size newMaxTextureMemory { 0 }; gpu::Context::Size newMaxTextureMemory{ 0 };
if (MenuOption::RenderMaxTexture4MB == text) { if (MenuOption::RenderMaxTexture4MB == text) {
newMaxTextureMemory = MB_TO_BYTES(4); newMaxTextureMemory = MB_TO_BYTES(4);
} else if (MenuOption::RenderMaxTexture64MB == text) { } else if (MenuOption::RenderMaxTexture64MB == text) {
@ -437,7 +444,8 @@ Menu::Menu() {
#ifdef Q_OS_WIN #ifdef Q_OS_WIN
// Developer > Render > Enable Sparse Textures // Developer > Render > Enable Sparse Textures
{ {
auto action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::SparseTextureManagement, 0, gpu::Texture::getEnableSparseTextures()); auto action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::SparseTextureManagement, 0,
gpu::Texture::getEnableSparseTextures());
connect(action, &QAction::triggered, [&](bool checked) { connect(action, &QAction::triggered, [&](bool checked) {
qDebug() << "[TEXTURE TRANSFER SUPPORT] --- Enable Dynamic Texture Management menu option:" << checked; qDebug() << "[TEXTURE TRANSFER SUPPORT] --- Enable Dynamic Texture Management menu option:" << checked;
gpu::Texture::setEnableSparseTextures(checked); gpu::Texture::setEnableSparseTextures(checked);
@ -445,36 +453,34 @@ Menu::Menu() {
} }
#else #else
qDebug() << "[TEXTURE TRANSFER SUPPORT] Incremental Texture Transfer and Dynamic Texture Management not supported on this platform."; qDebug() << "[TEXTURE TRANSFER SUPPORT] Incremental Texture Transfer and Dynamic Texture Management not supported on this "
"platform.";
#endif #endif
{ {
auto action = addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::RenderClearKtxCache); auto action = addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::RenderClearKtxCache);
connect(action, &QAction::triggered, []{ connect(action, &QAction::triggered, [] {
Setting::Handle<int>(KTXCache::SETTING_VERSION_NAME, KTXCache::INVALID_VERSION).set(KTXCache::INVALID_VERSION); Setting::Handle<int>(KTXCache::SETTING_VERSION_NAME, KTXCache::INVALID_VERSION).set(KTXCache::INVALID_VERSION);
}); });
} }
// Developer > Render > LOD Tools // Developer > Render > LOD Tools
addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools, 0, addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools, 0, qApp, SLOT(loadLODToolsDialog()));
qApp, SLOT(loadLODToolsDialog()));
// HACK enable texture decimation // HACK enable texture decimation
{ {
auto action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, "Decimate Textures"); auto action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, "Decimate Textures");
connect(action, &QAction::triggered, [&](bool checked) { connect(action, &QAction::triggered, [&](bool checked) { DEV_DECIMATE_TEXTURES = checked; });
DEV_DECIMATE_TEXTURES = checked;
});
} }
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::ComputeBlendshapes, 0, true, addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::ComputeBlendshapes, 0, true,
DependencyManager::get<ModelBlender>().data(), SLOT(setComputeBlendshapes(bool))); DependencyManager::get<ModelBlender>().data(), SLOT(setComputeBlendshapes(bool)));
{ {
auto drawStatusConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<render::DrawStatus>("RenderMainView.DrawStatus"); auto drawStatusConfig =
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::HighlightTransitions, 0, false, qApp->getRenderEngine()->getConfiguration()->getConfig<render::DrawStatus>("RenderMainView.DrawStatus");
drawStatusConfig, SLOT(setShowFade(bool))); addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::HighlightTransitions, 0, false, drawStatusConfig,
SLOT(setShowFade(bool)));
} }
// Developer > Assets >>> // Developer > Assets >>>
@ -485,9 +491,8 @@ Menu::Menu() {
auto& atpMigrator = ATPAssetMigrator::getInstance(); auto& atpMigrator = ATPAssetMigrator::getInstance();
atpMigrator.setDialogParent(this); atpMigrator.setDialogParent(this);
addActionToQMenuAndActionHash(assetDeveloperMenu, MenuOption::AssetMigration, addActionToQMenuAndActionHash(assetDeveloperMenu, MenuOption::AssetMigration, 0, &atpMigrator,
0, &atpMigrator, SLOT(loadEntityServerFile()));
SLOT(loadEntityServerFile()));
#endif #endif
// Developer > Avatar >>> // Developer > Avatar >>>
@ -502,21 +507,21 @@ Menu::Menu() {
#ifdef HAVE_DDE #ifdef HAVE_DDE
defaultNoFaceTracking = false; defaultNoFaceTracking = false;
#endif #endif
QAction* noFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking, QAction* noFaceTracker =
0, defaultNoFaceTracking, addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking, 0, defaultNoFaceTracking, qApp,
qApp, SLOT(setActiveFaceTracker())); SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(noFaceTracker); faceTrackerGroup->addAction(noFaceTracker);
#ifdef HAVE_DDE #ifdef HAVE_DDE
QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera, QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera, 0, true, qApp,
0, true, SLOT(setActiveFaceTracker()));
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(ddeFaceTracker); faceTrackerGroup->addAction(ddeFaceTracker);
#endif #endif
} }
#ifdef HAVE_DDE #ifdef HAVE_DDE
faceTrackingMenu->addSeparator(); faceTrackingMenu->addSeparator();
QAction* binaryEyelidControl = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::BinaryEyelidControl, 0, true); QAction* binaryEyelidControl =
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::BinaryEyelidControl, 0, true);
binaryEyelidControl->setVisible(true); // DDE face tracking is on by default binaryEyelidControl->setVisible(true); // DDE face tracking is on by default
QAction* coupleEyelids = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CoupleEyelids, 0, true); QAction* coupleEyelids = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CoupleEyelids, 0, true);
coupleEyelids->setVisible(true); // DDE face tracking is on by default coupleEyelids->setVisible(true); // DDE face tracking is on by default
@ -525,102 +530,104 @@ Menu::Menu() {
QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::VelocityFilter, 0, true); QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::VelocityFilter, 0, true);
ddeFiltering->setVisible(true); // DDE face tracking is on by default ddeFiltering->setVisible(true); // DDE face tracking is on by default
QAction* ddeCalibrate = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CalibrateCamera, 0, QAction* ddeCalibrate = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CalibrateCamera, 0,
DependencyManager::get<DdeFaceTracker>().data(), SLOT(calibrate())); DependencyManager::get<DdeFaceTracker>().data(), SLOT(calibrate()));
ddeCalibrate->setVisible(true); // DDE face tracking is on by default ddeCalibrate->setVisible(true); // DDE face tracking is on by default
faceTrackingMenu->addSeparator(); faceTrackingMenu->addSeparator();
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking, addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking,
[](bool mute) { FaceTracker::setIsMuted(mute); }, [](bool mute) { FaceTracker::setIsMuted(mute); }, Qt::CTRL | Qt::SHIFT | Qt::Key_F,
Qt::CTRL | Qt::SHIFT | Qt::Key_F, FaceTracker::isMuted()); FaceTracker::isMuted());
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::AutoMuteAudio, 0, false); addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::AutoMuteAudio, 0, false);
#endif #endif
#ifdef HAVE_IVIEWHMD #ifdef HAVE_IVIEWHMD
// Developer > Avatar > Eye Tracking // Developer > Avatar > Eye Tracking
MenuWrapper* eyeTrackingMenu = avatarDebugMenu->addMenu("Eye Tracking"); MenuWrapper* eyeTrackingMenu = avatarDebugMenu->addMenu("Eye Tracking");
addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SMIEyeTracking, 0, false, addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SMIEyeTracking, 0, false, qApp,
qApp, SLOT(setActiveEyeTracker())); SLOT(setActiveEyeTracker()));
{ {
MenuWrapper* calibrateEyeTrackingMenu = eyeTrackingMenu->addMenu("Calibrate"); MenuWrapper* calibrateEyeTrackingMenu = eyeTrackingMenu->addMenu("Calibrate");
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::OnePointCalibration, 0, addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::OnePointCalibration, 0, qApp,
qApp, SLOT(calibrateEyeTracker1Point())); SLOT(calibrateEyeTracker1Point()));
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::ThreePointCalibration, 0, addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::ThreePointCalibration, 0, qApp,
qApp, SLOT(calibrateEyeTracker3Points())); SLOT(calibrateEyeTracker3Points()));
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::FivePointCalibration, 0, addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::FivePointCalibration, 0, qApp,
qApp, SLOT(calibrateEyeTracker5Points())); SLOT(calibrateEyeTracker5Points()));
} }
addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SimulateEyeTracking, 0, false, addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SimulateEyeTracking, 0, false, qApp,
qApp, SLOT(setActiveEyeTracker())); SLOT(setActiveEyeTracker()));
#endif #endif
action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AvatarReceiveStats, 0, false); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AvatarReceiveStats, 0, false);
connect(action, &QAction::triggered, [this]{ Avatar::setShowReceiveStats(isOptionChecked(MenuOption::AvatarReceiveStats)); }); connect(action, &QAction::triggered,
[this] { Avatar::setShowReceiveStats(isOptionChecked(MenuOption::AvatarReceiveStats)); });
action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowBoundingCollisionShapes, 0, false); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowBoundingCollisionShapes, 0, false);
connect(action, &QAction::triggered, [this]{ Avatar::setShowCollisionShapes(isOptionChecked(MenuOption::ShowBoundingCollisionShapes)); }); connect(action, &QAction::triggered,
[this] { Avatar::setShowCollisionShapes(isOptionChecked(MenuOption::ShowBoundingCollisionShapes)); });
action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowMyLookAtVectors, 0, false); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowMyLookAtVectors, 0, false);
connect(action, &QAction::triggered, [this]{ Avatar::setShowMyLookAtVectors(isOptionChecked(MenuOption::ShowMyLookAtVectors)); }); connect(action, &QAction::triggered,
[this] { Avatar::setShowMyLookAtVectors(isOptionChecked(MenuOption::ShowMyLookAtVectors)); });
action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowOtherLookAtVectors, 0, false); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowOtherLookAtVectors, 0, false);
connect(action, &QAction::triggered, [this]{ Avatar::setShowOtherLookAtVectors(isOptionChecked(MenuOption::ShowOtherLookAtVectors)); }); connect(action, &QAction::triggered,
[this] { Avatar::setShowOtherLookAtVectors(isOptionChecked(MenuOption::ShowOtherLookAtVectors)); });
auto avatarManager = DependencyManager::get<AvatarManager>(); auto avatarManager = DependencyManager::get<AvatarManager>();
auto avatar = avatarManager->getMyAvatar(); auto avatar = avatarManager->getMyAvatar();
action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableLookAtSnapping, 0, true); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableLookAtSnapping, 0, true);
connect(action, &QAction::triggered, [this, avatar]{ connect(action, &QAction::triggered, [this, avatar] {
avatar->setProperty("lookAtSnappingEnabled", isOptionChecked(MenuOption::EnableLookAtSnapping)); avatar->setProperty("lookAtSnappingEnabled", isOptionChecked(MenuOption::EnableLookAtSnapping));
}); });
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::FixGaze, 0, false); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::FixGaze, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ToggleHipsFollowing, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ToggleHipsFollowing, 0, false, avatar.get(),
avatar.get(), SLOT(setToggleHips(bool))); SLOT(setToggleHips(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawBaseOfSupport, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawBaseOfSupport, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawBaseOfSupport(bool))); SLOT(setEnableDebugDrawBaseOfSupport(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawDefaultPose, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawDefaultPose, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawDefaultPose(bool))); SLOT(setEnableDebugDrawDefaultPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawAnimPose, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawAnimPose, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawAnimPose(bool))); SLOT(setEnableDebugDrawAnimPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawPosition, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawPosition, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawPosition(bool))); SLOT(setEnableDebugDrawPosition(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawOtherSkeletons, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawOtherSkeletons, 0, false,
avatarManager.data(), SLOT(setEnableDebugDrawOtherSkeletons(bool))); avatarManager.data(), SLOT(setEnableDebugDrawOtherSkeletons(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::MeshVisible, 0, true, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::MeshVisible, 0, true, avatar.get(),
avatar.get(), SLOT(setEnableMeshVisible(bool))); SLOT(setEnableMeshVisible(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::DisableEyelidAdjustment, 0, false); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::DisableEyelidAdjustment, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::TurnWithHead, 0, false); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::TurnWithHead, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableInverseKinematics, 0, true, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableInverseKinematics, 0, true, avatar.get(),
avatar.get(), SLOT(setEnableInverseKinematics(bool))); SLOT(setEnableInverseKinematics(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderSensorToWorldMatrix, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderSensorToWorldMatrix, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawSensorToWorldMatrix(bool))); SLOT(setEnableDebugDrawSensorToWorldMatrix(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKTargets, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKTargets, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawIKTargets(bool))); SLOT(setEnableDebugDrawIKTargets(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKConstraints, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKConstraints, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawIKConstraints(bool))); SLOT(setEnableDebugDrawIKConstraints(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKChains, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKChains, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawIKChains(bool))); SLOT(setEnableDebugDrawIKChains(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderDetailedCollision, 0, false, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderDetailedCollision, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawDetailedCollision(bool))); SLOT(setEnableDebugDrawDetailedCollision(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ActionMotorControl, 0, true, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ActionMotorControl, 0, true, avatar.get(),
avatar.get(), SLOT(updateMotionBehaviorFromMenu()), SLOT(updateMotionBehaviorFromMenu()), UNSPECIFIED_POSITION, "Developer");
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ScriptedMotorControl, 0, true, addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ScriptedMotorControl, 0, true, avatar.get(),
avatar.get(), SLOT(updateMotionBehaviorFromMenu()), SLOT(updateMotionBehaviorFromMenu()), UNSPECIFIED_POSITION, "Developer");
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowTrackedObjects, 0, false, qApp, SLOT(setShowTrackedObjects(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowTrackedObjects, 0, false, qApp,
SLOT(setShowTrackedObjects(bool)));
addActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::PackageModel, 0, qApp, SLOT(packageModel())); addActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::PackageModel, 0, qApp, SLOT(packageModel()));
// Developer > Hands >>> // Developer > Hands >>>
MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands"); MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands");
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false, addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false, avatar.get(),
avatar.get(), SLOT(setEnableDebugDrawHandControllers(bool))); SLOT(setEnableDebugDrawHandControllers(bool)));
// Developer > Entities >>> // Developer > Entities >>>
MenuWrapper* entitiesOptionsMenu = developerMenu->addMenu("Entities"); MenuWrapper* entitiesOptionsMenu = developerMenu->addMenu("Entities");
addActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::OctreeStats, 0, addActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::OctreeStats, 0, qApp, SLOT(loadEntityStatisticsDialog()));
qApp, SLOT(loadEntityStatisticsDialog()));
addCheckableActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::ShowRealtimeEntityStats); addCheckableActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::ShowRealtimeEntityStats);
@ -629,35 +636,30 @@ Menu::Menu() {
action = addActionToQMenuAndActionHash(networkMenu, MenuOption::Networking); action = addActionToQMenuAndActionHash(networkMenu, MenuOption::Networking);
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
qApp->showDialog(QString("hifi/dialogs/NetworkingPreferencesDialog.qml"), qApp->showDialog(QString("hifi/dialogs/NetworkingPreferencesDialog.qml"),
QString("hifi/tablet/TabletNetworkingPreferences.qml"), "NetworkingPreferencesDialog"); QString("hifi/tablet/TabletNetworkingPreferences.qml"), "NetworkingPreferencesDialog");
}); });
addActionToQMenuAndActionHash(networkMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches())); addActionToQMenuAndActionHash(networkMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::ClearDiskCache, 0, addActionToQMenuAndActionHash(networkMenu, MenuOption::ClearDiskCache, 0, DependencyManager::get<AssetClient>().data(),
DependencyManager::get<AssetClient>().data(), SLOT(clearCache())); SLOT(clearCache()));
addCheckableActionToQMenuAndActionHash(networkMenu, addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::DisableActivityLogger, 0, false,
MenuOption::DisableActivityLogger, &UserActivityLogger::getInstance(), SLOT(disable(bool)));
0, addActionToQMenuAndActionHash(networkMenu, MenuOption::ShowDSConnectTable, 0, qApp, SLOT(loadDomainConnectionDialog()));
false,
&UserActivityLogger::getInstance(),
SLOT(disable(bool)));
addActionToQMenuAndActionHash(networkMenu, MenuOption::ShowDSConnectTable, 0,
qApp, SLOT(loadDomainConnectionDialog()));
#if (PR_BUILD || DEV_BUILD) #if (PR_BUILD || DEV_BUILD)
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongProtocolVersion, 0, false, addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongProtocolVersion, 0, false, qApp,
qApp, SLOT(sendWrongProtocolVersionsSignature(bool))); SLOT(sendWrongProtocolVersionsSignature(bool)));
{ {
auto nodeList = DependencyManager::get<NodeList>(); auto nodeList = DependencyManager::get<NodeList>();
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongDSConnectVersion, 0, false, addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongDSConnectVersion, 0, false, nodeList.data(),
nodeList.data(), SLOT(toggleSendNewerDSConnectVersion(bool))); SLOT(toggleSendNewerDSConnectVersion(bool)));
} }
#endif #endif
// Developer >> Tests >>> // Developer >> Tests >>>
MenuWrapper* testMenu = developerMenu->addMenu("Tests"); MenuWrapper* testMenu = developerMenu->addMenu("Tests");
addActionToQMenuAndActionHash(testMenu, MenuOption::RunClientScriptTests, 0, dialogsManager.data(), SLOT(showTestingResults())); addActionToQMenuAndActionHash(testMenu, MenuOption::RunClientScriptTests, 0, dialogsManager.data(),
SLOT(showTestingResults()));
// Developer > Timing >>> // Developer > Timing >>>
MenuWrapper* timingMenu = developerMenu->addMenu("Timing"); MenuWrapper* timingMenu = developerMenu->addMenu("Timing");
@ -678,7 +680,6 @@ Menu::Menu() {
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::LogExtraTimings); addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::LogExtraTimings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings); addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings);
// Developer > Audio >>> // Developer > Audio >>>
MenuWrapper* audioDebugMenu = developerMenu->addMenu("Audio"); MenuWrapper* audioDebugMenu = developerMenu->addMenu("Audio");
@ -691,12 +692,12 @@ Menu::Menu() {
action = addActionToQMenuAndActionHash(audioDebugMenu, "Buffers..."); action = addActionToQMenuAndActionHash(audioDebugMenu, "Buffers...");
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
qApp->showDialog(QString("hifi/dialogs/AudioBuffers.qml"), qApp->showDialog(QString("hifi/dialogs/AudioBuffers.qml"), QString("hifi/tablet/TabletAudioBuffers.qml"),
QString("hifi/tablet/TabletAudioBuffers.qml"), "AudioBuffersDialog"); "AudioBuffersDialog");
}); });
addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteEnvironment, 0, addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteEnvironment, 0, DependencyManager::get<AudioClient>().data(),
DependencyManager::get<AudioClient>().data(), SLOT(sendMuteEnvironmentPacket())); SLOT(sendMuteEnvironmentPacket()));
action = addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioScope); action = addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioScope);
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
@ -708,25 +709,31 @@ Menu::Menu() {
// Developer > Physics >>> // Developer > Physics >>>
MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics"); MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");
{ {
auto drawStatusConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<render::DrawStatus>("RenderMainView.DrawStatus"); auto drawStatusConfig =
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned, qApp->getRenderEngine()->getConfiguration()->getConfig<render::DrawStatus>("RenderMainView.DrawStatus");
0, false, drawStatusConfig, SLOT(setShowNetwork(bool))); addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned, 0, false, drawStatusConfig,
SLOT(setShowNetwork(bool)));
} }
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletWireframe, 0, false, qApp, SLOT(setShowBulletWireframe(bool))); addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletWireframe, 0, false, qApp,
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletAABBs, 0, false, qApp, SLOT(setShowBulletAABBs(bool))); SLOT(setShowBulletWireframe(bool)));
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletContactPoints, 0, false, qApp, SLOT(setShowBulletContactPoints(bool))); addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletAABBs, 0, false, qApp,
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletConstraints, 0, false, qApp, SLOT(setShowBulletConstraints(bool))); SLOT(setShowBulletAABBs(bool)));
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletConstraintLimits, 0, false, qApp, SLOT(setShowBulletConstraintLimits(bool))); addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletContactPoints, 0, false, qApp,
SLOT(setShowBulletContactPoints(bool)));
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletConstraints, 0, false, qApp,
SLOT(setShowBulletConstraints(bool)));
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletConstraintLimits, 0, false, qApp,
SLOT(setShowBulletConstraintLimits(bool)));
// Developer > Picking >>> // Developer > Picking >>>
MenuWrapper* pickingOptionsMenu = developerMenu->addMenu("Picking"); MenuWrapper* pickingOptionsMenu = developerMenu->addMenu("Picking");
addCheckableActionToQMenuAndActionHash(pickingOptionsMenu, MenuOption::ForceCoarsePicking, 0, false, addCheckableActionToQMenuAndActionHash(pickingOptionsMenu, MenuOption::ForceCoarsePicking, 0, false,
DependencyManager::get<PickManager>().data(), SLOT(setForceCoarsePicking(bool))); DependencyManager::get<PickManager>().data(), SLOT(setForceCoarsePicking(bool)));
// Developer > Crash >>> // Developer > Crash >>>
MenuWrapper* crashMenu = developerMenu->addMenu("Crash"); MenuWrapper* crashMenu = developerMenu->addMenu("Crash");
// Developer > Crash > Display Crash Options // Developer > Crash > Display Crash Options
addCheckableActionToQMenuAndActionHash(crashMenu, MenuOption::DisplayCrashOptions, 0, true); addCheckableActionToQMenuAndActionHash(crashMenu, MenuOption::DisplayCrashOptions, 0, true);
@ -770,10 +777,10 @@ Menu::Menu() {
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::AnimStats); addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::AnimStats);
// Developer > Log // Developer > Log
addActionToQMenuAndActionHash(developerMenu, MenuOption::Log, Qt::CTRL | Qt::SHIFT | Qt::Key_L, addActionToQMenuAndActionHash(developerMenu, MenuOption::Log, Qt::CTRL | Qt::SHIFT | Qt::Key_L, qApp,
qApp, SLOT(toggleLogDialog())); SLOT(toggleLogDialog()));
#if 0 /// -------------- REMOVED FOR NOW -------------- #if 0 /// -------------- REMOVED FOR NOW --------------
addDisabledActionAndSeparator(navigateMenu, "History"); addDisabledActionAndSeparator(navigateMenu, "History");
QAction* backAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Back, 0, addressManager.data(), SLOT(goBack())); QAction* backAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Back, 0, addressManager.data(), SLOT(goBack()));
QAction* forwardAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Forward, 0, addressManager.data(), SLOT(goForward())); QAction* forwardAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Forward, 0, addressManager.data(), SLOT(goForward()));
@ -800,33 +807,27 @@ Menu::Menu() {
#endif #endif
// Help/Application menu ---------------------------------- // Help/Application menu ----------------------------------
MenuWrapper * helpMenu = addMenu("Help"); MenuWrapper* helpMenu = addMenu("Help");
// Help > About High Fidelity // Help > About High Fidelity
action = addActionToQMenuAndActionHash(helpMenu, "About High Fidelity"); action = addActionToQMenuAndActionHash(helpMenu, "About High Fidelity");
connect(action, &QAction::triggered, [] { connect(action, &QAction::triggered, [] {
qApp->showDialog(QString("hifi/dialogs/AboutDialog.qml"), qApp->showDialog(QString("hifi/dialogs/AboutDialog.qml"), QString("hifi/dialogs/TabletAboutDialog.qml"), "AboutDialog");
QString("hifi/dialogs/TabletAboutDialog.qml"), "AboutDialog");
}); });
helpMenu->addSeparator(); helpMenu->addSeparator();
// Help > HiFi Docs // Help > HiFi Docs
action = addActionToQMenuAndActionHash(helpMenu, "Online Documentation"); action = addActionToQMenuAndActionHash(helpMenu, "Online Documentation");
connect(action, &QAction::triggered, qApp, [] { connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("https://docs.highfidelity.com/")); });
QDesktopServices::openUrl(QUrl("https://docs.highfidelity.com/"));
});
// Help > HiFi Forum // Help > HiFi Forum
action = addActionToQMenuAndActionHash(helpMenu, "Online Forums"); action = addActionToQMenuAndActionHash(helpMenu, "Online Forums");
connect(action, &QAction::triggered, qApp, [] { connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("https://forums.highfidelity.com/")); });
QDesktopServices::openUrl(QUrl("https://forums.highfidelity.com/"));
});
// Help > Scripting Reference // Help > Scripting Reference
action = addActionToQMenuAndActionHash(helpMenu, "Online Script Reference"); action = addActionToQMenuAndActionHash(helpMenu, "Online Script Reference");
connect(action, &QAction::triggered, qApp, [] { connect(action, &QAction::triggered, qApp,
QDesktopServices::openUrl(QUrl("https://docs.highfidelity.com/api-reference")); [] { QDesktopServices::openUrl(QUrl("https://docs.highfidelity.com/api-reference")); });
});
addActionToQMenuAndActionHash(helpMenu, "Controls Reference", 0, qApp, SLOT(showHelp())); addActionToQMenuAndActionHash(helpMenu, "Controls Reference", 0, qApp, SLOT(showHelp()));
@ -834,15 +835,12 @@ Menu::Menu() {
// Help > Release Notes // Help > Release Notes
action = addActionToQMenuAndActionHash(helpMenu, "Release Notes"); action = addActionToQMenuAndActionHash(helpMenu, "Release Notes");
connect(action, &QAction::triggered, qApp, [] { connect(action, &QAction::triggered, qApp,
QDesktopServices::openUrl(QUrl("http://steamcommunity.com/games/390540/announcements/")); [] { QDesktopServices::openUrl(QUrl("http://steamcommunity.com/games/390540/announcements/")); });
});
// Help > Report a Bug! // Help > Report a Bug!
action = addActionToQMenuAndActionHash(helpMenu, "Report a Bug!"); action = addActionToQMenuAndActionHash(helpMenu, "Report a Bug!");
connect(action, &QAction::triggered, qApp, [] { connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("mailto:support@highfidelity.com")); });
QDesktopServices::openUrl(QUrl("mailto:support@highfidelity.com"));
});
} }
void Menu::addMenuItem(const MenuItemProperties& properties) { void Menu::addMenuItem(const MenuItemProperties& properties) {
@ -872,10 +870,10 @@ void Menu::addMenuItem(const MenuItemProperties& properties) {
if (properties.isSeparator) { if (properties.isSeparator) {
addDisabledActionAndSeparator(menuObj, properties.menuItemName, requestedPosition, properties.grouping); addDisabledActionAndSeparator(menuObj, properties.menuItemName, requestedPosition, properties.grouping);
} else if (properties.isCheckable) { } else if (properties.isCheckable) {
menuItemAction = addCheckableActionToQMenuAndActionHash(menuObj, properties.menuItemName, menuItemAction =
properties.shortcutKeySequence, properties.isChecked, addCheckableActionToQMenuAndActionHash(menuObj, properties.menuItemName, properties.shortcutKeySequence,
MenuScriptingInterface::getInstance(), SLOT(menuItemTriggered()), properties.isChecked, MenuScriptingInterface::getInstance(),
requestedPosition, properties.grouping); SLOT(menuItemTriggered()), requestedPosition, properties.grouping);
} else { } else {
menuItemAction = addActionToQMenuAndActionHash(menuObj, properties.menuItemName, properties.shortcutKeySequence, menuItemAction = addActionToQMenuAndActionHash(menuObj, properties.menuItemName, properties.shortcutKeySequence,
MenuScriptingInterface::getInstance(), SLOT(menuItemTriggered()), MenuScriptingInterface::getInstance(), SLOT(menuItemTriggered()),

400
interface/src/Menu.h
View file

@ -26,204 +26,204 @@ public:
}; };
namespace MenuOption { namespace MenuOption {
const QString AddRemoveFriends = "Add/Remove Friends..."; const QString AddRemoveFriends = "Add/Remove Friends...";
const QString AddressBar = "Show Address Bar"; const QString AddressBar = "Show Address Bar";
const QString Animations = "Animations..."; const QString Animations = "Animations...";
const QString AnimDebugDrawAnimPose = "Debug Draw Animation"; const QString AnimDebugDrawAnimPose = "Debug Draw Animation";
const QString AnimDebugDrawBaseOfSupport = "Debug Draw Base of Support"; const QString AnimDebugDrawBaseOfSupport = "Debug Draw Base of Support";
const QString AnimDebugDrawDefaultPose = "Debug Draw Default Pose"; const QString AnimDebugDrawDefaultPose = "Debug Draw Default Pose";
const QString AnimDebugDrawPosition= "Debug Draw Position"; const QString AnimDebugDrawPosition = "Debug Draw Position";
const QString AnimDebugDrawOtherSkeletons = "Debug Draw Other Skeletons"; const QString AnimDebugDrawOtherSkeletons = "Debug Draw Other Skeletons";
const QString AskToResetSettings = "Ask To Reset Settings on Start"; const QString AskToResetSettings = "Ask To Reset Settings on Start";
const QString AssetMigration = "ATP Asset Migration"; const QString AssetMigration = "ATP Asset Migration";
const QString AssetServer = "Asset Browser"; const QString AssetServer = "Asset Browser";
const QString AudioScope = "Show Scope"; const QString AudioScope = "Show Scope";
const QString AudioScopeFiftyFrames = "Fifty"; const QString AudioScopeFiftyFrames = "Fifty";
const QString AudioScopeFiveFrames = "Five"; const QString AudioScopeFiveFrames = "Five";
const QString AudioScopeFrames = "Display Frames"; const QString AudioScopeFrames = "Display Frames";
const QString AudioScopePause = "Pause Scope"; const QString AudioScopePause = "Pause Scope";
const QString AudioScopeTwentyFrames = "Twenty"; const QString AudioScopeTwentyFrames = "Twenty";
const QString AudioStatsShowInjectedStreams = "Audio Stats Show Injected Streams"; const QString AudioStatsShowInjectedStreams = "Audio Stats Show Injected Streams";
const QString AutoMuteAudio = "Auto Mute Microphone"; const QString AutoMuteAudio = "Auto Mute Microphone";
const QString AvatarReceiveStats = "Show Receive Stats"; const QString AvatarReceiveStats = "Show Receive Stats";
const QString AvatarBookmarks = "Avatar Bookmarks"; const QString AvatarBookmarks = "Avatar Bookmarks";
const QString AvatarPackager = "Avatar Packager"; const QString AvatarPackager = "Avatar Packager";
const QString Back = "Back"; const QString Back = "Back";
const QString BinaryEyelidControl = "Binary Eyelid Control"; const QString BinaryEyelidControl = "Binary Eyelid Control";
const QString BookmarkAvatar = "Bookmark Avatar"; const QString BookmarkAvatar = "Bookmark Avatar";
const QString BookmarkAvatarEntities = "Bookmark Avatar Entities"; const QString BookmarkAvatarEntities = "Bookmark Avatar Entities";
const QString BookmarkLocation = "Bookmark Location"; const QString BookmarkLocation = "Bookmark Location";
const QString CalibrateCamera = "Calibrate Camera"; const QString CalibrateCamera = "Calibrate Camera";
const QString CenterPlayerInView = "Center Player In View"; const QString CenterPlayerInView = "Center Player In View";
const QString Chat = "Chat..."; const QString Chat = "Chat...";
const QString ClearDiskCache = "Clear Disk Cache"; const QString ClearDiskCache = "Clear Disk Cache";
const QString Collisions = "Collisions"; const QString Collisions = "Collisions";
const QString Connexion = "Activate 3D Connexion Devices"; const QString Connexion = "Activate 3D Connexion Devices";
const QString Console = "Console..."; const QString Console = "Console...";
const QString ControlWithSpeech = "Enable Speech Control API"; const QString ControlWithSpeech = "Enable Speech Control API";
const QString CopyAddress = "Copy Address to Clipboard"; const QString CopyAddress = "Copy Address to Clipboard";
const QString CopyPath = "Copy Path to Clipboard"; const QString CopyPath = "Copy Path to Clipboard";
const QString CoupleEyelids = "Couple Eyelids"; const QString CoupleEyelids = "Couple Eyelids";
const QString CrashPureVirtualFunction = "Pure Virtual Function Call"; const QString CrashPureVirtualFunction = "Pure Virtual Function Call";
const QString CrashPureVirtualFunctionThreaded = "Pure Virtual Function Call (threaded)"; const QString CrashPureVirtualFunctionThreaded = "Pure Virtual Function Call (threaded)";
const QString CrashDoubleFree = "Double Free"; const QString CrashDoubleFree = "Double Free";
const QString CrashDoubleFreeThreaded = "Double Free (threaded)"; const QString CrashDoubleFreeThreaded = "Double Free (threaded)";
const QString CrashNullDereference = "Null Dereference"; const QString CrashNullDereference = "Null Dereference";
const QString CrashNullDereferenceThreaded = "Null Dereference (threaded)"; const QString CrashNullDereferenceThreaded = "Null Dereference (threaded)";
const QString CrashAbort = "Abort"; const QString CrashAbort = "Abort";
const QString CrashAbortThreaded = "Abort (threaded)"; const QString CrashAbortThreaded = "Abort (threaded)";
const QString CrashOutOfBoundsVectorAccess = "Out of Bounds Vector Access"; const QString CrashOutOfBoundsVectorAccess = "Out of Bounds Vector Access";
const QString CrashOutOfBoundsVectorAccessThreaded = "Out of Bounds Vector Access (threaded)"; const QString CrashOutOfBoundsVectorAccessThreaded = "Out of Bounds Vector Access (threaded)";
const QString CrashNewFault = "New Fault"; const QString CrashNewFault = "New Fault";
const QString CrashNewFaultThreaded = "New Fault (threaded)"; const QString CrashNewFaultThreaded = "New Fault (threaded)";
const QString CreateEntitiesGrabbable = "Create Entities As Grabbable (except Zones, Particles, and Lights)"; const QString CreateEntitiesGrabbable = "Create Entities As Grabbable (except Zones, Particles, and Lights)";
const QString DeadlockInterface = "Deadlock Interface"; const QString DeadlockInterface = "Deadlock Interface";
const QString UnresponsiveInterface = "Unresponsive Interface"; const QString UnresponsiveInterface = "Unresponsive Interface";
const QString DecreaseAvatarSize = "Decrease Avatar Size"; const QString DecreaseAvatarSize = "Decrease Avatar Size";
const QString DefaultSkybox = "Default Skybox"; const QString DefaultSkybox = "Default Skybox";
const QString DeleteAvatarBookmark = "Delete Avatar Bookmark..."; const QString DeleteAvatarBookmark = "Delete Avatar Bookmark...";
const QString DeleteAvatarEntitiesBookmark = "Delete Avatar Entities Bookmark"; const QString DeleteAvatarEntitiesBookmark = "Delete Avatar Entities Bookmark";
const QString DeleteBookmark = "Delete Bookmark..."; const QString DeleteBookmark = "Delete Bookmark...";
const QString DisableActivityLogger = "Disable Activity Logger"; const QString DisableActivityLogger = "Disable Activity Logger";
const QString DisableEyelidAdjustment = "Disable Eyelid Adjustment"; const QString DisableEyelidAdjustment = "Disable Eyelid Adjustment";
const QString DisableLightEntities = "Disable Light Entities"; const QString DisableLightEntities = "Disable Light Entities";
const QString DisplayCrashOptions = "Display Crash Options"; const QString DisplayCrashOptions = "Display Crash Options";
const QString DisplayHandTargets = "Show Hand Targets"; const QString DisplayHandTargets = "Show Hand Targets";
const QString DisplayModelBounds = "Display Model Bounds"; const QString DisplayModelBounds = "Display Model Bounds";
const QString DisplayModelTriangles = "Display Model Triangles"; const QString DisplayModelTriangles = "Display Model Triangles";
const QString DisplayModelElementChildProxies = "Display Model Element Children"; const QString DisplayModelElementChildProxies = "Display Model Element Children";
const QString DisplayModelElementProxy = "Display Model Element Bounds"; const QString DisplayModelElementProxy = "Display Model Element Bounds";
const QString DisplayDebugTimingDetails = "Display Timing Details"; const QString DisplayDebugTimingDetails = "Display Timing Details";
const QString LocationBookmarks = "Bookmarks"; const QString LocationBookmarks = "Bookmarks";
const QString DontDoPrecisionPicking = "Don't Do Precision Picking"; const QString DontDoPrecisionPicking = "Don't Do Precision Picking";
const QString DontRenderEntitiesAsScene = "Don't Render Entities as Scene"; const QString DontRenderEntitiesAsScene = "Don't Render Entities as Scene";
const QString EchoLocalAudio = "Echo Local Audio"; const QString EchoLocalAudio = "Echo Local Audio";
const QString EchoServerAudio = "Echo Server Audio"; const QString EchoServerAudio = "Echo Server Audio";
const QString EnableFlying = "Enable Flying"; const QString EnableFlying = "Enable Flying";
const QString EnableAvatarCollisions = "Enable Avatar Collisions"; const QString EnableAvatarCollisions = "Enable Avatar Collisions";
const QString EnableInverseKinematics = "Enable Inverse Kinematics"; const QString EnableInverseKinematics = "Enable Inverse Kinematics";
const QString EntityScriptServerLog = "Entity Script Server Log"; const QString EntityScriptServerLog = "Entity Script Server Log";
const QString ExpandMyAvatarSimulateTiming = "Expand /myAvatar/simulation"; const QString ExpandMyAvatarSimulateTiming = "Expand /myAvatar/simulation";
const QString ExpandMyAvatarTiming = "Expand /myAvatar"; const QString ExpandMyAvatarTiming = "Expand /myAvatar";
const QString ExpandOtherAvatarTiming = "Expand /otherAvatar"; const QString ExpandOtherAvatarTiming = "Expand /otherAvatar";
const QString ExpandPaintGLTiming = "Expand /paintGL"; const QString ExpandPaintGLTiming = "Expand /paintGL";
const QString ExpandSimulationTiming = "Expand /simulation"; const QString ExpandSimulationTiming = "Expand /simulation";
const QString ExpandPhysicsTiming = "Expand /physics"; const QString ExpandPhysicsTiming = "Expand /physics";
const QString ExpandUpdateTiming = "Expand /update"; const QString ExpandUpdateTiming = "Expand /update";
const QString FirstPerson = "First Person"; const QString FirstPerson = "First Person";
const QString FirstPersonHMD = "Enter First Person Mode in HMD"; const QString FirstPersonHMD = "Enter First Person Mode in HMD";
const QString FivePointCalibration = "5 Point Calibration"; const QString FivePointCalibration = "5 Point Calibration";
const QString FixGaze = "Fix Gaze (no saccade)"; const QString FixGaze = "Fix Gaze (no saccade)";
const QString Forward = "Forward"; const QString Forward = "Forward";
const QString FrameTimer = "Show Timer"; const QString FrameTimer = "Show Timer";
const QString FullscreenMirror = "Mirror"; const QString FullscreenMirror = "Mirror";
const QString Help = "Help..."; const QString Help = "Help...";
const QString HomeLocation = "Home "; const QString HomeLocation = "Home ";
const QString IncreaseAvatarSize = "Increase Avatar Size"; const QString IncreaseAvatarSize = "Increase Avatar Size";
const QString ActionMotorControl = "Enable Default Motor Control"; const QString ActionMotorControl = "Enable Default Motor Control";
const QString LastLocation = "Last Location"; const QString LastLocation = "Last Location";
const QString LoadScript = "Open and Run Script File..."; const QString LoadScript = "Open and Run Script File...";
const QString LoadScriptURL = "Open and Run Script from URL..."; const QString LoadScriptURL = "Open and Run Script from URL...";
const QString LodTools = "LOD Tools"; const QString LodTools = "LOD Tools";
const QString Login = "Login/Sign Up"; const QString Login = "Login/Sign Up";
const QString Log = "Log"; const QString Log = "Log";
const QString LogExtraTimings = "Log Extra Timing Details"; const QString LogExtraTimings = "Log Extra Timing Details";
const QString LowVelocityFilter = "Low Velocity Filter"; const QString LowVelocityFilter = "Low Velocity Filter";
const QString MeshVisible = "Draw Mesh"; const QString MeshVisible = "Draw Mesh";
const QString MuteEnvironment = "Mute Environment"; const QString MuteEnvironment = "Mute Environment";
const QString MuteFaceTracking = "Mute Face Tracking"; const QString MuteFaceTracking = "Mute Face Tracking";
const QString NamesAboveHeads = "Names Above Heads"; const QString NamesAboveHeads = "Names Above Heads";
const QString Networking = "Networking..."; const QString Networking = "Networking...";
const QString NoFaceTracking = "None"; const QString NoFaceTracking = "None";
const QString OctreeStats = "Entity Statistics"; const QString OctreeStats = "Entity Statistics";
const QString OnePointCalibration = "1 Point Calibration"; const QString OnePointCalibration = "1 Point Calibration";
const QString OnlyDisplayTopTen = "Only Display Top Ten"; const QString OnlyDisplayTopTen = "Only Display Top Ten";
const QString OpenVrThreadedSubmit = "OpenVR Threaded Submit"; const QString OpenVrThreadedSubmit = "OpenVR Threaded Submit";
const QString OutputMenu = "Display"; const QString OutputMenu = "Display";
const QString Overlays = "Show Overlays"; const QString Overlays = "Show Overlays";
const QString PackageModel = "Package Avatar as .fst..."; const QString PackageModel = "Package Avatar as .fst...";
const QString Pair = "Pair"; const QString Pair = "Pair";
const QString PhysicsShowOwned = "Highlight Simulation Ownership"; const QString PhysicsShowOwned = "Highlight Simulation Ownership";
const QString VerboseLogging = "Verbose Logging"; const QString VerboseLogging = "Verbose Logging";
const QString PhysicsShowBulletWireframe = "Show Bullet Collision"; const QString PhysicsShowBulletWireframe = "Show Bullet Collision";
const QString PhysicsShowBulletAABBs = "Show Bullet Bounding Boxes"; const QString PhysicsShowBulletAABBs = "Show Bullet Bounding Boxes";
const QString PhysicsShowBulletContactPoints = "Show Bullet Contact Points"; const QString PhysicsShowBulletContactPoints = "Show Bullet Contact Points";
const QString PhysicsShowBulletConstraints = "Show Bullet Constraints"; const QString PhysicsShowBulletConstraints = "Show Bullet Constraints";
const QString PhysicsShowBulletConstraintLimits = "Show Bullet Constraint Limits"; const QString PhysicsShowBulletConstraintLimits = "Show Bullet Constraint Limits";
const QString PipelineWarnings = "Log Render Pipeline Warnings"; const QString PipelineWarnings = "Log Render Pipeline Warnings";
const QString Preferences = "General..."; const QString Preferences = "General...";
const QString Quit = "Quit"; const QString Quit = "Quit";
const QString ReloadAllScripts = "Reload All Scripts"; const QString ReloadAllScripts = "Reload All Scripts";
const QString ReloadContent = "Reload Content (Clears all caches)"; const QString ReloadContent = "Reload Content (Clears all caches)";
const QString RenderClearKtxCache = "Clear KTX Cache (requires restart)"; const QString RenderClearKtxCache = "Clear KTX Cache (requires restart)";
const QString RenderMaxTextureMemory = "Maximum Texture Memory"; const QString RenderMaxTextureMemory = "Maximum Texture Memory";
const QString RenderMaxTextureAutomatic = "Automatic Texture Memory"; const QString RenderMaxTextureAutomatic = "Automatic Texture Memory";
const QString RenderMaxTexture4MB = "4 MB"; const QString RenderMaxTexture4MB = "4 MB";
const QString RenderMaxTexture64MB = "64 MB"; const QString RenderMaxTexture64MB = "64 MB";
const QString RenderMaxTexture256MB = "256 MB"; const QString RenderMaxTexture256MB = "256 MB";
const QString RenderMaxTexture512MB = "512 MB"; const QString RenderMaxTexture512MB = "512 MB";
const QString RenderMaxTexture1024MB = "1024 MB"; const QString RenderMaxTexture1024MB = "1024 MB";
const QString RenderMaxTexture2048MB = "2048 MB"; const QString RenderMaxTexture2048MB = "2048 MB";
const QString RenderMaxTexture3072MB = "3072 MB"; const QString RenderMaxTexture3072MB = "3072 MB";
const QString RenderMaxTexture4096MB = "4096 MB"; const QString RenderMaxTexture4096MB = "4096 MB";
const QString RenderMaxTexture6144MB = "6144 MB"; const QString RenderMaxTexture6144MB = "6144 MB";
const QString RenderMaxTexture8192MB = "8192 MB"; const QString RenderMaxTexture8192MB = "8192 MB";
const QString RenderSensorToWorldMatrix = "Show SensorToWorld Matrix"; const QString RenderSensorToWorldMatrix = "Show SensorToWorld Matrix";
const QString RenderIKTargets = "Show IK Targets"; const QString RenderIKTargets = "Show IK Targets";
const QString RenderIKConstraints = "Show IK Constraints"; const QString RenderIKConstraints = "Show IK Constraints";
const QString RenderIKChains = "Show IK Chains"; const QString RenderIKChains = "Show IK Chains";
const QString RenderDetailedCollision = "Show Detailed Collision"; const QString RenderDetailedCollision = "Show Detailed Collision";
const QString ResetAvatarSize = "Reset Avatar Size"; const QString ResetAvatarSize = "Reset Avatar Size";
const QString ResetSensors = "Reset Sensors"; const QString ResetSensors = "Reset Sensors";
const QString RunningScripts = "Running Scripts..."; const QString RunningScripts = "Running Scripts...";
const QString RunClientScriptTests = "Run Client Script Tests"; const QString RunClientScriptTests = "Run Client Script Tests";
const QString RunTimingTests = "Run Timing Tests"; const QString RunTimingTests = "Run Timing Tests";
const QString ScriptedMotorControl = "Enable Scripted Motor Control"; const QString ScriptedMotorControl = "Enable Scripted Motor Control";
const QString ShowTrackedObjects = "Show Tracked Objects"; const QString ShowTrackedObjects = "Show Tracked Objects";
const QString SendWrongDSConnectVersion = "Send wrong DS connect version"; const QString SendWrongDSConnectVersion = "Send wrong DS connect version";
const QString SendWrongProtocolVersion = "Send wrong protocol version"; const QString SendWrongProtocolVersion = "Send wrong protocol version";
const QString SetHomeLocation = "Set Home Location"; const QString SetHomeLocation = "Set Home Location";
const QString ShowBordersEntityNodes = "Show Entity Nodes"; const QString ShowBordersEntityNodes = "Show Entity Nodes";
const QString ShowBoundingCollisionShapes = "Show Bounding Collision Shapes"; const QString ShowBoundingCollisionShapes = "Show Bounding Collision Shapes";
const QString ShowDSConnectTable = "Show Domain Connection Timing"; const QString ShowDSConnectTable = "Show Domain Connection Timing";
const QString ShowMyLookAtVectors = "Show My Eye Vectors"; const QString ShowMyLookAtVectors = "Show My Eye Vectors";
const QString ShowOtherLookAtVectors = "Show Other Eye Vectors"; const QString ShowOtherLookAtVectors = "Show Other Eye Vectors";
const QString EnableLookAtSnapping = "Enable LookAt Snapping"; const QString EnableLookAtSnapping = "Enable LookAt Snapping";
const QString ShowRealtimeEntityStats = "Show Realtime Entity Stats"; const QString ShowRealtimeEntityStats = "Show Realtime Entity Stats";
const QString SimulateEyeTracking = "Simulate"; const QString SimulateEyeTracking = "Simulate";
const QString SMIEyeTracking = "SMI Eye Tracking"; const QString SMIEyeTracking = "SMI Eye Tracking";
const QString SparseTextureManagement = "Enable Sparse Texture Management"; const QString SparseTextureManagement = "Enable Sparse Texture Management";
const QString StartUpLocation = "Start-Up Location"; const QString StartUpLocation = "Start-Up Location";
const QString Stats = "Show Statistics"; const QString Stats = "Show Statistics";
const QString AnimStats = "Show Animation Stats"; const QString AnimStats = "Show Animation Stats";
const QString StopAllScripts = "Stop All Scripts"; const QString StopAllScripts = "Stop All Scripts";
const QString SuppressShortTimings = "Suppress Timings Less than 10ms"; const QString SuppressShortTimings = "Suppress Timings Less than 10ms";
const QString ThirdPerson = "Third Person"; const QString ThirdPerson = "Third Person";
const QString ThreePointCalibration = "3 Point Calibration"; const QString ThreePointCalibration = "3 Point Calibration";
const QString ThrottleFPSIfNotFocus = "Throttle FPS If Not Focus"; // FIXME - this value duplicated in Basic2DWindowOpenGLDisplayPlugin.cpp const QString ThrottleFPSIfNotFocus =
const QString ToggleHipsFollowing = "Toggle Hips Following"; "Throttle FPS If Not Focus"; // FIXME - this value duplicated in Basic2DWindowOpenGLDisplayPlugin.cpp
const QString ToolWindow = "Tool Window"; const QString ToggleHipsFollowing = "Toggle Hips Following";
const QString TransmitterDrive = "Transmitter Drive"; const QString ToolWindow = "Tool Window";
const QString TurnWithHead = "Turn using Head"; const QString TransmitterDrive = "Transmitter Drive";
const QString UseAudioForMouth = "Use Audio for Mouth"; const QString TurnWithHead = "Turn using Head";
const QString UseCamera = "Use Camera"; const QString UseAudioForMouth = "Use Audio for Mouth";
const QString VelocityFilter = "Velocity Filter"; const QString UseCamera = "Use Camera";
const QString VisibleToEveryone = "Everyone"; const QString VelocityFilter = "Velocity Filter";
const QString VisibleToFriends = "Friends"; const QString VisibleToEveryone = "Everyone";
const QString VisibleToNoOne = "No one"; const QString VisibleToFriends = "Friends";
const QString WorldAxes = "World Axes"; const QString VisibleToNoOne = "No one";
const QString DesktopTabletToToolbar = "Desktop Tablet Becomes Toolbar"; const QString WorldAxes = "World Axes";
const QString HMDTabletToToolbar = "HMD Tablet Becomes Toolbar"; const QString DesktopTabletToToolbar = "Desktop Tablet Becomes Toolbar";
const QString Shadows = "Shadows"; const QString HMDTabletToToolbar = "HMD Tablet Becomes Toolbar";
const QString AntiAliasing = "Temporal Antialiasing (FXAA if disabled)"; const QString Shadows = "Shadows";
const QString AmbientOcclusion = "Ambient Occlusion"; const QString AntiAliasing = "Temporal Antialiasing (FXAA if disabled)";
const QString NotificationSounds = "play_notification_sounds"; const QString AmbientOcclusion = "Ambient Occlusion";
const QString NotificationSoundsSnapshot = "play_notification_sounds_snapshot"; const QString NotificationSounds = "play_notification_sounds";
const QString NotificationSoundsTablet = "play_notification_sounds_tablet"; const QString NotificationSoundsSnapshot = "play_notification_sounds_snapshot";
const QString ForceCoarsePicking = "Force Coarse Picking"; const QString NotificationSoundsTablet = "play_notification_sounds_tablet";
const QString ComputeBlendshapes = "Compute Blendshapes"; const QString ForceCoarsePicking = "Force Coarse Picking";
const QString HighlightTransitions = "Highlight Transitions"; const QString ComputeBlendshapes = "Compute Blendshapes";
} const QString HighlightTransitions = "Highlight Transitions";
} // namespace MenuOption
#endif // hifi_Menu_h
#endif // hifi_Menu_h

30
scripts/simplifiedUI/ui/simplifiedUI.js
View file

@ -222,6 +222,36 @@ function onEmoteAppBarClosed() {
emoteAppBarWindow = false; emoteAppBarWindow = false;
} }
var PERMISSION_QML_PATH = Script.resourcesPath() + "qml/hifi/Permission.qml";
var PERMISSION_WINDOW_TITLE = "Permissions";
var PERMISSION_WINDOW_PRESENTATION_MODE = Desktop.PresentationMode.NATIVE;
var PERMISSION_WINDOW_WIDTH_PX = 600;
var PERMISSION_WINDOW_HEIGHT_PX = 200;
var PERMISSION_WINDOW_FLAGS =
0x00000001 | // Qt::Window
0x00000800 | // Qt::FramelessWindowHint
0x40000000 | // Qt::NoDropShadowWindowHint
0x00200000; // Qt::WindowDoesNotAcceptFocus
var PERMISSION_WINDOW_LEFT_MARGIN = 600;
var PERMISSION_WINDOW_BOTTOM_MARGIN = 200;
var permissionWindow = false;
function showPermissionsWindow() {
permissionWindow = Desktop.createWindow(PERMISSION_QML_PATH, {
title: PERMISSION_WINDOW_TITLE,
presentationMode: PERMISSION_WINDOW_PRESENTATION_MODE,
size: {
x: PERMISSION_WINDOW_WIDTH_PX,
y: PERMISSION_WINDOW_HEIGHT_PX
},
position: {
x: Window.x + PERMISSION_WINDOW_LEFT_MARGIN,
y: Window.y + Window.innerHeight - PERMISSION_WINDOW_BOTTOM_MARGIN
},
overrideFlags: PERMISSION_WINDOW_FLAGS
});
// emoteAppBarWindow.fromQml.connect(onMessageFromEmoteAppBar);
// emoteAppBarWindow.closed.connect(onEmoteAppBarClosed);
}
var EMOTE_APP_BAR_QML_PATH = Script.resourcesPath() + "qml/hifi/simplifiedUI/emoteApp/bar/EmoteAppBar.qml"; var EMOTE_APP_BAR_QML_PATH = Script.resourcesPath() + "qml/hifi/simplifiedUI/emoteApp/bar/EmoteAppBar.qml";
var EMOTE_APP_BAR_WINDOW_TITLE = "Emote"; var EMOTE_APP_BAR_WINDOW_TITLE = "Emote";