gosu 0.12.1 → 0.13.0

data/src/FileWin.cpp

@@ -4,7 +4,8 @@
 #include "WinUtility.hpp"
 #include <Gosu/IO.hpp>
 #include <Gosu/Utility.hpp>
-#include <windows.h>
+#include <windows.h>
+using namespace std;
 
 // TODO: Error checking
 
@@ -20,7 +21,7 @@ struct Gosu::File::Impl
     }
 };
 
-Gosu::File::File(const std::string& filename, FileMode mode)
+Gosu::File::File(const string& filename, FileMode mode)
 : pimpl(new Impl)
 {
     DWORD access;
@@ -38,7 +39,7 @@ Gosu::File::File(const std::string& filename, FileMode mode)
     DWORD share_mode = FILE_SHARE_READ;
     DWORD creation_disp = (mode == FM_READ) ? OPEN_EXISTING : OPEN_ALWAYS;
 
-    std::wstring wfilename = utf8_to_wstring(filename);
+    wstring wfilename = utf8_to_wstring(filename);
     pimpl->handle = CreateFileW(wfilename.c_str(), access, share_mode, 0, creation_disp,
                                 FILE_ATTRIBUTE_NORMAL, 0);
     if (pimpl->handle == INVALID_HANDLE_VALUE) {
@@ -53,12 +54,12 @@ Gosu::File::~File()
 {
 }
 
-std::size_t Gosu::File::size() const
+size_t Gosu::File::size() const
 {
     return GetFileSize(pimpl->handle, 0);
 }
 
-void Gosu::File::resize(std::size_t new_size)
+void Gosu::File::resize(size_t new_size)
 {
     if (SetFilePointer(pimpl->handle, new_size, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
         throw_last_winapi_error("setting the file pointer");
@@ -66,7 +67,7 @@ void Gosu::File::resize(std::size_t new_size)
     winapi_check(SetEndOfFile(pimpl->handle), "resizing a file");
 }
 
-void Gosu::File::read(std::size_t offset, std::size_t length, void* dest_buffer) const
+void Gosu::File::read(size_t offset, size_t length, void* dest_buffer) const
 {
     if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
         throw_last_winapi_error("setting the file pointer");
@@ -75,7 +76,7 @@ void Gosu::File::read(std::size_t offset, std::size_t length, void* dest_buffer)
     winapi_check(ReadFile(pimpl->handle, dest_buffer, length, &dummy, 0));
 }
 
-void Gosu::File::write(std::size_t offset, std::size_t length, const void* source_buffer)
+void Gosu::File::write(size_t offset, size_t length, const void* source_buffer)
 {
     if (SetFilePointer(pimpl->handle, offset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
         throw_last_winapi_error("setting the file pointer");

data/src/Font.cpp

@@ -5,6 +5,7 @@
 #include <Gosu/Image.hpp>
 #include <Gosu/Math.hpp>
 #include <Gosu/Text.hpp>
+#include <Gosu/Utility.hpp>
 #include <array>
 #include <cassert>
 #include <map>
@@ -19,11 +20,11 @@ struct Gosu::Font::Impl
     // the first plane will ever be touched.
     struct CharInfo
     {
-        std::unique_ptr<Image> image;
+        unique_ptr<Image> image;
         double factor;
     };
     typedef array<CharInfo, 65536> Plane;
-    std::unique_ptr<Plane> planes[16][FF_COMBINATIONS];
+    unique_ptr<Plane> planes[16][FF_COMBINATIONS];
     
     map<string, shared_ptr<Image>> entity_cache;
     
@@ -57,7 +58,7 @@ struct Gosu::Font::Impl
         
         if (info.image.get()) return *info.image;
         
-        std::string char_string = wstring_to_utf8(std::wstring(1, wc));
+        string char_string = wstring_to_utf8(wstring(1, wc));
         // TODO: Would be nice to have.
         // if (is_formatting_char(wc))
         //     char_string.clear();
@@ -102,7 +103,7 @@ unsigned Gosu::Font::flags() const
 
 double Gosu::Font::text_width(const string& text, double scale_x) const
 {
-    std::wstring wtext = utf8_to_wstring(text);
+    wstring wtext = utf8_to_wstring(text);
     FormattedString fs(wtext.c_str(), flags());
     double result = 0;
     for (unsigned i = 0; i < fs.length(); ++i) {
@@ -116,15 +117,15 @@ double Gosu::Font::text_width(const string& text, double scale_x) const
 void Gosu::Font::draw(const string& text, double x, double y, ZPos z,
     double scale_x, double scale_y, Color c, AlphaMode mode) const
 {
-    std::wstring wtext = utf8_to_wstring(text);
+    wstring wtext = utf8_to_wstring(text);
     FormattedString fs(wtext.c_str(), flags());
     
     for (unsigned i = 0; i < fs.length(); ++i) {
         const Image& image = pimpl->image_at(fs, i);
         double factor = pimpl->factor_at(fs, i);
-        Gosu::Color color = fs.entity_at(i)
-                          ? Gosu::Color(fs.color_at(i).alpha() * c.alpha() / 255, 255, 255, 255)
-                          : Gosu::multiply(fs.color_at(i), c);
+        Color color = fs.entity_at(i)
+                      ? Color(fs.color_at(i).alpha() * c.alpha() / 255, 255, 255, 255)
+                      : multiply(fs.color_at(i), c);
         image.draw(x, y, z, scale_x * factor, scale_y * factor, color, mode);
         x += image.width() * scale_x * factor;
     }
@@ -149,17 +150,15 @@ void Gosu::Font::set_image(wchar_t wc, const Image& image)
 void Gosu::Font::set_image(wchar_t wc, unsigned font_flags, const Image& image)
 {
     Impl::CharInfo& ci = pimpl->char_info(wc, font_flags);
-    if (ci.image.get()) {
-        throw logic_error("Cannot set image for the same character twice");
-    }
-    ci.image.reset(new Gosu::Image(image));
+    if (ci.image.get()) throw logic_error("Cannot set image for the same character twice");
+    ci.image.reset(new Image(image));
     ci.factor = 1.0;
 }
 
 void Gosu::Font::draw_rot(const string& text, double x, double y, ZPos z, double angle,
     double scale_x, double scale_y, Color c, AlphaMode mode) const
 {
-    Gosu::Graphics::transform(rotate(angle, x, y), [&] {
+    Graphics::transform(rotate(angle, x, y), [&] {
         draw(text, x, y, z, scale_x, scale_y, c, mode);
     });
 }

data/src/FormattedString.cpp

@@ -0,0 +1,237 @@
+#include "FormattedString.hpp"
+#include <Gosu/Utility.hpp>
+#include <cwchar>
+#include <cwctype>
+using namespace std;
+
+static unsigned flags(int b, int u, int i)
+{
+    unsigned flags = 0;
+    if (b > 0) flags |= Gosu::FF_BOLD;
+    if (u > 0) flags |= Gosu::FF_UNDERLINE;
+    if (i > 0) flags |= Gosu::FF_ITALIC;
+    return flags;
+}
+
+bool Gosu::FormattedString::FormattedChar::same_style_as(const FormattedChar& other) const
+{
+    return wc && other.wc && color == other.color && flags == other.flags;
+}
+
+Gosu::FormattedString::FormattedString()
+{
+}
+
+Gosu::FormattedString::FormattedString(const wchar_t* html, unsigned base_flags)
+{
+    // Remove \r characters if existent. Avoid a copy if we don't need one.
+    wstring unixified;
+    // We have to explicitly qualify wcschr to avoid an ambiguity on macOS.
+    if (std::wcschr(html, L'\r')) {
+        unixified.resize(wcslen(html));
+        unsigned pos = 0;
+        while (*html) {
+            if (*html != '\r') {
+                unixified[pos++] = *html;
+            }
+            ++html;
+        }
+        unixified.resize(pos);
+        html = unixified.c_str();
+    }
+    
+    size_t len = wcslen(html);
+    
+    // Just skip all this if there are entities or formatting tags in the string.
+    if (wcscspn(html, L"<&") == len) {
+        simple_string = html;
+        simple_flags = base_flags;
+        return;
+    }
+    
+    unsigned pos = 0;
+    int b = (base_flags & FF_BOLD) ? 1 : 0,
+    u = (base_flags & FF_UNDERLINE) ? 1 : 0,
+    i = (base_flags & FF_ITALIC) ? 1 : 0;
+    vector<Color> c;
+    c.push_back(0xffffffff);
+    while (pos < len) {
+        if (!wcsncmp(html + pos, L"<b>", 3)) {
+            b += 1;
+            pos += 3;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"</b>", 4)) {
+            b -= 1;
+            pos += 4;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"<u>", 3)) {
+            u += 1;
+            pos += 3;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"</u>", 4)) {
+            u -= 1;
+            pos += 4;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"<i>", 3)) {
+            i += 1;
+            pos += 3;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"</i>", 4)) {
+            i -= 1;
+            pos += 4;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"<c=", 3) && len >= pos + 10 && html[pos + 9] == L'>') {
+            unsigned rgb = static_cast<uint32_t>(wcstoul(html + pos + 3, 0, 16));
+            c.push_back(0xff000000 | rgb);
+            pos += 10;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"<c=", 3) && len >= pos + 12 && html[pos + 11] == L'>') {
+            unsigned argb = static_cast<uint32_t>(wcstoul(html + pos + 3, 0, 16));
+            c.push_back(argb);
+            pos += 12;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"</c>", 4)) {
+            if (c.size() > 1) {
+                c.pop_back();
+            }
+            pos += 4;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"&lt;", 4)) {
+            FormattedChar fc = { L'<', c.back(), flags(b, u, i) };
+            characters.push_back(fc);
+            pos += 4;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"&gt;", 4)) {
+            FormattedChar fc = { L'>', c.back(), flags(b, u, i) };
+            characters.push_back(fc);
+            pos += 4;
+            continue;
+        }
+        if (!wcsncmp(html + pos, L"&amp;", 5)) {
+            FormattedChar fc = { L'&', c.back(), flags(b, u, i) };
+            characters.push_back(fc);
+            pos += 5;
+            continue;
+        }
+        if (html[pos] == L'&' && html[pos + 1]) {
+            int end_of_entity = pos + 1;
+            while (html[end_of_entity] != L';') {
+                if (!iswalnum(static_cast<wint_t>(html[end_of_entity]))) {
+                    goto normal_character;
+                }
+                end_of_entity += 1;
+                if (end_of_entity >= len) {
+                    goto normal_character;
+                }
+            }
+            wstring entity(html + pos + 1, html + end_of_entity);
+            FormattedChar fc = { 0, c.back(), 0, wstring_to_utf8(entity) };
+            if (!is_entity(fc.entity)) {
+                goto normal_character;
+            }
+            characters.push_back(fc);
+            pos = end_of_entity + 1;
+            continue;
+        }
+
+    normal_character:
+        FormattedChar fc = { html[pos], c.back(), flags(b, u, i) };
+        characters.push_back(fc);
+        pos += 1;
+    }
+}
+
+wstring Gosu::FormattedString::unformat() const
+{
+    if (characters.empty()) return simple_string;
+    
+    wstring result(characters.size(), 0);
+    for (int i = 0; i < characters.size(); ++i) {
+        result[i] = characters[i].wc;
+    }
+    return result;
+}
+
+const char* Gosu::FormattedString::entity_at(unsigned index) const
+{
+    if (characters.empty()) return nullptr;
+    if (characters[index].wc != 0) return nullptr;
+    if (characters[index].entity.empty()) return nullptr;
+    
+    return characters[index].entity.c_str();
+}
+
+wchar_t Gosu::FormattedString::char_at(unsigned index) const
+{
+    return characters.empty() ? simple_string[index] : characters[index].wc;
+}
+
+unsigned Gosu::FormattedString::flags_at(unsigned index) const
+{
+    return characters.empty() ? simple_flags : characters[index].flags;
+}
+
+Gosu::Color Gosu::FormattedString::color_at(unsigned index) const
+{
+    return characters.empty() ? Color::WHITE : characters[index].color;
+}
+
+size_t Gosu::FormattedString::length() const
+{
+    return characters.empty() ? simple_string.length() : characters.size();
+}
+
+Gosu::FormattedString Gosu::FormattedString::range(size_t begin, size_t end) const
+{
+    FormattedString result;
+    if (characters.empty()) {
+        result.simple_string.assign(simple_string.begin() + begin,
+                                    simple_string.begin() + end);
+        result.simple_flags = simple_flags;
+    }
+    else {
+        result.characters.assign(characters.begin() + begin,
+                                 characters.begin() + end);
+    }
+    return result;
+}
+
+vector<Gosu::FormattedString> Gosu::FormattedString::split_lines() const
+{
+    vector<FormattedString> result;
+    unsigned begin = 0;
+    for (unsigned cur = 0; cur < length(); ++cur) {
+        if (char_at(cur) == L'\n') {
+            result.push_back(range(begin, cur));
+            begin = cur + 1;
+        }
+    }
+    result.push_back(range(begin, length()));
+    return result;
+}
+
+vector<Gosu::FormattedString> Gosu::FormattedString::split_parts() const
+{
+    if (characters.empty()) return vector<FormattedString>(1, *this);
+    
+    vector<FormattedString> result;
+    unsigned begin = 0;
+    for (unsigned cur = 1; cur < length(); ++cur) {
+        if (!characters[begin].same_style_as(characters[cur])) {
+            result.push_back(range(begin, cur));
+            begin = cur;
+        }
+    }
+    result.push_back(range(begin, length()));
+    return result;
+}

data/src/FormattedString.hpp

@@ -3,13 +3,6 @@
 #include "GraphicsImpl.hpp"
 #include <Gosu/Color.hpp>
 #include <Gosu/GraphicsBase.hpp>
-#include <Gosu/Utility.hpp>
-#include <cassert>
-#include <cstdint>
-#include <cwchar>
-#include <cwctype>
-#include <stdexcept>
-#include <utility>
 #include <vector>
 
 namespace Gosu
@@ -19,14 +12,11 @@ namespace Gosu
         struct FormattedChar
         {
             wchar_t wc;
-            Gosu::Color color;
+            Color color;
             unsigned flags;
             std::string entity;
             
-            bool same_style_as(const FormattedChar& other) const
-            {
-                return wc && other.wc && color == other.color && flags == other.flags;
-            }
+            bool same_style_as(const FormattedChar& other) const;
         };
         
         // If characters.empty(), use these for the whole string.
@@ -35,264 +25,23 @@ namespace Gosu
         // If not characters.empty(), ignore above fields and use this.
         std::vector<FormattedChar> characters;
         
-        static unsigned flags(int b, int u, int i)
-        {
-            unsigned flags = 0;
-            if (b > 0) flags |= FF_BOLD;
-            if (u > 0) flags |= FF_UNDERLINE;
-            if (i > 0) flags |= FF_ITALIC;
-            return flags;
-        }
-        
     public:
-        FormattedString()
-        {
-        }
+        FormattedString();
+        FormattedString(const wchar_t* html, unsigned base_flags);
         
-        explicit FormattedString(const wchar_t* html, unsigned base_flags)
-        {
-            // Remove \r characters if existent. Avoid a copy if we don't need one.
-            std::wstring unixified;
-            if (std::wcschr(html, L'\r')) {
-                unixified.resize(std::wcslen(html));
-                unsigned pos = 0;
-                while (*html) {
-                    if (*html != '\r') {
-                        unixified[pos++] = *html;
-                    }
-                    ++html;
-                }
-                unixified.resize(pos);
-                html = unixified.c_str();
-            }
-            
-            std::size_t len = std::wcslen(html);
-            
-            // Just skip all this if there are entities or formatting tags in the string.
-            if (std::wcscspn(html, L"<&") == len) {
-                simple_string = html;
-                simple_flags = base_flags;
-                return;
-            }
-            
-            unsigned pos = 0;
-            int b = (base_flags & FF_BOLD) ? 1 : 0,
-                u = (base_flags & FF_UNDERLINE) ? 1 : 0,
-                i = (base_flags & FF_ITALIC) ? 1 : 0;
-            std::vector<Gosu::Color> c;
-            c.push_back(0xffffffff);
-            while (pos < len) {
-                if (!std::wcsncmp(html + pos, L"<b>", 3)) {
-                    b += 1;
-                    pos += 3;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"</b>", 4)) {
-                    b -= 1;
-                    pos += 4;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"<u>", 3)) {
-                    u += 1;
-                    pos += 3;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"</u>", 4)) {
-                    u -= 1;
-                    pos += 4;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"<i>", 3)) {
-                    i += 1;
-                    pos += 3;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"</i>", 4)) {
-                    i -= 1;
-                    pos += 4;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"<c=", 3) && len >= pos + 10
-                    && html[pos + 9] == L'>') {
-                    using namespace std;
-                    unsigned rgb = static_cast<std::uint32_t>(wcstoul(html + pos + 3, 0, 16));
-                    c.push_back(0xff000000 | rgb);
-                    pos += 10;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"<c=", 3) && len >= pos + 12
-                    && html[pos + 11] == L'>') {
-                    using namespace std;
-                    unsigned argb = static_cast<std::uint32_t>(wcstoul(html + pos + 3, 0, 16));
-                    c.push_back(argb);
-                    pos += 12;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"</c>", 4)) {
-                    if (c.size() > 1) {
-                        c.pop_back();
-                    }
-                    pos += 4;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"&lt;", 4)) {
-                    FormattedChar fc = { L'<', c.back(), flags(b, u, i) };
-                    characters.push_back(fc);
-                    pos += 4;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"&gt;", 4)) {
-                    FormattedChar fc = { L'>', c.back(), flags(b, u, i) };
-                    characters.push_back(fc);
-                    pos += 4;
-                    continue;
-                }
-                if (!std::wcsncmp(html + pos, L"&amp;", 5)) {
-                    FormattedChar fc = { L'&', c.back(), flags(b, u, i) };
-                    characters.push_back(fc);
-                    pos += 5;
-                    continue;
-                }
-                if (html[pos] == L'&' && html[pos + 1]) {
-                    int end_of_entity = pos + 1;
-                    while (html[end_of_entity] != L';') {
-                        using namespace std;
-                        if (!iswalnum(static_cast<wint_t>(html[end_of_entity]))) {
-                            goto normal_character;
-                        }
-                        end_of_entity += 1;
-                        if (end_of_entity >= len) {
-                            goto normal_character;
-                        }
-                    }
-                    std::wstring entity(html + pos + 1, html + end_of_entity);
-                    FormattedChar fc = { 0, c.back(), 0, wstring_to_utf8(entity) };
-                    if (!is_entity(fc.entity)) {
-                        goto normal_character;
-                    }
-                    characters.push_back(fc);
-                    pos = end_of_entity + 1;
-                    continue;
-                }
-
-            normal_character:
-                FormattedChar fc = { html[pos], c.back(), flags(b, u, i) };
-                characters.push_back(fc);
-                pos += 1;
-            }
-        }
+        std::wstring unformat() const;
         
