PlatformFont Class Reference

#include <PlatformFont.h>

Inheritance diagram for PlatformFont:

Public Member Functions
	PlatformFont (const std::string &filename)
	PlatformFont (const std::string &filename, int style, int size, PColor fgcolor, PColor bgcolor, bool aa)
	Convenience constructor of PlatformFont:
	PlatformFont (PlatformFont &font)
	Copy constructor of PlatformFont:
virtual	~PlatformFont ()
	Copy constructor.
virtual void	SetFontColor (PColor color)
	Set*Color needs to be overridden because it doesn't change the SDL_Color data.
virtual void	SetBackgroundColor (PColor color)
	Set*Color needs to be overridden because it doesn't change the SDL_Color data.
virtual void	SetFontSize (const int size)
	Override SetFontSize to update TTF font and mark as changed.
virtual void	SetFontStyle (const int style)
	Override SetFontStyle to update TTF font and mark as changed.
SDL_Surface *	RenderText (const std::string &text)
	This takes care of all the busy work of rendering the text.
unsigned int	GetTextWidth (const std::string &text)
unsigned int	GetTextHeight (const std::string &text)
unsigned int	GetPosition (const std::string &text, unsigned int x)
virtual std::string	ObjectName () const
TTF_Font *	GetTTFFont () const
bool	HasChanged ()
	Check if font or its colors have changed.
void	ClearChanged ()
	Clear all changed flags.
void	UpdateSDLColors ()
	Update SDL color cache from PColor objects.
	PlatformFont (const std::string &filename)
	PlatformFont (const std::string &filename, int style, int size, PColor fgcolor, PColor bgcolor, bool aa)
	PlatformFont (PlatformFont &font)
virtual	~PlatformFont ()
	Copy constructor.
virtual void	SetFontColor (PColor color)
virtual void	SetBackgroundColor (PColor color)
SDL_Texture *	RenderTexture (const std::wstring &text)
	This takes care of all the busy work of rendering the text.
SDL_Texture *	RenderText (const std::wstring &text)
unsigned int	GetTextWidth (const std::string &text)
unsigned int	GetTextHeight (const std::string &text)
unsigned int	GetPosition (const std::string &text, unsigned int x)
virtual std::string	ObjectName () const
	PlatformFont (const std::string &filename)
	PlatformFont (const std::string &filename, int style, int size, PColor fgcolor, PColor bgcolor, bool aa)
	PlatformFont (PlatformFont &font)
virtual	~PlatformFont ()
unsigned int	GetTextWidth (const std::string &text)
unsigned int	GetTextHeight (const std::string &text)
Public Member Functions inherited from PFont
	PFont ()
	Standard constructors:
	PFont (const std::string &filename)
	PFont (const std::string &filename, int style, int size, PColor fgcolor, PColor bgcolor, bool aa)
	Convenience constructor of PFont:
	PFont (const PFont &font)
	Copy constructor of PFont:
virtual	~PFont ()
	Copy constructor.
virtual bool	SetProperty (std::string, Variant v)
	Standard Destructors.
virtual Variant	GetProperty (std::string) const
virtual ObjectValidationError	ValidateProperty (std::string, Variant v) const
virtual ObjectValidationError	ValidateProperty (std::string) const
virtual void	SetFontFileName (const std::string &name)
	Set methods for all of the data in font.
virtual void	SetAntiAliased (const bool aa)
virtual std::string	GetFontFileName () const
virtual int	GetFontStyle () const
virtual int	GetFontSize () const
virtual PColor	GetFontColor () const
virtual PColor	GetBackgroundColor () const
virtual bool	GetAntiAliased () const
virtual bool	IsNormalFont () const
virtual bool	IsBoldFont () const
virtual bool	IsItalicFont () const
virtual bool	IsUnderlineFont () const
Public Member Functions inherited from PEBLObjectBase
	PEBLObjectBase ()
	Standard Constructor.
	PEBLObjectBase (ComplexDataType cdt)
	Standard Constructor.
	PEBLObjectBase (const PEBLObjectBase &pob)
