RtDisplay.h

#ifndef CARMA_UI_RTD_RTDISPLAY_H
#define CARMA_UI_RTD_RTDISPLAY_H


/*
 * @file
 *
 * Realtime display windows and all the elements of composition.
 * This file is much too long and should be broken up into pieces.
 *
 * @author Steve Scott
 *
 * $CarmaCopyright$
 *
 */


#include <iomanip>
#include <string>
#include <sstream>
#include <vector>
#include <memory>
#include <cstring>

#include <boost/shared_ptr.hpp>

namespace rtdproto {
    class UIMessageRequest;
    class UIMessageReply;
    class RtObject;
}

namespace carma {

namespace services {
    class AstroTime;
}  // namespace carma::services

namespace ui {
namespace rtd {


class ReaderWithTimeout;


typedef enum {
    NONE_LAYOUT,
    UNFILLED_LAYOUT,
    CHAIN_LAYOUT,
    EOL_CENTERED_LAYOUT,
    EOL_RIGHT_JUSTIFIED_LAYOUT,
    EOL_LEFT_JUSTIFIED_LAYOUT
} Layout;

typedef enum {
        FONT_PLAIN,
        FONT_BOLD,
        FONT_ITALIC,
        FONT_BOLD_ITALIC,
} FontType;


class RtObject {
    public:
        virtual ~RtObject( );

        virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj) = 0;

        virtual void update( ) = 0;

        void setLayout(Layout layout);

        Layout getLayout( ) const;

        void setFontSize(int fontSize);

        void setToolTipText(const std::string & text);

        void appendToolTipText(const std::string & text);

        std::string getToolTipText() ;

    protected:
        explicit RtObject();

        int getFontSize(int parentFontSize) const;

        int getFontSize() const;

    private:
        Layout layout_;
        std::string toolTipText_;
        int fontSize_;
};

typedef boost::shared_ptr<RtObject> RtObjectPtr;

class Format {
public:
    explicit Format();
    
    Format(int width, int indent, int len);
    
    Format( const Format & rhs );
    
    explicit Format( const char * s );
    
    void fmt( const char * s );
    
    int width;
    int indent;
    int len;
    void dump();
private:
    void init();
};

typedef enum CellColorEnum {
    WHITE_CELL_COLOR,
    RED_CELL_COLOR,
    YELLOW_CELL_COLOR,
    GREEN_CELL_COLOR,
    BLUE_CELL_COLOR,
    ORANGE_CELL_COLOR,
    CYAN_CELL_COLOR,
    MAGENTA_CELL_COLOR,
    BLACK_CELL_COLOR,
    PURPLE_CELL_COLOR,
    LIGHT_GRAY_CELL_COLOR,
    STRIPE_LIGHT_CELL_COLOR,
    STRIPE_DARK_CELL_COLOR,
    LIGHT_GRAY_TEXT_CELL_COLOR, // Cell is white, text gray-ed out
    EMPTY_CELL_COLOR,
} CellColor;

class Cell;
typedef boost::shared_ptr<Cell> CellPtr;

class Cell:public RtObject {
public:
    Cell(int indent, int chars, int width);
    explicit Cell(const char* fmt, int altLen=0);

    explicit Cell(const Format& fmt,int altLen=0);

    void setColor( CellColor color );

    void setNohwColor( CellColor color );

    /*
     * Grays out the text
     */
    void setGrayedOut(bool state) { grayedOut_ = state; }
    
    bool isGrayedOut() { return grayedOut_; }

        /*
     * Sets the cell state so that it is rendered as a white empty box.
     * @param 
     */
    void setEmpty(bool state);
  
    std::string   getText();

    int getIndent( ) const;

    int getLen( ) const;

    bool isReplaceText( ) const;

    bool isPlottable( ) const;

    char          getAudio();

     void setBorderTopEnabled(bool state)    { borderTopEnabled_    = state; }
     void setBorderRightEnabled(bool state)  { borderRightEnabled_  = state; }
     void setBorderBottomEnabled(bool state) { borderBottomEnabled_ = state; }
     void setBorderLeftEnabled(bool state)   { borderLeftEnabled_   = state; }

    int addAlternative( const ::std::string & text,
                        CellColor             color );

    void setActiveAlternative( int index );

    void clearActiveAlternative( );

    bool alternativeIsActive( ) const;

    void setNa(bool tf);

    void setNohw(bool tf);

