void DesktopWindow::updateFromSettings(Settings& settings, bool changeSlide) { setDesktopFolder(); setWallpaperFile(settings.wallpaper()); setWallpaperMode(settings.wallpaperMode()); setLastSlide(settings.lastSlide()); QString wallpaperDir = settings.wallpaperDir(); if(wallpaperDir_ != wallpaperDir) { changeSlide = true; // another wallpapaer directory; change slide! } setWallpaperDir(wallpaperDir); int interval = settings.slideShowInterval(); if(interval > 0 && (interval < MIN_SLIDE_INTERVAL || interval > MAX_SLIDE_INTERVAL)) { interval = qBound(MIN_SLIDE_INTERVAL, interval, MAX_SLIDE_INTERVAL); settings.setSlideShowInterval(interval); } setSlideShowInterval(interval); setWallpaperRandomize(settings.wallpaperRandomize()); setFont(settings.desktopFont()); setIconSize(Fm::FolderView::IconMode, QSize(settings.desktopIconSize(), settings.desktopIconSize())); setMargins(settings.desktopCellMargins()); // setIconSize and setMargins may trigger relayout of items by QListView, so we need to do the layout again. queueRelayout(); setForeground(settings.desktopFgColor()); setBackground(settings.desktopBgColor()); setShadow(settings.desktopShadowColor()); showWmMenu_ = settings.showWmMenu(); if(slideShowInterval_ > 0 && QFileInfo(wallpaperDir_).isDir()) { if(!wallpaperTimer_) { changeSlide = true; // slideshow activated; change slide! wallpaperTimer_ = new QTimer(); connect(wallpaperTimer_, &QTimer::timeout, this, &DesktopWindow::nextWallpaper); } else { wallpaperTimer_->stop(); // restart the timer after updating wallpaper } if(changeSlide) { pickWallpaper(); } else if(QFile::exists(lastSlide_)) { /* show the last slide if it still exists, otherwise show the wallpaper until timeout */ wallpaperFile_ = lastSlide_; } } else if(wallpaperTimer_) { wallpaperTimer_->stop(); delete wallpaperTimer_; wallpaperTimer_ = nullptr; } updateWallpaper(); update(); if(wallpaperTimer_) { wallpaperTimer_->start(slideShowInterval_); } }
Button(const std::string& text, const Inputs& inputs): osgWidget::Label("", text), _xyz(inputs) { setupLabel(this); setEventMask(osgWidget::EVENT_MASK_MOUSE_CLICK); setShadow(0.1f); addHeight(4.0f); }
TextField::TextField( ) { setFontSize(12); setColor(QColor(192, 192, 192)); setBGColor(QColor(0, 0, 0)); setFont("Helvetica"); setAlignment(Qt::AlignLeft); setFixedPitch(false); setShadow(0); }
TextField::TextField( const TextField& def ) { setFontSize( def.getFontSize() ); setColor(def.getColor()); setBGColor(def.getBGColor()); setFont( def.getFont() ); setAlignment( def.getAlignment() ); setFixedPitch( def.getFixedPitch() ); setShadow( def.getShadow() ); }
void DesktopWindow::updateFromSettings(Settings& settings) { setDesktopFolder(); setWallpaperFile(settings.wallpaper()); setWallpaperMode(settings.wallpaperMode()); setFont(settings.desktopFont()); setIconSize(Fm::FolderView::IconMode, QSize(settings.desktopIconSize(), settings.desktopIconSize())); setMargins(settings.desktopCellMargins()); // setIconSize and setMargins may trigger relayout of items by QListView, so we need to do the layout again. queueRelayout(); setForeground(settings.desktopFgColor()); setBackground(settings.desktopBgColor()); setShadow(settings.desktopShadowColor()); showWmMenu_ = settings.showWmMenu(); updateWallpaper(); update(); }
TextField& TextField::operator=(const TextField& rhs) { if( this == &rhs) return *this; setFontSize( rhs.getFontSize() ); setColor(rhs.getColor()); setBGColor(rhs.getBGColor()); setFont( rhs.getFont() ); setAlignment( rhs.getAlignment() ); setFixedPitch( rhs.getFixedPitch() ); setShadow( rhs.getShadow() ); return *this; }
void DesktopWindow::removeBottomGap() { /************************************************************ NOTE: Desktop is an area bounded from below while icons snap to its grid srarting from above. Therefore, we try to adjust the vertical cell margin to prevent relatively large gaps from taking shape at the desktop bottom. ************************************************************/ auto delegate = static_cast<Fm::FolderItemDelegate*>(listView_->itemDelegateForColumn(0)); auto itemSize = delegate->itemSize(); qDebug() << "delegate:" << delegate->itemSize(); QSize cellMargins = getMargins(); int workAreaHeight = qApp->desktop()->availableGeometry(screenNum_).height() - 24; // a 12-pix margin will be considered everywhere int cellHeight = itemSize.height() + listView_->spacing(); int iconNumber = workAreaHeight / cellHeight; int bottomGap = workAreaHeight % cellHeight; /******************************************* First try to make room for an extra icon... *******************************************/ // If one pixel is subtracted from the vertical margin, cellHeight // will decrease by 2 while bottomGap will increase by 2*iconNumber. // So, we can add an icon to the bottom once this inequality holds: // bottomGap + 2*n*iconNumber >= cellHeight - 2*n // From here, we get our "subtrahend": qreal exactNumber = ((qreal)cellHeight - (qreal)bottomGap) / (2.0 * (qreal)iconNumber + 2.0); int subtrahend = (int)exactNumber + ((int)exactNumber == exactNumber ? 0 : 1); Settings& settings = static_cast<Application*>(qApp)->settings(); int minCellHeight = settings.desktopCellMargins().height(); if(subtrahend > 0 && cellMargins.height() - subtrahend >= minCellHeight) { cellMargins -= QSize(0, subtrahend); } /*************************************************** ... but if that can't be done, try to spread icons! ***************************************************/ else { cellMargins += QSize(0, (bottomGap / iconNumber) / 2); } // set the new margins (if they're changed) delegate->setMargins(cellMargins); setMargins(cellMargins); // in case the text shadow is reset to (0,0,0,0) setShadow(settings.desktopShadowColor()); }
DX11Widget::DX11Widget(DObjectPrivate &dd, QWidget *parent) : QWidget(parent), DObject(dd) { D_D(DX11Widget); d->init(); QWidget::setLayout(d->rootLayout); QWidget::setAttribute(Qt::WA_TranslucentBackground, true); QWidget::setWindowFlags(Qt::Window | Qt::FramelessWindowHint); setWindowFlags(windowFlags()); // resize(size()); setShadow(); XUtils::SetWindowExtents(this, WindowGlowRadius); DX11Widget::adjustSize(); }
CWindowObject::CWindowObject(int options_, std::string imageName): CIntObject(getUsedEvents(options_), Point()), shadow(nullptr), options(options_), background(createBg(imageName, options & PLAYER_COLORED)) { assert(parent == nullptr); //Safe to remove, but windows should not have parent if (options & RCLICK_POPUP) CCS->curh->hide(); if (background) pos = background->center(); else center(Point(screen->w/2, screen->h/2)); if (!(options & SHADOW_DISABLED)) setShadow(true); }
bool ComponentAnim::loadAnimations(std::string fname) { int maskW = 0, maskH = 0, xoffset = 0, yoffset = 0; int ncol = 0, nrow = 0; // Carga el archivo de config y lee FILE* f = fopen(fname.c_str(), "rb"); // Si el archivo es inválido, no se puede hacer nada if (f == NULL) return false; // 0. Columnas y filas if (fscanf(f, "%d %d", &ncol, &nrow) < 2) return false; // 1. Dimensiones de la máscara if (fscanf(f, "%d %d %d %d", &maskW, &maskH, &xoffset, &yoffset) < 2) return false; e->mask = new MaskBox(e->x, e->y, maskW, maskH, "enemy", xoffset, yoffset); setShadow(maskW); e->graphic = new SpriteMap(gfxPath, ncol, nrow, game->getGfxEngine()); //SpriteMap* gfx = ((SpriteMap*) e->graphic); // 2. Leer todas las animaciones // Stand loadAnimation(STAND, UP, "stu", f); loadAnimation(STAND, DOWN, "std", f); loadAnimation(STAND, LEFT, "stl", f); loadAnimation(STAND, RIGHT, "str", f); // Walk loadAnimation(WALK, UP, "wau", f); loadAnimation(WALK, DOWN, "wad", f); loadAnimation(WALK, LEFT, "wal", f); loadAnimation(WALK, RIGHT, "war", f); // AtkMelee loadAnimation(ATKMELEE, UP, "amu", f); loadAnimation(ATKMELEE, DOWN, "amd", f); loadAnimation(ATKMELEE, LEFT, "aml", f); loadAnimation(ATKMELEE, RIGHT, "amr", f); // AtkRanged loadAnimation(ATKRANGED, UP, "aru", f); loadAnimation(ATKRANGED, DOWN, "ard", f); loadAnimation(ATKRANGED, LEFT, "arl", f); loadAnimation(ATKRANGED, RIGHT, "arr", f); // AtkSpecial loadAnimation(ATKSPECIAL, UP, "asu", f); loadAnimation(ATKSPECIAL, DOWN, "asd", f); loadAnimation(ATKSPECIAL, LEFT, "asl", f); loadAnimation(ATKSPECIAL, RIGHT, "asr", f); // Damaged loadAnimation(DAMAGED, UP, "dmu", f); loadAnimation(DAMAGED, DOWN, "dmd", f); loadAnimation(DAMAGED, LEFT, "dml", f); loadAnimation(DAMAGED, RIGHT, "dmr", f); // Dead loadAnimation(DEAD, UP, "deu", f); loadAnimation(DEAD, DOWN, "ded", f); loadAnimation(DEAD, LEFT, "del", f); loadAnimation(DEAD, RIGHT, "der", f); fclose(f); return true; };
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { setupUi(this); Finished_Init = false; AllowInit = false; PreBuf_timer = new QTimer; Update_timer= new QTimer; Ping_timer= new QTimer; Spectrum_timer = new QTimer; BufferStatusUpdate_timer= new QTimer; singleClickTimer=new QTimer; m_msgbox = NULL; isPlaying=false; syncLost=false; currentRadio=NULL; currentTrack=""; dConnectionProgress=NULL; dDelConfirm=NULL; dShowHistory=NULL; netManager=NULL; currentRadioURL=-1; streamsErrLoop=false; pSpec=NULL; mMoving=false; savedVolume=0.5; isMuted=false; treeSelectionChanged=false; isRecording=false; newVersionAnimation=NULL; recButtonAnimation=NULL; isRootOperation=false; #ifdef VISUALS isVisResized=false; isVisRendering=false; visWin=new VisWinCL(this); bigVis=false; bigVisRunning=false; #endif initBitRate(); initOggQualityMap(); qDebug()<<"Cheking BASS version"; if (HIWORD(BASS_GetVersion())!=BASSVERSION) { qDebug()<<"An incorrect version of BASS.DLL was loaded"; QMessageBox::warning(this,QString("warning"),QString("An incorrect version of BASS.DLL was loaded")); } BASS_SetConfigPtr(BASS_CONFIG_NET_AGENT, (void*) _T(PLAYER_HTTPAGENT)); #ifdef Q_OS_WIN if (BASS_PluginLoad("bass_aac.dll",0)==0) { qDebug()<<"Unable to load bass_aac.ddl BassError="<<BASS_ErrorGetCode(); } #elif Q_OS_LINUX if (BASS_PluginLoad("bass_aac.so",0)==0) { qDebug()<<"Unable to load bass_aac.ddl BassError="<<BASS_ErrorGetCode(); } #endif QSettings tSettings(AppPath+CONFIG_FILENAME,QSettings::IniFormat); tSettings.setIniCodec("ISO 8859-1"); Proxy=tSettings.value("proxy","").toString(); ProxyPort=tSettings.value("proxyport","").toString(); ProxyUser=tSettings.value("proxyuser","").toString(); ProxyPass=tSettings.value("proxypass","").toString(); visualPlugin=tSettings.value("visual",VIS_WIN_PLUG).toString(); qDebug()<<"visualPlugin="<<visualPlugin; recPath=tSettings.value("recpath","").toString(); recPath=recPath.replace("\\","\\\\"); #ifdef Q_OS_WIN if (recPath!="" && recPath.at(recPath.length()-1)!='\\') recPath=recPath+"\\"; #else if (recPath!="" && recPath.at(recPath.length()-1)!='/') recPath=recPath+"/"; #endif if (recPath=="") { #ifdef Q_OS_WIN recPath=QDir::toNativeSeparators(QStandardPaths::standardLocations(QStandardPaths::MusicLocation).at(0)+"/"); #endif #ifdef Q_OS_MAC recPath=AppPath.fromLatin1(argv[0]); recPath+="/"; #endif } qDebug()<<"Recording path ="<<recPath; if (Proxy!="") { qDebug()<<"Proxy="<<Proxy; QString tBassProxyStr=ProxyUser; if (ProxyPass!="") tBassProxyStr+=":"+ProxyPass; if (ProxyUser!="") tBassProxyStr+="@"; tBassProxyStr+=Proxy+":"+ProxyPort; qDebug()<<"BASSProxy="<<tBassProxyStr; qDebug()<<"BASSProxy="<<tBassProxyStr.toLatin1().data(); //strcpy(proxyStrChar,Proxy.toLatin1().data()); BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,tBassProxyStr.toLatin1().data()); //BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,&proxyStrChar); } else { BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY, NULL); } //if( !InitVersion() ) ErrorMsgBox(_T("\n Error Setting up Version strings \n")); if( !InitBassErrorMap() ) ErrorMsgBox(_T("\n Error setting up Error Msgs \n")); if (!BASS_Init(-1,44100,0,NULL,NULL)) { ErrorMsgBox(_T("\nUnable to initialize BASS library\n"), 86, false); exit(86); } savedVolume=BASS_GetVolume(); slVolume->setValue(savedVolume*slVolume->maximum()); #ifdef Q_OS_WIN // allocate ACM format buffer, using suggested buffer size acmformlen = BASS_Encode_GetACMFormat(0,NULL,0,NULL,0); acmform = (WAVEFORMATEX*)malloc(acmformlen); memset(acmform,0,acmformlen); acmduncil = (WAVEFORMATEX*)malloc(acmformlen); memset(acmduncil, 0, acmformlen); // #endif connect(radioTree,SIGNAL(AddStationSig(QModelIndex,RadioCL*)),this,SLOT(AddStation(QModelIndex,RadioCL*))); connect(radioTree, SIGNAL(treeSelectionChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(radioTreeSelectionChanges(const QModelIndex &, const QModelIndex &))); qDebug()<<"Connecting timers signals "; connect(PreBuf_timer, SIGNAL(timeout()), this, SLOT(prebufTimeout())); connect(Update_timer, SIGNAL(timeout()), this, SLOT(updateTimeout())); connect(Ping_timer, SIGNAL(timeout()),this, SLOT(pingRadio())); connect(Spectrum_timer, SIGNAL(timeout()), this, SLOT(specTimeout())); connect(BufferStatusUpdate_timer, SIGNAL(timeout()),this, SLOT(updateBufferStatus())); connect(singleClickTimer, SIGNAL(timeout()),this, SLOT(singleClickTimeout())); qDebug()<<"Connecting mgh signals"; connect( &mgh, SIGNAL(SendUpdTrackInfo(QString)), this, SLOT(on_UpdTrackInfo(QString)) ); connect( &mgh, SIGNAL(SendUpdRadioInfo(QString,QString,QString,QString)), this, SLOT(on_UpdRadioInfo(QString,QString,QString,QString))); connect( &mgh, SIGNAL(SendSyncLost()), this, SLOT(on_SyncLost()) ); connect( &mgh, SIGNAL(SendPlaybackStarts()), this, SLOT(on_PlaybackStarts()) ); connect( &mgh, SIGNAL(SendClickRecord()), this, SLOT(on_ClickRecord()) ); qDebug()<<"Creating actions"; createActions(); qDebug()<<"Creating tray icon"; createTrayIcon(); qDebug()<<"Setting tray icon"; setIcon(PLAYER_STATUS_INACTIVE); trayIcon->setVisible(true); trayIcon->show(); setWindowTitle(QString(PLAYER_NAME)+" v"+RADIOLA_VERSION); qDebug()<<"Initializing spectrum image"; specbuf = NULL; specmode = DEFAULT_SPEC_MODE; // spectrum mode specpos = 0; // spectrum mode (and marker pos for 2nd mode) pSpec = new QImage(SPECWIDTH, SPECHEIGHT, QImage::Format_Indexed8); // setup palette pSpec->setColor(0, qRgb(0,0,0)); for(int a=1; a < 128; a++) { pSpec->setColor(a, qRgb(2*a, 256-2*a, 0)); } for(int a=0; a < 32; a++) { pSpec->setColor(128+a, qRgb(0, 0, 8*a)); pSpec->setColor(128+32+a, qRgb(8*a, 0, 255)); pSpec->setColor(128+64+a, qRgb(255, 8*a, 8*(31-a))); //pSpec->setColor(128+64+a, qRgb(8*(31-a), 8*a, 8*a)); pSpec->setColor(128+96+a, qRgb(255, 255, 8*a)); //pSpec->setColor(128+96+a, qRgb(255, 255, 8*a)); } pSpec->setColor(254, qRgb(112, 112, 255)); pSpec->setColor(253, qRgb(255, 128, 128)); pSpec->setColor(255, qRgb(212,208,200)); // background color // create the bitmap specbuf = (BYTE*)pSpec->bits(); pSpec->fill(255); specButton->setSpec(pSpec); readSettings(); qDebug()<<"Connecting tray signals "; connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(iconActivated(QSystemTrayIcon::ActivationReason))); setupRadioTree(); historyFile.setFileName(GetHistoryDir()); if (!historyFile.open(QIODevice::ReadWrite | QIODevice::Append)) { qDebug()<<"Unable to open history file for write"<<historyFile.fileName(); return; } StopPlayback(); QIcon icon = QIcon(MAINWIN_ICON); setWindowIcon(icon); new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_S), this, SLOT(showSettings())); new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_E), this, SLOT(showRecPath())); new QShortcut(QKeySequence(Qt::Key_F1), this, SLOT(showHelp())); new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_H), this, SLOT(showHistory())); #ifdef Q_OS_WIN new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_V), this, SLOT(showVisualization())); #endif new QShortcut(QKeySequence(Qt::Key_Space), this, SLOT(on_pbPlay_clicked())); new QShortcut(QKeySequence(Qt::Key_MediaPlay), this, SLOT(on_pbPlay_clicked())); new QShortcut(QKeySequence(Qt::Key_Delete), this, SLOT(removeRow())); new QShortcut(QKeySequence(Qt::Key_Insert), this, SLOT(insertStation())); new QShortcut(QKeySequence(Qt::Key_Plus), this, SLOT(insertSubfolder())); QGraphicsDropShadowEffect* effect = new QGraphicsDropShadowEffect(); effect->setBlurRadius(1); //Adjust accordingly effect->setOffset(3,3); //Adjust accordingly setShadow(bnShowHistory); setShadow(pbPlay); setShadow(pbRecord); setShadow(pbQuit); recButtonAnimation=new QMovie(":/images/rec_animation.gif"); connect(recButtonAnimation,SIGNAL(frameChanged(int)),this,SLOT(setRecButtonIcon(int))); singleClickTimer->setInterval(QApplication::doubleClickInterval()); singleClickTimer->setSingleShot(true); CheckNewVersion(); netManager = new QNetworkAccessManager(this); if (Proxy!="") { netManager->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,Proxy,ProxyPort.toInt(),ProxyUser,ProxyPass)); } connect(netManager, SIGNAL(finished(QNetworkReply*)),this, SLOT(pingReply(QNetworkReply*))); }
Menu::Menu() { auto dialogsManager = DependencyManager::get<DialogsManager>(); auto accountManager = DependencyManager::get<AccountManager>(); // File/Application menu ---------------------------------- MenuWrapper* fileMenu = addMenu("File"); // File > Login menu items { addActionToQMenuAndActionHash(fileMenu, MenuOption::Login); // connect to the appropriate signal of the AccountManager so that we can change the Login/Logout menu item connect(accountManager.data(), &AccountManager::profileChanged, dialogsManager.data(), &DialogsManager::toggleLoginDialog); connect(accountManager.data(), &AccountManager::logoutComplete, dialogsManager.data(), &DialogsManager::toggleLoginDialog); } // File > Quit addActionToQMenuAndActionHash(fileMenu, MenuOption::Quit, Qt::CTRL | Qt::Key_Q, qApp, SLOT(quit()), QAction::QuitRole); // Edit menu ---------------------------------- MenuWrapper* editMenu = addMenu("Edit"); // Edit > Cut auto cutAction = addActionToQMenuAndActionHash(editMenu, "Cut", QKeySequence::Cut); connect(cutAction, &QAction::triggered, [] { QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_X, Qt::ControlModifier); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); }); // Edit > Copy auto copyAction = addActionToQMenuAndActionHash(editMenu, "Copy", QKeySequence::Copy); connect(copyAction, &QAction::triggered, [] { QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_C, Qt::ControlModifier); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); }); // Edit > Paste auto pasteAction = addActionToQMenuAndActionHash(editMenu, "Paste", QKeySequence::Paste); connect(pasteAction, &QAction::triggered, [] { QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_V, Qt::ControlModifier); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); }); // Edit > Delete auto deleteAction = addActionToQMenuAndActionHash(editMenu, "Delete", QKeySequence::Delete); connect(deleteAction, &QAction::triggered, [] { QKeyEvent* keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_Delete, Qt::ControlModifier); QCoreApplication::postEvent(QCoreApplication::instance(), keyEvent); }); editMenu->addSeparator(); // Edit > Running Scripts auto action = addActionToQMenuAndActionHash(editMenu, MenuOption::RunningScripts, Qt::CTRL | Qt::Key_J); connect(action, &QAction::triggered, [] { if (!qApp->getLoginDialogPoppedUp()) { static const QUrl widgetUrl("hifi/dialogs/RunningScripts.qml"); static const QUrl tabletUrl("hifi/dialogs/TabletRunningScripts.qml"); static const QString name("RunningScripts"); qApp->showDialog(widgetUrl, tabletUrl, name); } }); editMenu->addSeparator(); // Edit > Asset Browser auto assetServerAction = addActionToQMenuAndActionHash(editMenu, MenuOption::AssetServer, Qt::CTRL | Qt::SHIFT | Qt::Key_A, qApp, SLOT(showAssetServerWidget())); { auto nodeList = DependencyManager::get<NodeList>(); QObject::connect(nodeList.data(), &NodeList::canWriteAssetsChanged, assetServerAction, &QAction::setEnabled); assetServerAction->setEnabled(nodeList->getThisNodeCanWriteAssets()); } // Edit > Avatar Packager #ifndef Q_OS_ANDROID action = addActionToQMenuAndActionHash(editMenu, MenuOption::AvatarPackager); connect(action, &QAction::triggered, [] { DependencyManager::get<AvatarPackager>()->open(); }); #endif // Edit > Reload All Content addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches())); // Display menu ---------------------------------- // FIXME - this is not yet matching Alan's spec because it doesn't have // menus for "2D"/"3D" - we need to add support for detecting the appropriate // default 3D display mode addMenu(DisplayPlugin::MENU_PATH()); MenuWrapper* displayModeMenu = addMenu(MenuOption::OutputMenu); QActionGroup* displayModeGroup = new QActionGroup(displayModeMenu); displayModeGroup->setExclusive(true); // View menu ---------------------------------- MenuWrapper* viewMenu = addMenu("View"); QActionGroup* cameraModeGroup = new QActionGroup(viewMenu); // View > [camera group] cameraModeGroup->setExclusive(true); // View > First Person auto firstPersonAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash( viewMenu, MenuOption::FirstPerson, 0, true, qApp, SLOT(cameraMenuChanged()))); firstPersonAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); // View > Third Person auto thirdPersonAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash( viewMenu, MenuOption::ThirdPerson, 0, false, qApp, SLOT(cameraMenuChanged()))); thirdPersonAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); // View > Mirror auto viewMirrorAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash( viewMenu, MenuOption::FullscreenMirror, 0, false, qApp, SLOT(cameraMenuChanged()))); viewMirrorAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); // View > Independent auto viewIndependentAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::IndependentMode, 0, false, qApp, SLOT(cameraMenuChanged()))); viewIndependentAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); // View > Entity Camera auto viewEntityCameraAction = cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CameraEntityMode, 0, false, qApp, SLOT(cameraMenuChanged()))); viewEntityCameraAction->setProperty(EXCLUSION_GROUP_KEY, QVariant::fromValue(cameraModeGroup)); viewMenu->addSeparator(); // View > Center Player In View addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CenterPlayerInView, 0, true, qApp, SLOT(rotationModeChanged())); // View > Enter First Person Mode in HMD addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FirstPersonHMD, 0, true); //TODO: Remove Navigation menu when these functions are included in GoTo menu // Navigate menu ---------------------------------- MenuWrapper* navigateMenu = addMenu("Navigate"); // Navigate > LocationBookmarks related menus -- Note: the LocationBookmarks class adds its own submenus here. auto locationBookmarks = DependencyManager::get<LocationBookmarks>(); locationBookmarks->setupMenus(this, navigateMenu); // Navigate > Copy Address auto addressManager = DependencyManager::get<AddressManager>(); addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyAddress, 0, addressManager.data(), SLOT(copyAddress())); // Navigate > Copy Path addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyPath, 0, addressManager.data(), SLOT(copyPath())); // Navigate > Start-up Location MenuWrapper* startupLocationMenu = navigateMenu->addMenu(MenuOption::StartUpLocation); QActionGroup* startupLocatiopnGroup = new QActionGroup(startupLocationMenu); startupLocatiopnGroup->setExclusive(true); startupLocatiopnGroup->addAction(addCheckableActionToQMenuAndActionHash(startupLocationMenu, MenuOption::HomeLocation, 0, false)); startupLocatiopnGroup->addAction(addCheckableActionToQMenuAndActionHash(startupLocationMenu, MenuOption::LastLocation, 0, true)); // Settings menu ---------------------------------- MenuWrapper* settingsMenu = addMenu("Settings"); // Settings > General... action = addActionToQMenuAndActionHash(settingsMenu, MenuOption::Preferences, Qt::CTRL | Qt::Key_G, nullptr, nullptr); connect(action, &QAction::triggered, [] { if (!qApp->getLoginDialogPoppedUp()) { qApp->showDialog(QString("hifi/dialogs/GeneralPreferencesDialog.qml"), QString("hifi/tablet/TabletGeneralPreferences.qml"), "GeneralPreferencesDialog"); } }); // Settings > Controls... action = addActionToQMenuAndActionHash(settingsMenu, "Controls..."); connect(action, &QAction::triggered, [] { auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system"); auto hmd = DependencyManager::get<HMDScriptingInterface>(); tablet->pushOntoStack("hifi/tablet/ControllerSettings.qml"); if (!hmd->getShouldShowTablet()) { hmd->toggleShouldShowTablet(); } }); // Settings > Audio... action = addActionToQMenuAndActionHash(settingsMenu, "Audio..."); connect(action, &QAction::triggered, [] { static const QUrl tabletUrl("hifi/audio/Audio.qml"); auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system"); auto hmd = DependencyManager::get<HMDScriptingInterface>(); tablet->pushOntoStack(tabletUrl); if (!hmd->getShouldShowTablet()) { hmd->toggleShouldShowTablet(); } }); // Settings > Graphics... action = addActionToQMenuAndActionHash(settingsMenu, "Graphics..."); connect(action, &QAction::triggered, [] { qApp->showDialog(QString("hifi/dialogs/GraphicsPreferencesDialog.qml"), QString("hifi/tablet/TabletGraphicsPreferences.qml"), "GraphicsPreferencesDialog"); }); // Settings > Security... action = addActionToQMenuAndActionHash(settingsMenu, "Security..."); connect(action, &QAction::triggered, [] { auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system"); auto hmd = DependencyManager::get<HMDScriptingInterface>(); tablet->pushOntoStack("hifi/dialogs/security/Security.qml"); if (!hmd->getShouldShowTablet()) { hmd->toggleShouldShowTablet(); } }); // Settings > Developer Menu addCheckableActionToQMenuAndActionHash(settingsMenu, "Developer Menu", 0, false, this, SLOT(toggleDeveloperMenus())); // Settings > Ask to Reset Settings addCheckableActionToQMenuAndActionHash(settingsMenu, MenuOption::AskToResetSettings, 0, false); // Developer menu ---------------------------------- MenuWrapper* developerMenu = addMenu("Developer", "Developer"); // Developer > Scripting >>> MenuWrapper* scriptingOptionsMenu = developerMenu->addMenu("Scripting"); // Developer > Scripting > Console... addActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::Console, Qt::CTRL | Qt::ALT | Qt::Key_J, DependencyManager::get<StandAloneJSConsole>().data(), SLOT(toggleConsole()), QAction::NoRole, UNSPECIFIED_POSITION); // Developer > Scripting > API Debugger action = addActionToQMenuAndActionHash(scriptingOptionsMenu, "API Debugger"); connect(action, &QAction::triggered, [] { QUrl defaultScriptsLoc = PathUtils::defaultScriptsLocation(); defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/utilities/tools/currentAPI.js"); DependencyManager::get<ScriptEngines>()->loadScript(defaultScriptsLoc.toString()); }); // Developer > Scripting > Entity Script Server Log auto essLogAction = addActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::EntityScriptServerLog, 0, qApp, SLOT(toggleEntityScriptServerLogDialog())); { auto nodeList = DependencyManager::get<NodeList>(); QObject::connect(nodeList.data(), &NodeList::canRezChanged, essLogAction, [essLogAction] { auto nodeList = DependencyManager::get<NodeList>(); essLogAction->setEnabled(nodeList->getThisNodeCanRez()); }); essLogAction->setEnabled(nodeList->getThisNodeCanRez()); } // Developer > Scripting > Script Log (HMD friendly)... addActionToQMenuAndActionHash(scriptingOptionsMenu, "Script Log (HMD friendly)...", Qt::NoButton, qApp, SLOT(showScriptLogs())); // Developer > Scripting > Verbose Logging addCheckableActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::VerboseLogging, 0, false, qApp, SLOT(updateVerboseLogging())); // Developer > Scripting > Enable Speech Control API #if defined(Q_OS_MAC) || defined(Q_OS_WIN) auto speechRecognizer = DependencyManager::get<SpeechRecognizer>(); QAction* speechRecognizerAction = addCheckableActionToQMenuAndActionHash(scriptingOptionsMenu, MenuOption::ControlWithSpeech, Qt::CTRL | Qt::SHIFT | Qt::Key_C, speechRecognizer->getEnabled(), speechRecognizer.data(), SLOT(setEnabled(bool)), UNSPECIFIED_POSITION); connect(speechRecognizer.data(), SIGNAL(enabledUpdated(bool)), speechRecognizerAction, SLOT(setChecked(bool))); #endif // Developer > UI >>> MenuWrapper* uiOptionsMenu = developerMenu->addMenu("UI"); action = addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::DesktopTabletToToolbar, 0, qApp->getDesktopTabletBecomesToolbarSetting()); // Developer > UI > Show Overlays addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::Overlays, 0, true); // Developer > UI > Desktop Tablet Becomes Toolbar connect(action, &QAction::triggered, [action] { qApp->setDesktopTabletBecomesToolbarSetting(action->isChecked()); }); // Developer > UI > HMD Tablet Becomes Toolbar action = addCheckableActionToQMenuAndActionHash(uiOptionsMenu, MenuOption::HMDTabletToToolbar, 0, qApp->getHmdTabletBecomesToolbarSetting()); connect(action, &QAction::triggered, [action] { qApp->setHmdTabletBecomesToolbarSetting(action->isChecked()); }); // Developer > Render >>> MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render"); action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AntiAliasing, 0, true); connect(action, &QAction::triggered, [action] { auto renderConfig = qApp->getRenderEngine()->getConfiguration(); if (renderConfig) { auto mainViewJitterCamConfig = renderConfig->getConfig<JitterSample>("RenderMainView.JitterCam"); auto mainViewAntialiasingConfig = renderConfig->getConfig<Antialiasing>("RenderMainView.Antialiasing"); if (mainViewJitterCamConfig && mainViewAntialiasingConfig) { if (action->isChecked()) { mainViewJitterCamConfig->play(); mainViewAntialiasingConfig->setDebugFXAA(false); } else { mainViewJitterCamConfig->none(); mainViewAntialiasingConfig->setDebugFXAA(true); } } } }); action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Shadows, 0, true); connect(action, &QAction::triggered, [action] { auto renderConfig = qApp->getRenderEngine()->getConfiguration(); if (renderConfig) { auto lightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderMainView.LightingModel"); if (lightingModelConfig) { lightingModelConfig->setShadow(action->isChecked()); } } }); action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AmbientOcclusion, 0, false); connect(action, &QAction::triggered, [action] { auto renderConfig = qApp->getRenderEngine()->getConfiguration(); if (renderConfig) { auto lightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderMainView.LightingModel"); if (lightingModelConfig) { lightingModelConfig->setAmbientOcclusion(action->isChecked()); } } }); addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::WorldAxes); addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DefaultSkybox, 0, true); // Developer > Render > Throttle FPS If Not Focus addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::ThrottleFPSIfNotFocus, 0, true); // Developer > Render > OpenVR threaded submit addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::OpenVrThreadedSubmit, 0, true); // Developer > Render > Resolution MenuWrapper* resolutionMenu = renderOptionsMenu->addMenu(MenuOption::RenderResolution); QActionGroup* resolutionGroup = new QActionGroup(resolutionMenu); resolutionGroup->setExclusive(true); resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionOne, 0, true)); resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionTwoThird, 0, false)); resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionHalf, 0, false)); resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionThird, 0, false)); resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionQuarter, 0, false)); //const QString = "Automatic Texture Memory"; //const QString = "64 MB"; //const QString = "256 MB"; //const QString = "512 MB"; //const QString = "1024 MB"; //const QString = "2048 MB"; // Developer > Render > Maximum Texture Memory MenuWrapper* textureMenu = renderOptionsMenu->addMenu(MenuOption::RenderMaxTextureMemory); QActionGroup* textureGroup = new QActionGroup(textureMenu); textureGroup->setExclusive(true); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTextureAutomatic, 0, true)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture4MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture64MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture256MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture512MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture1024MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture2048MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture4096MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture6144MB, 0, false)); textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture8192MB, 0, false)); connect(textureGroup, &QActionGroup::triggered, [textureGroup] { auto checked = textureGroup->checkedAction(); auto text = checked->text(); gpu::Context::Size newMaxTextureMemory { 0 }; if (MenuOption::RenderMaxTexture4MB == text) { newMaxTextureMemory = MB_TO_BYTES(4); } else if (MenuOption::RenderMaxTexture64MB == text) { newMaxTextureMemory = MB_TO_BYTES(64); } else if (MenuOption::RenderMaxTexture256MB == text) { newMaxTextureMemory = MB_TO_BYTES(256); } else if (MenuOption::RenderMaxTexture512MB == text) { newMaxTextureMemory = MB_TO_BYTES(512); } else if (MenuOption::RenderMaxTexture1024MB == text) { newMaxTextureMemory = MB_TO_BYTES(1024); } else if (MenuOption::RenderMaxTexture2048MB == text) { newMaxTextureMemory = MB_TO_BYTES(2048); } else if (MenuOption::RenderMaxTexture4096MB == text) { newMaxTextureMemory = MB_TO_BYTES(4096); } else if (MenuOption::RenderMaxTexture6144MB == text) { newMaxTextureMemory = MB_TO_BYTES(6144); } else if (MenuOption::RenderMaxTexture8192MB == text) { newMaxTextureMemory = MB_TO_BYTES(8192); } gpu::Texture::setAllowedGPUMemoryUsage(newMaxTextureMemory); }); #ifdef Q_OS_WIN // Developer > Render > Enable Sparse Textures { auto action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::SparseTextureManagement, 0, gpu::Texture::getEnableSparseTextures()); connect(action, &QAction::triggered, [&](bool checked) { qDebug() << "[TEXTURE TRANSFER SUPPORT] --- Enable Dynamic Texture Management menu option:" << checked; gpu::Texture::setEnableSparseTextures(checked); }); } #else qDebug() << "[TEXTURE TRANSFER SUPPORT] Incremental Texture Transfer and Dynamic Texture Management not supported on this platform."; #endif { auto action = addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::RenderClearKtxCache); connect(action, &QAction::triggered, []{ Setting::Handle<int>(KTXCache::SETTING_VERSION_NAME, KTXCache::INVALID_VERSION).set(KTXCache::INVALID_VERSION); }); } // Developer > Render > LOD Tools addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools, 0, qApp, SLOT(loadLODToolsDialog())); // HACK enable texture decimation { auto action = addCheckableActionToQMenuAndActionHash(renderOptionsMenu, "Decimate Textures"); connect(action, &QAction::triggered, [&](bool checked) { DEV_DECIMATE_TEXTURES = checked; }); } addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::ComputeBlendshapes, 0, true, DependencyManager::get<ModelBlender>().data(), SLOT(setComputeBlendshapes(bool))); // Developer > Assets >>> // Menu item is not currently needed but code should be kept in case it proves useful again at some stage. //#define WANT_ASSET_MIGRATION #ifdef WANT_ASSET_MIGRATION MenuWrapper* assetDeveloperMenu = developerMenu->addMenu("Assets"); auto& atpMigrator = ATPAssetMigrator::getInstance(); atpMigrator.setDialogParent(this); addActionToQMenuAndActionHash(assetDeveloperMenu, MenuOption::AssetMigration, 0, &atpMigrator, SLOT(loadEntityServerFile())); #endif // Developer > Avatar >>> MenuWrapper* avatarDebugMenu = developerMenu->addMenu("Avatar"); // Developer > Avatar > Face Tracking MenuWrapper* faceTrackingMenu = avatarDebugMenu->addMenu("Face Tracking"); { QActionGroup* faceTrackerGroup = new QActionGroup(avatarDebugMenu); bool defaultNoFaceTracking = true; #ifdef HAVE_DDE defaultNoFaceTracking = false; #endif QAction* noFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking, 0, defaultNoFaceTracking, qApp, SLOT(setActiveFaceTracker())); faceTrackerGroup->addAction(noFaceTracker); #ifdef HAVE_DDE QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera, 0, true, qApp, SLOT(setActiveFaceTracker())); faceTrackerGroup->addAction(ddeFaceTracker); #endif } #ifdef HAVE_DDE faceTrackingMenu->addSeparator(); QAction* binaryEyelidControl = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::BinaryEyelidControl, 0, true); binaryEyelidControl->setVisible(true); // DDE face tracking is on by default QAction* coupleEyelids = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CoupleEyelids, 0, true); coupleEyelids->setVisible(true); // DDE face tracking is on by default QAction* useAudioForMouth = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseAudioForMouth, 0, true); useAudioForMouth->setVisible(true); // DDE face tracking is on by default QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::VelocityFilter, 0, true); ddeFiltering->setVisible(true); // DDE face tracking is on by default QAction* ddeCalibrate = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CalibrateCamera, 0, DependencyManager::get<DdeFaceTracker>().data(), SLOT(calibrate())); ddeCalibrate->setVisible(true); // DDE face tracking is on by default faceTrackingMenu->addSeparator(); addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking, [](bool mute) { FaceTracker::setIsMuted(mute); }, Qt::CTRL | Qt::SHIFT | Qt::Key_F, FaceTracker::isMuted()); addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::AutoMuteAudio, 0, false); #endif #ifdef HAVE_IVIEWHMD // Developer > Avatar > Eye Tracking MenuWrapper* eyeTrackingMenu = avatarDebugMenu->addMenu("Eye Tracking"); addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SMIEyeTracking, 0, false, qApp, SLOT(setActiveEyeTracker())); { MenuWrapper* calibrateEyeTrackingMenu = eyeTrackingMenu->addMenu("Calibrate"); addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::OnePointCalibration, 0, qApp, SLOT(calibrateEyeTracker1Point())); addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::ThreePointCalibration, 0, qApp, SLOT(calibrateEyeTracker3Points())); addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::FivePointCalibration, 0, qApp, SLOT(calibrateEyeTracker5Points())); } addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SimulateEyeTracking, 0, false, qApp, SLOT(setActiveEyeTracker())); #endif action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AvatarReceiveStats, 0, false); connect(action, &QAction::triggered, [this]{ Avatar::setShowReceiveStats(isOptionChecked(MenuOption::AvatarReceiveStats)); }); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowBoundingCollisionShapes, 0, false); connect(action, &QAction::triggered, [this]{ Avatar::setShowCollisionShapes(isOptionChecked(MenuOption::ShowBoundingCollisionShapes)); }); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowMyLookAtVectors, 0, false); connect(action, &QAction::triggered, [this]{ Avatar::setShowMyLookAtVectors(isOptionChecked(MenuOption::ShowMyLookAtVectors)); }); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowOtherLookAtVectors, 0, false); connect(action, &QAction::triggered, [this]{ Avatar::setShowOtherLookAtVectors(isOptionChecked(MenuOption::ShowOtherLookAtVectors)); }); auto avatarManager = DependencyManager::get<AvatarManager>(); auto avatar = avatarManager->getMyAvatar(); action = addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableLookAtSnapping, 0, true); connect(action, &QAction::triggered, [this, avatar]{ avatar->setProperty("lookAtSnappingEnabled", isOptionChecked(MenuOption::EnableLookAtSnapping)); }); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::FixGaze, 0, false); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ToggleHipsFollowing, 0, false, avatar.get(), SLOT(setToggleHips(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawBaseOfSupport, 0, false, avatar.get(), SLOT(setEnableDebugDrawBaseOfSupport(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawDefaultPose, 0, false, avatar.get(), SLOT(setEnableDebugDrawDefaultPose(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawAnimPose, 0, false, avatar.get(), SLOT(setEnableDebugDrawAnimPose(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawPosition, 0, false, avatar.get(), SLOT(setEnableDebugDrawPosition(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::MeshVisible, 0, true, avatar.get(), SLOT(setEnableMeshVisible(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::DisableEyelidAdjustment, 0, false); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::TurnWithHead, 0, false); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableInverseKinematics, 0, true, avatar.get(), SLOT(setEnableInverseKinematics(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderSensorToWorldMatrix, 0, false, avatar.get(), SLOT(setEnableDebugDrawSensorToWorldMatrix(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKTargets, 0, false, avatar.get(), SLOT(setEnableDebugDrawIKTargets(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKConstraints, 0, false, avatar.get(), SLOT(setEnableDebugDrawIKConstraints(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderIKChains, 0, false, avatar.get(), SLOT(setEnableDebugDrawIKChains(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderDetailedCollision, 0, false, avatar.get(), SLOT(setEnableDebugDrawDetailedCollision(bool))); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ActionMotorControl, 0, true, avatar.get(), SLOT(updateMotionBehaviorFromMenu()), UNSPECIFIED_POSITION, "Developer"); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ScriptedMotorControl, 0, true, avatar.get(), SLOT(updateMotionBehaviorFromMenu()), UNSPECIFIED_POSITION, "Developer"); addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowTrackedObjects, 0, false, qApp, SLOT(setShowTrackedObjects(bool))); addActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::PackageModel, 0, qApp, SLOT(packageModel())); // Developer > Hands >>> MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands"); addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false, avatar.get(), SLOT(setEnableDebugDrawHandControllers(bool))); // Developer > Entities >>> MenuWrapper* entitiesOptionsMenu = developerMenu->addMenu("Entities"); addActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::OctreeStats, 0, qApp, SLOT(loadEntityStatisticsDialog())); addCheckableActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::ShowRealtimeEntityStats); // Developer > Network >>> MenuWrapper* networkMenu = developerMenu->addMenu("Network"); action = addActionToQMenuAndActionHash(networkMenu, MenuOption::Networking); connect(action, &QAction::triggered, [] { qApp->showDialog(QString("hifi/dialogs/NetworkingPreferencesDialog.qml"), QString("hifi/tablet/TabletNetworkingPreferences.qml"), "NetworkingPreferencesDialog"); }); addActionToQMenuAndActionHash(networkMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches())); addActionToQMenuAndActionHash(networkMenu, MenuOption::ClearDiskCache, 0, DependencyManager::get<AssetClient>().data(), SLOT(clearCache())); addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::DisableActivityLogger, 0, false, &UserActivityLogger::getInstance(), SLOT(disable(bool))); addActionToQMenuAndActionHash(networkMenu, MenuOption::ShowDSConnectTable, 0, qApp, SLOT(loadDomainConnectionDialog())); #if (PR_BUILD || DEV_BUILD) addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongProtocolVersion, 0, false, qApp, SLOT(sendWrongProtocolVersionsSignature(bool))); { auto nodeList = DependencyManager::get<NodeList>(); addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongDSConnectVersion, 0, false, nodeList.data(), SLOT(toggleSendNewerDSConnectVersion(bool))); } #endif // Developer >> Tests >>> MenuWrapper* testMenu = developerMenu->addMenu("Tests"); addActionToQMenuAndActionHash(testMenu, MenuOption::RunClientScriptTests, 0, dialogsManager.data(), SLOT(showTestingResults())); // Developer > Timing >>> MenuWrapper* timingMenu = developerMenu->addMenu("Timing"); MenuWrapper* perfTimerMenu = timingMenu->addMenu("Performance Timer"); addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::DisplayDebugTimingDetails, 0, false, qApp, SLOT(enablePerfStats(bool))); addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::OnlyDisplayTopTen, 0, true); addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandUpdateTiming, 0, false); addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandSimulationTiming, 0, false); addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandPhysicsTiming, 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::FrameTimer); addActionToQMenuAndActionHash(timingMenu, MenuOption::RunTimingTests, 0, qApp, SLOT(runTests())); addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::PipelineWarnings); addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::LogExtraTimings); addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings); // Developer > Audio >>> MenuWrapper* audioDebugMenu = developerMenu->addMenu("Audio"); action = addActionToQMenuAndActionHash(audioDebugMenu, "Stats..."); connect(action, &QAction::triggered, [] { QUrl defaultScriptsLoc = PathUtils::defaultScriptsLocation(); defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/utilities/audio/stats.js"); DependencyManager::get<ScriptEngines>()->loadScript(defaultScriptsLoc.toString()); }); action = addActionToQMenuAndActionHash(audioDebugMenu, "Buffers..."); connect(action, &QAction::triggered, [] { qApp->showDialog(QString("hifi/dialogs/AudioBuffers.qml"), QString("hifi/tablet/TabletAudioBuffers.qml"), "AudioBuffersDialog"); }); addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteEnvironment, 0, DependencyManager::get<AudioClient>().data(), SLOT(sendMuteEnvironmentPacket())); action = addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioScope); connect(action, &QAction::triggered, [] { QUrl defaultScriptsLoc = PathUtils::defaultScriptsLocation(); defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/utilities/audio/audioScope.js"); DependencyManager::get<ScriptEngines>()->loadScript(defaultScriptsLoc.toString()); }); // Developer > Physics >>> MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics"); { auto drawStatusConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<render::DrawStatus>("RenderMainView.DrawStatus"); addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned, 0, false, drawStatusConfig, SLOT(setShowNetwork(bool))); } addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletWireframe, 0, false, qApp, SLOT(setShowBulletWireframe(bool))); addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowBulletAABBs, 0, false, qApp, SLOT(setShowBulletAABBs(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 >>> MenuWrapper* pickingOptionsMenu = developerMenu->addMenu("Picking"); addCheckableActionToQMenuAndActionHash(pickingOptionsMenu, MenuOption::ForceCoarsePicking, 0, false, DependencyManager::get<PickManager>().data(), SLOT(setForceCoarsePicking(bool))); // Developer > Crash >>> MenuWrapper* crashMenu = developerMenu->addMenu("Crash"); // Developer > Crash > Display Crash Options addCheckableActionToQMenuAndActionHash(crashMenu, MenuOption::DisplayCrashOptions, 0, true); addActionToQMenuAndActionHash(crashMenu, MenuOption::DeadlockInterface, 0, qApp, SLOT(deadlockApplication())); addActionToQMenuAndActionHash(crashMenu, MenuOption::UnresponsiveInterface, 0, qApp, SLOT(unresponsiveApplication())); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashPureVirtualFunction); connect(action, &QAction::triggered, qApp, []() { crash::pureVirtualCall(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashPureVirtualFunctionThreaded); connect(action, &QAction::triggered, qApp, []() { std::thread(crash::pureVirtualCall).join(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashDoubleFree); connect(action, &QAction::triggered, qApp, []() { crash::doubleFree(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashDoubleFreeThreaded); connect(action, &QAction::triggered, qApp, []() { std::thread(crash::doubleFree).join(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashAbort); connect(action, &QAction::triggered, qApp, []() { crash::doAbort(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashAbortThreaded); connect(action, &QAction::triggered, qApp, []() { std::thread(crash::doAbort).join(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNullDereference); connect(action, &QAction::triggered, qApp, []() { crash::nullDeref(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNullDereferenceThreaded); connect(action, &QAction::triggered, qApp, []() { std::thread(crash::nullDeref).join(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashOutOfBoundsVectorAccess); connect(action, &QAction::triggered, qApp, []() { crash::outOfBoundsVectorCrash(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashOutOfBoundsVectorAccessThreaded); connect(action, &QAction::triggered, qApp, []() { std::thread(crash::outOfBoundsVectorCrash).join(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNewFault); connect(action, &QAction::triggered, qApp, []() { crash::newFault(); }); action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNewFaultThreaded); connect(action, &QAction::triggered, qApp, []() { std::thread(crash::newFault).join(); }); // Developer > Show Statistics addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::Stats, 0, true); // Developer > Show Animation Statistics addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::AnimStats); // Developer > Log addActionToQMenuAndActionHash(developerMenu, MenuOption::Log, Qt::CTRL | Qt::SHIFT | Qt::Key_L, qApp, SLOT(toggleLogDialog())); #if 0 /// -------------- REMOVED FOR NOW -------------- addDisabledActionAndSeparator(navigateMenu, "History"); QAction* backAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Back, 0, addressManager.data(), SLOT(goBack())); QAction* forwardAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Forward, 0, addressManager.data(), SLOT(goForward())); // connect to the AddressManager signal to enable and disable the back and forward menu items connect(addressManager.data(), &AddressManager::goBackPossible, backAction, &QAction::setEnabled); connect(addressManager.data(), &AddressManager::goForwardPossible, forwardAction, &QAction::setEnabled); // set the two actions to start disabled since the stacks are clear on startup backAction->setDisabled(true); forwardAction->setDisabled(true); MenuWrapper* toolsMenu = addMenu("Tools"); addActionToQMenuAndActionHash(toolsMenu, MenuOption::ToolWindow, Qt::CTRL | Qt::ALT | Qt::Key_T, dialogsManager.data(), SLOT(toggleToolWindow()), QAction::NoRole, UNSPECIFIED_POSITION, "Advanced"); addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::NamesAboveHeads, 0, true, NULL, NULL, UNSPECIFIED_POSITION, "Advanced"); #endif // Help/Application menu ---------------------------------- MenuWrapper * helpMenu = addMenu("Help"); // Help > About High Fidelity action = addActionToQMenuAndActionHash(helpMenu, "About High Fidelity"); connect(action, &QAction::triggered, [] { qApp->showDialog(QString("hifi/dialogs/AboutDialog.qml"), QString("hifi/dialogs/TabletAboutDialog.qml"), "AboutDialog"); }); helpMenu->addSeparator(); // Help > HiFi Docs action = addActionToQMenuAndActionHash(helpMenu, "Online Documentation"); connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("https://docs.highfidelity.com/")); }); // Help > HiFi Forum action = addActionToQMenuAndActionHash(helpMenu, "Online Forums"); connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("https://forums.highfidelity.com/")); }); // Help > Scripting Reference action = addActionToQMenuAndActionHash(helpMenu, "Online Script Reference"); connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("https://docs.highfidelity.com/api-reference")); }); addActionToQMenuAndActionHash(helpMenu, "Controls Reference", 0, qApp, SLOT(showHelp())); helpMenu->addSeparator(); // Help > Release Notes action = addActionToQMenuAndActionHash(helpMenu, "Release Notes"); connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("http://steamcommunity.com/games/390540/announcements/")); }); // Help > Report a Bug! action = addActionToQMenuAndActionHash(helpMenu, "Report a Bug!"); connect(action, &QAction::triggered, qApp, [] { QDesktopServices::openUrl(QUrl("mailto:[email protected]")); }); }
void CWindowObject::updateShadow() { setShadow(false); if (!(options & SHADOW_DISABLED)) setShadow(true); }
CWindowObject::~CWindowObject() { setShadow(false); }