GUIEditableText.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.
*/
 
#if !defined(GUIEDITABLETEXT__H_)
#define GUIEDITABLETEXT__H_
 
#include "GUIText.h"
 
#include "GUIPropertyResource.h"
#include "GUIRect.h"
#include "eC_TList_doubleLinked.h"
#include"eC_TList.h"
#include "bidi.h"
 
 
class CGUIEditableText : public CGUIText
{
public:
    struct CursorPos_t
    {
        CursorPos_t(
            eC_UInt uiCharIndex = 0,
            eC_UInt uiLineIndex = 0) :
            m_uiCharIndex(uiCharIndex),
            m_uiLineIndex(uiLineIndex)
        {}
 
        eC_UInt m_uiCharIndex; 
        eC_UInt m_uiLineIndex; 
    };
 
    struct BidiTurningPoint_t
    {
        eC_TList<eC_UInt> fromRtLIndex;
        eC_TList<eC_UInt> fromLtRIndex;
        eC_TList<LeftEmbedding> leftEmbeddingLevels;
        eC_TList<RightEmbedding> rightEmbeddingLevels;
    };
    BidiTurningPoint_t m_kBidiTurnPoints; 
 
    CGUIEditableText(
        const CGUIObject* const pkParentObject,
        const eC_String &kText,
        const eC_Value& vXPos = eC_FromInt(0),
        const eC_Value& vYPos = eC_FromInt(0),
        const eC_Value& vTextWidth = eC_FromInt(0),
        eC_Bool bWordWrap = false);
 
    CGUIEditableText(
        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_Value& vTextWidth = eC_FromInt(0),
        eC_Bool bWordWrap = false);
 
    CGUIEditableText(
        const CGUIObject* const pkParentObject,
        const TextResource_t &eTextID,
        const eC_Value& vXPos = eC_FromInt(0),
        const eC_Value& vYPos = eC_FromInt(0),
        const eC_Value& vTextWidth = eC_FromInt(0),
        eC_Bool bWordWrap = false);
 
    CGUIEditableText(const CGUIEditableText& rkSource);
 
    ~CGUIEditableText();
 
    CGUIEditableText& operator=(const CGUIEditableText& rkSource);
 
    void Insert(const eC_String& kInsChars);
 
    void Delete(
        eC_UInt uiCursorPosAtStartLine,
        eC_UInt uiCursorPosAtEndLine,
        eC_UInt uiStartLine = 0,
        eC_UInt uiEndLine = 0);
 
    virtual void PrintText();
 
    CGUIRect GetCursorAbsRect();
 
    virtual const eC_String* const GetPassword();
 
    CursorPos_t GetCursorPosition();
 
    CursorPos_t GetSelectionStart();
 
    CursorPos_t GetSelectionEnd();
 
    CursorPos_t GetCursorPosByCharIndex(eC_UInt uiCharIndex);
 
    virtual void SetTextString(const eC_String& rkTextString);
 
    void SetCursorPosition(
        eC_UInt uiCursorPosAtLine,
        eC_UInt uiCurrentLine = 0);
 
    CursorPos_t GetBestCursorPosition(const eC_Value& vRelXPos, const eC_Value& vRelYPos);
 
    void ResetTurningPoints();
 
    eC_UInt GetLtrTurnPnt(eC_UInt currentIndex);
 
    eC_UInt GetRtlTurnPnt(eC_UInt currentIndex);
 
    eC_Bool IsInLtRField(eC_UInt currentIndex);
 
    eC_Bool GetLTRpivotField(eC_UInt currentIndex, LeftEmbedding& ltrPivotPair);
 
    eC_Bool GetRectOfIndex(eC_UInt uiIndex, CGUIRect& rect);
 
    void SetEmbeddingDirection(const eC_Bool bRightToLeft);
 
    eC_Bool IsLeftToRightEmbedding();
 
    eC_Bool HasSelection();
 
    void SelectAll();
 
    void SetWordWrap(eC_Bool bWordWrap, const eC_Value& vWidth = eC_FromInt(0));
 
    void ResetSelection();
 
    void ExtendSelection(eC_UInt uiCharIndex, eC_UInt uiLineIndex = 0);
 
    void DeleteSelection();
 
    void SetCursorVisible(eC_Bool bVisible);
 
    void ToggleCursor();
 
    eC_Bool IsCursorVisible() const;
 
    void SetCursorWidth(eC_Value vWidth);
 
    eC_Value GetCursorWidth() const;
 
    void SetSelectionColor(const eC_UInt& uiSelectionColor);
 
    void SetSelectionColor(const GlobalProperty_t& uiSelectionColor);
 
    eC_UInt GetSelectionColor() const;
 
    virtual void SetFont(const FontResource_t &eFontID);
 
    void SetPasswordCharacter(eC_String& kPwdStr);
 
    void SetPasswordMode(eC_Bool bPasswordMode);
 
    CursorPos_t GetLastCursorPos();
 
    eC_String GetStrOfLine(eC_UInt uiCurrentLine) const;
 
    eC_String GetSelectedText();
 
    eC_Value GetLineHeight()
    {
        return m_vLineHeight;
    }
 
    virtual CGUIEditableText* Clone() const;
 
#ifdef GUILIANI_STREAM_GUI
    void ReadFromStream();
#endif
 
#ifdef GUILIANI_WRITE_GUI
    virtual void WriteToStream(const eC_Bool bWriteTextType = false);
#endif
 
private:
    typedef eC_TListDoubleLinked<eC_Value> WidthList;
 
    typedef WidthList::Iterator WidthListIterator;
 
