SoInteractionCoordinator.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2008, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef SO_INTERACTION_COORDINATOR_H
#define SO_INTERACTION_COORDINATOR_H

 
#include "SoManagedInteractionSystem.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <list>
 
#include <Inventor/events/SoKeyboardEvent.h>
#include <ThirdPartyWarningsRestore.h>
 
#include "SoCommandAction.h"
#include "SoPointingAction.h"
#include "SoOffsetAction.h"
 
class SoInteractionHandler;
class SoInteractionMapper;

class SOMANAGEDINTERACTION_API SoInteractionCoordinator
{
public:
  // Constructor
  SoInteractionCoordinator();
  // Destructor
  virtual ~SoInteractionCoordinator();

  size_t getNumMappers();

  void addMapper(SoInteractionMapper* mapper);

  void clearMappers();

  void truncateMappers(size_t n = 0);
 

  virtual void setSelectedPointingAction (SoPointingAction* action, SoInteractionHandler* handler,
    const SoPointerPosition& location, bool allowed = true);

  SoPointingAction* getCurrentPointingAction() const { return _currentPointingAction; }

  SoInteractionHandler* getCurrentPointingActionHandler() const { return _currentPActionHandler; }

  bool getCurrentPointingActionAllowed() const { return _currentPointingActionAllowed; }

  void affirmSelectedPointingAction() { _pointingActionSelected = true; }

  bool isPointingActionSelected() const { return _pointingActionSelected; }

  bool maySelectPointingAction() const { return _maySelectPointingAction; }

  virtual void setLockedPointingAction (SoPointingAction* action, SoInteractionHandler* handler);

  SoPointingAction* getLockedPointingAction() { return _lockedPointingAction; }

  SoInteractionHandler* getLockedPointingActionHandler() { return _lockedPActionHandler; }

  void grabReleasedByAction (SoPointingAction* action);

  virtual bool isPointingActionActive (SoPointingAction* action, int currentMask);

  virtual int getModeModifierMask(int numModes);

  virtual int getModeFromModifiers(int numModes, int modifierMask);

  virtual bool startPress(const SoPointerPosition& position, int modifierMask);

  virtual void endPress(int clickCount);

  virtual bool isDragging() { return _isDragging; }

  bool isCancelled() const { return _cancelled; }

  void cancelDrag();

  bool wheelModifiersFitOffsetAction(SoOffsetAction* action, int modifiers,
                                     double& sensitivityX, double& sensitivityY, bool& swapAxes);
  
  void setWheelActionExecuted() { _mayExecuteWheelAction = false; }

  bool mayExecuteWheelAction() const { return _mayExecuteWheelAction; }
 

  bool keyFitsCommandAction (SoCommandAction* action, int modifiers, SoKeyboardEvent::Key nKey);

  bool keyFitsOffsetAction (SoOffsetAction* action, int modifiers, SoKeyboardEvent::Key nKey,
                            double& sensitivityX, double& sensitivityY, bool& swapAxes);

  void setKeyboardActionExecuted() { _mayExecuteKeyboardAction = false; }

  bool mayExecuteKeyboardAction() const { return _mayExecuteKeyboardAction; }

  virtual bool isDragThresholdExceeded() const { return true; }
 

  SoPointingAction::TriggerList getTriggers(SoPointingAction* action);

  SoCommandAction::ShortcutList getShortcuts(SoCommandAction* action);

  SoOffsetAction::TriggerList getTriggers(SoOffsetAction* action);
 
protected:
  virtual void setDragging(bool dragging);

  void unsetPointingActionSelected() { _pointingActionSelected = false; }
 
  // Only allow to select (new) pointing action if this is \c true.
  bool _maySelectPointingAction;
 
  // Only allow to execute keyboard actions if this is \c true.
  bool _mayExecuteKeyboardAction;
 
  // Only allow to execute wheel actions if this is \c true.
  bool _mayExecuteWheelAction;
 
private:
  static void _grabReleasedByActionCB (SoPointingAction* action, void* data);

  std::list<SoInteractionMapper*> _mappers;
 
  // Selected pointing action.
  SoPointingAction* _currentPointingAction;
  SoInteractionHandler* _currentPActionHandler;
 
  // Locked pointing action.
  SoPointingAction* _lockedPointingAction;
  SoInteractionHandler* _lockedPActionHandler;
 
  // Is the controller enabled?
  bool _enabled;
 
  // This might be set to \c true during traversal.
  bool _pointingActionSelected;
 
  // This may be \c false for locked actions.
  bool _currentPointingActionAllowed;
 
  // This is set to \c true when dragging with an PointingAction.
  bool _isDragging;
 
  // This is set if the current dragging action has been canceled.
  bool _cancelled;
};
 
#endif  // __SoInteractionCoordinator_H