gosu 0.7.20 → 0.7.21

data/GosuImpl/Graphics/Text.cpp

@@ -4,12 +4,16 @@
 #include <Gosu/Image.hpp>
 #include <Gosu/Math.hpp>
 #include <Gosu/Utility.hpp>
-#include <boost/bind.hpp>
+#include <GosuImpl/Graphics/Common.hpp>
+#include <GosuImpl/Graphics/FormattedString.hpp>
 #include <boost/algorithm/string.hpp>
-#include <boost/tokenizer.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <boost/shared_ptr.hpp>
 #include <cassert>
 #include <cmath>
 #include <algorithm>
+#include <map>
 #include <vector>
 using namespace std;
 
@@ -38,7 +42,7 @@ namespace Gosu
     
         struct WordInfo
         {
-            wstring text;
+            FormattedString text;
             unsigned width;
             unsigned spaceWidth;
         };
@@ -52,10 +56,10 @@ namespace Gosu
             unsigned usedLines, allocatedLines;
 
             wstring fontName;
-            unsigned fontHeight, fontFlags, lineSpacing;
+            unsigned fontHeight, lineSpacing;
             TextAlign align;
 
-            unsigned spaceWidth;
+            unsigned spaceWidth_;
 
             void allocNextLine()
             {
@@ -71,8 +75,7 @@ namespace Gosu
 
         public:
             TextBlockBuilder(const wstring& fontName, unsigned fontHeight,
-                unsigned fontFlags, unsigned lineSpacing, unsigned width,
-                TextAlign align)
+                unsigned lineSpacing, unsigned width, TextAlign align)
             {
                 usedLines = 0;
                 allocatedLines = 10;
@@ -81,11 +84,10 @@ namespace Gosu
 
                 this->fontName = fontName;
                 this->fontHeight = fontHeight;
-                this->fontFlags = fontFlags;
                 this->lineSpacing = lineSpacing;
                 this->align = align;
 
-                spaceWidth = textWidth(L" ");
+                spaceWidth_ = textWidth(FormattedString(L" ", 0));
             }
 
             unsigned width() const
@@ -93,9 +95,19 @@ namespace Gosu
                 return bmp.width();
             }
 
-            unsigned textWidth(const std::wstring& text) const
+            unsigned textWidth(const FormattedString& text) const
             {
-                return Gosu::textWidth(text, fontName, fontHeight, fontFlags);
+                if (text.length() == 0)
+                    return 0;
+                
+                if (text.entityAt(0))
+                    return entityBitmap(text.entityAt(0)).width();
+                
+                std::vector<FormattedString> parts = text.splitParts();
+                unsigned result = 0;
+                BOOST_FOREACH (const FormattedString& part, parts)
+                    result += Gosu::textWidth(part.unformat(), fontName, fontHeight, part.flagsAt(0));
+                return result;
             }
 
             void addLine(Words::const_iterator begin, Words::const_iterator end,
@@ -134,9 +146,26 @@ namespace Gosu
 
                 for (Words::const_iterator cur = begin; cur != end; ++cur)
                 {
-                    drawText(bmp, cur->text, trunc(pos), trunc(top),
-                        Color::WHITE, fontName, fontHeight, fontFlags);
-
+                    std::vector<FormattedString> parts = cur->text.splitParts();
+                    int x = 0;
+                    BOOST_FOREACH (const FormattedString& part, parts)
+                    {
+                        if (part.entityAt(0))
+                        {
+                            Gosu::Bitmap entity = entityBitmap(part.entityAt(0));
+                            multiplyBitmapAlpha(entity, part.colorAt(0).alpha());
+                            bmp.insert(entity, trunc(pos) + x, trunc(top));
+                            x += entity.width();
+                            continue;
+                        }
+                        
+                        std::wstring unformattedPart = part.unformat();
+                        drawText(bmp, unformattedPart, trunc(pos) + x, trunc(top),
+                            part.colorAt(0), fontName, fontHeight, part.flagsAt(0));
+                        x += Gosu::textWidth(unformattedPart, fontName, fontHeight,
+                            part.flagsAt(0));
+                    }
+                    
                     if (align == taJustify && !overrideAlign)
                         pos += cur->width + 1.0 * (width() - wordsWidth) / (words - 1);
                     else
@@ -156,6 +185,11 @@ namespace Gosu
                     usedLines * (lineSpacing + fontHeight));
                 return result;
             }
