MeVisLab/Standard/Sources/Inventor/SoView2D/SoView2DExtension.h

Go to the documentation of this file.

#ifndef __SoView2DExtension_H
#define __SoView2DExtension_H
//----------------------------------------------------------------------------------
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __SoView2DSystem_H
#include "SoView2DSystem.h"
#endif

#include "XVEnterScope.h"
#include <Inventor/nodes/SoNode.h>
#include <Inventor/nodes/SoSubNode.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFTrigger.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFColor.h>
#include <Inventor/sensors/SoNodeSensor.h>
#include <Inventor/nodes/SoGroup.h>
#include <Inventor/events/SoEvent.h>
#include <Inventor/events/SoMouseButtonEvent.h>
#include <Inventor/events/SoSpaceballButtonEvent.h>
#include <Inventor/events/SoKeyboardEvent.h>
#include <Inventor/events/SoLocation2Event.h>
#include <Inventor/events/SoMotion3Event.h>
#include "XVLeaveScope.h"

#include <SoInteractionProviderNode.h>

class SoSFMLImage;


#ifndef TRISTATE
#define TRISTATE

typedef enum { IGNORED, PRESSED, RELEASED } tristateType;


#define TEST_STATE(state,flag) (((state)==IGNORED)?TRUE:(((state)==PRESSED)==((flag)!=0)))

#endif

//--------- disable VC++ warnings---------
#ifdef WIN32
#pragma warning (disable : 4355)
#pragma warning (disable : 4275)
#pragma warning (disable : 4251)
#pragma warning (disable : 4138)
#pragma warning (disable : 4800)
#endif

class View2DSliceList;
class View2DSlice;
class SoView2D;

typedef enum _View2DEventPhase {
    EVENT_START,  
    EVENT_MOTION, 
    EVENT_RELEASE,
    EVENT_KEY_PRESSED, 
    EVENT_KEY_RELEASED,
    EVENT_ANY, 
    EVENT_MOUSEWHEEL, 
    EVENT_MOUSEOVER_UPDATE 
} View2DEventPhase;

//==============================================================
//==============================================================
class View2DEvent {
public:
  View2DEvent();
  View2DEvent(bool sh,     bool ct, bool al,
    bool pr,     bool mo, bool re,
    bool b1,     bool b2, bool b3,
    int   dpx,    int dpy,
    int   button,
    bool isKP,   bool isKR,
    bool iVK,    int kk,
    bool iVSP,   float spx, float spy, float spz,
    long  secs,   long usecs, const SoEvent* event);

  void setValues(bool sh,     bool ct, bool al,
    bool pr,     bool mo, bool re,
    bool b1,     bool b2, bool b3,
    int   dpx,    int dpy,
    int   button,
    bool isKP,   bool isKR,
    bool iVK,    int kk,
    bool iVSP,   float spx, float spy, float spz,
    long  secs,   long usecs, const SoEvent* event);

  void print();

  bool checkDoubleClick(View2DEvent& ec);

  bool sliceHit() { return isValidSlicePos; }


  bool shift, ctrl, alt;

  bool press;
  bool motion;
  bool release;
  bool mouseOverUpdate;

  bool button1, button2, button3;

  int   button;

  bool isKeyPressed;
  bool isKeyReleased;
  bool isValidKey;
  int   keyCode;

  int   devicePosX;
  int   devicePosY;

  bool isValidSlicePos;
  float slicePosX;
  float slicePosY;
  float slicePosZ;

  long  second;
  long  usecond;

  const SoEvent* soevent;

  bool  handled;
  bool  doubleclick;
};

#define EventContainer View2DEvent
#define EventPhase View2DEventPhase

//=============================================================
//=============================================================
class SOVIEW2D_API SoView2DExtension : public SoInteractionProviderNode 
{

  SO_NODE_HEADER(SoView2DExtension);

public:
  SoSFColor color;
  SoSFBool  drawingOn;
  SoSFBool  editingOn;

  SoSFBool maskValid;
  
  SoSFFloat selectionTolerance;

  SoSFBool wantsAllEvents;
  SoSFBool wantsKeyEvents;
  SoSFBool wantsMouseWheelEvents;

  SoSFBool setEventHandled;
  SoSFBool ignoreHandledEvents;


