GUIObject.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 GUIOBJECT__H_
#define GUIOBJECT__H_
 
#include "GUIBehaviour.h"
#include "GUIObjectHandleResource.h"
#include "GUIRect.h"
#include "GUIBitmapPlane.h"
#include "GUILayouter.h"
#include "GUIAnimatable.h"
#include "GUIDataPool.h"
 
#include "GUIStreamTypes.h"
 
class CGUI;
class CGUIBehaviourDecorator;
class CGUILayouter;
class CGUICompositeObject;
 
 
class CGUIObject : public CGUIBehaviour, public CGUIAnimatable
{
    friend class CGUICompositeObject; 
    friend class CGUI; 
 
public:
#if defined(GUILIANI_STREAM_GUI) || defined(GUILIANI_WRITE_GUI)
    static const eC_Char XMLTAG_CONTROLCLASSID[];
 
    static const eC_Char XMLTAG_UUID[];
 
    static const eC_Char XMLTAG_OVERRIDDENNEIGHBORS[];
 
    static const eC_Char XMLTAG_XPOS[];
 
    static const eC_Char XMLTAG_YPOS[];
 
    static const eC_Char XMLTAG_WIDTH[];
 
    static const eC_Char XMLTAG_HEIGHT[];
 
    static const eC_Char XMLTAG_OBJECTID[];
 
    static const eC_Char XMLTAG_FOCUSSABLE[];
 
    static const eC_Char XMLTAG_INVISIBLE[];
 
    static const eC_Char XMLTAG_GRAYEDOUT[];
 
    static const eC_Char XMLTAG_DISABLED[];
 
    static const eC_Char XMLTAG_CLICKTHROUGH[];
 
    static const eC_Char XMLTAG_ALPHA[];
#endif
 
public:
    enum FourWayFocus_t
    {
        FOCUS_LEFT,
        FOCUS_RIGHT,
        FOCUS_UP,
        FOCUS_DOWN
    };
 
    CGUIObject(
        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);
 
    CGUIObject(
        CGUICompositeObject* const pkParent,
        const CGUIRect &kRect,
        const ObjectHandle_t &eID = NO_HANDLE);
 
    CGUIObject();
 
    CGUIObject(const CGUIObject& kSource);
 
    CGUIObject& operator=(const CGUIObject& kSource);
 
    virtual ~CGUIObject();
 
    inline void SetRelRect(const CGUIRect& kNewRect)
    {
        SetRelXPos(kNewRect.GetX1());
        SetRelYPos(kNewRect.GetY1());
        SetWidth(kNewRect.GetWidth());
        SetHeight(kNewRect.GetHeight());
    }
 
    virtual void SetRelXPos(const eC_Value& vX);
 
    virtual void SetRelYPos(const eC_Value& vY);
 
    inline void SetRelXPosREdge(const eC_Value& vX) { SetRelXPos(vX - m_vWidth); }
 
    inline void SetRelYPosBEdge(const eC_Value& vY) { SetRelYPos(vY - m_vHeight); }
 
    inline void SetRelXPosCenter(const eC_Value& vXCenter) { SetRelXPos(vXCenter - GetHalfWidth()); }
 
    inline void SetRelYPosCenter(const eC_Value& vYCenter) { SetRelYPos(vYCenter - GetHalfHeight()); }
 
    virtual void SetWidth(const eC_Value& vX);
 
    virtual void SetHeight(const eC_Value& vY);
 
    eC_Value GetDistanceRight() const;
 
    eC_Value GetDistanceBottom() const;
 
    inline CGUIRect GetAbsRect() const
    {
        return CGUIRect(
            GetAbsXPos(), GetAbsYPos(),
            GetAbsXPosREdge(), GetAbsYPosBEdge());
    }
 
    inline CGUIRect GetRelRect() const
    {
        return CGUIRect(
            GetRelXPos(), GetRelYPos(),
            GetRelXPosREdge(), GetRelYPosBEdge());
    }
 
    inline CGUIRect GetOriginRect() const
    {
        return CGUIRect(
            eC_FromInt(0), eC_FromInt(0),
            GetWidth(), GetHeight());
    }
 
    inline eC_Value GetWidth() const { return m_vWidth; }
 
    inline eC_Value GetHeight() const { return m_vHeight; }
 
