gosu 1.3.0 → 1.4.0

data/src/TrueTypeFont.cpp

@@ -1,89 +1,78 @@
 #include "TrueTypeFont.hpp"
 #include <Gosu/IO.hpp>
 #include <Gosu/Text.hpp>
+#include <Gosu/Utility.hpp>
+#include <algorithm>
+#include <map>
 #include <stdexcept>
 
-// Disable comma warnings in stb headers.
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcomma"
-#endif
-
 #define STB_TRUETYPE_IMPLEMENTATION
 #include <stb_truetype.h>
 
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
+struct Gosu::TrueTypeFont::Impl : Gosu::Noncopyable
+{
+    stbtt_fontinfo info{};
+    std::shared_ptr<TrueTypeFont> fallback;
 
-#include <algorithm>
-#include <map>
-using namespace std;
+    // The height of the ascent in internal font metrics (an arbitrary integer scale). The ascent is
+    // the part of the font above the baseline (which TrueType considers to be at y = 0).
+    int ascent{};
 
-struct Gosu::TrueTypeFont::Impl
-{
-    stbtt_fontinfo info;
-    shared_ptr<TrueTypeFont> fallback;
-    
-    // The ascent in internal font metrics (an arbitrary integer scale), that is, the part of the
-    // font above the baseline, which TrueType considers to be at y = 0.
-    int ascent;
-    
     // Scaling factor from internal font metrics (an arbitrary integer scale) to a font with
     // height = 1px.
     double base_scale;
-    
-    Impl(const unsigned char* ttf_data, shared_ptr<TrueTypeFont> fallback)
-    : fallback(move(fallback))
+
+    Impl(const unsigned char* ttf_data, std::shared_ptr<TrueTypeFont> fallback)
+    : fallback{move(fallback)}
     {
         auto offset = stbtt_GetFontOffsetForIndex(ttf_data, 0);
         int success = stbtt_InitFont(&info, ttf_data, offset);
-        if (!success) throw runtime_error("Invalid TrueType font data");
-        
+        if (!success) throw std::runtime_error{"Invalid TrueType font data"};
+
         // Calculate metrics.
-        int descent, lineGap;
-        stbtt_GetFontVMetrics(&info, &ascent, &descent, &lineGap);
-        int height = ascent - descent + lineGap;
-        base_scale = 1.0f / height;
+        int descent, line_gap;
+        stbtt_GetFontVMetrics(&info, &ascent, &descent, &line_gap);
+        int height = ascent - descent + line_gap;
+        base_scale = 1.0 / height;
     }
-    
+
     // This method always measures text, and also draws it if (bitmap != nullptr).
-    double draw_text(const u32string& text, bool is_end, double height,
-                     Bitmap* bitmap, double x, double y, Color c)
+    double draw_text(const std::u32string& text, bool is_end, double height, Bitmap* bitmap,
+                     double x, double y, Color c)
     {
         if (text.empty()) return 0;
 
         // The 'x' parameter is used as the running cursor variable in this method.
-        
+
         double scale = base_scale * height;
         int last_glyph = 0;
         int last_advance = 0;
 
-        for (u32string::size_type index = 0; index < text.size(); ++index) {
+        for (std::size_t index = 0; index < text.size(); ++index) {
             auto codepoint = text[index];
             // Silently skip control characters, including the \r in Windows-style line breaks.
             if (codepoint < ' ') continue;
-            
-            int glyph = stbtt_FindGlyphIndex(&info, codepoint);
+
+            int glyph = stbtt_FindGlyphIndex(&info, static_cast<int>(codepoint));
             // Handle missing characters in this font...
             if (glyph == 0) {
                 if (fallback) {
                     // Missing characters often come in clusters, so build a substring of
                     // codepoints that this font doesn't contain and then defer to the fallback
                     // font.
-                    u32string fallback_string = string_of_missing_glyphs(text, index);
+                    std::u32string fallback_string = string_of_missing_glyphs(text, index);
                     index += fallback_string.length();
-                    x = fallback->pimpl->draw_text(fallback_string, index == text.size(), height,
-                                                   bitmap, x, y, c);
+                    x = fallback->m_impl->draw_text(fallback_string, index == text.size(), height,
+                                                    bitmap, x, y, c);
                     last_glyph = 0;
                 }
                 continue;
             }
-            
+
             if (last_glyph) {
                 x += stbtt_GetGlyphKernAdvance(&info, last_glyph, glyph) * scale;
             }
-            
+
             // Now finally draw the glyph (if a bitmap was passed).
             if (bitmap) {
                 // Do not take lsb into account when positioning the glyph: It seems to correspond
@@ -92,93 +81,103 @@ struct Gosu::TrueTypeFont::Impl
                 // Ref: https://github.com/nothings/stb/issues/281#issuecomment-361264014
                 draw_glyph(*bitmap, x, y, c, glyph, scale);
             }
-            
+
             int advance;
             stbtt_GetGlyphHMetrics(&info, glyph, &advance, nullptr);
-            
+
             x += advance * scale;
             last_glyph = glyph;
             last_advance = advance;
         }
-        
+
         // If this is the end of the string, we need to take another look at the last glyph to avoid
         // cutting off some pixels that extend to the right of the character.
         if (is_end && last_glyph) {
             int ix = static_cast<int>(x);
+            float shift_x = static_cast<float>(x - ix);
+            float fscale = static_cast<float>(scale);
             int last_xoff, last_width;
             // TODO: Don't allocate a buffer just to get metrics!
-            free(stbtt_GetGlyphBitmapSubpixel(&info, scale, scale, x - ix, 0, last_glyph,
-                                              &last_width, nullptr, &last_xoff, nullptr));
+            std::shared_ptr<unsigned char> unused_data{
+                    stbtt_GetGlyphBitmapSubpixel(&info, fscale, fscale, shift_x, 0, last_glyph,
+                                                 &last_width, nullptr, &last_xoff, nullptr),
+                    std::free};
             // Move the cursor to the right if pixels have been touched by draw_glyph that are
             // to the right of the current cursor.
             // If the last character extends to the right of the cursor, then this prevents the
             // rightmost pixels from being truncated.
             // If the last character was whitespace, then last_width will be 0 (no pixel data)
             // and the cursor is what counts.
-            x = max<double>(x, x - last_advance * scale + last_xoff + last_width);
+            x = std::max<double>(x, x - last_advance * scale + last_xoff + last_width);
         }
-        
+
         // Never return a negative value from this method because it is used to determine bitmap
         // dimensions.
-        return max<double>(0, x);
+        return std::max<double>(0, x);
     }
-    
-    u32string string_of_missing_glyphs(const u32string& text, u32string::size_type from_index)
+
+    std::u32string string_of_missing_glyphs(const std::u32string& text, std::size_t from_index)
     {
-        u32string result;
-        
-        for (u32string::size_type index = from_index; index < text.size(); ++index) {
+        std::u32string result;
+
+        for (std::size_t index = from_index; index < text.size(); ++index) {
             auto codepoint = text[index];
             // Stop as soon as a glyph (except control characters) is available in the current font.
-            if (codepoint >= ' ' && stbtt_FindGlyphIndex(&info, codepoint) != 0) break;
-            
+            if (codepoint >= ' ' && stbtt_FindGlyphIndex(&info, static_cast<int>(codepoint)) != 0) {
+                break;
+            }
+
             result.push_back(codepoint);
         }
-        
+
         return result;
     }
-    
+
     void draw_glyph(Bitmap& bitmap, double fx, double fy, Color c, int glyph, double scale)
     {
         int x = static_cast<int>(fx);
         int y = static_cast<int>(fy);
+        float fscale = static_cast<float>(scale);
+        float shift_x = static_cast<float>(fx - x);
+        float shift_y = static_cast<float>(fy - y);
+
         int w, h, xoff, yoff;
-        
         // As an optimization, this method/class could try to re-use a buffer for rasterization
         // instead of having stb_truetype allocate a fresh one for each draw_glyph call.
-        unsigned char* pixels = stbtt_GetGlyphBitmapSubpixel(&info, scale, scale, fx - x, fy - y,
-                                                             glyph, &w, &h, &xoff, &yoff);
-        
-        blend_into_bitmap(bitmap, pixels, x + xoff, y + ascent * scale + yoff, w, h, c);
-        
-        free(pixels);
+        std::shared_ptr<unsigned char> pixels{stbtt_GetGlyphBitmapSubpixel(&info, fscale, fscale,
+                                                                           shift_x, shift_y, glyph,
+                                                                           &w, &h, &xoff, &yoff),
+                                              std::free};
+
+        int target_y = static_cast<int>(y + ascent * scale + yoff);
+        blend_into_bitmap(bitmap, pixels.get(), x + xoff, target_y, w, h, c);
     }
-    
-    void blend_into_bitmap(Bitmap& bitmap, const unsigned char* pixels, int x, int y, int w, int h,
-                           Color c)
+
+    static void blend_into_bitmap(Bitmap& bitmap, const unsigned char* pixels, //
+                                  int x, int y, int w, int h, Color c)
     {
         int stride = w;
-        
+
         // Instead of transferring all pixels in the range [0; w) x [0; h) into the bitmap, clip
         // these values because Bitmap::blend_pixel does not perform bounds checking.
-        
+
         int src_x = 0;
         if (x < 0) {
             src_x -= x;
             w += x;
             x = 0;
         }
-        
+
         int src_y = 0;
         if (y < 0) {
             src_y -= y;
             h += y;
             y = 0;
         }
-        
-        w = min<int>(w, bitmap.width() - x);
-        h = min<int>(h, bitmap.height() - y);
-        
+
+        w = std::min<int>(w, bitmap.width() - x);
+        h = std::min<int>(h, bitmap.height() - y);
+
         for (int rel_y = 0; rel_y < h; ++rel_y) {
             for (int rel_x = 0; rel_x < w; ++rel_x) {
                 int pixel = pixels[(src_y + rel_y) * stride + src_x + rel_x];
@@ -189,65 +188,67 @@ struct Gosu::TrueTypeFont::Impl
     }
 };
 
-Gosu::TrueTypeFont::TrueTypeFont(const unsigned char* ttf_data, shared_ptr<TrueTypeFont> fallback)
-: pimpl(new Impl(ttf_data, fallback))
+Gosu::TrueTypeFont::TrueTypeFont(const unsigned char* ttf_data,
+                                 std::shared_ptr<TrueTypeFont> fallback)
+: m_impl{new Impl(ttf_data, std::move(fallback))}
 {
 }
 
-double Gosu::TrueTypeFont::draw_text(const u32string &text, double height,
-                                     Bitmap *bitmap, double x, double y, Color c)
+double Gosu::TrueTypeFont::draw_text(const std::u32string& text, double height, Bitmap* bitmap,
+                                     double x, double y, Color c)
 {
-    return pimpl->draw_text(text, true, height, bitmap, x, y, c);
+    return m_impl->draw_text(text, true, height, bitmap, x, y, c);
 }
 
-bool Gosu::TrueTypeFont::matches(const unsigned char* ttf_data,
-                                 const string& font_name, unsigned font_flags)
+bool Gosu::TrueTypeFont::matches(const unsigned char* ttf_data, const std::string& font_name,
+                                 unsigned font_flags)
 {
     // Gosu::FontFlags uses the same values as the STBTT_ macros, except for this one.
-    int flags = (font_flags == 0 ? STBTT_MACSTYLE_NONE : font_flags);
+    int flags = (font_flags == 0 ? STBTT_MACSTYLE_NONE : static_cast<int>(font_flags));
 
     return stbtt_FindMatchingFont(ttf_data, font_name.c_str(), flags) >= 0 ||
            stbtt_FindMatchingFont(ttf_data, font_name.c_str(), STBTT_MACSTYLE_DONTCARE) >= 0;
 }
 
-static Gosu::TrueTypeFont& font_with_stack(vector<const unsigned char*> ttf_stack)
+static Gosu::TrueTypeFont& font_with_stack(std::vector<const unsigned char*> ttf_stack)
 {
     // TODO: Make this cache thread-safe.
-    static map<const unsigned char*, shared_ptr<Gosu::TrueTypeFont>> cache_by_data;
-    
+    static std::map<const unsigned char*, std::shared_ptr<Gosu::TrueTypeFont>> cache_by_data;
+
     // Filter out any fonts that could not be found, as well as duplicates.
     auto end = unique(ttf_stack.begin(), ttf_stack.end());
     end = remove(ttf_stack.begin(), end, nullptr);
     ttf_stack.erase(end, ttf_stack.end());
-    
+
     // This cannot happen because ttf_stack contains ttf_fallback_data(), which never returns null.
-    if (ttf_stack.empty()) throw logic_error("Empty font stack");
-    
-    shared_ptr<Gosu::TrueTypeFont> head_of_stack = nullptr;
+    if (ttf_stack.empty()) throw std::logic_error{"Empty font stack"};
+
+    std::shared_ptr<Gosu::TrueTypeFont> head_of_stack = nullptr;
     for (const unsigned char* ttf_data : ttf_stack) {
         auto& font_ptr = cache_by_data[ttf_data];
         if (!font_ptr) {
-            font_ptr = make_shared<Gosu::TrueTypeFont>(ttf_data, head_of_stack);
+            font_ptr = std::make_shared<Gosu::TrueTypeFont>(ttf_data, head_of_stack);
         }
         head_of_stack = font_ptr;
     }
     return *head_of_stack;
 }
 
-Gosu::TrueTypeFont& Gosu::font_by_name(const string& font_name, unsigned font_flags)
+Gosu::TrueTypeFont& Gosu::font_by_name(const std::string& font_name, unsigned font_flags)
 {
     // TODO: Make this cache thread-safe.
-    static map<pair<string, unsigned>, TrueTypeFont*> cache_by_name_and_flags;
-    
+    static std::map<std::pair<std::string, unsigned>, TrueTypeFont*> cache_by_name_and_flags;
+
     auto& font_ptr = cache_by_name_and_flags[make_pair(font_name, font_flags)];
     if (!font_ptr) {
-        // Build a stack from worst-case fallback to the desired font.
-        vector<const unsigned char*> ttf_stack;
+        // Build a stack of TTF data in order of preference, where the fallback font is at the
+        // front, and the desired font with all the right font flags (most preferable) at the back.
+        std::vector<const unsigned char*> ttf_stack;
         ttf_stack.push_back(ttf_fallback_data());
         ttf_stack.push_back(ttf_data_by_name(default_font_name(), 0));
         if (font_flags != 0) ttf_stack.push_back(ttf_data_by_name(default_font_name(), font_flags));
-        
-        if (font_name.find_first_of("./\\") != string::npos) {
+
+        if (font_name.find_first_of("./\\") != std::string::npos) {
             // A filename? Load it and add it to the stack.
             ttf_stack.push_back(ttf_data_from_file(font_name));
         }
@@ -256,25 +257,24 @@ Gosu::TrueTypeFont& Gosu::font_by_name(const string& font_name, unsigned font_fl
             ttf_stack.push_back(ttf_data_by_name(font_name, 0));
             if (font_flags != 0) ttf_stack.push_back(ttf_data_by_name(font_name, font_flags));
         }
-        
+
         font_ptr = &font_with_stack(move(ttf_stack));
     }
-    
+
     return *font_ptr;
 }
 
-const unsigned char* Gosu::ttf_data_from_file(const string& filename)
+const unsigned char* Gosu::ttf_data_from_file(const std::string& filename)
 {
     // TODO: Make this cache thread-safe.
-    static map<string, shared_ptr<Buffer>> ttf_file_cache;
-    
+    static std::map<std::string, std::shared_ptr<Buffer>> ttf_file_cache;
+
     auto& buffer_ptr = ttf_file_cache[filename];
     if (!buffer_ptr) {
-        buffer_ptr = make_shared<Buffer>();
+        buffer_ptr = std::make_shared<Buffer>();
         try {
             load_file(*buffer_ptr, filename);
-        }
-        catch (...) {
+        } catch (...) {
             // Prevent partially loaded files from getting stuck in the cache.
             buffer_ptr = nullptr;
             throw;

data/src/TrueTypeFont.hpp

@@ -12,51 +12,52 @@ namespace Gosu
     class TrueTypeFont
     {
         struct Impl;
-        std::shared_ptr<Impl> pimpl;
-        
+        std::shared_ptr<Impl> m_impl;
+
     public:
-        //! The caller must ensure that the ttf_data pointer will remain valid indefinitely.
+        /// The caller must ensure that the ttf_data pointer will outlive this object.
         TrueTypeFont(const unsigned char* ttf_data, std::shared_ptr<TrueTypeFont> fallback);
-        
-        //! Returns the right edge of a string when rendered onto a bitmap at the given position,
-        //! and with the given height.
-        //! If (bitmap != nullptr), the text is also rendered onto the bitmap.
-        double draw_text(const std::u32string& text, double height,
+
+        /// Returns the right edge of a string when rendered onto a bitmap at the given position,
+        /// and with the given height.
+        /// If (bitmap != nullptr), the text is also rendered onto the bitmap.
+        double draw_text(const std::u32string& text, double height, //
                          Bitmap* bitmap, double x, double y, Color c);
-        
-        //! Returns true if the supplied buffer seems to be a font of the given name.
-        static bool matches(const unsigned char* ttf_data,
+
+        /// Returns true if the supplied buffer seems to be a font of the given name.
+        static bool matches(const unsigned char* ttf_data, //
                             const std::string& font_name, unsigned font_flags);
     };
-    
+
     TrueTypeFont& font_by_name(const std::string& font_name, unsigned font_flags);
-    
-    //! Loads the contents of a file into memory and returns a pointer to it.
-    //! The pointer is guaranteed to be valid indefinitely.
-    //! In case of failure, this method must not return nullptr, but raise an exception.
-    //! Note that this method does not accept any font flags, and so it will always load the first
-    //! font in a TTC font collection.
-    //!
-    //! This function does not yet support Gosu::FontFlags, and consequently, custom TTF fonts do
-    //! not support markup or bold/italic text right now.
-    //!
-    //! Options for the future:
-    //! 1. Use stbtt_FindMatchingFont. This will only work for TTC font collections, and we will
-    //!    have to patch stb_truetype to look for fonts only based on `int flags`, while ignoring
-    //!    the name of fonts inside a bundle (who wants to deal with strings, anyway).
-    //! 2. Maybe Gosu should accept filename patterns like "LibreBaskerville-*.ttf" as the font
-    //!    name and then replace the * with "Regular", "Bold", "Italic" etc.?
-    //! 3. As a last resort, Gosu could implement faux bold and faux italics. I think faux
-    //!    underlines are a must anyway, since no font provides a dedicated TTF file for that.
-    //! These options are not mutually exclusive.
+
+    /// Loads the contents of a file into memory and returns a pointer to it.
+    /// The pointer is guaranteed to be valid indefinitely.
+    /// In case of failure, this method must not return nullptr, but raise an exception.
+    /// Note that this method does not accept any font flags, and so it will always load the first
+    /// font in a TTC font collection.
+    ///
+    /// This function does not yet support Gosu::FontFlags, and consequently, custom TTF fonts do
+    /// not support markup or bold/italic text right now.
+    ///
+    /// Options for the future:
+    /// 1. Use stbtt_FindMatchingFont. This will only work for TTC font collections, and we will
+    ///    have to patch stb_truetype to look for fonts only based on `int flags`, while ignoring
+    ///    the name of fonts inside a bundle (because we don't want to deal with strings).
+    /// 2. Maybe Gosu should accept filename patterns like "LibreBaskerville-*.ttf" as the font
+    ///    name and then replace the * with "Regular", "Bold", "Italic" etc.?
+    /// 3. As a last resort, Gosu could implement faux bold and faux italics. I think faux
+    ///    underlines are a must anyway, since no font provides a dedicated TTF file for that.
+    /// These options are not mutually exclusive.
     const unsigned char* ttf_data_from_file(const std::string& filename);
-    
-    //! This method loads a TODO
-    //! This method has a different implementation on each platform.
-    //! In case of failure, this method returns nullptr.
+
+    /// This method loads a system font with the given flags.
+    /// This method has a different implementation on each platform.
+    /// In case of failure, this method returns nullptr.
     const unsigned char* ttf_data_by_name(const std::string& font_name, unsigned font_flags);
-    
-    //! This method has a different implementation on each platform.
-    //! In case of failure, this method must not return nullptr, but raise an exception.
+
+    /// Returns the TTF data of a font that supports as many glyphs as possible.
+    /// This method has a different implementation on each platform.
+    /// In case of failure, this method must not return nullptr, but raise an exception.
     const unsigned char* ttf_fallback_data();
 }

data/src/TrueTypeFontApple.cpp

@@ -1,39 +1,35 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_MAC)
 
-#include "TrueTypeFont.hpp"
-#include "Log.hpp"
-
 #include <Gosu/Text.hpp>
-
-#import <CoreText/CoreText.h>
-#import <Foundation/Foundation.h>
-
+#include "Log.hpp"
+#include "TrueTypeFont.hpp"
+#include <CoreText/CoreText.h>
+#include <Foundation/Foundation.h>
 #include <map>
-using namespace std;
 
-const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned font_flags)
+const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
 {
     // TODO: Make this cache thread-safe.
-    static map<pair<string, unsigned>, const unsigned char*> ttf_file_cache;
-    
+    static std::map<std::pair<std::string, unsigned>, const unsigned char*> ttf_file_cache;
+
     auto& ttf_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
     if (ttf_ptr) return ttf_ptr;
 
     log("Trying to find a font named '%s', flags=%x", font_name.c_str(), font_flags);
 
     unsigned symbolic_traits = 0;
-    if (font_flags & Gosu::FF_BOLD)   symbolic_traits |= kCTFontTraitBold;
+    if (font_flags & Gosu::FF_BOLD) symbolic_traits |= kCTFontTraitBold;
     if (font_flags & Gosu::FF_ITALIC) symbolic_traits |= kCTFontTraitItalic;
 
-    NSDictionary *attributes = @{
+    NSDictionary* attributes = @{
         ((__bridge id) kCTFontNameAttribute): [NSString stringWithUTF8String:font_name.c_str()],
-        ((__bridge id) kCTFontTraitsAttribute): @{
-            ((__bridge id) kCTFontSymbolicTrait): @(symbolic_traits)
-        }
+        ((__bridge id) kCTFontTraitsAttribute):
+                @{((__bridge id) kCTFontSymbolicTrait): @(symbolic_traits)}
     };
     CTFontDescriptorRef descriptor =
-        CTFontDescriptorCreateWithAttributes((__bridge CFDictionaryRef) attributes);
+            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
+            CTFontDescriptorCreateWithAttributes((__bridge CFDictionaryRef) attributes);
 
     if (descriptor) {
         CTFontRef font = CTFontCreateWithFontDescriptorAndOptions(descriptor, 20, nullptr, 0);
@@ -42,11 +38,12 @@ const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned fo
                 // For some reason the initial call to CTFontCreateWithFontDescriptorAndOptions does
                 // not respect the requested font traits. Explicitly requesting the traits again
                 // seems to help. Tested on macOS 11.2.2.
-                CTFontRef correct_font = CTFontCreateCopyWithSymbolicTraits(font, 0.0, nullptr, symbolic_traits, symbolic_traits);
+                CTFontRef correct_font = CTFontCreateCopyWithSymbolicTraits(
+                        font, 0.0, nullptr, symbolic_traits, symbolic_traits);
                 CFRelease(font);
                 font = correct_font;
             }
-            NSURL *url = CFBridgingRelease(CTFontCopyAttribute(font, kCTFontURLAttribute));
+            NSURL* url = CFBridgingRelease(CTFontCopyAttribute(font, kCTFontURLAttribute));
             if (url && url.fileSystemRepresentation) {
                 log("Loading file '%s'", url.fileSystemRepresentation);
                 ttf_ptr = ttf_data_from_file(url.fileSystemRepresentation);
@@ -55,7 +52,7 @@ const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned fo
         }
         CFRelease(descriptor);
     }
-    
+
     return ttf_ptr;
 }
 
@@ -64,11 +61,11 @@ const unsigned char* Gosu::ttf_fallback_data()
     // Prefer Arial Unicode MS as a fallback because it covers a lot of Unicode.
     static const unsigned char* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
     if (arial_unicode) return arial_unicode;
-    
+
     return ttf_data_from_file("/Library/Fonts/Arial.ttf");
 }
 
-string Gosu::default_font_name()
+std::string Gosu::default_font_name()
 {
     return "Arial";
 }