MenuWrapper* networkMenu = developerMenu->addMenu("Network");    addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::DisableNackPackets, 0, false);    addCheckableActionToQMenuAndActionHash(networkMenu,                                           MenuOption::DisableActivityLogger,                                           0,                                           false,                                           &UserActivityLogger::getInstance(),                                           SLOT(disable(bool)));    addActionToQMenuAndActionHash(networkMenu, MenuOption::CachesSize, 0,                                  dialogsManager.data(), SLOT(cachesSizeDialog()));    addActionToQMenuAndActionHash(networkMenu, MenuOption::DiskCacheEditor, 0,                                  dialogsManager.data(), SLOT(toggleDiskCacheEditor()));     addActionToQMenuAndActionHash(networkMenu, MenuOption::ShowDSConnectTable, 0,                                  dialogsManager.data(), SLOT(showDomainConnectionDialog()));     MenuWrapper* timingMenu = developerMenu->addMenu("Timing and Stats");     MenuWrapper* perfTimerMenu = timingMenu->addMenu("Performance Timer");    addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::DisplayDebugTimingDetails, 0, false);    addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::OnlyDisplayTopTen, 0, true);    addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandUpdateTiming, 0, false);    addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarTiming, 0, false);    addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarSimulateTiming, 0, false);    addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandOtherAvatarTiming, 0, false);    addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandPaintGLTiming, 0, false);     addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::TestPing, 0, true);    addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::FrameTimer);    addActionToQMenuAndActionHash(timingMenu, MenuOption::RunTimingTests, 0, qApp, SLOT(runTests()));    addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::PipelineWarnings);    addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings);     auto audioIO = DependencyManager::get<AudioClient>();    MenuWrapper* audioDebugMenu = developerMenu->addMenu("Audio");    addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNoiseReduction,                                           0,                                           true,                                           audioIO.data(),                                           SLOT(toggleAudioNoiseReduction()));     addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoServerAudio, 0, false,                                           audioIO.data(), SLOT(toggleServerEcho()));    addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoLocalAudio, 0, false,                                           audioIO.data(), SLOT(toggleLocalEcho()));    addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteAudio,                                           Qt::CTRL | Qt::Key_M,                                           false,                                           audioIO.data(),                                           SLOT(toggleMute()));    addActionToQMenuAndActionHash(audioDebugMenu,                                  MenuOption::MuteEnvironment,                                  0,                                  audioIO.data(),                                  SLOT(sendMuteEnvironmentPacket()));     auto scope = DependencyManager::get<AudioScope>();     MenuWrapper* audioScopeMenu = audioDebugMenu->addMenu("Audio Scope");    addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScope,                                           Qt::CTRL | Qt::Key_P, false,                                           scope.data(),                                           SLOT(toggle()));    addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopePause,                                           Qt::CTRL | Qt::SHIFT | Qt::Key_P ,                                           false,                                           scope.data(),                                           SLOT(togglePause()));    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()));      MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");    addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned);    addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowHulls);     MenuWrapper* 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} void Menu::loadSettings() {    scanMenuBar(&Menu::loadAction);} void Menu::saveSettings() {    scanMenuBar(&Menu::saveAction);} void Menu::loadAction(Settings& settings, QAction& action) {    if (action.isChecked() != settings.value(action.text(), action.isChecked()).toBool()) {        action.trigger();    }} void Menu::saveAction(Settings& settings, QAction& action) {    settings.setValue(action.text(),  action.isChecked());} void Menu::scanMenuBar(settingsAction modifySetting) {    Settings settings;    foreach (QMenu* menu, findChildren<QMenu*>()) {        scanMenu(*menu, modifySetting, settings);    }} void Menu::scanMenu(QMenu& menu, settingsAction modifySetting, Settings& settings) {    settings.beginGroup(menu.title());    foreach (QAction* action, menu.actions()) {        if (action->menu()) {            scanMenu(*action->menu(), modifySetting, settings);        } else if (action->isCheckable()) {            modifySetting(settings, *action);        }    }    settings.endGroup();} void Menu::addDisabledActionAndSeparator(MenuWrapper* destinationMenu, const QString& actionName, int menuItemLocation) {    QAction* actionBefore = NULL;    if (menuItemLocation >= 0 && destinationMenu->actions().size() > menuItemLocation) {        actionBefore = destinationMenu->actions()[menuItemLocation];    }    if (actionBefore) {        QAction* separator = new QAction("",destinationMenu);        destinationMenu->insertAction(actionBefore, separator);        separator->setSeparator(true);         QAction* separatorText = new QAction(actionName,destinationMenu);        separatorText->setEnabled(false);        destinationMenu->insertAction(actionBefore, separatorText);     } else {        destinationMenu->addSeparator();        (destinationMenu->addAction(actionName))->setEnabled(false);    }} QAction* Menu::addActionToQMenuAndActionHash(MenuWrapper* destinationMenu,                                             const QString& actionName,                                             const QKeySequence& shortcut,                                             const QObject* receiver,                                             const char* member,                                             QAction::MenuRole role,                                             int menuItemLocation) {    QAction* action = NULL;    QAction* actionBefore = NULL;     if (menuItemLocation >= 0 && destinationMenu->actions().size() > menuItemLocation) {        actionBefore = destinationMenu->actions()[menuItemLocation];    }     if (!actionBefore) {        if (receiver && member) {            action = destinationMenu->addAction(actionName, receiver, member, shortcut);        } else {            action = destinationMenu->addAction(actionName);            action->setShortcut(shortcut);        }    } else {        action = new QAction(actionName, destinationMenu);        action->setShortcut(shortcut);        destinationMenu->insertAction(actionBefore, action);         if (receiver && member) {            connect(action, SIGNAL(triggered()), receiver, member);        }    }    action->setMenuRole(role);     _actionHash.insert(actionName, action);     return action;} QAction* Menu::addActionToQMenuAndActionHash(MenuWrapper* destinationMenu,                                             QAction* action,                                             const QString& actionName,                                             const QKeySequence& shortcut,                                             QAction::MenuRole role,                                             int menuItemLocation) {    QAction* actionBefore = NULL;     if (menuItemLocation >= 0 && destinationMenu->actions().size() > menuItemLocation) {        actionBefore = destinationMenu->actions()[menuItemLocation];    }     if (!actionName.isEmpty()) {        action->setText(actionName);    }     if (shortcut != 0) {        action->setShortcut(shortcut);    }     if (role != QAction::NoRole) {        action->setMenuRole(role);    }     if (!actionBefore) {        destinationMenu->addAction(action);    } else {        destinationMenu->insertAction(actionBefore, action);    }     _actionHash.insert(action->text(), action);     return action;} QAction* Menu::addCheckableActionToQMenuAndActionHash(MenuWrapper* destinationMenu,                                                      const QString& actionName,                                                      const QKeySequence& shortcut,                                                      const bool checked,                                                      const QObject* receiver,                                                      const char* member,                                                      int menuItemLocation) {     QAction* action = addActionToQMenuAndActionHash(destinationMenu, actionName, shortcut, receiver, member,                                                        QAction::NoRole, menuItemLocation);    action->setCheckable(true);    action->setChecked(checked);     return action;} void Menu::removeAction(MenuWrapper* menu, const QString& actionName) {    menu->removeAction(_actionHash.value(actionName));    _actionHash.remove(actionName);} void Menu::setIsOptionChecked(const QString& menuOption, bool isChecked) {    if (thread() != QThread::currentThread()) {        QMetaObject::invokeMethod(Menu::getInstance(), "setIsOptionChecked", Qt::BlockingQueuedConnection,                    Q_ARG(const QString&, menuOption),                    Q_ARG(bool, isChecked));        return;    }    QAction* menu = _actionHash.value(menuOption);    if (menu) {        menu->setChecked(isChecked);    }} bool Menu::isOptionChecked(const QString& menuOption) const {    const QAction* menu = _actionHash.value(menuOption);    if (menu) {        return menu->isChecked();    }    return false;} void Menu::triggerOption(const QString& menuOption) {    QAction* action = _actionHash.value(menuOption);    if (action) {        action->trigger();    } else {        qCDebug(interfaceapp) << "NULL Action for menuOption '" << menuOption << "'";    }} QAction* Menu::getActionForOption(const QString& menuOption) {    return _actionHash.value(menuOption);} QAction* Menu::getActionFromName(const QString& menuName, MenuWrapper* menu) {    QList<QAction*> menuActions;    if (menu) {        menuActions = menu->actions();    } else {        menuActions = actions();    }     foreach (QAction* menuAction, menuActions) {        QString actionText = menuAction->text();        if (menuName == menuAction->text()) {            return menuAction;        }    }    return NULL;} MenuWrapper* Menu::getSubMenuFromName(const QString& menuName, MenuWrapper* menu) {    QAction* action = getActionFromName(menuName, menu);    if (action) {        return MenuWrapper::fromMenu(action->menu());    }    return NULL;} MenuWrapper* Menu::getMenuParent(const QString& menuName, QString& finalMenuPart) {    QStringList menuTree = menuName.split(">");    MenuWrapper* parent = NULL;    MenuWrapper* menu = NULL;    foreach (QString menuTreePart, menuTree) {        parent = menu;        finalMenuPart = menuTreePart.trimmed();        menu = getSubMenuFromName(finalMenuPart, parent);        if (!menu) {            break;        }    }    return parent;} MenuWrapper* Menu::getMenu(const QString& menuName) {    QStringList menuTree = menuName.split(">");    MenuWrapper* parent = NULL;    MenuWrapper* menu = NULL;    int item = 0;    foreach (QString menuTreePart, menuTree) {        menu = getSubMenuFromName(menuTreePart.trimmed(), parent);        if (!menu) {            break;        }        parent = menu;        item++;    }    return menu;} QAction* Menu::getMenuAction(const QString& menuName) {    QStringList menuTree = menuName.split(">");    MenuWrapper* parent = NULL;    QAction* action = NULL;    foreach (QString menuTreePart, menuTree) {        action = getActionFromName(menuTreePart.trimmed(), parent);        if (!action) {            break;        }        parent = MenuWrapper::fromMenu(action->menu());    }    return action;} int Menu::findPositionOfMenuItem(MenuWrapper* menu, const QString& searchMenuItem) {    int position = 0;    foreach(QAction* action, menu->actions()) {        if (action->text() == searchMenuItem) {            return position;        }        position++;    }    return UNSPECIFIED_POSITION; // not found} int Menu::positionBeforeSeparatorIfNeeded(MenuWrapper* menu, int requestedPosition) {    QList<QAction*> menuActions = menu->actions();    if (requestedPosition > 1 && requestedPosition < menuActions.size()) {        QAction* beforeRequested = menuActions[requestedPosition - 1];        if (beforeRequested->isSeparator()) {            requestedPosition--;        }    }    return requestedPosition;}  MenuWrapper* Menu::addMenu(const QString& menuName) {    QStringList menuTree = menuName.split(">");    MenuWrapper* addTo = NULL;    MenuWrapper* menu = NULL;    foreach (QString menuTreePart, menuTree) {        menu = getSubMenuFromName(menuTreePart.trimmed(), addTo);        if (!menu) {            if (!addTo) {                menu = new MenuWrapper(QMenuBar::addMenu(menuTreePart.trimmed()));            } else {                menu = addTo->addMenu(menuTreePart.trimmed());            }        }        addTo = menu;    }     QMenuBar::repaint();    return menu;} void Menu::removeMenu(const QString& menuName) {    QAction* action = getMenuAction(menuName);     // only proceed if the menu actually exists    if (action) {        QString finalMenuPart;        MenuWrapper* parent = getMenuParent(menuName, finalMenuPart);        if (parent) {            parent->removeAction(action);        } else {            QMenuBar::removeAction(action);        }         QMenuBar::repaint();    }} bool Menu::menuExists(const QString& menuName) {    QAction* action = getMenuAction(menuName);     // only proceed if the menu actually exists    if (action) {        return true;    }    return false;} void Menu::addSeparator(const QString& menuName, const QString& separatorName) {    MenuWrapper* menuObj = getMenu(menuName);    if (menuObj) {        addDisabledActionAndSeparator(menuObj, separatorName);    }} void Menu::removeSeparator(const QString& menuName, const QString& separatorName) {    MenuWrapper* menu = getMenu(menuName);    bool separatorRemoved = false;    if (menu) {        int textAt = findPositionOfMenuItem(menu, separatorName);        QList<QAction*> menuActions = menu->actions();        QAction* separatorText = menuActions[textAt];        if (textAt > 0 && textAt < menuActions.size()) {            QAction* separatorLine = menuActions[textAt - 1];            if (separatorLine) {                if (separatorLine->isSeparator()) {                    menu->removeAction(separatorText);                    menu->removeAction(separatorLine);                    separatorRemoved = true;                }            }        }    }    if (separatorRemoved) {        QMenuBar::repaint();    }} void Menu::addMenuItem(const MenuItemProperties& properties) {    MenuWrapper* menuObj = getMenu(properties.menuName);    if (menuObj) {        QShortcut* shortcut = NULL;        if (!properties.shortcutKeySequence.isEmpty()) {            shortcut = new QShortcut(properties.shortcutKeySequence, this);        }         // check for positioning requests        int requestedPosition = properties.position;        if (requestedPosition == UNSPECIFIED_POSITION && !properties.beforeItem.isEmpty()) {            requestedPosition = findPositionOfMenuItem(menuObj, properties.beforeItem);            // double check that the requested location wasn't a separator label            requestedPosition = positionBeforeSeparatorIfNeeded(menuObj, requestedPosition);        }        if (requestedPosition == UNSPECIFIED_POSITION && !properties.afterItem.isEmpty()) {            int afterPosition = findPositionOfMenuItem(menuObj, properties.afterItem);            if (afterPosition != UNSPECIFIED_POSITION) {                requestedPosition = afterPosition + 1;            }        }         QAction* menuItemAction = NULL;        if (properties.isSeparator) {            addDisabledActionAndSeparator(menuObj, properties.menuItemName, requestedPosition);

Lines 501–1000 of 1091. Previous lines Load more