RotationItems: refactor inheritance and interfaces

GUI/Model/FromCore/ItemizeSample.cpp

@@ -325,21 +325,21 @@ void setRotation(ItemWithParticles* parent, const IRotation* rotation)
         parent->setRotation(nullptr);
     else if (const auto* r = dynamic_cast<const RotationX*>(rotation)) {
         auto* item = new XRotationItem();
-        item->angle().set(Units::rad2deg(r->angle()));
+        item->setAngle(Units::rad2deg(r->angle()));
         parent->setRotation(item);
     } else if (const auto* r = dynamic_cast<const RotationY*>(rotation)) {
         auto* item = new YRotationItem();
-        item->angle().set(Units::rad2deg(r->angle()));
+        item->setAngle(Units::rad2deg(r->angle()));
         parent->setRotation(item);
     } else if (const auto* r = dynamic_cast<const RotationZ*>(rotation)) {
         auto* item = new ZRotationItem();
-        item->angle().set(Units::rad2deg(r->angle()));
+        item->setAngle(Units::rad2deg(r->angle()));
         parent->setRotation(item);
     } else if (const auto* r = dynamic_cast<const RotationEuler*>(rotation)) {
         auto* item = new EulerRotationItem();
-        item->alpha().set(Units::rad2deg(r->alpha()));
-        item->beta().set(Units::rad2deg(r->beta()));
-        item->gamma().set(Units::rad2deg(r->gamma()));
+        item->setAlpha(Units::rad2deg(r->alpha()));
+        item->setBeta(Units::rad2deg(r->beta()));
+        item->setGamma(Units::rad2deg(r->gamma()));
         parent->setRotation(item);
     }
 }

GUI/Model/Sample/RotationItems.cpp

@@ -43,25 +43,23 @@ RotMatrix RotationItem::rotation() const
 
 // ----------------------------------------------------------------------------
 
-XRotationItem::XRotationItem()
-{
-    m_angle.init("Angle", "Rotation angle around x-axis", 0.0, Unit::degree, "angle");
-}
 
-void XRotationItem::serialize(Streamer& s)
+void XYZRotationItem::serialize(Streamer& s)
 {
     s.assertVersion(0);
     Serialize::rwProperty(s, Tag::Angle, m_angle);
 }
 
-unique_ptr<IRotation> XRotationItem::createRotation() const
+// ----------------------------------------------------------------------------
+
+XRotationItem::XRotationItem()
 {
-    return std::make_unique<RotationX>(deg2rad(angle()));
+    m_angle.init("Angle", "Rotation angle around x-axis", 0.0, Unit::degree, "angle");
 }
 
-DoubleDescriptor XRotationItem::angle() const
+unique_ptr<IRotation> XRotationItem::createRotation() const
 {
-    return m_angle;
+    return std::make_unique<RotationX>(deg2rad(m_angle.get()));
 }
 
 // ----------------------------------------------------------------------------
@@ -71,20 +69,9 @@ YRotationItem::YRotationItem()
     m_angle.init("Angle", "Rotation angle around y-axis", 0.0, Unit::degree, "angle");
 }
 
-void YRotationItem::serialize(Streamer& s)
-{
-    s.assertVersion(0);
-    Serialize::rwProperty(s, Tag::Angle, m_angle);
-}
-
 unique_ptr<IRotation> YRotationItem::createRotation() const
 {
-    return std::make_unique<RotationY>(deg2rad(angle()));
-}
-
-DoubleDescriptor YRotationItem::angle() const
-{
-    return m_angle;
+    return std::make_unique<RotationY>(deg2rad(m_angle.get()));
 }
 
 // ----------------------------------------------------------------------------
@@ -94,20 +81,9 @@ ZRotationItem::ZRotationItem()
     m_angle.init("Angle", "Rotation angle around z-axis", 0.0, Unit::degree, "angle");
 }
 
-void ZRotationItem::serialize(Streamer& s)
-{
-    s.assertVersion(0);
-    Serialize::rwProperty(s, Tag::Angle, m_angle);
-}
-
 unique_ptr<IRotation> ZRotationItem::createRotation() const
 {
-    return std::make_unique<RotationZ>(deg2rad(angle()));
-}
-
-DoubleDescriptor ZRotationItem::angle() const
-{
-    return m_angle;
+    return std::make_unique<RotationZ>(deg2rad(m_angle.get()));
 }
 
 // ----------------------------------------------------------------------------
@@ -129,20 +105,6 @@ void EulerRotationItem::serialize(Streamer& s)
 
 unique_ptr<IRotation> EulerRotationItem::createRotation() const
 {
-    return std::make_unique<RotationEuler>(deg2rad(alpha()), deg2rad(beta()), deg2rad(gamma()));
-}
-
-DoubleDescriptor EulerRotationItem::alpha() const
-{
-    return m_alpha;
-}
-
-DoubleDescriptor EulerRotationItem::beta() const
-{
-    return m_beta;
-}
-
-DoubleDescriptor EulerRotationItem::gamma() const
-{
-    return m_gamma;
+    return std::make_unique<RotationEuler>(deg2rad(m_alpha.get()), deg2rad(m_beta.get()),
+                                           deg2rad(m_gamma.get()));
 }

GUI/Model/Sample/RotationItems.h

@@ -36,49 +36,39 @@ protected:
     virtual unique_ptr<IRotation> createRotation() const = 0;
 };
 
-class XRotationItem : public RotationItem {
+class XYZRotationItem : public RotationItem {
 public:
-    XRotationItem();
     void serialize(Streamer& s) override;
     DoubleDescriptors rotationValues() const override { return {m_angle}; };
 
-    DoubleDescriptor angle() const;
+    void setAngle(double v) { m_angle.set(v); }
 
 protected:
-    unique_ptr<IRotation> createRotation() const override;
-
-private:
     DoubleProperty m_angle;
 };
 
-class YRotationItem : public RotationItem {
+class XRotationItem : public XYZRotationItem {
 public:
-    YRotationItem();
-    void serialize(Streamer& s) override;
-    DoubleDescriptors rotationValues() const override { return {m_angle}; };
-
-    DoubleDescriptor angle() const;
+    XRotationItem();
 
 protected:
     unique_ptr<IRotation> createRotation() const override;
+};
 
-private:
-    DoubleProperty m_angle;
+class YRotationItem : public XYZRotationItem {
+public:
+    YRotationItem();
+
+protected:
+    unique_ptr<IRotation> createRotation() const override;
 };
 
-class ZRotationItem : public RotationItem {
+class ZRotationItem : public XYZRotationItem {
 public:
     ZRotationItem();
-    void serialize(Streamer& s) override;
-    DoubleDescriptors rotationValues() const override { return {m_angle}; };
-
-    DoubleDescriptor angle() const;
 
 protected:
     unique_ptr<IRotation> createRotation() const override;
-
-private:
-    DoubleProperty m_angle;
 };
 
 class EulerRotationItem : public RotationItem {
@@ -87,9 +77,9 @@ public:
     void serialize(Streamer& s) override;
     DoubleDescriptors rotationValues() const override { return {m_alpha, m_beta, m_gamma}; };
 
-    DoubleDescriptor alpha() const;
-    DoubleDescriptor beta() const;
-    DoubleDescriptor gamma() const;
+    void setAlpha(double v) { m_alpha.set(v); }
+    void setBeta(double v) { m_beta.set(v); }
+    void setGamma(double v) { m_gamma.set(v); }
 
 protected:
     unique_ptr<IRotation> createRotation() const override;