GUIText.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 GUITEXT__H_
#define GUITEXT__H_
 
#include "GUIFontResource.h"
#include "GUITextResource.h"
#include "eC_TList_doubleLinked.h"
#include "GUIColorPropertyObserver.h"
#include "GUIStreamableObject.h"
#include "eC_Math.h"
#include "GUIProperties.h"
#include "GUIRect.h"
#include "GUICommonEnums.h"
 
const eC_Char ccLinebreak = '\n';
 
 
class CGUIText : public CGUIColorPropertyObserver, public CGUIStreamableObject
{
public:
    enum TextColorTypeFlags_t
    {
        TEXT_COLOR_STANDARD_IS_PROPERTY = 1,
        TEXT_COLOR_HIGHLIGHTED_IS_PROPERTY = 2,
        TEXT_COLOR_GRAYED_OUT_IS_PROPERTY = 4,
        TEXT_COLOR_PRESSED_IS_PROPERTY = 8
    };
 
    enum VerAligned_t
    {
        V_TOP,      
        V_CENTERED, 
        V_BOTTOM    
    };
 
    enum HorAligned_t
    {
        H_LEFT,     
        H_CENTERED, 
        H_RIGHT,    
        H_PROPERTY 
    };
 
    class ExtendedString_t
    {
    public:
        // Constructs an extended string element.with the default parameters
        ExtendedString_t() :
            m_kStrText(""),
            m_vWidth(),
            m_vHeight()
        {}
 
        ExtendedString_t(const eC_String& kStrText, eC_Value vWidth, eC_Value vHeight) :
            m_kStrText(kStrText),
            m_vWidth(vWidth),
            m_vHeight(vHeight)
        {}
 
        const eC_String& GetText() const { return m_kStrText; }
 
        eC_Value GetWidth() const { return m_vWidth; }
 
        eC_Value GetHeight() const { return m_vHeight; }
 
        void SetText(const eC_String& kStrText) { m_kStrText = kStrText; }
 
        void SetWidth(const eC_Value& vWidth) { m_vWidth = vWidth; }
 
        void SetHeight(const eC_Value& vHeight) { m_vHeight = vHeight; }
 
    private:
        eC_String   m_kStrText;
        eC_Value    m_vWidth;
        eC_Value    m_vHeight;
    };
 
    CGUIText(
        const CGUIObject* const pkParentObject,
        const eC_String &kText,
        const eC_Value& vXPos = eC_FromInt(0),
        const eC_Value& vYPos = eC_FromInt(0),
        const eC_Bool &bSingleLine = true);
 
    CGUIText(
        const CGUIObject* const pkParentObject,
        const eC_String* const pkText,
        const eC_Value& vXPos = eC_FromInt(0),
        const eC_Value& vYPos = eC_FromInt(0),
        const eC_Bool &bSingleLine = true);
 
    CGUIText(
        const CGUIObject* const pkParentObject,
        const TextResource_t &eTextID,
        const eC_Value& vXPos = eC_FromInt(0),
        const eC_Value& vYPos = eC_FromInt(0),
        const eC_Bool &bSingleLine = true);
 
    CGUIText(const CGUIText& kTextToBeCopied);
 
    virtual ~CGUIText();
 
    inline FontResource_t GetFont() const { return m_eFont; }
 
    eC_Int GetFontSize() const;
 
    inline eC_Float GetFontSpacing() const { return m_fFontSpacing; }
 
    inline HorAligned_t GetHorAlign() const { return m_eHorAligned; }
 
    inline VerAligned_t GetVerAlign() const { return m_eVerAligned; }
 
    virtual eC_Value GetTextHeight() const { return m_vTextHeight; }
 
    virtual eC_Value GetTextWidth() const { return m_vTextWidth; }
 
    virtual void GetRequiredTextSpace(eC_Value& vTextWidth, eC_Value& vTextHeight);
 
    virtual void GetRequiredOrgTextSpace(eC_Value& vTextWidth, eC_Value& vTextHeight);
 
    virtual eC_Value GetRequiredTextHeightForWidth(eC_Value vAvailableWidth = 0);
 
    const eC_String* GetText() const;
 
