#include <painttext.h>

Classes
struct	LayoutState

struct	TextFragment

struct	TextLine

Public Types
enum	WidthExceeded { FULL_WIDTH, ELLIPSIS, MULTI_LINE }

Public Member Functions
virtual void	setRect (const Rect &r)

virtual Rect	rect (void) const

virtual void	setText (const std::string &text)

virtual const std::string &	text (void) const

virtual void	setColor (const GFXColor &c)

virtual GFXColor	color (void) const

virtual void	setFont (const Font &f)

virtual Font	font (void) const

virtual void	setJustification (Justification j)

virtual Justification	justification (void) const

virtual void	setWidthExceeded (WidthExceeded w)

virtual WidthExceeded	widthExceeded (void) const

virtual int	lineCount (void) const

virtual int	visibleLineCountStartingWith (int lineNumber, float vertInterval) const

virtual int	layoutVersion (void) const

virtual void	drawLines (size_t start, size_t count=END_LINE) const

void	draw (void) const

	PaintText (void)

	PaintText (const Rect &rect, const std::string &text, const Font &font, const GFXColor &color, Justification just=RIGHT_JUSTIFY, WidthExceeded w=ELLIPSIS)

virtual	~PaintText (void)

Static Public Attributes
static const size_t	END_LINE = 1000000

Protected Member Functions
void	calcLayout (void)

void	calcLayoutIfNeeded (void) const

float	lineInset (const TextLine &line)

void	addFragment (TextLine &line, const std::string::size_type endPos, std::string::size_type &startPos, double &width)

void	parseFormat (std::string::size_type startPos, std::string::size_type resultPos, bool endLine)

void	parseFragmentsWithCharBreak (TextLine &line, std::string::size_type startPos, std::string::size_type endPos, float maxWidth, bool ellipsis, std::string::size_type *resultPos)

void	parseFragmentsWithWordBreak (TextLine &line, std::string::size_type startPos, float maxWidth, std::string::size_type *resultPos)

Protected Attributes
Rect	m_rect

std::string	m_text

GFXColor	m_color

Font	m_font

Justification	m_justification

WidthExceeded	m_widthExceeded

bool	m_needLayout

int	m_layoutVersion

vector< TextLine >	m_lines

double	m_verticalScaling

double	m_horizontalScaling

LayoutState	m_layout

Detailed Description

Definition at line 75 of file painttext.h.

Member Enumeration Documentation

enum PaintText::WidthExceeded

Enumerator
FULL_WIDTH
ELLIPSIS
MULTI_LINE

Definition at line 114 of file painttext.h.

     {
         FULL_WIDTH,             //Do nothing.  Just do one line of text.
         ELLIPSIS,               //Put an ellipsis at the end of the text.
         MULTI_LINE              //Go to the next line.
     };

Constructor & Destructor Documentation

PaintText::PaintText ( void )

Definition at line 760 of file painttext.cpp.

                            :
     m_rect()
     , m_text()
     , m_color( GUI_OPAQUE_BLACK() )
     , m_font()
     , m_justification( RIGHT_JUSTIFY )
     , m_widthExceeded( ELLIPSIS )
     , m_needLayout( true )
     , m_layoutVersion( 0 )
     , m_verticalScaling( 0.7 )
     , m_horizontalScaling( 0.7 )
 {
 }

PaintText::PaintText	(	const Rect &	rect,
		const std::string &	text,
		const Font &	font,
		const GFXColor &	color,
		Justification	just = `RIGHT_JUSTIFY`,
		WidthExceeded	w = `ELLIPSIS`
	)

Definition at line 774 of file painttext.cpp.

References setText().

                                         :
     m_rect( r )
     , m_text()
     ,             //Don't set text here.
     m_color( c )
     , m_font( f )
     , m_justification( j )
     , m_widthExceeded( w )
     , m_needLayout( true )
     , m_layoutVersion( 0 )
     , m_verticalScaling( 0.7 )
     , m_horizontalScaling( 0.7 )
 {
     setText( t );     //Do conversion if necessary.
 }

virtual PaintText::~PaintText ( void )

inlinevirtual

Definition at line 153 of file painttext.h.

153 {}

Member Function Documentation

void PaintText::addFragment	(	TextLine &	line,
		const std::string::size_type	endPos,
		std::string::size_type &	startPos,
		double &	width
	)

protected

