console.cpp

Go to the documentation of this file.

/* MAINTAINER: Bernard CURRENT_EDITOR: Bernard */

// #define WANT_TRACE


#include "SDL.h"
#include "SDL_opengl.h"

#include <sstream>
#include <string>
#include <iostream>
#include <vector>

#include "globals_client.h"
#include "log.h"
#include "console.h"
#include "platform.h"
#include "settings.h"
#include "application_client.h"
#include "conversions.h"
#include "translator.h"

#include "font_manager.h"

using namespace std;

const int  CONSOLE_ONOFF = SDLK_BACKQUOTE;
const float CONSOLE_TOP  = 10.0f;
const float CONSOLE_LEFT = 20.0f;

Console::Console()
{
        mPriority = IA_PRIORITY_CONSOLE;
        mActive = false;
        
        mFont = 0;
        mLineWrap = true;

        mTitle = 0; // some default value
        
        mInHistory = g_settings.getInt(SETTING_CONSOLE_LINES);

        // TODO: Load from settings
        mLogForwarding = true;

        mHistoryIgnore = false;
}

Console::~Console()
{
        TIN
}


void Console::init()
{
        TIN

        // registration to input manager
        getAppClient().getInputManager().setKeyReceiver(CONSOLE_ONOFF, this);
        getAppClient().getInputManager().addInputAcceptor(*this);

                
        // Loading font
        mFont = FontManager::getRef().get("FreeMono.ttf", 20);
        if (!mFont)
        {
                LOGE << "Loading font failed!" << endl;
                DIE();
        }
        
        // register as log acceptor
        registerLog();

        // This is for testing :-) 
        mTitle = LNG_CACHE_("-- Console --");
}

void Console::clean()
{
        TIN

        // unregister from input
        getAppClient().getInputManager().setKeyReceiver(CONSOLE_ONOFF, 0);
        getAppClient().getInputManager().removeInputAcceptor(*this);

        // Clean font
        mFont = 0; 

        // clean registration to log system
        g_log.setAcceptor(0); 


        LNG_UNCACHE(mTitle);
}


bool Console::wantKey(const SDL_keysym &keysym)
{
        // SDLK_BACKQUOTE == ` 
        if (keysym.sym == CONSOLE_ONOFF) return true;
                
        return mActive;
}

bool  Console::keyDown(const SDL_keysym &keysym)
{
        TIN 

        if (keysym.sym == CONSOLE_ONOFF) 
        {
                mActive = !mActive;
                getAppClient().getInputManager().WantAllInput(mActive);
                LOGD << " Console is " << mActive << endl;
                return true;
        }
        
        if (!mActive) return false;

        LOGT << "Processing new key " << keysym.sym << " :-)\n";
        
        switch (keysym.sym) 
        {

        // process command & erase commmand line
        case SDLK_RETURN:
                processCommand( mInputLine.getLineU() );        

                mInputLine.clear();
                
                break;
        
        // something with history of commands - not yet
        case SDLK_UP:
                LOGI << "History in console not implemented yet." << endl;
                break;
        case SDLK_DOWN:
                LOGI << "History in console not implemented yet." << endl;
                break;  
        case SDLK_TAB:
                LOGI << "Completion in console is not implemented." << endl;
                break;  

        // adding one char to commandline
        default:
        
                mInputLine.processKey(keysym);
                
                break;
        }
        
        return true;
}

void Console::logLine(const std::string &line)
{
        if ( mLogForwarding )
                addConsoleMessage(line);
}


void Console::registerLog()
{
        if ( mLogForwarding )
        {
                g_log.setAcceptor(this);
        }
        else
        {
                g_log.setAcceptor(0);
        }
}


void Console::render()
{
        TIN;
        
        
        assertL(mFont.isValid());
        
        mFont->RenderUTF8( xtos(getAppClient().getGFX().getFps()),
                (float)(getAppClient().getGFX().getWidth() - 50),
                (float)(getAppClient().getGFX().getHeight() - 30) );

        // if we don't want "slidedown/slideup" :-)
        if (!mActive) return;

        // OpenGL init
        getAppClient().getGFX().set2DOpenGL();
    glLoadIdentity();
        glColor3f( 1.0, 1.0, 1.0);


        // Decorations
        mFont->RenderUTF8(
                LNG_GET(mTitle), 
                CONSOLE_LEFT, 
                getAppClient().getGFX().getHeight() - (CONSOLE_TOP + mFont->Ascent())
        );

        
        
        // History (messages) - must be locked
        mHistoryMutex.lock();
        mHistoryIgnore = true;

        list<string>::iterator it = mMessageHistory.begin();
        int i = mInHistory+1;
        for(; it != mMessageHistory.end(); ++it, --i)
        {
                mFont->RenderUTF8(
                        *it,
                        CONSOLE_LEFT,
                        getAppClient().getGFX().getHeight() - (CONSOLE_TOP + i*mFont->Ascent())
                );
        }       

        mHistoryIgnore = false;
        mHistoryMutex.unlock();
        
        // commandline
        mFont->RenderUTF8( 
                mInputLine.getLineURender(),
                CONSOLE_LEFT,
                getAppClient().getGFX().getHeight() - (CONSOLE_TOP + (mInHistory+2)*mFont->Ascent())
        );

}

void Console::addConsoleMessage(const std::string &msg)
{
        // DON'T DO ANY LOGGING HERE SICE THIS MAY BE CALLED FROM
        // LOG AND THUS IT WOULD DO INFINITE LOOP
        
        mHistoryMutex.lock();
        if (!mHistoryIgnore) 
        {
                // Add message to history
                // Line wrapping - the text if first translated to wide chars - we
                // want proper multibyte chars wrapping. Then one by one chars are
                // taken from src (original message) to temporary "line". 
                if (mFont && mLineWrap)
                {
                        // maximal width of text in console
                        int maxW = getAppClient().getGFX().getWidth()-2*(int)CONSOLE_LEFT-mFont->getWwidth();
                
                        wstring src, dst;
                        utf8tows(msg.c_str(), src);
                        
                        while (!src.empty())
                        {
                                wchar_t w;
                                
                                w = src[0];
                                src.erase(0,1);
                                dst += w;
                                
                                string dst_utf;
                                wstoutf8(dst, dst_utf);
                                
                                if (mFont->getTextWidth(dst_utf) >= maxW)
                                {
                                        mMessageHistory.push_front(dst_utf);
                                        dst.erase(0);
                                }
                                
                        }
                        
                        if (!dst.empty())
                        {
                                string dst_utf;
                                wstoutf8(dst, dst_utf);
                                mMessageHistory.push_front(dst_utf);
                        }
                        
                }
                else
                {
                        mMessageHistory.push_front(msg);
                }
        
                
                // Remove old messages from history
                while ((signed int)mMessageHistory.size() > mInHistory)
                {
                        mMessageHistory.pop_back();
                }
        }

        mHistoryMutex.unlock();
}


void Console::processCommand(const std::string &cmd)
{
        TIN
        
        LOGD << "Console command: " << cmd << endl;

        addConsoleMessage(cmd);
        
        getAppClient().getCommander().addCommand(cmd);  
}

---