    void setPlottable(bool yesOrNo);

    void setAudio(char c);

    void setNoAudio();

    void setPlotLabel( const ::std::string & s );

    void setPlotLabel(int a, bool dev, const ::std::string & s);

    ::std::string getPlotLabel( ) const;

    void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);

    bool isValid();

    void setValidity(bool validity);

    void setCellName(const std::string &s) {
        cellName_ = s;
    }

    std::string getCellName() const {
        return cellName_;
    }

    void setDynamicDescription(const std::string &s) {
        dynamicDescription_ = s;
    }

    std::string getDynamicDescription() const {
        return dynamicDescription_;
    }

protected:
    virtual void  updateColor();

    ::std::string centerStringFmt( const ::std::string & s ) const;

    void updateInt(int data);

    int len;
    int indent;
    const Format format_;
    ::std::string text;

    ::std::ostringstream fmtOss_;

    const char* legit;

    char audio;

private:
    char getPlottableCode( ) const;

    CellColor getColor( );

    void          init();

    ::std::string centerString( const ::std::string & s,
                                bool                  fmtMode ) const;

    struct Alternative {
        ::std::string text;
        CellColor     color;
    };

    const int maxAlternativeLength_;

    int activeAlternative_;

    ::std::vector< Alternative > alternatives_;

    ::std::string alternativesErrText_;

    const char good_;

    bool isValid_;

    CellColor color_;

    ::std::string plotLabel_;

    ::std::string invalString_;

    ::std::string overflowString_;

    bool isPlottable_;

    bool          na_;
    ::std::string naString_;

    bool          noHw_;
    ::std::string noHwString_;
    CellColor     noHwColor_;
    
    bool grayedOut_;
        
    bool emptyCell_; // When true, the cell is a just a white box
    
    bool borderTopEnabled_;
    bool borderRightEnabled_;
    bool borderBottomEnabled_;
    bool borderLeftEnabled_;

    std::string cellName_;
    std::string dynamicDescription_;
};

//-------------------------------- EmptyCell ----------------------------------
class CellEmpty : public Cell {
    public:
        explicit CellEmpty( const char* fmt );

        explicit CellEmpty( const Format& fmt );

        virtual void update( );
};

//----------------------------- CellString -------------------------------
class CellString : public Cell {
public:
    CellString( const char*          fmt,
                const ::std::string& dataStringRef );

    CellString( const char*          fmt,
                const ::std::string& dataStringRef,
                const CellColor&     colorRef );

    CellString( const char*          fmt,
                const ::std::string& dataStringRef,
                int                  altLen );

    CellString( const Format&        fmt,
                const ::std::string& dataStringRef );

    CellString( const Format&        fmt,
                const ::std::string& dataStringRef,
                const CellColor&     colorRef );

    CellString( const Format&        fmt,
                const ::std::string& dataStringRef,
                int                  altLen );

    void setTruncate( bool truncate );

protected:
    virtual void update( );

    virtual void updateColor( );

private:
    void init();

    const ::std::string & dataStringRef_;

    const CellColor * const colorPtr_;

    bool truncate_;
};


//----------------------------- CellCharString -------------------------------
class CellCharString:public Cell {
public:
    CellCharString(const char* fmt, const char* string);
    CellCharString(const char* fmt, const char* string, int altLen);

    CellCharString(const Format& fmt, const char* string);

    CellCharString(const Format& fmt, const char* string, int altLen);

    virtual void update();
    virtual void updateColor();
    void setNotruncate() {
        truncateFlag = 0;
    }
protected:
    std::string   dataString;
    const char* data;
    bool  truncateFlag;
private:
    void init();
};


//-------------------------- CellCatString -------------------------------
class CellCatString:public Cell {
public:
    CellCatString(const char* fmt, const char* legit, const char* pre,
            const char* suf);
    CellCatString(const char* fmt, const char* legit, const char* pre,
            const char* suf, int altLen);
    CellCatString(const char* fmt, const char* pre, const char* suf);
    CellCatString(const Format& fmt, const char* legit, const char* pre,
            const char* suf);
    CellCatString(const Format& fmt, const char* legit, const char* pre,
            const char* suf, int altLen);
    CellCatString(const Format& fmt, const char* pre, const char* suf);

