spinner.hpp

#ifndef TERMOX_WIDGET_WIDGET_SPINNER_HPP
#define TERMOX_WIDGET_WIDGET_SPINNER_HPP
#include <chrono>
#include <memory>
#include <utility>
 
#include <termox/painter/glyph_string.hpp>
#include <termox/widget/widget.hpp>
 
namespace ox {
class Painter;
 
class Spinner : public Widget {
   public:
    using Duration_t = std::chrono::milliseconds;
 
    struct Parameters {
        Glyph_string frames;
        Duration_t period = Duration_t{100};
        int width         = 1;
        int offset        = 0;
    };
 
   public:
    explicit Spinner(Glyph_string frames,
                     Duration_t period = Duration_t{100},
                     int width         = 1,
                     int offset        = 0);
 
    explicit Spinner(Parameters p);
 
   public:
    void set_frames(Glyph_string frames);
 
    [[nodiscard]] auto frames() const noexcept -> Glyph_string const&;
 
    void set_period(Duration_t period);
 
    [[nodiscard]] auto period() const noexcept -> Duration_t;
 
    void set_width(int width);
 
    [[nodiscard]] auto spinner_width() const noexcept -> int;
 
    void set_offset(int offset);
 
   public:
    void start();
 
    void stop();
 
   protected:
    auto paint_event(Painter& p) -> bool override;
 
    auto timer_event() -> bool override;
 
   private:
    bool started_ = false;
    Glyph_string frames_;
    Duration_t period_;
    int width_;
    int index_;
};
 
[[nodiscard]] auto spinner(
    Glyph_string frames,
    Spinner::Duration_t period = Spinner::Duration_t{100},
    int width                  = 1,
    int offset                 = 0) -> std::unique_ptr<Spinner>;
 
[[nodiscard]] auto spinner(Spinner::Parameters p) -> std::unique_ptr<Spinner>;
 
 
struct Spinner_cycle : Spinner {
    struct Parameters {
        Duration_t period = Duration_t{100};
        int width         = 1;
        int offset        = 0;
    };
 
    explicit Spinner_cycle(Duration_t period = Duration_t{100},
                           int width         = 1,
                           int offset        = 0);
 