virtual	~PEBLObjectBase ()
	Standard Destructor.
virtual bool	InitializeProperty (std::string name, Variant v)
Variant	GetProperty (std::string) const
ComplexDataType	GetType ()
virtual std::ostream &	PrintProperties (std::ostream &out)
virtual Variant	GetPropertyList ()

Protected Member Functions
virtual std::ostream &	SendToStream (std::ostream &out) const
	This sends the font descriptions to the specified stream.
virtual std::ostream &	SendToStream (std::ostream &out) const
	This sends the font descriptions to the specified stream.
virtual std::ostream &	SendToStream (std::ostream &out) const
	This sends the font descriptions to the specified stream.
Protected Member Functions inherited from PFont
PColor *	GetFontColorPtr () const
PColor *	GetBackgroundColorPtr () const

Additional Inherited Members
Protected Attributes inherited from PFont
std::string	mFontFileName
int	mFontStyle
int	mFontSize
bool	mAntiAliased
Protected Attributes inherited from PEBLObjectBase
ComplexDataType	mCDT
std::map< std::string, Variant >	mProperties

Detailed Description

This is a platform-specific font class. Much of the information is held in the generic PFont class, but this class needs to hold onto an actual font structure from the font library, and handle the rendering.

Validator platform font - provides dummy text metrics Used only for compilation/linking, never executed

Definition at line 52 of file sdl/PlatformFont.h.

Constructor & Destructor Documentation

PlatformFont() [1/9]

PlatformFont::PlatformFont

(

const std::string &

filename

)

Definition at line 27 of file validator/PlatformFont.cpp.

    : PFont(filename, 0, 18, PColor(0,0,0,255), PColor(255,255,255,255), true) {
}

PlatformFont() [2/9]

PlatformFont::PlatformFont	(	const std::string &	filename,
		int	style,
		int	size,
		PColor	fgcolor,
		PColor	bgcolor,
		bool	aa
	)

Convenience constructor of PlatformFont:

Definition at line 117 of file sdl/PlatformFont.cpp.

                                                                                                                  :
    PFont(filename, style, size, fgcolor, bgcolor, aa),
    mBuffer(nullptr),
    mChanged(false)
 
{
    string fontname = Evaluator::gPath.FindFile(mFontFileName);
    if(fontname == "")
        PError::SignalFatalError(string("Unable to find font file [")  + mFontFileName + string("]."));
 
    // Create cache key from base class properties (after PFont constructor)
    mCacheKey.filename = mFontFileName;
    mCacheKey.style = mFontStyle;
    mCacheKey.size = mFontSize;
 
    // Get font from cache (will load from disk if not cached)
    mTTF_Font = FontCache::FontCacheManager::GetInstance().GetFont(mCacheKey, fontname);
 
    if(!mTTF_Font)
        {
            printf("Oh My Goodness, an error : [%s]\n", TTF_GetError());
            PError::SignalFatalError("Failed to create font\n");
        }
 
   //Translate PColor to SDLcolor for direct use in rendering.
    PColor* fgColor = GetFontColorPtr();
    PColor* bgColor = GetBackgroundColorPtr();
 
    if(fgColor) mSDL_FGColor = SDLUtility::PColorToSDLColor(*fgColor);
    if(bgColor) mSDL_BGColor = SDLUtility::PColorToSDLColor(*bgColor);
}

References FontCache::FontCacheKey::filename, PEBLPath::FindFile(), PFont::GetBackgroundColorPtr(), FontCache::FontCacheManager::GetFont(), PFont::GetFontColorPtr(), FontCache::FontCacheManager::GetInstance(), Evaluator::gPath, PFont::mFontFileName, PFont::mFontSize, PFont::mFontStyle, SDLUtility::PColorToSDLColor(), PError::SignalFatalError(), FontCache::FontCacheKey::size, and FontCache::FontCacheKey::style.

PlatformFont() [3/9]

PlatformFont::PlatformFont

(

PlatformFont &

font

)