    eC_Bool m_bRtLEmbedding;
 
    class CursorIndex_t
    {
    public:
        CursorIndex_t(
            eC_UInt uiCursorIndex,
            const WidthListIterator& kCursorIter,
            WidthList* pList) :
            m_uiCursorIndex(uiCursorIndex),
            m_kCursorIter(kCursorIter),
            m_pList(pList)
        {
        }
 
        CursorIndex_t() :
            m_uiCursorIndex(0),
            m_pList(NULL)
        {
        }
 
        CursorIndex_t& operator++() // prefix
        {
            if ((m_pList != NULL) && (m_uiCursorIndex + 1 < m_pList->GetQuantity()))
            {
                ++m_kCursorIter;
                ++m_uiCursorIndex;
            }
            return *this;
        }
 
        CursorIndex_t operator++(int) // postfix
        {
            CursorIndex_t kResult = *this;
            operator++();
            return kResult;
        }
 
        CursorIndex_t& operator--() // prefix
        {
            if (m_uiCursorIndex > 0)
            {
                --m_uiCursorIndex;
                --m_kCursorIter;
            }
            return *this;
        }
 
        CursorIndex_t operator--(int) // postfix
        {
            CursorIndex_t kResult = *this;
            operator--();
            return kResult;
        }
 
        eC_Value operator*()
        {
            if (m_kCursorIter.IsValid())
            {
                return *m_kCursorIter;
            }
            return eC_FromInt(0);
        }
 
        eC_Bool operator==(CursorIndex_t kCursorIndex)
        {
            return m_uiCursorIndex == kCursorIndex.m_uiCursorIndex &&
                m_kCursorIter == kCursorIndex.m_kCursorIter;
        }
 
        eC_Bool operator==(eC_UInt uiCursorIndex)
        {
            return m_uiCursorIndex == uiCursorIndex;
        }
 
        eC_Bool operator!=(CursorIndex_t kCursorIndex)
        {
            return !operator==(kCursorIndex);
        }
 
        eC_Bool operator!=(eC_UInt uiCursorIndex)
        {
            return m_uiCursorIndex != uiCursorIndex;
        }
 
        eC_Bool operator>(eC_UInt uiCursorIndex)
        {
            return m_uiCursorIndex > uiCursorIndex;
        }
 
        eC_Bool operator<(eC_UInt uiCursorIndex)
        {
            return m_uiCursorIndex < uiCursorIndex;
        }
 
        void SetCursorIndex(eC_UInt uiCursorIndex, const WidthListIterator& kCursorIter, WidthList* pList)
        {
            m_uiCursorIndex = uiCursorIndex;
            m_kCursorIter = kCursorIter;
            m_pList = pList;
        }
 
        eC_UInt GetCursorIndex() const
        {
            return m_uiCursorIndex;
        }
 
        WidthListIterator GetCursorIter() const
        {
            return m_kCursorIter;
        }
 
    private:
        eC_UInt m_uiCursorIndex;
 
        WidthListIterator m_kCursorIter;
 
        WidthList* m_pList;
    };
 
private:
    CGUIEditableText();
 
    void Init(const eC_Value& vTextWidth);
 
    void CopyAttributes(const CGUIEditableText& rkSource);
 
    virtual void SetTextSingleLine(const eC_Bool &bSingleLine);
 
    virtual void CollectHyphenationMarks(eC_String& rkStr, eC_UInt uiOffset);
 
    void DrawSelection();
 
    void DrawCursor();
 
    void SetIndexOfWidthList(eC_UInt uiIndexOfWidthList);
 
    void SetSelection(eC_UInt uiStartIndexOfWidthList, eC_UInt uiEndIndexOfWidthList);
 
    void RemoveString(eC_UInt uiStartIndexOfWidthList, eC_UInt uiEndIndexOfWidthList);
 
    eC_UInt LinePosToIndexOfWidthList(const CursorPos_t &tCursorLinePos);
 
    CursorPos_t GetCursorPositionFromIndex(eC_UInt uiIndexOfWidthList);
 
    void ComputeWidths(const eC_String &kAdjustedStr, eC_UInt uiStartIndexOfWidthList);
 
    // TODO: documentation
    void ComputeBidiWidths(const eC_String &kAdjustedStr, eC_UInt uiStartIndexOfWidthList);
 
    void AdjustWidths(
        ExtendedStringList_t::Iterator &StartStrIter,
        WidthListIterator &StartWidthIter,
        WidthListIterator &EndWidthIter);
 
    eC_UInt MoveCurrentWidthIndexToSafePos(
        eC_UInt uiCurrentWidthIndex,
        eC_UInt uiCursorPosAtCurrentLine,
        ExtendedStringList_t::Iterator &StrIter);
 
    void AdjustStr(
        eC_String* pkResultStr,
        eC_String* pkStrToAnalyse,
        eC_String* pkRestStr,
        WidthListIterator &StartWidthIter);
 
    void EnsureMinimumTextWidth();
 
private:
    WidthList m_kAccumulatedWidth;
 
    static const eC_UInt INDEX_COLOR_SELECTION;
 
    CursorIndex_t m_kIndexOfWidthList;
 
    CursorIndex_t m_kSelStartIndexOfWidthList;
 
    CursorIndex_t m_kSelEndIndexOfWidthList;
 
    eC_Value m_vCursorWidth;
 
    eC_Bool m_bCursorVisible;
 
    eC_Bool m_bPasswordMode;
 
    eC_String* m_pkPassword;
 
    eC_String m_kPwdChar;
 
    static const eC_UInt ms_uiInvalidPivot;
};
 
#endif