Subversion Repositories gelsvn

/**

 * @file   Console.h

 * @author Anders Wang Kristensen <awk@imm.dtu.dk>

 * @date   Fri Oct 22 18:32:06 2011

 *

 * @brief  OpenGL 'Quake'-like console

 */

#ifndef __GEL_GLGRAPHICS_CONSOLE_H__

#define __GEL_GLGRAPHICS_CONSOLE_H__

#include <GLGraphics/gel_gl.h>

#include <functional> //make_shared, bind

#include <map> //multimap

#include <sstream> //stringstream

#include <vector>

#include <cassert>

namespace GLGraphics {

class Console

{

public:

    Console();

    ~Console() throw();

    //GLUT functions

    void display();

    void keyboard(unsigned char key);

    void special(int key);

    //stdio-like io

    void print(const char* buffer);

    void printf(const char* format, ...);

    void newline();

    //execute command

    void execute(const char* buffer);

    void executef(const char* format, ...);

    typedef int cmd_token;

    //0-ary

    inline cmd_token reg_cmd(const std::string& name,

                             const std::function<void ()>& f,

                             const std::string& help);

    //1-ary

    template <typename A0>

    cmd_token reg_cmd(const std::string& name,

                      const std::function<void (const A0&)>& f,

                      const std::string& help);

    //2-ary

    template <typename A0, typename A1>

    cmd_token reg_cmd(const std::string& name,

                      const std::function<void (const A0&,const A1&)>& f,

                      const std::string& help);

    //3-ary

    template <typename A0, typename A1, typename A2>

    cmd_token reg_cmd(const std::string& name,

                      const std::function<void (const A0&,

                                                const A1&,const A2&)>& f,

                      const std::string& help);

    //remove

    inline void unreg_cmd(cmd_token);

    //get name/help of registrered command

    const char* get_name(cmd_token) const;

    const char* get_help(cmd_token) const;

    //helper classes

    class command;

    template <typename T>

    class variable;

private:

    //make noncopyable

    Console(Console&);

    const Console& operator=(const Console&);

    static inline void from_string(const std::string& source,

                                   std::string& target)

    {

        target = source;

    }

    template <typename T>

    static inline void from_string(const std::string& source, T& target)

    {

        std::stringstream ss(source);

        if (!(ss >> target))

        {

            std::stringstream ss;

            ss << "Cannot convert "

               << source << " to '" << typeid(T).name() << "'.";

            throw std::invalid_argument(ss.str());

        }

    }

    //from string

    template <typename T>

    static T lexical_cast(const std::string& source)

    {

        T target;

        from_string(source, target);

        return target;

    }

    //to string

    template <typename S>

    static std::string to_string(const S& source)

    {

        std::stringstream ss;

        if (!(ss << source))

        {

            //converting *to* string should never fail

            throw std::invalid_argument("Cannot convert argument to string.");

        }

        return ss.str();

    }

    class command_base

    {

    public:

        inline command_base(Console& c, const std::string& help)

            : m_console(c), m_help(help) { m_id = c.m_id_counter++; }

        virtual ~command_base() {}

        virtual void execute(const std::vector<std::string>& args) const = 0;

        virtual size_t arity() const = 0;

        inline cmd_token get_id() const { return m_id; }

        inline const char* get_help() const { return m_help.c_str(); }

    protected:

        Console& m_console;

        cmd_token m_id;

        std::string m_help;

    };

    //no need to be a template

    class command0 : public command_base

    {

    public:

        typedef std::function<void ()> function_type;

        inline command0(Console& c,

                        const std::string& h, const function_type& f)

            : command_base(c,h), m_callback(f) {}

        inline void execute(const std::vector<std::string>& args) const;

        inline size_t arity() const { return 0; }

    private:

        function_type m_callback;

    };

    template <typename A0>

    class command1 : public command_base

    {

    public:

        typedef typename std::function<void (const A0&)> function_type;

        command1(Console& c, const std::string& h, const function_type& f)

            : command_base(c,h), m_callback(f) {}

        void execute(const std::vector<std::string>& args) const;

        size_t arity() const { return 1; }

    private:

        function_type m_callback;

    };

    template <typename A0, typename A1>

    class command2 : public command_base

    {

    public:

        typedef typename std::function<void (const A0&,

                                             const A1&)> function_type;

        command2(Console& c, const std::string& h, const function_type& f)

            : command_base(c,h), m_callback(f) {}

        void execute(const std::vector<std::string>& args) const;

        size_t arity() const { return 2; }

    private:

        function_type m_callback;

    };

    template <typename A0, typename A1, typename A2>

    class command3 : public command_base

    {

    public:

        typedef typename std::function<void (const A0&,

                                             const A1&,

                                             const A2&)> function_type;

        command3(Console& c, const std::string& h, const function_type& f)

            : command_base(c,h), m_callback(f) {}

        void execute(const std::vector<std::string>& args) const;

        size_t arity() const { return 3; }

    private:

        function_type m_callback;

    };

    //multi, so we can have multiple cmds with same name (but different arity)

    typedef std::multimap<std::string,

                          std::unique_ptr<command_base> > command_map_t;

    cmd_token add_command(const std::string& name,

                           std::unique_ptr<command_base>&& ptr);

    void remove_command(cmd_token);

    void tab_completion();

    std::vector<std::string> parse_cmdline(const char* buffer) const;

    //builtin commands

    void help();

    void help(const std::string&);

    void clear();

    void history();

    void load_history();

    void save_history() const;

    void clear_history();

    //draw commands

    void draw_text(int x, int y,

                   float r, float g, float b,

                   const char* buffer);

    void draw_textf(int x, int y,

                    float r, float g, float b,

                    const char* fmt, ...);

    //state

    command_map_t m_commands;

