cinossiotftexp.h

//******************************************************************************
//******************************************************************************
 
#if !defined(_CINOSSIOTFTEXP)
#define _CINOSSIOTFTEXP
 
 
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
 
#include <inos_xml.h>
#include <cinossiotft.h>
 
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
 
#ifdef SMOS_COMPATIBLE
    /*
     * NOTE This is a workaround to support user layouts requiring many variables at the cost
     *      of having only 2 button rows instead of 6. To properly fix this issue,
     *      we need to rework this module in order to dynamically map touch identifiers to
     *      explorer items.
     */
    #define DF_SIOTFTEXP_MAX_PROCS                  64
    #define DF_SIOTFTEXP_MAX_VARS                   96
#else
    #define DF_SIOTFTEXP_MAX_PROCS                  16
    #define DF_SIOTFTEXP_MAX_VARS                   16
#endif
 
#define DF_SIOTFTEXP_NUMBER_NAME                80
#define DF_SIOTFTEXP_PROC_NAME                  32
#define DF_SIOTFTEXP_TAB_NAME                   32
 
 
// flags
 
#define DF_SIOTFTEXP_FLAG_REPAINT               0x00000001
#define DF_SIOTFTEXP_FLAG_RESET                 0x00000002
#define DF_SIOTFTEXP_FLAG_UPD_ENABLED           0x00000004
#define DF_SIOTFTEXP_FLAG_LINK_UP               0x00000008
//
#define DF_SIOTFTEXP_FLAG_USER_LAYOUT           0x00000010
#define DF_SIOTFTEXP_FLAG_REFRESH_BLOCKED       0x00000020
#define DF_SIOTFTEXP_FLAG_DEBUG                 0x00000040
#define DF_SIOTFTEXP_FLAG_HARDCOPY              0x00000080
 
#define DF_SIOTFTEXP_TYPE                       0x000F0000
#define DF_SIOTFTEXP_TYP_VAR                    0x00010000
#define DF_SIOTFTEXP_TYP_STATIC                 0x00020000
#define DF_SIOTFTEXP_TYP_NOP                    0x00030000
#define DF_SIOTFTEXP_TYP_MEMORY                 0x00040000
#define DF_SIOTFTEXP_TYP_TITLE                  0x00050000
//#define DF_SIOTFTEXP_TYP_GRAPHICS             0x00060000      // not yet done
#define DF_SIOTFTEXP_TYP_BMP                    0x00070000
 
#define DF_SIOTFTEXP_CHARACTERISTIC             0x00F00000
#define DF_SIOTFTEXP_CHAR_BIG                   0x00100000
#define DF_SIOTFTEXP_CHAR_HEX                   0x00200000
#define DF_SIOTFTEXP_CHAR_INVISIBLE             0x00400000
#define DF_SIOTFTEXP_CHAR_VALUE                 0x00800000
#define DF_SIOTFTEXP_CHAR_ACTIVE                0x01000000
 
#define DF_SIOTFTEXP_USERLEVEL                  0xF0000000
 
// makro to round an signed value correctly, used because fixed numbers contain
// a '1' in the lowest bit for the inco-server that adulterates the real value.
// This effect does not matter with fixed numbers but for intergers it is
// very bothering as they get truncated.
#define ROUND_SIGNED(value) value<0 ? value-=0.5 : value+=0.5;
 
// fix value, reason see comment for ROUND_SIGNED
#define FIX_SIGNED(type, value) (((type==defType_int64)||(type==defType_int32)||(type==defType_int16)||(type==defType_int8))&&(value < 0)) ? value-=1 : value;
 
// adjust value, reason see comment for ROUND_SIGNED
#define ADJUST_SIGNED(value) value = value - fixed64(0,1);
 
 
/*
    Maximally 6 button rows, maximally 16 variables, 16 procedures and 16 keys
    simultaneously on screen (in one tab)
 
    Button codes:
    0x00:       nothing, no key pressed, no button pressed
    0x01-0x0F:  special/internal commands
        0x01: row 1 scroll left
        0x02: row 1 scroll right
        0x03: row 2 scroll left
        0x04: row 2 scroll right
        0x05: row 3 scroll left
        0x06: row 3 scroll right
        0x07: row 4 scroll left
        0x08: row 4 scroll right
        0x09: row 5 scroll left
        0x0A: row 5 scroll right
        0x0B: row 6 scroll left
        0x0C: row 6 scroll right
 
        0x0D: reset required
*/
#define DF_SIOTFTEXP_CMD_SPECIAL                0x10
#define DF_SIOTFTEXP_CMD_LEVEL                  0x20
#ifdef SMOS_COMPATIBLE
    /*
     * NOTE This is a workaround to support user layouts requiring many variables at the cost
     *      of having only 2 button rows instead of 6. To properly fix this issue,
     *      we need to rework this module in order to dynamically map touch identifiers to
     *      explorer items.
     */
