SoCSOLabelRenderer.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2012, 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 <SoView2DCSOEditor/SoView2DCSOExtensibleEditor/SoCSOEditorExtension.h>
#include "CSOLabelPlacement.h"
#include <set>
 
ML_START_NAMESPACE
class CSOLabelRenderer;
ML_END_NAMESPACE
 
 
enum ResizeHotSpot
{
  NotHit = 0,
  N,
  E,
  S,
  W,
  NE,
  NW,
  SE,
  SW
};
 
 
class SOCSO_EXPORT SoCSOLabelRenderer : public SoCSOEditorExtension
{
  SO_NODE_HEADER(SoCSOLabelRenderer);
 
public:
  SoCSOLabelRenderer();
protected:
  ~SoCSOLabelRenderer() override;
 
public:
 
 
  void setVisibleCSOs(const std::vector<CSODrawCSOInfos>& drawCSOInformation,
                              const CSODrawView2DInfos& view2DInfos, SoView2DCSOExtensibleEditor* editor ) override;
 
  void draw(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor) override;
  void drawSecondPass(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor) override;
  void drawOverlay(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor) override;
 
  static void initClass();
 
  bool isModificationEditor() const override { return true; }
 
  void labelMoveStartPressAt(ml::CSO* cso, const SoPointerPosition& pos);
  void labelMoveDragMoveTo(ml::CSO* cso, const SoPointerPosition& pos);
 
  SoPointingAction* labelMoveEndPress(ml::CSO* cso, int clickCount);
 
  void labelResizeStartPressAt(ml::CSO* cso, const SoPointerPosition& pos);
  void labelResizeDragMoveTo(ml::CSO* cso, const SoPointerPosition& pos, int resizeHandlerCode);
 
  SoPointingAction* labelResizeEndPress(ml::CSO* cso, int clickCount);
 
  // just overload the methods below since we do not work
  // with the standard actions
  void createStartPressAt(const SoPointerPosition&) override {}
  void createDragMoveTo(const SoPointerPosition&) override {}
  bool createEndPress(int ) override { return false; }
  void pointerPositionIfAllowedAt(const SoPointerPosition&) override {}
 
  void selectAndMoveStartPressAt(const SoPointerPosition&) override {}
  void selectAndMoveDragMoveTo(const SoPointerPosition&) override {}
  SoPointingAction* selectAndMoveEndPress(int ) override {return nullptr; }
 
  void pointerPosition(const SoPointerPosition& pos) override;
  void pointerLeftWindow() override;
 
  int cursorShape() const override { return SoViewerProxy::DEFAULT_CURSOR; }
 
  void setLabelUnderMouseForInteraction(ml::CSO* cso);
  void setLabelUnderMouseForHighlighting(ml::CSO* cso);
 
  bool shouldRenderGeneral(ml::CSO*) const override { return true; }
 
  void startDrawing(View2DSliceList* slicelist) override;
 
  ml::CSO* getLabelCSO(const std::string& currentViewerId, const SoPointerPosition& pos);
 
  ml::CSO* getHitResizeHandler(const std::string& currentViewerId, const SoPointerPosition& pos, int& resizeHandlerCode);
 
  void setOuterModule(ml::CSOLabelRenderer* labelRendererModule) { _labelRendererModule = labelRendererModule; }
 
  void updateStringsInCache();
 
  void resetCache() override;
 
  void computeOutputInformation();
 
  SoSFMLBase inLabelPlacement;
 
  SoSFInt32 labelBorderMarginX;
  SoSFInt32 labelBorderMarginY;
  SoSFBool drawLabelBorderForSelectedCSO;
  SoSFBool shouldRenderLabelName;
  SoSFBool shouldDrawConnectingLine;
  SoSFBool shouldHighlightBorderOnMouseOver;
  SoSFFloat connectingLineAlpha;
  SoSFBool allowLabelResize;
  SoSFBool shouldDrawResizeHandlers;
  SoSFInt32 minConnectingLineLength;
  SoSFBool drawConnectingLineToCenterOfCSO;
  SoSFTrigger repaintTrigger;
  SoSFInt32 fontSize;
 