Copy constructor of PlatformFont:

Definition at line 152 of file sdl/PlatformFont.cpp.

                                              :
    PFont(font),  // Chain to base class copy constructor which handles colors
    mBuffer(nullptr),
    mChanged(false)
 
{
    mFontFileName    = font.GetFontFileName();
    mFontStyle       = font.GetFontStyle();
    mFontSize        = font.GetFontSize();
    mAntiAliased     = font.GetAntiAliased();
 
    // Create cache key from font properties
    mCacheKey.filename = mFontFileName;
    mCacheKey.style = mFontStyle;
    mCacheKey.size = mFontSize;
 
    // Get font from cache (may share TTF_Font with source font)
    string fontname = Evaluator::gPath.FindFile(mFontFileName);
    mTTF_Font = FontCache::FontCacheManager::GetInstance().GetFont(mCacheKey, fontname);
 
    //Translate PColor to SDLcolor for direct use in rendering.
    PColor* fgColor = GetFontColorPtr();
    PColor* bgColor = GetBackgroundColorPtr();
    if(fgColor) mSDL_FGColor = SDLUtility::PColorToSDLColor(*fgColor);
    if(bgColor) mSDL_BGColor = SDLUtility::PColorToSDLColor(*bgColor);
 
}

References FontCache::FontCacheKey::filename, PEBLPath::FindFile(), PFont::GetAntiAliased(), PFont::GetBackgroundColorPtr(), FontCache::FontCacheManager::GetFont(), PFont::GetFontColorPtr(), PFont::GetFontFileName(), PFont::GetFontSize(), PFont::GetFontStyle(), FontCache::FontCacheManager::GetInstance(), Evaluator::gPath, PFont::mAntiAliased, PFont::mFontFileName, PFont::mFontSize, PFont::mFontStyle, SDLUtility::PColorToSDLColor(), FontCache::FontCacheKey::size, and FontCache::FontCacheKey::style.

~PlatformFont() [1/3]

PlatformFont::~PlatformFont ( )

virtual

Copy constructor.

Fonts are not geting cleaned up, I think. Standard destructor of PlatformFont

Definition at line 183 of file sdl/PlatformFont.cpp.

{
    // Release font from cache (decrements ref count, closes if ref count reaches 0)
    FontCache::FontCacheManager::GetInstance().ReleaseFont(mCacheKey);
    mTTF_Font = NULL;
 
    // mBuffer is always nullptr with FontCache, but we keep it for binary compatibility
    // free(nullptr) is safe and does nothing
    free(mBuffer);
    mBuffer = NULL;
}

References FontCache::FontCacheManager::GetInstance(), NULL, and FontCache::FontCacheManager::ReleaseFont().

PlatformFont() [4/9]

PlatformFont::PlatformFont

(

const std::string &

filename

)

PlatformFont() [5/9]

PlatformFont::PlatformFont	(	const std::string &	filename,
		int	style,
		int	size,
		PColor	fgcolor,
		PColor	bgcolor,
		bool	aa
	)

PlatformFont() [6/9]

PlatformFont::PlatformFont

(

PlatformFont &

font

)

~PlatformFont() [2/3]

virtual PlatformFont::~PlatformFont ( )

virtual

Copy constructor.

PlatformFont() [7/9]

PlatformFont::PlatformFont

(

const std::string &

filename

)

PlatformFont() [8/9]

PlatformFont::PlatformFont	(	const std::string &	filename,
		int	style,
		int	size,
		PColor	fgcolor,
		PColor	bgcolor,
		bool	aa
	)

PlatformFont() [9/9]

PlatformFont::PlatformFont

(

PlatformFont &

font

)

~PlatformFont() [3/3]

virtual PlatformFont::~PlatformFont ( )

virtual

Member Function Documentation

ClearChanged()

void PlatformFont::ClearChanged

(

)

Clear all changed flags.

Definition at line 290 of file sdl/PlatformFont.cpp.