    virtual void update();
    virtual void updateColor();
    void setNotruncate() {
        truncateFlag = 0;
    }
protected:
    const char*   prefix;
    const char*   suffix;
    bool    truncateFlag;
private:
    void init();
};


//----------------------------- CellFloat -------------------------------
class CellFloat:public Cell {
public:
    CellFloat(const char* fmt, int rod, const char* legit, const float& data);
    CellFloat(const char* fmt, int rod, const char* legit, const float& data,
            int altLen);
    CellFloat(const char* fmt, int rod, const float& data);
    virtual void update();
protected:
    const float& data;
    const int     rod;
};


//----------------------------- CellDble -------------------------------
class CellDble:public Cell {
public:
    CellDble(const char* fmt, int rod, const char* legit, const double& data);
    CellDble(const char* fmt, int rod, const char* legit, const double& data,
            int altLen);
    CellDble(const char* fmt, int rod, const double& data);
    virtual void update();
protected:
    const double& data;
    const int     rod;
};


//----------------------------- CellRA&DEC -------------------------------

class CellRADEC:public CellDble {
public:
    CellRADEC(const char* fmt, int rod, const char* legit, const double& radec,
            const char* sourceType);
     CellRADEC(const char* fmt, int rod, const double& radec, const char* sourceType);
protected:
   const char*  sourceType;
   const double TWOPI;

   ::std::ostringstream scratchOSS_;
};

class CellRA:public CellRADEC {
public:
    CellRA(const char* fmt, int rod, const char* legit, const double& ra,
            const char* sourceType);
    CellRA(const char* fmt, int rod, const double& ra, const char* sourceType);
    virtual void update();
};
class CellDEC:public CellRADEC {
public:
    CellDEC(const char* fmt, int rod, const char* legit, const double& dec,
            const char* sourceType);
    CellDEC(const char* fmt, int rod, const double& dec, const char* sourceType);
    virtual void update();
};

//----------------------------- CellUT -------------------------------
class CellUT:public Cell{
public:
    CellUT(const char* fmt, int rod, const char* legit, const double& _mjd);
    CellUT(const char* fmt, int rod, const double& _mjd);
    virtual void update();
protected:
    const double& mjd;
    std::string makeUTstring();
private:
    const int     rod;

    ::std::ostringstream scratchOSS_;
};

//----------------------------- CellDateUT -------------------------------
class CellDateUT:public CellUT {
public:
    CellDateUT(const char* fmt, int rod, const char* legit, const double& _mjd,
            int choice=0);
    CellDateUT(const char* fmt, int rod, const double& _mjd, int choice=0);
    virtual void update();
private:
    const int choice_;
};



//----------------------------- CellInt's -------------------------------

class CellInt:public Cell {
public:
    CellInt(const char* fmt, const char* legit, const int& data);
    CellInt(const char* fmt, const char* legit, const int& data, int altLen);
    CellInt( const char * fmt,
             const int &  data );

    CellInt( const Format & fmt,
             const int &    data );

    virtual void update() {
        updateInt(data);
    }
protected:
    const int&  data;
};

class CellShort:public Cell {
public:
    CellShort(const char* fmt, const char* legit, const short& data);
    CellShort(const char* fmt, const char* legit, const short& data, int altLen);
    CellShort(const char* fmt, const short& data);
    virtual void update() {
        updateInt(static_cast< int >(data));
    }
protected:
    const short&  data;
};


class CellChar:public Cell {
public:
    CellChar(const char* fmt, const char* legit, const char& data);
    CellChar(const char* fmt, const char* legit, const char& data, int altLen);
    CellChar(const char* fmt, const char& data);

    virtual void update() {
        updateInt(static_cast< int >(data+idTranslation));
    }
    CellChar* idTranslate() {
        idTranslation=1;
        return this;
    }
protected:
    const char&  data;
    int idTranslation;
};


class CellUChar:public Cell {
public:
    CellUChar(const char* fmt, const char* legit, const unsigned char& data);
    CellUChar(const char* fmt, const char* legit, const unsigned char& data,
            int altLen);
    CellUChar(const char* fmt, const unsigned char& data);

    virtual void update() {
        updateInt(static_cast< int >(data+idTranslation));
    }
    CellUChar* idTranslate() {
        idTranslation=1;
        return this;
    }
protected:
    const unsigned char&  data;
    int idTranslation;
};


//------------------------------RtTitledObj-------------------------------
class RtTitledObj : public RtObject {
    public:
        void  setTitle(const std::string& title);

        std::string getTitle();
        virtual void  update();
        virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj) = 0;

    protected:
        explicit RtTitledObj();