Definition at line 432 of file painttext.cpp.

References Font::charWidth(), charWidth(), PaintText::TextFragment::color, PaintText::LayoutState::colorStack, PaintText::TextFragment::end, font(), PaintText::TextFragment::font, PaintText::LayoutState::fontStack, PaintText::TextLine::fragments, m_layout, m_text, and PaintText::TextFragment::start.

Referenced by parseFragmentsWithCharBreak().

 {
     string::size_type curPos = startPos;
     const Font &font = m_layout.fontStack.back();
     //Loop through the characters until we run out of room.
     while (curPos < endPos) {
         double charWidth = font.charWidth( m_text[curPos] );
         if (width-charWidth < 0.0)
             //The current character goes past the specified width.
             break;
         width -= charWidth;
         curPos++;
     }
     //Create the fragment.
     if (curPos > startPos) {
         TextFragment frag;
         frag.start = startPos;
         frag.end   = curPos-1;         //Last char in frag, not one past.
         frag.font  = font;
         frag.color = m_layout.colorStack.back();
         line.fragments.push_back( frag );
     }
     startPos = curPos;
 }

void PaintText::calcLayout ( void )

protected

Definition at line 674 of file painttext.cpp.

References PaintText::TextLine::baseLine, BOGUS_LINE_SPACING, PaintText::LayoutState::colorStack, PaintText::LayoutState::currentLineSpacing, ELLIPSIS, PaintText::LayoutState::fontStack, PaintText::TextLine::fragments, VegaConfig::getVariable(), Size::height, PaintText::TextLine::height, Font::horizontalScaling(), lineInset(), LINES_RESERVE, m_color, m_font, m_horizontalScaling, m_layout, m_layoutVersion, m_lines, m_needLayout, m_rect, m_text, m_verticalScaling, m_widthExceeded, MULTI_LINE, XMLSupport::parse_float(), parseFragmentsWithCharBreak(), parseFragmentsWithWordBreak(), PaintText::LayoutState::permanentLineSpacing, REFERENCE_BASELINE_POS, REFERENCE_FONT_ASCENDER, Font::size(), Rect::size, Font::verticalScaling(), vs_config, Size::width, and PaintText::TextLine::x.

Referenced by calcLayoutIfNeeded().

 {
     //Clear the old layout.
     m_lines.clear();
     //Make sure the version number changes.
     m_layoutVersion++;
     //Make sure we don't call this again unless we need to.
     m_needLayout = false;
     if ( m_text.empty() )
         return;
     //Scaling factors.
     m_verticalScaling   = m_font.verticalScaling();
     m_horizontalScaling = m_font.horizontalScaling();
     //Max line width in character reference space.
     static float font_width_hack = XMLSupport::parse_float( vs_config->getVariable( "graphics", "font_width_hack", "0.925" ) );
     const float  maxLineWidth    = m_rect.size.width*font_width_hack/m_horizontalScaling;
     //The temporary global state for the layout operation.
     //Make sure this gets initialized at the beginning of an operation.
     m_layout = LayoutState( 1.0, 1.0 );
     //Keep track of switches in fonts/colors.
     m_layout.fontStack.push_back( m_font );
     m_layout.colorStack.push_back( m_color );
     //Create the current line.
     m_lines.reserve( LINES_RESERVE );
     m_lines.resize( 1 );
     TextLine *currentLine = &m_lines.back();
     if (m_widthExceeded != MULTI_LINE) {
         //SINGLE LINE.
         currentLine->height   = m_rect.size.height;
         currentLine->baseLine = ( currentLine->height-m_font.size() )/2.0
                                 +m_verticalScaling*REFERENCE_FONT_ASCENDER;
 
         string::size_type ignorePos = 0;
         bool ellipsis = (m_widthExceeded == ELLIPSIS);
         parseFragmentsWithCharBreak( *currentLine, 0, m_text.size(), maxLineWidth, ellipsis, &ignorePos );
 
         //Need line width before we can set this.
         currentLine->x = lineInset( *currentLine );
         //If we got no fragments, get rid of the line.
         if ( currentLine->fragments.empty() )
             m_lines.pop_back();
     } else {
         //MULTIPLE LINES.
         int nextLinePos = 0;         //The char loc in m_text of the beginning of the next line.
         while (true) {
             //Figure vertical measurements before we parse the line.
             currentLine->height   = m_layout.fontStack.back().size()*m_layout.currentLineSpacing;
             currentLine->baseLine = currentLine->height-m_verticalScaling*REFERENCE_BASELINE_POS;
 
             //Get the first line of chars, including the length.
             string::size_type endNextLinePos = 0;
             m_layout.currentLineSpacing = BOGUS_LINE_SPACING;             //Line spacing for this line only. Bogus value.
             parseFragmentsWithWordBreak( *currentLine, nextLinePos, maxLineWidth, &endNextLinePos );
             if (m_layout.currentLineSpacing == BOGUS_LINE_SPACING) {
                 //We found no format command for current line spacing.  Use permanent spacing.
                 //Need to set this *after* we get the line spacing for this line.
                 m_layout.currentLineSpacing = m_layout.permanentLineSpacing;
             }
             //Horizontal starting position.
             currentLine->x = lineInset( *currentLine );
             //See if we're done.
             if ( endNextLinePos >= m_text.size() )
                 //EXIT FROM LOOP
                 break;
             //Start of next line.
             nextLinePos = endNextLinePos;
             m_lines.resize( m_lines.size()+1 );             //Add a new TextLine.
             currentLine = &m_lines.back();
         }
     }
 }

