LinearScale.h

Go to the documentation of this file.

#pragma once

#include "Border.h"
#include "Frame.h"
#include "ImageView.h"
#include "Signals.h"

namespace rose {

    using namespace std;

    enum class LinearScaleIndicator {
        RoundThumb,
        SquareThumb,
        SingleChannel,
        DualChannel,
    };

    class LinearScale : public Frame {
    protected:
        LinearScaleIndicator mLinearScaleInd{};         
        SignalSerialNumber mSignalSerialNumber{};       
        Orientation mOrientation{Orientation::Unset};   

        float mLowerBound0{0.f};                
        float mUpperBound0{1.f};                
        float mValue0{0.f};                     

        float mLowerBound1{0.f};                
        float mUpperBound1{1.f};                
        float mValue1{0.f};                     

        ImageId mImageId0{RoseImageInvalid};    
        ImageId mImageId1{RoseImageInvalid};    

        Rectangle mImageRect0{};                
        Rectangle mImageRect1{};                

        Rectangle getIndicatorRectangle(ImageId imageId);   

        void setThumbOffset(float offset, float maxOffset);

#if 0

        class LinearScaleBorder : public Border {
        public:
            LinearScaleBorder() = default;
            ~LinearScaleBorder() override = default;
            LinearScaleBorder(const LinearScaleBorder &) = delete;
            LinearScaleBorder(LinearScaleBorder &&) = delete;
            LinearScaleBorder& operator=(const LinearScaleBorder &) = delete;
            LinearScaleBorder& operator=(LinearScaleBorder &&) = delete;

            explicit LinearScaleBorder(int border) : Border(border) {}

            void initializeComposite() override;

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

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

        class LinearScaleImage : public ImageView {
        public:
            LinearScaleImage() = default;
            ~LinearScaleImage() override = default;
            LinearScaleImage(const LinearScaleImage &) = delete;
            LinearScaleImage(LinearScaleImage &&) = delete;
            LinearScaleImage& operator=(const LinearScaleImage &) = delete;
            LinearScaleImage& operator=(LinearScaleImage &&) = delete;

            explicit LinearScaleImage(ImageId imageId) : ImageView(imageId) {}

            void initializeComposite() override;

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

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

//        shared_ptr<LinearScaleBorder> mBorder{};       ///< The Border inside the Frame.
        shared_ptr<LinearScaleImage> mIndicator{}; 

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

        explicit LinearScale(LinearScaleIndicator linearScaleIndicator);

        LinearScale(float lowerBound, float upperBound, float value, LinearScaleIndicator linearScaleIndicator);

        void initializeComposite() override;

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

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

        using ScaledSignal = std::array<float,3>;
        std::shared_ptr<Slot<ScaledSignal>> rxScaledValue0{};   

        std::shared_ptr<Slot<ScaledSignal>> rxScaledValue1{};   

        void setOrientation(Orientation orientation) override {
            mOrientation = orientation;
            rose()->needsLayout();
        }

        virtual void initializeBorderComposite();

        virtual Rectangle initialBorderLayout(sdl::Renderer &renderer, Rectangle available, Rectangle borderLayout);

        virtual void drawBorder(sdl::Renderer &renderer, Rectangle available);

        virtual void initializeImageComposite();

        virtual Rectangle initialImageLayout(sdl::Renderer &renderer, Rectangle available, Rectangle imageLayout);

        virtual void drawImage(sdl::Renderer &renderer, Rectangle available);
    };
}