random_racer/src/Console.h

Go to the documentation of this file.

#ifndef _RR_CONSOLE_H_
#define _RR_CONSOLE_H_

#include <list>
#include <string>

#include <vrs/callback.h>
#include <vrs/container/dictionary.h>
#include <vrs/sg/scenething.h>
#include <vrs/sharedobj.h>

#include <random_utils/TimeableObject.h>

namespace VRS
{
class BehaviorCallback;
class Camera;
class Canvas;
class Font;
class KeyEvent;
class ResizeEvent;
class Text;
class Translation;
} // namespace VRS


namespace random_racer
{

class Console : public VRS::SharedObj,
                private random_utils::TimeableObject
{
    class TextBuffer : public VRS::SceneThing
    {
        int         m_maxLines;
        double      m_lineHeight;
        VRS::Vector m_startOffset;

    public:
        TextBuffer(int maxLines, const VRS::Vector& startOffset,
                   double lineHeight);

        void addLine(VRS::SO<VRS::Text> newLine);
        void addLine(const std::string& newLine);

        inline int maxLines() { return m_maxLines; }
        inline int numLines() { return objects(); }
    };

    enum Keys
    {
        BackSpaceKey    = 8,
        DeleteKey       = 127,
        DeleteLineKey   = 21,
        EnterKey        = 3,
        ReturnKey       = 13,
        UpKey           = 65297,
        DownKey         = 65296,
        LeftKey         = 65298,
        RightKey        = 65299,
        TabKey          = '\t',
        ShiftTabKey     = 25
    };

    // this are the static consts which controll several things
    // of the console, their name should say what.
    static const float c_marginY, c_marginX, c_pixelsPerChar;

    VRS::SO<VRS::SceneThing>            m_sceneThing;

    VRS::SO<VRS::Font>                  m_font;

    VRS::SO<VRS::Text>                  m_currentLine;

    VRS::SO<TextBuffer>                 m_textBuffer;

    VRS::SO<VRS::Canvas>                m_canvas;

    VRS::SO<VRS::BehaviorCallback>      m_eventCallback;

    VRS::SO<VRS::Camera>                m_cam;

    std::list<std::string>              m_history;

    std::list<std::string>::iterator    m_histIter;

    std::string                         m_currentTabWord;

    std::list<std::string>              m_tabList;

    std::list<std::string>::iterator    m_tabIter;

    bool                                m_startNewTabCompletition;

    bool                                m_lastTabWasForward;

    VRS::NonPersistentDictionary<std::string, VRS::SO<VRS::CallbackBase> >
        m_registry;


    static const unsigned int c_animationDuration;

    double m_animationDistance;

    double m_distancePerTick;

    unsigned int m_lastTick;

    bool m_animationInProgress;

    void startAnimation();

    VRS::SO<VRS::Translation> m_translation;


    static VRS::SO<Console> s_instance;

    Console();

    bool dispatchCommand(const std::string&, bool batchMode = false);

    void handleEvents();

    void resizeEvent(VRS::SO<VRS::ResizeEvent> event);

    void keyEvent(VRS::SO<VRS::KeyEvent> event);

    virtual void timerTick();

public:
    static VRS::SO<Console> get();

    inline VRS::SO<VRS::SceneThing> sceneThing() { return m_sceneThing; }

    inline VRS::SO<VRS::Canvas> canvas() { return m_canvas; }

    void setCanvas(VRS::SO<VRS::Canvas> canvas);

    void attach(VRS::SO<VRS::Canvas> canvas);

    void detach();

    inline VRS::SO<VRS::Font> font() { return m_font; }

    bool isVisible();

    inline bool isHidden() { return !isVisible(); }

    inline void addLine(const std::string& p_newLine)
    {
        m_textBuffer->addLine(p_newLine);
    }

    inline bool registerCommand(
        const std::string& p_name,
        VRS::SO<VRS::Callback> p_callBack)
    {
        return m_registry.insert(p_name, (VRS::CallbackBase*)p_callBack);
    }

    inline bool registerCommand(
        const std::string& p_name,
        VRS::SO<VRS::Callback1<const std::string&> > p_callBack)
    {
        return m_registry.insert(p_name, (VRS::CallbackBase*)p_callBack);
    }

    inline bool registerCommand(
        const std::string& p_name,
     VRS::SO<VRS::Callback2<const std::string&,const std::string&> > p_callBack)
    {
        return m_registry.insert(p_name, (VRS::CallbackBase*)p_callBack);
    }

    inline bool unregisterCommand(const std::string& p_name)
    {
        return m_registry.erase(p_name);
    }

    bool toggleVisibility();

    void hide();

    void show();

    void handleKey(unsigned int key);

    void historyUp(bool reallyUp = true);

    inline void historyDown()
    {
        historyUp(false);
    }

    void tabCompleteForward(bool forward = true);

    inline void tabCompleteBackward()
    {
        tabCompleteForward(false);
    }

    void autoexec();
};


} // namespace random_racer


#endif // _RR_CONSOLE_H_

---