GLECSVDataStatus GLECSVData::readNewline(GLEBYTE prevCh) {
m_lines++;
m_nextLine = true;
GLEBYTE ch = readChar();
if (ch == 0) {
m_firstColumn = m_pos;
return GLECSVDataStatusEOF;
}
if (isEol(ch) && (ch != prevCh)) {
// Found, e.g., CR followed by LF (Windows encoding of new line)
m_firstColumn = m_pos;
return GLECSVDataStatusEOL;
}
// Found just CR or just LF (Unix / Mac encoding of new line)
goBack();
m_firstColumn = m_pos;
return GLECSVDataStatusEOL;
}
void update_guiFocusGameMenu(GUI *g, Controls *c, game_t *gm)
{
MenuWidget *m;
NOT(g);
NOT(c);
NOT(gm);
m = &g->gameMenu;
updateMenuWidget(m, c);
if (goBack(c)) {
g->next = guiFocusGameGUI;
return;
}
if (submitted(c)) {
switch (m->focus) {
case gameMenuFocusResume: {
g->next = guiFocusGameGUI;
break;
}
case gameMenuFocusSettings: {
g->settings.previous = g->focus;
g->next = guiFocusSettings;
break;
}
case gameMenuFocusSkip: {
g->transMove.type = transMoveSkipPlay;
next_turn(gm);
g->next = nextGUIFocusByplayer_tag_t(gm->player[gm->turn].type);
break;
}
case gameMenuFocusQuit: {
g->next = guiFocusGameAreYouSureQuit;
break;
}
default:
break;
}
return;
}
}
void LCDMenu2::goEnter()
{
Menu *tmp;
tmp=curMenu;
if ((tmp=tmp->getChild(curloc))) {//The child exists
if (tmp->canEnter) {//canEnter function is set
if (tmp->canEnter(*tmp)) {//It wants us to enter
goMenu(*tmp);
}
}
else {//canEnter function not set, assume entry allowed
goMenu(*tmp);
curfuncname = tmp->name;
}
}
else {//Child did not exist The only time this should happen is one the back Menu item, so go back
goBack();
}
}
void updatePlayMenu(GUI *g, Controls *c, game_t *gm)
{
MenuWidget *m;
NOT(g);
NOT(c);
NOT(gm);
m = &g->playMenu;
updateMenuWidget(m, c);
if (goBack(c)) {
g->next = guiFocusMenu;
return;
}
if (submitted(c)) {
switch (m->focus) {
case playMenuFocusHumanVsHuman: {
initGame1vs1Human(gm);
initTextLog(&g->gameGui.textLog);
resetNewGameGui(g, gm);
initScoreBoard(&g->scoreBoard, gm);
toTransScreenFadePausePixelate(g, guiFocusGameGUI, 1.0f);
break;
}
case playMenuFocusHumanVsAI: {
initGame1vs1HumanAI(gm);
initTextLog(&g->gameGui.textLog);
resetNewGameGui(g, gm);
initScoreBoard(&g->scoreBoard, gm);
toTransScreenFadePausePixelate(g, guiFocusGameGUI, 1.0f);
break;
}
case playMenuFocusOptions: {
g->next = guiFocusOptions;
break;
}
default:
break;
}
}
}
PlateCalibratorWidget::PlateCalibratorWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::PlateCalibratorWidget)
{
_plater = new PlaterCalibrator( PolyboxModule::getInstance(), this );
ui->setupUi(this);
HomeButton* hb = new HomeButton( 50,50, this );
hb->setGeometry( this->width()-hb->width()-10,
this->height()-hb->height(),
hb->width(), hb->height());
connect( hb, SIGNAL(clicked()), this, SLOT(goBack()));
/*_update_timer.start( 100 ) ;
connect(&_update_timer, SIGNAL(timeout()),this,SLOT(updateUi()));
*/
connect(_plater, SIGNAL(updateUI()),this,SLOT(updateUi()));
}
GLECSVDataStatus GLECSVData::skipSpacesAndFirstDelim(GLEBYTE ch) {
while (true) {
if (!isSpace(ch)) {
if (ch == 0) {
return GLECSVDataStatusEOF;
} else if (isEol(ch)) {
return readNewline(ch);
} else if (isDelim(ch)) {
m_lastDelimWasSpace = isSpace(ch);
return GLECSVDataStatusOK;
} else {
goBack();
return GLECSVDataStatusOK;
}
}
ch = readChar();
}
return GLECSVDataStatusOK;
}
FrmCatch::FrmCatch(Sample* inSample, DateModel* inTDateTime, QWidget *parent, Qt::WFlags flags):
PreviewTab(7,inSample,inTDateTime,tr("Catch"),parent, flags){
setupUi(this);
connect(pushPrevious, SIGNAL(clicked()), this,
SLOT(goBack()));
connect(this, SIGNAL(blockCatchUISignals(const bool)), catchInputCtrl,
SIGNAL(blockWidgetsSignals(const bool)));
tCatch=0;
viewCatch=0;
mapper1=0;
nullDelegate=0;
initModels();
initUI();
initMappers();
}
void WebBrowserComponent::checkWindowAssociation()
{
if (isShowing())
{
if (blankPageShown)
goBack();
}
else
{
if (unloadPageWhenBrowserIsHidden && ! blankPageShown)
{
// when the component becomes invisible, some stuff like flash
// carries on playing audio, so we need to force it onto a blank
// page to avoid this, (and send it back when it's made visible again).
blankPageShown = true;
browser->goToURL ("about:blank", 0, 0);
}
}
}
void updateGameAreYouSureQuit(GUI *g, game_t *gm, Controls *c)
{
updateMenuWidget(&g->gameAreYouSureQuit, c);
if (submitted(c)) {
g->next = guiFocusGameMenu;
if (g->gameAreYouSureQuit.focus == yes) {
move_t m;
action_t a;
g->next = guiFocusGameOver;
m.type = MOVE_QUIT;
m.playerIdx = gm->turn;
mk_action(gm, &m, &a);
assert(a.type == ACTION_QUIT);
apply_action(&a, gm);
}
return;
}
if (goBack(c))
g->next = guiFocusGameMenu;
}
void GeneralCardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
if (Config.FreeChoose && Qt::RightButton == event->button()) {
FreeChooseDialog *general_changer = new FreeChooseDialog(QApplication::focusWidget());
connect(general_changer, SIGNAL(general_chosen(QString)), this, SLOT(changeGeneral(QString)));
general_changer->exec();
general_changer->deleteLater();
return;
}
if (frozen) return;
QPointF totalMove = mapToParent(event->pos()) - _m_lastMousePressScenePos;
if (totalMove.x() * totalMove.x() + totalMove.y() * totalMove.y() < _S_MOVE_JITTER_TOLERANCE)
emit clicked();
else
emit released();
if (auto_back) {
goBack(true, false);
}
}
void NetTree::handleSelect(MythUIButtonListItem *item)
{
MythGenericTree *node = GetNodePtrFromButton(item);
int nodeInt = node->getInt();
switch (nodeInt)
{
case kSubFolder:
handleDirSelect(node);
break;
case kUpFolder:
goBack();
break;
default:
{
streamWebVideo();
}
};
slotItemChanged();
}
void update_guiFocusSettings(GUI *g, Controls *c)
{
Settings *s;
NOT(g);
NOT(c);
s = &g->settings;
updateMenuWidget(&s->menu, c);
s->snd = false;
if (goBack(c)) {
g->next = s->previous;
return;
}
switch (s->menu.focus) {
case settingsFocusSfx: {
int pvol;
int idx = s->menu.focus - volMus;
pvol = s->vol[idx];
s->vol[idx] = updateVolumes(s->vol[idx], c);
if (pvol != s->vol[idx]) {
s->snd = true;
}
break;
}
case settingsFocusControls: {
if (submitted(c)) {
g->next = guiFocusControls;
}
break;
}
default:
break;
}
}
void DebugProc(void)
{
BYTE re1, re2;
BYTE a1, a2, a3, a4, a5, a6;
printf("\r\nTEST REGIME\r\n");
// Отладочные телодвижения
// (проверка правильности подключения двигателей: вперед, назад, влево, вправо)
#define Time 500
goFwd(); delay_ms(Time);
goBack(); delay_ms(Time);
goLeft(); delay_ms(Time);
goRight(); delay_ms(Time);
robotStop();
pip();
goFastLeft(); delay_ms(Time);
goFastRight(); delay_ms(Time);
robotStop();
pip();
while (1)
{
re1 = ReadByteADC(ADC_E1);
re2 = ReadByteADC(ADC_E2);
a1 = ReadByteADC(ADC_1);
a2 = ReadByteADC(ADC_2);
a3 = ReadByteADC(ADC_3);
a4 = ReadByteADC(ADC_4);
a5 = ReadByteADC(ADC_5);
a6 = ReadByteADC(ADC_6);
delay_ms(20);
printf("(%4u %4u) (%4u %4u) %4u %4u %4u %4u\r", re1, re2, a1, a2, a3, a4, a5, a6);
}
}
/* ******************************************************************** *
* public: display the current menu
* @param
* @return
* ******************************************************************** */
void LCDMenuLib::display()
/* ******************************************************************** */
{
//declaration
LCDMenu * tmp;
uint8_t i = scroll;
uint8_t maxi = (rows + scroll);
char buffer[_LCDML_DISP_cfg_max_string_length];
child_cnt = countChilds();
//check children
if ((tmp = curMenu->getChild(i))) {
if (!bitRead(control, _LCDML_control_search_display)) {
//clear lcd
display_clear();
//show menu structure
do
{
if (bitRead(group_en, tmp->disp)) {
#if defined ( ESP8266 ) || defined ( ESP32 )
strcpy_P(content[i-scroll], (char*)(flash_table[tmp->name]));
#else
strcpy_P(content[i-scroll], (char*)pgm_read_word(&(flash_table[tmp->name])));
#endif
content_id[i-scroll] = tmp->name;
i++;
}
} while ((tmp = tmp->getSibling(1)) != NULL && i<maxi);
bitSet(control, _LCDML_control_disp_update);
}
}
else { // no children
goBack();
// function can run ...
}
setCursor();
}
void LLPanelSnapshotLocal::onSaveFlyoutCommit(LLUICtrl* ctrl)
{
if (ctrl->getValue().asString() == "save as")
{
gViewerWindow->resetSnapshotLoc();
}
LLFloaterSnapshot* floater = LLFloaterSnapshot::getInstance();
floater->notify(LLSD().with("set-working", true));
BOOL saved = LLFloaterSnapshot::saveLocal();
if (saved)
{
LLFloaterSnapshot::postSave();
goBack();
floater->notify(LLSD().with("set-finished", LLSD().with("ok", true).with("msg", "local")));
}
else
{
cancel();
}
}
void Mover::update(){
velocity += acceleration;
location += velocity;
acceleration *= 0;
if(isBack) {
ofVec2f forceBack = initialLoc - location;
if(forceBack.length() < 2) {
location = initialLoc;
}
else{
goBack();
velocity *= 0.8;
}
}
}
BackButton::BackButton(QWebView * webView, QWidget * parent)
: QToolButton(parent)
, m_webView(webView)
{
m_defaultAction = new QAction(this);
m_defaultAction->setData(-1);
setDefaultAction(m_defaultAction);
setAutoRaise(true);
setIcon(QIcon::fromTheme("go-previous", QIcon(":/go-previous.png")));
setToolTip(trUtf8("Go back"));
setShortcut(QKeySequence::Back);
setPopupMode(QToolButton::MenuButtonPopup);
m_popupMenu = new Menu(this);
setMenu(m_popupMenu);
updateButton();
connect(m_webView, SIGNAL(urlChanged(const QUrl &)), this, SLOT(updateButton()));
connect(m_defaultAction, SIGNAL(triggered()), this, SLOT(goBack()));
connect(m_popupMenu, SIGNAL(aboutToShow()), this, SLOT(updatePopupMenu()));
}
FormSimulator::FormSimulator(FormMain* parent)
: QDialog(parent), m_ui(new Ui::FormSimulator), m_mainWindow(parent), m_isActive(false), m_activeSimulation(NULL) {
m_ui->setupUi(this);
// Load some needed settings.
m_isVisibleOnStartup = qApp->settings()->value(APP_CFG_SIMULATOR, "visible_on_startup", false).toBool();
m_isSticked = qApp->settings()->value(APP_CFG_SIMULATOR, "is_sticked", false).toBool();
// Do necessary initializations.
setupIcons();
setupPhoneWidget();
connect(parent, SIGNAL(moved()), this, SLOT(conditionallyAttachToParent()));
connect(parent, SIGNAL(resized()), this, SLOT(conditionallyAttachToParent()));
connect(m_ui->m_btnRunSimulation, SIGNAL(clicked()), this, SLOT(startSimulation()));
connect(m_ui->m_btnStopSimulation, SIGNAL(clicked()), this, SLOT(stopSimulation()));
connect(m_ui->m_btnGoBack, SIGNAL(clicked()), this, SLOT(goBack()));
connect(this, SIGNAL(stopEnableChanged(bool)), m_ui->m_btnStopSimulation, SLOT(setEnabled(bool)));
// This window mustn't be deleted when closed by user.
setAttribute(Qt::WA_DeleteOnClose, false);
setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
}
void LLPanelSnapshotLocal::onSaveFlyoutCommit(LLUICtrl* ctrl)
{
if (ctrl->getValue().asString() == "save as")
{
gViewerWindow->resetSnapshotLoc();
}
LLFloaterSnapshot* floater = LLFloaterSnapshot::getInstance();
floater->notify(LLSD().with("set-working", true));
BOOL saved = LLFloaterSnapshot::saveLocal();
if (saved)
{
LLFloaterSnapshot::postSave();
goBack();
floater->notify(LLSD().with("set-finished", LLSD().with("ok", true).with("msg", "local")));
}
else
{
// <FS:Ansariel> Notify user if we could not save file
LLNotificationsUtil::add("CannotSaveSnapshot");
cancel();
}
}
bool NetTree::keyPressEvent(QKeyEvent *event)
{
if (GetFocusWidget()->keyPressEvent(event))
return true;
bool handled = false;
QStringList actions;
handled = GetMythMainWindow()->TranslateKeyPress("Internet Video", event, actions);
for (int i = 0; i < actions.size() && !handled; i++)
{
QString action = actions[i];
handled = true;
if (action == "MENU")
{
showMenu();
}
else if (action == "ESCAPE")
{
if (m_type != DLG_TREE
&& !GetMythMainWindow()->IsExitingToMain()
&& m_currentNode != m_siteGeneric)
handled = goBack();
else
handled = false;
}
else
handled = false;
}
if (!handled && MythScreenType::keyPressEvent(event))
handled = true;
return handled;
}
bool CodeWidget::codeSubmitFail(const RPCError &error) {
if (MTP::isFloodError(error)) {
stopCheck();
_sentRequest = 0;
showCodeError(langFactory(lng_flood_error));
return true;
}
if (MTP::isDefaultHandledError(error)) return false;
stopCheck();
_sentRequest = 0;
auto &err = error.type();
if (err == qstr("PHONE_NUMBER_INVALID") || err == qstr("PHONE_CODE_EXPIRED")) { // show error
goBack();
return true;
} else if (err == qstr("PHONE_CODE_EMPTY") || err == qstr("PHONE_CODE_INVALID")) {
showCodeError(langFactory(lng_bad_code));
return true;
} else if (err == qstr("PHONE_NUMBER_UNOCCUPIED")) { // success, need to signUp
getData()->code = _sentCode;
goReplace(new Intro::SignupWidget(parentWidget(), getData()));
return true;
} else if (err == qstr("SESSION_PASSWORD_NEEDED")) {
getData()->code = _sentCode;
_checkRequest->start(1000);
_sentRequest = MTP::send(MTPaccount_GetPassword(), rpcDone(&CodeWidget::gotPassword), rpcFail(&CodeWidget::codeSubmitFail));
return true;
}
if (Logs::DebugEnabled()) { // internal server error
auto text = err + ": " + error.description();
showCodeError([text] { return text; });
} else {
showCodeError(&Lang::Hard::ServerError);
}
return false;
}
void sortMan()
{
unsigned char nxTerm = 0;
unsigned char adj = adjC(CT);
if (visited[CT] == 0)
termPick();
counter();
unsigned char pSwap = ((CT == 2 || CT == 3) ? 1 : 0);
unsigned char pFar = (indi[term[CT][0]] == adj | indi[term[CT][0]] == CT | indi[term[CT][0]] == 0); //wont work for empty node
if (indi[swap[CT % 2]] == CT)
{
if (farCount == 2)
{
if (term[CT][0] == term[CT][1])
{
nxTerm = indi[term[CT][0]]; //the common terminal
pickup(0);
drop(0);
gotoSort();
pickupS(1);
dropS(0);
goBack();
pickup(1);
drop(1);
}
else //both diff of far
{
nxTerm = indi[term[CT][0]];
pickup(0);
drop(0);
gotoSort();
pickupS(0);
dropS(1);
goBack();
pickup(1);
drop(1);
//SchPickupAtSort //CT
//SchDropAtSort //far
}
}
else if (farCount == 1)
{
if (adjCount == 1)
{
nxTerm = adj;
pickup(pFar);
drop(pFar);
gotoSort();
pickupS(pSwap);
dropS(pSwap);
goBack();
pickup(!pFar);
drop(!pFar);
//nothing to schedule
}
else
{ //empty node
//:O :O
if (visited[adj] == 0 || term[adj][0] != indi[adj] || term[adj][1] != indi[adj])
nxTerm = adj;
else //seq also usable for both empty
{
nxTerm = indi[term[CT][pFar]];
pickup(pFar);
drop(pFar);
gotoSort();
pickupS(pSwap);
goBack();
drop(!pFar);
}
}
}
else if (adjCount == 1)
{
if (farCount == 1)
{
nxTerm = adj;
pickup(pFar);
drop(pFar);
gotoSort();
pickupS(pSwap);
dropS(pSwap);
goBack();
pickup(!pFar);
drop(!pFar);
//nothing to schedule
}
else
{
//empty node
drop(pFar);
gotoSort();
pickupS(pSwap);
goBack();
pickup(!pFar);
drop(!pFar);
nxTerm = adj;
}
}
else if (adjCount == 2)
{
nxTerm = adj;
pickup(0);
drop(0);
gotoSort();
pickupS(pSwap);
dropS(pSwap);
goBack();
pickup(1);
drop(1);
}
if (arm[0] == 0 && arm[1] == 0)
{
travel(nxTerm);
sortFree();
}
else
{
travel(nxTerm);
sortMan();
}
}
else if (indi[swap[CT % 2]] != CT) //Sort can be empty
{
if (farCount == 2)
{
if (term[CT][0] == term[CT][1]) //and sort not empty why ?? :/
{
nxTerm = indi[term[CT][0]]; //the common terminal
//SchPickupAtSort
//SchDropAtSort
pickup(0);
drop(0);
pickup(1);
drop(1);
}
else if (swap[CT % 2] == term[CT][0])
{
pickup(0);
drop(0);
nxTerm = indi[arm[0]];
}
else if (swap[CT % 2] == term[CT][1])
{
pickup(1);
drop(1);
nxTerm = indi[arm[1]];
}
else
{
if (visited[indi[term[CT][0]]] == 1)
{
nxTerm = indi[term[CT][0]];
}
else
nxTerm = indi[term[CT][1]];
pickup(0);
drop(0);
pickup(1);
}
}
else if (farCount == 1)
{
if (adjCount == 1)
{
if (swap[CT % 2] == 0)
{
pickup(!pFar); //adjwala
drop(!pFar);
pickup(pFar);
nxTerm = adj;
//SchDropAtSort
}
else
{
//Sort of far and CT has 1 far a adj
pickup(!pFar);
drop(!pFar);
pickup(pFar);
nxTerm = adj;
}
}
else //====
{ //one node is empty
if (visited[adj] == 1)
nxTerm = indi[term[CT][pFar]];
else nxTerm = adj;
pickup(pFar);
drop(pFar);
//SchDropAtSort
}
}
else if (adjCount == 1)
{
if (farCount == 1)
{
if (swap[CT % 2] == 0)
{
pickup(!pFar); //adjwala
drop(!pFar);
pickup(pFar);
nxTerm = adj;
//SchDropAtSort
}
else
{
//Sort of far and CT has 1 far a adj
pickup(!pFar);
drop(!pFar);
nxTerm = adj;
}
}
else //1 empty 1 adj
{
pickup(!pFar);
drop(!pFar);
nxTerm = adj;
}
}
else if (adjCount == 2)
{
if (swap[CT % 2] > 0) //smthin is at Sort
{
pickup(0);
drop(0);
}
else
{
pickup(0);
drop(0);
pickup(1);
}
nxTerm = adj;
}
else //empty term nore precisely we arent pickiing up anything so we have NO CLUE WHERE TO GO
{
drop(0);
drop(1);
if (visited[1] + visited[2] + visited[3] + visited[4] > 3 && checkForCompletion() >= 6)
{
if (nxTerm == 0 && swap[0] == 0 && swap[1] == 0 && arm[0] == 0 && arm[1] == 0) //panic or complete
while (1);
}
else
{
if (visited[adj] == 0)
nxTerm = adj;
else
{
if (arm[0] > 0)
nxTerm = indi[arm[0]];
else if (arm[1] > 0)
nxTerm = indi[arm[1]];
else if (swap[CT % 2]>0)
nxTerm = indi[swap[CT % 2]];
else if (swap[(CT + 1) % 2] > 0)
nxTerm = indi[swap[(CT + 1) % 2]];
else
nxTerm = unvisited();
}
}
if (nxTerm == 0)
{
while (1);
}
}
}
if (arm[0] == 0 && arm[1] == 0)
{
travel(nxTerm);
sortFree();
}
else
{
travel(nxTerm);
sortMan();
}
}
NavigationBar::NavigationBar(BrowserWindow* window)
: QWidget(window)
, m_window(window)
{
setObjectName(QSL("navigationbar"));
m_layout = new QHBoxLayout(this);
m_layout->setMargin(style()->pixelMetric(QStyle::PM_ToolBarItemMargin, 0, this));
m_layout->setSpacing(style()->pixelMetric(QStyle::PM_ToolBarItemSpacing, 0, this));
setLayout(m_layout);
m_buttonBack = new ToolButton(this);
m_buttonBack->setObjectName("navigation-button-back");
m_buttonBack->setToolTip(tr("Back"));
m_buttonBack->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonBack->setToolbarButtonLook(true);
m_buttonBack->setAutoRaise(true);
m_buttonBack->setEnabled(false);
m_buttonBack->setFocusPolicy(Qt::NoFocus);
m_buttonForward = new ToolButton(this);
m_buttonForward->setObjectName("navigation-button-next");
m_buttonForward->setToolTip(tr("Forward"));
m_buttonForward->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonForward->setToolbarButtonLook(true);
m_buttonForward->setAutoRaise(true);
m_buttonForward->setEnabled(false);
m_buttonForward->setFocusPolicy(Qt::NoFocus);
QHBoxLayout* backNextLayout = new QHBoxLayout();
backNextLayout->setContentsMargins(0, 0, 0, 0);
backNextLayout->setSpacing(0);
backNextLayout->addWidget(m_buttonBack);
backNextLayout->addWidget(m_buttonForward);
m_reloadStop = new ReloadStopButton(this);
m_buttonHome = new ToolButton(this);
m_buttonHome->setObjectName("navigation-button-home");
m_buttonHome->setToolTip(tr("Home"));
m_buttonHome->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonHome->setToolbarButtonLook(true);
m_buttonHome->setAutoRaise(true);
m_buttonHome->setFocusPolicy(Qt::NoFocus);
m_buttonAddTab = new ToolButton(this);
m_buttonAddTab->setObjectName("navigation-button-addtab");
m_buttonAddTab->setToolTip(tr("New Tab"));
m_buttonAddTab->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonAddTab->setToolbarButtonLook(true);
m_buttonAddTab->setAutoRaise(true);
m_buttonAddTab->setFocusPolicy(Qt::NoFocus);
m_menuBack = new Menu(this);
m_menuBack->setCloseOnMiddleClick(true);
m_buttonBack->setMenu(m_menuBack);
connect(m_buttonBack, SIGNAL(aboutToShowMenu()), this, SLOT(aboutToShowHistoryBackMenu()));
m_menuForward = new Menu(this);
m_menuForward->setCloseOnMiddleClick(true);
m_buttonForward->setMenu(m_menuForward);
connect(m_buttonForward, SIGNAL(aboutToShowMenu()), this, SLOT(aboutToShowHistoryNextMenu()));
m_supMenu = new ToolButton(this);
m_supMenu->setObjectName("navigation-button-supermenu");
m_supMenu->setPopupMode(QToolButton::InstantPopup);
m_supMenu->setToolbarButtonLook(true);
m_supMenu->setToolTip(tr("Main Menu"));
m_supMenu->setAutoRaise(true);
m_supMenu->setFocusPolicy(Qt::NoFocus);
m_supMenu->setMenu(m_window->superMenu());
m_supMenu->setShowMenuInside(true);
m_searchLine = new WebSearchBar(m_window);
m_navigationSplitter = new QSplitter(this);
m_navigationSplitter->addWidget(m_window->tabWidget()->locationBars());
m_navigationSplitter->addWidget(m_searchLine);
m_navigationSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
m_navigationSplitter->setCollapsible(0, false);
m_exitFullscreen = new ToolButton(this);
m_exitFullscreen->setObjectName("navigation-button-exitfullscreen");
m_exitFullscreen->setToolTip(tr("Exit Fullscreen"));
m_exitFullscreen->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_exitFullscreen->setToolbarButtonLook(true);
m_exitFullscreen->setFocusPolicy(Qt::NoFocus);
m_exitFullscreen->setAutoRaise(true);
m_exitFullscreen->setVisible(false);
m_layout->addLayout(backNextLayout);
m_layout->addWidget(m_reloadStop);
m_layout->addWidget(m_buttonHome);
m_layout->addWidget(m_buttonAddTab);
m_layout->addWidget(m_navigationSplitter);
m_layout->addWidget(m_supMenu);
m_layout->addWidget(m_exitFullscreen);
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuRequested(QPoint)));
connect(m_buttonBack, SIGNAL(clicked()), this, SLOT(goBack()));
connect(m_buttonBack, SIGNAL(middleMouseClicked()), this, SLOT(goBackInNewTab()));
connect(m_buttonBack, SIGNAL(controlClicked()), this, SLOT(goBackInNewTab()));
connect(m_buttonForward, SIGNAL(clicked()), this, SLOT(goForward()));
connect(m_buttonForward, SIGNAL(middleMouseClicked()), this, SLOT(goForwardInNewTab()));
connect(m_buttonForward, SIGNAL(controlClicked()), this, SLOT(goForwardInNewTab()));
connect(m_reloadStop, SIGNAL(stopClicked()), this, SLOT(stop()));
connect(m_reloadStop, SIGNAL(reloadClicked()), this, SLOT(reload()));
connect(m_buttonHome, SIGNAL(clicked()), m_window, SLOT(goHome()));
connect(m_buttonHome, SIGNAL(middleMouseClicked()), m_window, SLOT(goHomeInNewTab()));
connect(m_buttonHome, SIGNAL(controlClicked()), m_window, SLOT(goHomeInNewTab()));
connect(m_buttonAddTab, SIGNAL(clicked()), m_window, SLOT(addTab()));
connect(m_buttonAddTab, SIGNAL(middleMouseClicked()), m_window->tabWidget(), SLOT(addTabFromClipboard()));
connect(m_exitFullscreen, SIGNAL(clicked(bool)), m_window, SLOT(toggleFullScreen()));
}
void LLPanelSnapshot::cancel()
{
goBack();
LLFloaterSnapshot::getInstance()->notify(LLSD().with("set-ready", true));
}
void GrabCardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *){
emit grabbed();
goBack();
}
void move(Cell maze[][16],int *mx,int *my,int *dir) {
if (goodFront(maze,*mx,*my,*dir)) go(mx,my,*dir);
else if (goodRight(maze,*mx,*my,*dir)) goRight(mx,my,dir);
else if (goodLeft(maze,*mx,*my,*dir)) goLeft(mx,my,dir);
else goBack(mx,my,dir);
}
TITANIUM_FUNCTION(WebView, goBack)
{
goBack();
return get_context().CreateUndefined();
}
ChooseFolderView::ChooseFolderView( QWidget *parent ) : QWidget(parent) {
QBoxLayout *layout = new QVBoxLayout(this);
layout->setAlignment(Qt::AlignCenter);
layout->setSpacing(PADDING);
layout->setMargin(PADDING);
welcomeLayout = new QHBoxLayout();
welcomeLayout->setAlignment(Qt::AlignLeft);
welcomeLayout->setSpacing(0);
welcomeLayout->setMargin(0);
layout->addLayout(welcomeLayout);
QLabel *logo = new QLabel(this);
logo->setPixmap(QPixmap(":/images/app.png"));
welcomeLayout->addWidget(logo, 0, Qt::AlignTop);
// hLayout->addSpacing(PADDING);
QLabel *welcomeLabel =
new QLabel("<h1>" +
tr("Welcome to <a href='%1'>%2</a>,")
.replace("<a ", "<a style='color:palette(text)'")
.arg(Constants::WEBSITE, Constants::APP_NAME)
+ "</h1>", this);
welcomeLabel->setOpenExternalLinks(true);
welcomeLayout->addWidget(welcomeLabel);
// layout->addSpacing(PADDING);
tipLabel = new QLabel(
tr("%1 needs to scan your music collection.").arg(Constants::APP_NAME)
, this);
tipLabel->setFont(FontUtils::big());
layout->addWidget(tipLabel);
QBoxLayout *buttonLayout = new QHBoxLayout();
layout->addLayout(buttonLayout);
cancelButton = new QPushButton(tr("Cancel"));
connect(cancelButton, SIGNAL(clicked()), parent, SLOT(goBack()));
buttonLayout->addWidget(cancelButton);
#ifdef APP_MAC_NO
QPushButton *useiTunesDirButton = new QPushButton(tr("Use iTunes collection"));
connect(useiTunesDirButton, SIGNAL(clicked()), SLOT(iTunesDirChosen()));
useiTunesDirButton->setDefault(true);
useiTunesDirButton->setFocus(Qt::NoFocusReason);
buttonLayout->addWidget(useiTunesDirButton);
#endif
QString musicLocation = QDesktopServices::storageLocation(QDesktopServices::MusicLocation);
QString homeLocation = QDesktopServices::storageLocation(QDesktopServices::HomeLocation);
if (QFile::exists(musicLocation) && musicLocation != homeLocation + "/") {
QPushButton *useSystemDirButton = new QPushButton(tr("Use %1").arg(musicLocation));
connect(useSystemDirButton, SIGNAL(clicked()), SLOT(systemDirChosen()));
#ifndef APP_MAC_NO
useSystemDirButton->setDefault(true);
useSystemDirButton->setFocus(Qt::NoFocusReason);
#endif
buttonLayout->addWidget(useSystemDirButton);
}
QPushButton *chooseDirButton = new QPushButton(tr("Choose a folder..."));
connect(chooseDirButton, SIGNAL(clicked()), SLOT(chooseFolder()));
buttonLayout->addWidget(chooseDirButton);
#if !defined(APP_MAC) && !defined(Q_WS_WIN)
QLabel *privacyLabel =
new QLabel(
tr("%1 will connect to the Last.fm web services and pass artist names and album titles in order to fetch covert art, biographies and much more.")
.arg(Constants::APP_NAME) + " " +
tr("If you have privacy concerns about this you can quit now.")
, this);
privacyLabel->setFont(FontUtils::small());
privacyLabel->setOpenExternalLinks(true);
privacyLabel->setWordWrap(true);
layout->addWidget(privacyLabel);
#endif
}
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 > Help
addActionToQMenuAndActionHash(fileMenu, MenuOption::Help, 0, qApp, SLOT(showHelp()));
// File > About
addActionToQMenuAndActionHash(fileMenu, MenuOption::AboutApp, 0, qApp, SLOT(aboutApp()), QAction::AboutRole);
// File > Quit
addActionToQMenuAndActionHash(fileMenu, MenuOption::Quit, Qt::CTRL | Qt::Key_Q, qApp, SLOT(quit()), QAction::QuitRole);
// Edit menu ----------------------------------
MenuWrapper* editMenu = addMenu("Edit");
// Edit > Undo
QUndoStack* undoStack = qApp->getUndoStack();
QAction* undoAction = undoStack->createUndoAction(editMenu);
undoAction->setShortcut(Qt::CTRL | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, undoAction);
// Edit > Redo
QAction* redoAction = undoStack->createRedoAction(editMenu);
redoAction->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, redoAction);
// Edit > Running Scripts
addActionToQMenuAndActionHash(editMenu, MenuOption::RunningScripts, Qt::CTRL | Qt::Key_J,
qApp, SLOT(toggleRunningScriptsWidget()));
// Edit > Open and Run Script from File... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::LoadScript, Qt::CTRL | Qt::Key_O,
qApp, SLOT(loadDialog()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Open and Run Script from Url... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::LoadScriptURL,
Qt::CTRL | Qt::SHIFT | Qt::Key_O, qApp, SLOT(loadScriptURLDialog()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
auto scriptEngines = DependencyManager::get<ScriptEngines>();
// Edit > Stop All Scripts... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::StopAllScripts, 0,
scriptEngines.data(), SLOT(stopAllScripts()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Reload All Scripts... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadAllScripts, Qt::CTRL | Qt::Key_R,
scriptEngines.data(), SLOT(reloadAllScripts()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Scripts Editor... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ScriptEditor, Qt::ALT | Qt::Key_S,
dialogsManager.data(), SLOT(showScriptEditor()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Console... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::Console, Qt::CTRL | Qt::ALT | Qt::Key_J,
DependencyManager::get<StandAloneJSConsole>().data(),
SLOT(toggleConsole()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
editMenu->addSeparator();
// Edit > My Asset Server
auto assetServerAction = addActionToQMenuAndActionHash(editMenu, MenuOption::AssetServer,
Qt::CTRL | Qt::SHIFT | Qt::Key_A,
qApp, SLOT(toggleAssetServerWidget()));
auto nodeList = DependencyManager::get<NodeList>();
QObject::connect(nodeList.data(), &NodeList::canWriteAssetsChanged, assetServerAction, &QAction::setEnabled);
assetServerAction->setEnabled(nodeList->getThisNodeCanWriteAssets());
// Edit > Package Model... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::PackageModel, 0,
qApp, SLOT(packageModel()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Reload All Content [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Audio menu ----------------------------------
MenuWrapper* audioMenu = addMenu("Audio");
auto audioIO = DependencyManager::get<AudioClient>();
// Audio > Mute
addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::MuteAudio, Qt::CTRL | Qt::Key_M, false,
audioIO.data(), SLOT(toggleMute()));
// Audio > Show Level Meter
addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::AudioTools, 0, true);
// Avatar menu ----------------------------------
MenuWrapper* avatarMenu = addMenu("Avatar");
auto avatarManager = DependencyManager::get<AvatarManager>();
QObject* avatar = avatarManager->getMyAvatar();
// Avatar > Attachments...
auto action = addActionToQMenuAndActionHash(avatarMenu, MenuOption::Attachments);
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->show(QString("hifi/dialogs/AttachmentsDialog.qml"), "AttachmentsDialog");
});
// Avatar > Size
MenuWrapper* avatarSizeMenu = avatarMenu->addMenu("Size");
// Avatar > Size > Increase
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::IncreaseAvatarSize,
0, // QML Qt::Key_Plus,
avatar, SLOT(increaseSize()));
// Avatar > Size > Decrease
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::DecreaseAvatarSize,
0, // QML Qt::Key_Minus,
avatar, SLOT(decreaseSize()));
// Avatar > Size > Reset
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::ResetAvatarSize,
0, // QML Qt::Key_Equal,
avatar, SLOT(resetSize()));
// Avatar > Reset Sensors
addActionToQMenuAndActionHash(avatarMenu,
MenuOption::ResetSensors,
0, // QML Qt::Key_Apostrophe,
qApp, SLOT(resetSensors()));
// 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
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::FirstPerson, 0, // QML Qt:: Key_P
true, qApp, SLOT(cameraMenuChanged())));
// View > Third Person
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::ThirdPerson, 0,
false, qApp, SLOT(cameraMenuChanged())));
// View > Mirror
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::FullscreenMirror, 0, // QML Qt::Key_H,
false, qApp, SLOT(cameraMenuChanged())));
// View > Independent [advanced]
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::IndependentMode, 0,
false, qApp, SLOT(cameraMenuChanged()),
UNSPECIFIED_POSITION, "Advanced"));
// View > Entity Camera [advanced]
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::CameraEntityMode, 0,
false, qApp, SLOT(cameraMenuChanged()),
UNSPECIFIED_POSITION, "Advanced"));
viewMenu->addSeparator();
// View > Mini Mirror
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::MiniMirror, 0, false);
// View > Center Player In View
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CenterPlayerInView,
0, true, qApp, SLOT(rotationModeChanged()),
UNSPECIFIED_POSITION, "Advanced");
// View > Overlays
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::Overlays, 0, true);
// Navigate menu ----------------------------------
MenuWrapper* navigateMenu = addMenu("Navigate");
// Navigate > Show Address Bar
addActionToQMenuAndActionHash(navigateMenu, MenuOption::AddressBar, Qt::CTRL | Qt::Key_L,
dialogsManager.data(), SLOT(toggleAddressBar()));
// Navigate > Bookmark related menus -- Note: the Bookmark class adds its own submenus here.
qApp->getBookmarks()->setupMenus(this, navigateMenu);
// Navigate > Copy Address [advanced]
auto addressManager = DependencyManager::get<AddressManager>();
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyAddress, 0,
addressManager.data(), SLOT(copyAddress()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Navigate > Copy Path [advanced]
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyPath, 0,
addressManager.data(), SLOT(copyPath()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Settings menu ----------------------------------
MenuWrapper* settingsMenu = addMenu("Settings");
// Settings > Advance Menus
addCheckableActionToQMenuAndActionHash(settingsMenu, "Advanced Menus", 0, false, this, SLOT(toggleAdvancedMenus()));
// Settings > Developer Menus
addCheckableActionToQMenuAndActionHash(settingsMenu, "Developer Menus", 0, false, this, SLOT(toggleDeveloperMenus()));
// Settings > General...
action = addActionToQMenuAndActionHash(settingsMenu, MenuOption::Preferences, Qt::CTRL | Qt::Key_Comma, nullptr, nullptr, QAction::PreferencesRole);
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/GeneralPreferencesDialog.qml"), "GeneralPreferencesDialog");
});
// Settings > Avatar...
action = addActionToQMenuAndActionHash(settingsMenu, "Avatar...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/AvatarPreferencesDialog.qml"), "AvatarPreferencesDialog");
});
// Settings > Audio...
action = addActionToQMenuAndActionHash(settingsMenu, "Audio...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/AudioPreferencesDialog.qml"), "AudioPreferencesDialog");
});
// Settings > LOD...
action = addActionToQMenuAndActionHash(settingsMenu, "LOD...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/LodPreferencesDialog.qml"), "LodPreferencesDialog");
});
// Settings > Control with Speech [advanced]
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
auto speechRecognizer = DependencyManager::get<SpeechRecognizer>();
QAction* speechRecognizerAction = addCheckableActionToQMenuAndActionHash(settingsMenu, MenuOption::ControlWithSpeech,
Qt::CTRL | Qt::SHIFT | Qt::Key_C,
speechRecognizer->getEnabled(),
speechRecognizer.data(),
SLOT(setEnabled(bool)),
UNSPECIFIED_POSITION, "Advanced");
connect(speechRecognizer.data(), SIGNAL(enabledUpdated(bool)), speechRecognizerAction, SLOT(setChecked(bool)));
#endif
// Developer menu ----------------------------------
MenuWrapper* developerMenu = addMenu("Developer", "Developer");
// Developer > Graphics...
action = addActionToQMenuAndActionHash(developerMenu, "Graphics...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/GraphicsPreferencesDialog.qml"), "GraphicsPreferencesDialog");
});
// Developer > Render >>>
MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render");
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 > 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 > Resolution
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::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));
connect(textureGroup, &QActionGroup::triggered, [textureGroup] {
auto checked = textureGroup->checkedAction();
auto text = checked->text();
gpu::Context::Size newMaxTextureMemory { 0 };
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);
}
gpu::Texture::setAllowedGPUMemoryUsage(newMaxTextureMemory);
});
// Developer > Render > LOD Tools
addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools, 0, dialogsManager.data(), SLOT(lodTools()));
// Developer > Assets >>>
MenuWrapper* assetDeveloperMenu = developerMenu->addMenu("Assets");
auto& atpMigrator = ATPAssetMigrator::getInstance();
atpMigrator.setDialogParent(this);
addActionToQMenuAndActionHash(assetDeveloperMenu, MenuOption::AssetMigration,
0, &atpMigrator,
SLOT(loadEntityServerFile()));
// 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_FACESHIFT
QAction* faceshiftFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Faceshift,
0, false,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(faceshiftFaceTracker);
#endif
#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
#endif
#if defined(HAVE_FACESHIFT) || defined(HAVE_DDE)
faceTrackingMenu->addSeparator();
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking,
Qt::CTRL | Qt::SHIFT | Qt::Key_F, true); // DDE face tracking is on by default
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
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AvatarReceiveStats, 0, false,
avatarManager.data(), SLOT(setShouldShowReceiveStats(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderBoundingCollisionShapes);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderMyLookAtVectors, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderOtherLookAtVectors, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::FixGaze, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawDefaultPose, 0, false,
avatar, SLOT(setEnableDebugDrawDefaultPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawAnimPose, 0, false,
avatar, SLOT(setEnableDebugDrawAnimPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawPosition, 0, false,
avatar, SLOT(setEnableDebugDrawPosition(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::MeshVisible, 0, true,
avatar, SLOT(setEnableMeshVisible(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::DisableEyelidAdjustment, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::TurnWithHead, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::UseAnimPreAndPostRotations, 0, true,
avatar, SLOT(setUseAnimPreAndPostRotations(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableInverseKinematics, 0, true,
avatar, SLOT(setEnableInverseKinematics(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderSensorToWorldMatrix, 0, false,
avatar, SLOT(setEnableDebugDrawSensorToWorldMatrix(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ActionMotorControl,
Qt::CTRL | Qt::SHIFT | Qt::Key_K, true, avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ScriptedMotorControl, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableCharacterController, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
// Developer > Hands >>>
MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands");
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false,
avatar, SLOT(setEnableDebugDrawHandControllers(bool)));
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::LowVelocityFilter, 0, true,
qApp, SLOT(setLowVelocityFilter(bool)));
MenuWrapper* leapOptionsMenu = handOptionsMenu->addMenu("Leap Motion");
addCheckableActionToQMenuAndActionHash(leapOptionsMenu, MenuOption::LeapMotionOnHMD, 0, false);
// Developer > Entities >>>
MenuWrapper* entitiesOptionsMenu = developerMenu->addMenu("Entities");
addActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::OctreeStats, 0,
dialogsManager.data(), SLOT(octreeStatsDetails()));
addCheckableActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::ShowRealtimeEntityStats);
// Developer > Network >>>
MenuWrapper* networkMenu = developerMenu->addMenu("Network");
addActionToQMenuAndActionHash(networkMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()));
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()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::BandwidthDetails, 0,
dialogsManager.data(), SLOT(bandwidthDetails()));
#if (PR_BUILD || DEV_BUILD)
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongProtocolVersion, 0, false,
qApp, SLOT(sendWrongProtocolVersionsSignature(bool)));
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongDSConnectVersion, 0, false,
nodeList.data(), SLOT(toggleSendNewerDSConnectVersion(bool)));
#endif
// Developer > Timing >>>
MenuWrapper* timingMenu = developerMenu->addMenu("Timing");
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::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");
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()));
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);
}
// Developer > Audio > Audio Network Stats...
addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNetworkStats, 0,
dialogsManager.data(), SLOT(audioStatsDetails()));
// Developer > Physics >>>
MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");
{
auto drawStatusConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<render::DrawStatus>();
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned,
0, false, drawStatusConfig, SLOT(setShowNetwork(bool)));
}
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowHulls);
// Developer > Ask to Reset Settings
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::AskToResetSettings, 0, false);
// Developer > Display Crash Options
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::DisplayCrashOptions, 0, true);
// Developer > Crash >>>
MenuWrapper* crashMenu = developerMenu->addMenu("Crash");
addActionToQMenuAndActionHash(crashMenu, MenuOption::DeadlockInterface, 0, qApp, SLOT(deadlockApplication()));
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(); }); });
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(); }); });
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(); }); });
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(); }); });
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(); }); });
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(); }); });
// Developer > Log...
addActionToQMenuAndActionHash(developerMenu, MenuOption::Log, Qt::CTRL | Qt::SHIFT | Qt::Key_L,
qApp, SLOT(toggleLogDialog()));
// Developer > Stats
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::Stats);
#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
}
/* ******************************************************************** *
* private
* @param
* menu instance (pointer)
* menu element (pointer)
* @return
* search status (uint8)
* ******************************************************************** */
uint8_t LCDMenuLib::selectElementDirect(LCDMenu &p_m, uint8_t p_search)
/* ******************************************************************** */
{
//deklaration
LCDMenu * search = &p_m;
LCDMenu * tmp;
uint8_t found = 0;
bitSet(control, _LCDML_control_search_display);
do
{
tmp = search->getChild(0);
if (tmp) {//check elements for childs
goEnter();
if (tmp->name == p_search) { //search elements in this layer
found = 1;
break;
}
else {
function = _LCDML_NO_FUNC;
}
found = selectElementDirect(*tmp, p_search); //recursive search until found is true or last item reached
if (found == 1) { //check result
//something found
break;
}
else {
function = _LCDML_NO_FUNC;
//nothing found
//goto next root element
goBack();
Button_udlr(_LCDML_button_down);
}
}
else {
//no childs found
if (search->name == p_search) { //search
//found something
found = 1;
break;
}
else {
function = _LCDML_NO_FUNC;
//select next element
Button_udlr(_LCDML_button_down);
}
}
} while ((search=search->getSibling(1)) != NULL && found == 0);
if (found == 1) {
bitClear(control, _LCDML_control_search_display);
}
//return result
return found;
}