    inline eC_Value GetRelXPos() const { return m_vXPosRel; }
 
    inline eC_Value GetRelYPos() const { return m_vYPosRel; }
 
    inline eC_Value GetRelXPosREdge() const { return m_vXPosRel + m_vWidth; }
 
    inline eC_Value GetRelYPosBEdge() const { return m_vYPosRel + m_vHeight; }
 
    inline eC_Value GetAbsXPosREdge() const { return GetAbsXPos() + m_vWidthVisible; }
 
    inline eC_Value GetAbsYPosBEdge() const { return GetAbsYPos() + m_vHeightVisible; }
 
    inline eC_Value GetAbsXPos() const { return m_vXPosAbsParent + m_vXPosRelVisible; }
 
    inline eC_Value GetAbsYPos() const { return m_vYPosAbsParent + m_vYPosRelVisible; }
 
    inline eC_Value GetRelXPosCenter() const { return GetRelXPos() + GetHalfWidth(); }
 
    inline eC_Value GetHalfWidth() const { return eC_Div(m_vWidth, eC_FromInt(2)); }
 
    inline eC_Value GetRelYPosCenter() const { return GetRelYPos() + GetHalfHeight(); }
 
    inline eC_Value GetHalfHeight() const { return eC_Div(m_vHeight, eC_FromInt(2)); }
 
    inline eC_Value GetAbsXPosCenter() const { return GetAbsXPos() + eC_Div(m_vWidthVisible, eC_FromInt(2)); }
 
    inline eC_Value GetAbsYPosCenter() const { return GetAbsYPos() + eC_Div(m_vHeightVisible, eC_FromInt(2)); }
 
    eC_Value GetCurrentAbsXPos() const;
 
    eC_Value GetCurrentAbsYPos() const;
 
    inline eC_Value GetCurrentAbsXPosREdge() const
    {
        return GetCurrentAbsXPos() + GetWidth();
    }
 
    inline eC_Value GetCurrentAbsYPosBEdge() const
    {
        return GetCurrentAbsYPos() + GetHeight();
    }
 
    CGUIRect GetCurrentAbsRect() const;
 
    inline eC_Value GetCurrentAbsXPosCenter() const { return GetCurrentAbsXPos() + GetHalfWidth(); }
 
    inline eC_Value GetCurrentAbsYPosCenter() const { return GetCurrentAbsYPos() + GetHalfHeight(); }
 
    virtual void SetParent(CGUICompositeObject* const pkParent);
 
    inline CGUICompositeObject * GetParent() { return m_pkParentObject; }
 
    inline const CGUICompositeObject * GetParent() const { return m_pkParentObject; }
 
    eC_Bool IsDescendantOf(const CGUIObject* const pAncestor) const;
 
    inline CGUIObject* GetObjectByID(const ObjectHandle_t &eID, const eC_Bool& bOnlyVisible = false)
    {
        // Call the const-GetObjectByID function, which is the real implementation.
        return const_cast<CGUIObject*>(static_cast<const CGUIObject*const>(this)->GetObjectByID(eID, bOnlyVisible));
    }
 
    const CGUIObject* GetObjectByID(const ObjectHandle_t &eID, const eC_Bool& bOnlyVisible = false) const;
 
    virtual CGUIObject *FindObject(const eC_Value& vAbsX, const eC_Value& vAbsY);
 
    inline void SetID(const ObjectHandle_t &eID) { m_eID = eID; }
 
    inline ObjectHandle_t GetID() const { return m_eID; }
 
    virtual eC_Bool FocusAny() { return RequestFocus(); }
 
    virtual eC_Bool FocusNext(
        CGUIObject* const pRefObj = NULL,
        const eC_Bool &bSubTreeOfRefObjDone = false);
 
    virtual eC_Bool FocusPrevious(
        CGUIObject* const pRefObj = NULL,
        const eC_Bool &bSubTreeOfRefObjDone = false);
 
    virtual eC_Bool DoDraw();
 
    virtual eC_Bool DoDrawSnapshot();
 
    eC_Bool RequestFocus();
 
    virtual eC_Bool ClaimFocus();
 
    void InvalidateArea();
 
    eC_Bool CalculateInvalidatedRect(CGUIRect& rRect) const;
 
    inline void SetNeighborRightID(const ObjectHandle_t eNewNeighborRightID)
    {
        m_eNeighborRightID = eNewNeighborRightID;
    }
 