/*
    0x10-0x2F:  row 1 buttons
    0x30-0x4F:  row 2 buttons
    0x50-0x6F:  96 variables to edit
    0x70-0x8F:  
    0x90-0xAF:  
    0xB0-0xCF:  64 call procedure buttons
    0xD0-0xDF:  
    0xE0-0xEF:  
    0xF0-0xFF:  16 matrix keys
*/
    #define DF_SIOTFTEXP_CMD_VARIABLE               0x50
    #define DF_SIOTFTEXP_CMD_PROCEDURE              0xB0
#else
/*
    0x10-0x2F:  row 1 buttons
    0x30-0x4F:  row 2 buttons
    0x50-0x6F:  row 3 buttons
    0x70-0x8F:  row 4 buttons
    0x90-0xAF:  row 5 buttons
    0xB0-0xCF:  row 6 buttons
    0xD0-0xDF:  16 variables to edit
    0xE0-0xEF:  16 call procedure buttons
    0xF0-0xFF:  16 matrix keys
*/
    #define DF_SIOTFTEXP_CMD_VARIABLE               DF_SIOTFT_CMD_AREA
    #define DF_SIOTFTEXP_CMD_PROCEDURE              0xE0
#endif
#define DF_SIOTFTEXP_CMD_KEYMATRIX              0xF0
 
 
enum ETFTCharCmd
{
    eTFTCharSet,
    eTFTCharAdd,
    eTFTCharClear
};
 
 
//------------------------------------------------------------------------------
// variables
//------------------------------------------------------------------------------
 
class CINOSSioTftExp;
class CINOSSioTftExpTab;
 
class CTFTIncoMember
{
    friend class CINOSSioTftExp;
    friend class CINOSSioTftExpTab;
 
    public:
        CTFTIncoMember(CINOSSioTftExpTab* apParent, XMLNode axVarNode);
 
        virtual ~CTFTIncoMember();
 
        virtual void GetValueLimited(char* apBuf, uint32 auSize);
 
        virtual void GetValue(char* apBuf, uint32 auSize);
 
        virtual void SetValue(char* apBuf);
 
        virtual void GetUnit(char* apBuf, uint32 auSize);
 
        virtual uint32 GetCharacteristics();
 
        bool SetCharacteristics(uint32 auChar, ETFTCharCmd aeCmd);
 
        virtual bool IsWritable(uint32 auUserLevel);
 
        virtual void SelLanguage(const char* apLangName, const char* apLangFile,
                const char* apLangFileEnd);
 
        virtual bool UpdateInco();
 
        virtual bool RepaintNeeded();
 
        virtual const char* GetName();
 
        virtual const char* FindName(const char* apLangName=NULL) { return NULL; }
 
        virtual void GetDefaultName(char* apBuf, uint32 auSize) {
            const char* name=FindName(NULL);
            if (name) inos_strncpy(apBuf, name, auSize);
        }
 
        virtual bool CanToggle() {return false;};
 
        virtual void Toggle() {};
 
 
        virtual uint16 GetCoordX() {
            return m_uCoordX;
        }
 
        virtual uint16 GetCoordY() {
            return m_uCoordY;
        }
 
        virtual void SetCoordY(uint16 auCoordY) {
            m_uCoordY=auCoordY;
        }
 
        virtual uint16 GetSizeX() {
            return m_uSizeX;
        }
 
        virtual uint16 GetSizeY() {
            return m_uSizeY;
        }
 
        virtual bool HitTest(uint16 auCoordX, uint16 auCoordY) {
            if (m_uType&DF_SIOTFTEXP_CHAR_INVISIBLE) {
                return false;
            }
            return ((m_uCoordX<=auCoordX)&&(auCoordX<(m_uCoordX+m_uSizeX))&&
                    (m_uCoordY<=auCoordY)&&(auCoordY<(m_uCoordY+m_uSizeY)));
        }
 
