SoView2DExtension.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, 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
**
**************************************************************************************/
 
 
 
#pragma once
 
#include "SoView2DSystem.h"
 
#include <ThirdPartyWarningsDisable.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 <ThirdPartyWarningsRestore.h>
 
#include <SoInteractionProviderNode.h>
#include <mlGLHiDPI.h>
 
class SoSFMLImage;
 
struct SoView2DDrawingSettings
{
  SoView2DDrawingSettings() {
    drawImageData = true;
    applyLut = true;
  }
 
  bool drawImageData;
  bool applyLut;
};
 
#ifndef TRISTATE
#define TRISTATE
enum tristateType { IGNORED, PRESSED, RELEASED };
 
 
#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)
// Warning 4800 isn't defined for Visual Studio 2017
#if (_MSC_VER < 1910)
#pragma warning (disable : 4800)
#endif
#endif
 
class View2DSliceList;
class View2DSlice;
class SoView2D;
 
enum View2DEventPhase {
    EVENT_START,  
    EVENT_MOTION, 
    EVENT_RELEASE,
    EVENT_KEY_PRESSED, 
    EVENT_KEY_RELEASED,
    EVENT_ANY, 
    EVENT_MOUSEWHEEL, 
    EVENT_MOUSEOVER_UPDATE 
};
 
//==============================================================
//==============================================================
class View2DEvent
{
public:
  View2DEvent();
  View2DEvent(bool sh,     bool ct, bool al,
    bool pr,     bool mo, bool re, bool dc,
    bool b1,     bool b2, bool b3,
    int  dpx,    int dpy, bool ov,
    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 dc,
    bool b1,     bool b2, bool b3,
    int  dpx,    int dpy, bool ov,
    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 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 isOverViewer;
  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
 
enum LineStyles
{
  SOLID,
  DOTTED,
  DASHED,
  LONG_DASHED
};
 
#define VIEW2D_DEFINE_LINE_STYLE_ENUM \
  SO_NODE_DEFINE_ENUM_VALUE(LineStyles, SOLID); \
  SO_NODE_DEFINE_ENUM_VALUE(LineStyles, DASHED); \
  SO_NODE_DEFINE_ENUM_VALUE(LineStyles, DOTTED); \
  SO_NODE_DEFINE_ENUM_VALUE(LineStyles, LONG_DASHED);
 
#define VIEW2D_ADD_LINE_STYLE_FIELD(lineStyleField) \
  SO_NODE_ADD_FIELD(lineStyleField, (SOLID)); \
  SO_NODE_SET_SF_ENUM_TYPE(lineStyleField, LineStyles);
 
 
//=============================================================
 
//=============================================================
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*/){};
 
  virtual void   overwriteDrawingSettings(SoView2DDrawingSettings& /*settings*/) {};
 
  View2DEvent* getEvent();
 
  float getSelectDist();
 
  inline static float snapToPixelCenter(float coordinateComponent) { return floorf(coordinateComponent) + 0.5f; }
 
  bool isPointInsideDeviceRect(float pointX, float pointY, float centerX, float centerY, float hitRectangleSize=0.0);
 
  void drawMiniRect(float xp, float yp, float ext, float lineWidth = 1.f);
  void drawDashedMiniRect(float xp, float yp, float ext, float lineWidth);
  void drawFilledMiniRect(float xp, float yp, float ext, float lineWidth = 1.f);
 
  void drawMiniTriangle(float xp, float yp, float ext, float lineWidth = 1.f);
  void drawFilledMiniTriangle(float xp, float yp, float ext, float lineWidth = 1.f);
 
  void drawMiniCircle(float xp, float yp, float ext, float lineWidth = 1.f);
  void drawFilledMiniCircle(float xp, float yp, float ext, float lineWidth = 1.f);
  void drawFixedSizeMiniCircleAt(float xp, float yp);
 
  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 enableLineStippling(const SoSFEnum& lineStyleField);
  static void disableLineStippling(const SoSFEnum& lineStyleField);
 
 
  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);
 
  enum Sign { ZERO, NEGATIVE, POSITIVE };
 
  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:
  void     GLRender(SoGLRenderAction *action) override;
  void     callback(SoCallbackAction *action) override;
  void     handleEvent(SoHandleEventAction *action) override;
  void     getMatrix(SoGetMatrixAction *action) override;
  void     getBoundingBox(SoGetBoundingBoxAction *action) override;
  void     pick(SoPickAction *action) override;
  void     doAction(SoAction *action) override;
 
  virtual void     editingOnChanged(SoField*) {}
 
  virtual void     buttonMaskChanged(SoField*) {}
 
  virtual void     createNewModeRequestTriggered(SoField*) { setCreateNewModeRequest(TRUE); }
 
  SoNodeSensor* _nodeSensor;
 
  float _rgbColor[4];
 
  bool  _wantsMouseOverUpdateEvents;
 
   ~SoView2DExtension() override;
 
private:
 
  bool      _active;
  SoView2D* _activeView2D;
 
  View2DEvent *_ec;
 
  bool _createNewModeRequest;
};