#include <CQFontRenderer.h>

Inheritance diagram for CQFontRenderer:

Collaboration diagram for CQFontRenderer:

Public Member Functions
	CQFontRenderer ()

virtual std::pair< double, double >	getTextureSize (const CLFontSpec &spec, const std::string &text)

virtual std::pair < CLTextTextureSpec , GLubyte >	operator() (const std::string &family, double fontSize, const std::string &text, CLText::FONT_WEIGHT weight=CLText::WEIGHT_NORMAL, CLText::FONT_STYLE style=CLText::STYLE_NORMAL, double zoomFactor=1.0)

virtual	~CQFontRenderer ()

Public Member Functions inherited from CLFontRendererBase
virtual	~CLFontRendererBase ()

Static Public Member Functions
static std::pair < CLTextTextureSpec , GLubyte >	createTexture (const std::string &family, double fontSize, const std::string &text, CLText::FONT_WEIGHT weight=CLText::WEIGHT_NORMAL, CLText::FONT_STYLE style=CLText::STYLE_NORMAL, double zoomFactor=1.0)

Protected Member Functions
void	findSimilarFamily (const std::string &name, std::set< std::string > &families) const

void	getFamilyList (const std::string &family, std::list< std::string > &list) const

QFont	getFont (const CLFontSpec &spec)

std::pair< CLTextTextureSpec , GLubyte >	getTexture (QFont &font, const std::string &text, double zoomFactor)

std::pair< double, double >	getTextureSize (const QFont &font, const std::string &text)

void	orderFamilies (const std::string &name, const std::set< std::string > &familySet, std::list< std::string > &familyList) const

Protected Attributes
std::map< CLFontSpec, QFont >	mFontMap

QFontDatabase *	mpFontDatabase

Static Protected Attributes
static CQFontRenderer	FONT_RENDERER

Detailed Description

Definition at line 23 of file CQFontRenderer.h.

Constructor & Destructor Documentation

CQFontRenderer::CQFontRenderer ( )

Constructor.

Definition at line 45 of file CQFontRenderer.cpp.

                               : CLFontRendererBase(), mpFontDatabase(NULL)
 {
 }

CQFontRenderer::~CQFontRenderer ( )

virtual

Destructor

Definition at line 52 of file CQFontRenderer.cpp.

References mpFontDatabase.

 {
   if (this->mpFontDatabase != NULL)
     {
       delete this->mpFontDatabase;
     }
 }

Member Function Documentation

std::pair< CLTextTextureSpec , GLubyte > CQFontRenderer::createTexture	(	const std::string &	family,
		double	fontSize,
		const std::string &	text,
		CLText::FONT_WEIGHT	weight = `CLText::WEIGHT_NORMAL`,
		CLText::FONT_STYLE	style = `CLText::STYLE_NORMAL`,
		double	zoomFactor = `1.0`
	)

static

static method that creates a texture with a static FontRenderer object. This method can be used as a callback.

Definition at line 456 of file CQFontRenderer.cpp.

References FONT_RENDERER.

 {
   return FONT_RENDERER(family, fontSize, text, weight, style, zoomFactor);
 }

void CQFontRenderer::findSimilarFamily	(	const std::string &	name,
		std::set< std::string > &	families
	)		const

protected

Finds the font families that fit the given family name. A family fits if the name is exactly the same or if the name is contained in the family name. For generic names like sans, serif or monospaced the algorithm tries to find a suitable font family.

Definition at line 401 of file CQFontRenderer.cpp.

References mpFontDatabase.

Referenced by getFamilyList().

 {
   QString qname(name.c_str());
   QStringList familyList = this->mpFontDatabase->families();
   QStringList::const_iterator constIterator;
 
   for (constIterator = familyList.constBegin(); constIterator != familyList.constEnd(); ++constIterator)
     {
       if ((*constIterator).contains(name.c_str(), Qt::CaseInsensitive))
         {
           families.insert((*constIterator).toLatin1().data());
         }
     }
 }

void CQFontRenderer::getFamilyList	(	const std::string &	family,
		std::list< std::string > &	list
	)		const

protected

Definition at line 441 of file CQFontRenderer.cpp.

References findSimilarFamily(), and orderFamilies().

Referenced by getFont().

 {
   QString name(family.c_str());
   name = name.toLower();
   name = name.trimmed();
   // find a new font
   std::set<std::string> familySet;
   this->findSimilarFamily(family, familySet);
 
   if (!familySet.empty())
     {
       this->orderFamilies(family, familySet, list);
     }
 }

QFont CQFontRenderer::getFont ( const CLFontSpec & spec )

protected

Returns the font that matches the given FontSpc.

Returns the font that matches the given FontSpec.

Definition at line 80 of file CQFontRenderer.cpp.