        virtual EBlockTextAlignment GetAlignment() {
            return m_eAlign;
        }
 
        uint8 GetForeColor();
 
        uint8 GetBackColor();
        void SetBackColor(uint8 auColor);
 
        uint8 GetFrame() {
            return m_uFrame;
        }
        
        STFTFontInfo& GetFont() {
            return m_Font;
        }
 
        void SetReadOnly () {
            m_bUserReadOnly = true;
        }
 
        void SetWritable () {
            m_bUserReadOnly = false;
        }
 
        uint8 GetKeyBoard () const {
            return m_uKeyboard;
        }
 
    protected:
        CINOSSioTftExpTab* m_pParent;
        XMLNode m_xVarNode;
        const char* m_pName;
        uint32 m_uType;
        uint16 m_uColumns;
        uint16 m_uCoordX;
        uint16 m_uCoordY;
        uint8 m_uHeight;
        uint16 m_uSizeX;
        uint16 m_uSizeY;
        EBlockTextAlignment m_eAlign;
        uint8 m_uColFore;
        uint8 m_uColBack;
        uint8 m_uFrame;
        uint8 m_uKeyboard;
        bool m_bReadOnly;
        bool m_bUserReadOnly;
        STFTFontInfo m_Font;
};
 
 
//------------------------------------------------------------------------------
class CTFTIncoVariable:public CTFTIncoMember
{
    friend class CINOSSioTftExpTab;
 
 
    public:
 
        typedef void (*OnValueChanged)(CTFTIncoVariable*, void*, const double);
 
        typedef double (*OnValueConversion)(CTFTIncoVariable*, void*, const double, bool);
 
    public:
        CTFTIncoVariable(CINOSSioTftExpTab* apParent, XMLNode axVarNode);
 
        virtual ~CTFTIncoVariable() {}
 
        virtual void GetValueLimited(char* apBuf, uint32 auSize) override;
 
        virtual void GetValue(char* apBuf, uint32 auSize) override;
 
        virtual void SetValue(char* apBuf) override;
 
        virtual void GetUnit(char* apBuf, uint32 auSize) override;
 
        virtual uint32 GetCharacteristics() override;
 
        virtual bool IsWritable(uint32 auUserLevel) override;
 
        virtual bool UpdateInco() override;
        virtual bool RepaintNeeded() override;
 
        virtual const char* FindName(const char* apLangName=NULL) override;
 
        static void setConversionFunc(OnValueConversion func, void* apContext);
 
        static void setValueChangeFunc(OnValueChanged func, void* apContext);
 
        virtual bool CanToggle() override;
 
        virtual void Toggle() override;
 
        virtual CINCOItem* GetItem () const;
 
        virtual void SetDigits (int8 aiDigits);
 
    protected:
        void ValueChanged(const double value);
 
    protected:
        CINCOItem* m_pItem;
        uint16 m_uIndex;
        int8 m_iDigits;
        static OnValueConversion s_pConversionFunc;
        static OnValueChanged s_pValueChangedFunc;
        static void* s_pContext;
        real64 m_dMin;
        real64 m_dMax;
        
};
 
 
//------------------------------------------------------------------------------
class CTFTIncoNop:public CTFTIncoMember
{
    public:
        CTFTIncoNop(XMLNode axVarNode):CTFTIncoMember(NULL, axVarNode)
        {
            m_uType|=DF_SIOTFTEXP_TYP_NOP;
        }
 
        virtual ~CTFTIncoNop() {}
};
 
 
//------------------------------------------------------------------------------
class CTFTIncoTitle:public CTFTIncoMember
{
    public:
        CTFTIncoTitle(CINOSSioTftExpTab* apParent, XMLNode axVarNode)
                : CTFTIncoMember(apParent, axVarNode)
        {
            m_uType|=DF_SIOTFTEXP_TYP_TITLE;
        }
 
        virtual ~CTFTIncoTitle() {}
 
        virtual const char* FindName(const char* apLangName=NULL) override;
};
 
 
//------------------------------------------------------------------------------
class CTFTIncoStatic:public CTFTIncoMember
{
    friend class CINOSSioTftExpTab;
 
    public:
        CTFTIncoStatic(CINOSSioTftExpTab* apParent, XMLNode axVarNode)
                : CTFTIncoMember(apParent, axVarNode), m_pValue(NULL)
        {
            m_uType|=DF_SIOTFTEXP_TYP_STATIC;
        }
 
        virtual ~CTFTIncoStatic() {}
 