  SoSFEnum button1;
  SoSFEnum button2;
  SoSFEnum button3;
  SoSFEnum shift;
  SoSFEnum control;
  SoSFEnum alt;

  SoSFBool  needsValidVoxel;

  SoSFBool  renderOnSlab;

  SoSFBool    createNewMode;
  SoSFTrigger createNewModeRequest;

  SoSFBool clipToSlice;

  SoSFEnum cursorShape;


  SoSFBool  fixZOn;

  static void   initClass();

  SoView2DExtension();

  void init();

  virtual void updateValues();


  virtual void   draw(View2DSliceList *slicelist,View2DSlice* slice, int sliceZ);


  virtual bool  evalEvent(SoView2D* view2d, View2DSliceList* slicelist,
    View2DEvent* ec, View2DEventPhase phase);

  virtual void   startDrawing(View2DSliceList * /*slicelist*/){};

  virtual void   endDrawing(View2DSliceList * /*slicelist*/){};


  View2DEvent* getEvent();

  float  getSelectDist();

  bool isPointInsideDeviceRect(float pointX, float pointY, float centerX, float centerY, float hitRectangleSize=0.0);

  virtual void   drawMiniRect(float x, float y);
  virtual void   drawMiniRect(float xp, float yp, float ext);
  virtual void   drawFilledMiniRect(float xp, float yp, float ext);
  virtual void   drawMiniCircle(float xp, float yp, float ext);

  void drawVoxelBorder(View2DSlice* slice, float vx,float vy,float vz);

  int getX();

  int getY();

  virtual bool  isDrawingOn()        { return drawingOn.getValue(); };
  virtual bool  isEditingOn()        { return editingOn.getValue(); };
  virtual bool  isFixZOn()           { return fixZOn.getValue(); };
  virtual bool  isClipToSlice()      { return clipToSlice.getValue(); };

  static  void fieldChangedCB(void *data, SoSensor *sensor);
  virtual void fieldChanged(SoSensor* sensor);

  bool isCreateNewMode();
  void setCreateNewMode(bool flag);

  bool isCreateNewModeRequest();
  void setCreateNewModeRequest(bool flag);

  virtual bool isActive();

  virtual void deleteSelectedObject();

  virtual void getStatusString(SbString& status);


  static void    getAxisOrientation(int axis, SbMatrix &matrix, char &negativeResult, char &positiveResult);

  static float pointToLineDistance(SbVec3f point, SbVec3f line1, SbVec3f line2);
  static float pointToLineDistance(SbVec2f point, SbVec2f line1, SbVec2f line2);

  typedef enum { ZERO, NEGATIVE, POSITIVE } Sign;

  static Sign edgeIntersectWithPlane(const SbVec3f &v1,
    const SbVec3f &v2,
    const SbPlane &plane,
    SbVec3f &intersect);


  virtual bool  evaluateEvent(SoView2D *view2d, View2DEvent* ec);

  static bool isImageParallel (SoSFMLImage* image, View2DSliceList *dsl);

  virtual bool ignoreEvent(View2DEvent* ec);

  bool wantsMouseOverUpdates() const { return _wantsMouseOverUpdateEvents; }

  virtual void consumeEvent(View2DEvent* ec, bool handled = TRUE);

  int getSelectedModifierMask();
  int getSelectedIgnoreMask();

  SoPointingAction::Trigger getPointingActionTriggerFromFields();

  virtual bool implementsManagedInteractionAndClassicEventHandling() const { return false; }

protected:
  virtual void     GLRender(SoGLRenderAction *action);
  virtual void     callback(SoCallbackAction *action);
  virtual void     handleEvent(SoHandleEventAction *action);
  virtual void     getMatrix(SoGetMatrixAction *action);
  virtual void     getBoundingBox(SoGetBoundingBoxAction *action);
  virtual void     pick(SoPickAction *action);
  virtual void     doAction(SoAction *action);
#ifndef SGIOIV
  virtual void     getPrimitiveCount(SoGetPrimitiveCountAction * action);
#endif


  SoNodeSensor* _nodeSensor;

  float _rgbColor[4];

  bool  _wantsMouseOverUpdateEvents;

  virtual  ~SoView2DExtension();

private:

  bool      _active;
  SoView2D* _activeView2D;

  View2DEvent *_ec;

  bool _createNewModeRequest;
};

#endif