orthanc-stone: Applications/Samples/Sdl/SingleFrameViewer/SdlSimpleViewer.cpp comparison

comparison Applications/Samples/Sdl/SingleFrameViewer/SdlSimpleViewer.cpp @ 1801:64dad1d7aca4

renamed subclass

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 20 May 2021 13:23:59 +0200
parents	2c0497d61a5d
children	d1849468729b

comparison

equal deleted inserted replaced

-:2c0497d61a5d
+:64dad1d7aca4
 };
 private:
 class Annotation;
-class Primitive : public boost::noncopyable
+class GeometricPrimitive : public boost::noncopyable
 {
 private:
 bool         modified_;
 Annotation&  parentAnnotation_;
 Color        color_;
 Color        hoverColor_;
 bool         isHover_;
 int          depth_;
 public:
-Primitive(Annotation& parentAnnotation,
+GeometricPrimitive(Annotation& parentAnnotation,
 int depth) :
 modified_(true),
 parentAnnotation_(parentAnnotation),
 color_(192, 192, 192),
 hoverColor_(0, 255, 0),
 isHover_(false),
 depth_(depth)
 {
 }
-virtual ~Primitive()
+virtual ~GeometricPrimitive()
 {
 }
 Annotation& GetParentAnnotation() const
 {
 class Annotation : public boost::noncopyable
 {
 private:
-typedef std::list<Primitive*>  Primitives;
+typedef std::list<GeometricPrimitive*>  GeometricPrimitives;
 AnnotationsOverlay&  that_;
-Primitives           primitives_;
+GeometricPrimitives  primitives_;
 public:
 Annotation(AnnotationsOverlay& that) :
 that_(that)
 {
 that.AddAnnotation(this);
 }
 virtual ~Annotation()
 {
-for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
+for (GeometricPrimitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
 {
 that_.DeletePrimitive(*it);
 }
 }
-Primitive* AddPrimitive(Primitive* primitive)
+GeometricPrimitive* AddPrimitive(GeometricPrimitive* primitive)
 {
 if (primitive == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 {
 AddPrimitive(primitive);
 return *primitive;
 }
-virtual void SignalMove(Primitive& primitive) = 0;
+virtual void SignalMove(GeometricPrimitive& primitive) = 0;
 virtual void Serialize(Json::Value& target) = 0;
 };
-class Handle : public Primitive
+class Handle : public GeometricPrimitive
 {
 private:
 ScenePoint2D  center_;
 ScenePoint2D  delta_;
 public:
 explicit Handle(Annotation& parentAnnotation,
 const ScenePoint2D& center) :
-Primitive(parentAnnotation, 0),  // Highest priority
+GeometricPrimitive(parentAnnotation, 0),  // Highest priority
 center_(center),
 delta_(0, 0)
 {
 }
 GetParentAnnotation().SignalMove(*this);
 }
 };
-class Segment : public Primitive
+class Segment : public GeometricPrimitive
 {
 private:
 ScenePoint2D  p1_;
 ScenePoint2D  p2_;
 ScenePoint2D  delta_;
 public:
 Segment(Annotation& parentAnnotation,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
-Primitive(parentAnnotation, 1),  // Can only be selected if no handle matches
+GeometricPrimitive(parentAnnotation, 1),  // Can only be selected if no handle matches
 p1_(p1),
 p2_(p2),
 delta_(0, 0)
 {
 }
 GetParentAnnotation().SignalMove(*this);
 }
 };
-class Circle : public Primitive
+class Circle : public GeometricPrimitive
 {
 private:
 ScenePoint2D  p1_;
 ScenePoint2D  p2_;
 public:
 Circle(Annotation& parentAnnotation,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
-Primitive(parentAnnotation, 2),
+GeometricPrimitive(parentAnnotation, 2),
 p1_(p1),
 p2_(p2)
 {
 }
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);  // No hit is possible
 }
 };
-class Arc : public Primitive
+class Arc : public GeometricPrimitive
 {
 private:
 ScenePoint2D  start_;
 ScenePoint2D  middle_;
 ScenePoint2D  end_;
 public:
 Arc(Annotation& parentAnnotation,
 const ScenePoint2D& start,
 const ScenePoint2D& middle,
 const ScenePoint2D& end) :
-Primitive(parentAnnotation, 2),
+GeometricPrimitive(parentAnnotation, 2),
 start_(start),
 middle_(middle),
 end_(end),
 radius_(20)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);  // No hit is possible
 }
 };
-class Text : public Primitive
+class Text : public GeometricPrimitive
 {
 private:
 AnnotationsOverlay&              that_;
 bool                             first_;
 size_t                           subLayer_;
 std::unique_ptr<TextSceneLayer>  content_;
 public:
 Text(AnnotationsOverlay& that,
 Annotation& parentAnnotation) :
-Primitive(parentAnnotation, 2),
+GeometricPrimitive(parentAnnotation, 2),
 that_(that),
 first_(true)
 {
 }
 class EditPrimitiveTracker : public IFlexiblePointerTracker
 {
 private:
-Primitive&         primitive_;
+GeometricPrimitive&  primitive_;
-ScenePoint2D       sceneClick_;
+ScenePoint2D         sceneClick_;
-AffineTransform2D  canvasToScene_;
+AffineTransform2D    canvasToScene_;
-bool               alive_;
+bool                 alive_;
 public:
-EditPrimitiveTracker(Primitive& primitive,
+EditPrimitiveTracker(GeometricPrimitive& primitive,
 const ScenePoint2D& sceneClick,
 const AffineTransform2D& canvasToScene) :
 primitive_(primitive),
 sceneClick_(sceneClick),
 canvasToScene_(canvasToScene),
 Handle& GetHandle2() const
 {
 return handle2_;
 }
-virtual void SignalMove(Primitive& primitive) ORTHANC_OVERRIDE
+virtual void SignalMove(GeometricPrimitive& primitive) ORTHANC_OVERRIDE
 {
 if (&primitive == &handle1_ ||
 &primitive == &handle2_)
 {
 segment_.SetPosition(handle1_.GetCenter(), handle2_.GetCenter());
 Handle& GetEndHandle() const
 {
 return endHandle_;
 }
-virtual void SignalMove(Primitive& primitive) ORTHANC_OVERRIDE
+virtual void SignalMove(GeometricPrimitive& primitive) ORTHANC_OVERRIDE
 {
 if (&primitive == &startHandle_)
 {
 segment1_.SetPosition(startHandle_.GetCenter(), middleHandle_.GetCenter());
 arc_.SetStart(startHandle_.GetCenter());
 Handle& GetHandle2() const
 {
 return handle2_;
 }
-virtual void SignalMove(Primitive& primitive) ORTHANC_OVERRIDE
+virtual void SignalMove(GeometricPrimitive& primitive) ORTHANC_OVERRIDE
 {
 if (&primitive == &handle1_ ||
 &primitive == &handle2_)
 {
 segment_.SetPosition(handle1_.GetCenter(), handle2_.GetCenter());
 {
 }
 };
-typedef std::set<Primitive*>   Primitives;
+typedef std::set<GeometricPrimitive*>  GeometricPrimitives;
-typedef std::set<Annotation*>  Annotations;
+typedef std::set<Annotation*>          Annotations;
-typedef std::set<size_t>       SubLayers;
+typedef std::set<size_t>               SubLayers;
-Tool         activeTool_;
+Tool                 activeTool_;
-size_t       macroLayerIndex_;
+size_t               macroLayerIndex_;
-size_t       polylineSubLayer_;
+size_t               polylineSubLayer_;
-Primitives   primitives_;
+GeometricPrimitives  primitives_;
-Annotations  annotations_;
+Annotations          annotations_;
-SubLayers    subLayersToRemove_;
+SubLayers            subLayersToRemove_;
 void AddAnnotation(Annotation* annotation)
 {
 assert(annotation != NULL);
 assert(annotations_.find(annotation) == annotations_.end());
 annotations_.erase(annotation);
 delete annotation;
 }
 }
-void DeletePrimitive(Primitive* primitive)
+void DeletePrimitive(GeometricPrimitive* primitive)
 {
 if (primitive != NULL)
 {
 assert(primitives_.find(primitive) != primitives_.end());
 primitives_.erase(primitive);
 subLayersToRemove_.clear();
 std::unique_ptr<PolylineSceneLayer> polyline(new PolylineSceneLayer);
-for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
+for (GeometricPrimitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
 {
 assert(*it != NULL);
-Primitive& primitive = **it;
+GeometricPrimitive& primitive = **it;
 primitive.RenderPolylineLayer(*polyline, scene);
 if (primitive.IsModified())
 {
 bool ClearHover()
 {
 bool needsRefresh = false;
-for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
+for (GeometricPrimitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
 {
 assert(*it != NULL);
 if ((*it)->IsHover())
 {
 (*it)->SetHover(false);
 {
 bool needsRefresh = false;
 const ScenePoint2D s = p.Apply(scene.GetCanvasToSceneTransform());
-for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
+for (GeometricPrimitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
 {
 assert(*it != NULL);
 bool hover = (*it)->IsHit(s, scene);
 if ((*it)->IsHover() != hover)
 }
 else
 {
 const ScenePoint2D s = p.Apply(scene.GetCanvasToSceneTransform());
-Primitive* bestHit = NULL;
+GeometricPrimitive* bestHit = NULL;
-for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
+for (GeometricPrimitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
 {
 assert(*it != NULL);
 if ((*it)->IsHit(s, scene))
 {
 if (bestHit == NULL ||

Mercurial > hg > orthanc-stone

comparison Applications/Samples/Sdl/SingleFrameViewer/SdlSimpleViewer.cpp @ 1801:64dad1d7aca4