        virtual void GetValue(char* apBuf, uint32 auSize) override;
 
        virtual const char* FindName(const char* apLangName=NULL) override;
 
    protected:
        const char* m_pValue;
};
 
 
//------------------------------------------------------------------------------
class CTFTIncoMemory:public CTFTIncoMember
{
    public:
        CTFTIncoMemory(CINOSSioTftExpTab* apParent, XMLNode axVarNode)
                : CTFTIncoMember(apParent, axVarNode), m_uAdr(0)
        {
            m_uType|=DF_SIOTFTEXP_TYP_MEMORY;
        }
 
        virtual ~CTFTIncoMemory() {}
 
        virtual void GetValue(char* apBuf, uint32 auSize) override;
 
        virtual void SetValue(char* apBuf) override;
 
        virtual uint32 GetCharacteristics() override;
 
        virtual bool IsWritable(uint32 auUserLevel) override;
 
        virtual const char* FindName(const char* apLangName=NULL) override;
 
        void SetAdr(uint32 auAdr) {
            m_uAdr=auAdr;
        }
 
    protected:
        uintptr m_uAdr;
 
};
 
 
//------------------------------------------------------------------------------
class CTFTIncoBitmap:public CTFTIncoMember
{
    friend class CINOSSioTftExpTab;
 
    public:
        CTFTIncoBitmap(CINOSSioTftExpTab* apParent, XMLNode axVarNode, void* apData, uint16 auSize)
                : CTFTIncoMember(apParent, axVarNode)
                , m_pData((uint8*)apData), m_uSize(auSize)
        {
            m_uType|=DF_SIOTFTEXP_TYP_BMP;
        }
 
        virtual ~CTFTIncoBitmap() {}
 
//      virtual void GetValue(char* apBuf, uint32 auSize);
 
        virtual const char* FindName(const char* apLangName=NULL) override;
 
        void SetCoordY(uint16 auCoordY) override {
            // do nothing
        }
        uint8* GetData() {
            return m_pData;
        }
        uint16 GetSize() {
            return m_uSize;
        }
 
    protected:
        uint8* m_pData;
        uint16 m_uSize;
};
 
 
//------------------------------------------------------------------------------
class CINOSSioTftExpProc
{
    public:
        CINOSSioTftExpProc(CINOSSioTftExpTab* apParent, XMLNode axConfigNode,
                CINCOProcedure* apProcItem);
 
        const char* GetName() { return m_pName; }
 
        void GetDefaultName(char* apBuf, uint32 auSize) {
            const char* name=FindName(NULL);
            if (name) inos_strncpy(apBuf, name, auSize);
        }
 
        const char* FindName(const char* apLangName=NULL);
 
        void SelLanguage(const char* apLangName, const char* apLangFile,
                const char* apLangFileEnd);
 
        inline uint32 GetCharacteristics() {
            return m_uCharacteristics;
        }
 
        bool SetCharacteristics(uint32 auChar, ETFTCharCmd aeCmd);
 
        bool UpdateInco();
        bool RepaintNeeded();
 
        CINCOProcedure* GetProc() {
            return m_pProc;
        }
 
        uint16 GetCoordX() {
            return m_uCoordX;
        }
 
        uint16 GetCoordY() {
            return m_uCoordY;
        }
 
        uint16 GetSizeX() {
            return m_uSizeX;
        }
 
        uint16 GetSizeY() {
            return m_uSizeY;
        }
 
        bool HitTest(uint16 auCoordX, uint16 auCoordY) {
            return ((m_uCoordX<=auCoordX)&&(auCoordX<(m_uCoordX+m_uSizeX))&&
                    (m_uCoordY<=auCoordY)&&(auCoordY<(m_uCoordY+m_uSizeY)));
        }
 
        const char* GetBitmap() {
            if (m_uCharacteristics&DF_SIOTFTEXP_CHAR_ACTIVE) {
                return m_pBitmapActive;
            } else {
                return m_pBitmapInactive;
            }
        }
 
        void Call();
 
    protected:
        CINOSSioTftExpTab* m_pParent;
        XMLNode m_xProcNode;
        const char* m_pName;
        CINCOProcedure* m_pProc;
        uint16 m_uCoordX;
        uint16 m_uCoordY;
        uint16 m_uSizeX;
        uint16 m_uSizeY;
        const char* m_pBitmapActive;
        const char* m_pBitmapInactive;
        uint32 m_uCharacteristics;
};
 
