source: orxonox.OLD/trunk/src/util/shell.h @ 5157

/*!
 * @file shell.h
 * Definition of a on-screen-shell
*/

#ifndef _SHELL_H
#define _SHELL_H

#include "element_2d.h"
#include "event_listener.h"

#include <stdarg.h>

#define      SHELL_BUFFER_SIZE       16384         //!< The Size of the input-buffers (should be large enough to carry any kind of input)

// FORWARD DECLARATION
class Text;
class ShellCommandBase;
template<class T> class tList;
template<class T> class tIterator;

//! A class that is able to redirect all output to a openGL-Shell, and that one can use to input some commands
/**
 * the major idea is, that all the Output can be redirected to the Shell,
 * and does not have to be displayed to the opening Shell, this is good,
 * for developers using Windows, where all output is otherwise redirected
 * to stdout.txt
 *
 * Furthermore the Shell should enable us, to input some simple commands
 * Each Class can tell check itself in to the Shell, and listen for commands.
 *
 * @todo implement what is written above :/
 */
class Shell : public Element2D, public EventListener {

  public:
    virtual ~Shell();
    /** @returns a Pointer to the only object of this Class */
    inline static Shell* getInstance() { if (!Shell::singletonRef) Shell::singletonRef = new Shell();  return Shell::singletonRef; };

    void testI (int i);
    void testS (const char* s);
    void testB (bool b);
    void testF (float f);
    void testSF (const char* s, float f);

    void activate();
    void deactivate();

    void setTextSize(unsigned int textSize, unsigned int lineSpacing = 1);
    void rebuildText();

    // BUFFER //
    void setBufferSize(unsigned int bufferSize) { this->bufferSize = bufferSize; };
    void setBufferDisplaySize(unsigned int bufferDisplaySize);
    void flushBuffers();
    static bool addBufferLineStatic(const char* line, ...);
    void addBufferLine(const char* line, va_list arg);
    void printToDisplayBuffer(const char* text);
    void moveBuffer(int lineCount);
    const char* getBufferLine(unsigned int lineNumber);

    // InputLine
    void flushInputLine();
    void addCharacter(char character);
    void addCharacters(const char* characters);
    void removeCharacters(unsigned int characterCount = 1);
    bool executeCommand();

    void clear();

    void setRepeatDelay(float repeatDelay, float repeatRate);

    // EventListener
    virtual void process(const Event &event);

    // Element2D-functions
    void tick(float dt);
    virtual void draw() const;

    void help() const;
    void debug() const;

  private:
    bool autoComplete();
    bool classComplete(const char* classBegin);
    bool objectComplete(const char* objectBegin, long classID);
    bool functionComplete(const char* functionBegin);

    bool generalComplete(const tList<const char>* stringList, const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);

    const tList<const char>* createCompleteList(const tList<const char>* inputList, const char* classNameBegin);
    const tList<const char>* createCompleteList(const tList<BaseObject>* inputList, const char* classNameBegin);
    const tList<const char>* createCompleteList(const tList<ShellCommandBase>* inputList, const char* classNameBegin);

    // helpers //
    Vector calculateLinePosition(unsigned int lineNumber);


  private:
    Shell();
    static Shell*            singletonRef;           //!< The singleton-reference to the only memeber of this class.

    unsigned int             bufferSize;             //!< The Size of the buffer
    unsigned int             bufferDisplaySize;      //!< The Size of the Display-buffer, in lines (not in characters)

    Text*                    inputLineText;          //!< The inputLine of the Shell
    char*                    inputLine;              //!< the Char-Array of the Buffer
    float                    repeatRate;             //!< The Repeat-Delay.
    float                    repeatDelay;            //!< The delay of the first Character of a given Character.
    float                    delayed;                //!< how much of the delay is remaining.
    int                      pressedKey;             //!< the pressed key that will be repeated.

    tList<char>*             buffer;                 //!< A list of stored char-arrays(strings) to store the history
    tIterator<char>*         bufferIterator;         //!< An iterator for the Shells main buffer.

    tList<char>*             inputHistory;           //!< The history of given commands.

    Text**                   bufferText;             //!< A list of stored bufferTexts for the display of the buffer
    unsigned int             textSize;               //!< The size of the text.
    unsigned int             lineSpacing;            //!< The Spacing between lines.
    unsigned int             shellHeight;            //!< The hight of the Shell in Pixels
    bool                     bActive;                //!< if the shell is active;

    char                     bufferArray[SHELL_BUFFER_SIZE];     //!< a BUFFER for fast writing
    char                     keepBufferArray[SHELL_BUFFER_SIZE]; //!< a BUFFER to have multi-non-newLine commands be copied into the shell.
    bool                     keepBuffer;

    // completion
    tList<const char>*       completionList;          //!< A list of completions, that are io.
};

#endif /* _SHELL_H */