MeVisLab/Standard/Sources/Inventor/SoCSO/SoView2DCSOEditor/SoView2DCSOExtensibleEditor/SoCSOEditorExtension.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

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


#ifndef __SoCSOEditorExtension_H
#define __SoCSOEditorExtension_H

#include <SoCSOSystem.h>

#include "SoCSOVisualizationSettings.h"

#include <Inventor/nodes/SoNode.h>
#include <Inventor/sensors/SoFieldSensor.h>

#include <View2DPosition.h>
#include <SoView2D.h>
#include <SoViewerProxy.h>



class SoView2DCSOExtensibleEditor;

class SOCSO_EXPORT SoCSOEditorExtension : public SoNode
{
  SO_NODE_HEADER(SoCSOEditorExtension);

protected:
  SoCSOEditorExtension();
  ~SoCSOEditorExtension();

public: 

  void setExtensibleEditor(SoView2DCSOExtensibleEditor* extensibleEditor) { _editor = extensibleEditor; }

  virtual void startDrawing(View2DSliceList* ) {}

  virtual void draw(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& sliceInfo, SoView2DCSOExtensibleEditor* editor);

  static void initClass();
  
  virtual void createStartPressAt(const SoPointerPosition& pos) = 0;
  virtual void createDragMoveTo(const SoPointerPosition& pos) = 0;
  // returns whether to continue with this action
  virtual bool createEndPress(int clickCount) = 0;
  
  virtual void selectAndMoveStartPressAt(const SoPointerPosition& pos) = 0;
  virtual void selectAndMoveDragMoveTo(const SoPointerPosition& pos) = 0;
  virtual SoPointingAction* selectAndMoveEndPress(int clickCount) = 0;

  virtual void insertSeedPointStartPressAt(const SoPointerPosition& ) {}
  virtual void insertSeedPointDragMoveTo(const SoPointerPosition& ) {}
  virtual SoPointingAction* insertSeedPointEndPress(int ) { return NULL; }

  virtual void pointerPosition(const SoPointerPosition& ) {}
  virtual void pointerLeftWindow() {}

  virtual bool isCreationAllowed() const { return allowCreation.getValue() == 1; }
  virtual bool isModificationAllowed() const { return allowModification.getValue() == 1; }
  virtual bool shouldRenderCSOs() const { return shouldRender.getValue(); }
  virtual bool canCreateCSOs() const { return false; }

  SbString getCreatorExtensionId() const { return extensionId.getValue(); }
  void setActiveCSOList(ml::CSOList* hitCSOList);
  void setSelectAndMoveInformation(ml::CSOList* hitCSOList, ml::CSO* hitCSO, ml::CSOSeedPoint* hitSeedPoint, 
                                   ml::CSOPathPoints* hitPathPoints, float hitDistance);
  void setCSOUnderMouse(ml::CSO* cso) { _csoUnderMouse = cso; }

  virtual SbString getSubType() const { return _subType; }
  virtual bool shouldRenderSpecific(ml::CSO* cso) const;
  virtual bool shouldRenderGeneral(ml::CSO*) const { return false; }
  virtual bool isDefaultRenderer() const { return false; }

  virtual void resetCache() {}

  virtual void cancel() {}
  virtual int cursorShape() const { return SoViewerProxy::CROSS_CURSOR; }
  virtual bool deleteSeedPoint(ml::CSO* cso, ml::CSOSeedPoint* );
  ml::CSOSeedPoint* getPreviousSeedPoint(ml::CSOSeedPoint* seedPoint) const;

  SoSFString extensionId;
  SoSFBool allowCreation;
  SoSFBool allowModification;
  SoSFBool allowSeedPointInteraction;
  SoSFBool shouldRender;
  SoSFMLBase inVisualizationSettings;

  virtual  bool evaluateHitPoint(const ml::Vector3& worldPosition, View2DSliceList* slicelist, ml::CSOList* csoList, 
                                 const ml::CSOBoundingBox& slabBB, SoView2DCSOExtensibleEditor* editor,
                                 ml::CSO*& localHitCSO, ml::CSOSeedPoint*& localHitSeedPoint, 
                                 ml::CSOPathPoints*& localHitPathPoints, float& distance);


protected:

  SoView2DCSOExtensibleEditor* _editor;

  ml::CSOList*       _hitCSOList;
  ml::CSO*           _hitCSO;
  ml::CSOSeedPoint*  _hitSeedPoint;
  ml::CSOPathPoints* _hitPathPoints;  
  float              _hitDistance;
  ml::CSO*           _csoUnderMouse;
  
  void sendCSONotificationRepaint();
  void sendCSONotificationMove();
  void sendCSONotificationFinishInteraction();
  void sendCSONotificationResetInteractionState();
  void sendCSONotificationInsertSeedPoint();
  void sendCSONotificationNewCSOStarted();

  void setExtensionIdAsSubType() { _subType = extensionId.getValue().getString(); }

  virtual void setCreationData(const SoPointerPosition& pos, ml::CSO* newCSO);

  SoFieldSensor* _extensionIdSensor;
  static void extensionIdCB(void* data, SoDataSensor* );

  ml::CSOVisualizationSettings* getVisualizationSettings();

  ml::CSOVisualizationSettings _visualizationSettings;

  SbString _subType;
  
  void drawPathPoints(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, const SbVec2f& shadowOffsetDevice, SoView2DCSOExtensibleEditor* editor);
  void renderPathPoints(const CSOPathPointsRenderSettings& renderSettings, const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const std::vector<CSOSliceCrossing>& pathPointsLists);

  void drawPathAndCrossingPoints(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const SbVec2f& shadowOffsetDevice, const std::vector<CSOSliceCrossing>& pathAndCrossingPoints);

  void drawSeedPoints(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor);

  void drawFixedSizeCircleAt(float deviceX, float deviceY);

  void glVertex2fForVector3(const CSODrawView2DInfos& view2DInfos, const ml::Vector3& position, const SbVec2f& deviceOffset);
  void mapWorldToDeviceViaVoxel(const CSODrawView2DInfos& view2DInfos, const ml::Vector3& position, float& deviceX, float& deviceY);

  ml::Vector3 getTransformedPosition(const CSODrawView2DInfos& view2DInfos, const ml::Vector3& position);

  void mapWorldToDevice(const SoPointerPosition& pos, const ml::Vector3& worldPosition, float& deviceX, float& deviceY);
  ml::Vector3 mapDeviceToWorld(const SoPointerPosition& pos, float deviceX, float deviceY);
  ml::Vector3 mapWorldToVoxel(const SoPointerPosition& pos, const ml::Vector3& worldPosition);
  ml::Vector3 mapVoxelToWorld(const SoPointerPosition& pos, const ml::Vector3& voxelPosition);

  SbVec2f nonShadowOffset() const { return SbVec2f(0,0); }
  SbVec2f shadowOffset() const { return SbVec2f(1,1); }

  void setupGLForCSO(const CSODrawCSOInfos& csoInfos);
  void setupGLAntiAlias();
  void restoreGLAntiAlias();
  void setupGLShadow(float generalAlpha=1.0f);
  void glSetAlpha(float alpha);
  float getDepthAlpha(int maxSliceDistance, int currentSliceDistance) const;
};


#endif // __SoCSOEditorExtension_H