void PaintText::calcLayoutIfNeeded ( void ) const

protected

Definition at line 190 of file painttext.cpp.

References calcLayout(), and m_needLayout.

Referenced by drawLines(), layoutVersion(), lineCount(), and visibleLineCountStartingWith().

 {
     if (m_needLayout) {
         //calcLayout is a cache.  Doesn't change the "real" state of the object.
         PaintText *s = const_cast< PaintText* > (this);
         s->calcLayout();
     }
 }

virtual GFXColor PaintText::color ( void ) const

inlinevirtual

Definition at line 94 of file painttext.h.

References m_color.

Referenced by parseFormat(), and StaticDisplay::textColor().

     {
         return m_color;
     }

void PaintText::draw ( void ) const

inline

Definition at line 140 of file painttext.h.

References drawLines().

Referenced by Picker::draw(), and NewButton::draw().

     {
         drawLines( 0 );
     }

void PaintText::drawLines	(	size_t	start,
		size_t	count = `END_LINE`
	)		const

virtual

Definition at line 218 of file painttext.cpp.

References PaintText::TextLine::baseLine, calcLayoutIfNeeded(), drawChars(), ELLIPSIS_FRAGMENT, ELLIPSIS_STRING, PaintText::TextLine::fragments, GFXBlendMode(), GFXColorf(), GFXPopBlendMode(), GFXPushBlendMode(), GFXToggleTexture(), gl_options, guiMin, PaintText::TextLine::height, i, INVSRCALPHA, LINE_HEIGHT_EPSILON, m_horizontalScaling, m_lines, m_rect, m_text, m_verticalScaling, Rect::origin, gl_options_t::smooth_lines, SRCALPHA, Rect::top(), useStroke(), PaintText::TextLine::x, Point::x, and Point::y.

Referenced by StaticDisplay::draw(), and draw().

 {
     //Make sure we hav a display list.
     calcLayoutIfNeeded();
     //Make sure we have something to do.
     if ( m_lines.empty() )
         return;
     //Initialize the graphics state.
     GFXToggleTexture( false, 0 );
     if (gl_options.smooth_lines)
         glEnable( GL_LINE_SMOOTH );
     GFXPushBlendMode();
     GFXBlendMode( SRCALPHA, INVSRCALPHA );
     glPushMatrix();
     //Keep track of line position.
     float lineTop    = m_rect.top();
     //Figure ending line index.
     const size_t end = guiMin( start+count, m_lines.size() );
     //Loop through the display list lines.
     for (size_t i = start; i < end; i++) {
         const TextLine &line = m_lines[i];
         //Make sure we can paint this line in the vertical space we have left.
         if (lineTop-line.height*LINE_HEIGHT_EPSILON < m_rect.origin.y)
             //Not enough space to draw this line.
             break;
         //Position at the start of the line.
         glLoadIdentity();
         glTranslatef( m_rect.origin.x+line.x, lineTop-line.baseLine, 0.0 );
         if ( line.fragments.size() )
             GFXColorf( line.fragments[0].color );
         if ( !useStroke() )
             glRasterPos2f( 0, 0 );
         else
             glScaled( m_horizontalScaling, m_verticalScaling, 1.0 );
         float rasterpos = 0;
         //Draw each fragment.
         for (vector< TextFragment >::const_iterator frag = line.fragments.begin(); frag != line.fragments.end(); frag++) {
             if (frag->start == ELLIPSIS_FRAGMENT)
                 //We have a special-case for the ellipsis at the end of a line.
                 drawChars( ELLIPSIS_STRING, 0, 2, frag->font, frag->color, rasterpos );
             else
                 rasterpos = drawChars( m_text, frag->start, frag->end, frag->font, frag->color, rasterpos );
         }
         //Top of next line.
         lineTop -= line.height;
     }
     glRasterPos2f( 0, 0 );
     //Undo graphics state
     GFXPopBlendMode();
     if (gl_options.smooth_lines)
         glDisable( GL_LINE_SMOOTH );
     glPopMatrix();
     GFXToggleTexture( true, 0 );
 }

