From 37a92b86d13e89d0dcec92be6d23ceced29dbc36 Mon Sep 17 00:00:00 2001 From: scuri Date: Mon, 21 Jun 2010 22:55:10 +0000 Subject: *** empty log message *** --- src/ftgl/FTLayout/FTLayout.cpp | 80 ++++++ src/ftgl/FTLayout/FTLayoutGlue.cpp | 171 ++++++++++++ src/ftgl/FTLayout/FTLayoutImpl.h | 56 ++++ src/ftgl/FTLayout/FTSimpleLayout.cpp | 460 +++++++++++++++++++++++++++++++++ src/ftgl/FTLayout/FTSimpleLayoutImpl.h | 225 ++++++++++++++++ 5 files changed, 992 insertions(+) create mode 100644 src/ftgl/FTLayout/FTLayout.cpp create mode 100644 src/ftgl/FTLayout/FTLayoutGlue.cpp create mode 100644 src/ftgl/FTLayout/FTLayoutImpl.h create mode 100644 src/ftgl/FTLayout/FTSimpleLayout.cpp create mode 100644 src/ftgl/FTLayout/FTSimpleLayoutImpl.h (limited to 'src/ftgl/FTLayout') diff --git a/src/ftgl/FTLayout/FTLayout.cpp b/src/ftgl/FTLayout/FTLayout.cpp new file mode 100644 index 0000000..d4298bd --- /dev/null +++ b/src/ftgl/FTLayout/FTLayout.cpp @@ -0,0 +1,80 @@ +/* + * FTGL - OpenGL font library + * + * Copyright (c) 2001-2004 Henry Maddocks + * Copyright (c) 2008 Sam Hocevar + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "config.h" + +#include "FTGL/ftgl.h" + +#include "../FTFont/FTFontImpl.h" +#include "./FTLayoutImpl.h" + + +// +// FTLayout +// + + +FTLayout::FTLayout() +{ + impl = new FTLayoutImpl(); +} + + +FTLayout::FTLayout(FTLayoutImpl *pImpl) +{ + impl = pImpl; +} + + +FTLayout::~FTLayout() +{ + delete impl; +} + + +FT_Error FTLayout::Error() const +{ + return impl->err; +} + + +// +// FTLayoutImpl +// + + +FTLayoutImpl::FTLayoutImpl() : + err(0) +{ + ; +} + + +FTLayoutImpl::~FTLayoutImpl() +{ + ; +} + diff --git a/src/ftgl/FTLayout/FTLayoutGlue.cpp b/src/ftgl/FTLayout/FTLayoutGlue.cpp new file mode 100644 index 0000000..60f428d --- /dev/null +++ b/src/ftgl/FTLayout/FTLayoutGlue.cpp @@ -0,0 +1,171 @@ +/* + * FTGL - OpenGL font library + * + * Copyright (c) 2001-2004 Henry Maddocks + * Copyright (c) 2008 Éric Beets + * Copyright (c) 2008 Sam Hocevar + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "config.h" + +#include "FTInternals.h" + +static const FTBBox static_ftbbox; + +FTGL_BEGIN_C_DECLS + +#define C_TOR(cname, cargs, cxxname, cxxarg, cxxtype) \ + FTGLlayout* cname cargs \ + { \ + cxxname *l = new cxxname cxxarg; \ + if(l->Error()) \ + { \ + delete l; \ + return NULL; \ + } \ + FTGLlayout *ftgl = (FTGLlayout *)malloc(sizeof(FTGLlayout)); \ + ftgl->ptr = l; \ + ftgl->type = cxxtype; \ + return ftgl; \ + } + +// FTSimpleLayout::FTSimpleLayout(); +C_TOR(ftglCreateSimpleLayout, (), FTSimpleLayout, (), LAYOUT_SIMPLE); + +#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \ + cret cname cargs \ + { \ + if(!l || !l->ptr) \ + { \ + fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \ + cxxerr; \ + } \ + return l->ptr->cxxname cxxarg; \ + } + +// FTLayout::~FTLayout(); +void ftglDestroyLayout(FTGLlayout *l) +{ + if(!l || !l->ptr) + { + fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__); + return; + } + delete l->ptr; + free(l); +} + +// virtual FTBBox FTLayout::BBox(const char* string) +extern "C++" { +C_FUN(static FTBBox, _ftgGetlLayoutBBox, (FTGLlayout *l, const char *s), + return static_ftbbox, BBox, (s)); +} + +void ftgGetlLayoutBBox(FTGLlayout *l, const char * s, float c[6]) +{ + FTBBox ret = _ftgGetlLayoutBBox(l, s); + FTPoint lower = ret.Lower(), upper = ret.Upper(); + c[0] = lower.Xf(); c[1] = lower.Yf(); c[2] = lower.Zf(); + c[3] = upper.Xf(); c[4] = upper.Yf(); c[5] = upper.Zf(); +} + +// virtual void FTLayout::Render(const char* string, int renderMode); +C_FUN(void, ftglRenderLayout, (FTGLlayout *l, const char *s, int r), + return, Render, (s, r)); + +// FT_Error FTLayout::Error() const; +C_FUN(FT_Error, ftglGetLayoutError, (FTGLlayout *l), return -1, Error, ()); + +// void FTSimpleLayout::SetFont(FTFont *fontInit) +void ftglSetLayoutFont(FTGLlayout *l, FTGLfont *font) +{ + if(!l || !l->ptr) + { + fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__); + return; + } + if(l->type != FTGL::LAYOUT_SIMPLE) + { + fprintf(stderr, "FTGL warning: %s not implemented for %d\n", + __FUNCTION__, l->type); + } + l->font = font; + return dynamic_cast(l->ptr)->SetFont(font->ptr); +} + +// FTFont *FTSimpleLayout::GetFont() +FTGLfont *ftglGetLayoutFont(FTGLlayout *l) +{ + if(!l || !l->ptr) + { + fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__); + return NULL; + } + if(l->type != FTGL::LAYOUT_SIMPLE) + { + fprintf(stderr, "FTGL warning: %s not implemented for %d\n", + __FUNCTION__, l->type); + } + return l->font; +} + +#undef C_FUN + +#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \ + cret cname cargs \ + { \ + if(!l || !l->ptr) \ + { \ + fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \ + cxxerr; \ + } \ + if(l->type != FTGL::LAYOUT_SIMPLE) \ + { \ + fprintf(stderr, "FTGL warning: %s not implemented for %d\n", \ + __FUNCTION__, l->type); \ + cxxerr; \ + } \ + return dynamic_cast(l->ptr)->cxxname cxxarg; \ + } + +// void FTSimpleLayout::SetLineLength(const float LineLength); +C_FUN(void, ftglSetLayoutLineLength, (FTGLlayout *l, const float length), + return, SetLineLength, (length)); + +// float FTSimpleLayout::GetLineLength() const +C_FUN(float, ftglGetLayoutLineLength, (FTGLlayout *l), + return 0.0f, GetLineLength, ()); + +// void FTSimpleLayout::SetAlignment(const TextAlignment Alignment) +C_FUN(void, ftglSetLayoutAlignment, (FTGLlayout *l, const int a), + return, SetAlignment, ((FTGL::TextAlignment)a)); + +// TextAlignment FTSimpleLayout::GetAlignment() const +C_FUN(int, ftglGetLayoutAlignement, (FTGLlayout *l), + return FTGL::ALIGN_LEFT, GetAlignment, ()); + +// void FTSimpleLayout::SetLineSpacing(const float LineSpacing) +C_FUN(void, ftglSetLayoutLineSpacing, (FTGLlayout *l, const float f), + return, SetLineSpacing, (f)); + +FTGL_END_C_DECLS + diff --git a/src/ftgl/FTLayout/FTLayoutImpl.h b/src/ftgl/FTLayout/FTLayoutImpl.h new file mode 100644 index 0000000..85df50d --- /dev/null +++ b/src/ftgl/FTLayout/FTLayoutImpl.h @@ -0,0 +1,56 @@ +/* + * FTGL - OpenGL font library + * + * Copyright (c) 2001-2004 Henry Maddocks + * Copyright (c) 2008 Sam Hocevar + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef __FTLayoutImpl__ +#define __FTLayoutImpl__ + +#include "FTSize.h" +#include "FTGlyphContainer.h" + + +class FTLayoutImpl +{ + friend class FTLayout; + + protected: + FTLayoutImpl(); + + virtual ~FTLayoutImpl(); + + protected: + /** + * Current pen or cursor position; + */ + FTPoint pen; + + /** + * Current error code. Zero means no error. + */ + FT_Error err; +}; + +#endif // __FTLayoutImpl__ + diff --git a/src/ftgl/FTLayout/FTSimpleLayout.cpp b/src/ftgl/FTLayout/FTSimpleLayout.cpp new file mode 100644 index 0000000..b5a7beb --- /dev/null +++ b/src/ftgl/FTLayout/FTSimpleLayout.cpp @@ -0,0 +1,460 @@ +/* + * FTGL - OpenGL font library + * + * Copyright (c) 2001-2004 Henry Maddocks + * Copyright (c) 2008 Sam Hocevar + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "config.h" + +#include +#include + +#include "FTInternals.h" +#include "FTUnicode.h" + +#include "FTGlyphContainer.h" +#include "FTSimpleLayoutImpl.h" + + +// +// FTSimpleLayout +// + + +FTSimpleLayout::FTSimpleLayout() : + FTLayout(new FTSimpleLayoutImpl()) +{} + + +FTSimpleLayout::~FTSimpleLayout() +{} + + +FTBBox FTSimpleLayout::BBox(const char *string, const int len, FTPoint pos) +{ + return dynamic_cast(impl)->BBox(string, len, pos); +} + + +FTBBox FTSimpleLayout::BBox(const wchar_t *string, const int len, FTPoint pos) +{ + return dynamic_cast(impl)->BBox(string, len, pos); +} + + +void FTSimpleLayout::Render(const char *string, const int len, FTPoint pos, + int renderMode) +{ + return dynamic_cast(impl)->Render(string, len, pos, + renderMode); +} + + +void FTSimpleLayout::Render(const wchar_t* string, const int len, FTPoint pos, + int renderMode) +{ + return dynamic_cast(impl)->Render(string, len, pos, + renderMode); +} + + +void FTSimpleLayout::SetFont(FTFont *fontInit) +{ + dynamic_cast(impl)->currentFont = fontInit; +} + + +FTFont *FTSimpleLayout::GetFont() +{ + return dynamic_cast(impl)->currentFont; +} + + +void FTSimpleLayout::SetLineLength(const float LineLength) +{ + dynamic_cast(impl)->lineLength = LineLength; +} + + +float FTSimpleLayout::GetLineLength() const +{ + return dynamic_cast(impl)->lineLength; +} + + +void FTSimpleLayout::SetAlignment(const FTGL::TextAlignment Alignment) +{ + dynamic_cast(impl)->alignment = Alignment; +} + + +FTGL::TextAlignment FTSimpleLayout::GetAlignment() const +{ + return dynamic_cast(impl)->alignment; +} + + +void FTSimpleLayout::SetLineSpacing(const float LineSpacing) +{ + dynamic_cast(impl)->lineSpacing = LineSpacing; +} + + +float FTSimpleLayout::GetLineSpacing() const +{ + return dynamic_cast(impl)->lineSpacing; +} + + +// +// FTSimpleLayoutImpl +// + + +FTSimpleLayoutImpl::FTSimpleLayoutImpl() +{ + currentFont = NULL; + lineLength = 100.0f; + alignment = FTGL::ALIGN_LEFT; + lineSpacing = 1.0f; +} + + +template +inline FTBBox FTSimpleLayoutImpl::BBoxI(const T* string, const int len, + FTPoint position) +{ + FTBBox tmp; + + WrapText(string, len, position, 0, &tmp); + + return tmp; +} + + +FTBBox FTSimpleLayoutImpl::BBox(const char *string, const int len, + FTPoint position) +{ + return BBoxI(string, len, position); +} + + +FTBBox FTSimpleLayoutImpl::BBox(const wchar_t *string, const int len, + FTPoint position) +{ + return BBoxI(string, len, position); +} + + +template +inline void FTSimpleLayoutImpl::RenderI(const T *string, const int len, + FTPoint position, int renderMode) +{ + pen = FTPoint(0.0f, 0.0f); + WrapText(string, len, position, renderMode, NULL); +} + + +void FTSimpleLayoutImpl::Render(const char *string, const int len, + FTPoint position, int renderMode) +{ + RenderI(string, len, position, renderMode); +} + + +void FTSimpleLayoutImpl::Render(const wchar_t* string, const int len, + FTPoint position, int renderMode) +{ + RenderI(string, len, position, renderMode); +} + + +template +inline void FTSimpleLayoutImpl::WrapTextI(const T *buf, const int len, + FTPoint position, int renderMode, + FTBBox *bounds) +{ + FTUnicodeStringItr breakItr(buf); // points to the last break character + FTUnicodeStringItr lineStart(buf); // points to the line start + float nextStart = 0.0; // total width of the current line + float breakWidth = 0.0; // width of the line up to the last word break + float currentWidth = 0.0; // width of all characters on the current line + float prevWidth; // width of all characters but the current glyph + float wordLength = 0.0; // length of the block since the last break char + int charCount = 0; // number of characters so far on the line + int breakCharCount = 0; // number of characters before the breakItr + float glyphWidth, advance; + FTBBox glyphBounds; + + // Reset the pen position + pen.Y(0); + + // If we have bounds mark them invalid + if(bounds) + { + bounds->Invalidate(); + } + + // Scan the input for all characters that need output + FTUnicodeStringItr prevItr(buf); + for (FTUnicodeStringItr itr(buf); *itr; prevItr = itr++, charCount++) + { + // Find the width of the current glyph + glyphBounds = currentFont->BBox(itr.getBufferFromHere(), 1); + glyphWidth = glyphBounds.Upper().Xf() - glyphBounds.Lower().Xf(); + + advance = currentFont->Advance(itr.getBufferFromHere(), 1); + prevWidth = currentWidth; + // Compute the width of all glyphs up to the end of buf[i] + currentWidth = nextStart + glyphWidth; + // Compute the position of the next glyph + nextStart += advance; + + // See if the current character is a space, a break or a regular character + if((currentWidth > lineLength) || (*itr == '\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 we have not yet found a break, break on the last character + if(breakItr == lineStart || (*itr == '\n')) + { + // Break on the previous character + breakItr = prevItr; + breakCharCount = charCount - 1; + breakWidth = prevWidth; + // None of the previous words will be carried to the next line + wordLength = 0; + // If the current character is a newline discard its advance + if(*itr == '\n') advance = 0; + } + + float remainingWidth = lineLength - breakWidth; + + // Render the current substring + FTUnicodeStringItr breakChar = breakItr; + // move past the break character and don't count it on the next line either + ++breakChar; --charCount; + // If the break character is a newline do not render it + if(*breakChar == '\n') + { + ++breakChar; --charCount; + } + + OutputWrapped(lineStart.getBufferFromHere(), breakCharCount, + //breakItr.getBufferFromHere() - lineStart.getBufferFromHere(), + position, renderMode, remainingWidth, bounds); + + // Store the start of the next line + lineStart = breakChar; + // TODO: Is Height() the right value here? + pen -= FTPoint(0, currentFont->LineHeight() * 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 + breakItr = lineStart; + charCount -= breakCharCount; + } + else if(iswspace(*itr)) + { + // This is the last word break position + wordLength = 0; + breakItr = itr; + breakCharCount = charCount; + + // Check to see if this is the first whitespace character in a run + if(buf == itr.getBufferFromHere() || !iswspace(*prevItr)) + { + // Record the width of the start of the block + breakWidth = currentWidth; + } + } + else + { + wordLength += advance; + } + } + + float remainingWidth = lineLength - currentWidth; + // Render any remaining text on the last line + // Disable justification for the last row + if(alignment == FTGL::ALIGN_JUSTIFY) + { + alignment = FTGL::ALIGN_LEFT; + OutputWrapped(lineStart.getBufferFromHere(), -1, position, renderMode, + remainingWidth, bounds); + alignment = FTGL::ALIGN_JUSTIFY; + } + else + { + OutputWrapped(lineStart.getBufferFromHere(), -1, position, renderMode, + remainingWidth, bounds); + } +} + + +void FTSimpleLayoutImpl::WrapText(const char *buf, const int len, + FTPoint position, int renderMode, + FTBBox *bounds) +{ + WrapTextI(buf, len, position, renderMode, bounds); +} + + +void FTSimpleLayoutImpl::WrapText(const wchar_t* buf, const int len, + FTPoint position, int renderMode, + FTBBox *bounds) +{ + WrapTextI(buf, len, position, renderMode, bounds); +} + + +template +inline void FTSimpleLayoutImpl::OutputWrappedI(const T *buf, const int len, + FTPoint position, int renderMode, + const float remaining, + FTBBox *bounds) +{ + float distributeWidth = 0.0; + // Align the text according as specified by Alignment + switch (alignment) + { + case FTGL::ALIGN_LEFT: + pen.X(0); + break; + case FTGL::ALIGN_CENTER: + pen.X(remaining / 2); + break; + case FTGL::ALIGN_RIGHT: + pen.X(remaining); + break; + case FTGL::ALIGN_JUSTIFY: + pen.X(0); + distributeWidth = remaining; + break; + } + + // If we have bounds expand them by the line's bounds, otherwise render + // the line. + if(bounds) + { + FTBBox temp = currentFont->BBox(buf, len); + + // Add the extra space to the upper x dimension + temp = FTBBox(temp.Lower() + pen, + temp.Upper() + pen + FTPoint(distributeWidth, 0)); + + // See if this is the first area to be added to the bounds + if(bounds->IsValid()) + { + *bounds |= temp; + } + else + { + *bounds = temp; + } + } + else + { + RenderSpace(buf, len, position, renderMode, distributeWidth); + } +} + + +void FTSimpleLayoutImpl::OutputWrapped(const char *buf, const int len, + FTPoint position, int renderMode, + const float remaining, FTBBox *bounds) +{ + OutputWrappedI(buf, len, position, renderMode, remaining, bounds); +} + + +void FTSimpleLayoutImpl::OutputWrapped(const wchar_t *buf, const int len, + FTPoint position, int renderMode, + const float remaining, FTBBox *bounds) +{ + OutputWrappedI(buf, len, position, renderMode, remaining, bounds); +} + + +template +inline void FTSimpleLayoutImpl::RenderSpaceI(const T *string, const int len, + FTPoint position, int renderMode, + const float extraSpace) +{ + float space = 0.0; + + // If there is space to distribute, count the number of spaces + if(extraSpace > 0.0) + { + int numSpaces = 0; + + // Count the number of space blocks in the input + FTUnicodeStringItr prevItr(string), itr(string); + for(int i = 0; ((len < 0) && *itr) || ((len >= 0) && (i <= len)); + ++i, prevItr = itr++) + { + // If this is the end of a space block, increment the counter + if((i > 0) && !iswspace(*itr) && iswspace(*prevItr)) + { + numSpaces++; + } + } + + space = extraSpace/numSpaces; + } + + // Output all characters of the string + FTUnicodeStringItr prevItr(string), itr(string); + for(int i = 0; ((len < 0) && *itr) || ((len >= 0) && (i <= len)); + ++i, prevItr = itr++) + { + // If this is the end of a space block, distribute the extra space + // inside it + if((i > 0) && !iswspace(*itr) && iswspace(*prevItr)) + { + pen += FTPoint(space, 0); + } + + pen = currentFont->Render(itr.getBufferFromHere(), 1, pen, FTPoint(), renderMode); + } +} + + +void FTSimpleLayoutImpl::RenderSpace(const char *string, const int len, + FTPoint position, int renderMode, + const float extraSpace) +{ + RenderSpaceI(string, len, position, renderMode, extraSpace); +} + + +void FTSimpleLayoutImpl::RenderSpace(const wchar_t *string, const int len, + FTPoint position, int renderMode, + const float extraSpace) +{ + RenderSpaceI(string, len, position, renderMode, extraSpace); +} + diff --git a/src/ftgl/FTLayout/FTSimpleLayoutImpl.h b/src/ftgl/FTLayout/FTSimpleLayoutImpl.h new file mode 100644 index 0000000..96a074d --- /dev/null +++ b/src/ftgl/FTLayout/FTSimpleLayoutImpl.h @@ -0,0 +1,225 @@ +/* + * FTGL - OpenGL font library + * + * Copyright (c) 2001-2004 Henry Maddocks + * Copyright (c) 2008 Sam Hocevar + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef __FTSimpleLayoutImpl__ +#define __FTSimpleLayoutImpl__ + +#include "FTLayoutImpl.h" + + +class FTFont; + +class FTSimpleLayoutImpl : public FTLayoutImpl +{ + friend class FTSimpleLayout; + + protected: + FTSimpleLayoutImpl(); + + virtual ~FTSimpleLayoutImpl() {}; + + virtual FTBBox BBox(const char* string, const int len, + FTPoint position); + + virtual FTBBox BBox(const wchar_t* string, const int len, + FTPoint position); + + virtual void Render(const char *string, const int len, + FTPoint position, int renderMode); + + virtual void Render(const wchar_t *string, const int len, + FTPoint position, int renderMode); + + /** + * Render a string of characters and distribute extra space amongst + * the whitespace regions of the string. + * + * @param string A buffer of wchar_t characters to output. + * @param len The length of the string. If < 0 then all characters + * will be displayed until a null character is encountered. + * @param position TODO + * @param renderMode Render mode to display + * @param extraSpace The amount of extra space to distribute amongst + * the characters. + */ + virtual void RenderSpace(const char *string, const int len, + FTPoint position, int renderMode, + const float extraSpace); + + /** + * Render a string of characters and distribute extra space amongst + * the whitespace regions of the string. + * + * @param string A buffer of wchar_t characters to output. + * @param len The length of the string. If < 0 then all characters + * will be displayed until a null character is encountered. + * @param position TODO + * @param renderMode Render mode to display + * @param extraSpace The amount of extra space to distribute amongst + * the characters. + */ + virtual void RenderSpace(const wchar_t *string, const int len, + FTPoint position, int renderMode, + const float extraSpace); + + 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 buf A char string to output. + * @param len The length of the string. If < 0 then all characters + * will be displayed until a null character is encountered. + * @param position TODO + * @param renderMode Render mode to display + * @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 *buf, const int len, + FTPoint position, int renderMode, + FTBBox *bounds); + + /** + * 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 buf A wchar_t style string to output. + * @param len The length of the string. If < 0 then all characters + * will be displayed until a null character is encountered. + * @param position TODO + * @param renderMode Render mode to display + * @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 *buf, const int len, + FTPoint position, int renderMode, + FTBBox *bounds); + + /** + * A helper method used by WrapText to either output the text or + * compute it's bounds. + * + * @param buf A pointer to an array of character data. + * @param len The length of the string. If < 0 then all characters + * will be displayed until a null character is encountered. + * @param position TODO + * @param renderMode Render mode to display + * @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 *buf, const int len, + FTPoint position, int renderMode, + const float RemainingWidth, FTBBox *bounds); + + /** + * A helper method used by WrapText to either output the text or + * compute it's bounds. + * + * @param buf A pointer to an array of character data. + * @param len The length of the string. If < 0 then all characters + * will be displayed until a null character is encountered. + * @param position TODO + * @param renderMode Render mode to display + * @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 *buf, const int len, + FTPoint position, int renderMode, + 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. + */ + FTGL::TextAlignment alignment; + + /** + * The height of each line of text expressed as + * a percentage of the font's line height. + */ + float lineSpacing; + + /* Internal generic BBox() implementation */ + template + inline FTBBox BBoxI(const T* string, const int len, FTPoint position); + + /* Internal generic Render() implementation */ + template + inline void RenderI(const T* string, const int len, + FTPoint position, int renderMode); + + /* Internal generic RenderSpace() implementation */ + template + inline void RenderSpaceI(const T* string, const int len, + FTPoint position, int renderMode, + const float extraSpace); + + /* Internal generic WrapText() implementation */ + template + void WrapTextI(const T* buf, const int len, FTPoint position, + int renderMode, FTBBox *bounds); + + /* Internal generic OutputWrapped() implementation */ + template + void OutputWrappedI(const T* buf, const int len, FTPoint position, + int renderMode, const float RemainingWidth, + FTBBox *bounds); +}; + +#endif // __FTSimpleLayoutImpl__ + -- cgit v1.2.3