    void GetTextColor(eC_UInt &uiTextColorStandard,
        eC_UInt &uiTextColorHighlighted,
        eC_UInt &uiTextColorGrayedOut,
        eC_UInt &uiTextColorPressed) const;
 
    void GetTextColor(GlobalProperty_t &eTextColorStandard,
        GlobalProperty_t &eTextColorHighlighted,
        GlobalProperty_t &eTextColorGrayedOut,
        GlobalProperty_t &eTextColorPressed) const;
 
    inline TextResource_t GetTextID() const { return m_eTextID; }
 
    virtual void PrintText();
 
    virtual void SetFont(const FontResource_t &eFontID);
 
    void SetFontSpacing(const eC_Float &fFontSpacing);
 
    inline void SetContainingObject(const CGUIObject* const pkParent) { m_pkParentObject = pkParent; }
 
    inline const CGUIObject* GetContainingObject() const { return m_pkParentObject; }
 
    virtual void SetTextColor(
        const eC_UInt &uiTextColorStandard,
        const eC_UInt &uiTextColorHighlighted,
        const eC_UInt &uiTextColorGrayedOut,
        const eC_UInt &uiTextColorPressed);
 
    virtual void SetTextColor(
        const GlobalProperty_t &eTextColorStandard,
        const GlobalProperty_t &eTextColorHighlighted,
        const GlobalProperty_t &eTextColorGrayedOut,
        const GlobalProperty_t &eTextColorPressed);
 
    eC_UInt GetTextColorStandard() const;
 
    void SetTextColorStandard(const eC_UInt &uiTextColorStandard);
 
    void SetTextColorStandard(const GlobalProperty_t &eTextColorPropertyStandard);
 
    eC_UInt GetTextColorHighlighted() const;
 
    void SetTextColorHighlighted(const eC_UInt &uiTextColorHighlighted);
 
    void SetTextColorHighlighted(const GlobalProperty_t &eTextColorPropertyHighlighted);
 
    eC_UInt GetTextColorGrayedOut() const;
 
    void SetTextColorGrayedOut(const eC_UInt &uiTextColorGrayedOut);
 
    void SetTextColorGrayedOut(const GlobalProperty_t &eTextColorPropertyGrayedOut);
 
    eC_UInt GetTextColorPressed() const;
 
    void SetTextColorPressed(const eC_UInt &uiTextColorPressed);
 
    void SetTextColorPressed(const GlobalProperty_t &eTextColorPropertyPressed);
 
    void SetTextAlignmentProperty(const GlobalProperty_t &eTextAlignmentProperty);
 
    virtual void SetTextID(const TextResource_t &eTextID);
 
    void SetTextString(const eC_String* pkTextString);
 
    virtual void SetTextString(const eC_String& kTextString);
 
    void InvalidateArea();
 
    void SetRelRect(const CGUIRect& kRect)
    {
        if (m_vRelXPos != kRect.GetX1())
            SetRelXPos(kRect.GetX1());
 
        if (m_vRelYPos != kRect.GetY1())
            SetRelYPos(kRect.GetY1());
 
        if (m_vTextWidth != kRect.GetWidth())
            SetTextWidth(kRect.GetWidth());
 
        if (m_vTextHeight != kRect.GetHeight())
            SetTextHeight(kRect.GetHeight());
    }
 
    virtual void SetTextWidth(const eC_Value& vTextWidth);
 
    virtual void SetTextHeight(const eC_Value& vTextHeight);
 
    virtual void SetTextSingleLine(const eC_Bool &bSingleLine);
 
    eC_Bool IsTextID() const;
 
    eC_Bool IsBidi() const;
 
    void SetAligned(
        const VerAligned_t &eVerAligned = V_TOP,
        const HorAligned_t &eHorAligned = H_LEFT);
 
    void SetAlignedHorizontal(const HorAligned_t& eHorAligned = H_LEFT);
 
    void SetAlignedVertical(const VerAligned_t& eVerAligned = V_TOP);
 
    virtual void SetRelXPos(const eC_Value& vRelXPos)
    {
        m_vRelXPos = vRelXPos;
    }
 
    virtual eC_Value GetRelXPos() const
    {
        return m_vRelXPos;
    }
 