References getFamilyList(), CLFontSpec::mFamily, mFontMap, mpFontDatabase, CLFontSpec::mSize, CLFontSpec::mStyle, CLFontSpec::mWeight, CLText::STYLE_ITALIC, CLText::STYLE_NORMAL, and CLText::WEIGHT_BOLD.

Referenced by getTextureSize(), and operator()().

 {
   // we only initialize the font database when it is needed for the first time,
   // hopefully this will resolve the crash under linux if it is instanciated to early.
   if (this->mpFontDatabase == NULL)
     {
       this->mpFontDatabase = new QFontDatabase();
     }
 
   // check if it is a generic font name (sand, serif or monospaced)
   // and try to find a fitting font
   // sans: helvetica or arial
   // serif: times, times new roman or garamond
   // monospaced: courier, courier new or monaco
   //std::cout << "Searching font for family \"" << spec.mFamily << "\" with size " << spec.mSize << " weight " << (spec.mWeight==CLText::WEIGHT_BOLD?(const char*)"bold":(const char*)"normal") << " and style " << (spec.mStyle==CLText::STYLE_ITALIC?(const char*)"italic":(const char*)"normal") << "." << std::endl;
   std::map<CLFontSpec, QFont>::iterator pos;
   pos = this->mFontMap.find(spec);
   QFont font;
   QString styleString;
 
   if (spec.mWeight == CLText::WEIGHT_BOLD)
     {
       styleString = "Bold";
     }
 
   if (spec.mStyle == CLText::STYLE_ITALIC)
     {
       styleString += " Italic";
     }
 
   styleString = styleString.trimmed();
 
   if (pos == this->mFontMap.end())
     {
       QString family(spec.mFamily.c_str());
       family = family.toLower();
 
       if (family == "sans")
         {
           // try helvetica and arial in this order
           QFont defaultFont;
           QString defaultFamily = defaultFont.defaultFamily();
           defaultFont = this->mpFontDatabase->font(defaultFamily, styleString, spec.mSize);
           CLFontSpec tempSpec = spec;
           tempSpec.mFamily = "helvetica";
 
           if (defaultFamily.contains(tempSpec.mFamily.c_str()))
             {
               font = defaultFont;
             }
           else
             {
               font = this->getFont(tempSpec);
 
               if (font == defaultFont)
                 {
                   // if the font is the default font, we try the next one
                   tempSpec.mFamily = "arial";
 
                   if (defaultFamily.contains(tempSpec.mFamily.c_str()))
                     {
                       font = defaultFont;
                     }
                   else
                     {
                       font = this->getFont(tempSpec);
                     }
                 }
             }
         }
       else if (family == "serif")
         {
           // try times, times new roman and garamond in this order
           QFont defaultFont;
           QString defaultFamily = defaultFont.defaultFamily();
           defaultFont = this->mpFontDatabase->font(defaultFamily, styleString, spec.mSize);
           CLFontSpec tempSpec = spec;
           tempSpec.mFamily = "times";
 
           if (defaultFamily.contains(tempSpec.mFamily.c_str()))
             {
               font = defaultFont;
             }
           else
             {
               font = this->getFont(tempSpec);
 
               if (font == defaultFont)
                 {
                   // if the font is the default font, we try the next one
                   tempSpec.mFamily = "times new roman";
 
                   if (defaultFamily.contains(tempSpec.mFamily.c_str()))
                     {
                       font = defaultFont;
                     }
                   else
                     {
                       font = this->getFont(tempSpec);
 
                       if (font == defaultFont)
                         {
                           // if the font is the default font, we try the next one
                           tempSpec.mFamily = "garamond";
 
                           if (defaultFamily.contains(tempSpec.mFamily.c_str()))
                             {
                               font = defaultFont;
                             }
                           else
                             {
                               font = this->getFont(tempSpec);
                             }
                         }
                     }
                 }
             }
         }
       else if (family == "monospaced")
         {
           // try courier, courier new and monaco in this order
           QFont defaultFont;
           QString defaultFamily = defaultFont.defaultFamily();
           defaultFont = this->mpFontDatabase->font(defaultFamily, styleString, spec.mSize);
           CLFontSpec tempSpec = spec;
           tempSpec.mFamily = "courier";
 
           if (defaultFamily.contains(tempSpec.mFamily.c_str()))
             {
               font = defaultFont;
             }
           else
             {
               font = this->getFont(tempSpec);
 
               if (font == defaultFont)
                 {
                   // if the font is the default font, we try the next one
                   tempSpec.mFamily = "courier new";
 
                   if (defaultFamily.contains(tempSpec.mFamily.c_str()))
                     {
                       font = defaultFont;
                     }
                   else
                     {
                       font = getFont(tempSpec);
 
                       if (font == defaultFont)
                         {
                           // if the font is the default font, we try the next one
                           tempSpec.mFamily = "monaco";
 
                           if (defaultFamily.contains(tempSpec.mFamily.c_str()))
                             {
                               font = defaultFont;
                             }
                           else
                             {
                               font = this->getFont(tempSpec);
                             }
                         }
                     }
                 }
             }
         }
       else
         {
           std::list<std::string> familyList;
           this->getFamilyList(spec.mFamily, familyList);
           // now create the font for one of the families in the list
           QFont defaultFont;
           QString defaultFamily = defaultFont.defaultFamily();
           defaultFont = this->mpFontDatabase->font(defaultFamily, styleString, spec.mSize);
 
           if (!familyList.empty())
             {
               // go through the list and check if there is a font in the that
               // does not return the default font for the given size and
               // style
               std::list<std::string>::const_iterator familyIt = familyList.begin(), familyEndit = familyList.end();
 
               while (familyIt != familyEndit)
                 {
                   font = QFont(familyIt->c_str(), spec.mSize, (spec.mWeight == CLText::WEIGHT_BOLD) ? QFont::Bold : QFont::Normal, (spec.mStyle == CLText::STYLE_NORMAL) ? false : true);
 
                   if (font != defaultFont)
                     {
                       break;
                     }
 
                   ++familyIt;
                 }
             }
           else
             {
               // return the default font
               font = defaultFont;
             }
         }
 
       this->mFontMap.insert(std::pair<CLFontSpec, QFont>(spec, font));
     }
   else
     {
       font = pos->second;
     }
 
   //std::cout << "Using font family \"" << font.mFamily().toLatin1().data() << "\" with size " << font.pointSize() << " weight " << (font.bold()?(const char*)"bold":(const char*)"normal") << " and style " << (font.italic()?(const char*)"italic":(const char*)"normal") << "." << std::endl;
   return font;
 }