virtual Font PaintText::font ( void ) const

inlinevirtual

Definition at line 101 of file painttext.h.

References m_font.

Referenced by addFragment(), StaticDisplay::font(), parseFragmentsWithCharBreak(), and parseFragmentsWithWordBreak().

     {
         return m_font;
     }

virtual Justification PaintText::justification ( void ) const

inlinevirtual

Definition at line 108 of file painttext.h.

References m_justification.

Referenced by StaticDisplay::justification().

     {
         return m_justification;
     }

int PaintText::layoutVersion ( void ) const

virtual

Definition at line 183 of file painttext.cpp.

References calcLayoutIfNeeded(), and m_layoutVersion.

Referenced by StaticDisplay::draw().

 {
     calcLayoutIfNeeded();
     return m_layoutVersion;
 }

int PaintText::lineCount ( void ) const

virtual

Definition at line 159 of file painttext.cpp.

References calcLayoutIfNeeded(), and m_lines.

Referenced by StaticDisplay::draw().

 {
     calcLayoutIfNeeded();
     return m_lines.size();
 }

float PaintText::lineInset ( const TextLine & line)

protected

Definition at line 662 of file painttext.cpp.

References CENTER_JUSTIFY, LEFT_JUSTIFY, m_horizontalScaling, m_justification, m_rect, Rect::size, Size::width, and PaintText::TextLine::width.

Referenced by calcLayout().

 {
     float result = 0.0;         //Assume we will RIGHT_JUSTIFY.
     if (m_justification == CENTER_JUSTIFY)
         result = (m_rect.size.width-line.width*m_horizontalScaling)/2.0;
     else if (m_justification == LEFT_JUSTIFY)
         result = m_rect.size.width-line.width*m_horizontalScaling;
     return result;
 }

void PaintText::parseFormat	(	std::string::size_type	startPos,
		std::string::size_type *	resultPos,
		bool *	endLine
	)

protected

Definition at line 343 of file painttext.cpp.

References BOGUS_LINE_SPACING, BOLD_STROKE, color(), PaintText::LayoutState::colorStack, PaintText::LayoutState::currentLineSpacing, DT_FORMAT_COLOR_CHAR, DT_FORMAT_LINE_SPACING_CHAR, DT_FORMAT_NEWLINE_CHAR, DT_FORMAT_POP_CHAR, DT_FORMAT_RESET_CHAR, DT_FORMAT_STROKE_CHAR, f, PaintText::LayoutState::fontStack, m_layout, m_text, parseFormatColor(), parseFormatFloat(), and PaintText::LayoutState::permanentLineSpacing.

