- Start/Stop API

- Improved example

Author: djowel

examples/status_bars/main.cpp

@@ -10,60 +10,78 @@ using cycfi::artist::rgba;
 namespace colors = cycfi::artist::colors;
 using namespace std::chrono_literals;
 
-constexpr auto bred     = colors::red.opacity(0.4);
-constexpr auto bgreen   = colors::green.level(0.7).opacity(0.4);
-constexpr auto brblue   = colors::royal_blue.opacity(0.4);
+constexpr auto bgreen   = colors::green.level(0.7).opacity(0.8);
 constexpr auto pgold    = colors::gold.opacity(0.8);
 
 // Main window background color
 auto constexpr bkd_color = rgba(35, 35, 37, 255);
 auto background = box(bkd_color);
 
+bool run = false;
+template <typename ProgressBar>
+void prog_incr(ProgressBar& prog_bar, view& view_)
+{
+   auto val = prog_bar.value();
+   if (val > 1.0)
+   {
+      prog_bar.value(1.0);
+      run = false;
+   }
+   else
+   {
+      prog_bar.value(val + 0.005);
+   }
+   view_.refresh(prog_bar);
+}
+
+template <typename ProgressBar>
+void prog_animate(ProgressBar& prog_bar, view& view_)
+{
+   if (run)
+   {
+      prog_incr(prog_bar, view_);
+      view_.post(10ms,
+         [&]()
+         {
+            prog_animate(prog_bar, view_);
+         }
+      );
+   }
+}
+
 auto make_bars(view& view_)
 {
    auto prog_bar        = share(progress_bar(rbox(colors::black), rbox(pgold)));
-   auto bsy_bar         = share(busy_bar(rbox(colors::black), rbox(brblue)));
-   auto prog_advance    = icon_button(icons::plus);
-   auto busy_start      = button("I", 1.0, bgreen);
-   auto busy_stop       = button("O", 1.0, bred);
+   auto bsy_bar         = share(busy_bar(rbox(colors::black), rbox(bgreen)));
+   auto start_stop      = toggle_icon_button(icons::play, icons::stop, 2.0);
 
-   prog_advance.on_click =
-      [prog_bar, &view_](bool) mutable
+   start_stop.on_click =
+      [prog_bar, bsy_bar, &view_](bool state) mutable
       {
-         auto val = prog_bar->value();
-         if (val > 0.9)
+         if (state)
+         {
+            bsy_bar->start(view_, 10ms);
+            run = true;
             prog_bar->value(0.0);
+            prog_animate(*prog_bar, view_);
+         }
          else
-            prog_bar->value(val + 0.125);
-         view_.refresh(*prog_bar);
-      };
-
-   busy_stop.on_click =
-      [bsy_bar, &view_](bool) mutable
-      {
-         bsy_bar->animate(view_, 0ms);
-      };
-
-   busy_start.on_click =
-      [bsy_bar, &view_](bool) mutable
-      {
-         bsy_bar->animate(view_, 50ms);
+         {
+            bsy_bar->stop(view_);
+            run = false;
+         }
       };
 
    return
-      margin({20, 0, 20, 20},
-         vtile(
-            margin_top(20, htile(
-               margin_right(3, valign(0.5, prog_advance)),
-               vsize(27, hold(prog_bar))
-            )),
-            margin_top(20, vtile(
-               margin_right(3, htile(
-                  busy_stop,
-                  busy_start
-               )),
+      margin({20, 20, 20, 20},
+         htile(
+            start_stop,
+            hspace(10),
+            vtile(
+               vsize(27, hold(prog_bar)),
+               vspace(10),
                vsize(27, hold(bsy_bar))
-            ))
+            )
          )
       );
 }

lib/include/elements/element/status_bar.hpp

@@ -14,9 +14,6 @@
 
 namespace cycfi::elements
 {
-   ////////////////////////////////////////////////////////////////////////////
-   // Progress Bar
-   ////////////////////////////////////////////////////////////////////////////
    class status_bar_base : public element, public receiver<double>
    {
    public:
@@ -44,14 +41,6 @@ namespace cycfi::elements
       double                  _value;
    };
 
-   class basic_status_bar_base : public status_bar_base
-   {
-   public:
-                              basic_status_bar_base(double init_value)
-                               : status_bar_base(init_value)
-                              {}
-   };
-
    namespace concepts
    {
       template <typename T>
@@ -61,7 +50,7 @@ namespace cycfi::elements
    template <
       concepts::Element Background
     , concepts::Element Foreground
-    , concepts::StatusBar Base = basic_status_bar_base>
+    , concepts::StatusBar Base = status_bar_base>
    class basic_status_bar : public Base
    {
    public:
@@ -92,7 +81,7 @@ namespace cycfi::elements
    };
 
    template <concepts::Element Background, concepts::Element Foreground>
-   basic_status_bar<Background, Foreground, basic_status_bar_base>
+   inline basic_status_bar<Background, Foreground, status_bar_base>
    progress_bar(Background&& bg, Foreground&& fg, double init_value = 0.0)
    {
       return {
@@ -107,54 +96,43 @@ namespace cycfi::elements
    public:
                               busy_bar_base(
                                  double init_value = 0.0
-                               , double start_value = 0.0
+                               , double start_pos = 0.0
                               )
                                : status_bar_base(init_value)
-                               , _start(start_value)
+                               , _start_pos(start_pos)
                                , _status(-0.2)
                               {}
 
-      void                    start(double val);
-      double                  start() const { return _start; }
-      void                    animate(view& view_, duration time);
+      void                    start_pos(double val);
+      double                  start_pos() const { return _start_pos; }
+
+      void                    start(view& view_, duration time);
+      void                    stop(view& view_);
 
       rect                    foreground_bounds(context const& ctx) const override;
 
    private:
 
       void                    animate(view& view_);
 
-      double                  _start;  // Start position
+      double                  _start_pos;
       double                  _status;
       duration                _time;
    };
 
-   class basic_busy_bar_base : public busy_bar_base
-   {
-   public:
-                              basic_busy_bar_base(
-                                 double init_value
-                               , double start_value
-                              )
-                               : busy_bar_base(init_value, start_value)
-                              {}
-   };
-
    template <concepts::Element Background, concepts::Element Foreground>
-   inline basic_status_bar<Background, Foreground, basic_busy_bar_base>
+   inline basic_status_bar<Background, Foreground, busy_bar_base>
    busy_bar(
       Background&& bg
     , Foreground&& fg
     , double init_value = 0.0
-    , double start_value = 0.0
+    , double start_pos = 0.0
    )
    {
       return {
          std::forward<Background>(bg),
          std::forward<Foreground>(fg),
-         init_value,
-         start_value
-      };
+         init_value, start_pos};
    }
 }
 

lib/src/element/status_bar.cpp

@@ -87,9 +87,9 @@ namespace cycfi::elements
    }
 
    // Implement the start method as per the patch
-   void busy_bar_base::start(double val)
+   void busy_bar_base::start_pos(double val)
    {
-      _start = clamp(val, 0.0, 1.0);
+      _start_pos = clamp(val, 0.0, 1.0);
    }
 
    // Implement foreground_bounds to include the start value
@@ -104,32 +104,39 @@ namespace cycfi::elements
 
       // Adjust bounds based on the start value
       if (bounds.width() > bounds.height())
-         bounds.left = bounds.left + (bounds.width() * start());
+         bounds.left = bounds.left + (bounds.width() * start_pos());
       else
-         bounds.bottom = bounds.bottom + (bounds.height() * start());
+         bounds.bottom = bounds.bottom + (bounds.height() * start_pos());
 
       return bounds;
    }
 
-   void busy_bar_base::animate(view& view_, duration time)
+   void busy_bar_base::start(view& view_, duration time)
    {
       _time = time;
       animate(view_);
    }
 
+   void busy_bar_base::stop(view& view_)
+   {
+      using namespace std::chrono_literals;
+      _time = 0ms;
+      animate(view_);
+   }
+
    void busy_bar_base::animate(view& view_)
    {
       if (_time == _time.zero())
       {
          _status = -0.2;
          value(0.0);
-         start(0.0);
+         start_pos(0.0);
          view_.refresh();
          return;
       }
 
       _status += 0.01;
-      start(_status);
+      start_pos(_status);
       value(_status + 0.2);
       if (_status >= 1.0)
          _status = -0.2;