std::pair< CLTextTextureSpec , GLubyte > CQFontRenderer::getTexture	(	QFont &	font,
		const std::string &	text,
		double	zoomFactor
	)

protected

Creates a texture for the given text using the given font object. The caller has to free the memory for the TextureSpec object and the pData in the TextureSpec object.

zoomFactor

Definition at line 317 of file CQFontRenderer.cpp.

References getTextureSize(), CLTextTextureSpec::mAscent, CLTextTextureSpec::mMaxScale, CLTextureSpec::mNumComponents, CLTextTextureSpec::mScale, CLTextureSpec::mTextHeight, CLTextureSpec::mTextureHeight, CLTextureSpec::mTextureName, CLTextureSpec::mTextureWidth, and CLTextureSpec::mTextWidth.

Referenced by operator()().

 {
   CLTextTextureSpec* pSpec = NULL;
   // find out what size the text will have
   font.setStyleStrategy(QFont::ForceOutline);
   QFontMetrics fontMetrics(font);
   std::pair<double, double> size = this->getTextureSize(font, text);
   //std::cout << "texture size: " << size.first << "," << size.second << std::endl;
   // make the size a power of 2
   unsigned int exponentWidth = (unsigned int)ceil(log(size.first /** zoomFactor*/ + 2) / log(2.0));
   unsigned int exponentHeight = (unsigned int)ceil(log(size.second /** zoomFactor*/ + 2) / log(2.0));
   unsigned int width = 1 << exponentWidth;
   unsigned int height = 1 << exponentHeight;
   // draw the text somewhere with white stroke on black background
   QImage image(width, height, QImage::Format_RGB32);
   QPainter painter(&image);
   painter.setBackground(Qt::black);
   painter.setPen(QPen(QColor(255, 255, 255, 255), 0.25, Qt::SolidLine, Qt::FlatCap, Qt::BevelJoin));
   painter.setBrush(Qt::NoBrush);
   painter.setFont(font);
   painter.eraseRect(0, 0, width, height);
   // move over by 1,1 to get a small edge around the text
   painter.translate(1.0, 1.0);
   // we scale after the erase so that we don't have to divide the width and
   // the height
   //painter.scale(zoomFactor, zoomFactor);
   painter.drawText(0.0, fontMetrics.ascent() + 1, text.c_str());
   painter.end();
   // convert the image to an OpenGL texture
   image = QGLWidget::convertToGLFormat(image);
   // create the texture spec
   pSpec = new CLTextTextureSpec();
   pSpec->mTextureWidth = width;
   pSpec->mTextureHeight = height;
   pSpec->mTextWidth = size.first;
   pSpec->mTextHeight = size.second;
   pSpec->mScale = zoomFactor;
   pSpec->mMaxScale = -1.0;
   pSpec->mNumComponents = 1;
   pSpec->mTextureName = 0;
   GLint w = 0;
   GLenum format = GL_ALPHA;
   glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
   glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
 
   while (w == 0 && width > 1 && height > 1)
     {
       // divide the size by two in each direction
       width = width >> 1;
       height = height >> 1;
       glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
       glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
     }
 
   GLubyte* textureData = NULL;
 
   if (w != 0)
     {
       if (w != pSpec->mTextureWidth)
         {
           pSpec->mTextureWidth = width;
           pSpec->mTextureHeight = height;
         }
 
       textureData = new GLubyte[width * height];
       pSpec->mAscent = (double)fontMetrics.ascent();
       unsigned int i, iMax = width * height;
 
       for (i = 0; i < iMax; ++i)
         {
           textureData[i] = image.bits()[4 * i];
         }
     }
 
   return std::pair<CLTextTextureSpec*, GLubyte*>(pSpec, textureData);
 }

