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();
}