Referenced by parseFragmentsWithCharBreak(), and parseFragmentsWithWordBreak().

 {
     const string::size_type endPos = m_text.size();
     //Default return value.
     *endLine = false;
     bool formatSuccess = false;
     string::size_type curPos = startPos;
     if (curPos < endPos) {
         //Make sure we have some chars to process.
         switch (m_text[curPos])
         {
         case DT_FORMAT_NEWLINE_CHAR:
             //End of line.
             {
                 float value = BOGUS_LINE_SPACING;            //Bogus value.
                 parseFormatFloat( m_text, curPos+1, endPos, &formatSuccess, &value, &curPos );
                 if (formatSuccess) {
                     *endLine = true;                 //End of this line.
                     if (value != BOGUS_LINE_SPACING)
                         m_layout.currentLineSpacing = value;
                 }
                 break;
             }
         case DT_FORMAT_LINE_SPACING_CHAR:
             //New permanent line spacing.
             {
                 float value = BOGUS_LINE_SPACING;            //Bogus value.
                 parseFormatFloat( m_text, curPos+1, endPos, &formatSuccess, &value, &curPos );
                 if (formatSuccess && value != BOGUS_LINE_SPACING)
                     m_layout.permanentLineSpacing = value;
                 break;
             }
         case DT_FORMAT_STROKE_CHAR:
             //"Bold" -- change stroke width of font.
             {
                 float strokeWeight = BOLD_STROKE;
                 parseFormatFloat( m_text, curPos+1, endPos, &formatSuccess, &strokeWeight, &curPos );
                 if (formatSuccess) {
                     Font f( m_layout.fontStack.back() );             //Make a new font.
                     f.setStrokeWeight( strokeWeight );
                     m_layout.fontStack.push_back( f );
                 }
                 break;
             }
         case DT_FORMAT_COLOR_CHAR:
             //Change the text color.
             {
                 GFXColor color;
                 parseFormatColor( m_text, curPos+1, endPos, &formatSuccess, color, &curPos );
                 if (formatSuccess)
                     m_layout.colorStack.push_back( color );
                 break;
             }
         case DT_FORMAT_POP_CHAR:
             //Pop a color/font.
             curPos++;
             if (curPos == endPos) {
                 *endLine = true;
             } else if (m_text[curPos] == DT_FORMAT_STROKE_CHAR) {
                 if (m_layout.fontStack.size() > 1) m_layout.fontStack.pop_back();
                 else if (m_text[curPos] == DT_FORMAT_COLOR_CHAR)
                     if (m_layout.colorStack.size() > 1) m_layout.colorStack.pop_back();
             }
             curPos++;
             break;
         case DT_FORMAT_RESET_CHAR:
             //Reset colors/fonts back to original.  Pops all off stack except bottom.
             curPos++;
             if (curPos == endPos)
                 *endLine = true;
             else if (m_text[curPos] == DT_FORMAT_STROKE_CHAR)
                 while (m_layout.fontStack.size() > 1)
                     m_layout.fontStack.pop_back();
             else if (m_text[curPos] == DT_FORMAT_COLOR_CHAR)
                 while (m_layout.colorStack.size() > 1)
                     m_layout.colorStack.pop_back();
             curPos++;
             break;
         }
     }
     *resultPos = curPos;
 }

void PaintText::parseFragmentsWithCharBreak	(	TextLine &	line,
		std::string::size_type	startPos,
		std::string::size_type	endPos,
		float	maxWidth,
		bool	ellipsis,
		std::string::size_type *	resultPos
	)

protected

Definition at line 468 of file painttext.cpp.

References addFragment(), Font::charWidth(), DT_FORMAT_CHAR, ELLIPSIS_FRAGMENT, ELLIPSIS_STRING, PaintText::TextFragment::end, font(), PaintText::TextFragment::font, PaintText::LayoutState::fontStack, PaintText::TextLine::fragments, i, isWordBreak(), m_layout, m_text, parseFormat(), PaintText::TextFragment::start, Font::stringWidth(), and PaintText::TextLine::width.