{
    mChanged = false;
    PColor* fgColor = GetFontColorPtr();
    PColor* bgColor = GetBackgroundColorPtr();
    if(fgColor) fgColor->ClearChanged();
    if(bgColor) bgColor->ClearChanged();
}

References PColor::ClearChanged(), PFont::GetBackgroundColorPtr(), and PFont::GetFontColorPtr().

Referenced by PlatformLabel::Draw(), and PlatformTextBox::Draw().

GetPosition() [1/2]

unsigned int PlatformFont::GetPosition	(	const std::string &	text,
		unsigned int	x
	)

Definition at line 562 of file sdl/PlatformFont.cpp.

{
 
    //Start at 0 and check until the width of the rendered text is bigger than x
 
    unsigned int lastcutoff = 0;
    unsigned int lastwidth = 0;
    
    unsigned int cutoff = 1;
 
    std::string::const_iterator start;
    std::string::const_iterator end;
 
    start = text.begin();
    end = start+1;
 
    while(cutoff < text.size())
        {
 
            //the bytes don't align with the glyphs. Be sure we only
            //permit the cutoff to occur between valid utf8 glyphs.
            while(!PEBLUtility::is_utf8(text.substr(0,cutoff)))
                {
                    //end++;
                    cutoff++;
                }
            //If the width of the rendered text is larger than the x argument,
            unsigned int width = GetTextWidth(text.substr(0,cutoff));
            if(width > x)
                {
                    //width is greater that the x position. now, round to the
                    //best cutoff.
                    double prop = (x-lastwidth)/(width-lastwidth);
                    if(prop>.5)
                        {
                            return cutoff;
                        }
                    else
                        {
                            return lastcutoff;
                        }
                    
                  
                }
            lastcutoff = cutoff;
            lastwidth = width;
 
            cutoff++;
                //end++;
        }
 
    //If we make it this far, we have run out of letters, so return the last character.
 
    return (unsigned int)(text.size());
}

References GetTextWidth(), and PEBLUtility::is_utf8().

Referenced by PlatformTextBox::FindCursorPosition().

GetPosition() [2/2]

unsigned int PlatformFont::GetPosition	(	const std::string &	text,
		unsigned int	x
	)

GetTextHeight() [1/3]

unsigned int PlatformFont::GetTextHeight

(

const std::string &

text

)

Definition at line 547 of file sdl/PlatformFont.cpp.

{
    int height, width;
 
    if(PEBLUtility::is_utf8(toBeRendered))
        TTF_SizeUTF8(mTTF_Font,toBeRendered.c_str(),&width,&height); // should work on all utf8
    else
        TTF_SizeText(mTTF_Font,toBeRendered.c_str(),&width,&height); //breaks on non-ascii text
 
    unsigned int uheight = (unsigned int)height;
    return uheight;
}

References PEBLUtility::is_utf8().

Referenced by PlatformTextBox::FindCursorPosition(), PlatformTextBox::HandleKeyPress(), and PlatformTextBox::RenderText().

GetTextHeight() [2/3]

unsigned int PlatformFont::GetTextHeight

(

const std::string &

text

)

GetTextHeight() [3/3]

unsigned int PlatformFont::GetTextHeight

(

const std::string &

text

)

GetTextWidth() [1/3]

unsigned int PlatformFont::GetTextWidth

(

const std::string &

text

)

Definition at line 517 of file sdl/PlatformFont.cpp.

{
    int height, width;
    std::string toBeRendered = StripText(text.c_str());
 
    // Auto-detect script and set direction for accurate width measurement
    std::string script = PEBLUtility::DetectScript(toBeRendered);
    const char* script_cstr = script_to_cstr(script);
 
    TTF_SetFontScriptName(mTTF_Font, script_cstr);
    if (PEBLUtility::IsRTLScript(script)) {
        TTF_SetFontDirection(mTTF_Font, TTF_DIRECTION_RTL);
    } else {
        TTF_SetFontDirection(mTTF_Font, TTF_DIRECTION_LTR);
    }
 
    if(PEBLUtility::is_utf8(toBeRendered))
        {
 
            TTF_SizeUTF8(mTTF_Font,toBeRendered.c_str(),&width,&height); // should work on all utf8
        }
    else
        TTF_SizeText(mTTF_Font,toBeRendered.c_str(),&width,&height); //breaks on non-ascii text
    
    // TTF_SizeUNICODE(mTTF_Font,toBeRendered.c_str(),&width,&height); //requires conversion to Uint16 array.
   
    unsigned int uwidth = (unsigned int)width;
    return uwidth;
}

