TimeBox.h

Go to the documentation of this file.

#pragma once

#include <utility>
#include <atomic>

#include "Layout.h"
#include "Signals.h"
#include "TimerTick.h"
#include "LocalTime.h"

namespace rose {

    class TimeBox : public Manager {
    protected:
        static constexpr std::string_view HoursMinutesFmt = "%R";
        static constexpr std::string_view LongSecondsFmt = "%S %Z";
        static constexpr std::string_view ShortSecondsFmt = "%Z";

        std::unique_ptr<cpp_local_time::LocalTime> mLocalTimeConvert{};

        std::shared_ptr<TimerTick> mTimerTick{};      
        bool mDisplaySeconds{true}; 
        bool mLocalTime{false};     
        std::string mTimeZone{};    

        TickProtocol::slot_type secondSlot{};   
        const std::time_put<char> &locale_time_put;

        void initialize();

        auto put_locale_time(std::stringstream &strm, char fill, const std::tm *tm, const std::string_view &format) {
            auto fmt = std::string{format};
            if (fmt.empty()) {
                throw std::runtime_error("Format must not be empty");
            } else {
                const char *fmtbeg = fmt.c_str();
                const char *fmtend = fmtbeg + fmt.size();
                return locale_time_put.put(strm, strm, fill, tm, fmtbeg, fmtend);
            }
        }

        void updateTimeDisplay();

    public:
        TimeBox() = delete;

        ~TimeBox() override = default;

        TimeBox(const TimeBox&) = delete;

        TimeBox(TimeBox&&) = delete;

        TimeBox& operator=(const TimeBox&) = delete;

        TimeBox& operator=(TimeBox&&) = delete;

        explicit TimeBox(std::shared_ptr<TimerTick> timerTick);

        TimeBox(std::shared_ptr<TimerTick> timerTick, bool seconds, bool localTime = false) : TimeBox(std::move(timerTick)) {
            mDisplaySeconds = seconds;
            mLocalTime = localTime;
        }

        TimeBox(std::shared_ptr<TimerTick> timerTick, const char *timeZone, bool seconds = true) : TimeBox(std::move(timerTick)) {
            mDisplaySeconds = seconds;
            mTimeZone = timeZone;
        }

        TimeBox(std::shared_ptr<TimerTick> timerTick, const std::string &timeZone, bool seconds = true) : TimeBox(std::move(timerTick)) {
            mDisplaySeconds = seconds;
            mTimeZone = timeZone;
        }

        static constexpr std::string_view id = "TimeBox";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        void draw(gm::Context &context, const Position<int>& containerPosition) override;

        Rectangle layout(gm::Context &context, const Rectangle &screenRect) override;
    };

    class DateBox : public Manager {
    protected:
        static constexpr std::string_view LongDateFormat = "%a %b %d, %Y";
        static constexpr std::string_view ShortDateFormat = "%a %b %d";

        std::unique_ptr<cpp_local_time::LocalTime> mLocalTimeConvert{};

        bool mDisplayYear{true};
        bool mLocalTime{false};     
        std::string mTimeZone{};    
        std::shared_ptr<TimerTick> mTimerTick{};      

        TickProtocol::slot_type minuteSlot{};   
        const std::time_put<char> &locale_time_put;

        void initialize();

        auto put_locale_time(std::stringstream &strm, char fill, const std::tm *tm, const std::string_view &format) {
            auto fmt = std::string{format};
            if (fmt.empty()) {
                throw std::runtime_error("Format must not be empty");
            } else {
                const char *fmtbeg = fmt.c_str();
                const char *fmtend = fmtbeg + fmt.size();
                return locale_time_put.put(strm, strm, fill, tm, fmtbeg, fmtend);
            }
        }

        void updateDateDisplay();

    public:
        DateBox() = delete;

        ~DateBox() override = default;

        DateBox(const DateBox&) = delete;

        DateBox(DateBox&&) = delete;

        DateBox& operator=(const DateBox&) = delete;

        DateBox& operator=(DateBox&&) = delete;

        explicit DateBox(std::shared_ptr<TimerTick> minutes);

        DateBox(std::shared_ptr<TimerTick> timerTick, bool year, bool localTime = false) : DateBox(std::move(timerTick)) {
            mDisplayYear = year;
            mLocalTime = localTime;
        }

        DateBox(std::shared_ptr<TimerTick> timerTick, const char *timeZone, bool year = true) : DateBox(std::move(timerTick)) {
            mDisplayYear = year;
            mTimeZone = timeZone;
        }

        DateBox(std::shared_ptr<TimerTick> timerTick, const std::string &timeZone, bool year = true) : DateBox(std::move(timerTick)) {
            mDisplayYear = year;
            mTimeZone = timeZone;
        }

        static constexpr std::string_view id = "DateBox";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        void draw(gm::Context &context, const Position<int>& containerPosition) override;

        Rectangle layout(gm::Context &context, const Rectangle &screenRect) override;
    };

    class TimeDateBox : public Manager {
    protected:
        bool mDisplaySecond{};
        bool mDisplayYear{};
        bool mLocalTime{};
        std::string mTimeZone{};
        std::shared_ptr<TimerTick> mTick{};

        void initialize();

    public:
        TimeDateBox() = delete;

        ~TimeDateBox() override = default;

        TimeDateBox(const TimeDateBox&) = delete;

        TimeDateBox(TimeDateBox&&) = delete;

        TimeDateBox& operator=(const TimeDateBox&) = delete;

        TimeDateBox& operator=(TimeDateBox&&) = delete;

        explicit TimeDateBox(std::shared_ptr<TimerTick> tick);

        TimeDateBox(std::shared_ptr<TimerTick> timerTick, bool second, bool year, bool localTime = false) : TimeDateBox(std::move(timerTick)) {
            mDisplayYear = year;
            mDisplaySecond = second;
            mLocalTime = localTime;
        }

        TimeDateBox(std::shared_ptr<TimerTick> timerTick, const char *timeZone, bool second, bool year = true) : TimeDateBox(std::move(timerTick)) {
            mDisplayYear = year;
            mDisplaySecond = second;
            mTimeZone = timeZone;
        }

        TimeDateBox(std::shared_ptr<TimerTick> timerTick, const std::string &timeZone, bool second, bool year = true) : TimeDateBox(std::move(timerTick)) {
            mDisplayYear = year;
            mDisplaySecond = second;
            mTimeZone = timeZone;
        }

        static constexpr std::string_view id = "TimeDateBox";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        void draw(gm::Context &context, const Position<int>& containerPosition) override;

        Rectangle layout(gm::Context &context, const Rectangle &screenRect) override;
    };
}