+            
+            unsigned spaceWidth() const
+            {
+                return spaceWidth_;
+            }
         };
 
         void processWords(TextBlockBuilder& builder, const Words& words)
@@ -200,47 +234,41 @@ namespace Gosu
             if (words.empty() || lineBegin != words.end())
                 builder.addLine(lineBegin, words.end(), wordsWidth, true);
         }
-
-        typedef boost::tokenizer<boost::char_separator<wchar_t>,
-            wstring::const_iterator, wstring> Tokenizer;
-
-        void processParagraph(TextBlockBuilder& builder,
-            const wstring& paragraph)
+        
+        void processParagraph(TextBlockBuilder& builder, const FormattedString& paragraph)
         {
             Words collectedWords;
-
-            const unsigned spaceWidth = builder.textWidth(L" ");
-
+            
             unsigned beginOfWord = 0;
             
             for (unsigned cur = 0; cur < paragraph.length(); ++cur)
             {
                 WordInfo newWord;
 
-                if (paragraph[cur] == L' ')
+                if (paragraph.charAt(cur) == L' ')
                 {
                     // Whitespace: Add last word to list if existent
                     if (beginOfWord != cur)
                     {
-                        newWord.text.assign(paragraph.begin() + beginOfWord, paragraph.begin() + cur);
+                        newWord.text = paragraph.range(beginOfWord, cur);
                         newWord.width = builder.textWidth(newWord.text);
-                        newWord.spaceWidth = spaceWidth;
+                        newWord.spaceWidth = builder.spaceWidth();
                         collectedWords.push_back(newWord);
                     }
                     beginOfWord = cur + 1;
                 }
-                else if (isBreakingAsianGlyph(paragraph[cur]))
+                else if (isBreakingAsianGlyph(paragraph.charAt(cur)))
                 {
                     // Whitespace: Add last word to list if existent
                     if (beginOfWord != cur)
                     {
-                        newWord.text.assign(paragraph.begin() + beginOfWord, paragraph.begin() + cur);
+                        newWord.text = paragraph.range(beginOfWord, cur);
                         newWord.width = builder.textWidth(newWord.text);
                         newWord.spaceWidth = 0;
                         collectedWords.push_back(newWord);
                     }
                     // Add glyph as a single "word"
-                    newWord.text = wstring(1, paragraph[cur]);
+                    newWord.text = paragraph.range(cur, cur + 2);
                     newWord.width = builder.textWidth(newWord.text);
                     newWord.spaceWidth = 0;
                     collectedWords.push_back(newWord);
@@ -250,7 +278,7 @@ namespace Gosu
             if (beginOfWord < paragraph.length())
             {
                 WordInfo lastWord;
-                lastWord.text.assign(paragraph.begin() + beginOfWord, paragraph.end());
+                lastWord.text = paragraph.range(beginOfWord, paragraph.length());
                 lastWord.width = builder.textWidth(lastWord.text);
                 lastWord.spaceWidth = 0;
                 collectedWords.push_back(lastWord);
@@ -259,14 +287,11 @@ namespace Gosu
             processWords(builder, collectedWords);
         }
 
-        void processText(TextBlockBuilder& builder, const wstring& text)
+        void processText(TextBlockBuilder& builder, const FormattedString& text)
         {
-            vector<wstring> paragraphs;
-            wstring processedText = boost::replace_all_copy(text, L"\r\n", L"\n");
-            boost::split(paragraphs, processedText,
-                boost::is_any_of(L"\r\n"));
-            for_each(paragraphs.begin(), paragraphs.end(),
-                boost::bind(processParagraph, boost::ref(builder), _1));
+            vector<FormattedString> paragraphs = text.splitLines();
+            BOOST_FOREACH (FormattedString& fs, paragraphs)
+                processParagraph(builder, fs);
         }
     }
 }
@@ -275,7 +300,8 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
     const std::wstring& fontName, unsigned fontHeight, unsigned lineSpacing,
     unsigned maxWidth, TextAlign align, unsigned fontFlags)
 {
-    if (text.empty())
+    FormattedString fs(boost::replace_all_copy(text, L"\r\n", L"\n"), fontFlags);
+    if (fs.length() == 0)
     {
         Bitmap emptyBitmap;
         emptyBitmap.resize(1, fontHeight);
@@ -284,11 +310,11 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
     
     // Set up the builder object which will manage all the drawing and
     // conversions for us.
-    TextBlockBuilder builder(fontName, fontHeight, fontFlags,
+    TextBlockBuilder builder(fontName, fontHeight,
         lineSpacing, maxWidth, align);
     
     // Let the process* functions draw everything.
-    processText(builder, text);
+    processText(builder, fs);
     
     // Done!
     return builder.result();
@@ -298,27 +324,62 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
 Gosu::Bitmap Gosu::createText(const std::wstring& text,
     const std::wstring& fontName, unsigned fontHeight, unsigned fontFlags)
 {
-    if (text.empty())
-    {
-        Bitmap emptyBitmap;
-        emptyBitmap.resize(1, fontHeight);
-        return emptyBitmap;
-    }
-
-    vector<wstring> lines;
-    wstring processedText = boost::replace_all_copy(text, L"\r\n", L"\n");
-    boost::split(lines, processedText, boost::is_any_of(L"\r\n"));
-
     Bitmap bmp;
-    bmp.resize(textWidth(lines.front(), fontName, fontHeight, fontFlags), fontHeight);
-    drawText(bmp, text, 0, 0, 0xffffffff, fontName, fontHeight, fontFlags);
+    bmp.resize(1, fontHeight);
+    
+    FormattedString fs(boost::replace_all_copy(text, L"\r\n", L"\n"), fontFlags);
+    if (fs.length() == 0)
+        return bmp;
     
-    for (int i = 1; i < lines.size(); ++i)
+    vector<FormattedString> lines = fs.splitLines();
+
+    for (int i = 0; i < lines.size(); ++i)
     {
-        bmp.resize(max(bmp.width(), textWidth(lines[i], fontName, fontHeight, fontFlags)),
-                   bmp.height() + fontHeight);
-        drawText(bmp, lines[i], 0, fontHeight * i, 0xffffffff, fontName, fontHeight, fontFlags);
+        bmp.resize(bmp.width(), (i + 1) * fontHeight);
+
+        if (lines[i].length() == 0)
+            continue;
+        
+        unsigned x = 0;
+        std::vector<FormattedString> parts = lines[i].splitParts();
+        for (int p = 0; p < parts.size(); ++p)
+        {
+            const FormattedString& part = parts[p];
+            if (part.length() == 1 && part.entityAt(0))
+            {
+                Gosu::Bitmap entity = entityBitmap(part.entityAt(0));
+                multiplyBitmapAlpha(entity, part.colorAt(0).alpha());
+                bmp.resize(std::max(bmp.width(), x + entity.width()), bmp.height());
+                bmp.insert(entity, x, i * fontHeight);
+                x += entity.width();
+                continue;
+            }
+                
+            assert(part.length() > 0);
+            std::wstring unformattedText = part.unformat();
+            unsigned partWidth =
+                textWidth(unformattedText, fontName, fontHeight, part.flagsAt(0));
+            bmp.resize(std::max(bmp.width(), x + partWidth), bmp.height());
+            drawText(bmp, unformattedText, x, i * fontHeight, part.colorAt(0),
+                fontName, fontHeight, part.flagsAt(0));
+            x += partWidth;
+        }
     }
     
     return bmp;
 }
+
+namespace
+{
+    std::map<std::wstring, boost::shared_ptr<Gosu::Bitmap> > entities;
+}
+
+void Gosu::registerEntity(const std::wstring& name, const Gosu::Bitmap& replacement)
+{
+    entities[name].reset(new Bitmap(replacement));
+}
+
+const Gosu::Bitmap& Gosu::entityBitmap(const std::wstring& name)
+{
+    return *entities[name];
+}

data/GosuImpl/Graphics/TextTouch.mm

@@ -79,25 +79,30 @@ namespace
         #endif
     }
 
-    OSXFont* getFont(wstring fontName, double height)
+    OSXFont* getFont(wstring fontName, unsigned fontFlags, double height)
     {
         fontName = normalizeFont(fontName);
     
-        static map<pair<wstring, double>, OSXFont*> usedFonts;
+        static map<pair<wstring, pair<unsigned, double> >, OSXFont*> usedFonts;
         
-        OSXFont* result = usedFonts[make_pair(fontName, height)];
+        OSXFont* result = usedFonts[make_pair(fontName, make_pair(fontFlags, height))];
         if (!result)
         {
             Gosu::ObjRef<NSString> name([[NSString alloc] initWithUTF8String: Gosu::wstringToUTF8(fontName).c_str()]);
             #ifdef GOSU_IS_IPHONE
-            result = [[OSXFont fontWithName: name.obj() size: height] retain];
+            result = [OSXFont fontWithName: name.obj() size: height];
             #else
-            NSFontDescriptor* desc = [[[NSFontDescriptor alloc] initWithFontAttributes:nil] fontDescriptorWithFamily:name.obj()];
+            NSFontDescriptor* desc = [[NSFontDescriptor fontDescriptorWithFontAttributes:nil] fontDescriptorWithFamily:name.obj()];
             result = [[NSFont fontWithDescriptor:desc size:height] retain];
+            if (result && (fontFlags & Gosu::ffBold))
+                result = [[NSFontManager sharedFontManager] convertFont:result toHaveTrait:NSFontBoldTrait];
+            if (result && (fontFlags & Gosu::ffItalic))
+                result = [[NSFontManager sharedFontManager] convertFont:result toHaveTrait:NSFontItalicTrait];
             #endif
             if (!result && fontName != Gosu::defaultFontName())
-                result = getFont(Gosu::defaultFontName(), height);
-            usedFonts[make_pair(fontName, height)] = result;
+                result = getFont(Gosu::defaultFontName(), 0, height);
+            assert(result);
+            usedFonts[make_pair(fontName, make_pair(fontFlags, height))] = [result retain];
         }
         return result;
     }
@@ -110,17 +115,46 @@ wstring Gosu::defaultFontName()
     return L"Arial";
 }
 
+#ifndef GOSU_IS_IPHONE
+namespace
+{
+    NSDictionary* attributeDictionary(NSFont* font, Gosu::Color color, unsigned fontFlags)
+    {
+        static std::map<Gosu::Color, NSColor*> colorCache;
+        
+        // Because of the way we later copy the buffer directly to a Gosu::Bitmap, we
+        // need to swap the color components already.
+        color = color.abgr();
+        
+        if (!colorCache[color])
+            colorCache[color] = [[NSColor colorWithDeviceRed:color.red()/255.0
+                green:color.green()/255.0 blue:color.blue()/255.0 alpha:color.alpha()/255.0] retain];
+        
+        NSMutableDictionary* dict =
+            [[NSMutableDictionary alloc] initWithObjectsAndKeys:
+                font, NSFontAttributeName,
+                colorCache[color], NSForegroundColorAttributeName,
+                nil];
+        if (fontFlags & Gosu::ffUnderline)
+        {
+            Gosu::ObjRef<NSNumber> underline([[NSNumber alloc] initWithInt:NSUnderlineStyleSingle]);
+            [dict setValue: underline.obj() forKey:NSUnderlineStyleAttributeName];
+        }
+        return dict;
+    }
+}
+#endif
+
 unsigned Gosu::textWidth(const wstring& text,
     const wstring& fontName, unsigned fontHeight, unsigned fontFlags)
 {
-    OSXFont* font = getFont(fontName, fontHeight);
+    OSXFont* font = getFont(fontName, fontFlags, fontHeight);
     
     // This will, of course, compute a too large size; fontHeight is in pixels,
     // the method expects point.
     ObjRef<NSString> string([[NSString alloc] initWithUTF8String: wstringToUTF8(text).c_str()]);
     #ifndef GOSU_IS_IPHONE
-    ObjRef<NSDictionary> attributes([[NSDictionary alloc] initWithObjectsAndKeys:
-        font, NSFontAttributeName, nil]);
+    ObjRef<NSDictionary> attributes(attributeDictionary(font, 0xffffffff, fontFlags));
     NSSize size = [string.obj() sizeWithAttributes: attributes.get()];
     #else
     CGSize size = [string.obj() sizeWithFont: font];
@@ -134,13 +168,12 @@ void Gosu::drawText(Bitmap& bitmap, const wstring& text, int x, int y,
     Color c, const wstring& fontName, unsigned fontHeight,
     unsigned fontFlags)
 {
-    OSXFont* font = getFont(fontName, fontHeight);
+    OSXFont* font = getFont(fontName, fontFlags, fontHeight);
     ObjRef<NSString> string([[NSString alloc] initWithUTF8String: wstringToUTF8(text).c_str()]);
 
     // This will, of course, compute a too large size; fontHeight is in pixels, the method expects point.
     #ifndef GOSU_IS_IPHONE
-    ObjRef<NSDictionary> attributes([[NSDictionary alloc] initWithObjectsAndKeys:
-        font, NSFontAttributeName, nil]);
+    ObjRef<NSDictionary> attributes(attributeDictionary(font, c, fontFlags));
     NSSize size = [string.obj() sizeWithAttributes: attributes.get()];
     #else
     CGSize size = [string.obj() sizeWithFont: font];
@@ -160,14 +193,14 @@ void Gosu::drawText(Bitmap& bitmap, const wstring& text, int x, int y,
                               colorSpace,
                               kCGImageAlphaPremultipliedLast);
     CGColorSpaceRelease(colorSpace);
-    #if defined(GOSU_IS_IPHONE)
+    #ifdef GOSU_IS_IPHONE
     CGFloat color[] = { c.green() / 255.0, c.blue() / 255.0, c.red() / 255.0, 0 };
     CGContextSetStrokeColor(context, color);
     CGContextSetFillColor(context, color);
     #endif
     
     // Use new font with proper size this time.
-    font = getFont(fontName, fontHeight * fontHeight / size.height);
+    font = getFont(fontName, fontFlags, fontHeight * fontHeight / size.height);
 
     #ifdef GOSU_IS_IPHONE
     CGContextTranslateCTM(context, 0, fontHeight);
@@ -177,8 +210,7 @@ void Gosu::drawText(Bitmap& bitmap, const wstring& text, int x, int y,
     UIGraphicsPopContext();
     #else
     NSPoint NSPointZero = { 0, 0 };
-    attributes.reset([[NSDictionary alloc] initWithObjectsAndKeys:
-        font, NSFontAttributeName, [NSColor whiteColor], NSForegroundColorAttributeName, nil]);
+    attributes.reset(attributeDictionary(font, c, fontFlags));
     
     [NSGraphicsContext saveGraphicsState];
     [NSGraphicsContext setCurrentContext:

data/GosuImpl/Graphics/TextUnix.cpp

@@ -149,8 +149,7 @@ namespace Gosu
                     if (x + x2 < 0 || x + x2 >= bitmap.width())
                         break;
                     unsigned val = ft_bitmap.buffer[y2*width+x2];
-                    Color color = c;
-                    color.setAlpha(val);
+                    Color color = multiply(c, Gosu::Color(val, 255, 255, 255));
                     bitmap.setPixel(x2 + x, y2 + y, color);
                 }
             }

data/GosuImpl/Graphics/TextWin.cpp

@@ -173,9 +173,8 @@ void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
         for (unsigned relX = 0; relX < width; ++relX)
         {
             Color pixel = c;
-            pixel.setAlpha(GetPixel(helper.context(), relX, relY) & 0xff);
-            // IMPR: Make better use of c.alpha()?
-            // Maybe even add an AlphaMode parameter?
+            Color::Channel srcAlpha = GetPixel(helper.context(), relX, relY) & 0xff;
+            pixel = multiply(c, Color(srcAlpha, 255, 255, 255));
             if (pixel != 0 && x + relX >= 0 && x + relX < bitmap.width() &&
                 y + relY >= 0 && y + relY < bitmap.height())
                 bitmap.setPixel(x + relX, y + relY, pixel);