typedef CINOSSioTftExpProc* TINOSSioTftExpProc;
 
 
//------------------------------------------------------------------------------
// CINOSSioTftExpTab
//------------------------------------------------------------------------------
 
class CINOSSioTftExpTab
{
    friend class CINOSSioTftExp;
 
    public:
        CINOSSioTftExpTab(XMLNode axTabNode, CINOSSioTftExpTab* apParent);
 
        virtual ~CINOSSioTftExpTab();
 
        void AddTab(CINOSSioTftExpTab* apSubTab);
 
        void AddProc(XMLNode axProcNode);
 
        void AddVar(XMLNode axVarNode);
 
        void InheritProcs(TINOSSioTftExpProc* apProcs);
 
        const char* GetDefaultName() {
            return m_xTabNode.getAttribute(XML_ATTR_NAME_NAME);
        }
 
        CINOSSioTftExpTab* GetTabAt(uint32 auIndex);
 
        CINOSSioTftExpTab* FindAndSelectTab(char* apTab);
 
        CINOSSioTftExpTab* FindTab(const char* const apTab, bool abSelect);
 
        CTFTIncoMember* FindMember(const char* const apPath);
 
        TINOSSioTftExpProc FindProc(const char* const apPath);
 
        bool SetCharacteristics(uint32 auChar, ETFTCharCmd aeCmd);
 
        void SelLanguage(const char* apLangName, bool abRecursive,
                const char* apLangFile, const char* apLangFileEnd);
 
        bool UpdateInco();
        bool RepaintNeeded();
 
        inline uint32 GetCharacteristics() {
            return m_uCharacteristics;
        }
 
        void ReadTab(XMLNode axNode, uint32 auLevel=0);
 
        uint8 GetForeColor() {
            if (m_uColFore!=255) {
                return m_uColFore;
            }
            return m_pParent->GetForeColor();
        }
 
        uint8 GetBackColor() {
            if (m_uColBack!=255) {
                return m_uColBack;
            }
            return m_pParent->GetBackColor();
        }
 
        virtual uint16 GetCoordX() {
            return m_uCoordX;
        }
 
        virtual uint16 GetCoordY() {
            return m_uCoordY;
        }
 
        virtual void SetCoordX(uint16 auCoordX) {
            m_uCoordX=auCoordX;
        }
 
        virtual void SetCoordY(uint16 auCoordY) {
            m_uCoordY=auCoordY;
        }
 
        virtual uint16 GetSizeX() {
            return m_uSizeX;
        }
 
        virtual uint16 GetSizeY() {
            return m_uSizeY;
        }
 
        bool HitTest(uint16 auCoordX, uint16 auCoordY) {
            return ((m_uCoordX<=auCoordX)&&(auCoordX<(m_uCoordX+m_uSizeX))&&
                    (m_uCoordY<=auCoordY)&&(auCoordY<(m_uCoordY+m_uSizeY)));
        }
 
    private:
        XMLNode m_xTabNode;
        const char* m_pName;
        CINOSSioTftExpTab* m_pChildrenHead;
        CINOSSioTftExpTab* m_pPrev;
        CINOSSioTftExpTab* m_pNext;
        CINOSSioTftExpTab* m_pParent;
        CINOSSioTftExpTab* m_pActive;
        uint32 m_uTabCount;
        uint32 m_uActualColumns;
        uint32 m_uCharacteristics;
        uint16 m_uWidth;
        uint8 m_uFirstVisibleChild;
 
        uint16 m_uCoordX;
        uint16 m_uCoordY;
//      uint16 m_uCfgWidth;
//      uint16 m_uCfgHeight;
        uint16 m_uSizeX;
        uint16 m_uSizeY;
        uint8 m_uColFore;
        uint8 m_uColBack;
        const char* m_pBitmapActive;
        const char* m_pBitmapInactive;
 
        TINOSSioTftExpProc m_pProcs[DF_SIOTFTEXP_MAX_PROCS];
        TINOSDoubleLinkedList<CTFTIncoMember>* m_pVariables;
 
};
 
 
//------------------------------------------------------------------------------
// CTFTIEuint8
//------------------------------------------------------------------------------
 