    virtual void SetRelYPos(const eC_Value& vRelYPos)
    {
        m_vRelYPos = vRelYPos;
    }
 
    virtual eC_Value GetRelYPos() const
    {
        return m_vRelYPos;
    }
 
    inline eC_Bool IsTextSingleLine() const { return m_bSingleLine; }
 
    inline eC_Bool IsTextCut() { AdaptText(); return m_bTextCut; }
 
    inline void SetAdjustment(
        const eC_Value& vXAdjustment,
        const eC_Value& vYAdjustment)
    {
        m_vXAdjustment = vXAdjustment;
        m_vYAdjustment = vYAdjustment;
    }
 
    inline void GetAdjustment(
        eC_Value& vXAdjustment,
        eC_Value& vYAdjustment) const
    {
        vXAdjustment = m_vXAdjustment;
        vYAdjustment = m_vYAdjustment;
    }
 
    CGUIText& operator=(const CGUIText& kSource);
 
    inline static void SetEllipsisString(const eC_String& kEllipsis) { ms_kEllipsis = kEllipsis; }
 
    inline static eC_String GetEllipsisString() { return ms_kEllipsis; }
 
    inline static void SetHyphenString(const eC_String& kHyphen) { ms_kHyphen = kHyphen; }
 
    inline static eC_String GetHyphenString() { return ms_kHyphen; }
 
    void FitHeightToContainedText();
 
    virtual CGUIText* Clone() const;
 
    virtual void SetLineSpacing(const eC_Value vLineSpacing);
 
    inline virtual eC_Value GetLineSpacing() const { return m_vLineSpacing; }
 
    inline void SetSpecificClipRect(const CGUIRect& kRect) { m_kSpecificClipRect = kRect; }
 
    inline const CGUIRect& GetSpecificClipRect() const { return m_kSpecificClipRect; }
 
    eC_UInt GetNumberOfLines();
 
    void SetAutoSize(const eC_Bool& bAutoSize);
 
    eC_Bool GetAutoSize() const;
 
    void SetRotation(const CGUICommonEnums::Rotation_t eRotation);
 
    CGUICommonEnums::Rotation_t GetRotation() const;
 
#ifdef GUILIANI_STREAM_GUI
    virtual void ReadFromStream();
#endif
 
#ifdef GUILIANI_WRITE_GUI
    virtual void WriteToStream(const eC_Bool bWriteTextType = false);
#endif
 
#if defined(GUILIANI_STREAM_GUI) || defined(GUILIANI_WRITE_GUI)
    static const eC_Char XMLTAG_TEXTTYPEID[];
 
    static const eC_Char XMLTAG_TEXTID[];
 
    static const eC_Char XMLTAG_TEXT_COLOR_PROPERTY_FLAGS[]; 
 
    static const eC_Char XMLTAG_TEXT_COLOR_STANDARD[]; 
    static const eC_Char XMLTAG_TEXT_COLOR_HIGHLIGHTED[]; 
    static const eC_Char XMLTAG_TEXT_COLOR_GRAYEDOUT[]; 
    static const eC_Char XMLTAG_TEXT_COLOR_PRESSED[];  
#endif
 
protected:
#ifdef GUILIANI_STREAM_GUI
    void ReadFontColors(const eC_UInt uiVersion);
#endif
 
#ifdef GUILIANI_WRITE_GUI
    void WriteFontColors();
#endif
 
    virtual void AdaptText();
 
    virtual eC_Value GetHorStartAbsXPos();
 
    virtual eC_Value GetVerStartAbsYPos();
 
    virtual eC_Value GetPrintLineAbsXPos(const eC_Value& vWidth, const eC_Value& vHeight);
 
    virtual eC_Value GetPrintLineAbsYPos(const eC_Value& vWidth, const eC_Value& vHeight);
 
    virtual eC_Value GetPrintLineAbsXPos(const eC_UInt uiLine);
 
    virtual eC_Value GetPrintLineAbsYPos(const eC_UInt uiLine);
 
    virtual eC_Value GetPrintLineAbsXPos();
 
    virtual eC_Value GetPrintLineAbsYPos();
 
    virtual void FitString(
        ExtendedString_t& rkResultStrData,
        const eC_String& rkStrToAnalyse,
        eC_String& rkRestStr,
        eC_UInt& uiOffset);
 
