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