        RtTitledObj(const std::string& title);

        std::string title_;
};

//-------------------------------- RtRow ---------------------------------

class RtRow;
typedef boost::shared_ptr<RtRow> RtRowPtr;

class RtRow : public RtTitledObj {
    public:
        RtRow(const ::std::string & rowLabel);
        virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);
        static RtRowPtr makeRow(const ::std::string & rowLabel) {
            return RtRowPtr(new RtRow(rowLabel));
        }
};

//-------------------------------- RtColumn ---------------------------------

class RtColumn;
typedef boost::shared_ptr<RtColumn> RtColPtr;
typedef boost::shared_ptr<RtColumn> RtColumnPtr;

class RtColumn : public RtTitledObj {
    public:
        RtColumn(const ::std::string& colLabel);
        virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);
        static RtColPtr makeCol(const ::std::string& colLabel) {
            return RtColPtr(new RtColumn(colLabel));
        }
        static RtColPtr makeColumn(const ::std::string& colLabel) {
            return RtColPtr(new RtColumn(colLabel));
        }
};

//------------------------------ RtContainer --------------------------------

typedef enum {
    TWO_PIXELS_ALL_SIDES_BORDER,
    TWO_PIXELS_LEFT_RIGHT_BOTTOM_BORDER,
    TWO_PIXELS_BELOW_BORDER,
    ONE_PIXEL_ABOVE_BORDER,
    ONE_PIXEL_BELOW_BORDER,
    ONE_PIXEL_RIGHT_BORDER,
    ONE_PIXEL_LEFT_BORDER,
    NO_BORDER
} Border;


class RtContainer : public RtTitledObj {
public:
    virtual ~RtContainer( );

    virtual void  update();

    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj) = 0;

    void setBorder(Border border);
    Border getBorder() const;

    ::size_t getNumObjects( ) const;

    RtObjectPtr add(RtObjectPtr rtObject);

    RtObjectPtr replace(unsigned int i, RtObjectPtr rtObject);
    RtObjectPtr replace(RtObjectPtr oldObj, RtObjectPtr newObj);

    RtObjectPtr getObj( ::size_t index ) const;

protected:
    explicit RtContainer();

    RtContainer(const ::std::string& title);

    RtContainer(Border border);

    RtContainer(const ::std::string & title, Border border);

protected:
    typedef ::std::vector< RtObjectPtr > ObjectContainerType;
    ObjectContainerType      objects_;
    size_t                   numObjects_;

private:

    std::string::size_type   updateReserve_;
    Border                   border_;
};

//-------------------------------- RtLabel ---------------------------------
class RtLabel:public RtObject {
public:
    RtLabel();

    explicit RtLabel(const std::string& label);

    RtLabel(const std::string& label, char layoutCode);

    RtLabel(const std::string& label, int relFontSize);

    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);

    virtual void  update();

    ::std::string getLabel() const;

    FontType getFontType() const;

    int getRelFontSize() const;

    void setLabel(const std::string& label);

    void setFontType(const FontType type);

    void setRelFontSize(int relFontSize);
private:
    void init();
    ::std::string label_;
    int relFontSize_;
    FontType fontType;
};

typedef boost::shared_ptr<RtLabel> RtLabelPtr;

//-------------------------------- RtArea ---------------------------------
class RtArea : public RtContainer {
public:
    explicit RtArea( const ::std::string & title );

    RtArea(const std::string& title, Border border);

    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);

    int  getLabelPad();

    int  getUnitPad();

    int  getEndPad();

    void setLabelPad(int p);

    void setUnitPad(int p);

    void setEndPad(int p);

    CellPtr addItem(RtLabelPtr label, CellPtr cell, RtLabelPtr units);

    CellPtr addItem(const ::std::string & label, CellPtr cell, const char* units);

    CellPtr addItem(const ::std::string & label, CellPtr cell, RtLabelPtr units);

    CellPtr addItem(const ::std::string & label, CellPtr cell);

    CellPtr addCell(const char* fmt, char* legit, const char* string);

    CellPtr addCell(const char* fmt, const char* string);

    CellPtr addItem(const ::std::string & label, const char* fmt, char* legit, const char* string);

    CellPtr addItem(const ::std::string & label, const char* fmt, const char* string);

    CellPtr addItem(const ::std::string & label, const char* fmt, char* legit, short& data);

    CellPtr addItem(const ::std::string & label, const char* fmt, char* legit, int&   data);
    CellPtr addItem(const ::std::string & label, const char* fmt, int rod, char* legit, double& data);

private:
    int   labelPad;
    int   unitPad;
    int   endPad;
};

typedef boost::shared_ptr<RtArea> RtAreaPtr;

//-------------------------------- RtTable ---------------------------------
class RtTable : public RtContainer {
public:
    explicit RtTable( const ::std::string & title );

    virtual ~RtTable( );

    ::size_t getNumRows( ) const;

    ::size_t getNumCols( ) const;

    RtRowPtr addRow( RtRowPtr rowObj );

    RtColPtr addCol( RtColPtr colObj );

    CellPtr addCell(CellPtr cell);

    void addCols(int numOfCols, const char* names[]);

    void addOvroAntCols();

    static std::vector<std::string> getAntNames() ;

    static std::vector<std::string> getOvroAntNames() ;

    static std::vector<std::string> getBimaAntNames() ;

    static std::vector<std::string> getSzaAntNames() ;

    void addBimaAntCols();

    void setRowLabel(int rowNo, const std::string& label);

    void noRowLabels();

    void noColLabels();

    void setMinRows( ::size_t minRows );

    void setPrefRows( ::size_t prefRows );

    void setReverseOrder();

    void setLabelPrefix( const ::std::string & labelPrefix );

    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);

    Cell& getCell(int index);

    void replaceCell(int index, CellPtr cell);

    int getNumCells() const;

private:
    class RawContainer;

    std::string::size_type tableUpdateReserve_;

    char displayRowLabelsCode_;

    char displayColLabelsCode_;

    ::size_t minCols_;

    ::size_t minRows_;

    ::size_t prefCols_;

    ::size_t prefRows_;

    bool reverseOrder_;

    ::std::string labelPrefix_;

    // All columns
    std::vector< RtColPtr > cols_;

    // All rows
    std::vector< RtRowPtr > rows_;

    // All cells
    std::vector<CellPtr> cells_;
};

typedef boost::shared_ptr<RtTable> RtTablePtr;

//-------------------------------- RtBox ---------------------------------
class RtBox : public RtContainer {
    public:
        virtual ~RtBox( );

        void setSpring();
        void setProp();
        void setStretchFactor(double stretchFactor);
        virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);

        typedef enum {
            BOX_HORIZONTAL,
            BOX_VERTICAL,
            BOX_FOLDER,
        } BoxType;

        typedef enum {
            STRETCH_PROPORTIONAL,
            STRETCH_SPRING,
        } StretchType;
    protected:
        RtBox(BoxType type, const std::string& title);
        RtBox(BoxType type, Border border);
        RtBox(BoxType type, const std::string& title, Border border);

    private:
        // Code for box type
        const BoxType boxType_;
        StretchType stretchType_;
        double stretchFactor_;
        void init();
};

typedef boost::shared_ptr<RtBox> RtBoxPtr;

//-------------------------------- RtVBox ---------------------------------
class RtVBox:public RtBox {
public:
    explicit RtVBox(const std::string& title);

    explicit RtVBox(Border border);

    RtVBox(const std::string& title, Border border);
};

typedef boost::shared_ptr<RtVBox> RtVBoxPtr;

//-------------------------------- RtHBox ---------------------------------
class RtHBox:public RtBox {
public:
    explicit RtHBox(const std::string& title);

    explicit RtHBox(Border border);

    RtHBox(const std::string& title, Border border);
};

typedef boost::shared_ptr<RtHBox> RtHBoxPtr;

//-------------------------------- RtFolder ---------------------------------
class RtFolder:public RtBox {
public:
    explicit RtFolder(const std::string & title);

    explicit RtFolder(Border border);

    RtFolder(const ::std::string & title, Border border);
};

typedef boost::shared_ptr<RtFolder> RtFolderPtr;

//------------------------------ RtStatic --------------------------------
class RtStatic : public RtObject {
    public:
        virtual void update( );

        virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj) = 0;

    protected:
        explicit RtStatic();
};

//-------------------------------- RtSpring ---------------------------------
class RtSpring:public RtStatic {
public:
    RtSpring(int minWidth, int prefWidth, double springiness);

    RtSpring(int minWidth, double springiness);

    RtSpring(int minWidth, int prefWidth);

    RtSpring(int minWidth);

    RtSpring(double springiness);

    RtSpring();

    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);

