GUIRange.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef GUIRANGE__H_
#define GUIRANGE__H_
 
#include "GUIStreamableObject.h"
#include "eC_Math.h"
 
 
 
class CGUIRange : public CGUIStreamableObject
{
public:
 
    enum Base_t
    {
        BASE_AT_MINIMUM,
        BASE_AT_MAXIMUM
    };
 
    CGUIRange() :
        m_vPercentValue(eC_FromInt(0)),
        m_iValue(0),
        m_uiStepSize(1),
        m_iMaxValue(1),
        m_iMinValue(0),
        m_eBase(BASE_AT_MINIMUM),
        m_bMaximumLevelIsAlwaysValid(false)
    {}
 
    CGUIRange(
        eC_Int iValue,
        eC_Int iMinValue,
        eC_Int iMaxValue,
        eC_UInt uiStepSize = 1,
        Base_t eBase = BASE_AT_MINIMUM,
        eC_Bool bExtremeLevelsAreAlwaysValid = false) :
        m_vPercentValue(eC_FromInt(0)),
        m_iValue(0),
        m_uiStepSize(1),
        m_iMaxValue(1),
        m_iMinValue(0),
        m_eBase(BASE_AT_MINIMUM),
        m_bMaximumLevelIsAlwaysValid(bExtremeLevelsAreAlwaysValid)
    {
        SetMinValue(iMinValue);
        SetMaxValue(iMaxValue);
        SetStepSize(uiStepSize);
        SetBase(eBase);
        SetValue(iValue);
    }
 
    CGUIRange(
        eC_Int iLevelPercentage,
        eC_UInt uiStepSizeLevelPercentage,
        eC_Int iMinValue,
        eC_Int iMaxValue,
        Base_t eBase = BASE_AT_MINIMUM,
        eC_Bool bExtremeLevelsAreAlwaysValid = false) :
        m_vPercentValue(eC_FromInt(0)),
        m_iValue(0),
        m_uiStepSize(1),
        m_iMaxValue(1),
        m_iMinValue(0),
        m_eBase(BASE_AT_MINIMUM),
        m_bMaximumLevelIsAlwaysValid(bExtremeLevelsAreAlwaysValid)
    {
        SetMinValue(iMinValue);
        SetMaxValue(iMaxValue);
        SetStepSizeLevelPercentage(uiStepSizeLevelPercentage);
        SetBase(eBase);
        SetLevelPercentage(iLevelPercentage);
    }
 
    CGUIRange(
        eC_Value vLevel,
        eC_Int iMinValue,
        eC_Int iMaxValue,
        eC_Value vStepSizeLevel,
        Base_t eBase = BASE_AT_MINIMUM,
        eC_Bool bExtremeLevelsAreAlwaysValid = false) :
        m_vPercentValue(eC_FromInt(0)),
        m_iValue(0),
        m_uiStepSize(1),
        m_iMaxValue(1),
        m_iMinValue(0),
        m_eBase(BASE_AT_MINIMUM),
        m_bMaximumLevelIsAlwaysValid(bExtremeLevelsAreAlwaysValid)
    {
        SetMinValue(iMinValue);
        SetMaxValue(iMaxValue);
        SetStepSizeLevel(vStepSizeLevel);
        SetBase(eBase);
        SetLevel(vLevel);
    }
 
    CGUIRange(const CGUIRange& kSource) {CopyAttributes(kSource);}
 
    CGUIRange& operator=(const CGUIRange& kSource)
    {
        CopyAttributes(kSource);
        return *this;
    }
 
    void SetValue(eC_Int iNewValue);
 
    inline eC_Int GetValue() const {return m_iValue;}
 
    inline eC_Value GetLevel() const {return m_vPercentValue;}
 
    inline eC_UInt GetLevelPercentage() const
    {
        return eC_ToInt(eC_Mul(m_vPercentValue, eC_FromInt(100)));
    }
 
    void SetLevel(eC_Value vPercent);
 
