GUIWheel.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 __GUIWHEEL_H__
#define __GUIWHEEL_H__
 
#include "GUIObject.h"
#include "GUIEasing.h"
#include "GUIImageResource.h"
#include "GUINinePatch.h"
#include "GUIColorPropertyObserver.h"
 
#include "GUICommonEnums.h"
#include "GUIText.h"
 
// @guiliani_doxygen toplevel_control Wheel
// @endguiliani_doxygen
class CGUIWheel : public CGUIObject, public CGUIColorPropertyObserver
{
protected:
    struct NodeInfo;
 
public:
    typedef eC_TListDoubleLinked<NodeInfo> NodeList;
 
    CGUIWheel(
        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);
 
    CGUIWheel();
 
    CGUIWheel(const CGUIWheel& kToBeCopied);
 
    CGUIWheel& operator=(const CGUIWheel& kSource);
 
    virtual ~CGUIWheel();
 
    void Init();
    
    void DeInit();
 
    void SetMinValue(eC_Int iMinValue);
 
    eC_Int GetMinValue();
 
    void SetMaxValue(eC_Int iMaxValue);
 
    eC_Int GetMaxValue();
 
    void SetStepSize(eC_Int iStepSize);
 
    eC_Int GetStepSize() const;
 
    void SetPostfixString(const eC_String& kPostfixString);
 
    virtual void AdaptWheel();
 
    virtual void AddEntry(const eC_String &kEntry, eC_Bool bSort = false);
 
    virtual void DeleteEntry(const eC_String &kEntry);
 
    virtual void DeleteAllEntries();
 
    virtual void ScrollTo(eC_UInt uiNodeIndex);
 
    virtual void ScrollTo(const eC_String &kNodeText);
 
    virtual void ScrollToAnimated(eC_UInt uiNodeIndex);
 
    virtual void ScrollToAnimated(const eC_String &kNodeText);
 
    virtual eC_UInt GetCurrentIndex();
 
    virtual const eC_String& GetCurrentValue();
 
    virtual eC_Int SearchEntry(const eC_String &kNodeText);
 
    // Methods derived from CGUIObject 
    virtual eC_Bool DoDraw();
 
    virtual eC_Bool IsHighlightable() const { return false; }
 
    virtual void DoAnimate(const eC_Value& vTimes = eC_FromInt(1));
    virtual eC_Bool DoClick(const eC_Value& vAbsX, const eC_Value& vAbsY);
    virtual eC_Bool DoButtonDown(const eC_Value& vAbsX, const eC_Value& vAbsY);
    virtual eC_Bool DoDrag(const eC_Value& vDeltaX, const eC_Value& vDeltaY, const eC_Value& vAbsX, const eC_Value& vAbsY);
    virtual eC_Bool DoDragEnd(const eC_Value& vAbsX, const eC_Value& vAbsY);
 
    virtual void SetWidth(const eC_Value& vWidth);
    virtual void SetHeight(const eC_Value& vHeight);
    virtual eC_Bool SetValue(const CGUIValue& rkValue);
 
    eC_Bool IsCyclic() const;
 
    void SetCyclic(eC_Bool bCyclic);
 
    eC_Bool IsUsingRange() const;
 
    void SetUseRange(eC_Bool bUseRange);
 
    eC_UInt GetNumberOfEntries();
 
    virtual void NormalizeEntry(eC_String& kEntry);
 
    void SetDirection(CGUICommonEnums::Orientation_t eDirection);
 
    CGUICommonEnums::Orientation_t GetDirection() const;
 
    void SetEntriesFont(const FontResource_t& eFontID);
 
    FontResource_t GetEntriesFont() const;
 
    void SetEntriesColor(const eC_UInt& uiEntriesColor);
 
    void SetEntriesColor(const GlobalProperty_t& eEntriesColor);
 
    eC_UInt GetEntriesColor() const;
 
    void SetFocussedEntryFont(const FontResource_t& eFontID);
 
    FontResource_t GetFocussedEntryFont() const;
 
    void SetFocussedEntryColor(const eC_UInt& uiFocussedEntryColor);
 
    void SetFocussedEntryColor(const GlobalProperty_t& eFocussedEntryColor);
 
    eC_UInt GetFocussedEntryColor() const;
 
    virtual void OnColorPropertyChange();
 
    void SetAnimatedUpdate(const eC_Bool& bAnimatedUpdate);
 
    eC_Bool GetAnimatedUpdate() const;
 
#if defined(GUILIANI_STREAM_GUI)
    virtual void ReadFromStream();
#endif
 
#if defined(GUILIANI_WRITE_GUI)
    virtual void WriteToStream(const eC_Bool bWriteClassID = false);
#endif
 
    CGUINinePatch& GetNinePatch()
    {
        return m_kNinePatch;
    }
 
protected:
    virtual void CreateNodesFromRange();
 
    virtual void AdjustNodesRelativePositions();
    
    virtual void AdjustNodesRelativePositionsCyclic();
    
    virtual void AdjustNodesRelativePositionsNotCyclic();
 
    virtual void AdjustCurrentScrollPosAndNode(eC_Value vDragDelta);
    
    virtual void AdjustSize();
 
    virtual void GetNodeIndexInRelPos(eC_Value vOffset, eC_Int &iIndex, eC_Int &iCycle, eC_Value& vScrollPos);
     
    virtual void SetCurrentNode(eC_UInt uiNodeIndex);
    
    virtual eC_UInt GetCurrentNode();
    
    virtual NodeList::SafeIterator GetCurrentNodeSafeIter();
    
    virtual eC_UInt GetNodeIndexFromIter(const NodeList::Iterator &kNodeIter);
    
