Пример #1
0
bool Config::handleEvent( eq::EventICommand command )
{
    switch( command.getEventType( ))
    {
        case DATA_CHANGED:
        {
            _registerData( command );
            if( _readyToCommit() )
                _frameData.commit();    // broadcast changed data to all clients
            return false;
        }

        case PROXY_CHANGED:
        {
            _updateData( command );
            if( _readyToCommit() )
            {
                _updateSimulation();    // update the simulation every nth frame
                _frameData.commit();    // broadcast changed data to all clients
            }
            return false;
        }

        case eq::Event::KEY_PRESS:
        {
            const eq::Event& event = command.get< eq::Event >();
            if( _handleKeyEvent( event.keyPress ))
            {
                _redraw = true;
                return true;
            }
            break;
        }

        case eq::Event::WINDOW_EXPOSE:
        case eq::Event::WINDOW_RESIZE:
        case eq::Event::WINDOW_CLOSE:
        case eq::Event::VIEW_RESIZE:
            _redraw = true;
            break;

        default:
            break;
    }

    _redraw |= eq::Config::handleEvent( command );
    return _redraw;
}
Пример #2
0
bool Config::handleEvent( const eq::ConfigEvent* event )
{               
    switch( event->data.type )
    {
      case ConfigEvent::DATA_CHANGED:
          _registerData(static_cast< const ConfigEvent* >( event ));
          if( _readyToCommit() ) {
              _frameData.commit();        // broadcast changed data to all clients
          }
          break;

      case ConfigEvent::PROXY_CHANGED:
      {
          _updateData(static_cast< const ConfigEvent* >( event ));
          if( _readyToCommit() ) {
              _updateSimulation();    // update the simulation every nth frame
              _frameData.commit();    // broadcast changed data to all clients
          }
      }
      break;
                
      case eq::Event::KEY_PRESS:
          if( _handleKeyEvent( event->data.keyPress ))
          {
              _redraw = true;
              return true;
          }
          break;
                                
      case eq::Event::WINDOW_EXPOSE:
      case eq::Event::WINDOW_RESIZE:
      case eq::Event::WINDOW_CLOSE:
      case eq::Event::VIEW_RESIZE:
          _redraw = true;
          break;
                
      default:
          break;
    }
        
    _redraw |= eq::Config::handleEvent( event );
    return _redraw;
}
Пример #3
0
bool Config::handleEvent( eq::EventICommand command )
{
    switch( command.getEventType( ))
    {
        case eq::Event::KEY_PRESS:
        {
            const eq::Event& event = command.get< eq::Event >();
            if( _handleKeyEvent( event.keyPress ))
            {
                _redraw = true;
                return true;
            }
            break;
        }

        case eq::Event::CHANNEL_POINTER_BUTTON_PRESS:
        {
            const eq::Event& event = command.get< eq::Event >();
            const eq::uint128_t& viewID = event.context.view.identifier;
            _frameData.setCurrentViewID( viewID );
            if( viewID == 0 )
            {
                _currentCanvas = 0;
                return false;
            }

            const View* view = _getCurrentView();
            const eq::Layout* layout = view->getLayout();
            const eq::Canvases& canvases = getCanvases();
            for( eq::CanvasesCIter i = canvases.begin();
                 i != canvases.end(); ++i )
            {
                eq::Canvas* canvas = *i;
                const eq::Layout* canvasLayout = canvas->getActiveLayout();

                if( canvasLayout == layout )
                {
                    _currentCanvas = canvas;
                    return true;
                }
            }
            return true;
        }

        case eq::Event::CHANNEL_POINTER_BUTTON_RELEASE:
        {
            const eq::Event& event = command.get< eq::Event >();
            const eq::PointerEvent& releaseEvent =
                event.pointerButtonRelease;
            if( releaseEvent.buttons == eq::PTR_BUTTON_NONE)
            {
                if( releaseEvent.button == eq::PTR_BUTTON1 )
                {
                    _spinX = releaseEvent.dy;
                    _spinY = releaseEvent.dx;
                    _redraw = true;
                    return true;
                }
                if( releaseEvent.button == eq::PTR_BUTTON2 )
                {
                    _advance = -releaseEvent.dy;
                    _redraw = true;
                    return true;
                }
            }
            break;
        }
        case eq::Event::CHANNEL_POINTER_MOTION:
        {
            const eq::Event& event = command.get< eq::Event >();
            switch( event.pointerMotion.buttons )
            {
              case eq::PTR_BUTTON1:
                  _spinX = 0;
                  _spinY = 0;

                  if( _frameData.usePilotMode())
                      _frameData.spinCamera(
                          -0.005f * event.pointerMotion.dy,
                          -0.005f * event.pointerMotion.dx );
                  else
                      _frameData.spinModel(
                          -0.005f * event.pointerMotion.dy,
                          -0.005f * event.pointerMotion.dx, 0.f );
                  _redraw = true;
                  return true;

              case eq::PTR_BUTTON2:
                  _advance = -event.pointerMotion.dy;
                  _frameData.moveCamera( 0.f, 0.f, .005f * _advance );
                  _redraw = true;
                  return true;

              case eq::PTR_BUTTON3:
                  _frameData.moveCamera(  .0005f * event.pointerMotion.dx,
                                         -.0005f * event.pointerMotion.dy,
                                          0.f );
                  _redraw = true;
                  return true;
            }
            break;
        }

        case eq::Event::CHANNEL_POINTER_WHEEL:
        {
            const eq::Event& event = command.get< eq::Event >();
            _frameData.moveCamera( -0.05f * event.pointerWheel.yAxis,
                                   0.f,
                                   0.05f * event.pointerWheel.xAxis );
            _redraw = true;
            return true;
        }

        case eq::Event::MAGELLAN_AXIS:
        {
            const eq::Event& event = command.get< eq::Event >();
            _spinX = 0;
            _spinY = 0;
            _advance = 0;
            _frameData.spinModel( 0.0001f * event.magellan.xRotation,
                                  0.0001f * event.magellan.yRotation,
                                  0.0001f * event.magellan.zRotation );
            _frameData.moveCamera( 0.0001f * event.magellan.xAxis,
                                   0.0001f * event.magellan.yAxis,
                                   0.0001f * event.magellan.zAxis );
            _redraw = true;
            return true;
        }

        case eq::Event::MAGELLAN_BUTTON:
        {
            const eq::Event& event = command.get< eq::Event >();
            if( event.magellan.button == eq::PTR_BUTTON1 )
                _frameData.toggleColorMode();

            _redraw = true;
            return true;
        }

        case eq::Event::WINDOW_EXPOSE:
        case eq::Event::WINDOW_RESIZE:
        case eq::Event::WINDOW_CLOSE:
        case eq::Event::VIEW_RESIZE:
            _redraw = true;
            break;

        case IDLE_AA_LEFT:
            if( _useIdleAA )
            {
                const int32_t steps = command.get< int32_t >();
                _numFramesAA = LB_MAX( _numFramesAA, steps );
            }
            else
                _numFramesAA = 0;
            return false;

        default:
            break;
    }

    _redraw |= eq::Config::handleEvent( command );
    return _redraw;
}
Пример #4
0
bool Config::handleEvent( const eq::ConfigEvent* event )
{
    switch( event->data.type )
    {
        case eq::Event::KEY_PRESS:
            if( _handleKeyEvent( event->data.keyPress ))
                return true;
            break;

        case eq::Event::CHANNEL_POINTER_BUTTON_PRESS:
        {
            const co::base::UUID& viewID = event->data.context.view.identifier;
            _frameData.setCurrentViewID( viewID );
            if( viewID == co::base::UUID::ZERO )
            {
                _currentCanvas = 0;
                return true;
            }
            
            const eq::View* view = find< eq::View >( viewID );
            const eq::Layout* layout = view->getLayout();
            const eq::Canvases& canvases = getCanvases();
            for( eq::Canvases::const_iterator i = canvases.begin();
                 i != canvases.end(); ++i )
            {
                eq::Canvas* canvas = *i;
                const eq::Layout* canvasLayout = canvas->getActiveLayout();

                if( canvasLayout == layout )
                {
                    _currentCanvas = canvas;
                    return true;
                }
            }
            return true;
        }

        case eq::Event::CHANNEL_POINTER_BUTTON_RELEASE:
            if( event->data.pointerButtonRelease.buttons == eq::PTR_BUTTON_NONE
                && event->data.pointerButtonRelease.button  == eq::PTR_BUTTON1 )
            {
                _spinY = event->data.pointerButtonRelease.dx;
                _spinX = event->data.pointerButtonRelease.dy;
            }
            return true;

        case eq::Event::CHANNEL_POINTER_MOTION:
            if( event->data.pointerMotion.buttons == eq::PTR_BUTTON_NONE )
                return true;

            if( event->data.pointerMotion.buttons == eq::PTR_BUTTON1 )
            {
                _spinX = 0;
                _spinY = 0;

                _frameData.spinCamera(  -0.005f * event->data.pointerMotion.dy,
                                        -0.005f * event->data.pointerMotion.dx);
            }
            else if( event->data.pointerMotion.buttons == eq::PTR_BUTTON2 ||
                     event->data.pointerMotion.buttons == ( eq::PTR_BUTTON1 |
                                                       eq::PTR_BUTTON3 ))
            {
                _frameData.moveCamera( .0, .0,
                                        .005f*event->data.pointerMotion.dy);
            }
            else if( event->data.pointerMotion.buttons == eq::PTR_BUTTON3 )
            {
                _frameData.moveCamera( .0005f * event->data.pointerMotion.dx,
                                      -.0005f * event->data.pointerMotion.dy, 
                                       .0 );
            }
            return true;

        default:
            break;
    }
    return eq::Config::handleEvent( event );
}