GUIAbstractBar.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 GUIABSTRACTBAR__H_
#define GUIABSTRACTBAR__H_
 
#include "GUIObject.h"
#include "GUIRange.h"
 
 
class CGUIAbstractBar : public CGUIObject
{
public:
    virtual eC_Bool SetValue(const CGUIValue& rkValue)
    {
        m_kRange.SetValue(rkValue.ToInt());
        CheckForValueChange(); // This will call NotifyValueObservers
        return true; 
    }
 
    inline const CGUIRange& GetRange() const
    {
        return m_kRange;
    }
 
    inline void SetLevel(eC_Value vPercent)
    {
        m_kRange.SetLevel(vPercent);
        CheckForValueChange();
    }
 
    inline void SetLevelPercentage(eC_UInt uiPercentage)
    {
        m_kRange.SetLevelPercentage(uiPercentage);
        CheckForValueChange();
    }
 
    inline void SetMinValue(eC_Int iMinValue)
    {
        m_kRange.SetMinValue(iMinValue);
        CheckForValueChange();
    }
 
    inline void SetMaxValue(eC_Int iMaxValue)
    {
        m_kRange.SetMaxValue(iMaxValue);
        CheckForValueChange();
    }
 
    void SetRange(eC_Int iMinValue, eC_Int iMaxValue)
    {
        m_kRange.SetRange(iMinValue, iMaxValue);
        CheckForValueChange();
    }
 
    inline void SetStepSizeLevelPercentage(eC_UInt uiPercentage)
    {
        m_kRange.SetStepSizeLevelPercentage(uiPercentage);
        CheckForValueChange();
    }
 
    inline void SetStepSizeLevel(eC_Value vPercent)
    {
        m_kRange.SetStepSizeLevel(vPercent);
        CheckForValueChange();
    }
 
    inline void SetStepSize(eC_UInt uiIntValues)
    {
        m_kRange.SetStepSize(uiIntValues);
        CheckForValueChange();
    }
 
    eC_Bool Increase()
    {
        if (m_kRange.Increase())
        {
            CheckForValueChange();
        }
        return false;
    }
 
    eC_Bool Decrease()
    {
        if (m_kRange.Decrease())
        {
            CheckForValueChange();
        }
        return false;
    }
 
    inline void SetBase(CGUIRange::Base_t eBase)
    {
        m_kRange.SetBase(eBase);
        CheckForValueChange();
    }
 
    inline void SetMaximumLevelIsAlwaysValid(eC_Bool bNotOnlyMultiplesOfStepSize)
    {
        m_kRange.SetMaximumLevelIsAlwaysValid(bNotOnlyMultiplesOfStepSize);
        CheckForValueChange();
    }
 
    virtual eC_Bool OnValueChange()
    {
        return false;
    }
 
    inline void SetAnimationSpeed(const eC_UInt &ruiAnimationSpeed)  { m_uiAnimationSpeed = ruiAnimationSpeed; }
 
    inline eC_UInt GetAnimationSpeed() const { return m_uiAnimationSpeed; }
    
    inline void SetAnimationInterval(const eC_UInt &ruiAnimationInterval)  { m_uiAnimationInterval = ruiAnimationInterval; }
 
    inline eC_UInt GetAnimationInterval() const { return m_uiAnimationInterval; }
 
    void AnimateToValue(const eC_Int iTargetValue);
 
    virtual void DoAnimate(const eC_Value& vTimes = eC_FromInt(1));
 
protected:
    CGUIAbstractBar();
 
    CGUIAbstractBar(
        CGUICompositeObject* const pkParent,
        const eC_Value& vX,
        const eC_Value& vY,
        const eC_Value& vWidth,
        const eC_Value& vHeight,
        const ObjectHandle_t &eID = NO_HANDLE);
 
    CGUIAbstractBar(
        CGUICompositeObject* const pkParent,
        const CGUIRect &kRect,
        const ObjectHandle_t &eID = NO_HANDLE);
 
    CGUIAbstractBar(const CGUIAbstractBar& kSource);
 
    CGUIAbstractBar& operator=(const CGUIAbstractBar& kSource);
 
#ifdef GUILIANI_STREAM_GUI
    virtual void ReadFromStream();
#endif
#ifdef GUILIANI_WRITE_GUI
    virtual void WriteToStream(const eC_Bool bWriteClassID = false);
#endif
 
private:
    void Init();
 
    void CopyAttributes(const CGUIAbstractBar& kSource);
 
    void CheckForValueChange();
 
    CGUIRange m_kRange;
 
    eC_Int m_iOldValue;
 
    eC_UInt m_uiAnimationSpeed;
 
    eC_UInt m_uiAnimationInterval;
 
    eC_Int m_iTargetValue;
};
#endif