class CTFTIELuint8:public CINCOuint8
{
    // constructor
    public:
        CTFTIELuint8(
            char*           aName,          // object name
            void*           aData,          // pointer to object data
            CINOSSioTftExp* apExplorer,     // pointer to my var exp
            uint32          aLower,         // lower bound
            uint32          aUpper,         // upper bound
            char*           aUnit=0,        // unit of object
            unsigned short  aChar=defCharShowDec,// characteristics of object
            uint16      aKeyLevel=cKeyLevelMin, // keylevel of object
            unsigned short  aArrayLength=1  // array length of object
            );
 
        CTFTIELuint8(
            char*   aName,
            void*   aData,
            CINOSSioTftExp* apExplorer,     // pointer to my var exp
            CINCOintConfig* aConfig=0
            );
 
 
    // public member functions
    public:
        virtual long Put(void* aSource, long aIndex=0, long aOffset=0) override;
 
    protected:
        CINOSSioTftExp* m_pExplorer;
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CTFTIELuint8);
};
 
 
//------------------------------------------------------------------------------
// CINOSSioTftExp
//------------------------------------------------------------------------------
 
class CINOSSioTftExp : public CINOSTask
{
    typedef void (*InitDoneFunc)(CINOSSioTftExp* apExp, void* apContext);
    typedef void (*OnTabChangeFunc)(void* apContext);
 
    //--------------------------------------------------------------------------
    // user interface
    //--------------------------------------------------------------------------
    public:
        static CINOSSioTftExp* Find(const char* apExplorer);
 
        CINOSSioTftExp(const char* acName, CINOSSioTft* apDisplay, const char* acConfig);
 
        virtual ~CINOSSioTftExp();
 
        void SelLanguage(uint32 auLangIndex);
 
        uint32 GetLanguage();
 
        const char* GetLangFileName(uint32 auLangIndex) const;
 
        void SetUserLevel(uint32 auLevel);
 
        void GetActualTab(char* apTab, uint32 auLength, bool abFullPath=false);
 
        void SetActualTab(char* apTab);
 
        void GetActualVar(char* apVar, uint32 auLength);
 
        void GetActualVarLang(char* apVar, uint32 auLength);
 
        void GetActualVarValue(char* apVal, uint32 auLength);
 
        bool UpdateInco();
        bool RepaintNeeded();
        void Refresh ();
 
        void HardCopy (int16 aiXX1 = -1, int16 aiYY1 = -1,
                int16 aiXX2 = -1, int16 aiYY2 = -1,
                bool abUseRLE = true);
 
        uint32 GetPressedKeys() {
            return m_uUserKeys;
        }
 
        uint32 GetFlags() {
            return m_uFlags;
        }
 
        CINOSSioTftExpTab* GetTopTab () const {
            return m_pTopTab;
        }
 
        void EnableRefresh(bool abRefresh) {
            if (abRefresh) {
                m_uFlags&=~DF_SIOTFTEXP_FLAG_REFRESH_BLOCKED;
            } else {
                m_uFlags|=DF_SIOTFTEXP_FLAG_REFRESH_BLOCKED;
            }
        }
 
        void SetTabCharacteristics(const char* const acTabPath,
                uint32 auCharacteristics, ETFTCharCmd aeCmd);
 
        bool SetVarCharacteristics(const char* const acVarPath,
                uint32 auCharacteristics, ETFTCharCmd aeCmd);
 
        bool SetProcCharacteristics(const char* const acPath,
                uint32 auCharacteristics, ETFTCharCmd aeCmd);
 
        void Reset();
        
        void SetInitDoneCallback(InitDoneFunc callback, void* apContext);
 
        void SetTabChangeCallback(OnTabChangeFunc callback, void* apContext);
 
    //--------------------------------------------------------------------------
    // for internal use only, not documented by Doxygen
    //--------------------------------------------------------------------------
#ifndef DOXYGEN_USER_BUILD
 
    friend class CINOSSioTftExpTab;
    friend class CTFTIELuint8;
 
    public:
        static void MakeFloatValue(char* apBuf, void* apValue, char acFormat, uint16 auDigits);
 
        static uint32 ReplaceNewLines(char* apText, uint32 auSize, bool abEscaping);
 
        static void AppendSpaces(char* apText, uint32 auSize);
 
    protected:
        void Init();
 
        uint32 GetRows(STFTFontInfo& arInfo) {
            ASSERT_ALWAYS(arInfo.m_uHeight!=0);
            ASSERT_ALWAYS(arInfo.m_uZoomY!=0);
            return m_pSioTft->GetHeight()/arInfo.GetRealHeight();
        }
 
