void LLFloaterCamera::switchMode(ECameraControlMode mode) { setMode(mode); switch (mode) { case CAMERA_CTRL_MODE_MODES: if(sFreeCamera) { switchMode(CAMERA_CTRL_MODE_FREE_CAMERA); } break; case CAMERA_CTRL_MODE_PAN: sFreeCamera = false; clear_camera_tool(); break; case CAMERA_CTRL_MODE_FREE_CAMERA: sFreeCamera = true; activate_camera_tool(); break; case CAMERA_CTRL_MODE_PRESETS: if(sFreeCamera) { switchMode(CAMERA_CTRL_MODE_FREE_CAMERA); } break; default: //normally we won't occur here llassert_always(FALSE); } }
void CUDRCController::setActive(bool value) { if(m_mode == HOTSPOT) return; if(value == HIGH) { ::digitalWrite(BASE_PIN, LOW); switchMode(FM_FM); } else { switchMode(m_mode); ::digitalWrite(BASE_PIN, HIGH); } }
void VirtualKeyboard::switchMode(const String& newMode) { if (!_modes.contains(newMode)) { warning("Keyboard mode '%s' unknown", newMode.c_str()); } else { switchMode(&_modes[newMode]); } }
void VirtualKeyboard::show() { if (!_loaded) { warning("Virtual keyboard not loaded"); return; } else { _kbdGUI->checkScreenChanged(); } switchMode(_initialMode); _kbdGUI->run(); if (_submitKeys) { EventManager *eventMan = _system->getEventManager(); assert(eventMan); // push keydown & keyup events into the event manager Event evt; evt.synthetic = false; while (!_keyQueue.empty()) { evt.kbd = _keyQueue.pop(); evt.type = EVENT_KEYDOWN; eventMan->pushEvent(evt); evt.type = EVENT_KEYUP; eventMan->pushEvent(evt); } } else { _keyQueue.clear(); } }
KviTopicWidget::KviTopicWidget(QWidget * par, KviChannelWindow * pChannel, const char * name) : QWidget(par) { setObjectName(name); m_pKviChannelWindow = pChannel; m_pHistory = 0; m_pAccept = 0; m_pDiscard = 0; m_pContextPopup = 0; m_iCursorPosition = 0; m_pInput = 0; m_pLabel = new KviThemedLabel(this, pChannel, "topic_label"); m_pLabel->setTextFormat(Qt::RichText); connect(m_pLabel,SIGNAL(doubleClicked()),this,SLOT(switchMode())); reset(); m_pCompletionBox = new KviTalListWidget(this,"topic_completion_box",Qt::Popup); m_pCompletionBox->setFont( font() ); m_pCompletionBox->setPalette( palette() ); m_pCompletionBox->setFrameStyle(QFrame::Box | QFrame::Plain); m_pCompletionBox->setSelectionBehavior(QAbstractItemView::SelectRows); m_pCompletionBox->setSelectionMode(QAbstractItemView::SingleSelection); m_pItemDelegate = new KviTopicListBoxItemDelegate(m_pCompletionBox); m_pCompletionBox->setItemDelegate(m_pItemDelegate); connect(m_pCompletionBox,SIGNAL(itemSelectionChanged()),this,SLOT(complete())); m_pCompletionBox->hide(); setAutoFillBackground(false); setContentsMargins(0,0,0,0); applyOptions(); }
void LLFloaterCamera::fromFreeToPresets() { if (!sFreeCamera && mCurrMode == CAMERA_CTRL_MODE_FREE_CAMERA && mPrevMode == CAMERA_CTRL_MODE_PRESETS) { switchMode(CAMERA_CTRL_MODE_PRESETS); } }
//-------------------------------------------------------------- void testApp::keyReleased(int key){ switch( key ){ case 'j': color_tracking.toggleJitter(); break; case 'r': gr.recordGesture(); break; case 53: gr.decreaseClassLabel(); break; case 45: gr.increaseClassLabel(); break; case 't': gr.trainPipeline(); break; case 's': gr.saveTrainingData(); break; case 'c': gr.clearTrainingData(); break; case 'f': ofToggleFullscreen(); break; case 59: switchMode(); break; default: break; } }
CInputFilter::EFilterStatus CInputFilter::CMouseButtonAction::perform( CEvent& event, void*, EActionMode actionMode) { EActionState newState = switchMode(actionMode); CEvent::Type type; if (newState == kStateOn) { type = IPlatformScreen::getButtonDownEvent(); } else if (newState == kStateOff) { type = IPlatformScreen::getButtonUpEvent(); } else { return kNotHandled; } setState(newState); event = CEvent(type, event.getTarget(), m_buttonInfo, CEvent::kDeliverImmediately | CEvent::kDontFreeData); return kHandled; }
void LLFloaterCamera::onClickBtn(ECameraControlMode mode) { // check for a click on active button if (mCurrMode == mode) mMode2Button[mode]->setToggleState(TRUE); switchMode(mode); }
void VirtualKeyboard::switchMode(const std::string&newMode) { if (!_modes.count(newMode)) { Warning("Keyboard mode '" + newMode + "' unknown"); } else { switchMode(&_modes[newMode]); } }
bool SmartPolicy::decideDir (double elapsedS, Vector2* outDir, Game* game, EnemyTank* me) { modeElapsedS += elapsedS; //This mode switching algorithms will maximize fire and the tank is hidding only when he can't fire if (mode == AGGRESSIVE) { if (!me->canFire()) { switchMode(DEFENSIVE); planPath(game, me); } } else { if (me->canFire()) { switchMode(AGGRESSIVE); planPath(game, me); } } //FIXME: first move should be to avoid rockets PathFinder* pathFinder = game->getPathFinder(); if (pathFinder->needsReplanning(me)) { planPath(game,me); } if (!shortestWay) { return adjustForFiring(outDir, game, me); } #ifdef DEBUG //game->dbg_addCellOverlay(CellOverlay(destX, destY, WHITE)); game->dbg_addDebugPath(new DebugPath(shortestWay, VIOLET)); #endif //If tank is already at destination grid cell, don't move forward /*const Grid& g = game->getColManager().getGrid(); const Vector2& pos = me->getPosition(); if (g.getCellX(pos) == destX && g.getCellY(pos) == destY) { return adjustForFiring(outDir, game, me); }*/ //LOGE("p(0) (%f,%f), tank position (%f,%f)", p->get(0).x, p->get(0).y, me->getPosition().x, me->getPosition().y); const Vector2 dir = (shortestWay->get(0) - me->getPosition()).getNormalized(); outDir->set(dir); return true; }
NewTransferDlg::NewTransferDlg(QWidget* parent) : QDialog(parent), m_bDetails(false), m_bPaused(false), m_nDownLimit(0), m_nUpLimit(0), m_nClass(-1), m_mode(Transfer::Download), m_nQueue(0) { setupUi(this); textURIs->setFocus(Qt::OtherFocusReason); spinDown->setRange(0,INT_MAX); spinUp->setRange(0,INT_MAX); connect(toolBrowse, SIGNAL(pressed()), this, SLOT(browse())); connect(radioDownload, SIGNAL(clicked()), this, SLOT(switchMode())); connect(radioUpload, SIGNAL(clicked()), this, SLOT(switchMode())); connect(pushAddFiles, SIGNAL(clicked()), this, SLOT(browse2())); connect(toolAuth, SIGNAL(clicked()), this, SLOT(authData())); connect(toolAuth2, SIGNAL(clicked()), this, SLOT(authData())); comboClass->addItem(tr("Auto detect")); for(int i=0;i<g_enginesDownload.size();i++) comboClass->addItem(g_enginesDownload[i].longName); comboClass2->addItem(tr("Auto detect")); for(int i=0;i<g_enginesUpload.size();i++) comboClass2->addItem(g_enginesUpload[i].longName); QMenu* menu = new QMenu(toolAddSpecial); QAction* act; act = menu->addAction(tr("Add local files...")); connect(act, SIGNAL(triggered()), this, SLOT(browse2())); act = menu->addAction(tr("Add contents of a text file...")); connect(act, SIGNAL(triggered()), this, SLOT(addTextFile())); act = menu->addAction(tr("Add from clipboard")); connect(act, SIGNAL(triggered()), this, SLOT(addClipboard())); toolAddSpecial->setMenu(menu); }
void HistogramWindow::metricToggled(bool x) { if (active) return; active = true; stale = true; data->setChecked(!x); switchMode(); active = false; }
void HistogramWindow::setDataMode(bool value) { if (!rangemode) return; else { active = true; data->setChecked(value); metric->setChecked(!value); active = false; switchMode(); } }
GameControlWidget::GameControlWidget(QWidget *parent) : QGLWidget(QGLFormat(QGL::DoubleBuffer),parent), ui(new Ui::GameControlWidget), redrawTimerID(-1),currHandler(NULL), tiltMode(*this),gameMode(*this),scoreboardMode(*this) { switchMode(GS_TitleMode); ui->setupUi(this); this->setMouseTracking(true); initialGameState(); }
void LLFloaterCamera::onClose(bool app_quitting) { //We don't care of camera mode if app is quitting if(app_quitting) return; // When mCurrMode is in CAMERA_CTRL_MODE_PAN // switchMode won't modify mPrevMode, so force it here. // It is needed to correctly return to previous mode on open, see EXT-2727. if (mCurrMode == CAMERA_CTRL_MODE_PAN) mPrevMode = CAMERA_CTRL_MODE_PAN; switchMode(CAMERA_CTRL_MODE_PAN); mClosed = TRUE; }
bool VirtualKeyboard::show(bool blocking) { if (!_loaded) { Warning("Virtual keyboard not loaded"); return false; } else { _kbdGUI->checkScreenChanged(); } switchMode(_initialMode); _kbdGUI->run(blocking); return _submitKeys; }
int FileIo::seek(long offset, Position pos) { assert(fp_ != 0); int fileSeek = 0; switch (pos) { case BasicIo::cur: fileSeek = SEEK_CUR; break; case BasicIo::beg: fileSeek = SEEK_SET; break; case BasicIo::end: fileSeek = SEEK_END; break; } if (switchMode(opSeek) != 0) return 1; return std::fseek(fp_, offset, fileSeek); }
static int Screen_fd(ScreenObject *self) { if (self->fd >= 0) return 1; self->fd = open("/dev/fb0", O_RDWR); if (self->fd < 0) return 0; int vid = 0; int res = 0; if (self->desiredMode >= 0) { // printf("desired mode %d\n", self->desiredMode); vid = self->desiredMode; if ((res=ioctl(self->fd, PS3FB_IOCTL_SETMODE, (unsigned long)&vid))<0) return 0; self->mode = self->desiredMode; } else { if ((res=ioctl(self->fd, PS3FB_IOCTL_GETMODE, (unsigned long)&vid))<0) self->mode = -1; else self->mode = vid; } if (ioctl(self->fd, PS3FB_IOCTL_SCREENINFO, (unsigned long)(&self->res))==-1) return 0; self->lengthPerFrame = self->res.xres * self->res.yres * 4; self->length = self->lengthPerFrame * self->res.num_frames; self->graphicsMode = 1; switchMode(self, 1); self->addr = mmap(0, self->length, PROT_WRITE, MAP_SHARED, self->fd, 0); if (self->addr == NULL) return 0; if (ioctl(self->fd, PS3FB_IOCTL_ON, 0) < 0) return 0; self->drawFrame = 1; self->current = self->addr; uint32_t showFrame = self->drawFrame ? 0 : 1; ioctl(self->fd, PS3FB_IOCTL_FSEL, (unsigned long)&showFrame); return 1; }
bool CUDRCController::open() { if(::wiringPiSetupGpio() != 0) { wxLogError("Unable to initialize the wiringPi library"); return false; } if(m_mode != HOTSPOT) { ::pinMode(m_pttPin, OUTPUT); for(int i = 0; i < ARRAY_SIZE(input_pins); ++i) { ::pinMode(input_pins[i], INPUT); ::pullUpDnControl(input_pins[i], PUD_UP); } for(int i = 0; i < ARRAY_SIZE(output_pins); ++i) { ::pinMode(output_pins[i], OUTPUT); ::digitalWrite(output_pins[i], HIGH); } ::digitalWrite(m_pttPin, HIGH); ::digitalWrite(BASE_PIN, LOW); switchMode(m_mode); ::digitalWrite(BASE_PIN, HIGH); } else { // On a UDRC II in Hotspot mode, the PTT is on EXT3_PIN instead switch(getNWDRProductID()) { case UDRC_PRODUCT_ID: m_pttPin = PTT_PIN; break; case UDRC_II_PRODUCT_ID: m_pttPin = EXT3_PIN; break; case -1: return false; default: wxLogError("Unknown NW Digital Radio Product"); return false; } ::pinMode(m_pttPin, OUTPUT); ::digitalWrite(m_pttPin, LOW); } return true; }
void LLFloaterCamera::onClose(bool app_quitting) { //We don't care of camera mode if app is quitting if(app_quitting) return; // When mCurrMode is in CAMERA_CTRL_MODE_PAN // switchMode won't modify mPrevMode, so force it here. // It is needed to correctly return to previous mode on open, see EXT-2727. if (mCurrMode == CAMERA_CTRL_MODE_PAN) mPrevMode = CAMERA_CTRL_MODE_PAN; // HACK: Should always close as docked to prevent toggleInstance without calling onOpen. if ( !isDocked() ) setDocked(true); switchMode(CAMERA_CTRL_MODE_PAN); mClosed = TRUE; }
void TypingBox::keyPressEvent(QKeyEvent *event) { if(event->key()==Qt::Key_Return){ emit enterPressed(); } else if(event->key()==Qt::Key_Escape) { emit escapePressed(); } else if(event->key()==Qt::Key_Tab) { emit switchMode(); } else if(event->key()==Qt::Key_Period && (event->modifiers() & Qt::ControlModifier)) { emit showPreferences(); } else if(event->key()==Qt::Key_Z && (event->modifiers() & Qt::ControlModifier)) { emit switchColoringMode(); } else { QTextBrowser::keyPressEvent(event); } }
void GLLUTWidget::keyPressEvent ( QKeyEvent * event ) { if (event->key()==Qt::Key_Left) { //this->zoom.panRight(); this->redraw(); //upgl event->accept(); } else if (event->key()==Qt::Key_M) { switchMode(); } else if (event->key()==Qt::Key_A) { if (state.slice_idx < (int)slices.size()-1) state.slice_idx++; this->redraw(); //upgl } else if (event->key()==Qt::Key_I) { signalKeyPressEvent(event); event->accept(); } else if (event->key()==Qt::Key_C) { signalKeyPressEvent(event); event->accept(); } else if (event->key()==Qt::Key_Z) { if (state.slice_idx > 0) state.slice_idx--; this->redraw(); //upgl } else if (event->key()==Qt::Key_Right) { //this->zoom.panLeft(); this->redraw(); //upgl event->accept(); } else if (event->key()==Qt::Key_Up) { //this->zoom.panDown(); this->redraw(); //upgl event->accept(); } else if (event->key()==Qt::Key_Down) { //this->zoom.panUp(); this->redraw(); //upgl event->accept(); } else if (event->key()==Qt::Key_PageUp) { //this->zoom.zoomIn(); this->redraw(); //upgl event->accept(); } else if (event->key()==Qt::Key_PageDown) { //this->zoom.zoomOut(); this->redraw(); //upgl event->accept(); } else { event->ignore(); } }
static void Screen_closeResources(ScreenObject* self) { if (self->fd >= 0) { if (self->addr != NULL) { ioctl(self->fd, PS3FB_IOCTL_OFF, 0); munmap(self->addr, self->length); } close(self->fd); self->fd = -1; } if (self->graphicsMode) { switchMode(self, 0); self->graphicsMode = 0; } if (self->dumpFD >= 0) { close(self->dumpFD); self->dumpFD = -1; } self->desiredMode = -1; }
void VirtualKeyboard::processAreaClick(const std::string& area) { if (!_currentMode->events.count(area)) return; VKEvent *evt = _currentMode->events[area]; switch (evt->type) { case kVKEventKey: // add virtual keypress to queue _keyQueue.insertKey(*(KeyState*) evt->data); break; case kVKEventModifier: _keyQueue.toggleFlags(*(int*) (evt->data)); break; case kVKEventSwitchMode: // switch to new mode switchMode((char *) evt->data); _keyQueue.clearFlags(); break; case kVKEventSubmit: if (_submitCallback != NULL) _submitCallback(getString()); close(true); break; case kVKEventCancel: close(false); break; case kVKEventClear: _keyQueue.clear(); break; case kVKEventDelete: _keyQueue.deleteKey(); break; case kVKEventMoveLeft: _keyQueue.moveLeft(); break; case kVKEventMoveRight: _keyQueue.moveRight(); break; } }
CInputFilter::EFilterStatus CInputFilter::CLockCursorToScreenAction::perform( CEvent& event, void*, EActionMode actionMode) { EActionState newState = switchMode(actionMode); if (newState != kStateOn && newState != kStateOff) { return kNotHandled; } setState(newState); // prepare event CServer::CLockCursorToScreenInfo* info = CServer::CLockCursorToScreenInfo::alloc(newState != kStateOff); event = CEvent(CServer::getLockCursorToScreenEvent(), event.getTarget(), info, CEvent::kDeliverImmediately); return kHandled; }
long FileIo::write(BasicIo& src) { assert(fp_ != 0); if (static_cast<BasicIo*>(this) == &src) return 0; if (!src.isopen()) return 0; if (switchMode(opWrite) != 0) return 0; byte buf[4096]; long readCount = 0; long writeCount = 0; long writeTotal = 0; while ((readCount = src.read(buf, sizeof(buf)))) { writeTotal += writeCount = (long)std::fwrite(buf, 1, readCount, fp_); if (writeCount != readCount) { // try to reset back to where write stopped src.seek(writeCount-readCount, BasicIo::cur); break; } } return writeTotal; }
CInputFilter::EFilterStatus CInputFilter::CModifierAction::perform( CEvent&, void*, EActionMode actionMode) { EActionState newState = switchMode(actionMode); if (newState == kStateOn) { setModifierMask(m_modifiers); } else if (newState == kStateOff) { setModifierMask(0); } else { return kNotHandled; } setState(newState); // FIXME. set proper key event, so updateModifiers will get called from // within sendEvent automatically return kUpdateModifiers; }
void KukieControlQueue::setAdditionalLoad(float loadMass, float loadPos) { if(isRealRobot) { std_msgs::Float32MultiArray msg; msg.layout.dim.push_back(std_msgs::MultiArrayDimension()); msg.layout.dim[0].size = 2; msg.layout.dim[0].stride = 0; msg.layout.dim[0].label = "Load"; msg.data.push_back(loadMass); msg.data.push_back(loadPos); pubAddLoad.publish(msg); int tmpMode = getCurrentControlType(); stopCurrentMode(); switchMode(tmpMode); } else { if(!isShutUp()) ROS_INFO("(setAdditionalLoad) this functionality is not available in simulator - ignored"); } }
RotationEdit::RotationEdit( QWidget * parent ) : ValueEdit( parent ), mode( mAuto ), setting( false ) { actMode = new QAction( this ); connect( actMode, SIGNAL( triggered() ), this, SLOT( switchMode() ) ); QToolButton * btMode = new QToolButton( this ); btMode->setDefaultAction( actMode ); QHBoxLayout * lay = new QHBoxLayout( this ); lay->setMargin( 0 ); lay->setSpacing( 0 ); lay->addWidget( btMode, 2 ); for ( int x = 0; x < 4; x++ ) { lay->addWidget( l[x] = new CenterLabel, 1 ); lay->addWidget( v[x] = new QDoubleSpinBox, 5 ); connect( v[x], SIGNAL( valueChanged( double ) ), this, SLOT( sltChanged() ) ); } setFocusProxy( v[0] ); setupMode(); }