Referenced by calcLayout(), and parseFragmentsWithWordBreak().

 {
     string::size_type curPos = startPos;          //Beginning of current part of the string we are working on.
     double curWidth     = maxWidth;     //The width left to work with.
     bool   forceEndLine = false;    //True = end-of-line through format.  False = char width.
     while (curPos < endPos) {
         //Is there a format char left in this string?
         const string::size_type formatPos = m_text.find( DT_FORMAT_CHAR, curPos );
         if (formatPos == std::string::npos || formatPos >= endPos) {
             //No format char.
             addFragment( line, endPos, curPos, curWidth );
             break;
         }
         //Create fragment for characters before the format char.
         addFragment( line, formatPos, curPos, curWidth );
         if (curPos < formatPos)
             //Format is past the max width.  We're done with this line.
             break;
         //Interpret the format command.
         assert( m_text[curPos] == DT_FORMAT_CHAR );
         curPos++;         //Look at the command char.
         if (curPos >= endPos) {
             //No command char.  String ends with single "#".  Ignore it.
             curPos = endPos-1;
             break;
         }
         if (m_text[curPos] == DT_FORMAT_CHAR) {
             //Double format char.  Equals one format char.
             const string::size_type oldPos = curPos;
             addFragment( line, curPos+1, curPos, curWidth );
             if (curPos == oldPos) {
                 //No room in the line for the one char.  Leave it for next line.
                 curPos--;                 //Put chars back in string.
                 break;                 //End of this line.
             }
         } else {
             parseFormat( curPos, &curPos, &forceEndLine );
             if (forceEndLine)
                 break;
         }
     }
     if (!forceEndLine && curPos < endPos) {
         if (ellipsis) {
             //We need to append an ellipsis. We didn't use the whole string, and we didn't end
             //the line because of a format command.
             //We use the font at the end of the line.  This is a hack, but it seems like a
             //reasonable compromise.  If we use the font from the beginning of the line, suppose the
             //line starts out with bold, followed by a non-bold explanation?
             //We use the color of the last fragment before the ellipsis.
 
             const Font  &font = m_layout.fontStack.back();
             const double ellipsisWidth = font.stringWidth( ELLIPSIS_STRING );
             //If ellipsis doesn't fit in the original width, just ship the truncated string.
             if (ellipsisWidth < maxWidth) {
                 while (line.fragments.size() > 0) {
                     TextFragment     &frag = line.fragments.back();
                     //Remove enough space in the last fragment to be able to append the ellipsis.
                     string::size_type i;
                     for (i = frag.end; i >= frag.start; i--) {
                         curWidth -= frag.font.charWidth( m_text[i] );
                         if (curWidth+ellipsisWidth <= maxWidth) {
                             //If we back up this far, the ellipsis will fit in the max width.
                             frag.end = i;
                             break;
                         }
                     }
                     if (i < frag.start) {
                         //Used up the whole fragment and still didn't find enough space.
                         line.fragments.pop_back();
                     } else {
                         //Create an ellipsis fragment and append it to the line.
                         TextFragment newFrag = frag;
                         newFrag.start = ELLIPSIS_FRAGMENT;
                         line.fragments.push_back( newFrag );
                         curWidth += ellipsisWidth;
                         break;
                     }
                 }
             }
         } else {
             //Get rid of word break chars at the end of this line.
             //First, make sure to skip over any white space.
             while ( curPos < endPos && isWordBreak( m_text[curPos] ) )
                 curPos++;
             //Now, get rid of any word break chars at the tail end of our fragment list.
             while (line.fragments.size() > 0) {
                 TextFragment     &frag = line.fragments.back();
                 string::size_type i;
                 for (i = frag.end; i >= frag.start; i--) {
                     if ( !isWordBreak( m_text[i] ) )
                         break;
                     curWidth -= frag.font.charWidth( m_text[i] );
                 }
                 if (i >= frag.start)
                     //Found something besides a word break in this fragment.
                     break;
                 //Used up the whole fragment.  Start on the next one.
                 line.fragments.pop_back();
             }
         }
     }
     //Set the width of this line.
     line.width = maxWidth-curWidth;
     //And make sure we know how far we got in the string.
     *resultPos = curPos;
 }

void PaintText::parseFragmentsWithWordBreak	(	TextLine &	line,
		std::string::size_type	startPos,
		float	maxWidth,
		std::string::size_type *	resultPos
	)

protected

Definition at line 582 of file painttext.cpp.

References Font::charWidth(), charWidth(), DT_FORMAT_CHAR, font(), PaintText::LayoutState::fontStack, isWordBreak(), m_layout, m_text, parseFormat(), and parseFragmentsWithCharBreak().