    void SetLevelPercentage(eC_UInt uiPercentage);
 
    inline eC_Int GetMinValue() const {return m_iMinValue;}
 
    void SetMinValue(eC_Int iMinValue)
    {
        SetRange(iMinValue, m_iMaxValue);
    }
 
    inline eC_Int GetMaxValue() const {return m_iMaxValue;}
 
    void SetMaxValue(eC_Int iMaxValue)
    {
        SetRange(m_iMinValue, iMaxValue);
    }
 
    void SetRange(eC_Int iMinValue, eC_Int iMaxValue);
 
    void SetStepSizeLevelPercentage(eC_UInt uiPercentage);
 
    void SetStepSizeLevel(eC_Value vPercent);
 
    inline eC_UInt GetStepSize() const {return m_uiStepSize;}
 
    void SetStepSize(eC_UInt uiIntValues);
 
    eC_Bool Increase();
 
    eC_Bool Decrease();
 
    inline const Base_t& GetBase() const {return m_eBase;}
 
    void SetBase(Base_t eBase);
 
    inline eC_Bool GetMaximumLevelIsAlwaysValid() const
    {
        return m_bMaximumLevelIsAlwaysValid;
    }
 
    inline void SetMaximumLevelIsAlwaysValid(
        eC_Bool bNotOnlyMultiplesOfStepSize)
    {
        m_bMaximumLevelIsAlwaysValid = bNotOnlyMultiplesOfStepSize;
    }
 
    inline void ClipToBounds(eC_Int &iValue) const
    {
        if (iValue < m_iMinValue) iValue = m_iMinValue;
        else if (iValue > m_iMaxValue) iValue = m_iMaxValue;
    }
 
    void RoundToNextStep(eC_Int &iRangeValue) const;
 
#ifdef GUILIANI_STREAM_GUI
    virtual void ReadFromStream();
#endif
 
#ifdef GUILIANI_WRITE_GUI
    virtual void WriteToStream(const eC_Bool bWriteClassID = false);
#endif
 
private:
    inline void CopyAttributes(const CGUIRange& kSource)
    {
        m_vPercentValue = kSource.m_vPercentValue;
        m_iValue = kSource.m_iValue;
        m_uiStepSize = kSource.m_uiStepSize;
        m_iMaxValue = kSource.m_iMaxValue;
        m_iMinValue = kSource.m_iMinValue;
        m_eBase = kSource.m_eBase;
        m_bMaximumLevelIsAlwaysValid = kSource.m_bMaximumLevelIsAlwaysValid;
    }
 
    void CalcLevel();
 
    inline void ClipPercentage(eC_UInt &uiPercentage) const
    {
        if (uiPercentage > 100) uiPercentage = 100;
    }
 
    inline void ClipLevel(eC_Value& vPercent) const
    {
        if (vPercent > eC_FromInt(1)) vPercent = eC_FromInt(1);
        else if (vPercent < eC_FromInt(0)) vPercent = eC_FromInt(0);
    }
 
    inline eC_Int RoundUpToMultiplesOf(eC_Int iValueToRound, eC_Int iStepSize) const
    {
        if (iStepSize != 0)
            // round up to next multiple of step size, steps based at zero
            return ((iValueToRound + (iStepSize - 1)) / iStepSize)
                * iStepSize;
        else
            return iValueToRound;
    }
 
    inline eC_Int RoundDownToMultiplesOf(eC_Int iValueToRound, eC_Int iStepSize) const
    {
        if (iStepSize != 0)
            // round down to next multiple of step size, steps based at zero
            return (iValueToRound / iStepSize) * iStepSize;
        else
            return iValueToRound;
    }
 
    eC_Value m_vPercentValue;
 
    eC_Int m_iValue;
 
    eC_UInt m_uiStepSize;
 
    eC_Int m_iMaxValue;
 
    eC_Int m_iMinValue;
 
    Base_t m_eBase;
 
    eC_Bool m_bMaximumLevelIsAlwaysValid;
};
#endif