  SoSFBool tryToPlaceLabelsWithoutOverlap;
  SoSFEnum detachedLabelPlacement;
  SoSFEnum viewerBorderHandling;
 
 
  SoSFInt32 inputInfoCSOId;
  SoSFString inputInfoViewerId;
 
  SoSFVec2f outputInfoLabelBoundingBoxStart;
  SoSFVec2f outputInfoLabelBoundingBoxEnd;
  SoSFString outputInfoLabelCaption;
  SoSFString outputInfoLabelString;
  SoSFInt32 outputInfoLabelCaptionWidth;
  SoSFBool outputInfoIsValid;
  SoSFBool shouldShowLabelStringOfOutputInfoLabel;
 
 
  SoSFEnum movePossibleCursor;
  SoSFEnum movePerformCursor;
 
  SoSFEnum scaleNCursor;
  SoSFEnum scaleNWCursor;
  SoSFEnum scaleWCursor;
  SoSFEnum scaleSWCursor;
  SoSFEnum scaleSCursor;
  SoSFEnum scaleSECursor;
  SoSFEnum scaleECursor;
  SoSFEnum scaleNECursor;
 
 
private:
 
  ml::CSOLabelRenderer* _labelRendererModule;
 
  struct DeviceOffset
  {
    DeviceOffset() { xOffset = yOffset = 0; }
    int xOffset;
    int yOffset;
  };
 
  std::map < int, std::string > _csoLabelStrings;
  std::map < int, std::string > _csoLabelNames;
  std::map < int, std::string > _csoLabelCaptions;
  std::map < int, DeviceOffset > _csoDeviceOffsets;
  std::map < int, bool > _shouldRenderLabel;
 
  std::multimap < std::string, CSOLabelRenderInformation > _viewerLabelRenderInformation;
  void filterCSOLabelsForLayout(const std::vector<CSODrawCSOInfos>& drawCSOInfos,
                                const CSODrawView2DInfos& view2DInfos, SoView2DCSOExtensibleEditor* editor,
                                std::vector<CSODrawCSOInfos>& filteredDrawCSOInfos);
  void clearInternalStructures();
  void buildAllLabelStringsThatNeedUpdate(ml::CSOList* csoList);
  void prepareLabel(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor);
  bool getLabelRenderInformation(const std::string& viewerId, ml::CSO* cso, CSOLabelRenderInformation& labelRenderInfo);
  bool getLabelRenderInformation(const std::string& viewerId, unsigned int csoId, CSOLabelRenderInformation& labelRenderInfo);
 
  void removeLabelRenderInformation(const std::string& viewerId, ml::CSO* cso);
  void removeAllLabelRenderInformationForCSOId(int id, bool removeAll=false);
  void cacheLabelRenderInformation(const std::string& viewerId,  const CSOLabelRenderInformation& renderInfo);
  bool isHit(const CSOLabelRenderInformation& labelRenderInfo, const SoPointerPosition& pos) const;
  bool isHit(const CSOLabelRenderInformation& labelRenderInfo, float deviceX, float deviceY) const;
  bool shouldRenderBecauseOfSliceAlignment(const CSODrawSliceInformation& drawSliceInfo);
  bool isCSOGhosting(const CSODrawSliceInformation& drawSliceInfo);
 
  void buildLabelString(ml::CSO* cso);
  void drawLabelBorder(const CSODrawCSOInfos& csoInfos, const CSODrawSliceInformation& drawSliceInfo, const SbVec2f& upperLeft, const SbVec2f& size);
  void drawResizeHandlers(const SbVec2f& upperLeft, const SbVec2f& size);
  void drawLabelName(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, float fontColor[4], const std::string& labelName);
  void drawLabelCSOConnectingLine(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo,
                                  const SbVec2f& upperLeft, const SbVec2f& size);
 
  void computeConnectingLineCSOPosition(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo,
                                        const SbVec2f& labelMidPoint, float& lineX1, float& lineY1);
 
  bool isMouseOverLabelOrCSOForInteraction(ml::CSO* cso);
  bool isMouseOverLabelOrCSOForHighlighting(ml::CSO* cso);
 
 
  void getCSOPoints( const CSODrawCSOInfos& csoInfos, std::vector< ml::Vector3 >& csoPoints );
 
  void ensureLabelIsVisible(View2DSlice* slice, SbVec2f& labelUpperLeft, SbVec2f& labelSize);
  bool isLabelInsideViewer(View2DSlice* slice, SbVec2f& labelUpperLeft, SbVec2f& labelSize);
  float fitFontSizeToBox(const CSOLabelRenderInformation& labelRenderInformation, const std::string& labelString, float originalFontSize);
 
  void moveLabelRelative(const std::string& viewerId, ml::CSO* cso, const SoPointerPosition& pos, const SbVec2f& relativeMovementOffset);
 
  void setLabelRelative(const std::string& viewerId, ml::CSO* cso, const SbVec2f relativePosition);
  SbVec2f getRelativePositionOfCSOInViewer(const std::string& viewerId, ml::CSO* cso);
  float getResizeDelta( const SbVec2f& currentDevicePosition, int resizeHandlerCode );
  void drawGLRectangle(const SbVec2f& upperLeft, const SbVec2f& lowerRight, float offset=0, float lineWidth=1) const;
  bool isInRectangle(const SbVec2f& rectUpperLeft, const SbVec2f& rectLowerRight, const SbVec2f& position) const;
 
  float distance(float x0, float y0, float x1, float y1) const;
  void clipLineToRectangle(float& lineX0, float& lineY0, float& lineX1, float& lineY1, float rectMinX, float rectMinY, float rectMaxX, float rectMaxY) const;
  int outcode(float lineX, float lineY, float rectMinX, float rectMinY, float rectMaxX, float rectMaxY) const;
 
  void getLabelSize(float fontSize, const std::string& labelString, int& labelWidth, int& labelHeight);
  float getFontSize(ml::CSO* cso, SoView2D* viewer);
  void setFontSize(ml::CSO* cso, SoView2D* viewer, float fontSize);
 
  void computeLabelBoxes(const std::vector<CSODrawCSOInfos>& filteredDrawCSOInfos, const CSODrawView2DInfos& view2DInfos, std::map < int, SbVec2f >& labelBoxes);
  void getLabelBoxForCSO( ml::CSO* cso, const CSODrawView2DInfos& view2DInfos, int& labelWidth, int& labelHeight );
 
  View2DSlice* getCurrentSlice(const SoPointerPosition& pos);
 
  ml::CSOLabelPlacement* getLabelPlacement();
 
 
  void getDetachedLabelPosition( const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, float& deviceX, float& deviceY );
  SbVec2f computeNewDetachedLabelPositionWhileInteracting( const SbVec2f& lastRelativeLabelPosition, const SbVec2f& relativeMovementOffset, const CSOLabelRenderInformation& labelRenderInfo, ml::CSO* cso, View2DSlice* slice );
  ml::Vector3 getDeviceAnchorPosition(ml::CSO* cso);
 
  void getFreePosition(float& deviceX, float& deviceY, const std::string& viewerId, float labelWidth, float labelHeight, View2DSlice* slice);
  bool boundingBoxesIntersect(const CSOLabelRenderInformation& labelRenderInfo, float deviceX, float deviceY, float labelWidth, float labelHeight);
  static void baseEventCB(void* userData, ml::BaseEvent* event);
  bool needsUpdate(ml::CSO* cso);
  void attachAsListenerTo(ml::CSOList* csoList);
  static std::string getViewerId(const SoPointerPosition& pos);
 
  bool shouldRenderLabelString(unsigned int csoId, const std::string& viewerId);
  SbBox2f getLabelDeviceRect(const CSOLabelRenderInformation& labelRenderInfo) const;
 
  ml::CSOList* _listenToCSOList;
  std::set<int> _needsUpdateCSOIds;
 
  SbVec2f _startDragDevicePosition;
  SbVec2f _startDragOffsetToCenter;
  SbVec2f _currentFrameUpperLeft;
  SbVec2f _currentFrameLowerRight;
  SbVec2f _relativeLabelPosition;
  ml::CSO* _csoLabelUnderMouseForInteraction;
  ml::CSO* _csoLabelUnderMouseForHighlighting;
 
  float _minimumFontSize;
  float _maximumFontSize;
 
  ml::CSOLabelPlacement _labelPlacement;
 
  friend class ml::CSOLabelPlacement;
};