src/render/rFont.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***************************************************************************

*/

#ifndef ArmageTron_FONT_H
#define ArmageTron_FONT_H

#include "rSDL.h"

#include "defs.h"
//#include "rTexture.h"
#include "tString.h"
#include "tColor.h"

#include <map>

enum sr_fontClass {
    sr_fontConsole       = 00001, 
    sr_fontMenu          = 00002, 
    sr_fontMenuTitle     = 00004, 
    sr_fontScoretable    = 00010, 
    sr_fontMenuHelp      = 00020, 
    sr_fontError         = 00040, 
    sr_fontCockpit       = 00100, 
    sr_fontCenterMessage = 00200, 
    sr_fontServerBrowser = 00400, 
    sr_fontCycleLabel    = 01000, 
    sr_fontServerDetails = 02000  
};

enum sr_fontTypes {
    sr_fontOld       = 0, 
    sr_fontPixmap    = 1, 
    sr_fontBitmap    = 2, 
    sr_fontTexture   = 3, 
    sr_fontPolygon   = 4, 
    sr_fontOutline   = 5, 
    sr_fontExtruded  = 6  
};

extern int sr_fontType;

class FTFont;

// maybe make this a child of std::ostream...
class rTextField{
    tString buffer;       // buffer where we store stuff before we print it
    float  width;          // width in openGL units
    int  parIndent;      // number of spaces to insert after automatic newline
    REAL left,top;       // top left corner of the console
    REAL cheight; // character dimensions
    //    rFont *F;             // the font
    int  x,y,realx;      // current cursor position
    float nextx;          // x-coordinate the next char should go to for rendering
    float currentWidth;   //The current position where the next char will go to for caching
    bool multiline;        // linewrapping enabled?
    FTFont *font;
    sr_fontClass type;    //what is the type of this font?

    tColor color_;               
    static tColor defaultColor_; 
    static tColor blendColor_;   

    int cursor; // display mode of the cursor; 0: disabled, 1: low, 2: high
    int cursorPos; // position of the cursor (number of chars to come)

    REAL cursor_x,cursor_y; // position on the screen

    void FlushLine(int len,bool newline=true);
    void FlushLine(bool newline=true);
public:
#define  rCWIDTH_NORMAL  (16/640.0)
#define  rCHEIGHT_NORMAL (32/480.0)

    rTextField(REAL Left,REAL Top,
               REAL Cheight, sr_fontClass Type);

    virtual ~rTextField(); // for future extensions (buffered console?)

    REAL GetCHeight() const {
        return cheight;
    }

   void SetTop( REAL t ){
        top = t;
    }

    void SetLeft( REAL l ){
        top = l;
    }
    
    REAL GetTop() const{
        return top;
    }

    REAL GetLeft() const{
        return left;
    }

    void SetWidth(float w){
        width=w;
    }

    float GetWidth() const {
        return width;
    }

    void SetIndent(int i){
        parIndent=i;
    }

    int GetIndent() const {
        return parIndent;
    }

    void SetCursor(int c,int p){
        cursor=c;
        cursorPos=p;
    }

    void ResetColor(){
        FlushLine(false);
        color_ = defaultColor_;
    }

    void EnableLineWrap() {
        multiline = true;
    }

    // rTextField & operator<<(unsigned char c);

    enum ColorMode {
        COLOR_IGNORE,   // ignore color codes, printing everything verbatim
        COLOR_USE,      // normal mode: hide color codes and use them
        COLOR_SHOW      // use color codes, but print them as well
    };

    rTextField & StringOutput(const char *c, ColorMode colorMode = COLOR_USE );

    int Lines(){
        return y;
    }

    inline rTextField & SetColor( tColor const & color );       
    inline tColor const & GetColor( void ) const;       
    inline rTextField const & GetColor( tColor & color ) const; 
    static void SetDefaultColor( tColor const & defaultColor ); 
    static tColor const & GetDefaultColor( void );      
    static void GetDefaultColor( tColor & defaultColor );       
    static void SetBlendColor( tColor const & blendColor );     
    static tColor const & GetBlendColor( void );        
    static void GetBlendColor( tColor & blendColor );   

    static float GetTextLength (tString const &str, float height, bool stripColors=false, bool useNewline=true, float *resultingHeight=0); 

private:
    inline void WriteChar(unsigned char c); 
};

template<class T> rTextField & operator<<(rTextField &c,const T &x){
    tColoredString out;
    out << x;
    return c.StringOutput(out);
}

void DisplayText(REAL x,REAL y,REAL h,const char *text, sr_fontClass type,int center=0,
                 int cursor=0,int cursorPos=0, rTextField::ColorMode colorMode = rTextField::COLOR_USE );

// *******************************************************************************************
// *
// *    GetColor
// *
// *******************************************************************************************
// *******************************************************************************************

tColor const & rTextField::GetColor( void ) const
{
    return this->color_;
}

// *******************************************************************************************
// *
// *    GetColor
// *
// *******************************************************************************************
// *******************************************************************************************

rTextField const & rTextField::GetColor( tColor & color ) const
{
    color = this->color_;
    return *this;
}

// *******************************************************************************************
// *
// *    SetColor
// *
// *******************************************************************************************
// *******************************************************************************************

rTextField & rTextField::SetColor( tColor const & color )
{
    this->color_ = color;
    return *this;
}
void sr_ReloadFont(void);

#endif

---