    std::vector<std::string> m_buffer;

    size_t m_history_index;

    std::vector<std::string> m_history;

    std::string::size_type m_caret;

    std::string m_current_command;

    int m_id_counter;

    bool m_is_executing;

    GLuint m_font;

    static const unsigned char g_png_data[];

    static const size_t g_png_size;

};

//0-ary

Console::cmd_token Console::reg_cmd(const std::string& name,

                                    const std::function<void ()>& f,

                                    const std::string& help)

{

    typedef command0 command_type;

    return add_command(name,

        std::unique_ptr<command_type>(

            new command_type(std::ref(*this), help, f)));

}

void Console::command0::execute(const std::vector<std::string>& args) const

{

    assert(args.size() == arity());

    m_callback();

}

//1-ary

template <typename A0>

Console::cmd_token Console::reg_cmd(const std::string& name,

                                    const std::function<void (const A0&)>& f,

                                    const std::string& help)

{

    typedef command1<A0> command_type;

    return add_command(name,

        std::unique_ptr<command_type>(

            new command_type(std::ref(*this), help, f)));

}

template <typename A0>

void Console::command1<A0>::execute(const std::vector<std::string>& args) const

{

    assert(args.size() == arity());

    m_callback(lexical_cast<A0>(args[0]));

}

//2-ary

template <typename A0, typename A1>

Console::cmd_token Console::reg_cmd(const std::string& name,

                                    const std::function<void (const A0&,

                                      const A1&)>& f,

                                    const std::string& help)

{

    typedef command2<A0,A1> command_type;

    return add_command(name,

        std::unique_ptr<command_type>(

            new command_type(std::ref(*this), help, f)));

}

template <typename A0,typename A1>

void Console::command2<A0,A1>::execute(

    const std::vector<std::string>& args) const

{

    assert(args.size() == arity());

    m_callback(lexical_cast<A0>(args[0]),

               lexical_cast<A1>(args[1]));

}

//3-ary

template <typename A0, typename A1, typename A2>

Console::cmd_token Console::reg_cmd(const std::string& name,

                                    const std::function<void (const A0&,

                                      const A1&,const A2&)>& f,

                                    const std::string& help)

{

    typedef command3<A0,A1,A2> command_type;

    return add_command(name,

        std::unique_ptr<command_type>(

            new command_type(std::ref(*this), help, f)));

}

template <typename A0,typename A1, typename A2>

void Console::command3<A0,A1,A2>::execute(

    const std::vector<std::string>& args) const

{

    assert(args.size() == arity());

    m_callback(lexical_cast<A0>(args[0]),

               lexical_cast<A1>(args[1]),

               lexical_cast<A2>(args[2]));

}

void Console::unreg_cmd(cmd_token id)

{

    remove_command(id);

}

class Console::command

{

public:

    inline command() : m_console(NULL) {}

    inline void reg(Console& cs,

        const std::string& name,

        const std::function<void ()>& function,

        const std::string& help)

    {

        assert(!m_console);

        m_console = &cs;

        m_id = m_console->reg_cmd(name, function, help);

    }

    template <typename A0>

    void reg(Console& cs,

        const std::string& name,

        const std::function<void (const A0&)>& function,

        const std::string& help)

    {

        assert(!m_console);

        m_console = &cs;

        m_id = m_console->reg_cmd<A0>(name, function, help);

    }

    template <typename A0, typename A1>

    void reg(Console& cs,

        const std::string& name,

        const std::function<void (const A0&, const A1&)>& function,

        const std::string& help)

    {

        assert(!m_console);

        m_console = &cs;

        m_id = m_console->reg_cmd<A0,A1>(name, function, help);

    }

    template <typename A0, typename A1, typename A2>

    void reg(Console& cs,

        const std::string& name,

        const std::function<void (const A0&,

        const A1&, const A2&)>& function,

        const std::string& help)

    {

        assert(!m_console);

        m_console = &cs;

        m_id = m_console->reg_cmd<A0,A1,A2>(name, function, help);

    }

    inline ~command()

    {

        if (m_console)

            m_console->unreg_cmd(m_id);

    }

    inline const char* get_name() const

    {

        assert(m_console);

        return m_console->get_name(m_id);

    }

    inline const char* get_help() const

    {

        assert(m_console);

        return m_console->get_help(m_id);

    }

    inline Console* get_console() const { return m_console; }

    inline cmd_token get_id() const { assert(m_console); return m_id; }

private:

    command(command&);

    const command& operator=(const command&);

    Console* m_console;

    cmd_token m_id;

};

template <typename T>

class Console::variable

{

public:

    variable(const T& initial_value = T())

        : m_value(initial_value) {}

    void reg(Console& cs,

        const std::string& name,

        const std::string& help)

    {

        m_print_cmd.reg(cs, name,

            std::bind(&variable::print_value, this), help);

        m_set_cmd.reg<T>(cs, name,

            std::bind(&variable::set_value, this, std::placeholders::_1),

            help);

    }

    const variable& operator=(const T& value) { m_value = value; return *this; }

    operator const T&() const { return m_value; }

    const char* get_name() const { return m_print_cmd.get_name(); }

    const char* get_help() const { return m_print_cmd.get_help(); }

private:

    variable(const variable&);

    const variable& operator=(const variable&);

    void print_value()

    {

        m_print_cmd.get_console()->printf("%s = %s",

            m_print_cmd.get_name(),

            Console::to_string(m_value).c_str());

    }

    void set_value(const T& value)

    {

        m_value = value;

        m_print_cmd.get_console()->execute(m_print_cmd.get_name());

    }

    T m_value;

    command m_print_cmd;

    command m_set_cmd;

};

}

#endif //__GEL_GLGRAPHICS_CONSOLE_H__