std::pair< double, double > CQFontRenderer::getTextureSize	(	const CLFontSpec &	spec,
		const std::string &	text
	)

virtual

Returns the size for a font given a font, a text and a zoom factor.

Implements CLFontRendererBase.

Definition at line 306 of file CQFontRenderer.cpp.

References getFont().

Referenced by getTexture().

 {
   QFont font = this->getFont(spec);
   return this->getTextureSize(font, text);
 }

std::pair< double, double > CQFontRenderer::getTextureSize	(	const QFont &	font,
		const std::string &	text
	)

protected

Returns the size for a font given a font specification, a text and a zoom factor.

Definition at line 295 of file CQFontRenderer.cpp.

 {
   QFontMetrics fontMetrics(font);
   int textWidthInPixels = fontMetrics.width(text.c_str()) + 2;
   int textHeightInPixels = fontMetrics.height() + 2;
   return std::pair<double, double>(textWidthInPixels, textHeightInPixels);
 }

std::pair< CLTextTextureSpec , GLubyte > CQFontRenderer::operator()	(	const std::string &	family,
		double	fontSize,
		const std::string &	text,
		CLText::FONT_WEIGHT	weight = `CLText::WEIGHT_NORMAL`,
		CLText::FONT_STYLE	style = `CLText::STYLE_NORMAL`,
		double	zoomFactor = `1.0`
	)

virtual

Functor that returns a TextureSpec objct with a texture for the given font family, font size font weight, font style and text. The caller is responsible to free the memory of the TextureSpec object and of the pData in the TextureSpec.

Functor that returns a TextureSpec object with a texture for the given font family, font size font weight, font style and text. The caller is responsible to free the memory of the TextureSpec object and of the pData in the TextureSpec.

Implements CLFontRendererBase.

Definition at line 66 of file CQFontRenderer.cpp.

References getFont(), getTexture(), CLFontSpec::mFamily, CLFontSpec::mSize, CLFontSpec::mStyle, and CLFontSpec::mWeight.

 {
   CLFontSpec spec;
   spec.mFamily = family;
   spec.mSize = fontSize * zoomFactor;
   spec.mWeight = weight;
   spec.mStyle = style;
   QFont font = this->getFont(spec);
   return getTexture(font, text, zoomFactor);
 }

void CQFontRenderer::orderFamilies	(	const std::string &	name,
		const std::set< std::string > &	familySet,
		std::list< std::string > &	familyList
	)		const

protected

Given a certain name and a set of font family names, the algorithm tries to put them in an order from best match to worst match.

Definition at line 420 of file CQFontRenderer.cpp.

Referenced by getFamilyList().

 {
   std::set<std::string>::const_iterator it = familySet.begin();
   std::set<std::string>::const_iterator endit = familySet.end();
 
   // simple version only copies the set
   while (it != endit)
     {
       // TODO If the name is equal to the current iterator, we insert it before
       // TODO the first item that is not equal
       // TODO If the current item starts with the name, we add it before the
       // TODO first one that starts with the name and has a longer string.
       // TODO If the name is somewhere in the items string, we add it before
       // TODO the first entry that does contain the name, but is longer.
       // TODO For this comparison, we should take thefoundary into account
       // TODO and maybe remove it befoe comparing
       familyList.push_back(*it);
       ++it;
     }
 }

Member Data Documentation

CQFontRenderer CQFontRenderer::FONT_RENDERER

staticprotected

Static instance of CQFontRenderer for use in a static function that can be used as a callback.

Definition at line 102 of file CQFontRenderer.h.

Referenced by createTexture().

std::map<CLFontSpec, QFont> CQFontRenderer::mFontMap

protected

A map that stores the font that matches a given spec the best.

Definition at line 100 of file CQFontRenderer.h.

Referenced by getFont().

QFontDatabase* CQFontRenderer::mpFontDatabase

protected

An instance of the font database. It has to be a pointer since there seems to be a problem under linux if an instance of QFontDatabase is created before some other things have been instanciated. At least the application crashed when I made this an object instead of a pointer.

Definition at line 95 of file CQFontRenderer.h.

Referenced by findSimilarFamily(), getFont(), and ~CQFontRenderer().

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation