Sprites are no longer reliant on the receiver API

Author: djowel

lib/include/elements/element/dial.hpp

@@ -67,9 +67,7 @@ namespace cycfi::elements
 
                            basic_dial(double init_value = 0.0);
 
-      void                 prepare_subject(context& ctx) override;
       element*             hit_test(context const& ctx, point p, bool leaf, bool control) override;
-
       bool                 scroll(context const& ctx, point dir, point p) override;
       void                 keep_tracking(context const& ctx, tracker_info& track_info) override;
 

lib/include/elements/element/image.hpp

@@ -60,28 +60,6 @@ namespace cycfi::elements
       float                   _scale;
    };
 
-   /**
-    * \class sprite_as_double
-    *
-    * \brief
-    *    A template structure to handle sprite images used as 'double'
-    *    receivers.
-    *
-    *    Receives a 'double' value in the range of 0.0 to 1.0, which
-    *    indicates which frame of the sprite image should be displayed. The
-    *    double value essentially represents the frame number, scaled down to
-    *    fit within the 0.0 to 1.0 range.
-    *
-    * \tparam Derived
-    *    The derived class type.
-    */
-   template <typename Derived>
-   struct sprite_as_double : receiver<double>
-   {
-      void                    value(double val) override;
-      double                  value() const override;
-   };
-
    /**
     * \class basic_sprite
     *
@@ -112,24 +90,7 @@ namespace cycfi::elements
       float                   _height;
    };
 
-   /**
-    * \class sprite
-    *
-    * \brief
-    *    A class representing a sprite image that can be used as controls.
-    *
-    *    `sprite` extends `basic_sprite` to utilize both `sprite_as_int` and
-    *    `sprite_as_double`, making it usable as both an 'int' and a 'double'
-    *    receiver.
-    *
-    *    Sprites are images used as controls. Various frames are laid out in
-    *    a single (big) image but only one frame is drawn at any single time.
-    *    Useful for switches, knobs and basic (sprite) animation.
-    */
-   struct sprite : basic_sprite, sprite_as_double<sprite>
-   {
-      using basic_sprite::basic_sprite;
-   };
+   using sprite = basic_sprite;
 
    namespace detail
    {
@@ -172,43 +133,6 @@ namespace cycfi::elements
    {
       return _index;
    }
-
-   /**
-    * \brief
-    *    Returns the index of the currently displayed frame in
-    *    sprite_as_double as a fraction of the total frames.
-    *
-    * \tparam Derived
-    *    The derived class type.
-    *
-    * \returns
-    *    The index of the currently displayed frame as a fraction of the
-    *    total frames (between 0.0 to 1.0).
-    */
-   template <typename Derived>
-   double sprite_as_double<Derived>::value() const
-   {
-      auto this_ = static_cast<Derived const*>(this);
-      return this_->index() / this_->num_frames()-1;
-   }
-
-   /**
-    * \brief
-    *    Sets the index of the sprite_as_double to the provided value.
-    *
-    * \tparam Derived
-    *    The derived class type.
-    *
-    * \param val
-    *    The value to set the index to. It's a value between 0.0 and 1.0
-    *    representing the relative position in the sequence of frames.
-    */
-   template <typename Derived>
-   void sprite_as_double<Derived>::value(double val)
-   {
-      auto this_ = static_cast<Derived*>(this);
-      this_->index(val * (this_->num_frames()-1));
-   }
 }
 
 #endif

lib/include/elements/element/style/sprite_dial.hpp

@@ -12,19 +12,52 @@
 
 namespace cycfi::elements
 {
+   template <typename Subject>
+   class sprite_dial_styler : public proxy<Subject>
+   {
+   public:
+
+      using base_type = proxy<Subject>;
+
+                              sprite_dial_styler(Subject subject);
+
+      void                    draw(context const& ctx) override;
+   };
+
    template <concepts::SpriteSubject Styler>
-   inline proxy<remove_cvref_t<Styler>, basic_dial>
+   inline proxy<sprite_dial_styler<remove_cvref_t<Styler>>, basic_dial>
    dial(Styler&& styler, double init_value = 0.0);
 
    //--------------------------------------------------------------------------
    // Inlines
    //--------------------------------------------------------------------------
 
+   template <typename Subject>
+   inline sprite_dial_styler<Subject>::sprite_dial_styler(Subject subject)
+    : base_type{std::move(subject)}
+   {}
+
+   template <typename Subject>
+   inline void sprite_dial_styler<Subject>::draw(context const& ctx)
+   {
+      auto dial = find_parent<basic_dial*>(ctx);
+      if (!dial)
+         return;
+
+      auto sp = find_subject<sprite*>(this);
+      if (sp)
+      {
+         sp->index(dial->value() * (sp->num_frames()-1));
+         sp->draw(ctx);
+      }
+   }
+
    template <concepts::SpriteSubject Styler>
-   inline proxy<remove_cvref_t<Styler>, basic_dial>
+   inline proxy<sprite_dial_styler<remove_cvref_t<Styler>>, basic_dial>
    dial(Styler&& styler, double init_value)
    {
-      return {std::forward<Styler>(styler), init_value};
+      using styler_type = sprite_dial_styler<remove_cvref_t<Styler>>;
+      return {styler_type{std::forward<Styler>(styler)}, init_value};
    }
 }
 

lib/src/element/dial.cpp

@@ -20,18 +20,9 @@ namespace cycfi::elements
       clamp(_value, 0.0, 1.0);
    }
 
-   void basic_dial::prepare_subject(context& ctx)
-   {
-      proxy_base::prepare_subject(ctx);
-      if (auto* rcvr = find_subject<receiver<double>*>(this))
-         rcvr->value(_value);
-   }
-
    void basic_dial::value(double val)
    {
       _value = clamp(val, 0.0, 1.0);
-      if (auto* rcvr = find_subject<receiver<double>*>(this))
-         rcvr->value(_value);
    }
 
    namespace
@@ -44,10 +35,9 @@ namespace cycfi::elements
       }
    }
 
-   void basic_dial::edit(view& view_, param_type val)
+   void basic_dial::edit(view& /*view_*/, param_type val)
    {
       edit_value(this, val);
-      receiver<double>::notify_edit(view_);
    }
 
    double basic_dial::radial_value(context const& ctx, tracker_info& track_info)