    explicit Spinner_cycle(Parameters p);
};
 
[[nodiscard]] auto spinner_cycle(
    Spinner::Duration_t period = Spinner::Duration_t{100},
    int width                  = 1,
    int offset                 = 0) -> std::unique_ptr<Spinner_cycle>;
 
[[nodiscard]] auto spinner_cycle(Spinner_cycle::Parameters p)
    -> std::unique_ptr<Spinner_cycle>;
 
struct Spinner_cycle_ccw : Spinner {
    Spinner_cycle_ccw(Duration_t period = Duration_t{100},
                      int width         = 1,
                      int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_cycle_ccw(Args&&... args)
    -> std::unique_ptr<Spinner_cycle_ccw>
{
    return std::make_unique<Spinner_cycle_ccw>(std::forward<Args>(args)...);
}
 
struct Spinner_fall : Spinner {
    Spinner_fall(Duration_t period = Duration_t{100},
                 int width         = 1,
                 int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_fall(Args&&... args) -> std::unique_ptr<Spinner_fall>
{
    return std::make_unique<Spinner_fall>(std::forward<Args>(args)...);
}
 
struct Spinner_fall_two : Spinner {
    Spinner_fall_two(Duration_t period = Duration_t{100},
                     int width         = 1,
                     int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_fall_two(Args&&... args)
    -> std::unique_ptr<Spinner_fall_two>
{
    return std::make_unique<Spinner_fall_two>(std::forward<Args>(args)...);
}
 
struct Spinner_fall_three : Spinner {
    Spinner_fall_three(Duration_t period = Duration_t{100},
                       int width         = 1,
                       int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_fall_three(Args&&... args)
    -> std::unique_ptr<Spinner_fall_three>
{
    return std::make_unique<Spinner_fall_three>(std::forward<Args>(args)...);
}
 
struct Spinner_rise : Spinner {
    Spinner_rise(Duration_t period = Duration_t{100},
                 int width         = 1,
                 int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_rise(Args&&... args) -> std::unique_ptr<Spinner_rise>
{
    return std::make_unique<Spinner_rise>(std::forward<Args>(args)...);
}
 
struct Spinner_rise_two : Spinner {
    Spinner_rise_two(Duration_t period = Duration_t{100},
                     int width         = 1,
                     int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_rise_two(Args&&... args)
    -> std::unique_ptr<Spinner_rise_two>
{
    return std::make_unique<Spinner_rise_two>(std::forward<Args>(args)...);
}
 
struct Spinner_rise_three : Spinner {
    Spinner_rise_three(Duration_t period = Duration_t{100},
                       int width         = 1,
                       int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_rise_three(Args&&... args)
    -> std::unique_ptr<Spinner_rise_three>
{
    return std::make_unique<Spinner_rise_three>(std::forward<Args>(args)...);
}
 
struct Spinner_fill : Spinner {
    Spinner_fill(Duration_t period = Duration_t{100},
                 int width         = 1,
                 int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_fill(Args&&... args) -> std::unique_ptr<Spinner_fill>
{
    return std::make_unique<Spinner_fill>(std::forward<Args>(args)...);
}
 
struct Spinner_top_fill : Spinner {
    Spinner_top_fill(Duration_t period = Duration_t{100},
                     int width         = 1,
                     int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_top_fill(Args&&... args)
    -> std::unique_ptr<Spinner_top_fill>
{
    return std::make_unique<Spinner_top_fill>(std::forward<Args>(args)...);
}
 
struct Spinner_tail : Spinner {
    Spinner_tail(Duration_t period = Duration_t{100},
                 int width         = 1,
                 int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_tail(Args&&... args) -> std::unique_ptr<Spinner_tail>
{
    return std::make_unique<Spinner_tail>(std::forward<Args>(args)...);
}
 
struct Spinner_switch : Spinner {
    Spinner_switch(Duration_t period = Duration_t{100},
                   int width         = 1,
                   int offset        = 0);
};
 
template <typename... Args>
auto spinner_switch(Args&&... args) -> std::unique_ptr<Spinner_switch>
{
    return std::make_unique<Spinner_switch>(std::forward<Args>(args)...);
}
 
struct Spinner_chase : Spinner {
    Spinner_chase(Duration_t period = Duration_t{100},
                  int width         = 1,
                  int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_chase(Args&&... args)
    -> std::unique_ptr<Spinner_chase>
{
    return std::make_unique<Spinner_chase>(std::forward<Args>(args)...);
}
 
struct Spinner_line : Spinner {
    Spinner_line(Duration_t period = Duration_t{100},
                 int width         = 1,
                 int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_line(Args&&... args) -> std::unique_ptr<Spinner_line>
{
    return std::make_unique<Spinner_line>(std::forward<Args>(args)...);
}
 
struct Spinner_block_cycle : Spinner {
    Spinner_block_cycle(Duration_t period = Duration_t{100},
                        int width         = 1,
                        int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_block_cycle(Args&&... args)
    -> std::unique_ptr<Spinner_block_cycle>
{
    return std::make_unique<Spinner_block_cycle>(std::forward<Args>(args)...);
}
 
struct Spinner_fade : Spinner {
    Spinner_fade(Duration_t period = Duration_t{100},
                 int width         = 1,
                 int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_fade(Args&&... args) -> std::unique_ptr<Spinner_fade>
{
    return std::make_unique<Spinner_fade>(std::forward<Args>(args)...);
}
 
struct Spinner_fade_trail : Spinner {
    Spinner_fade_trail(Duration_t period = Duration_t{100},
                       int width         = 1,
                       int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_fade_trail(Args&&... args)
    -> std::unique_ptr<Spinner_fade_trail>
{
    return std::make_unique<Spinner_fade_trail>(std::forward<Args>(args)...);
}
 
struct Spinner_quarter_circles : Spinner {
    Spinner_quarter_circles(Duration_t period = Duration_t{100},
                            int width         = 1,
                            int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_quarter_circles(Args&&... args)
    -> std::unique_ptr<Spinner_quarter_circles>
{
    return std::make_unique<Spinner_quarter_circles>(
        std::forward<Args>(args)...);
}
 
struct Spinner_triangles : Spinner {
    Spinner_triangles(Duration_t period = Duration_t{100},
                      int width         = 1,
                      int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_triangles(Args&&... args)
    -> std::unique_ptr<Spinner_triangles>
{
    return std::make_unique<Spinner_triangles>(std::forward<Args>(args)...);
}
 
struct Spinner_empty_triangles : Spinner {
    Spinner_empty_triangles(Duration_t period = Duration_t{100},
                            int width         = 1,
                            int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_empty_triangles(Args&&... args)
    -> std::unique_ptr<Spinner_empty_triangles>
{
    return std::make_unique<Spinner_empty_triangles>(
        std::forward<Args>(args)...);
}
 
struct Spinner_clock : Spinner {
    Spinner_clock(Duration_t period = Duration_t{100},
                  int width         = 1,
                  int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_clock(Args&&... args)
    -> std::unique_ptr<Spinner_clock>
{
    return std::make_unique<Spinner_clock>(std::forward<Args>(args)...);
}
 
struct Spinner_box : Spinner {
    Spinner_box(Duration_t period = Duration_t{100},
                int width         = 1,
                int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_box(Args&&... args) -> std::unique_ptr<Spinner_box>
{
    return std::make_unique<Spinner_box>(std::forward<Args>(args)...);
}
 
struct Spinner_cross : Spinner {
    Spinner_cross(Duration_t period = Duration_t{100},
                  int width         = 1,
                  int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_cross(Args&&... args)
    -> std::unique_ptr<Spinner_cross>
{
    return std::make_unique<Spinner_cross>(std::forward<Args>(args)...);
}
 
struct Spinner_vertical_pass : Spinner {
   public:
    Spinner_vertical_pass(Duration_t period = Duration_t{100},
                          int width         = 1,
                          int offset        = 0);
 
   private:
    [[nodiscard]] auto first() -> Glyph_string;
 
    [[nodiscard]] auto second() -> Glyph_string;
};
 
template <typename... Args>
[[nodiscard]] auto spinner_vertical_pass(Args&&... args)
    -> std::unique_ptr<Spinner_vertical_pass>
{
    return std::make_unique<Spinner_vertical_pass>(std::forward<Args>(args)...);
}
 
struct Spinner_horizontal_pass : Spinner {
   public:
    Spinner_horizontal_pass(Duration_t period = Duration_t{100},
                            int width         = 1,
                            int offset        = 0);
 
   private:
    [[nodiscard]] auto first() -> Glyph_string;
 
    [[nodiscard]] auto second() -> Glyph_string;
};
 
template <typename... Args>
[[nodiscard]] auto spinner_horizontal_pass(Args&&... args)
    -> std::unique_ptr<Spinner_horizontal_pass>
{
    return std::make_unique<Spinner_horizontal_pass>(
        std::forward<Args>(args)...);
}
 
struct Spinner_bump : Spinner {
    Spinner_bump(Duration_t period = Duration_t{100},
                 int width         = 1,
                 int offset        = 0);
};
 
template <typename... Args>
[[nodiscard]] auto spinner_bump(Args&&... args) -> std::unique_ptr<Spinner_bump>
{
    return std::make_unique<Spinner_bump>(std::forward<Args>(args)...);
}
 
}  // namespace ox
#endif  // TERMOX_WIDGET_WIDGET_SPINNER_HPP