private:
    const int     minWidth;
    const int     prefWidth;
    const double  springiness;
};

typedef boost::shared_ptr<RtSpring> RtSpringPtr;

//-------------------------------- RtSpacer ---------------------------------
class RtSpacer: public RtStatic {
public:
    RtSpacer(int minWidth, int prefWidth, double weight);
    RtSpacer(int minWidth, int prefWidth);
    RtSpacer(int minWidth, double weight);
    RtSpacer(int minWidth);
    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);
private:
    const int     minWidth;
    const int     prefWidth;
    const double  weight;
};

typedef boost::shared_ptr<RtSpacer> RtSpacerPtr;

//------------------------------- RtTimeString --------------------------------
class RtTimeString:public RtObject {
public:
    RtTimeString(const char* ut, const char* lst);
    void change(const char* ut, const char* lst);
    virtual void  update();
    virtual std::string getUpdate();
    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);
private:
    const int utWidth_;
    
    const int lstWidth_;
    
    const int localWidth_;

    // AstroTime object, used for LDT -> LST conversion
    const ::std::auto_ptr< services::AstroTime > astroTime_;

    const char * ut_;

    const char * lst_;

    ::std::ostringstream  scratchOSS_;

    ::std::string output_;
};

//------------------------------- RtTimePanel --------------------------------
class RtTimePanel:public RtObject {
public:
    RtTimePanel(const char* ut, const char* lst);
    RtTimePanel(const char* ut, const char* lst, bool visible);
    void change(const char* ut, const char* lst, bool visible = true);

    virtual void update();

    virtual std::string getUpdate();

    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);

private:
    bool    visible;
    RtTimeString* rts;
};

typedef boost::shared_ptr<RtTimePanel> RtTimePanelPtr;


//-------------------------------- RtDisplay ---------------------------------
class RtDisplay:public RtContainer {
public:
    RtDisplay( const ::std::string & programName,
               const char *          subtitle,
               const char *          ut,
               const char *          lst,
               bool                  visibleTimePanel = true );

    RtDisplay( const ::std::string & programName,
               const char *          subtitle,
               bool                  visibleTimePanel = true );

    static void appendToFile(std::string str);

    std::string getTimestring();

    virtual void serialize(bool initialize, int fontSize, ::rtdproto::RtObject *rtobj);
    virtual void serialize(bool initialize, int fontSize, ::rtdproto::UIMessageReply &msg);

    bool  serveData(bool forceInit=false);

    void         setReconfigured();
    virtual void checkReconfig();
    void         setGenericHelp(const std::string& helpString);

    void setSpecificHelp( const ::std::string & helpString );
    void setSpecificHelp( const ::std::string & title,
                          const ::std::string & helpString );

    void setSpecificHelpFromTextFile( const ::std::string & filePath );
    void setSpecificHelpFromTextFile( const ::std::string & title,
                                      const ::std::string & filePath );

    void setGenericHelpFromTextFile(const ::std::string& filePath);
    void setGenericHelpFromTextFile(const ::std::string& title,
                                    const ::std::string& filePath );

    void         setUpdateRate(int milliSeconds);
    int          getUpdateRate();
    ::std::string  getUpdateRateString( ) const;
    int   replyUpdate(int fontSize, ::rtdproto::UIMessageReply &msg);
    void   incRequestCount();
    ::std::string getProgramName( ) const;

protected:
    const char*        sysName;
    std::string        makeTitle(const std::string& subtitle);
    std::string        genericHelpTitle;
    std::string        genericHelp_;
    std::string        specificHelpTitle;
    std::string        specificHelp;
private:
    ReaderWithTimeout* readerTMO;
    int replyIni(int fontSize, ::rtdproto::UIMessageReply &msg, bool reInitialize=false);
    void         init();
    RtTimePanelPtr rtp;
    int          needIni;
    int          requestCount;
    char         visibleTimePanel;
    int          updateRate;
    ::std::string formatUpdateRate(const ::std::string &);

    virtual void preInternalUpdate( ) { }

    virtual void internalUpdate( ) { }

    void setUpdateRateString( const ::std::string & s );

    const ::std::string programName_;

    ::std::string updateRateString_;

    // Google Protocol Buffers UIMessageReply object
    boost::shared_ptr< ::rtdproto::UIMessageReply > legacyMessage_;
};


}  // namespace carma::ui::rtd
}  // namespace carma::ui
}  // namespace carma

#endif