    virtual void SetCurrentNodeSafeIter(const NodeList::SafeIterator &kNodeSafeIter);
     
    virtual NodeList::Iterator GetNextNodeCyclic(NodeList::Iterator kIter);
     
    virtual NodeList::Iterator GetPreviousNodeCyclic(NodeList::Iterator kIter);
 
    virtual eC_Value GetCurrentScrollPosForCurrentDirection();
 
    virtual void SetCurrentScrollPosForCurrentDirection(eC_Value vCurrentScrollPos);
 
    virtual eC_Value GetDefaultNodeSizeCurrentDirection();
 
    virtual void SetDefaultNodeSize(eC_Value vWidth, eC_Value vHeight);
 
    virtual void StartScrollingAnimation();
 
    virtual void StopScrollingAnimation();
 
    NodeList& GetNodes();
 
    virtual void PixelToIndexCycleOffset(eC_Value vPixel, eC_Int &iIndex, eC_Int &iCycle, eC_Value& vOffset);
 
    virtual eC_Value IndexCycleOffsetToPixel(eC_Int iIndex, eC_Int iCycle, eC_Value vOffset);
 
    struct NodeInfo
    {
        eC_String m_sNodeText; 
        CGUIText* m_pkGUIText;  
 
        NodeInfo(const NodeInfo& kToBeCopied) :
            m_sNodeText(""),
            m_pkGUIText(NULL)
        {
            operator=(kToBeCopied);
        };
 
        NodeInfo() :
            m_sNodeText(""),
            m_pkGUIText(NULL)
        {
        }
 
        NodeInfo(
            CGUIObject* pkParent,
            const eC_String &kNodeText,
            eC_Value vXPos, eC_Value vYPos,
            eC_Value vWidth, eC_Value vHeight) :
            m_sNodeText(kNodeText)
        { 
            m_pkGUIText = new CGUIText(pkParent, kNodeText, vXPos, vYPos); 
            m_pkGUIText->SetAligned(CGUIText::V_CENTERED, CGUIText::H_CENTERED);
            m_pkGUIText->SetTextWidth(vWidth);
            m_pkGUIText->SetTextHeight(vHeight);
            
            m_pkGUIText->SetFont(DUMMY_FONT);
        }
 
        NodeInfo& operator=(const NodeInfo& kNode);
 
        bool operator==(const NodeInfo& kNode)
        {
            return kNode.m_sNodeText == m_sNodeText;
        }
 
        bool operator>(const NodeInfo& kNode)
        {
            eC_Int iValueMe = 0;
            eC_Int iValueOther = 0;
            eC_Bool bIsNumMe = m_sNodeText.ToInt(iValueMe);
            eC_Bool bIsNumOther = kNode.m_sNodeText.ToInt(iValueOther);
            if (bIsNumMe && bIsNumOther)
            {
                return (iValueOther > iValueMe);
            }
            else if (!bIsNumMe && !bIsNumOther)
            {
                return (kNode.m_sNodeText > m_sNodeText);
            }
            return bIsNumMe;
        }
 
        ~NodeInfo();
    };
 
protected:
    static const eC_UInt INDEX_COLOR_ENTRY; 
    static const eC_UInt INDEX_COLOR_FOCUSSEDENTRY; 
 
    NodeList m_kNodes;
 
    NodeList::SafeIterator m_CurrentNodeSafeIter;
    eC_UInt m_CurrentNodeIndex; 
    eC_Value m_vCurrentScrollPosX; 
    eC_Value m_vCurrentScrollPosY;  
 
    eC_Value m_vTargetPos;
 
    // Used for animation
    // Animation start position
    eC_Int m_iAniStartNodeIndex;
    eC_Int m_iAniStartNodeCycle;
    eC_Value m_vAniStartScrollPos;
    // Animation target position
    eC_Int m_iAniTargetNodeIndex;
    eC_Int m_iAniTargetNodeCycle;
    eC_Value m_vAniTargetScrollPos;
 
    eC_Value m_vNodeDefaultWidth;
    eC_Value m_vNodeDefaultHeight;
 
    eC_Bool m_bCyclic;
    eC_Bool m_bUseRange;
    eC_Int m_iMinValue;
    eC_Int m_iMaxValue;
    eC_Int m_iStepSize;
    eC_Int m_iMinDigitNumber; 
    eC_String m_kFillupString; 
    eC_String m_kPrefixString; 
    eC_String m_kPostfixString; 
    eC_Bool m_bFillFromBegin;
    
    eC_UInt m_uiDragTimeStamp;
    eC_UInt m_uiDragStarted; 
    CGUIPoint m_kDragStart; 
 
    ImageResource_t m_eBGImage; 
 
    CGUICommonEnums::Orientation_t m_eDirection; 
 
    CGUIEasing::EasingType_t  m_eEasingTypeCurrent; 
    CGUIEasing::EasingType_t  m_eEasingTypeNormal; 
    CGUIEasing::EasingType_t  m_eEasingTypeBack; 
 
    eC_Value m_vEasingDurationCurrent; 
    eC_Value m_vEasingDurationNormal; 
    eC_Value m_vEasingDurationBack; 
 
    FontResource_t m_eEntriesFont;
    FontResource_t m_eFocussedEntryFont;
    eC_String m_kFocussedValue;
    eC_Value m_vNodeX;
    eC_Value m_vNodeY;
    eC_UInt m_uiNumOfVisibleNodes;
    eC_Value m_vRemainingSpaceX;
    eC_Value m_vRemainingSpaceY;
    eC_Value m_vAdditionalSpace;
 
    CGUINinePatch m_kNinePatch; 
 
    eC_Bool m_bAnimatedUpdate; 
};
 
#endif // GUIWHEEL_H