Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-12 13:14:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Still working on menus

Browse source
This commit is contained in:
Brad Davis 2015-04-23 23:41:09 -07:00
parent d68d13489d
commit 1d316a1872
5 changed files with 334 additions and 327 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
interface/src/Bookmarks.cpp
View file

@ -87,11 +87,11 @@ void Bookmarks::persistToFile() {
void Bookmarks::setupMenus(const QString & parentMenu) { void Bookmarks::setupMenus(const QString & parentMenu) {
// Add menus/actions // Add menus/actions
Menu * menu = Menu::getInstance(); Menu * menu = Menu::getInstance();
menu->addMenuItem(parentMenu, MenuOption::BookmarkLocation, [this] { menu->addItem(parentMenu, MenuOption::BookmarkLocation, [this] {
bookmarkLocation(); bookmarkLocation();
}); });
menu->addMenu(parentMenu, MenuOption::Bookmarks); menu->addMenu(parentMenu, MenuOption::Bookmarks);
menu->addMenuItem(parentMenu, MenuOption::DeleteBookmark, [this] { menu->addItem(parentMenu, MenuOption::DeleteBookmark, [this] {
deleteBookmark(); deleteBookmark();
}); });
@ -178,19 +178,19 @@ void Bookmarks::deleteBookmark() {
void Bookmarks::enableMenuItems(bool enabled) { void Bookmarks::enableMenuItems(bool enabled) {
Menu* menu = Menu::getInstance(); Menu* menu = Menu::getInstance();
menu->enableMenuItem(MenuOption::Bookmarks, enabled); menu->enableItem(MenuOption::Bookmarks, enabled);
menu->enableMenuItem(MenuOption::DeleteBookmark, enabled); menu->enableItem(MenuOption::DeleteBookmark, enabled);
} }
void Bookmarks::addLocationToMenu(QString& name, QString& address) { void Bookmarks::addLocationToMenu(QString& name, QString& address) {
Menu::getInstance()->addMenuItem(MenuOption::Bookmarks, name, [=] { Menu::getInstance()->addItem(MenuOption::Bookmarks, name, [=] {
DependencyManager::get<AddressManager>()->handleLookupString(address); DependencyManager::get<AddressManager>()->handleLookupString(address);
}); });
} }
void Bookmarks::removeLocationFromMenu(QString& name) { void Bookmarks::removeLocationFromMenu(QString& name) {
Menu::getInstance()->removeMenuItem(name); Menu::getInstance()->removeItem(name);
} }

535
interface/src/Menu.cpp
View file

@ -42,6 +42,7 @@
#include "InterfaceLogging.h" #include "InterfaceLogging.h"
#include "Menu.h" #include "Menu.h"
#include "Util.h"
// Proxy object to simplify porting over // Proxy object to simplify porting over
HifiAction::HifiAction(const QString & menuOption) : _menuOption(menuOption) { HifiAction::HifiAction(const QString & menuOption) : _menuOption(menuOption) {
@ -57,28 +58,15 @@ void HifiAction::setChecked(bool checked) {
} }
void HifiAction::setVisible(bool visible) { void HifiAction::setVisible(bool visible) {
QObject* result = Menu::getInstance()->findMenuObject(_menuOption); return Menu::getInstance()->setItemVisible(_menuOption);
if (result) {
result->setProperty("visible", visible);
}
} }
const QString & HifiAction::shortcut() const { QString HifiAction::shortcut() const {
static const QString NONE; return Menu::getInstance()->getItemShortcut(_menuOption);
QObject* result = Menu::getInstance()->findMenuObject(_menuOption);
if (!result) {
return NONE;
}
QObject* shortcut = result->property("shortcut").value<QObject*>();
if (!shortcut) {
return NONE;
}
shortcut->dumpObjectInfo();
return NONE;
} }
void HifiAction::setText(const QString & text) { void HifiAction::setText(const QString & text) {
Menu::getInstance()->setText(_menuOption, text); Menu::getInstance()->setItemText(_menuOption, text);
} }
void HifiAction::setTriggerAction(std::function<void()> f) { void HifiAction::setTriggerAction(std::function<void()> f) {
@ -116,7 +104,6 @@ Menu* Menu::getInstance() {
Menu::Menu(QQuickItem * parent) : HifiMenu(parent) { Menu::Menu(QQuickItem * parent) : HifiMenu(parent) {
} }
void Menu::init() { void Menu::init() {
auto dialogsManager = DependencyManager::get<DialogsManager>(); auto dialogsManager = DependencyManager::get<DialogsManager>();
AccountManager& accountManager = AccountManager::getInstance(); AccountManager& accountManager = AccountManager::getInstance();
@ -125,7 +112,7 @@ void Menu::init() {
static const QString FILE_MENU{ "File" }; static const QString FILE_MENU{ "File" };
addMenu(ROOT_MENU, FILE_MENU); addMenu(ROOT_MENU, FILE_MENU);
{ {
addMenuItem(FILE_MENU, MenuOption::Login); addItem(FILE_MENU, 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, &AccountManager::profileChanged, connect(&accountManager, &AccountManager::profileChanged,
dialogsManager.data(), &DialogsManager::toggleLoginDialog); dialogsManager.data(), &DialogsManager::toggleLoginDialog);
@ -141,22 +128,22 @@ void Menu::init() {
static const QString SCRIPTS_MENU{ "Scripts" }; static const QString SCRIPTS_MENU{ "Scripts" };
addMenu(FILE_MENU, SCRIPTS_MENU); addMenu(FILE_MENU, SCRIPTS_MENU);
//Qt::CTRL | Qt::Key_O //Qt::CTRL | Qt::Key_O
addMenuItem(SCRIPTS_MENU, MenuOption::LoadScript, [=] { addItem(SCRIPTS_MENU, MenuOption::LoadScript, [=] {
qApp->loadDialog(); qApp->loadDialog();
}); });
//Qt::CTRL | Qt::SHIFT | Qt::Key_O //Qt::CTRL | Qt::SHIFT | Qt::Key_O
addMenuItem(SCRIPTS_MENU, MenuOption::LoadScriptURL, [=] { addItem(SCRIPTS_MENU, MenuOption::LoadScriptURL, [=] {
qApp->loadScriptURLDialog(); qApp->loadScriptURLDialog();
}); });
addMenuItem(SCRIPTS_MENU, MenuOption::StopAllScripts, [=] { addItem(SCRIPTS_MENU, MenuOption::StopAllScripts, [=] {
qApp->stopAllScripts(); qApp->stopAllScripts();
}); });
//Qt::CTRL | Qt::Key_R, //Qt::CTRL | Qt::Key_R,
addMenuItem(SCRIPTS_MENU, MenuOption::ReloadAllScripts, [=] { addItem(SCRIPTS_MENU, MenuOption::ReloadAllScripts, [=] {
qApp->reloadAllScripts(); qApp->reloadAllScripts();
}); });
// Qt::CTRL | Qt::Key_J, // Qt::CTRL | Qt::Key_J,
addMenuItem(SCRIPTS_MENU, MenuOption::RunningScripts, [=] { addItem(SCRIPTS_MENU, MenuOption::RunningScripts, [=] {
qApp->toggleRunningScriptsWidget(); qApp->toggleRunningScriptsWidget();
}); });
} }
@ -166,15 +153,15 @@ void Menu::init() {
addMenu(FILE_MENU, LOCATION_MENU); addMenu(FILE_MENU, LOCATION_MENU);
qApp->getBookmarks()->setupMenus(LOCATION_MENU); qApp->getBookmarks()->setupMenus(LOCATION_MENU);
//Qt::CTRL | Qt::Key_L //Qt::CTRL | Qt::Key_L
addMenuItem(LOCATION_MENU, MenuOption::AddressBar, [=] { addItem(LOCATION_MENU, MenuOption::AddressBar, [=] {
auto dialogsManager = DependencyManager::get<DialogsManager>(); auto dialogsManager = DependencyManager::get<DialogsManager>();
dialogsManager->toggleAddressBar(); dialogsManager->toggleAddressBar();
}); });
addMenuItem(LOCATION_MENU, MenuOption::CopyAddress, [=] { addItem(LOCATION_MENU, MenuOption::CopyAddress, [=] {
auto addressManager = DependencyManager::get<AddressManager>(); auto addressManager = DependencyManager::get<AddressManager>();
addressManager->copyAddress(); addressManager->copyAddress();
}); });
addMenuItem(LOCATION_MENU, MenuOption::CopyPath, [=] { addItem(LOCATION_MENU, MenuOption::CopyPath, [=] {
auto addressManager = DependencyManager::get<AddressManager>(); auto addressManager = DependencyManager::get<AddressManager>();
addressManager->copyPath(); addressManager->copyPath();
}); });
@ -182,7 +169,7 @@ void Menu::init() {
// Qt::CTRL | Qt::Key_Q // Qt::CTRL | Qt::Key_Q
// QAction::QuitRole // QAction::QuitRole
addMenuItem(FILE_MENU, MenuOption::Quit, [=] { addItem(FILE_MENU, MenuOption::Quit, [=] {
qApp->quit(); qApp->quit();
}); });
} }
@ -204,10 +191,10 @@ void Menu::init() {
// Qt::CTRL | Qt::Key_Comma // Qt::CTRL | Qt::Key_Comma
// QAction::PreferencesRole // QAction::PreferencesRole
addMenuItem(EDIT_MENU, MenuOption::Preferences, [=] { addItem(EDIT_MENU, MenuOption::Preferences, [=] {
dialogsManager->editPreferences(); dialogsManager->editPreferences();
}); });
addMenuItem(EDIT_MENU, MenuOption::Animations, [=] { addItem(EDIT_MENU, MenuOption::Animations, [=] {
dialogsManager->editAnimations(); dialogsManager->editAnimations();
}); });
} }
@ -219,65 +206,60 @@ void Menu::init() {
#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>();
//Qt::CTRL | Qt::SHIFT | Qt::Key_C //Qt::CTRL | Qt::SHIFT | Qt::Key_C
addMenuItem(TOOLS_MENU, MenuOption::ControlWithSpeech); addItem(TOOLS_MENU, MenuOption::ControlWithSpeech);
setChecked(MenuOption::ControlWithSpeech, speechRecognizer->getEnabled()); setChecked(MenuOption::ControlWithSpeech, speechRecognizer->getEnabled());
connect(speechRecognizer.data(), &SpeechRecognizer::enabledUpdated, [=] { connect(speechRecognizer.data(), &SpeechRecognizer::enabledUpdated, [=] {
setChecked(MenuOption::ControlWithSpeech, speechRecognizer->getEnabled()); setChecked(MenuOption::ControlWithSpeech, speechRecognizer->getEnabled());
}); });
#endif #endif
// Qt::ALT | Qt::Key_S, // Qt::ALT | Qt::Key_S,
addMenuItem(TOOLS_MENU, MenuOption::ScriptEditor, [=] { addItem(TOOLS_MENU, MenuOption::ScriptEditor, [=] {
dialogsManager->showScriptEditor(); dialogsManager->showScriptEditor();
}); });
// QML Qt::Key_Backslash, // QML Qt::Key_Backslash,
addMenuItem(TOOLS_MENU, MenuOption::Chat, [=] { addItem(TOOLS_MENU, MenuOption::Chat, [=] {
dialogsManager->showIRCLink(); dialogsManager->showIRCLink();
}); });
addMenuItem(TOOLS_MENU, MenuOption::AddRemoveFriends, [=] { addItem(TOOLS_MENU, MenuOption::AddRemoveFriends, [=] {
qApp->showFriendsWindow(); qApp->showFriendsWindow();
}); });
#if 0
QMenu* visibilityMenu = toolsMenu->addMenu("I Am Visible To");
{ {
QActionGroup* visibilityGroup = new QActionGroup(toolsMenu); static const QString VIZ_MENU{ "I Am Visible To" };
addMenu(TOOLS_MENU, VIZ_MENU);
auto discoverabilityManager = DependencyManager::get<DiscoverabilityManager>(); auto discoverabilityManager = DependencyManager::get<DiscoverabilityManager>();
// FIXME group
QAction* visibleToEveryone = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToEveryone, addCheckableItem(VIZ_MENU, MenuOption::VisibleToEveryone,
0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::All, discoverabilityManager->getDiscoverabilityMode() == Discoverability::All,
discoverabilityManager.data(), SLOT(setVisibility())); [=](bool) { discoverabilityManager->setVisibility(); });
visibilityGroup->addAction(visibleToEveryone); addCheckableItem(VIZ_MENU, MenuOption::VisibleToFriends,
discoverabilityManager->getDiscoverabilityMode() == Discoverability::Friends,
QAction* visibleToFriends = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToFriends, [=](bool) { discoverabilityManager->setVisibility(); });
0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::Friends, addCheckableItem(VIZ_MENU, MenuOption::VisibleToNoOne,
discoverabilityManager.data(), SLOT(setVisibility())); discoverabilityManager->getDiscoverabilityMode() == Discoverability::None,
visibilityGroup->addAction(visibleToFriends); [=](bool) { discoverabilityManager->setVisibility(); });
QAction* visibleToNoOne = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToNoOne,
0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::None,
discoverabilityManager.data(), SLOT(setVisibility()));
visibilityGroup->addAction(visibleToNoOne);
connect(discoverabilityManager.data(), &DiscoverabilityManager::discoverabilityModeChanged, connect(discoverabilityManager.data(), &DiscoverabilityManager::discoverabilityModeChanged,
discoverabilityManager.data(), &DiscoverabilityManager::visibilityChanged); discoverabilityManager.data(), &DiscoverabilityManager::visibilityChanged);
} }
#endif
//Qt::CTRL | Qt::ALT | Qt::Key_T, //Qt::CTRL | Qt::ALT | Qt::Key_T,
addMenuItem(TOOLS_MENU, MenuOption::ToolWindow, [=] { addItem(TOOLS_MENU, MenuOption::ToolWindow, [=] {
// dialogsManager->toggleToolWindow(); // dialogsManager->toggleToolWindow();
}); });
//Qt::CTRL | Qt::ALT | Qt::Key_J, //Qt::CTRL | Qt::ALT | Qt::Key_J,
addMenuItem(TOOLS_MENU, MenuOption::Console, [=] { addItem(TOOLS_MENU, MenuOption::Console, [=] {
DependencyManager::get<StandAloneJSConsole>()->toggleConsole(); DependencyManager::get<StandAloneJSConsole>()->toggleConsole();
}); });
// QML Qt::Key_Apostrophe, // QML Qt::Key_Apostrophe,
addMenuItem(TOOLS_MENU, MenuOption::ResetSensors, [=] { addItem(TOOLS_MENU, MenuOption::ResetSensors, [=] {
qApp->resetSensors(); qApp->resetSensors();
}); });
addMenuItem(TOOLS_MENU, MenuOption::PackageModel, [=] { addItem(TOOLS_MENU, MenuOption::PackageModel, [=] {
qApp->packageModel(); qApp->packageModel();
}); });
} }
@ -290,35 +272,35 @@ void Menu::init() {
static const QString SIZE_MENU{ "Size" }; static const QString SIZE_MENU{ "Size" };
addMenu(AVATAR_MENU, SIZE_MENU); addMenu(AVATAR_MENU, SIZE_MENU);
// QML Qt::Key_Plus, // QML Qt::Key_Plus,
addMenuItem(SIZE_MENU, MenuOption::IncreaseAvatarSize, [=] { addItem(SIZE_MENU, MenuOption::IncreaseAvatarSize, [=] {
avatar->increaseSize(); avatar->increaseSize();
}); });
// QML Qt::Key_Minus, // QML Qt::Key_Minus,
addMenuItem(SIZE_MENU, MenuOption::DecreaseAvatarSize, [=] { addItem(SIZE_MENU, MenuOption::DecreaseAvatarSize, [=] {
avatar->decreaseSize(); avatar->decreaseSize();
}); });
// QML Qt::Key_Equal, // QML Qt::Key_Equal,
addMenuItem(SIZE_MENU, MenuOption::ResetAvatarSize, [=] { addItem(SIZE_MENU, MenuOption::ResetAvatarSize, [=] {
avatar->resetSize(); avatar->resetSize();
}); });
addMenuItem(SIZE_MENU, MenuOption::ResetAvatarSize, [=] { addItem(SIZE_MENU, MenuOption::ResetAvatarSize, [=] {
avatar->resetSize(); avatar->resetSize();
}); });
} }
//Qt::CTRL | Qt::SHIFT | Qt::Key_K //Qt::CTRL | Qt::SHIFT | Qt::Key_K
addCheckableMenuItem(AVATAR_MENU, MenuOption::KeyboardMotorControl, true, [=](bool) { addCheckableItem(AVATAR_MENU, MenuOption::KeyboardMotorControl, true, [=](bool) {
avatar->updateMotionBehavior(); avatar->updateMotionBehavior();
}); });
addCheckableMenuItem(AVATAR_MENU, MenuOption::ScriptedMotorControl, true); addCheckableItem(AVATAR_MENU, MenuOption::ScriptedMotorControl, true);
addCheckableMenuItem(AVATAR_MENU, MenuOption::NamesAboveHeads, true); addCheckableItem(AVATAR_MENU, MenuOption::NamesAboveHeads, true);
addCheckableMenuItem(AVATAR_MENU, MenuOption::GlowWhenSpeaking, true); addCheckableItem(AVATAR_MENU, MenuOption::GlowWhenSpeaking, true);
addCheckableMenuItem(AVATAR_MENU, MenuOption::BlueSpeechSphere, true); addCheckableItem(AVATAR_MENU, MenuOption::BlueSpeechSphere, true);
addCheckableMenuItem(AVATAR_MENU, MenuOption::EnableCharacterController, true, [=](bool) { addCheckableItem(AVATAR_MENU, MenuOption::EnableCharacterController, true, [=](bool) {
avatar->updateMotionBehavior(); avatar->updateMotionBehavior();
}); });
addCheckableMenuItem(AVATAR_MENU, MenuOption::ShiftHipsForIdleAnimations, false, [=](bool) { addCheckableItem(AVATAR_MENU, MenuOption::ShiftHipsForIdleAnimations, false, [=](bool) {
avatar->updateMotionBehavior(); avatar->updateMotionBehavior();
}); });
} }
@ -329,57 +311,58 @@ void Menu::init() {
// Mac Qt::CTRL | Qt::META | Qt::Key_F, // Mac Qt::CTRL | Qt::META | Qt::Key_F,
// Win32/Linux Qt::CTRL | Qt::Key_F, // Win32/Linux Qt::CTRL | Qt::Key_F,
addCheckableMenuItem(VIEW_MENU, MenuOption::Fullscreen, false, [=](bool checked) { addCheckableItem(VIEW_MENU, MenuOption::Fullscreen, false, [=](bool checked) {
// qApp->setFullscreen(checked); // qApp->setFullscreen(checked);
}); });
// QML Qt::Key_P, // QML Qt::Key_P,
addCheckableMenuItem(VIEW_MENU, MenuOption::FirstPerson, true, [=](bool checked) { addCheckableItem(VIEW_MENU, MenuOption::FirstPerson, true, [=](bool checked) {
// qApp->cameraMenuChanged(); // qApp->cameraMenuChanged();
}); });
//QML Qt::SHIFT | Qt::Key_H, //QML Qt::SHIFT | Qt::Key_H,
addCheckableMenuItem(VIEW_MENU, MenuOption::Mirror, true); addCheckableItem(VIEW_MENU, MenuOption::Mirror, true);
// QML Qt::Key_H, // QML Qt::Key_H,
addCheckableMenuItem(VIEW_MENU, MenuOption::FullscreenMirror, true, [=](bool checked) { addCheckableItem(VIEW_MENU, MenuOption::FullscreenMirror, true, [=](bool checked) {
// qApp->cameraMenuChanged(); // qApp->cameraMenuChanged();
}); });
// Mac Qt::META | Qt::Key_H, // Mac Qt::META | Qt::Key_H,
// Win32/Linux Qt::CTRL | Qt::Key_H, // Win32/Linux Qt::CTRL | Qt::Key_H,
addCheckableMenuItem(VIEW_MENU, MenuOption::HMDTools, false, [=](bool checked) { addCheckableItem(VIEW_MENU, MenuOption::HMDTools, false, [=](bool checked) {
dialogsManager->hmdTools(checked); dialogsManager->hmdTools(checked);
}); });
addCheckableMenuItem(VIEW_MENU, MenuOption::EnableVRMode, false, [=](bool checked) { addCheckableItem(VIEW_MENU, MenuOption::EnableVRMode, false, [=](bool checked) {
// qApp->setEnableVRMode(checked); // qApp->setEnableVRMode(checked);
}); });
addCheckableMenuItem(VIEW_MENU, MenuOption::Enable3DTVMode, false, [=](bool checked) { addCheckableItem(VIEW_MENU, MenuOption::Enable3DTVMode, false, [=](bool checked) {
// qApp->setEnable3DTVMode(checked); // qApp->setEnable3DTVMode(checked);
}); });
{ {
static const QString BORDER_MENU{ "View" }; static const QString BORDER_MENU{ "Server Borders" };
addMenu(VIEW_MENU, BORDER_MENU); addMenu(VIEW_MENU, BORDER_MENU);
// Qt::CTRL | Qt::SHIFT | Qt::Key_1 // Qt::CTRL | Qt::SHIFT | Qt::Key_1
addCheckableMenuItem(BORDER_MENU, MenuOption::ShowBordersEntityNodes, false, [=](bool checked) { addCheckableItem(BORDER_MENU, MenuOption::ShowBordersEntityNodes, false, [=](bool checked) {
qApp->getNodeBoundsDisplay().setShowEntityNodes(checked); qApp->getNodeBoundsDisplay().setShowEntityNodes(checked);
}); });
} }
addCheckableMenuItem(VIEW_MENU, MenuOption::OffAxisProjection, false); addCheckableItem(VIEW_MENU, MenuOption::OffAxisProjection, false);
addCheckableMenuItem(VIEW_MENU, MenuOption::TurnWithHead, false); addCheckableItem(VIEW_MENU, MenuOption::TurnWithHead, false);
// QML Qt::Key_Slash // QML Qt::Key_Slash
addCheckableMenuItem(VIEW_MENU, MenuOption::Stats, false); addCheckableItem(VIEW_MENU, MenuOption::Stats, false);
// Qt::CTRL | Qt::SHIFT | Qt::Key_L // Qt::CTRL | Qt::SHIFT | Qt::Key_L
addMenuItem(VIEW_MENU, MenuOption::Log, [=] { addItem(VIEW_MENU, MenuOption::Log, [=] {
qApp->toggleLogDialog(); qApp->toggleLogDialog();
}); });
addMenuItem(VIEW_MENU, MenuOption::BandwidthDetails, [=] { addItem(VIEW_MENU, MenuOption::BandwidthDetails, [=] {
dialogsManager->bandwidthDetails(); dialogsManager->bandwidthDetails();
}); });
addMenuItem(VIEW_MENU, MenuOption::OctreeStats, [=] { addItem(VIEW_MENU, MenuOption::OctreeStats, [=] {
dialogsManager->octreeStatsDetails(); dialogsManager->octreeStatsDetails();
}); });
} }
{ {
static const QString DEV_MENU{ "Developer" }; static const QString DEV_MENU{ "Developer" };
@ -388,9 +371,9 @@ void Menu::init() {
static const QString RENDER_MENU{ "Render" }; static const QString RENDER_MENU{ "Render" };
addMenu(DEV_MENU, RENDER_MENU); addMenu(DEV_MENU, RENDER_MENU);
// QML Qt::SHIFT | Qt::Key_A, // QML Qt::SHIFT | Qt::Key_A,
addCheckableMenuItem(RENDER_MENU, MenuOption::Atmosphere, true); addCheckableItem(RENDER_MENU, MenuOption::Atmosphere, true);
addCheckableMenuItem(RENDER_MENU, MenuOption::AmbientOcclusion); addCheckableItem(RENDER_MENU, MenuOption::AmbientOcclusion);
addCheckableMenuItem(RENDER_MENU, MenuOption::DontFadeOnOctreeServerChanges); addCheckableItem(RENDER_MENU, MenuOption::DontFadeOnOctreeServerChanges);
{ {
static const QString LIGHT_MENU{ MenuOption::RenderAmbientLight }; static const QString LIGHT_MENU{ MenuOption::RenderAmbientLight };
addMenu(RENDER_MENU, LIGHT_MENU); addMenu(RENDER_MENU, LIGHT_MENU);
@ -408,7 +391,7 @@ void Menu::init() {
MenuOption::RenderAmbientLight9, MenuOption::RenderAmbientLight9,
}; };
foreach(QString option, LIGHTS) { foreach(QString option, LIGHTS) {
addCheckableMenuItem(LIGHT_MENU, option); addCheckableItem(LIGHT_MENU, option);
// FIXME // FIXME
// setExclusiveGroup() // setExclusiveGroup()
} }
@ -417,22 +400,22 @@ void Menu::init() {
{ {
static const QString SHADOWS_MENU{ "Shadows" }; static const QString SHADOWS_MENU{ "Shadows" };
addMenu(RENDER_MENU, SHADOWS_MENU); addMenu(RENDER_MENU, SHADOWS_MENU);
addCheckableMenuItem(SHADOWS_MENU, "No Shadows", true); addCheckableItem(SHADOWS_MENU, "No Shadows", true);
addCheckableMenuItem(SHADOWS_MENU, MenuOption::SimpleShadows); addCheckableItem(SHADOWS_MENU, MenuOption::SimpleShadows);
addCheckableMenuItem(SHADOWS_MENU, MenuOption::CascadedShadows); addCheckableItem(SHADOWS_MENU, MenuOption::CascadedShadows);
} }
{ {
static const QString FRAMERATE_MENU{ MenuOption::RenderTargetFramerate }; static const QString FRAMERATE_MENU{ MenuOption::RenderTargetFramerate };
addMenu(RENDER_MENU, FRAMERATE_MENU); addMenu(RENDER_MENU, FRAMERATE_MENU);
//framerateGroup->setExclusive(true); //framerateGroup->setExclusive(true);
addCheckableMenuItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerateUnlimited, true); addCheckableItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerateUnlimited, true);
addCheckableMenuItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate60); addCheckableItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate60);
addCheckableMenuItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate50); addCheckableItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate50);
addCheckableMenuItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate40); addCheckableItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate40);
addCheckableMenuItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate30); addCheckableItem(FRAMERATE_MENU, MenuOption::RenderTargetFramerate30);
} }
#if !defined(Q_OS_MAC) #if !defined(Q_OS_MAC)
addCheckableMenuItem(RENDER_MENU, MenuOption::RenderTargetFramerateVSyncOn, true, [](bool checked) { addCheckableItem(RENDER_MENU, MenuOption::RenderTargetFramerateVSyncOn, true, [](bool checked) {
qApp->setVSyncEnabled(); qApp->setVSyncEnabled();
}); });
#endif #endif
@ -440,223 +423,211 @@ void Menu::init() {
static const QString RES_MENU{ MenuOption::RenderResolution }; static const QString RES_MENU{ MenuOption::RenderResolution };
addMenu(RENDER_MENU, RES_MENU); addMenu(RENDER_MENU, RES_MENU);
// resolutionGroup->setExclusive(true); // resolutionGroup->setExclusive(true);
addCheckableMenuItem(RES_MENU, MenuOption::RenderResolutionOne, true); addCheckableItem(RES_MENU, MenuOption::RenderResolutionOne, true);
addCheckableMenuItem(RES_MENU, MenuOption::RenderResolutionTwoThird); addCheckableItem(RES_MENU, MenuOption::RenderResolutionTwoThird);
addCheckableMenuItem(RES_MENU, MenuOption::RenderResolutionHalf); addCheckableItem(RES_MENU, MenuOption::RenderResolutionHalf);
addCheckableMenuItem(RES_MENU, MenuOption::RenderResolutionThird); addCheckableItem(RES_MENU, MenuOption::RenderResolutionThird);
addCheckableMenuItem(RES_MENU, MenuOption::RenderResolutionQuarter); addCheckableItem(RES_MENU, MenuOption::RenderResolutionQuarter);
} }
// QML Qt::Key_Asterisk, // QML Qt::Key_Asterisk,
addCheckableMenuItem(RENDER_MENU, MenuOption::Stars, true); addCheckableItem(RENDER_MENU, MenuOption::Stars, true);
addCheckableMenuItem(RENDER_MENU, MenuOption::EnableGlowEffect, true, [](bool checked){ addCheckableItem(RENDER_MENU, MenuOption::EnableGlowEffect, true, [](bool checked){
DependencyManager::get<GlowEffect>()->toggleGlowEffect(checked); DependencyManager::get<GlowEffect>()->toggleGlowEffect(checked);
}); });
//Qt::ALT | Qt::Key_W //Qt::ALT | Qt::Key_W
addCheckableMenuItem(RENDER_MENU, MenuOption::Wireframe); addCheckableItem(RENDER_MENU, MenuOption::Wireframe);
// QML Qt::SHIFT | Qt::Key_L, // QML Qt::SHIFT | Qt::Key_L,
addMenuItem(RENDER_MENU, MenuOption::LodTools, [=] { addItem(RENDER_MENU, MenuOption::LodTools, [=] {
dialogsManager->lodTools(); dialogsManager->lodTools();
}); });
} } // Developer -> Render
{ {
static const QString AVATAR_MENU{ "Avatar Dev" }; static const QString AVATAR_MENU{ "Avatar Dev" };
addMenu(DEV_MENU, AVATAR_MENU); addMenu(DEV_MENU, AVATAR_MENU);
setText(AVATAR_MENU, "Avatar"); setItemText(AVATAR_MENU, "Avatar");
{ {
} static const QString FACE_MENU{ "Face Tracking" };
} addMenu(AVATAR_MENU, FACE_MENU);
} // FIXME GROUP
addCheckableItem(FACE_MENU, MenuOption::NoFaceTracking, true, [](bool checked) {
#if 0 qApp->setActiveFaceTracker();
QMenu* faceTrackingMenu = avatarDebugMenu->addMenu("Face Tracking"); });
{
QActionGroup* faceTrackerGroup = new QActionGroup(avatarDebugMenu);
QAction* noFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking,
0, true,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(noFaceTracker);
#ifdef HAVE_FACESHIFT #ifdef HAVE_FACESHIFT
QAction* faceshiftFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Faceshift, addCheckableItem(FACE_MENU, MenuOption::Faceshift, true, [](bool checked) {
0, false, qApp->setActiveFaceTracker();
qApp, SLOT(setActiveFaceTracker())); });
faceTrackerGroup->addAction(faceshiftFaceTracker);
#endif #endif
#ifdef HAVE_DDE #ifdef HAVE_DDE
QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera, addCheckableItem(FACE_MENU, MenuOption::UseCamera, true, [](bool checked) {
0, false, qApp->setActiveFaceTracker();
qApp, SLOT(setActiveFaceTracker())); });
faceTrackerGroup->addAction(ddeFaceTracker);
#endif
}
#ifdef HAVE_DDE
faceTrackingMenu->addSeparator();
QAction* useAudioForMouth = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseAudioForMouth, 0, true);
useAudioForMouth->setVisible(false);
QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::VelocityFilter, 0, true);
ddeFiltering->setVisible(false);
#endif #endif
addCheckableItem(FACE_MENU, MenuOption::UseAudioForMouth, true);
// FIXME integrate the visibility into the main API
getActionForOption(MenuOption::UseAudioForMouth)->setVisible(false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderSkeletonCollisionShapes); addCheckableItem(FACE_MENU, MenuOption::VelocityFilter, true);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderHeadCollisionShapes); // FIXME integrate the visibility into the main API
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderBoundingCollisionShapes); getActionForOption(MenuOption::VelocityFilter)->setVisible(false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderLookAtVectors, 0, false); }
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderFocusIndicator, 0, false); addCheckableItem(AVATAR_MENU, MenuOption::RenderSkeletonCollisionShapes);
addCheckableItem(AVATAR_MENU, MenuOption::RenderHeadCollisionShapes);
QMenu* handOptionsMenu = developerMenu->addMenu("Hands"); addCheckableItem(AVATAR_MENU, MenuOption::RenderBoundingCollisionShapes);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::AlignForearmsWithWrists, 0, false); addCheckableItem(AVATAR_MENU, MenuOption::RenderLookAtVectors);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::AlternateIK, 0, false); addCheckableItem(AVATAR_MENU, MenuOption::RenderFocusIndicator);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHands, 0, true); {
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false); static const QString HANDS_MENU{ "Hands" };
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::ShowIKConstraints, 0, false); addMenu(AVATAR_MENU, HANDS_MENU);
addCheckableItem(HANDS_MENU, MenuOption::AlignForearmsWithWrists);
QMenu* sixenseOptionsMenu = handOptionsMenu->addMenu("Sixense"); addCheckableItem(HANDS_MENU, MenuOption::AlternateIK);
addCheckableItem(HANDS_MENU, MenuOption::DisplayHands, true);
addCheckableItem(HANDS_MENU, MenuOption::DisplayHandTargets);
addCheckableItem(HANDS_MENU, MenuOption::ShowIKConstraints);
{
static const QString SIXENSE_MENU{ "Sixense" };
addMenu(HANDS_MENU, SIXENSE_MENU);
#ifdef __APPLE__ #ifdef __APPLE__
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu, addCheckableItem(SIXENSE_MENU, MenuOption::SixenseEnabled, false, [](bool checked) {
MenuOption::SixenseEnabled, SixenseManager::getInstance().toggleSixense(checked);
0, false, });
&SixenseManager::getInstance(),
SLOT(toggleSixense(bool)));
#endif #endif
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu, addCheckableItem(SIXENSE_MENU, MenuOption::FilterSixense, true, [](bool checked) {
MenuOption::FilterSixense, SixenseManager::getInstance().setFilter(checked);
0, });
true, addCheckableItem(SIXENSE_MENU, MenuOption::LowVelocityFilter, true, [](bool checked) {
&SixenseManager::getInstance(), qApp->setLowVelocityFilter(checked);
SLOT(setFilter(bool))); });
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu, addCheckableItem(SIXENSE_MENU, MenuOption::SixenseMouseInput, true);
MenuOption::LowVelocityFilter, addCheckableItem(SIXENSE_MENU, MenuOption::SixenseLasers);
0, }
true,
qApp,
SLOT(setLowVelocityFilter(bool)));
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu, MenuOption::SixenseMouseInput, 0, true);
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu, MenuOption::SixenseLasers, 0, false);
QMenu* leapOptionsMenu = handOptionsMenu->addMenu("Leap Motion"); {
addCheckableActionToQMenuAndActionHash(leapOptionsMenu, MenuOption::LeapMotionOnHMD, 0, false); static const QString LEAP_MENU{ "Leap Motion" };
addMenu(HANDS_MENU, LEAP_MENU);
addCheckableItem(LEAP_MENU, MenuOption::LeapMotionOnHMD);
addCheckableItem(LEAP_MENU, MenuOption::LeapMotionOnHMD);
}
#ifdef HAVE_RSSDK #ifdef HAVE_RSSDK
QMenu* realSenseOptionsMenu = handOptionsMenu->addMenu("RealSense"); {
addActionToQMenuAndActionHash(realSenseOptionsMenu, MenuOption::LoadRSSDKFile, 0, static const QString RSS_MENU{ "RealSense" };
RealSense::getInstance(), SLOT(loadRSSDKFile())); addMenu(HANDS_MENU, RSS_MENU);
addItem(RSS_MENU, MenuOption::LoadRSSDKFile, [] {
RealSense::getInstance()->loadRSSDKFile();
});
addCheckableItem(RSS_MENU, MenuOption::LeapMotionOnHMD);
}
#endif #endif
} // Developer -> Hands
QMenu* networkMenu = developerMenu->addMenu("Network"); {
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::DisableNackPackets, 0, false); static const QString NETWORK_MENU{ "Network" };
addCheckableActionToQMenuAndActionHash(networkMenu, addMenu(DEV_MENU, NETWORK_MENU);
MenuOption::DisableActivityLogger, addCheckableItem(NETWORK_MENU, MenuOption::DisableNackPackets);
0, addCheckableItem(NETWORK_MENU, MenuOption::DisableActivityLogger, false, [](bool checked) {
false, UserActivityLogger::getInstance().disable(checked);
&UserActivityLogger::getInstance(), });
SLOT(disable(bool))); addItem(NETWORK_MENU, MenuOption::CachesSize, [=] {
addActionToQMenuAndActionHash(networkMenu, MenuOption::CachesSize, 0, dialogsManager->cachesSizeDialog();
dialogsManager.data(), SLOT(cachesSizeDialog())); });
addActionToQMenuAndActionHash(networkMenu, MenuOption::DiskCacheEditor, 0, addItem(NETWORK_MENU, MenuOption::DiskCacheEditor, [=] {
dialogsManager.data(), SLOT(toggleDiskCacheEditor())); dialogsManager->toggleDiskCacheEditor();
});
} // Developer -> Network
QMenu* timingMenu = developerMenu->addMenu("Timing and Stats"); {
QMenu* perfTimerMenu = timingMenu->addMenu("Performance Timer"); static const QString TIMING_MENU{ "Timing and Stats" };
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::DisplayDebugTimingDetails, 0, false); addMenu(DEV_MENU, TIMING_MENU);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::OnlyDisplayTopTen, 0, true); {
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandUpdateTiming, 0, false); static const QString PERF_MENU{ "Performance Timer" };
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarTiming, 0, false); addMenu(TIMING_MENU, PERF_MENU);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarSimulateTiming, 0, false); addCheckableItem(PERF_MENU, MenuOption::DisplayDebugTimingDetails);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandOtherAvatarTiming, 0, false); addCheckableItem(PERF_MENU, MenuOption::OnlyDisplayTopTen, true);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandPaintGLTiming, 0, false); addCheckableItem(PERF_MENU, MenuOption::ExpandUpdateTiming);
addCheckableItem(PERF_MENU, MenuOption::ExpandMyAvatarTiming);
addCheckableItem(PERF_MENU, MenuOption::ExpandMyAvatarSimulateTiming);
addCheckableItem(PERF_MENU, MenuOption::ExpandOtherAvatarTiming);
addCheckableItem(PERF_MENU, MenuOption::ExpandPaintGLTiming);
}
addCheckableItem(TIMING_MENU, MenuOption::TestPing, true);
addCheckableItem(TIMING_MENU, MenuOption::FrameTimer);
addItem(TIMING_MENU, MenuOption::RunTimingTests, [] { runTimingTests(); });
addCheckableItem(TIMING_MENU, MenuOption::PipelineWarnings);
addCheckableItem(TIMING_MENU, MenuOption::SuppressShortTimings);
} // Developer -> Timing and Stats
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::TestPing, 0, true); {
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::FrameTimer); static const QString AUDIO_MENU{ "Audio" };
addActionToQMenuAndActionHash(timingMenu, MenuOption::RunTimingTests, 0, qApp, SLOT(runTests())); addMenu(DEV_MENU, AUDIO_MENU);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::PipelineWarnings); auto audioIO = DependencyManager::get<AudioClient>();
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings); addCheckableItem(AUDIO_MENU, MenuOption::AudioNoiseReduction, true, [=](bool checked) {
audioIO->toggleAudioNoiseReduction();
});
addCheckableItem(AUDIO_MENU, MenuOption::EchoServerAudio, false, [=](bool checked) {
audioIO->toggleServerEcho();
});
addCheckableItem(AUDIO_MENU, MenuOption::EchoLocalAudio, false, [=](bool checked) {
audioIO->toggleLocalEcho();
});
addCheckableItem(AUDIO_MENU, MenuOption::StereoAudio, false, [=](bool checked) {
audioIO->toggleStereoInput();
});
// Qt::CTRL | Qt::Key_M,
addCheckableItem(AUDIO_MENU, MenuOption::MuteAudio, false, [=](bool checked) {
audioIO->toggleMute();
});
addCheckableItem(AUDIO_MENU, MenuOption::MuteEnvironment, false, [=](bool checked) {
audioIO->sendMuteEnvironmentPacket();
});
{
static const QString SCOPE_MENU{ "Audio Scope" };
addMenu(AUDIO_MENU, SCOPE_MENU);
auto scope = DependencyManager::get<AudioScope>();
// Qt::CTRL | Qt::Key_P
addCheckableItem(SCOPE_MENU, MenuOption::AudioScope, false, [=](bool checked) {
scope->toggle();
});
// Qt::CTRL | Qt::SHIFT | Qt::Key_P
addCheckableItem(SCOPE_MENU, MenuOption::AudioScopePause, false, [=](bool checked) {
scope->togglePause();
});
addSeparator(SCOPE_MENU, "Display Frames");
auto audioIO = DependencyManager::get<AudioClient>(); // FIXME GROUP
QMenu* audioDebugMenu = developerMenu->addMenu("Audio"); addCheckableItem(SCOPE_MENU, MenuOption::AudioScopeFiveFrames, true, [=](bool checked) {
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNoiseReduction, scope->selectAudioScopeFiveFrames();
0, });
true, addCheckableItem(SCOPE_MENU, MenuOption::AudioScopeTwentyFrames, false, [=](bool checked) {
audioIO.data(), scope->selectAudioScopeTwentyFrames();
SLOT(toggleAudioNoiseReduction())); });
addCheckableItem(SCOPE_MENU, MenuOption::AudioScopeFiftyFrames, false, [=](bool checked) {
scope->selectAudioScopeFiftyFrames();
});
}
auto statsRenderer = DependencyManager::get<AudioIOStatsRenderer>();
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoServerAudio, 0, false, // Qt::CTRL | Qt::SHIFT | Qt::Key_A,
audioIO.data(), SLOT(toggleServerEcho())); addCheckableItem(AUDIO_MENU, MenuOption::AudioStats, false, [=](bool checked) {
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoLocalAudio, 0, false, statsRenderer->toggle();
audioIO.data(), SLOT(toggleLocalEcho())); });
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::StereoAudio, 0, false, addCheckableItem(AUDIO_MENU, MenuOption::AudioStatsShowInjectedStreams, false, [=](bool checked) {
audioIO.data(), SLOT(toggleStereoInput())); statsRenderer->toggleShowInjectedStreams();
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteAudio, });
Qt::CTRL | Qt::Key_M, } // Developer -> Audio
false, } // Developer
audioIO.data(),
SLOT(toggleMute()));
addActionToQMenuAndActionHash(audioDebugMenu,
MenuOption::MuteEnvironment,
0,
audioIO.data(),
SLOT(sendMuteEnvironmentPacket()));
auto scope = DependencyManager::get<AudioScope>();
QMenu* audioScopeMenu = audioDebugMenu->addMenu("Audio Scope"); {
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScope, static const QString HELP_MENU{ "Help" };
Qt::CTRL | Qt::Key_P, false, addMenu(ROOT_MENU, HELP_MENU);
scope.data(), addItem(HELP_MENU, MenuOption::EditEntitiesHelp, [] {
SLOT(toggle())); qApp->showEditEntitiesHelp();
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopePause, });
Qt::CTRL | Qt::SHIFT | Qt::Key_P , addItem(HELP_MENU, MenuOption::AboutApp, [] {
false, qApp->aboutApp();
scope.data(), });
SLOT(togglePause())); } // Help
addDisabledActionAndSeparator(audioScopeMenu, "Display Frames");
{
QAction *fiveFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiveFrames,
0,
true,
scope.data(),
SLOT(selectAudioScopeFiveFrames()));
QAction *twentyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeTwentyFrames,
0,
false,
scope.data(),
SLOT(selectAudioScopeTwentyFrames()));
QAction *fiftyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiftyFrames,
0,
false,
scope.data(),
SLOT(selectAudioScopeFiftyFrames()));
QActionGroup* audioScopeFramesGroup = new QActionGroup(audioScopeMenu);
audioScopeFramesGroup->addAction(fiveFrames);
audioScopeFramesGroup->addAction(twentyFrames);
audioScopeFramesGroup->addAction(fiftyFrames);
} }
auto statsRenderer = DependencyManager::get<AudioIOStatsRenderer>();
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioStats,
Qt::CTRL | Qt::SHIFT | Qt::Key_A,
false,
statsRenderer.data(),
SLOT(toggle()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioStatsShowInjectedStreams,
0,
false,
statsRenderer.data(),
SLOT(toggleShowInjectedStreams()));
QMenu* helpMenu = addMenu("Help");
addActionToQMenuAndActionHash(helpMenu, MenuOption::EditEntitiesHelp, 0, qApp, SLOT(showEditEntitiesHelp()));
#ifndef Q_OS_MAC
QAction* aboutAction = helpMenu->addAction(MenuOption::AboutApp);
connect(aboutAction, SIGNAL(triggered()), qApp, SLOT(aboutApp()));
#endif
#endif
} }
void Menu::loadSettings() { void Menu::loadSettings() {

27
interface/src/Menu.h
View file

@ -36,7 +36,7 @@ public:
void setCheckable(bool); void setCheckable(bool);
void setChecked(bool); void setChecked(bool);
void setVisible(bool); void setVisible(bool);
const QString & shortcut() const; QString shortcut() const;
void setText(const QString &); void setText(const QString &);
void setTriggerAction(std::function<void()>); void setTriggerAction(std::function<void()>);
void setToggleAction(std::function<void(bool)>); void setToggleAction(std::function<void(bool)>);
@ -56,37 +56,32 @@ public:
void loadSettings(); void loadSettings();
void saveSettings(); void saveSettings();
HifiAction * getActionForOption(const QString& menuOption) { HifiAction * getActionForOption(const QString& menuOption) {
return new HifiAction(menuOption); return new HifiAction(menuOption);
} }
// QMenu* addMenu(const QString& menuName);
//void removeMenu(const QString& menuName); void addMenuItem(const MenuItemProperties& properties);
//bool menuExists(const QString& menuName);
//void addSeparator(const QString& menuName, const QString& separatorName);
//void removeSeparator(const QString& menuName, const QString& separatorName);
//void addMenuItem(const MenuItemProperties& properties);
//void removeMenuItem(const QString& menuitem);
//bool menuItemExists(const QString& menuName, const QString& menuitem);
bool isOptionChecked(const QString& menuOption) const { bool isOptionChecked(const QString& menuOption) const {
return HifiMenu::isChecked(menuOption); return HifiMenu::isChecked(menuOption);
} }
void setIsOptionChecked(const QString& menuOption, bool isChecked) { void setIsOptionChecked(const QString& menuOption, bool isChecked) {
HifiMenu::setChecked(menuOption, isChecked); HifiMenu::setChecked(menuOption, isChecked);
} }
void triggerOption(const QString& menuOption) { void triggerOption(const QString& menuOption) {
HifiMenu::triggerMenuItem(menuOption); HifiMenu::triggerItem(menuOption);
} }
void setOptionText(const QString& menuOption, const QString & text) { void setOptionText(const QString& menuOption, const QString & text) {
HifiMenu::setText(menuOption, text); HifiMenu::setItemText(menuOption, text);
} }
void setOptionTriggerAction(const QString& menuOption, std::function<void()> f) { void setOptionTriggerAction(const QString& menuOption, std::function<void()> f) {
HifiMenu::setTriggerAction(menuOption, f); HifiMenu::setTriggerAction(menuOption, f);
} }
//void setOptionToggleAction(const QString& menuOption, std::function<void(bool)> f);
//void addMenuItem(const QString & parentMenu, const QString & menuOption, std::function<void()> f);
//void addMenuItem(const QString & parentMenu, const QString & menuOption);
//void addMenu(const QString & parentMenu, const QString & menuOption);
//void enableMenuItem(const QString & menuOption, bool enabled = true);
private: private:
void init(); void init();

60
libraries/ui/src/HifiMenu.cpp
View file

@ -112,7 +112,7 @@ void HifiMenu::addSeparator(const QString& parentMenu, const QString& separatorN
void HifiMenu::removeSeparator(const QString& parentMenu, const QString& separatorName) { void HifiMenu::removeSeparator(const QString& parentMenu, const QString& separatorName) {
} }
void HifiMenu::addMenuItem(const QString & parentMenu, const QString & menuOption) { void HifiMenu::addItem(const QString & parentMenu, const QString & menuOption) {
QObject* parent = findMenuObject(parentMenu); QObject* parent = findMenuObject(parentMenu);
Q_ASSERT(parent); Q_ASSERT(parent);
QObject* result = ::addItem(parent, menuOption); QObject* result = ::addItem(parent, menuOption);
@ -127,20 +127,20 @@ void HifiMenu::addMenuItem(const QString & parentMenu, const QString & menuOptio
connect(result, SIGNAL(toggled(bool)), &_toggleMapper, SLOT(map())); connect(result, SIGNAL(toggled(bool)), &_toggleMapper, SLOT(map()));
} }
void HifiMenu::addMenuItem(const QString & parentMenu, const QString & menuOption, std::function<void()> f) { void HifiMenu::addItem(const QString & parentMenu, const QString & menuOption, std::function<void()> f) {
setTriggerAction(menuOption, f); setTriggerAction(menuOption, f);
addMenuItem(parentMenu, menuOption); addItem(parentMenu, menuOption);
} }
void HifiMenu::removeMenuItem(const QString& menuOption) { void HifiMenu::removeItem(const QString& menuOption) {
removeMenu(menuOption); removeMenu(menuOption);
} }
bool HifiMenu::menuItemExists(const QString& menuName, const QString& menuitem) const { bool HifiMenu::itemExists(const QString& menuName, const QString& menuitem) const {
return findMenuObject(menuName); return findMenuObject(menuName);
} }
void HifiMenu::triggerMenuItem(const QString& menuOption) { void HifiMenu::triggerItem(const QString& menuOption) {
QObject* menuItem = findMenuObject(menuOption); QObject* menuItem = findMenuObject(menuOption);
Q_ASSERT(menuItem); Q_ASSERT(menuItem);
Q_ASSERT(menuItem != _rootMenu); Q_ASSERT(menuItem != _rootMenu);
@ -185,20 +185,24 @@ void HifiMenu::setCheckable(const QString& menuOption, bool checkable) {
Q_ASSERT(menuItem->property("checkable").toBool() == checkable); Q_ASSERT(menuItem->property("checkable").toBool() == checkable);
} }
void HifiMenu::setText(const QString& menuOption, const QString & text) { void HifiMenu::setItemText(const QString& menuOption, const QString & text) {
QObject* menuItem = findMenuObject(menuOption); QObject* menuItem = findMenuObject(menuOption);
if (!menuItem) { if (!menuItem) {
warn(menuOption); warn(menuOption);
return; return;
} }
menuItem->setProperty("text", QVariant::fromValue(text)); if (menuItem->property("type").toInt() == 2) {
menuItem->setProperty("title", QVariant::fromValue(text));
} else {
menuItem->setProperty("text", QVariant::fromValue(text));
}
} }
void HifiMenu::setRootMenu(QObject* rootMenu) { void HifiMenu::setRootMenu(QObject* rootMenu) {
_rootMenu = rootMenu; _rootMenu = rootMenu;
} }
void HifiMenu::enableMenuItem(const QString & menuOption, bool enabled) { void HifiMenu::enableItem(const QString & menuOption, bool enabled) {
QObject* menuItem = findMenuObject(menuOption); QObject* menuItem = findMenuObject(menuOption);
if (!menuItem) { if (!menuItem) {
warn(menuOption); warn(menuOption);
@ -207,15 +211,45 @@ void HifiMenu::enableMenuItem(const QString & menuOption, bool enabled) {
menuItem->setProperty("enabled", QVariant::fromValue(enabled)); menuItem->setProperty("enabled", QVariant::fromValue(enabled));
} }
void HifiMenu::addCheckableMenuItem(const QString& parentMenu, const QString& menuOption, bool checked) { void HifiMenu::addCheckableItem(const QString& parentMenu, const QString& menuOption, bool checked) {
addMenuItem(parentMenu, menuOption); addItem(parentMenu, menuOption);
setCheckable(menuOption); setCheckable(menuOption);
if (checked) { if (checked) {
setChecked(menuOption, checked); setChecked(menuOption, checked);
} }
} }
void HifiMenu::addCheckableMenuItem(const QString& parentMenu, const QString& menuOption, bool checked, std::function<void(bool)> f) { void HifiMenu::addCheckableItem(const QString& parentMenu, const QString& menuOption, bool checked, std::function<void(bool)> f) {
setToggleAction(menuOption, f); setToggleAction(menuOption, f);
addCheckableMenuItem(parentMenu, menuOption, checked); addCheckableItem(parentMenu, menuOption, checked);
}
void HifiMenu::setItemVisible(const QString& menuOption, bool visible) {
QObject* result = findMenuObject(menuOption);
if (result) {
result->setProperty("visible", visible);
}
}
bool HifiMenu::isItemVisible(const QString& menuOption) {
QObject* result = findMenuObject(menuOption);
if (result) {
return result->property("visible").toBool();
}
return false;
}
void HifiMenu::setItemShortcut(const QString& menuOption, const QString& shortcut) {
QObject* result = findMenuObject(menuOption);
if (result) {
result->setProperty("shortcut", shortcut);
}
}
QString HifiMenu::getItemShortcut(const QString& menuOption) {
QObject* result = findMenuObject(menuOption);
if (result) {
return result->property("shortcut").toString();
}
return QString();
} }

27
libraries/ui/src/HifiMenu.h
View file

@ -35,19 +35,26 @@ public:
void addSeparator(const QString& menuName, const QString& separatorName); void addSeparator(const QString& menuName, const QString& separatorName);
void removeSeparator(const QString& menuName, const QString& separatorName); void removeSeparator(const QString& menuName, const QString& separatorName);
void addMenuItem(const QString& parentMenu, const QString& menuOption); void addItem(const QString& parentMenu, const QString& menuOption);
void addCheckableMenuItem(const QString& parentMenu, const QString& menuOption, bool checked = false); void addItem(const QString& parentMenu, const QString& menuOption, std::function<void()> f);
void addCheckableMenuItem(const QString& parentMenu, const QString& menuOption, bool checked, std::function<void(bool)> f);
void addMenuItem(const QString& parentMenu, const QString& menuOption, std::function<void()> f); void addCheckableItem(const QString& parentMenu, const QString& menuOption, bool checked = false);
void removeMenuItem(const QString& menuitem); void addCheckableItem(const QString& parentMenu, const QString& menuOption, bool checked, std::function<void(bool)> f);
bool menuItemExists(const QString& menuName, const QString& menuitem) const;
void triggerMenuItem(const QString& menuOption); void removeItem(const QString& menuitem);
void enableMenuItem(const QString& menuOption, bool enabled = true); bool itemExists(const QString& menuName, const QString& menuitem) const;
void triggerItem(const QString& menuOption);
void enableItem(const QString& menuOption, bool enabled = true);
bool isChecked(const QString& menuOption) const; bool isChecked(const QString& menuOption) const;
void setChecked(const QString& menuOption, bool isChecked = true); void setChecked(const QString& menuOption, bool checked = true);
void setCheckable(const QString& menuOption, bool checkable = true); void setCheckable(const QString& menuOption, bool checkable = true);
void setExclusiveGroup(const QString& menuOption, const QString & groupName); void setExclusiveGroup(const QString& menuOption, const QString & groupName);
void setText(const QString& menuOption, const QString& text); void setItemText(const QString& menuOption, const QString& text);
void setItemVisible(const QString& menuOption, bool visible = true);
bool isItemVisible(const QString& menuOption);
void setItemShortcut(const QString& menuOption, const QString & shortcut);
QString getItemShortcut(const QString& menuOption);
void setRootMenu(QObject * rootMenu); void setRootMenu(QObject * rootMenu);