cycle_box.hpp

#ifndef TERMOX_WIDGET_WIDGETS_CYCLE_BOX_HPP
#define TERMOX_WIDGET_WIDGETS_CYCLE_BOX_HPP
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
 
#include <signals_light/signal.hpp>
 
#include <termox/painter/glyph.hpp>
#include <termox/painter/glyph_string.hpp>
#include <termox/system/key.hpp>
#include <termox/system/mouse.hpp>
#include <termox/widget/align.hpp>
#include <termox/widget/growth.hpp>
#include <termox/widget/tuple.hpp>
#include <termox/widget/widgets/label.hpp>
#include <termox/widget/widgets/tile.hpp>
 
// TODO Indicate in focus with color or trait change.
 
namespace ox {
 
 
class Cycle_box : public HLabel {
   public:
    struct Parameters {
        Align alignment        = Align::Center;
        int extra_left         = 0;
        int extra_right        = 0;
        Growth growth_strategy = Growth::Static;
    };
 
   public:
    sl::Signal<void(std::string)> option_changed;
 
   public:
    explicit Cycle_box(Align alignment        = Align::Center,
                       int extra_left         = 0,
                       int extra_right        = 0,
                       Growth growth_strategy = Growth::Static);
 
    explicit Cycle_box(Parameters p);
 
   public:
 
    auto add_option(Glyph_string label) -> sl::Signal<void()>&;
 
 
    void remove_option(Glyph_string const& label);
 
    void next();
 
    void previous();
 
 
    void set_current_option(std::string const& label);
 
 
    void set_current_option(std::size_t index);
 
    [[nodiscard]] auto size() const -> std::size_t;
 
   protected:
    auto mouse_press_event(Mouse const& m) -> bool override;
 
    auto mouse_wheel_event(Mouse const& m) -> bool override;
 
    auto key_press_event(Key k) -> bool override;
 
   private:
    struct Option {
        Glyph_string name;
        sl::Signal<void()> enabled = {};
    };
 
   private:
    std::vector<Option> options_;
    std::size_t index_ = 0;
 
   private:
    [[nodiscard]] auto current_option_label() const -> Glyph_string;
 
    [[nodiscard]] auto find(std::string const& label)
        -> decltype(options_)::iterator;
 
    void emit_signals();
};
 
[[nodiscard]] auto cycle_box(Cycle_box::Parameters = {})
    -> std::unique_ptr<Cycle_box>;
 
class Labeled_cycle_box : public HTuple<HLabel, Tile, Cycle_box> {
   public:
    struct Parameters {
        Glyph_string label = U"";
    };
 
   public:
    HLabel& label        = this->get<0>();
    Tile& div            = this->get<1>();
    Cycle_box& cycle_box = this->get<2>();
 
   public:
    explicit Labeled_cycle_box(Glyph_string title = U"");
 
    explicit Labeled_cycle_box(Parameters p);
};
 
[[nodiscard]] auto labeled_cycle_box(Glyph_string label = U"")
    -> std::unique_ptr<Labeled_cycle_box>;
 
[[nodiscard]] auto labeled_cycle_box(Labeled_cycle_box::Parameters p)
    -> std::unique_ptr<Labeled_cycle_box>;
 
}  // namespace ox
 
namespace ox::slot {
 
[[nodiscard]] auto add_option(Cycle_box& cb) -> sl::Slot<void(Glyph_string)>;
 
[[nodiscard]] auto add_option(Cycle_box& cb, Glyph_string const& label)
    -> sl::Slot<void()>;
 
[[nodiscard]] auto remove_option(Cycle_box& cb)
    -> sl::Slot<void(std::string const&)>;
 
[[nodiscard]] auto remove_option(Cycle_box& cb, std::string const& label)
    -> sl::Slot<void()>;
 
[[nodiscard]] auto next(Cycle_box& cb) -> sl::Slot<void()>;
 
[[nodiscard]] auto previous(Cycle_box& cb) -> sl::Slot<void()>;
 
}  // namespace ox::slot
#endif  // TERMOX_WIDGET_WIDGETS_CYCLE_BOX_HPP