bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa, osg::Object*, osg::NodeVisitor*)
{
if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _c)
{
osg::Vec3d world;
_mapNode->getTerrain()->getWorldCoordsUnderMouse(aa.asView(), ea.getX(), ea.getY(), world);
GeoPoint coords;
coords.fromWorld(s_activeMap->getSRS(), world);
osg::ref_ptr<ElevationEnvelope> env = s_activeMap->getElevationPool()->createEnvelope(s_activeMap->getSRS(), 23u);
float ep_elev = env->getElevation(coords.x(), coords.y());
OE_NOTICE << "Elevations under mouse. EP=" << ep_elev << "\n";
}
return false;
}
bool QueryCoordinatesHandler::handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
{
if ( ea.getEventType() == osgGA::GUIEventAdapter::MOVE )
{
osgViewer::View* view = static_cast<osgViewer::View*>( aa.asView() );
osg::Vec3d coords = getCoords( ea.getX(), ea.getY(), view, false );
mGlobe->showCurrentCoordinates( coords.x(), coords.y() );
}
if ( ea.getEventType() == osgGA::GUIEventAdapter::PUSH
&& ea.getButtonMask() == osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON )
{
osgViewer::View* view = static_cast<osgViewer::View*>( aa.asView() );
osg::Vec3d coords = getCoords( ea.getX(), ea.getY(), view, false );
OE_NOTICE << "SelectedCoordinates set to:\nLon: " << coords.x() << " Lat: " << coords.y()
<< " Ele: " << coords.z() << std::endl;
mGlobe->setSelectedCoordinates( coords );
if ( ea.getModKeyMask() == osgGA::GUIEventAdapter::MODKEY_CTRL )
//ctrl + rightclick pops up a QMessageBox
{
mGlobe->showSelectedCoordinates();
}
}
return false;
}
bool KeyboardHandler::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
{
if(ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN)
{
if(ea.getKey() == 'w')
{
std::cout << "W pressed" << std::endl;
return false;
}
}
return false;
}
bool MYGUIManager::handleEvent(const osgGA::GUIEventAdapter& ea, bool async) const {
if (async || !_platform || !_initialized) {
const_cast<MYGUIManager*>(this)->pushEvent(&ea);
return false;
}
int x = ea.getX(), y = ea.getY(), key = ea.getKey();
static int z = 0;
if (ea.getMouseYOrientation() == osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS)
y = ea.getWindowHeight() - y;
x = int(floor(float(x) / _uiScale + 0.5f));
y = int(floor(float(y) / _uiScale + 0.5f));
switch (ea.getEventType())
{
case osgGA::GUIEventAdapter::PUSH:
return MyGUI::InputManager::getInstance().injectMousePress(x, y, convertMouseButton(ea.getButton()));
break;
case osgGA::GUIEventAdapter::RELEASE:
return MyGUI::InputManager::getInstance().injectMouseRelease(x, y, convertMouseButton(ea.getButton()));
break;
case osgGA::GUIEventAdapter::SCROLL:
switch (ea.getScrollingMotion()) {
case osgGA::GUIEventAdapter::SCROLL_UP:
z++; break;
case osgGA::GUIEventAdapter::SCROLL_DOWN:
z--; break;
}
// fall through
case osgGA::GUIEventAdapter::DRAG:
case osgGA::GUIEventAdapter::MOVE:
return MyGUI::InputManager::getInstance().injectMouseMove(x, y, z);
break;
case osgGA::GUIEventAdapter::KEYDOWN:
if (key<127)
return MyGUI::InputManager::getInstance().injectKeyPress(convertKeyCode(key), (char)key);
else
return MyGUI::InputManager::getInstance().injectKeyPress(convertKeyCode(key));
break;
case osgGA::GUIEventAdapter::KEYUP:
return MyGUI::InputManager::getInstance().injectKeyRelease(convertKeyCode(key));
break;
case osgGA::GUIEventAdapter::RESIZE:
_platform->getRenderManagerPtr()->setViewSize(
int(floor(float(ea.getWindowWidth()) / _uiScale + 0.5f)),
int(floor(float(ea.getWindowHeight()) / _uiScale + 0.5f)));
break;
default:
break;
}
return false;
}
bool handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
{
if ( ea.getEventType() == osgGA::GUIEventAdapter::MOVE )
{
osgViewer::View* view = static_cast<osgViewer::View*>( aa.asView() );
osgUtil::LineSegmentIntersector::Intersections hits;
if ( view->computeIntersections( ea.getX(), ea.getY(), hits ) )
{
osgEarth::GeoPoint isectPoint;
isectPoint.fromWorld( mGlobe->mapNode()->getMapSRS()->getGeodeticSRS(), hits.begin()->getWorldIntersectPoint() );
mGlobe->showCurrentCoordinates( isectPoint );
}
}
return false;
}
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& /*aa*/)
{
if (!_gt) return false;
switch(ea.getEventType())
{
case(osgGA::GUIEventAdapter::KEYDOWN):
{
if (ea.getKey() == 'g')
{
osg::notify(osg::NOTICE)<<"Gaussian"<<std::endl;
_gt->setFilterMatrixAs(osgTerrain::GeometryTechnique::GAUSSIAN);
return true;
}
else if (ea.getKey() == 's')
{
osg::notify(osg::NOTICE)<<"Smooth"<<std::endl;
_gt->setFilterMatrixAs(osgTerrain::GeometryTechnique::SMOOTH);
return true;
}
else if (ea.getKey() == 'S')
{
osg::notify(osg::NOTICE)<<"Sharpen"<<std::endl;
_gt->setFilterMatrixAs(osgTerrain::GeometryTechnique::SHARPEN);
return true;
}
else if (ea.getKey() == '+')
{
_gt->setFilterWidth(_gt->getFilterWidth()*1.1);
osg::notify(osg::NOTICE)<<"Filter width = "<<_gt->getFilterWidth()<<std::endl;
return true;
}
else if (ea.getKey() == '-')
{
_gt->setFilterWidth(_gt->getFilterWidth()/1.1);
osg::notify(osg::NOTICE)<<"Filter width = "<<_gt->getFilterWidth()<<std::endl;
return true;
}
else if (ea.getKey() == '>')
{
_gt->setFilterBias(_gt->getFilterBias()+0.1);
osg::notify(osg::NOTICE)<<"Filter bias = "<<_gt->getFilterBias()<<std::endl;
return true;
}
else if (ea.getKey() == '<')
{
_gt->setFilterBias(_gt->getFilterBias()-0.1);
osg::notify(osg::NOTICE)<<"Filter bias = "<<_gt->getFilterBias()<<std::endl;
return true;
}
break;
}
default:
break;
}
return false;
}
bool KeyboardEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
{
switch(ea.getEventType())
{
case(osgGA::GUIEventAdapter::KEYDOWN):
{
switch(ea.getKey())
{
case '1':
placeStreams(GRID_LAYOUT);
return false;
break;
case '2':
placeStreams(ROW_LAYOUT);
return false;
break;
case '3':
colorStreams(MEMORY_COLORING);
return false;
break;
case '4':
colorStreams(EXECUTION_FREQ_COLORING);
return false;
break;
case 'h':
hideByImage(HIDE);
return false;
break;
case 'u':
hideByImage(HIDE_ALL_ELSE);
return false;
break;
case 'n':
updateTimeline(1);
return false;
break;
case 'p':
updateTimeline(-1);
return false;
break;
default:
return false;
}
}
default:
return false;
}
}
bool OrbitCameraManipulator::handleMouseWheel( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
{
osgGA::GUIEventAdapter::ScrollingMotion sm = ea.getScrollingMotion();
// TODO: increase scroll factor when eye is far away from model bounding sphere
double scroll_distance_factor = ( m_eye - m_rotate_center ).length()*0.1;
switch( sm )
{
// mouse scroll up event
case osgGA::GUIEventAdapter::SCROLL_UP:
{
// perform zoom
zoomCamera( m_wheel_zoom_factor*scroll_distance_factor );
aa.requestRedraw();
aa.requestContinuousUpdate( isAnimating() || _thrown );
return true;
}
// mouse scroll down event
case osgGA::GUIEventAdapter::SCROLL_DOWN:
{
// perform zoom
zoomCamera( -m_wheel_zoom_factor*scroll_distance_factor );
aa.requestRedraw();
aa.requestContinuousUpdate( isAnimating() || _thrown );
return true;
}
// unhandled mouse scrolling motion
default:
return false;
}
}
bool WeaponHandler::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa)
{
/* osgViewer::View* view = dynamic_cast<osgViewer::View*>(&aa);
if (!view) return false;
osgViewer::ViewerBase* viewer = view->getViewerBase();
*/
// if (ea.getHandled()) return false;
switch(ea.getEventType())
{
case(osgGA::GUIEventAdapter::RELEASE):
//case(osgGA::GUIEventAdapter::DOUBLECLICK):
{
//shoot
// if(ea.getButtonMask() == osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON)
{
//if(osgGA::GUIEventAdapter::RELEASE == ea.getEventType())
GameManager::instance()->getWeaponManager()->Tire();
}
break;
}
default:
break;
}
return false;
}
void UFOManipulator::home(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us)
{
home(ea.getTime());
us.requestRedraw();
us.requestContinuousUpdate(false);
}
bool CScreenCapture::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
{
osgViewer::ViewerBase* viewer = dynamic_cast<osgViewer::View*>(&aa)->getViewerBase();
if (!viewer) return false;
switch (ea.getEventType())
{
case (osgGA::GUIEventAdapter::FRAME) :
{
// Booleans aren't the best way of doing this, but I want to do
// the actual adding here because I don't want to require
// startCapture() take a viewer as argument, which could not be
// the right one.
if (_startCapture)
{
// Start capturing with the currently set number of frames.
// If set to -1 it will capture continuously, if set to >0
// it will capture that number of frames.
_startCapture = false;
addCallbackToViewer(*viewer);
}
else if (_stopCapture)
{
_stopCapture = false;
removeCallbackFromViewer(*viewer);
}
break;
}
default:
break;
}
return false;
}
bool handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
{
if ( ea.getEventType() == osgGA::GUIEventAdapter::RESIZE || _first )
{
osg::Camera* cam = aa.asView()->getCamera();
if ( cam && cam->getViewport() )
{
const osg::Viewport* vp = cam->getViewport();
if ( _first || vp->width() != _width || vp->height() != _height )
{
_cs->setProjectionMatrix(osg::Matrix::ortho2D( 0, vp->width()-1, 0, vp->height()-1 ) );
ControlContext cx;
cx._vp = new osg::Viewport( 0, 0, vp->width(), vp->height() );
cx._viewContextID = aa.asView()->getCamera()->getGraphicsContext()->getState()->getContextID();
_cs->setControlContext( cx );
_width = vp->width();
_height = vp->height();
}
if ( vp->width() != 0 && vp->height() != 0 )
{
_first = false;
}
}
}
return false;
}
bool handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& )
{
if( ea.getEventType() != osgGA::GUIEventAdapter::KEYDOWN )
return false;
switch( ea.getKey() )
{
case 'x':
_gl2Scene->reloadShaderSource();
return true;
case 'y':
_gl2Scene->toggleShaderEnable();
return true;
}
return false;
}
bool OSGCameraManipulator::keyUp(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter &aa) {
int bRes = true;
int nResKey = ea.getKey();
if ((nResKey == osgGA::GUIEventAdapter::KEY_Control_L) ||
(nResKey == osgGA::GUIEventAdapter::KEY_Control_R)) {
m_bCtrl = false;
}
if ((nResKey == osgGA::GUIEventAdapter::KEY_Shift_L) ||
(nResKey == osgGA::GUIEventAdapter::KEY_Shift_R)) {
m_bShift = false;
m_dbDefaultMoveSpeed = 1;
}
if ((nResKey == osgGA::GUIEventAdapter::KEY_Up) ||
(nResKey == osgGA::GUIEventAdapter::KEY_Down)) {
m_dbForwardFactor = 0.0;
m_dbLateralRotationRate = 0.0;
m_dbDefaultMoveSpeed = 1;
}
if ((nResKey == osgGA::GUIEventAdapter::KEY_Left) ||
(nResKey == osgGA::GUIEventAdapter::KEY_Right)) {
m_dbDirectionRotationRate = 0.0;
m_dbPitchOffsetRate = 0.0;
m_dbDefaultMoveSpeed = 1;
}
return(bRes);
}
bool GISManipulator::handleMouseWheel( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us )
{
osgGA::GUIEventAdapter::ScrollingMotion sm = ea.getScrollingMotion();
osg::Vec3d eye, center, up;
getTransformation( eye, center, up );
double altitude = eye[2];
if ( sm == osgGA::GUIEventAdapter::SCROLL_UP ) {
altitude /= 1.41;
}
else if ( sm == osgGA::GUIEventAdapter::SCROLL_DOWN ) {
altitude *= 1.41;
}
else {
return false;
}
eye[2] = altitude;
center[2] = eye[2] - 1.0;
setTransformation( eye, center, up );
us.requestRedraw();
us.requestContinuousUpdate( isAnimating() );
return true;
}
void PickHandler::pick_measure(osgViewer::Viewer* viewer, const osgGA::GUIEventAdapter& ea)
{
osgUtil::LineSegmentIntersector::Intersections intersections;
if (viewer->computeIntersections(ea.getX(), ea.getY(), intersections)){
// use the nearest intersection
const osgUtil::LineSegmentIntersector::Intersection& intersection = *(intersections.begin());
(*measure_vertices)[1].set( intersection.getWorldIntersectPoint());
// cout << (*measure_vertices)[1] <<endl;
}
}
void ViewerManipulator::handleKeypress(const osgGA::GUIEventAdapter& ea)
{
if (ea.getKey()=='r')
{
sendEvent(user->s_name, "sfff", "setOrientation", 0.0, 0.0, 0.0, LO_ARGS_END);
}
}
bool TerrainZoomManipulator::handleMouseWheel( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us )
{
// no zooming by intersection is choosed
if (! (_flags & 0x08))
{
setCenterByMousePointer(ea, us);
}
switch( ea.getScrollingMotion() )
{
// mouse scroll up event
case osgGA::GUIEventAdapter::SCROLL_UP:
{
// perform zoom
zoomModel( _wheelZoomFactor, true );
us.requestRedraw();
us.requestContinuousUpdate( isAnimating() || _thrown );
return true;
}
// mouse scroll down event
case osgGA::GUIEventAdapter::SCROLL_DOWN:
zoomModel( -_wheelZoomFactor, true );
us.requestRedraw();
us.requestContinuousUpdate( false );
return true;
// unhandled mouse scrolling motion
default:
return false;
}
}
bool PickHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
{
switch(ea.getEventType())
{
case(osgGA::GUIEventAdapter::DOUBLECLICK):
{
if(measuring_tool_on){
// if(ea.getButtonMask() ==GUIEventAdapter::MIDDLE_MOUSE_BUTTON){
osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
if (viewer) pick(viewer,ea);
// }
}
return false;
}
case(osgGA::GUIEventAdapter::MOVE):
{
if(!measure_anchored)
return false;
osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
if (viewer ) pick_measure(viewer,ea);
return false;
}
default:
return false;
}
}
bool Vwr::CameraManipulator::handlePush(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us)
{
if (ea.getButtonMask() == GUIEventAdapter::MIDDLE_MOUSE_BUTTON)
{
if (_distance != 0)
{
lastDistance = _distance;
osg::Vec3d eye, cameraCenter, up;
osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>( &us );
viewer->getCamera()->getViewMatrixAsLookAt(eye, cameraCenter, up);
_center = eye;
_distance = 0;
}
else
{
_distance = lastDistance;
}
return true;
}
else
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
return true;
}
}
/*!
*
* \param ea
* Adapter udalosti.
*
* Metoda spomali pohyb na zaklade zdroja prijatej udalosti.
*
*/
bool Vwr::CameraManipulator::handleKeyUp( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter & us)
{
switch( ea.getKey() )
{
case osgGA::GUIEventAdapter::KEY_Space:
{
flushMouseEventStack();
_thrown = false;
_distance = 1.0f;
home(ea,us);
us.requestRedraw();
us.requestContinuousUpdate(false);
stop();
break;
}
case osgGA::GUIEventAdapter::KEY_Up:
case osgGA::GUIEventAdapter::KEY_Down:
decelerateForwardRate = true;
break;
case osgGA::GUIEventAdapter::KEY_Right:
case osgGA::GUIEventAdapter::KEY_Left:
decelerateSideRate = true;
break;
case osgGA::GUIEventAdapter::KEY_Page_Up:
case osgGA::GUIEventAdapter::KEY_Page_Down:
decelerateVerticalRate = true;
break;
}
return true;
}
bool MYGUIHandler::handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
{
// This only works under single-threaded mode
switch (ea.getEventType()) {
case osgGA::GUIEventAdapter::PUSH:
case osgGA::GUIEventAdapter::RELEASE:
case osgGA::GUIEventAdapter::SCROLL:
case osgGA::GUIEventAdapter::DRAG:
case osgGA::GUIEventAdapter::MOVE:
case osgGA::GUIEventAdapter::KEYDOWN:
case osgGA::GUIEventAdapter::KEYUP:
{
// check if there are any model window
bool hasModal = false;
if (_manager->_initialized) {
hasModal = MyGUI::InputManager::getInstance().isModalAny();
}
return _manager->handleEvent(ea) || hasModal;
}
case osgGA::GUIEventAdapter::RESIZE:
_manager->handleEvent(ea, true);
return false;
default:
return false;
}
}
virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &)
{
if (ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN)
{
switch (ea.getKey())
{
case 65361:
steerAngle += 0.1;
break;
case 65363:
steerAngle -= 0.1;
break;
case 65362:
gasPedal = 1.0;
break;
case 65364:
brakePedal = 1.0;
break;
}
return true;
}
else if (ea.getEventType() == osgGA::GUIEventAdapter::KEYUP)
{
switch (ea.getKey())
{
case 65362:
gasPedal = 0.0;
break;
case 65364:
brakePedal = 0.0;
break;
case 103:
gear += 1;
if (gear > 5)
gear = 5;
break;
case 102:
gear -= 1;
if (gear < -1)
gear = -1;
break;
}
return true;
}
return false;
}
virtual bool handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
{
if( ea.getEventType() == osgGA::GUIEventAdapter::FRAME )
{
osg::Vec3 pos = osg::Vec3( lightPos[0], lightPos[1], lightPos[2] );
osg::Matrixf view = osg::Matrixf::lookAt( pos, osg::Vec3( 0., 0., 0. ), osg::Vec3( 0., 0., 1. ) );
osg::Matrixf proj = osg::Matrixf::perspective( 50., 1., 10., 80. );
_shadowViewProj->set( view * proj );
return( true );
}
else if( ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN )
{
switch( ea.getKey() )
{
case 'd':
{
bool v;
_displayTC->get( v );
_displayTC->set( !v );
return( true );
}
case 'l':
{
lightPos[ 0 ] -= 1.;
return( true );
}
case 'L':
{
lightPos[ 0 ] += 1.;
return( true );
}
case 'k':
{
lightPos[ 1 ] -= 1.;
return( true );
}
case 'K':
{
lightPos[ 1 ] += 1.;
return( true );
}
}
}
return( false );
}
virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa) {
if (!level.valid()) return false;
game::Polyhedron *poly = level->getSelectedPolyhedron();
int dir = -1;
switch (ea.getEventType()) {
case osgGA::GUIEventAdapter::FRAME:
level->update();
return false;
case osgGA::GUIEventAdapter::KEYDOWN:
switch (ea.getKey()) {
case osgGA::GUIEventAdapter::KEY_Up:
dir = 0; break;
case osgGA::GUIEventAdapter::KEY_Left:
dir = 1; break;
case osgGA::GUIEventAdapter::KEY_Down:
dir = 2; break;
case osgGA::GUIEventAdapter::KEY_Right:
dir = 3; break;
case osgGA::GUIEventAdapter::KEY_Space:
if (!level->isAnimating()) level->switchToNextPolyhedron();
break;
default:
return false;
}
if (dir >= 0) {
osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
osg::Camera* camera = viewer ? viewer->getCamera() : NULL;
if (camera) {
osg::Vec3 eye, center, up;
camera->getViewMatrixAsLookAt(eye, center, up);
eye = (eye - center) ^ up;
if (eye.x() < eye.y()) {
if (eye.x() + eye.y() > 0) dir += 3;
} else if (eye.x() + eye.y() > 0) dir += 2;
else dir += 1;
}
const game::MoveDirection dirs[4] = { MOVE_UP, MOVE_LEFT, MOVE_DOWN, MOVE_RIGHT };
if (!level->isAnimating() && poly) poly->move(level.get(), dirs[dir & 3]);
}
break;
default:
return false;
}
return true;
}
bool OSGViewer::EventHandler::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) {
bool suppressDefault = false;
osgGA::GUIEventAdapter::EventType t = ea.getEventType();
// keypress handlers
if (t == osgGA::GUIEventAdapter::KEYDOWN) {
int key = ea.getKey();
KeyCallbackMap::iterator it = key_cbs.find(key);
if (it != key_cbs.end()) (it->second)(ea);
}
// general event handlers
for (int i=0; i < event_cbs.size(); ++i) suppressDefault |= event_cbs[i](ea);
if (suppressDefault) return false;
else return osgGA::TrackballManipulator::handle(ea, aa);
}
bool keyboardEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
{
bool newKeyDownEvent = false;
bool newKeyUpEvent = false;
switch(ea.getEventType())
{
case(osgGA::GUIEventAdapter::KEYDOWN):
{
keyFunctionMap::iterator itr = keyFuncMap.find(ea.getKey());
if (itr != keyFuncMap.end())
{
if ( (*itr).second.keyState == KEY_UP )
{
(*itr).second.keyState = KEY_DOWN;
newKeyDownEvent = true;
}
if (newKeyDownEvent)
{
std::cout << ea.getKey() << "+";
(*itr).second.keyFunction();
newKeyDownEvent = false;
}
return true;
}
return false;
}
case(osgGA::GUIEventAdapter::KEYUP):
{
keyFunctionMap::iterator itr = keyFuncMap.find(ea.getKey());
if (itr != keyFuncMap.end() )
{
(*itr).second.keyState = KEY_UP;
}
itr = keyUPFuncMap.find(ea.getKey());
if (itr != keyUPFuncMap.end())
{
(*itr).second.keyFunction();
return true;
}
return false;
}
default:
return false;
}
}
bool OpenVREventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& ad)
{
switch (ea.getEventType())
{
case osgGA::GUIEventAdapter::KEYUP:
{
switch (ea.getKey())
{
case osgGA::GUIEventAdapter::KEY_R:
m_openvrDevice->resetSensorOrientation();
break;
}
}
}
return osgGA::GUIEventHandler::handle(ea, ad);
}
void OscSendingDevice::sendEvent(const osgGA::GUIEventAdapter &ea)
{
static osc::int64 msg_id(0);
bool msg_sent(false);
unsigned int num_messages = _numMessagesPerEvent;
if((ea.getEventType() == osgGA::GUIEventAdapter::DRAG) || (ea.getEventType() == osgGA::GUIEventAdapter::MOVE))
num_messages = 1;
for(unsigned int i = 0; i < num_messages; ++i) {
msg_sent = sendEventImpl(ea, msg_id);
if ((_delayBetweenSendsInMilliSecs > 0) && (i < num_messages-1))
OpenThreads::Thread::microSleep(1000 * _delayBetweenSendsInMilliSecs);
}
if (msg_sent)
msg_id++;
}
// handle keydown events
virtual bool handle(const osgGA::GUIEventAdapter& ea,
osgGA::GUIActionAdapter&)
{
if (ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN) {
switch (ea.getKey()) {
case 's':
{
osg::Sequence::SequenceMode mode = _seq->getMode();
if (mode == osg::Sequence::STOP) {
mode = osg::Sequence::START;
std::cerr << "Start" << std::endl;
}
else if (mode == osg::Sequence::PAUSE) {
mode = osg::Sequence::RESUME;
std::cerr << "Resume" << std::endl;
}
else {
mode = osg::Sequence::PAUSE;
std::cerr << "Pause" << std::endl;
}
_seq->setMode(mode);
}
break;
case 'l':
{
osg::Sequence::LoopMode mode;
int begin, end;
_seq->getInterval(mode, begin, end);
if (mode == osg::Sequence::LOOP) {
mode = osg::Sequence::SWING;
std::cerr << "Swing" << std::endl;
}
else {
mode = osg::Sequence::LOOP;
std::cerr << "Loop" << std::endl;
}
_seq->setInterval(mode, begin, end);
}
break;
default:
break;
}
}
return false;
}