    virtual void PreparePrint();
 
    eC_Bool PrepareClipRect();
 
    inline eC_Value GetRequiredTextWidth() const { return m_vRequiredTextWidth; }
 
    inline void SetRequiredTextWidth(eC_Value vRequiredTextWidth) { m_vRequiredTextWidth = vRequiredTextWidth; }
 
    inline eC_Value GetRequiredTextHeight() const { return m_vRequiredTextHeight; }
 
    inline void SetRequiredTextHeight(eC_Value vRequiredTextHeight) { m_vRequiredTextHeight = vRequiredTextHeight; }
 
    virtual void OnNotification();
 
    eC_Bool ContainsHyphenationMarks(const eC_String& kStr) const;
 
    virtual void CollectHyphenationMarks(eC_String& rkStr, eC_UInt uiOffset);
 
    void SetTextCut(const eC_Bool bIsCut) { m_bTextCut = bIsCut; }
 
    void CreateLocalTextCopy();
 
protected:
    eC_Value m_vLineHeight;
 
    typedef eC_TListDoubleLinked <ExtendedString_t> ExtendedStringList_t;
 
    ExtendedStringList_t m_kListStringsExtended;
 
    eC_Value m_vTextHeight;
 
    eC_Value m_vTextWidth;
 
    eC_Bool m_bSingleLine;
 
    eC_Bool m_bAdaptText;
 
    eC_String* m_pkText;
 
    static const eC_String ms_ckSingleSpace;
 
    static const eC_String ms_ckEmptyString;
 
    static const ExtendedString_t ms_ckEmptyExtendedString;
 
    eC_Value m_vLineSpacing;
 
    eC_Bool m_bTextIDLocalCopy;
 
    typedef eC_TListDoubleLinked<eC_UInt> UIntList;
 
    UIntList m_kHyphens;
 
    eC_Value m_vRequiredOrgTextWidth;
 
    eC_Value m_vRequiredOrgTextHeight;
 
    eC_Bool m_bTextIsBiDi;
 
    const CGUIObject *m_pkParentObject;
 
    eC_Value m_vRelXPos;
 
    eC_Value m_vRelYPos;
 
    GlobalProperty_t m_eTextAlignmentProperty;
 
    HorAligned_t m_eHorAligned;
 
    VerAligned_t m_eVerAligned;
 
    eC_Value m_vXAdjustment;
 
    eC_Value m_vYAdjustment;
 
    eC_Bool m_bUseEllipsis;
 
    FontResource_t  m_eFont;
 
    eC_Float m_fFontSpacing;
 
    eC_Bool m_bTextCut;
 
    TextResource_t m_eTextID;
 
    CGUICommonEnums::Rotation_t m_eRotation;
 
private:
    CGUIText();
 
    void Init(
        const CGUIObject* const pkParentObject,
        const eC_Value& vXPos,
        const eC_Value& vYPos,
        eC_Bool bSingleLine);
 
    virtual void CreateStringList();
 
    virtual ExtendedString_t FitStringWithEllipsis(
        const eC_String& kOrgStr,
        const eC_Bool bForceEllipsis = false);
 
    eC_UInt FitStringWithHyphen(
        const eC_String& kFirstPart,
        eC_String& kSecondPart,
        eC_UInt uiOffset,
        eC_String& kHyphenated) const;
 
    void RestoreHyphenationMarks(eC_String& kResult) const;
 
private:
    static const eC_UInt INDEX_COLOR_STANDARD;
    static const eC_UInt INDEX_COLOR_HIGHLIGHTED;
    static const eC_UInt INDEX_COLOR_GRAYEDOUT;
    static const eC_UInt INDEX_COLOR_PRESSED;
 
    static const eC_String ms_ckHyphenationMark;
 
    static const eC_UInt ms_cuiHyphMarkLength;
 
    static eC_String ms_kHyphen;
 
    static eC_String ms_kEllipsis;
 
    eC_Value m_vRequiredTextWidth;
 
    eC_Value m_vRequiredTextHeight;
 
    CGUIRect m_kSpecificClipRect;
 
    eC_Bool m_bAutoSize;
};
 
#endif