        uint32 GetColumns(STFTFontInfo& arInfo) {
            ASSERT_ALWAYS(arInfo.m_iWidth!=0);
            ASSERT_ALWAYS(arInfo.m_uZoomX!=0);
            return m_pSioTft->GetWidth()/(arInfo.m_iWidth*arInfo.m_uZoomX);
        }
 
        uint32 ShowTab(CINOSSioTftExpTab* apTab, uint32 auLevel);
 
        uint32 ShowTabFix(CINOSSioTftExpTab* apTab, uint32 auLevel);
 
        void ShowProcs(CINOSSioTftExpTab* apTab);
 
        void ShowProcsFix(CINOSSioTftExpTab* apTab);
 
        void ShowVars(uint32 auCoordY, CINOSSioTftExpTab* apTab, bool abNames=false);
 
        void ShowVarsFix(CINOSSioTftExpTab* apTab, bool abNames=false);
 
        void TextOut(uint16 auCoordX, uint16 auCoordY, char* pText,
                STFTFontInfo& arFontInfo, int16 aiStrLength=-1, uint32 auFlags=0);
 
        void TextOutFix(uint16 auStartCoordX, uint16 auStartCoordY,
                uint16 auEndCoordX, uint16 auEndCoordY, EBlockTextAlignment aeBlockAlignment,
                char* apText, STFTFontInfo& arFontInfo, int16 aiStrLength=-1,
                uint32 auFlags=0);
 
        void ResetDisplay();
 
        CINOSSioTftExp* GetNext() {
            return m_pNext;
        }
 
        void HandleCommands();
 
        virtual void Action() override;
 
        void ActivateFirstChild();
 
        void ProcessLangFile(char* apFile);
 
        void HandleHardcopy ();
 
    protected:
        static CINOSSioTftExp* m_pFirst;
        CINOSSioTftExp* m_pNext;
        CINOSSioTft* m_pSioTft;
        CINOSSioTftExpTab* m_pTopTab;
        CINOSSioTftExpTab* m_pActiveTab;
        CTFTIncoMember* m_pActiveVar;
        CINOSSemaphore m_CKeySemaphore;
        const char* m_pConfig;
        uint16 m_uLangCount;
        const char** m_ppLangFile;
        const char** m_ppLangFileEnd;
        const char** m_ppLangFiles;
 
        STouchButton m_DefButton;
        CINOSSioTftExpTab* m_pVisibleTabs[256];
        CTFTIncoMember* m_TouchMembers[DF_SIOTFTEXP_MAX_VARS];
        CINOSTime m_ThrobberTime;
 
        STFTFontInfo m_TabFont;
        STFTFontInfo m_VarFont;
        STFTFontInfo m_VarFontBig;
        STFTFontInfo m_ProcFont;
 
        uint16 m_uWidth;
        uint16 m_uHeight;
        uint16 m_uTopDivider;
        uint16 m_uBottomDivider;
        uint8 m_uActLanguage;
        uint8 m_uUserLevel;
        uint8 m_uVarColumns;
        uint8 m_uValueColumn;
        uint8 m_uUnitColumn;
        uint8 m_uTabBtnSize;
        uint8 m_uProcBtnSize;
        uint8 m_uThrobber;
        uint8 m_uThrobberSize;
        STFTHardcopy m_HardCopyInstruction;
        uint32 m_uFlags;
        uint32 m_uUserKeys;
        uint32 m_uTime;
        const char* m_pTFTProject;
        const char* m_pMacroFile;
        InitDoneFunc m_pInitDoneCallback;
        void* m_pInitDoneContext;       
        OnTabChangeFunc m_pTabChangeCallback;
        void* m_pTabChangeContext;
 
    public:
        static CINOSMutex m_mMutex;
 
#endif // DOXYGEN_USER_BUILD
 
    // end CINOSSioTftExp
};
 
 
//------------------------------------------------------------------------------
inline void SkipText(const char*& apText)
{
    while (*apText) {
        apText++;
    }
}
 
 
//------------------------------------------------------------------------------
inline void SkipNull(const char*& apText)
{
    while (!*apText) {
        apText++;
    }
}
 
 
//------------------------------------------------------------------------------
// global defs
//------------------------------------------------------------------------------
 
 
 
//------------------------------------------------------------------------------
 
#endif // _CINOSSIOTFTEXP
 
 
//------------------------------------------------------------------------------
// end of file