Gauge.h

Go to the documentation of this file.

#pragma once

#include "Frame.h"
#include "Signals.h"
#include "Utilities.h"

namespace rose {

    enum class GaugeIndex : unsigned long {
        LowerBound = 0,     
        LowWarning,         
        LowNormal,          
        HighNormal,         
        HighWarning,        
        UpperBound,         
    };

    constexpr inline auto indexValue(const GaugeIndex &g) {
        using IntType = typename std::underlying_type<GaugeIndex>::type;
        return static_cast<IntType>(g);
    }

    inline GaugeIndex& operator++( GaugeIndex &gaugeIndex ) {
        using IntType = typename std::underlying_type<GaugeIndex>::type;
        if (gaugeIndex == GaugeIndex::UpperBound)
            throw std::domain_error("Incrementing GaugeIndex beyond UpperBound.");
        gaugeIndex = static_cast<GaugeIndex>( static_cast<IntType>(gaugeIndex) + 1 );
        return gaugeIndex;
    }

    inline GaugeIndex operator+(const GaugeIndex &gaugeIndex, unsigned long increment) {
        using IntType = typename std::underlying_type<GaugeIndex>::type;
        if (static_cast<IntType>(gaugeIndex) + increment > indexValue(GaugeIndex::UpperBound))
            throw std::domain_error("Incrementing GaugeIndex beyond UpperBound.");
        return static_cast<GaugeIndex>(static_cast<IntType>(gaugeIndex) + increment);
    }

    using GaugeValueLimits = std::array<float,6>;   
    using GaugeValueHues = std::array<uint32_t,5>;   

    class Gauge : public Frame {
    protected:
        class GaugeInterior : public Widget {
        protected:
            friend class Gauge;
            bool mTextureValid{false};                          
            sdl::Texture mTexture{};                            
            Orientation mOrientation{Orientation::Unset};       

            static array<int, 6>
            computeValueBands(GaugeValueLimits gaugeValueLimits, Rectangle rect, Orientation orientation);              

        public:
            GaugeInterior() = default;
            ~GaugeInterior() override = default;                
            GaugeInterior(const Gauge &) = delete;
            GaugeInterior& operator=(const GaugeInterior &) = delete;
            GaugeInterior(GaugeInterior &&) = delete;
            GaugeInterior& operator=(GaugeInterior &&) = delete;

            Rectangle widgetLayout(sdl::Renderer &renderer, Rectangle available, uint layoutStage) override;

            void draw(sdl::Renderer &renderer, Rectangle parentRect) override;

            void setOrientation(Orientation orientation) override { mOrientation = orientation; }
        };

        friend class GaugeInterior;

        static constexpr GaugeValueLimits defaultLimits = {0.f, 0.1f, 0.2f,
                                                           0.8f, 0.9f, 1.f};

        static constexpr GaugeValueHues defaultHues = { 300, 240, 120,
                                                        60, 10};
        float mValue{0.f};                          
        sdl::Texture mTexture{};                    
        int mStripLength{0};                        
        ImageId mIndicator{RoseImageInvalid};       

        GaugeValueLimits mValueLimits;

        GaugeValueHues mValueHues;

        Orientation mOrientation{Orientation::Unset};   

    public:
        ~Gauge() override = default;               
        Gauge(const Gauge &) = delete;
        Gauge& operator=(const Gauge &) = delete;
        Gauge(Gauge &&) = delete;
        Gauge& operator=(Gauge &&) = delete;

        explicit Gauge(ImageId imageId = RoseImageInvalid);

        Gauge(const GaugeValueLimits &gaugeValueLimits, const GaugeValueHues &gaugeValueHuess, ImageId imageId = RoseImageInvalid);

        Gauge(GaugeValueLimits &&gaugeValueLimits, GaugeValueHues &&gaugeValueHues, ImageId imageId = RoseImageInvalid);

        void initializeComposite() override;

        Rectangle widgetLayout(sdl::Renderer &renderer, Rectangle available, uint layoutStage) override;

        void draw(sdl::Renderer &renderer, Rectangle parentRect) override;

        std::shared_ptr<Slot<float>> valueRx;       

        void setValue(float value);

        void setOrientation(Orientation orientation) override;
    };
}