-        std::wstring unformat() const
-        {
-            if (characters.empty()) {
-                return simple_string;
-            }
-            
-            std::wstring result(characters.size(), 0);
-            for (int i = 0; i < characters.size(); ++i) {
-                result[i] = characters[i].wc;
-            }
-            return result;
-        }
+        const char* entity_at(unsigned index) const;
+        wchar_t char_at(unsigned index) const;
+        unsigned flags_at(unsigned index) const;
+        Color color_at(unsigned index) const;
         
-        const char* entity_at(unsigned index) const
-        {
-            if (characters.empty()) {
-                return nullptr;
-            }
-            
-            if (characters[index].wc != 0 || characters[index].entity.empty()) {
-                return nullptr;
-            }
-            
-            return characters[index].entity.c_str();
-        }
+        std::size_t length() const;
         
-        wchar_t char_at(unsigned index) const
-        {
-            if (characters.empty()) {
-                return simple_string[index];
-            }
-            else {
-                return characters[index].wc;
-            }
-        }
+        FormattedString range(std::size_t begin, std::size_t end) const;
         
-        unsigned flags_at(unsigned index) const
-        {
-            if (characters.empty()) {
-                return simple_flags;
-            }
-            else {
-                return characters[index].flags;
-            }
-        }
-        
-        Gosu::Color color_at(unsigned index) const
-        {
-            if (characters.empty()) {
-                return Color::WHITE;
-            }
-            else {
-                return characters[index].color;
-            }
-        }
-        
-        std::size_t length() const
-        {
-            if (std::size_t len = characters.size()) {
-                return len;
-            }
-            else {
-                return simple_string.length();
-            }
-        }
-        
-        FormattedString range(std::size_t begin, std::size_t end) const
-        {
-            FormattedString result;
-            if (characters.empty()) {
-                result.simple_string.assign(simple_string.begin() + begin,
-                                            simple_string.begin() + end);
-                result.simple_flags = simple_flags;
-            }
-            else {
-                result.characters.assign(characters.begin() + begin,
-                                         characters.begin() + end);
-            }
-            return result;
-        }
-        
-        std::vector<FormattedString> split_lines() const
-        {
-            std::vector<FormattedString> result;
-            unsigned begin = 0;
-            for (unsigned cur = 0; cur < length(); ++cur) {
-                if (char_at(cur) == L'\n') {
-                    result.push_back(range(begin, cur));
-                    begin = cur + 1;
-                }
-            }
-            result.push_back(range(begin, length()));
-            return result;
-        }
-        
-        std::vector<FormattedString> split_parts() const
-        {
-            if (characters.empty()) {
-                return std::vector<FormattedString>(1, *this);
-            }
-            
-            std::vector<FormattedString> result;
-            unsigned begin = 0;
-            for (unsigned cur = 1; cur < length(); ++cur) {
-                if (!characters[begin].same_style_as(characters[cur])) {
-                    result.push_back(range(begin, cur));
-                    begin = cur;
-                }
-            }
-            result.push_back(range(begin, length()));
-            return result;
-        }
+        std::vector<FormattedString> split_lines() const;
+        std::vector<FormattedString> split_parts() const;
     };
 }
+