kc3-lang/ftgl

diff --git a/include/FTLayout.h b/include/FTLayout.h
new file mode 100644
index 0000000..43f0410
--- /dev/null
+++ b/include/FTLayout.h
@@ -0,0 +1,107 @@
+#ifndef    __FTLayout__
+#define    __FTLayout__
+
+#include "FTGL.h"
+#include "FTPoint.h"
+#include "FTFont.h"
+
+/**
+ * FTLayout is the interface for layout managers that render text.
+ *
+ * Specific layout manager classes are derived from this class. This class
+ * is abstract and deriving classes must implement the protected
+ * <code>Render</code> methods to render formatted text and 
+ * <code>BBox</code> methods to determine the bounding box of output text.
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTLayout {
+    public:        
+        /**
+         * Get the bounding box for a formatted string.
+         *
+         * @param string    a char string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        virtual void BBox(const char* String,float& llx,float& lly,float& llz,float& urx,float& ury,float& urz) = 0;
+
+        /**
+         * Get the bounding box for a formatted string.
+         *
+         * @param string    a wchar_t string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        virtual void BBox(const wchar_t* String,float& llx,float& lly,float& llz,float& urx,float& ury,float& urz) = 0;
+            
+        /**
+         * Render a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        virtual void Render(const char *String) = 0;
+
+        /**
+         * Render a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        virtual void Render(const wchar_t *String) = 0;
+   protected:
+        /**
+         * Current pen or cursor position;
+         */
+        FTPoint pen;
+
+        /**
+         * Expose <code>FTFont::DoRender</code> method to derived classes.
+         * 
+         * @param font 		 The font that contains the glyph.
+         * @param chr       current character
+         * @param nextChr   next character
+         * @see FTFont::DoRender
+         */
+        void DoRender(FTFont *font,const unsigned int chr,const unsigned int nextChr)
+            { font->DoRender(chr,nextChr,pen); }
+        
+        /**
+         * Expose <code>FTFont::CheckGlyph</code> method to derived classes.
+         *
+         * @param font The font that contains the glyph.
+         * @param chr  character index
+         */
+        void CheckGlyph(FTFont *font,const unsigned int Chr)
+            { font->CheckGlyph(Chr); }
+            
+         /**
+          * Expose the FTFont <code>glyphList</code> to our derived classes.
+          * 
+          * @param font The font to perform the query on.
+          * @param Char The character corresponding to the glyph to query.
+          *
+          * @return A pointer to the glyphList of font.
+          */ 
+         FTGlyphContainer *GetGlyphs(FTFont *font)
+            { return(font->glyphList); }
+            
+         /** 
+          * Expose the FTFont <code>charSize</code> to our derived classes.
+          *
+          * @param The font to perform the query on.
+          *
+          * @return A reference to the charSize object of font.
+          */
+         FTSize &GetCharSize(FTFont *font)
+            { return(font->charSize); }
+}; /* class FTLayout */
+#endif  /* __FTLayout__ */
+
diff --git a/include/FTSimpleLayout.h b/include/FTSimpleLayout.h
new file mode 100644
index 0000000..665e6cf
--- /dev/null
+++ b/include/FTSimpleLayout.h
@@ -0,0 +1,262 @@
+#ifndef    __FTSimpleLayout__
+#define    __FTSimpleLayout__
+
+#include "FTLayout.h"
+#include "FTBBox.h"
+
+class FTFont;
+
+class FTGL_EXPORT FTSimpleLayout : public FTLayout {
+    public:        
+        /**
+         * Initializes line spacing to 1.0, alignment to 
+         * ALIGN_LEFT and wrap to 100.0
+         */
+        FTSimpleLayout();
+        
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string    a char string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        virtual void BBox( const char* string, float& llx, float& lly, float& llz, float& urx, float& ury, float& urz);
+        
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string    a wchar_t string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        virtual void BBox( const wchar_t* string, float& llx, float& lly, float& llz, float& urx, float& ury, float& urz);
+                        
+        /**
+         * Render a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        virtual void Render( const char* string );
+
+        /**
+         * Render a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        virtual void Render( const wchar_t* string );
+        
+        /**
+         * Render a string of characters and distribute extra space amongst
+         * the whitespace regions of the string.
+         *
+         * @param String		'C' style string to output.
+         * @param ExtraSpace  The amount of extra space to add to each run of 
+         *                    whitespace.
+         */
+        void RenderSpace(const char *String,const float ExtraSpace = 0.0)
+            { pen.x = 0; pen.y = 0; RenderSpace(String,0,-1,ExtraSpace); }
+
+        /**
+         * Render a string of characters and distribute extra space amongst
+         * the whitespace regions of the string.
+         *
+         * @param String		wchar_t string to output.
+         * @param ExtraSpace  The amount of extra space to add to each run of 
+         *                    whitespace.
+         */
+        void RenderSpace(const wchar_t *String,const float ExtraSpace = 0.0)
+            { pen.x = 0; pen.y = 0; RenderSpace(String,0,-1,ExtraSpace); }        
+        
+        typedef enum {ALIGN_LEFT,ALIGN_CENTER,ALIGN_RIGHT,ALIGN_JUST} TextAlignment;
+        
+        /**
+         * Set he font to use for rendering the text.  
+         *
+         * @param fontInit A pointer to the new font.  The font is
+         *                 referenced by this but will not be 
+         *                 disposed of when this is deleted.
+         */
+        void SetFont(FTFont *fontInit) 
+            { currentFont = fontInit; }
+        /**
+         * @return The current font.
+         */
+        FTFont *GetFont() 
+            { return(currentFont); }
+        /**
+         * The maximum line length for formatting text.
+         *
+         * @param LineLength The new line length.
+         */
+        void SetLineLength(const float LineLength)
+            { lineLength = LineLength; }
+            
+        /**
+         * @return The current line length.
+         */
+        float GetLineLength() const
+            { return(lineLength); }
+            
+        /**
+         * The text alignment mode used to distribute
+         * space within a line or rendered text.
+         *
+         * @param Alignment The new alignment mode.
+         */
+        void SetAlignment(const TextAlignment Alignment) 
+            { alignment = Alignment; }
+        /**
+         * @return The text alignment mode.
+         */
+        TextAlignment GetAlignment() const
+            { return(alignment); }
+            
+        /**
+         * Sets the line height.
+         *
+         * @param LineSpacing The height of each line of text expressed as
+         *                    a percentage of the current fonts line height.
+         */
+        void SetLineSpacing(const float LineSpacing) 
+            { lineSpacing = LineSpacing; }
+            
+        /**
+         * @return The line spacing.
+         */
+        float GetLineSpacing() const
+            { return(lineSpacing); }
+   protected:
+        /**
+         * Render a string of characters and distribute extra space amongst
+         * the whitespace regions of the string.  Note that this method
+         * does not reset the pen position before rendering.  This method
+         * provides the impelmentation for other RenderSpace methods and
+         * thus should be overloaded when attempting to overload any
+         * RenderSpace methods.
+         *
+         * @param String	A buffer of wchar_t characters to output.
+         * @param Start    The index of the first character in String to output.
+         * @param Stop     The index of the last character in String to output.
+         * @param ExtraSpace The amount of extra space to distribute amongst
+         *                   the characters.
+         */
+        virtual void RenderSpace(const char *String,const int Start,const int Stop,const float ExtraSpace = 0.0);
+
+        /**
+         * Render a string of characters and distribute extra space amongst
+         * the whitespace regions of the string.  Note that this method
+         * does not reset the pen position before rendering.  This method
+         * provides the impelmentation for other RenderSpace methods and
+         * thus should be overloaded when attempting to overload any
+         * RenderSpace methods.
+         *
+         * @param String	A buffer of wchar_t characters to output.
+         * @param Start    The index of the first character in String to output.
+         * @param Stop     The index of the last character in String to output.
+         * @param ExtraSpace The amount of extra space to distribute amongst
+         *                   the characters.
+         */
+        virtual void RenderSpace(const wchar_t *String,const int Start,const int Stop,const float ExtraSpace = 0.0);
+    private:        
+        /**
+         * Either render a string of characters and wrap lines
+         * longer than a threshold or compute the bounds
+         * of a string of characters when wrapped.  The functionality
+         * of this method is exposed by the BBoxWrapped and
+         * RenderWrapped methods.
+         *
+         * @param Buffer 		wchar_t style string to output.
+         * @param bounds      A pointer to a bounds object.  If non null
+         *                    the bounds of the text when laid out
+         *                    will be stored in bounds.  If null the
+         *                    text will be rendered.
+         */      
+        virtual void WrapText(const char *Buffer,FTBBox *bounds = NULL);
+        
+        /**
+         * Either render a string of characters and wrap lines
+         * longer than a threshold or compute the bounds
+         * of a string of characters when wrapped.  The functionality
+         * of this method is exposed by the BBoxWrapped and
+         * RenderWrapped methods.
+         *
+         * @param Buffer 		wchar_t style string to output.
+         * @param bounds      A pointer to a bounds object.  If non null
+         *                    the bounds of the text when laid out
+         *                    will be stored in bounds.  If null the
+         *                    text will be rendered.
+         */        
+        virtual void WrapText(const wchar_t *Buffer,FTBBox *bounds = NULL);
+
+        /**
+         * A helper method used by WrapText to either output the text or
+         * compute it's bounds.
+         *
+         * @param Buffer   A pointer to an array of character data.
+         * @param StartIdx The index of the first character to process.
+         * @param EndIdx   The index of the last character to process.  If 
+         *                 < 0 then characters will be parsed until a '\0'
+         *                 is encountered.
+         * @param RemainingWidth The amount of extra space left on the line.
+         * @param bounds     A pointer to a bounds object.  If non null the
+         *                   bounds will be initialized or expanded by the 
+         *                   bounds of the line.  If null the text will be 
+         *                   rendered.  If the bounds are invalid (lower > upper)
+         *                   they will be initialized.  Otherwise they
+         *                   will be expanded.
+         */
+        void OutputWrapped(const char *Buffer,const int StartIdx,const int EndIdx,const float RemainingWidth,FTBBox *bounds);
+
+        /**
+         * A helper method used by WrapText to either output the text or
+         * compute it's bounds.
+         *
+         * @param Buffer   A pointer to an array of character data.
+         * @param StartIdx The index of the first character to process.
+         * @param EndIdx   The index of the last character to process.  If 
+         *                 < 0 then characters will be parsed until a '\0'
+         *                 is encountered.
+         * @param RemainingWidth The amount of extra space left on the line.
+         * @param bounds     A pointer to a bounds object.  If non null the
+         *                   bounds will be initialized or expanded by the 
+         *                   bounds of the line.  If null the text will be 
+         *                   rendered.  If the bounds are invalid (lower > upper)
+         *                   they will be initialized.  Otherwise they
+         *                   will be expanded.
+         */
+        void OutputWrapped(const wchar_t *Buffer,const int StartIdx,const int EndIdx,const float RemainingWidth,FTBBox *bounds);
+        
+        /**
+         * The font to use for rendering the text.  The font is
+         * referenced by this but will not be disposed of when this
+         * is deleted.
+         */
+        FTFont          *currentFont;
+        /**
+         * The maximum line length for formatting text.
+         */
+        float				lineLength;
+        
+        /**
+         * The text alignment mode used to distribute
+         * space within a line or rendered text.
+         */
+        TextAlignment 	alignment;
+        
+        /**
+         * The height of each line of text expressed as
+         * a percentage of the fonts line height.
+         */
+        float 				lineSpacing;
+}; /* class FTSimpleLayout */
+#endif  /* __FTSimpleLayout__ */
+
diff --git a/src/FTSimpleLayout.cpp b/src/FTSimpleLayout.cpp
new file mode 100644
index 0000000..c28bd6d
--- /dev/null
+++ b/src/FTSimpleLayout.cpp
@@ -0,0 +1,347 @@
+#include "FTSimpleLayout.h"
+
+#include "FTFont.h"
+#include "FTGlyphContainer.h"
+#include "FTBBox.h"
+
+#include <ctype.h>
+
+
+FTSimpleLayout::FTSimpleLayout() {
+   currentFont = NULL;
+   lineLength = 100.0f;
+   alignment = ALIGN_LEFT;
+   lineSpacing = 1.0f;
+} /* FTSimpleLayout::FTSimpleLayout() */
+
+void FTSimpleLayout::BBox(const char *String,float& llx, float& lly, float& llz, float& urx, float& ury, float& urz) {
+   FTBBox bounds; 
+   
+   WrapText(String,&bounds); 
+   llx = bounds.lowerX; lly = bounds.lowerY; llz = bounds.lowerZ;
+   urx = bounds.upperX; ury = bounds.upperY; urz = bounds.upperZ;
+} /* FTSimpleLayout::BBox() */
+
+void FTSimpleLayout::BBox(const wchar_t *String,float& llx, float& lly, float& llz, float& urx, float& ury, float& urz) {
+   FTBBox bounds; 
+   
+   WrapText(String,&bounds); 
+   llx = bounds.lowerX; lly = bounds.lowerY; llz = bounds.lowerZ;
+   urx = bounds.upperX; ury = bounds.upperY; urz = bounds.upperZ;
+} /* FTSimpleLayout::BBox() */
+
+void FTSimpleLayout::Render(const char *String) {
+   pen.x = pen.y = 0.0f;
+   WrapText(String,NULL);
+} /* FTSimpleLayout::Render() */
+
+void FTSimpleLayout::Render(const wchar_t* String) {
+   pen.x = pen.y = 0.0f;
+   WrapText(String,NULL);
+} /* FTSimpleLayout::Render() */
+
+void FTSimpleLayout::WrapText(const char *Buffer,FTBBox *bounds) {
+   int breakIdx = 0;					// The index of the last break character
+   int lineStart = 0;				// The character index of the line start
+   float nextStart = 0.0;			// The total width of the line being generated
+   float breakWidth = 0.0;			// The width of the line up to the last word break
+   float currentWidth = 0.0;		// The width of all characters on the line being generated
+   float prevWidth;					// The width of all characters but the current glyph
+   float wordLength = 0.0;			// The length of the block since the last break character
+   float glyphWidth,advance;
+   FTBBox glyphBounds;
+   /* Reset the pen position */
+   pen.y = 0;
+   
+   if (bounds) {
+      bounds->Invalidate();
+   } /* If we have bounds mark them invalid (if bounds) */
+   
+   for (int charIdx = 0;Buffer[charIdx];charIdx++) {         
+      /* Find the width of the current glyph */
+      CheckGlyph(currentFont,Buffer[charIdx]);
+      glyphBounds = GetGlyphs(currentFont)->BBox(Buffer[charIdx]);
+      glyphWidth = glyphBounds.upperX - glyphBounds.lowerX;
+      
+      advance = GetGlyphs(currentFont)->Advance(Buffer[charIdx],Buffer[charIdx + 1]);
+      prevWidth = currentWidth;
+      /* Compute the width of all glyphs up to the end of Buffer[charIdx] */
+      currentWidth = nextStart + glyphWidth;
+      /* Compute the position of the next glyph */
+      nextStart += advance;
+      
+      if ((currentWidth > lineLength) || (Buffer[charIdx] == '\n')) {
+         /* A non whitespace character has exceeded the line length.  Or a */
+         /* newline character has forced a line break.  Output the last    */
+         /* line and start a new line after the break character.           */
+         
+         if (!breakIdx || (Buffer[charIdx] == '\n')) {
+            /* Break on the previous character */
+            breakIdx = charIdx - 1;
+            breakWidth = prevWidth;
+            /* None of the previous word will be carried to the next line */
+            wordLength = 0;
+            /* If the current character is a newline discard it's advance */
+            if (Buffer[charIdx] == '\n') advance = 0;
+         } /* If we have not yet found a break break on the last character (if !breakIdx) */
+         
+         float remainingWidth = lineLength - breakWidth;
+
+         /* Render the current substring */
+         if (Buffer[breakIdx + 1] == '\n') {
+            breakIdx++;
+            OutputWrapped(Buffer,lineStart,breakIdx -1,remainingWidth,bounds);
+         } else {
+            OutputWrapped(Buffer,lineStart,breakIdx   ,remainingWidth,bounds);
+         } /* If the break character is a newline do not render it (if Buffer[charIdx]) */
+
+         /* Store the start of the next line */
+         lineStart = breakIdx + 1;
+         // TODO: Is Height() the right value here?
+         pen.y -= GetCharSize(currentFont).Height()*lineSpacing;
+         /* The current width is the width since the last break */
+         nextStart = wordLength + advance;
+         wordLength += advance;
+         currentWidth = wordLength + advance;
+         /* Reset the safe break for the next line */
+         breakIdx = 0;
+      } else if (isspace(Buffer[charIdx])) {
+         /* This is the last word break position */
+         wordLength = 0;
+         breakIdx = charIdx;
+
+         if (!charIdx || !isspace(Buffer[charIdx - 1])) {
+            /* Record the width of the start of the block */
+            breakWidth = currentWidth;
+         } /* Check to see if this is the first whitespace character in a run (if !isspace()) */
+      } else {
+         wordLength += advance;
+      } /* See if Buffer[charIdx] is a space, a break or a regular charactger (if/elseif/else Buffer[]) */
+   } /* Scan the input for all characters that need output (for charIdx) */
+   
+   float remainingWidth = lineLength - currentWidth;
+   /* Render any remaining text on the last line */
+   if (alignment == ALIGN_JUST) {
+      alignment = ALIGN_LEFT;
+      OutputWrapped(Buffer,lineStart,-1,remainingWidth,bounds);
+      alignment = ALIGN_JUST;
+   } else {
+      OutputWrapped(Buffer,lineStart,-1,remainingWidth,bounds);
+   } /* Disable justification for the last row (if/else Alignemnt) */
+} /* FTSimpleLayout::WrapText() */
+
+void FTSimpleLayout::WrapText(const wchar_t* Buffer,FTBBox *bounds) {
+   int breakIdx = 0;					// The index of the last break character
+   int lineStart = 0;				// The character index of the line start
+   float nextStart = 0.0;			// The total width of the line being generated
+   float breakWidth = 0.0;			// The width of the line up to the last word break
+   float currentWidth = 0.0;		// The width of all characters on the line being generated
+   float prevWidth;					// The width of all characters but the current glyph
+   float wordLength = 0.0;			// The length of the block since the last break character
+   float glyphWidth,advance;
+   FTBBox glyphBounds;
+   /* Reset the pen position */
+   pen.y = 0;
+   
+   if (bounds) {
+      bounds->Invalidate();
+   } /* If we have bounds mark them invalid (if bounds) */
+   
+   for (int charIdx = 0;Buffer[charIdx];charIdx++) {         
+      /* Find the width of the current glyph */
+      CheckGlyph(currentFont,Buffer[charIdx]);
+      glyphBounds = GetGlyphs(currentFont)->BBox(Buffer[charIdx]);
+      glyphWidth = glyphBounds.upperX - glyphBounds.lowerX;
+      
+      advance = GetGlyphs(currentFont)->Advance(Buffer[charIdx],Buffer[charIdx + 1]);
+      prevWidth = currentWidth;
+      /* Compute the width of all glyphs up to the end of Buffer[charIdx] */
+      currentWidth = nextStart + glyphWidth;
+      /* Compute the position of the next glyph */
+      nextStart += advance;
+      
+      if ((currentWidth > lineLength) || (Buffer[charIdx] == '\n')) {
+         /* A non whitespace character has exceeded the line length.  Or a */
+         /* newline character has forced a line break.  Output the last    */
+         /* line and start a new line after the break character.           */
+         
+         if (!breakIdx || (Buffer[charIdx] == '\n')) {
+            /* Break on the previous character */
+            breakIdx = charIdx - 1;
+            breakWidth = prevWidth;
+            /* None of the previous word will be carried to the next line */
+            wordLength = 0;
+            /* If the current character is a newline discard it's advance */
+            if (Buffer[charIdx] == '\n') advance = 0;
+         } /* If we have not yet found a break break on the last character (if !breakIdx) */
+         
+         float remainingWidth = lineLength - breakWidth;
+
+         /* Render the current substring */
+         if (Buffer[breakIdx + 1] == '\n') {
+            breakIdx++;
+            OutputWrapped(Buffer,lineStart,breakIdx -1,remainingWidth,bounds);
+         } else {
+            OutputWrapped(Buffer,lineStart,breakIdx   ,remainingWidth,bounds);
+         } /* If the break character is a newline do not render it (if Buffer[charIdx]) */
+
+         /* Store the start of the next line */
+         lineStart = breakIdx + 1;
+         // TODO: Is Height() the right value here?
+         pen.y -= GetCharSize(currentFont).Height()*lineSpacing;
+         /* The current width is the width since the last break */
+         nextStart = wordLength + advance;
+         wordLength += advance;
+         currentWidth = wordLength + advance;
+         /* Reset the safe break for the next line */
+         breakIdx = 0;
+      } else if (isspace(Buffer[charIdx])) {
+         /* This is the last word break position */
+         wordLength = 0;
+         breakIdx = charIdx;
+
+         if (!charIdx || !isspace(Buffer[charIdx - 1])) {
+            /* Record the width of the start of the block */
+            breakWidth = currentWidth;
+         } /* Check to see if this is the first whitespace character in a run (if !isspace()) */
+      } else {
+         wordLength += advance;
+      } /* See if Buffer[charIdx] is a space, a break or a regular charactger (if/elseif/else Buffer[]) */
+   } /* Scan the input for all characters that need output (for charIdx) */
+   
+   float remainingWidth = lineLength - currentWidth;
+   /* Render any remaining text on the last line */
+   if (alignment == ALIGN_JUST) {
+      alignment = ALIGN_LEFT;
+      OutputWrapped(Buffer,lineStart,-1,remainingWidth,bounds);
+      alignment = ALIGN_JUST;
+   } else {
+      OutputWrapped(Buffer,lineStart,-1,remainingWidth,bounds);
+   } /* Disable justification for the last row (if/else Alignemnt) */
+} /* FTSimpleLayout::WrapText() */
+
+void FTSimpleLayout::OutputWrapped(const char *Buffer,const int StartIdx,const int EndIdx,const float RemainingWidth,FTBBox *bounds) {
+   float distributeWidth = 0.0;
+   switch (alignment) {
+      case ALIGN_LEFT:
+         pen.x = 0; 
+         break;
+      case ALIGN_CENTER:
+         pen.x = RemainingWidth/2; 
+         break;
+      case ALIGN_RIGHT:
+         pen.x = RemainingWidth;
+         break;
+      case ALIGN_JUST:
+         pen.x = 0;
+         distributeWidth = RemainingWidth;
+         break;
+   } /* Allign the text according as specified by Alignment (switch Alignment) */
+
+   if (bounds) {
+      float llx,lly,llz,urx,ury,urz;
+      currentFont->BBox(Buffer,StartIdx,EndIdx,llx,lly,llz,urx,ury,urz);
+
+      /* Add the extra space to the upper x dimension */
+      urx += distributeWidth;
+      // TODO: It's a little silly to convert from a FTBBox to floats and back again, but I don't want to 
+      //       implement yet another method for finding the bounding box as a BBox.
+      FTBBox temp(llx,lly,llz,urx,ury,urz);
+      temp.Move(FTPoint(pen.x,pen.y,0.0f));
+      
+      if (!bounds->IsValid()) {
+         *bounds = temp;
+      } else {
+         *bounds += temp;
+      } /* See if this is the first area to be added to the bounds (if/else bounds) */
+   } else {
+      RenderSpace(Buffer,StartIdx,EndIdx,distributeWidth);
+   } /* If we have bounds expand them by the lines bounds, otherwise render the line (if/else bounds) */
+} /* FTSimpleLayout::OutputWrapped() */
+
+void FTSimpleLayout::OutputWrapped(const wchar_t *Buffer,const int StartIdx,const int EndIdx,const float RemainingWidth,FTBBox *bounds) {
+   float distributeWidth = 0.0;
+   switch (alignment) {
+      case ALIGN_LEFT:
+         pen.x = 0; 
+         break;
+      case ALIGN_CENTER:
+         pen.x = RemainingWidth/2; 
+         break;
+      case ALIGN_RIGHT:
+         pen.x = RemainingWidth;
+         break;
+      case ALIGN_JUST:
+         pen.x = 0;
+         distributeWidth = RemainingWidth;
+         break;
+   } /* Allign the text according as specified by Alignment (switch Alignment) */
+
+   if (bounds) {
+      float llx,lly,llz,urx,ury,urz;
+      currentFont->BBox(Buffer,StartIdx,EndIdx,llx,lly,llz,urx,ury,urz);
+
+      /* Add the extra space to the upper x dimension */
+      urx += distributeWidth;
+      // TODO: It's a little silly to convert from a FTBBox to floats and back again, but I don't want to 
+      //       implement yet another method for finding the bounding box as a BBox.
+      FTBBox temp(llx,lly,llz,urx,ury,urz);
+      temp.Move(FTPoint(pen.x,pen.y,0.0f));
+      
+      if (!bounds->IsValid()) {
+         *bounds = temp;
+      } else {
+         *bounds += temp;
+      } /* See if this is the first area to be added to the bounds (if/else bounds) */
+   } else {
+      RenderSpace(Buffer,StartIdx,EndIdx,distributeWidth);
+   } /* If we have bounds expand them by the lines bounds, otherwise render the line (if/else bounds) */
+} /* FTSimpleLayout::OutputWrapped() */
+
+void FTSimpleLayout::RenderSpace(const char *String,const int StartIdx,const int EndIdx,const float ExtraSpace) {
+   float space = 0.0;
+   
+   if (ExtraSpace > 0.0) {
+      int numSpaces = 0;
+
+      for (int idx = StartIdx;((EndIdx < 0) && String[idx]) || ((EndIdx >= 0) && (idx <= EndIdx));idx++) {
+         if ((idx > StartIdx) && !isspace(String[idx]) && isspace(String[idx - 1])) {
+            numSpaces++;
+         } /* If this is the end of a space block increment the counter (if isspace()) */
+      } /* Count the number of space blocks in the input (for idx) */
+      
+      space = ExtraSpace/numSpaces;
+   } /* If there is space to distribute count the number of spaces (if ExtraSpace) */
+   
+   for (int idx = StartIdx;((EndIdx < 0) && String[idx]) || ((EndIdx >= 0) && (idx <= EndIdx));idx++) {
+      if ((idx > StartIdx) && !isspace(String[idx]) && isspace(String[idx - 1])) {
+         pen.x += space;
+      } /* If this is the end of a space block distribute the extra space into it (if isspace()) */
+
+      DoRender(currentFont,String[idx],String[idx + 1]);
+   } /* Output all characters of the string (for idx) */
+} /* FTSimpleLayout::RenderSpace() */
+
+void FTSimpleLayout::RenderSpace(const wchar_t *String,const int StartIdx,const int EndIdx,const float ExtraSpace) {
+   float space = 0.0;
+   
+   if (ExtraSpace > 0.0) {
+      int numSpaces = 0;
+
+      for (int idx = StartIdx;((EndIdx < 0) && String[idx]) || ((EndIdx >= 0) && (idx <= EndIdx));idx++) {
+         if ((idx > StartIdx) && !isspace(String[idx]) && isspace(String[idx - 1])) {
+            numSpaces++;
+         } /* If this is the end of a space block increment the counter (if isspace()) */
+      } /* Count the number of space blocks in the input (for idx) */
+      
+      space = ExtraSpace/numSpaces;
+   } /* If there is space to distribute count the number of spaces (if ExtraSpace) */
+   
+   for (int idx = StartIdx;((EndIdx < 0) && String[idx]) || ((EndIdx >= 0) && (idx <= EndIdx));idx++) {
+      if ((idx > StartIdx) && !isspace(String[idx]) && isspace(String[idx - 1])) {
+         pen.x += space;
+      } /* If this is the end of a space block distribute the extra space into it (if isspace()) */
+
+      DoRender(currentFont,String[idx],String[idx + 1]);
+   } /* Output all characters of the string (for idx) */
+} /* FTSimpleLayout::RenderSpace() */