    inline void SetNeighborLeftID(const ObjectHandle_t eNewNeighborLeftID)
    {
        m_eNeighborLeftID = eNewNeighborLeftID;
    }
 
    inline void SetNeighborTopID(const ObjectHandle_t eNewNeighborTopID)
    {
        m_eNeighborTopID = eNewNeighborTopID;
    }
 
    inline void SetNeighborBottomID(const ObjectHandle_t eNewNeighborBottomID)
    {
        m_eNeighborBottomID = eNewNeighborBottomID;
    }
 
    inline void SetNeighborIDs(
        const ObjectHandle_t eNewNeighborLeftID,
        const ObjectHandle_t eNewNeighborRightID,
        const ObjectHandle_t eNewNeighborTopID,
        const ObjectHandle_t eNewNeighborBottomID)
    {
        m_eNeighborLeftID = eNewNeighborLeftID;
        m_eNeighborRightID = eNewNeighborRightID;
        m_eNeighborTopID = eNewNeighborTopID;
        m_eNeighborBottomID = eNewNeighborBottomID;
    }
 
    inline ObjectHandle_t GetNeighborRightID() const { return m_eNeighborRightID; }
 
    inline ObjectHandle_t GetNeighborLeftID() const { return m_eNeighborLeftID; }
 
    inline ObjectHandle_t GetNeighborTopID() const { return m_eNeighborTopID; }
 
    inline ObjectHandle_t GetNeighborBottomID() const { return m_eNeighborBottomID; }
 
    void SetBehaviour(CGUIBehaviourDecorator* pkBehaviour);
 
    inline CGUIBehaviourDecorator * GetBehaviour()
    {
        return m_pkBehaviour;
    }
 
    inline const CGUIBehaviourDecorator * GetBehaviour() const
    {
        return m_pkBehaviour;
    }
 
    void SetLayouter(CGUILayouter *pLayouter);
 
    inline CGUILayouter* GetLayouter()
    {
        return m_pkLayouter;
    }
 
    inline const CGUILayouter* GetLayouter() const
    {
        return m_pkLayouter;
    }
 
    virtual void RefreshLayout(CGUILayouter::eMovedEdges_t eMovedEdges) const;
 
    virtual void SetGrayedOut(const eC_Bool &bGrayOut);
 
    virtual void SetInvisible(const eC_Bool &bInvisible);
 
    virtual void SetDisabled(const eC_Bool &bDisabled);
 
    virtual void SetFocussable(const eC_Bool &bFocussable);
 
    inline void SetStopFocus(const eC_Bool &bDontFocusToParent)
    {
        m_bStopFocus = bDontFocusToParent;
    }
 
    inline void SetClickThrough(const eC_Bool &bClickThrough)
    {
        m_bClickThrough = bClickThrough;
    }
 
    eC_Bool IsFocussable() const;
 
    virtual eC_Bool IsHighlightable() const;
 
    eC_Bool IsDragable() const;
 
    eC_Bool IsClickable() const;
 
    eC_Bool IsFocussed() const;
 
    eC_Bool IsHighlighted() const;
 
    eC_Bool IsPressed() const;
 
    eC_Bool IsDragged() const;
 
    inline eC_Bool IsGrayedOut() const { return m_bIsGrayedOut; }
 
    inline eC_Bool IsInvisible() const { return m_bIsInvisible; }
 
    inline eC_Bool IsDisabled() const { return m_bIsDisabled; }
 
    inline eC_Bool IsClickThrough() const
    {
        return m_bClickThrough;
    }
 
    inline eC_Bool IsStopFocus() const { return m_bStopFocus; }
 
    virtual eC_Bool IsCompositeObject() const { return false; }
 
 
    inline eC_UByte GetAlpha() const { return m_ubAlpha; }
 
    void SetAlpha(eC_UByte ubAlpha);
 
    void RenderToBitmap(eC_UInt uiBitmapID, eC_Value vXOffset = eC_FromInt(0), eC_Value vYOffset = eC_FromInt(0));
 
    virtual void CreateSnapshot(eC_UInt uiBackColor = 0x00);
 
    void DeleteSnapshot();
 
    GUIBitmapPlaneID_t GetBitmapID() const;
 
    CGUIBitmapPlane& GetBitmapPlane() const;
 