References PEBLUtility::DetectScript(), PEBLUtility::is_utf8(), and PEBLUtility::IsRTLScript().

Referenced by PlatformTextBox::FindCursorPosition(), GetPosition(), PlatformTextBox::HandleKeyPress(), and PlatformTextBox::RenderText().

GetTextWidth() [2/3]

unsigned int PlatformFont::GetTextWidth

(

const std::string &

text

)

GetTextWidth() [3/3]

unsigned int PlatformFont::GetTextWidth

(

const std::string &

text

)

GetTTFFont()

TTF_Font * PlatformFont::GetTTFFont ( ) const

inline

Definition at line 78 of file sdl/PlatformFont.h.

{ return mTTF_Font; }

Referenced by PlatformLabel::RenderText(), and PlatformTextBox::RenderText().

HasChanged()

bool PlatformFont::HasChanged

(

)

Check if font or its colors have changed.

Definition at line 270 of file sdl/PlatformFont.cpp.

{
    // Check if colors changed and update SDL cache if needed
    PColor* fgColor = GetFontColorPtr();
    PColor* bgColor = GetBackgroundColorPtr();
 
    if(fgColor && fgColor->HasChanged())
    {
        UpdateSDLColors();
        return true;
    }
    if(bgColor && bgColor->HasChanged())
    {
        UpdateSDLColors();
        return true;
    }
    return mChanged;
}

References PFont::GetBackgroundColorPtr(), PFont::GetFontColorPtr(), PColor::HasChanged(), and UpdateSDLColors().

ObjectName() [1/2]

virtual std::string PlatformFont::ObjectName ( ) const

inlinevirtual

Reimplemented from PFont.

Definition at line 75 of file sdl/PlatformFont.h.

{return "Platform Font";};

ObjectName() [2/2]

virtual std::string PlatformFont::ObjectName ( ) const

inlinevirtual

Reimplemented from PFont.

Definition at line 87 of file PlatformFont_RTL.h.

{return "Platform Font";};

RenderText() [1/2]

SDL_Surface * PlatformFont::RenderText

(

const std::string &

text

)

This takes care of all the busy work of rendering the text.

Definition at line 318 of file sdl/PlatformFont.cpp.