Referenced by calcLayout().

 {
     string::size_type curPos = startPos;          //Beginning of current part of the string we are working on.
     double curWidth        = maxWidth;     //The width left to work with.
     const string::size_type endPos = m_text.size();     //One past the end of the string.
     bool   forceEndLine    = false;   //True = end-of-line through format.  False = char width.
     LayoutState origLayout = m_layout;     //The original layout state before we start the line.
     string::size_type wordBreakPos = endPos;      //Previous word break location in text.
     //In this loop we just measure the width.  We find the end of the current line in m_text,
     //then call parseFragmentsWithCharBreak once we know how far to go.
     while (curPos < endPos) {
         //Is there a format char left in this string?
         const string::size_type formatPos = m_text.find( DT_FORMAT_CHAR, curPos );
         string::size_type endFragPos = formatPos;
         if (formatPos == std::string::npos || formatPos >= endPos)
             //No format char.
             endFragPos = endPos;
         //Loop through the characters until we run out of room.
         const Font &font = m_layout.fontStack.back();
         while (curPos < endFragPos) {
             double charWidth = font.charWidth( m_text[curPos] );
             if ( isWordBreak( m_text[curPos] ) )
                 wordBreakPos = curPos;
             if (curWidth-charWidth < 0.0)
                 //The current character goes past the specified width.
                 break;
             curWidth -= charWidth;
             curPos++;
         }
         if (curPos == endPos) {
             //The rest of the text is not as wide as the max.  We are done with this pass.
             wordBreakPos = endPos;
             break;
         } else if (curPos < endFragPos) {
             //We found a last character. Go back to the last word break.
             break;
         }
         assert( curPos == formatPos );         //Other other case: we ran into a format command.
         //Interpret the format command.
         assert( m_text[curPos] == DT_FORMAT_CHAR );
         curPos++;         //Look at the command char.
         if (curPos >= endPos) {
             //No command char.  String ends with single "#".  Ignore it.
             curPos = endPos-1;
             break;
         }
         if (m_text[curPos] == DT_FORMAT_CHAR) {
             //Double format char.  Equals one format char.
             curWidth -= font.charWidth( DT_FORMAT_CHAR );
             if (curWidth < 0.0) {
                 //No room in the line for the one char.  Leave it for next line.
                 curPos--;                 //Put chars back in string.
                 break;                 //End of this line.
             }
         } else {
             parseFormat( curPos, &curPos, &forceEndLine );
             if (forceEndLine) {
                 wordBreakPos = endPos;
                 break;
             }
         }
     }
     //Now we need to generate the fragments.
     //NOTE:  If the text contains a word that is too long for a line, we get a special case
     //where we never find a word break.  That ends up calling parseFragmentsWithCharBreak with
     //the end of the string as the limit, so the word is broken on a char boundary, which is
     //exactly what we want.
     string::size_type endLinePos = wordBreakPos+1;
     //Include all extra word break characters.
     while ( endLinePos+1 < endPos && isWordBreak( m_text[endLinePos] ) )
         endLinePos++;
     m_layout = origLayout;                 //Undo any format changes.
     parseFragmentsWithCharBreak( line, startPos, endLinePos, maxWidth, false, resultPos );
 }

virtual Rect PaintText::rect ( void ) const

inlinevirtual

Definition at line 80 of file painttext.h.

References m_rect.

     {
         return m_rect;
     }

void PaintText::setColor ( const GFXColor & c)

virtual

Definition at line 123 of file painttext.cpp.

References c, equalColors(), m_color, and m_needLayout.

Referenced by Picker::draw(), NewButton::draw(), and StaticDisplay::setTextColor().

 {
     if ( !equalColors( m_color, c ) ) {
         m_color = c;
         m_needLayout = true;
     }
 }

void PaintText::setFont ( const Font & f)

virtual

Definition at line 132 of file painttext.cpp.

References m_font, and m_needLayout.

Referenced by Picker::draw(), NewButton::draw(), and StaticDisplay::setFont().

 {
     if (m_font != f) {
         m_font = f;
         m_needLayout = true;
     }
 }

void PaintText::setJustification ( Justification j)

virtual

Definition at line 141 of file painttext.cpp.

References m_justification, and m_needLayout.

Referenced by NewButton::draw(), and StaticDisplay::setJustification().

 {
     if (m_justification != j) {
         m_justification = j;
         m_needLayout    = true;
     }
 }

void PaintText::setRect ( const Rect & r)

virtual

Definition at line 92 of file painttext.cpp.

References m_needLayout, and m_rect.

Referenced by Picker::draw(), NewButton::draw(), and StaticDisplay::setPaintTextRect().

 {
     if (m_rect != r) {
         m_rect = r;
         m_needLayout = true;
     }
 }

void PaintText::setText ( const std::string & text)

virtual

Definition at line 101 of file painttext.cpp.

References i, m_needLayout, m_text, OLD_FORMAT_NEWLINE, and text().

