virtual void keyPressed(const KeyEventUnrecPtr e)
 {
     if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
     {
         TutorialWindow->closeWindow();
     }
 }
    virtual void keyTyped(const KeyEventUnrecPtr e)
    {	// changes the sequence ordering
        if (e->getKey() == KeyEvent::KEY_1)
		{
			AgeFunc->setSequenceOrder(AgeParticleFunction::CYCLE);
		}		
		else if (e->getKey() == KeyEvent::KEY_2)
		{
			AgeFunc->setSequenceOrder(AgeParticleFunction::REVERSE_CYCLE);
		}
		else if (e->getKey() == KeyEvent::KEY_3)
		{
			AgeFunc->setSequenceOrder(AgeParticleFunction::CUSTOM);
		}
		else return;
    }
    virtual void keyTyped(const KeyEventUnrecPtr e)
    {
        if(e->getKey()== KeyEvent::KEY_1) // Use the Point Drawer
        {

        }

    }
void GenericFieldEditor::TextFieldListener::keyTyped       (const KeyEventUnrecPtr    e)
{
    if(e->getKey() == KeyEvent::KEY_ESCAPE)
    {
        _GenericFieldEditor->cancelEditing();
        _GenericFieldEditor->startEditing();
    }
}
示例#5
0
void Slider::KnobDraggedListener::keyTyped(const KeyEventUnrecPtr e)
{
	if(e->getKey() == KeyEvent::KEY_ESCAPE)
	{
		_Slider->setValue(_InitialValue);
        disconnect();
	}
}
   virtual void keyPressed(const KeyEventUnrecPtr e)
   {
	   //Exit
       if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_CONTROL)
       {
           TutorialWindow->closeWindow();
       }

	   //Toggle animation
	   if(e->getKey() == KeyEvent::KEY_SPACE)
	   {
		   if(animationPaused)
			   animationPaused = false;
		   else
			   animationPaused = true;
	   }
   }
    virtual void keyPressed(const KeyEventUnrecPtr e)
    {
        if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
        {
            TutorialWindow->closeWindow();
        }

        if(e->getKey() == KeyEvent::KEY_B)//generate particles when clicked
        {
            //Attach the Generator to the Particle System
            Example1ParticleSystem->pushToGenerators(ExampleBurstGenerator);

            Example2ParticleSystem->pushToGenerators(Example2BurstGenerator);


        }
    }
    virtual void keyPressed(const KeyEventUnrecPtr e)
    {
        //Exit
        if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_CONTROL)
        {
            TutorialWindow->closeWindow();
        }

        //Toggle animation
        if(e->getKey() == KeyEvent::KEY_SPACE)
        {
            if(animationPaused)
                animationPaused = false;
            else
                animationPaused = true;
        }

        //Toggle bind pose
        if(e->getKey() == KeyEvent::KEY_B)
        {
            //Toggle skeleton
            if(dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->getDrawBindPose() == false)
            {
                dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawBindPose(true);
            } 
            else
            {
                dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawBindPose(false);
            }
        }

        //Toggle current pose
        if(e->getKey() == KeyEvent::KEY_P)
        {
            //Toggle skeleton
            if(dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->getDrawPose() == false)
            {
                dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawPose(true);
            } 
            else
            {
                dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawPose(false);
            }
        }
    }
void InternalWindow::TitlebarDraggedListener::keyPressed(const KeyEventUnrecPtr e)
{
    if(e->getKey() == KeyEvent::KEY_ESCAPE)
    {
        disconnect();

        //Reset the Window to it's original Position
        _InternalWindow->setPosition(_WindowStartPosition);
    }
}
void InternalWindow::PopupMenuInteractionListener::keyPressed(const KeyEventUnrecPtr e)
{
    if(e->getKey() == KeyEvent::KEY_ESCAPE)
    {
        _InternalWindow->destroyPopupMenu();
    }
    else if(e->getKey() == KeyEvent::KEY_UP)
    {
        _InternalWindow->getMFActivePopupMenus()->front()->setSelection( _InternalWindow->getMFActivePopupMenus()->front()->getSelectionIndex() -1 );
    }
    else if(e->getKey() == KeyEvent::KEY_DOWN)
    {
        _InternalWindow->getMFActivePopupMenus()->front()->setSelection( _InternalWindow->getMFActivePopupMenus()->front()->getSelectionIndex() +1 );
    }
    else if(e->getKey() == KeyEvent::KEY_ENTER && _InternalWindow->getMFActivePopupMenus()->front()->getItem(_InternalWindow->getMFActivePopupMenus()->front()->getSelectionIndex()) != NULL)
    {
        _InternalWindow->getMFActivePopupMenus()->front()->getItem(_InternalWindow->getMFActivePopupMenus()->front()->getSelectionIndex())->activate();
        _InternalWindow->destroyPopupMenu();
    }
}
示例#11
0
 virtual void keyPressed(const KeyEventUnrecPtr e)
 {
     if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
     {
         TutorialWindow->closeWindow();
     }
     switch(e->getKey())
     {
     case KeyEvent::KEY_S:
          {
              allPhysicsBodies.push_back(buildSphere());
          }
          break;
     case KeyEvent::KEY_B:
          {
              allPhysicsBodies.push_back(buildBox());
          }
          break;
     case KeyEvent::KEY_E:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 1280.0f);
         break;
     case KeyEvent::KEY_1:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 20.0f);
         break;
     case KeyEvent::KEY_2:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 80.0f);
         break;
     case KeyEvent::KEY_3:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 320.0f);
         break;
     case KeyEvent::KEY_4:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 1280.0f);
         break;
     case KeyEvent::KEY_5:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 5120.0f);
         break;
     case KeyEvent::KEY_6:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 20480.0f);
         break;
     }
 }
    virtual void keyTyped(const KeyEventUnrecPtr e)
    {
        if(e->getKey()== KeyEvent::KEY_1) // Use the Point Drawer
        {
            ParticleNodeCore->setDrawer(ExamplePointParticleSystemDrawer);
        }

        if(e->getKey()== KeyEvent::KEY_2)//Use the Line Drawer for 2
        {
            ParticleNodeCore->setDrawer(ExampleLineParticleSystemDrawer);
        }

        if(e->getKey()== KeyEvent::KEY_3)//Use the Quad Drawer for 3
        {
            ParticleNodeCore->setDrawer(ExampleQuadParticleSystemDrawer);
        }
        if(e->getKey() == KeyEvent::KEY_F) //particles will be sorted from closest to the view point to the furthest
        {
            ParticleNodeCore->setSortingMode(ParticleSystemCore::FRONT_TO_BACK);
        }
        if(e->getKey() == KeyEvent::KEY_R) //particles will be sorted from furthest to the view point to the closest.
        {
            ParticleNodeCore->setSortingMode(ParticleSystemCore::BACK_TO_FRONT);
        }
        if(e->getKey() == KeyEvent::KEY_N) //particles will not be sorted
        {
            ParticleNodeCore->setSortingMode(ParticleSystemCore::NONE);
        }
    }
    virtual void keyTyped(const KeyEventUnrecPtr e)
    {
        UInt32 CHANGE_SOURCE;
        if(e->getKey()== KeyEvent::KEY_P)
        {

            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_POSITION_CHANGE;
        }

        else if(e->getKey()== KeyEvent::KEY_C)
        {
            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_VELOCITY_CHANGE;
        }

        else if(e->getKey()== KeyEvent::KEY_V)
        {
            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_VELOCITY;
        }

        else if(e->getKey()== KeyEvent::KEY_A)
        {
            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_ACCELERATION;
        }

        else  if(e->getKey()== KeyEvent::KEY_N)
        {
            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_PARTICLE_NORMAL;
        }

        else if(e->getKey()== KeyEvent::KEY_D)
        {
            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_VIEW_POSITION;
        }

        else if(e->getKey()== KeyEvent::KEY_S)
        {
            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_STATIC;
        }

        else  if(e->getKey()== KeyEvent::KEY_W)
        {
            CHANGE_SOURCE = QuadParticleSystemDrawer::NORMAL_VIEW_DIRECTION;
        }
        else {
            return;
        }
        ExampleParticleSystemDrawer->setNormalSource(CHANGE_SOURCE);

    }
   virtual void keyPressed(const KeyEventUnrecPtr e)
   {
       if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_CONTROL)
       {
           TutorialWindow->closeWindow();
       }
       switch(e->getKey())
       {
       case KeyEvent::KEY_B:
           buildBox(Vec3f(10.0,10.0,10.0), Pnt3f((Real32)(rand()%100)-50.0,(Real32)(rand()%100)-50.0,25.0));
           break;
	   case KeyEvent::KEY_UP:
           _IsUpKeyDown = true;
		   break;
	   case KeyEvent::KEY_DOWN:
           _IsDownKeyDown = true;
		   break;
	   case KeyEvent::KEY_LEFT:
           _IsLeftKeyDown = true;
		   break;
	   case KeyEvent::KEY_RIGHT:
           _IsRightKeyDown = true;
           break;
       case KeyEvent::KEY_D:
            {
                if(PhysDrawableNode->getTravMask())
                {
                    PhysDrawableNode->setTravMask(TypeTraits<UInt32>::getMin());
                }
                else
                {
                    PhysDrawableNode->setTravMask(TypeTraits<UInt32>::getMax());
                }
            }
            break;
       }
   }
示例#15
0
 virtual void keyPressed(const KeyEventUnrecPtr e)
 {
     if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
     {
         TutorialWindow->closeWindow();
     }
     switch(e->getKey())
     {
         case KeyEvent::KEY_S:
             {
                 buildSphere();
             }
             break;
         case KeyEvent::KEY_B:
             {
                 buildBox();
             }
             break;
         case KeyEvent::KEY_T:
             {
                 buildTriMesh();
             }
             break;
         case KeyEvent::KEY_D:
             {
                 if(PhysDrawableNode->getTravMask())
                 {
                     PhysDrawableNode->setTravMask(TypeTraits<UInt32>::getMin());
                 }
                 else
                 {
                     PhysDrawableNode->setTravMask(TypeTraits<UInt32>::getMax());
                 }
             }
             break;
     }
 }
    virtual void keyPressed(const KeyEventUnrecPtr e)
    {
        if(e->getKey()== KeyEvent::KEY_1) // Use the Point Drawer
        {
            ParticleNodeCore->setDrawer(ExamplePointParticleSystemDrawer);
        }

        if(e->getKey()== KeyEvent::KEY_2)//Use the Line Drawer for 2
        {
            ParticleNodeCore->setDrawer(ExampleLineParticleSystemDrawer);
        }
        if(e->getKey()== KeyEvent::KEY_R)
        {   // reverse the magnitude of the field
            ExampleUniformAffector->setMagnitude(-(ExampleUniformAffector->getMagnitude()));


        }

        // change direction of the field
        if(e->getKey()== KeyEvent::KEY_A)
        {
            ExampleUniformAffector->setDirection(Vec3f(-1.0,0.0,0.0));

        }
        if(e->getKey()== KeyEvent::KEY_W)
        {
            ExampleUniformAffector->setDirection(Vec3f(0.0,1.0,0.0));

        }
        if(e->getKey()== KeyEvent::KEY_S)
        {
            ExampleUniformAffector->setDirection(Vec3f(0.0,-1.0,0.0));

        }
        if(e->getKey()== KeyEvent::KEY_D)
        {
            ExampleUniformAffector->setDirection(Vec3f(1.0,0.0,0.0));

        }
        if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
        {
            TutorialWindow->closeWindow();
        }
    }
   virtual void keyReleased(const KeyEventUnrecPtr e)
   {
	   switch(e->getKey())
	   {
	   case KeyEvent::KEY_UP:
           _IsUpKeyDown = false;
		   break;
	   case KeyEvent::KEY_DOWN:
           _IsDownKeyDown = false;
		   break;
	   case KeyEvent::KEY_LEFT:
           _IsLeftKeyDown = false;
		   break;
	   case KeyEvent::KEY_RIGHT:
           _IsRightKeyDown = false;
           break;
       }
   }
    virtual void keyTyped(const KeyEventUnrecPtr e)
    {
        switch(e->getKey())
        {
            case KeyEvent::KEY_1: // Use the Point Drawer
                ParticleNodeCore->setDrawer(ExamplePointParticleSystemDrawer);
                break;

            case KeyEvent::KEY_2://Use the Line Drawer for 2
                ParticleNodeCore->setDrawer(ExampleLineParticleSystemDrawer);
                break;

            case KeyEvent::KEY_3://Use the Quad Drawer for 3
                ParticleNodeCore->setDrawer(ExampleQuadParticleSystemDrawer);
                break;
            case KeyEvent::KEY_4://Use the Disc Drawer for 4
                ParticleNodeCore->setDrawer(ExampleDiscParticleSystemDrawer);
                break;
            case KeyEvent::KEY_S://Toggle the statistics
                StatisticsOn = !StatisticsOn;
                mgr->setStatistics(StatisticsOn);
                break;
        }
    }
void EditableTextComponent::keyTyped(const KeyEventUnrecPtr e)
{
	
    if(getEnabled() && getEditable() && !(e->getModifiers() &( KeyEvent::KEY_MODIFIER_ALT | KeyEvent::KEY_MODIFIER_CONTROL | KeyEvent::KEY_MODIFIER_META )))
	{
		if(e->getKeyChar()>31 && e->getKeyChar() < 127)
		{
			if(hasSelection())
			{
                deleteSelectedText();
				setCaretPosition(_TextSelectionStart);
			}
            insert(std::string( 1,e->getKeyChar() ), _TextSelectionStart);
			_TextSelectionStart = getCaretPosition();
			_TextSelectionEnd = _TextSelectionStart;
		}
		if(e->getKey()== e->KEY_BACK_SPACE)
		{
			if(hasSelection())
			{
                deleteSelectedText();
			}
			else
			{	
                //erase at the current caret position
                Int32 DeleteIndex(getCaretPosition());
                if(DeleteIndex != 0)
                {
                    moveCaret(-1);
                    deleteRange(DeleteIndex-1, DeleteIndex);
                }
			}
		}
		if(e->getKey()== e->KEY_DELETE)
		{
			if(hasSelection())
			{
                deleteSelectedText();
			}
			else if(getText().size()>0)
			{
				//erase at the current caret position
                deleteRange(getCaretPosition(), getCaretPosition()+1);
				_TextSelectionStart = getCaretPosition();
				_TextSelectionEnd = _TextSelectionStart;
			}
		}
	}
	
    switch(e->getKey())
    {
    case KeyEvent::KEY_RIGHT:
    case KeyEvent::KEY_KEYPAD_RIGHT:
        moveCaret(1);
        break;
    case KeyEvent::KEY_LEFT:
    case KeyEvent::KEY_KEYPAD_LEFT:
        moveCaret(-1);
        break;
    case KeyEvent::KEY_V:
        if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
        {
            paste();
        }
        break;
    case KeyEvent::KEY_C:
        if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
        {
            copy();
        }
        break;
    case KeyEvent::KEY_X:
        if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
        {
            cut();
        }
        break;
    case KeyEvent::KEY_A:
        if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
        {
            selectAll();
        }
        break;
    }

	Inherited::keyTyped(e);
}
void InternalWindow::keyPressed(const KeyEventUnrecPtr e)
{
    if(!getLockInput())
    {
        //Check for Accelerator Keys
        UInt32 RelevantModifiers = (e->getModifiers() & KeyEvent::KEY_MODIFIER_ALT) |
            (e->getModifiers() & KeyEvent::KEY_MODIFIER_CONTROL) |
            (e->getModifiers() & KeyEvent::KEY_MODIFIER_SHIFT) |
            (e->getModifiers() & KeyEvent::KEY_MODIFIER_META);
        KeyAcceleratorMapItor MapItor = _KeyAcceleratorMap.find(KeyEvent::getHashable(e->getKey(), RelevantModifiers));
        if(MapItor != _KeyAcceleratorMap.end())
        {
            (*MapItor).second->acceleratorTyped(KeyAcceleratorEvent::create(InternalWindowRefPtr(this), e->getTimeStamp(), e->getKey(), e->getModifiers()));
        }
        //Send Key event to Component that has Focus
        //If there is not Focused Component then do nothing
        if(getFocusedComponent() != NULL &&
           getFocusedComponent() != this)
        {
            getFocusedComponent()->keyPressed(e);
            ComponentContainerRefPtr ParentContainer(getFocusedComponent()->getParentContainer());
            while(ParentContainer != NULL &&
                  ParentContainer != this)
            {
                ParentContainer->keyPressed(e);
                ParentContainer = dynamic_cast<ComponentContainer*>(ParentContainer->getParentContainer());
            }
        }
        Component::keyPressed(e);
    }
}
 virtual void keyPressed(const KeyEventUnrecPtr e)
 {
     if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_CONTROL)
     {
         TutorialWindow->closeWindow();
     }
     else
     {
         switch(e->getKey())
         {
             case KeyEvent::KEY_B:
                 {	// check if the burst generator is null
                     if(ExampleBurstGen == NULL)
                     {
                         ExampleBurstGen = OSG::BurstParticleGenerator::create();
                         ExampleBurstGen->setPositionDistribution(createPositionDistribution());
                         ExampleBurstGen->setBurstAmount(20);
                         ExampleBurstGen->setVelocityDistribution(createVelocityDistribution());
                         ExampleBurstGen->setNormalDistribution(createNormalDistribution());
                         ExampleBurstGen->setLifespanDistribution(createLifespanDistribution());
                         ExampleBurstGen->setSizeDistribution(createSizeDistribution());
                     }
                     // attach the burst generator
                     ExampleParticleSystem->pushToGenerators(ExampleBurstGen);
                 }
                 break;
             case KeyEvent::KEY_P:
                 {	// increase trail resolution
                     ExampleTrailGenerator->setTrailResolution(ExampleTrailGenerator->getTrailResolution() * 0.70 + 0.0001);
                     std::cout << "Trail Resolution:  " << ExampleTrailGenerator->getTrailResolution() << std::endl;
                     break;
                 }
             case KeyEvent::KEY_L:
                 {	// decrease trail resolution
                     ExampleTrailGenerator->setTrailResolution(ExampleTrailGenerator->getTrailResolution() * 1.25);
                     std::cout << "Trail Resolution:  " << ExampleTrailGenerator->getTrailResolution() << std::endl;
                     break;
                 }
             case KeyEvent::KEY_O:
                 {	// increase trail length
                     ExampleTrailGenerator->setTrailLength(ExampleTrailGenerator->getTrailLength() * 1.25 + 0.1);
                     std::cout << "Trail Length:  " << ExampleTrailGenerator->getTrailLength() << std::endl;
                     break;
                 }
             case KeyEvent::KEY_K:
                 {	// decrease trail length
                     ExampleTrailGenerator->setTrailLength(ExampleTrailGenerator->getTrailLength() * 0.7);
                     std::cout << "Trail Length:  " << ExampleTrailGenerator->getTrailLength() << std::endl;
                     break;
                 }
             case KeyEvent::KEY_I:
                 {	// toggle lines/points as trail draw method
                     ExampleTrailGenerator->setDrawMethod((ExampleTrailGenerator->getDrawMethod() == SimpleParticleTrailGenerator::LINES)?
                                                          (SimpleParticleTrailGenerator::POINTS):(SimpleParticleTrailGenerator::LINES));
                     break;
                 }
             case KeyEvent::KEY_J:
                 {	// toggle trail length method
                     ExampleTrailGenerator->setTrailLengthMethod((ExampleTrailGenerator->getTrailLengthMethod() == ParticleTrailGenerator::NUM_POINTS)?
                                                                 (ParticleTrailGenerator::TIME):(ParticleTrailGenerator::NUM_POINTS));
                     std::cout << "Trail Length: " << (ExampleTrailGenerator->getTrailLengthMethod() == ParticleTrailGenerator::NUM_POINTS ? "Num Pts":"Time") << std::endl;
                     break;
                 }
             case KeyEvent::KEY_Y:
                 {	// toggle trail spacing method
                     ExampleTrailGenerator->setTrailResolutionMethod((ExampleTrailGenerator->getTrailResolutionMethod() == ParticleTrailGenerator::TIME_SPACING)?
                                                                     (ParticleTrailGenerator::DISTANCE_SPACING):(ParticleTrailGenerator::TIME_SPACING));
                     std::cout << "Trail resolution: " <<(ExampleTrailGenerator->getTrailResolutionMethod() == ParticleTrailGenerator::TIME_SPACING ? "Time Spacing" : "Distance Spacing") << std::endl;
                     break;
                 }
             case KeyEvent::KEY_V:
                 {
                     mgr->getRenderAction()->setVolumeDrawing(!mgr->getRenderAction()->getVolumeDrawing());
                 }
         }
     }
 }
示例#22
0
    virtual void keyPressed(const KeyEventUnrecPtr e)
    {
        //Exit
        if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
        {
            TutorialWindow->closeWindow();
        }

        //Toggle animation
        if(e->getKey() == KeyEvent::KEY_SPACE)
        {
            if(animationPaused)
                animationPaused = false;
            else
                animationPaused = true;
        }

        //Toggle bind pose
        if(e->getKey() == KeyEvent::KEY_B)
        {
            if(e->getModifiers() & KeyEvent::KEY_MODIFIER_SHIFT)
            {
                //Toggle mesh
                if(UnboundGeometry->getTravMask() == 0)
                {
                    UnboundGeometry->setTravMask(1);
                } 
                else
                {
                    UnboundGeometry->setTravMask(0);
                }
            }
            else
            {
                //Toggle skeleton
                if(dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->getDrawBindPose() == false)
                {
                    dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawBindPose(true);
                } 
                else
                {
                    dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawBindPose(false);
                }
            }
        }

        //Toggle current pose
        if(e->getKey() == KeyEvent::KEY_P)
        {
            if(e->getModifiers() & KeyEvent::KEY_MODIFIER_SHIFT)
            {
                //Toggle mesh
                if(MeshNode->getTravMask() == 0)
                {
                    MeshNode->setTravMask(1);
                } 
                else
                {
                    MeshNode->setTravMask(0);
                }
            }
            else
            {
                //Toggle skeleton
                if(dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->getDrawPose() == false)
                {
                    dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawPose(true);
                } 
                else
                {
                    dynamic_cast<SkeletonDrawable*>(SkeletonNode->getCore())->setDrawPose(false);
                }
            }
        }
    }