    virtual void EnableSnapshotDrawing();
 
    virtual void DisableSnapshotDrawing(eC_Bool bDeleteSnapshot = true);
 
    inline eC_Bool IsDrawingSnapshot() const
    {
        return m_bDrawSnapshot;
    }
 
    void AddValueObserver(CGUIObserver* pkObserver)
    {
        GetDataPoolConnector().AddObserver(pkObserver);
    }
 
    void RemoveValueObserver(CGUIObserver* pkObserver)
    {
        if (m_pkDataPoolConnector)
            m_pkDataPoolConnector->RemoveObserver(pkObserver);
    }
 
    void NotifyValueObservers(const CGUIValue& kValue, const eC_UInt uiX = 0, const eC_UInt uiY = 0)
    {
        if (m_pkDataPoolConnector)
            m_pkDataPoolConnector->NotifyObservers(kValue, this, uiX, uiY);
    }
 
    CDataPoolConnector& GetDataPoolConnector();
 
    eC_Bool DataPoolConnectorExists() const
    {
        return (m_pkDataPoolConnector != NULL);
    }
 
    virtual eC_Bool SetValue(const CGUIValue& rkValue)
    {
        NotifyValueObservers(rkValue);
        // Default returns false to notify caller that the value could not be interpreted by this control
        return false;
    }
 
#ifndef GUILIANI_NO_DATAPOOL
    virtual eC_Bool SetValue(CDataPoolEntry& rkValue);
#endif
 
#ifdef GUILIANI_STREAM_GUI
    virtual void ReadFromStream();
#endif
 
#ifdef GUILIANI_WRITE_GUI
    virtual void WriteToStream(const eC_Bool bWriteClassID = false);
#endif
 
    void SetUUID(const UUID_t& kUUID)
    {
        m_kUUID = kUUID;
    }
 
    UUID_t GetUUID() const
    {
        return m_kUUID;
    }
 
protected:
    virtual eC_Bool FourWayNext(FourWayFocus_t eFocusDirection);
 
    virtual eC_Bool CreateBitmapPlane();
 
protected:
    UUID_t m_kUUID;
 
private:
    void SetParentInternal(CGUICompositeObject* const pkParent);
 
    virtual void HandleDraw(const CGUIRect &ClipRect);
 
    void UpdateInvalidation();
 
    virtual eC_Bool FocusNextDown();
 
    virtual eC_Bool FocusPreviousDown();
 
    void Init(
        CGUICompositeObject* const pkParent,
        const CGUIRect &kRect,
        const ObjectHandle_t &eID);
 
    eC_Bool IsInSector(FourWayFocus_t eFocusDirection) const;
 
    void NotifyOfCreation();
 
    eC_Value m_vXPosRel, m_vYPosRel;
 
    eC_Value m_vWidth, m_vHeight;
 
    CGUICompositeObject* m_pkParentObject;
 
    CGUIBehaviourDecorator* m_pkBehaviour;
 
    CGUILayouter* m_pkLayouter;
 
    ObjectHandle_t m_eID;
 
    ObjectHandle_t m_eNeighborRightID;
 
    ObjectHandle_t m_eNeighborLeftID;
 
    ObjectHandle_t m_eNeighborBottomID;
 
    ObjectHandle_t m_eNeighborTopID;
 
    static const CGUIObject* ms_pkFocusTerminatingObj;
 
    static const CGUIObject* ms_pkFirstRequestedObj;
 
    eC_Value m_vWidthVisible, m_vHeightVisible;
 
    eC_Value m_vXPosRelVisible, m_vYPosRelVisible;
 
    eC_Value m_vXPosAbsParent, m_vYPosAbsParent;
 
    eC_Bool m_bStopFocus;
 
    eC_Bool m_bClickThrough;
 
    eC_Bool m_bIsFocussable;
 
    eC_Bool m_bIsGrayedOut;
 
    eC_Bool m_bIsInvisible;
 
    eC_Bool m_bIsDisabled;
 
    eC_Bool m_bMarkedForInvalidation;
 
    eC_Bool m_bDrawSnapshot;
 
    GUIBitmapPlaneID_t m_uiBitmapID;
 
    eC_UByte m_ubAlpha;
 
    CDataPoolConnector* m_pkDataPoolConnector;
};
#endif