Referenced by Picker::draw(), NewButton::draw(), PaintText(), and StaticDisplay::setText().

 {
     const string *finalText = &text;
     string conversionResult;
     if (text.find( OLD_FORMAT_NEWLINE ) != string::npos) {
         //We have some old format characters we need to convert.
         for (string::const_iterator i = text.begin(); i != text.end(); i++) {
             if (*i == OLD_FORMAT_NEWLINE)
                 conversionResult.append( "#n#" );
             else
                 conversionResult += (*i);
         }
         finalText = &conversionResult;
     }
     //OK, now we see whether anything has changed.
     if (m_text != *finalText) {
         m_text = *finalText;
         m_needLayout = true;
     }
 }

void PaintText::setWidthExceeded ( WidthExceeded w)

virtual

Definition at line 150 of file painttext.cpp.

References m_needLayout, and m_widthExceeded.

Referenced by StaticDisplay::setMultiLine().

 {
     if (m_widthExceeded != w) {
         m_widthExceeded = w;
         m_needLayout    = true;
     }
 }

virtual const std::string& PaintText::text ( void ) const

inlinevirtual

Definition at line 87 of file painttext.h.

References m_text.

Referenced by setText(), and StaticDisplay::text().

     {
         return m_text;
     }

int PaintText::visibleLineCountStartingWith	(	int	lineNumber,
		float	vertInterval
	)		const

virtual

Definition at line 166 of file painttext.cpp.

References calcLayoutIfNeeded(), i, LINE_HEIGHT_EPSILON, and m_lines.

Referenced by StaticDisplay::draw().

 {
     calcLayoutIfNeeded();
     int   result = 0;
     float currentHeight = vertInterval;
     for (vector< TextLine >::size_type i = lineNumber; i < m_lines.size(); ++i) {
         const float lineHeight = m_lines[i].height;
         if (currentHeight-lineHeight*LINE_HEIGHT_EPSILON < 0.0)
             //Did all the lines.
             break;
         currentHeight -= lineHeight;
         result++;
     }
     return result;
 }

virtual WidthExceeded PaintText::widthExceeded ( void ) const

inlinevirtual

Definition at line 123 of file painttext.h.

References m_widthExceeded.

Referenced by StaticDisplay::multiLine().

     {
         return m_widthExceeded;
     }

Member Data Documentation

const size_t PaintText::END_LINE = 1000000

static

Definition at line 138 of file painttext.h.

GFXColor PaintText::m_color

protected

Definition at line 239 of file painttext.h.

Referenced by calcLayout(), color(), and setColor().

Font PaintText::m_font

protected

Definition at line 240 of file painttext.h.

Referenced by calcLayout(), font(), and setFont().

double PaintText::m_horizontalScaling

protected

Definition at line 248 of file painttext.h.

Referenced by calcLayout(), drawLines(), and lineInset().

Justification PaintText::m_justification

protected

Definition at line 241 of file painttext.h.

Referenced by justification(), lineInset(), and setJustification().

LayoutState PaintText::m_layout

protected

Definition at line 249 of file painttext.h.

Referenced by addFragment(), calcLayout(), parseFormat(), parseFragmentsWithCharBreak(), and parseFragmentsWithWordBreak().

int PaintText::m_layoutVersion

protected

Definition at line 245 of file painttext.h.

Referenced by calcLayout(), and layoutVersion().

vector< TextLine > PaintText::m_lines

protected

Definition at line 246 of file painttext.h.

Referenced by calcLayout(), drawLines(), lineCount(), and visibleLineCountStartingWith().

bool PaintText::m_needLayout

protected

Definition at line 244 of file painttext.h.

Referenced by calcLayout(), calcLayoutIfNeeded(), setColor(), setFont(), setJustification(), setRect(), setText(), and setWidthExceeded().

Rect PaintText::m_rect

protected

Definition at line 237 of file painttext.h.

Referenced by calcLayout(), drawLines(), lineInset(), rect(), and setRect().

std::string PaintText::m_text

protected

Definition at line 238 of file painttext.h.

Referenced by addFragment(), calcLayout(), drawLines(), parseFormat(), parseFragmentsWithCharBreak(), parseFragmentsWithWordBreak(), setText(), and text().

double PaintText::m_verticalScaling

protected

Definition at line 247 of file painttext.h.

Referenced by calcLayout(), and drawLines().

WidthExceeded PaintText::m_widthExceeded

protected

Definition at line 242 of file painttext.h.

Referenced by calcLayout(), setWidthExceeded(), and widthExceeded().

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

src/gui/painttext.h
src/gui/painttext.cpp

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation