Example #1
0
void MouseNavigationTool::buttonCallback(int buttonSlotIndex,InputDevice::ButtonCallbackData* cbData)
	{
	/* Process based on which button was pressed: */
	switch(buttonSlotIndex)
		{
		case 0:
			if(cbData->newButtonState) // Button has just been pressed
				{
				/* Act depending on this tool's current state: */
				switch(navigationMode)
					{
					case IDLE:
					case SPINNING:
						if(factory->interactWithWidgets)
							{
							/* Check if the GUI interactor accepts the event: */
							GUIInteractor::updateRay();
							if(GUIInteractor::buttonDown(false))
								{
								/* Deactivate this tool if it is spinning: */
								if(navigationMode==SPINNING)
									deactivate();
								
								/* Go to widget interaction mode: */
								navigationMode=WIDGETING;
								}
							else
								{
								/* Try activating this tool: */
								if(navigationMode==SPINNING||activate())
									startRotating();
								}
							}
						else
							{
							/* Try activating this tool: */
							if(navigationMode==SPINNING||activate())
								startRotating();
							}
						break;
					
					case PANNING:
						if(dolly)
							startDollying();
						else
							startScaling();
						break;
					
					default:
						/* This shouldn't happen; just ignore the event */
						break;
					}
				}
			else // Button has just been released
				{
				/* Act depending on this tool's current state: */
				switch(navigationMode)
					{
					case WIDGETING:
						{
						if(GUIInteractor::isActive())
							{
							/* Deliver the event: */
							GUIInteractor::buttonUp();
							}
						
						/* Deactivate this tool: */
						navigationMode=IDLE;
						break;
						}
					
					case ROTATING:
						{
						/* Check if the input device is still moving: */
						Point currentPos=calcScreenPos();
						Vector delta=currentPos-lastRotationPos;
						if(Geometry::mag(delta)>factory->spinThreshold)
							{
							/* Calculate spinning angular velocity: */
							Vector offset=(lastRotationPos-screenCenter)+rotateOffset;
							Vector axis=Geometry::cross(offset,delta);
							Scalar angularVelocity=Geometry::mag(delta)/(factory->rotateFactor*(getApplicationTime()-lastMoveTime));
							spinAngularVelocity=axis*(Scalar(0.5)*angularVelocity/axis.mag());
							
							/* Go to spinning mode: */
							navigationMode=SPINNING;
							}
						else
							{
							/* Deactivate this tool: */
							deactivate();
							
							/* Go to idle mode: */
							navigationMode=IDLE;
							}
						break;
						}
					
					case DOLLYING:
					case SCALING:
						startPanning();
						break;
					
					default:
						/* This shouldn't happen; just ignore the event */
						break;
					}
				}
			break;
		
		case 1:
			if(cbData->newButtonState) // Button has just been pressed
				{
				/* Act depending on this tool's current state: */
				switch(navigationMode)
					{
					case IDLE:
					case SPINNING:
						/* Try activating this tool: */
						if(navigationMode==SPINNING||activate())
							startPanning();
						break;
					
					case ROTATING:
						if(dolly)
							startDollying();
						else
							startScaling();
						break;
					
					default:
						/* This shouldn't happen; just ignore the event */
						break;
					}
				}
			else // Button has just been released
				{
				/* Act depending on this tool's current state: */
				switch(navigationMode)
					{
					case PANNING:
						/* Deactivate this tool: */
						deactivate();
						
						/* Go to idle mode: */
						navigationMode=IDLE;
						break;
					
					case DOLLYING:
					case SCALING:
						startRotating();
						break;
					
					default:
						/* This shouldn't happen; just ignore the event */
						break;
					}
				}
			break;
		
		case 2:
			/* Set the dolly flag: */
			dolly=cbData->newButtonState;
			if(factory->invertDolly)
				dolly=!dolly;
			if(dolly) // Dollying has just been enabled
				{
				/* Act depending on this tool's current state: */
				switch(navigationMode)
					{
					case SCALING:
						startDollying();
						break;
					
					default:
						/* Nothing to do */
						break;
					}
				}
			else
				{
				/* Act depending on this tool's current state: */
				switch(navigationMode)
					{
					case DOLLYING:
						startScaling();
						break;
					
					default:
						/* Nothing to do */
						break;
					}
				}
			break;
		}
	}
Example #2
0
void MouseNavigationTool::buttonCallback(int,int buttonIndex,InputDevice::ButtonCallbackData* cbData)
{
    /* Process based on which button was pressed: */
    switch(buttonIndex)
    {
    case 0:
        if(cbData->newButtonState) // Button has just been pressed
        {
            /* Act depending on this tool's current state: */
            switch(navigationMode)
            {
            case IDLE:
            case SPINNING:
                if(factory->interactWithWidgets)
                {
                    /* Check if the mouse pointer is over a GLMotif widget: */
                    GLMotif::Event event(false);
                    event.setWorldLocation(calcSelectionRay());
                    if(getWidgetManager()->pointerButtonDown(event))
                    {
                        if(navigationMode==SPINNING)
                        {
                            /* Deactivate this tool: */
                            deactivate();
                        }

                        /* Go to widget interaction mode: */
                        navigationMode=WIDGETING;

                        /* Drag the entire root widget if the event's target widget is a title bar: */
                        if(dynamic_cast<GLMotif::TitleBar*>(event.getTargetWidget())!=0)
                        {
                            /* Start dragging: */
                            draggedWidget=event.getTargetWidget();

                            /* Calculate the dragging transformation: */
                            NavTrackerState initialTracker=NavTrackerState::translateFromOriginTo(calcScreenPos());
                            preScale=Geometry::invert(initialTracker);
                            GLMotif::WidgetManager::Transformation initialWidget=getWidgetManager()->calcWidgetTransformation(draggedWidget);
                            preScale*=NavTrackerState(initialWidget);
                        }
                        else
                            draggedWidget=0;
                    }
                    else
                    {
                        /* Try activating this tool: */
                        if(navigationMode==SPINNING||activate())
                            startRotating();
                    }
                }
                else
                {
                    /* Try activating this tool: */
                    if(navigationMode==SPINNING||activate())
                        startRotating();
                }
                break;

            case PANNING:
                if(dolly)
                    startDollying();
                else
                    startScaling();
                break;

            default:
                /* This shouldn't happen; just ignore the event */
                break;
            }
        }
        else // Button has just been released
        {
            /* Act depending on this tool's current state: */
            switch(navigationMode)
            {
            case WIDGETING:
            {
                /* Deliver the event: */
                GLMotif::Event event(true);
                event.setWorldLocation(calcSelectionRay());
                getWidgetManager()->pointerButtonUp(event);

                /* Deactivate this tool: */
                navigationMode=IDLE;
                draggedWidget=0;
                break;
            }

            case ROTATING:
            {
                /* Check if the input device is still moving: */
                Point currentPos=calcScreenPos();
                Vector delta=currentPos-lastRotationPos;
                if(Geometry::mag(delta)>factory->spinThreshold)
                {
                    /* Calculate spinning angular velocity: */
                    Vector offset=(lastRotationPos-screenCenter)+rotateOffset;
                    Vector axis=Geometry::cross(offset,delta);
                    Scalar angularVelocity=Geometry::mag(delta)/(factory->rotateFactor*getCurrentFrameTime());
                    spinAngularVelocity=axis*(Scalar(0.5)*angularVelocity/axis.mag());

                    /* Go to spinning mode: */
                    navigationMode=SPINNING;
                }
                else
                {
                    /* Deactivate this tool: */
                    deactivate();

                    /* Go to idle mode: */
                    navigationMode=IDLE;
                }
                break;
            }

            case DOLLYING:
            case SCALING:
                startPanning();
                break;

            default:
                /* This shouldn't happen; just ignore the event */
                break;
            }
        }
        break;

    case 1:
        if(cbData->newButtonState) // Button has just been pressed
        {
            /* Act depending on this tool's current state: */
            switch(navigationMode)
            {
            case IDLE:
            case SPINNING:
                /* Try activating this tool: */
                if(navigationMode==SPINNING||activate())
                    startPanning();
                break;

            case ROTATING:
                if(dolly)
                    startDollying();
                else
                    startScaling();
                break;

            default:
                /* This shouldn't happen; just ignore the event */
                break;
            }
        }
        else // Button has just been released
        {
            /* Act depending on this tool's current state: */
            switch(navigationMode)
            {
            case PANNING:
                /* Deactivate this tool: */
                deactivate();

                /* Go to idle mode: */
                navigationMode=IDLE;
                break;

            case DOLLYING:
            case SCALING:
                startRotating();
                break;

            default:
                /* This shouldn't happen; just ignore the event */
                break;
            }
        }
        break;

    case 2:
        /* Set the dolly flag: */
        dolly=cbData->newButtonState;
        if(factory->invertDolly)
            dolly=!dolly;
        if(dolly) // Dollying has just been enabled
        {
            /* Act depending on this tool's current state: */
            switch(navigationMode)
            {
            case SCALING:
                startDollying();
                break;

            default:
                /* Nothing to do */
                break;
            }
        }
        else
        {
            /* Act depending on this tool's current state: */
            switch(navigationMode)
            {
            case DOLLYING:
                startScaling();
                break;

            default:
                /* Nothing to do */
                break;
            }
        }
        break;
    }
}
void MouseDialogNavigationTool::buttonCallback(int,InputDevice::ButtonCallbackData* cbData)
	{
	if(cbData->newButtonState) // Button has just been pressed
		{
		bool takeEvent=true;
		if(factory->interactWithWidgets)
			{
			/* Check if the GUI interactor accepts the event: */
			GUIInteractor::updateRay();
			if(GUIInteractor::buttonDown(false))
				{
				/* Deactivate this tool if it is spinning: */
				if(spinning)
					deactivate();
				spinning=false;
				
				/* Disable navigation: */
				takeEvent=false;
				}
			}
		
		if(takeEvent)
			{
			/* Deactivate spinning: */
			spinning=false;
			
			/* Start navigating according to the current navigation mode: */
			switch(navigationMode)
				{
				case ROTATING:
					if(activate())
						startRotating();
					break;
				
				case PANNING:
					if(activate())
						startPanning();
					break;
				
				case DOLLYING:
					if(activate())
						startDollying();
					break;
				
				case SCALING:
					if(activate())
						startScaling();
					break;
				}
			}
		}
	else // Button has just been released
		{
		if(GUIInteractor::isActive())
			{
			/* Deliver the event: */
			GUIInteractor::buttonUp();
			}
		else
			{
			/* Check for spinning if currently in rotating mode: */
			if(navigationMode==ROTATING)
				{
				/* Check if the input device is still moving: */
				Point currentPos=calcScreenPos();
				Vector delta=currentPos-lastRotationPos;
				if(Geometry::mag(delta)>factory->spinThreshold)
					{
					/* Calculate spinning angular velocity: */
					Vector offset=(lastRotationPos-screenCenter)+rotateOffset;
					Vector axis=Geometry::cross(offset,delta);
					Scalar angularVelocity=Geometry::mag(delta)/(factory->rotateFactor*(getApplicationTime()-lastMoveTime));
					spinAngularVelocity=axis*(Scalar(0.5)*angularVelocity/axis.mag());
					
					/* Enable spinning: */
					spinning=true;
					}
				else
					{
					/* Deactivate the tool: */
					deactivate();
					}
				}
			else
				{
				/* Deactivate the tool: */
				deactivate();
				}
			}
		}
	}
void MouseDialogNavigationTool::buttonCallback(int,int buttonIndex,InputDevice::ButtonCallbackData* cbData)
	{
	if(cbData->newButtonState) // Button has just been pressed
		{
		/* Deactivate spinning: */
		spinning=false;
		
		/* Start navigating according to the current navigation mode: */
		switch(navigationMode)
			{
			case ROTATING:
				if(activate())
					startRotating();
				break;
			
			case PANNING:
				if(activate())
					startPanning();
				break;
			
			case DOLLYING:
				if(activate())
					startDollying();
				break;
			
			case SCALING:
				if(activate())
					startScaling();
				break;
			}
		}
	else // Button has just been released
		{
		/* Check for spinning if currently in rotating mode: */
		if(navigationMode==ROTATING)
			{
			/* Check if the input device is still moving: */
			Point currentPos=calcScreenPos();
			Vector delta=currentPos-lastRotationPos;
			if(Geometry::mag(delta)>factory->spinThreshold)
				{
				/* Calculate spinning angular velocity: */
				Vector offset=(lastRotationPos-screenCenter)+rotateOffset;
				Vector axis=Geometry::cross(offset,delta);
				Scalar angularVelocity=Geometry::mag(delta)/(factory->rotateFactor*getFrameTime());
				spinAngularVelocity=axis*(Scalar(0.5)*angularVelocity/axis.mag());
				
				/* Enable spinning: */
				spinning=true;
				}
			else
				{
				/* Deactivate the tool: */
				deactivate();
				}
			}
		else
			{
			/* Deactivate the tool: */
			deactivate();
			}
		}
	}