{
 
    int maxchars = 1000;
#if 0
    cerr << "About to render text [" << text  << "] with font " << *this << endl;
 
    int i  = 0;
    while(i < text.length())
    {
 
        cerr << "[" << text[i] << "|" << (unsigned int)(text[i]) << "]";
        i++;
    }
 
    cerr << endl;
#endif
 
    //If there is no text, return a null surface.
    // if(text=="") return NULL; don't do this;render anyway because this causes updates
    // to blank labels to fail in 2.0
 
 
 
 
    //Get a temporary pointer that we return
    std::string toBeRendered = StripText(text);
    SDL_Surface * tmpSurface = NULL;
 
    if(toBeRendered.length()>maxchars)
        {
            toBeRendered=toBeRendered.substr(0,maxchars);
        }
    //The text renderer doesn't like to render empty text.
    if(toBeRendered.length() == 0) toBeRendered = " ";
 
    // Auto-detect script and set both script and direction for proper HarfBuzz shaping
    std::string script = PEBLUtility::DetectScript(toBeRendered);
    const char* script_cstr = script_to_cstr(script);
 
    // Set the script for proper shaping (ligatures, contextual forms, etc.)
    TTF_SetFontScriptName(mTTF_Font, script_cstr);
 
    // Set direction based on script
    if (PEBLUtility::IsRTLScript(script)) {
        TTF_SetFontDirection(mTTF_Font, TTF_DIRECTION_RTL);
    } else {
        TTF_SetFontDirection(mTTF_Font, TTF_DIRECTION_LTR);
    }
 
    //Using the RenderUTF8 stuff below has a hard time with 'foreign' characters; possibly because
    //the toberendered needs to be converted to UTF-8????
 
    //Note: Modern Emscripten (2.0+) DOES support TTF_RenderUTF8 functions
    if(mAntiAliased)
        {
            // If background alpha is < 255, we need transparency support
            // SDL's Shaded mode doesn't support alpha properly, so use Blended + manual background
            if(mSDL_BGColor.a < 255)
            {
                // Use Blended mode for text (transparent background)
                SDL_Surface* textSurface = NULL;
                if(PEBLUtility::is_utf8(toBeRendered))
                {
                    textSurface = TTF_RenderUTF8_Blended(mTTF_Font, toBeRendered.c_str(), mSDL_FGColor);
                } else {
                    textSurface = TTF_RenderText_Blended(mTTF_Font, toBeRendered.c_str(), mSDL_FGColor);
                }
 
                if(textSurface)
                {
                    // Create a new RGBA surface for compositing
                    tmpSurface = SDL_CreateRGBSurface(0, textSurface->w, textSurface->h, 32,
                                                      0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
                    if(tmpSurface)
                    {
                        // Fill with background color INCLUDING its alpha value
                        // This encodes transparency directly in the pixel data
                        SDL_FillRect(tmpSurface, NULL, SDL_MapRGBA(tmpSurface->format,
                                                                    mSDL_BGColor.r, mSDL_BGColor.g,
                                                                    mSDL_BGColor.b, mSDL_BGColor.a));
                        // Blit the opaque text on top (will replace background pixels)
                        SDL_BlitSurface(textSurface, NULL, tmpSurface, NULL);
                    }
                    SDL_FreeSurface(textSurface);
                }
            }
            else
            {
                // Use Shaded mode for opaque backgrounds (more efficient)
                if(PEBLUtility::is_utf8(toBeRendered))
                {
                    tmpSurface = TTF_RenderUTF8_Shaded(mTTF_Font, toBeRendered.c_str(), mSDL_FGColor, mSDL_BGColor);
                } else {
                    tmpSurface = TTF_RenderText_Shaded(mTTF_Font, toBeRendered.c_str(), mSDL_FGColor, mSDL_BGColor);
                }
            }
 
        }
    else
        {
           // tmpSurface = TTF_RenderText_Blended(mTTF_Font,toBeRendered.c_str(), mSDL_FGColor);
            if(PEBLUtility::is_utf8(toBeRendered) )
             {
               tmpSurface = TTF_RenderUTF8_Blended(mTTF_Font,toBeRendered.c_str(), mSDL_FGColor);
             }
            else
             {
                tmpSurface =  TTF_RenderText_Blended(mTTF_Font, toBeRendered.c_str(), mSDL_FGColor);
             }
        }
 
    //
    //TTF_RenderText_Blended(
    //TTF_Font *font, // This is the TTF_Font to use.
    //char *cstr, // This is the text to render.
    //                     SDL_Color &clr, // This is the color to use.
    //                     );
 
 
 
 
    if(tmpSurface)
        {
            return tmpSurface;
            //we need to copy the surface to the texture, render it, and return I think.
 
        }
    else
        {
            string message =   "Unable to render text  [" +  toBeRendered + "] in PlatformFont::RenderText. Attempting to render '' instead\n";
            PError::SignalWarning(message);
 
            //We have a problem, probably because we are trying to render garbage. Let's try to render "" instead, and
            //signal a waring.  If there is still an error, we will signal a fatal error.
            std::string tmp = "";
            tmpSurface =  TTF_RenderText_Blended(mTTF_Font, tmp.c_str(), mSDL_FGColor);
 
           if(tmpSurface)
            {
                return tmpSurface;
            }
            else
            {
              string message =   "Unable to render text in PlatformFont::RenderText";
              PError::SignalFatalError(message);
            }
        }
    return NULL;
}

References PEBLUtility::DetectScript(), PEBLUtility::is_utf8(), PEBLUtility::IsRTLScript(), PFont::mAntiAliased, NULL, PError::SignalFatalError(), and PError::SignalWarning().

Referenced by PlatformLabel::RenderText(), and PlatformTextBox::RenderText().

RenderText() [2/2]

SDL_Surface * PlatformFont::RenderText

(

const std::wstring &

text

)

Definition at line 626 of file PlatformFont_RTL.cpp.

{
 
    int maxchars = 1000;
#if 0
    cerr << "About to render text [" << text  << "] with font " << *this << endl;
 
    int i  = 0;
    while(i < text.length())
    {
 
        cerr << "[" << text[i] << "|" << (unsigned int)(text[i]) << "]";
        i++;
    }
 
    cerr << endl;
#endif
 
 
 
        
    //If there is no text, return a null surface.
    // if(text=="") return NULL; don't do this;render anyway because this causes updates
    // to blank labels to fail in 2.0
 
 
    //Get a temporary pointer that we return
    std::string toBeRendered = StripText(text);
    SDL_Surface * tmpSurface = NULL;
 
    if(toBeRendered.length()>maxchars)
        {
            toBeRendered=toBeRendered.substr(0,maxchars);
        }
    //The text renderer doesn't like to render empty text.
    if(toBeRendered.length() == 0) toBeRendered = " ";
 
    //Using the RenderUTF8 stuff below has a hard time with 'foreign' characters; possibly because
    //the toberendered needs to be converted to UTF-8????
    mTexture = DrawTexture(toBeRendered);
    return tmpSurface;
}

References NULL.

RenderTexture()

SDL_Texture * PlatformFont::RenderTexture

(

const std::wstring &

text

)

This takes care of all the busy work of rendering the text.

SendToStream() [1/3]

std::ostream & PlatformFont::SendToStream ( std::ostream &  out ) const

protectedvirtual

This sends the font descriptions to the specified stream.

Reimplemented from PFont.

Definition at line 619 of file sdl/PlatformFont.cpp.

{
    out << "<SDL-Specific Font>" << std::flush;
    return out;
}

SendToStream() [2/3]

virtual std::ostream & PlatformFont::SendToStream ( std::ostream &  out ) const

protectedvirtual

This sends the font descriptions to the specified stream.

Reimplemented from PFont.

SendToStream() [3/3]

virtual std::ostream & PlatformFont::SendToStream ( std::ostream &  out ) const

protectedvirtual

This sends the font descriptions to the specified stream.

Reimplemented from PFont.

SetBackgroundColor() [1/2]

void PlatformFont::SetBackgroundColor ( PColor  color )

virtual

Set*Color needs to be overridden because it doesn't change the SDL_Color data.

Reimplemented from PFont.

Definition at line 212 of file sdl/PlatformFont.cpp.

{
    //Chain up to parent method
    PFont::SetBackgroundColor(color);
 
    //Set child member data - retrieve from property map
    PColor* bgColor = GetBackgroundColorPtr();
    if(bgColor) mSDL_BGColor = SDLUtility::PColorToSDLColor(*bgColor);
    mChanged = true;  // Mark font as changed to trigger re-rendering
}

References PFont::GetBackgroundColorPtr(), SDLUtility::PColorToSDLColor(), and PFont::SetBackgroundColor().

SetBackgroundColor() [2/2]

virtual void PlatformFont::SetBackgroundColor ( PColor  color )

virtual

Reimplemented from PFont.

SetFontColor() [1/2]

void PlatformFont::SetFontColor ( PColor  color )

virtual

Set*Color needs to be overridden because it doesn't change the SDL_Color data.

Reimplemented from PFont.

Definition at line 198 of file sdl/PlatformFont.cpp.

{
    //Chain up to parent method
    PFont::SetFontColor(color);
 
    //Set child member data - retrieve from property map
    PColor* fgColor = GetFontColorPtr();
    if(fgColor) mSDL_FGColor = SDLUtility::PColorToSDLColor(*fgColor);
    mChanged = true;  // Mark font as changed to trigger re-rendering
}

References PFont::GetFontColorPtr(), SDLUtility::PColorToSDLColor(), and PFont::SetFontColor().

SetFontColor() [2/2]

virtual void PlatformFont::SetFontColor ( PColor  color )

virtual

Reimplemented from PFont.

SetFontSize()

void PlatformFont::SetFontSize ( const int  size )

virtual

Override SetFontSize to update TTF font and mark as changed.

Reimplemented from PFont.

Definition at line 226 of file sdl/PlatformFont.cpp.

{
    // If size unchanged, nothing to do
    if (size == mFontSize) return;
 
    //Chain up to parent method
    PFont::SetFontSize(size);
 
    // Release old cached font
    FontCache::FontCacheManager::GetInstance().ReleaseFont(mCacheKey);
 
    // Update cache key with new size
    mCacheKey.size = size;
 
    // Get new cached font with new size
    string fontname = Evaluator::gPath.FindFile(mFontFileName);
    mTTF_Font = FontCache::FontCacheManager::GetInstance().GetFont(mCacheKey, fontname);
 
    mChanged = true;  // Mark font as changed to trigger re-rendering
}

References PEBLPath::FindFile(), FontCache::FontCacheManager::GetFont(), FontCache::FontCacheManager::GetInstance(), Evaluator::gPath, PFont::mFontFileName, PFont::mFontSize, FontCache::FontCacheManager::ReleaseFont(), PFont::SetFontSize(), and FontCache::FontCacheKey::size.

SetFontStyle()

void PlatformFont::SetFontStyle ( const int  style )

virtual

Override SetFontStyle to update TTF font and mark as changed.

Reimplemented from PFont.

Definition at line 248 of file sdl/PlatformFont.cpp.

{
    // If style unchanged, nothing to do
    if (style == mFontStyle) return;
 
    //Chain up to parent method
    PFont::SetFontStyle(style);
 
    // Release old cached font
    FontCache::FontCacheManager::GetInstance().ReleaseFont(mCacheKey);
 
    // Update cache key with new style
    mCacheKey.style = style;
 
    // Get new cached font with new style
    string fontname = Evaluator::gPath.FindFile(mFontFileName);
    mTTF_Font = FontCache::FontCacheManager::GetInstance().GetFont(mCacheKey, fontname);
 
    mChanged = true;  // Mark font as changed to trigger re-rendering
}

References PEBLPath::FindFile(), FontCache::FontCacheManager::GetFont(), FontCache::FontCacheManager::GetInstance(), Evaluator::gPath, PFont::mFontFileName, PFont::mFontStyle, FontCache::FontCacheManager::ReleaseFont(), PFont::SetFontStyle(), and FontCache::FontCacheKey::style.

UpdateSDLColors()

void PlatformFont::UpdateSDLColors

(

)

Update SDL color cache from PColor objects.

Definition at line 300 of file sdl/PlatformFont.cpp.

{
    PColor* fgColor = GetFontColorPtr();
    PColor* bgColor = GetBackgroundColorPtr();
 
    if(fgColor)
    {
        mSDL_FGColor = SDLUtility::PColorToSDLColor(*fgColor);
    }
    if(bgColor)
    {
        mSDL_BGColor = SDLUtility::PColorToSDLColor(*bgColor);
    }
    mChanged = true;  // Mark font as changed so label re-renders
}

References PFont::GetBackgroundColorPtr(), PFont::GetFontColorPtr(), and SDLUtility::PColorToSDLColor().

Referenced by HasChanged().

---

The documentation for this class was generated from the following files:

• sdl/PlatformFont.h
• PlatformFont_RTL.h
• validator/PlatformFont.h
• sdl/PlatformFont.cpp
• PlatformFont_RTL.cpp
• validator/PlatformFont.cpp