gosu 1.4.6 → 2.0.0.pre6

data/src/TrueTypeFontWin.cpp

@@ -1,31 +1,30 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_WIN)
 
-#include "Log.hpp"
 #include "TrueTypeFont.hpp"
 
-#define _WIN32_WINNT 0x0500
-#include <Gosu/IO.hpp>
+#include <Gosu/Buffer.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
-#include "WinUtility.hpp"
 #include <cstdlib>
 #include <cwchar>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <windows.h>
 
-const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
+const std::uint8_t* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
 {
-    // TODO: Make this cache thread-safe.
     static std::map<std::pair<std::string, unsigned>, std::shared_ptr<Buffer>> ttf_file_cache;
+    static std::recursive_mutex mutex;
+    std::scoped_lock lock(mutex);
 
     auto& buffer_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
-    if (buffer_ptr) return static_cast<const unsigned char*>(buffer_ptr->data());
-
-    log("Trying to find a font named '%s', flags=%x", font_name.c_str(), font_flags);
+    if (buffer_ptr) {
+        return static_cast<const std::uint8_t*>(buffer_ptr->data());
+    }
 
-    LOGFONT logfont = {0,
+    LOGFONTW logfont { 0,
                        0,
                        0,
                        0,
@@ -37,51 +36,52 @@ const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsign
                        OUT_OUTLINE_PRECIS,
                        CLIP_DEFAULT_PRECIS,
                        ANTIALIASED_QUALITY,
-                       DEFAULT_PITCH};
+                       DEFAULT_PITCH };
 
     std::wstring wfont_name = utf8_to_utf16(font_name);
     std::wcsncpy(logfont.lfFaceName, wfont_name.c_str(), LF_FACESIZE);
     logfont.lfFaceName[LF_FACESIZE - 1] = 0;
 
-    if (HFONT font = CreateFontIndirect(&logfont)) {
+    if (HFONT font = CreateFontIndirectW(&logfont)) {
         if (HDC hdc = GetDC(0)) {
-            HFONT last_font = (HFONT) SelectObject(hdc, (HGDIOBJ) font);
+            HFONT last_font = (HFONT)SelectObject(hdc, (HGDIOBJ)font);
             auto ttf_buffer_size = GetFontData(hdc, 0, 0, nullptr, 0);
             if (ttf_buffer_size != GDI_ERROR) {
-                auto buffer = std::make_shared<Gosu::Buffer>();
-                buffer->resize(ttf_buffer_size);
+                auto buffer = std::make_shared<Gosu::Buffer>(ttf_buffer_size);
                 if (GetFontData(hdc, 0, 0, buffer->data(), buffer->size()) != GDI_ERROR) {
-                    auto data = static_cast<const unsigned char*>(buffer->data());
-                    if (font_name.empty() || TrueTypeFont::matches(data, font_name, font_flags)) {
+                    if (font_name.empty()
+                        || TrueTypeFont::matches(buffer->data(), font_name, font_flags)) {
                         buffer_ptr = buffer;
-                        log("Found a matching file (%d bytes)", (int) buffer->size());
-                    }
-                    else {
-                        log("Internal font name did not match; discarding result");
                     }
                 }
             }
-            SelectObject(hdc, (HGDIOBJ) last_font);
+            SelectObject(hdc, (HGDIOBJ)last_font);
             ReleaseDC(0, hdc);
         }
-        DeleteObject((HGDIOBJ) font);
+        DeleteObject((HGDIOBJ)font);
     }
 
-    return buffer_ptr ? static_cast<const unsigned char*>(buffer_ptr->data()) : nullptr;
+    return buffer_ptr ? buffer_ptr->data() : nullptr;
 }
 
-const unsigned char* Gosu::ttf_fallback_data()
+const std::uint8_t* 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;
+    static const std::uint8_t* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
+    if (arial_unicode) {
+        return arial_unicode;
+    }
 
     // Otherwise, just try to find *any* font.
-    static const unsigned char* any_font = ttf_data_by_name("", 0);
-    if (any_font) return any_font;
+    static const std::uint8_t* any_font = ttf_data_by_name("", 0);
+    if (any_font) {
+        return any_font;
+    }
 
     static const char* windir = std::getenv("WINDIR");
-    if (windir) return ttf_data_from_file(std::string(windir) + "/Fonts/arial.ttf");
+    if (windir) {
+        return ttf_data_from_file(std::string(windir) + "/Fonts/arial.ttf");
+    }
 
     return ttf_data_from_file("C:/Windows/Fonts/arial.ttf");
 }

data/src/Utility.cpp

@@ -1,25 +1,22 @@
 #include <Gosu/Platform.hpp>
 #include <Gosu/Utility.hpp>
-
-#include <utf8proc.h>
-
-#include <cstring>
 #include <memory>
 #include <stdexcept>
+#include <utf8proc.h>
 
-std::u32string Gosu::utf8_to_composed_utc4(const std::string& utf8)
+std::u32string Gosu::utf8_to_composed_utc4(std::string_view utf8)
 {
     std::u32string utc4;
     utc4.reserve(utf8.size());
 
     const auto* current_byte = reinterpret_cast<const utf8proc_uint8_t*>(utf8.data());
-    auto remaining_length = utf8.length();
+    auto remaining_length = static_cast<utf8proc_ssize_t>(utf8.length());
 
     // First convert from UTF-8 to UTC-4.
     utf8proc_int32_t codepoint;
     while (remaining_length) {
         auto bytes_read = utf8proc_iterate(current_byte, remaining_length, &codepoint);
-        if (bytes_read == -1) {
+        if (bytes_read < 0) {
             // Not looking good, skip this byte and retry.
             current_byte += 1;
             remaining_length -= 1;
@@ -33,12 +30,15 @@ std::u32string Gosu::utf8_to_composed_utc4(const std::string& utf8)
 
     // Now compose characters in-place.
     auto* utc4_data = reinterpret_cast<utf8proc_int32_t*>(utc4.data());
+    auto utc4_length = static_cast<utf8proc_ssize_t>(utc4.length());
     auto options = static_cast<utf8proc_option_t>(UTF8PROC_NLF2LF | UTF8PROC_COMPOSE);
-    auto new_length = utf8proc_normalize_utf32(utc4_data, utc4.length(), options);
+    auto new_length = utf8proc_normalize_utf32(utc4_data, utc4_length, options);
+    // GCOV_EXCL_START: No code path in utf8proc_normalize_utf32 currently returns an error.
     if (new_length < 0) {
-        throw std::runtime_error{"Could not normalize '" + utf8 +
-                                 "': " + utf8proc_errmsg(new_length)};
+        throw std::runtime_error("Could not normalize '" + std::string(utf8)
+                                 + "': " + utf8proc_errmsg(new_length));
     }
+    // GCOV_EXCL_END
     utc4.resize(new_length);
 
     return utc4;
@@ -46,8 +46,13 @@ std::u32string Gosu::utf8_to_composed_utc4(const std::string& utf8)
 
 bool Gosu::has_extension(std::string_view filename, std::string_view extension)
 {
+    /// To avoid extra code paths later, we cut off all leading dots.
+    if (extension.starts_with('.')) {
+        extension.remove_prefix(1);
+    }
+
     std::size_t ext_len = extension.length();
-    if (ext_len > filename.length()) {
+    if (ext_len >= filename.length()) {
         return false;
     }
 
@@ -57,13 +62,14 @@ bool Gosu::has_extension(std::string_view filename, std::string_view extension)
         --filename_iter;
         --ext_iter;
 
-        if (std::tolower(static_cast<int>(*filename_iter)) !=
-            std::tolower(static_cast<int>(*ext_iter))) {
+        if (std::tolower(static_cast<int>(*filename_iter))
+            != std::tolower(static_cast<int>(*ext_iter))) {
             return false;
         }
     }
-
-    return true;
+    // We have verified the part after the dot, now make sure that the preceding character is a dot.
+    --filename_iter;
+    return *filename_iter == '.';
 }
 
 #ifdef GOSU_IS_IPHONE
@@ -72,7 +78,7 @@ bool Gosu::has_extension(std::string_view filename, std::string_view extension)
 
 std::vector<std::string> Gosu::user_languages()
 {
-    static const std::regex language_regex{"([a-z]{2})-([A-Z]{2})([^A-Z].*)?"};
+    static const std::regex language_regex("([a-z]{2})-([A-Z]{2})([^A-Z].*)?");
 
     std::vector<std::string> user_languages;
 
@@ -97,13 +103,17 @@ std::vector<std::string> Gosu::user_languages()
 {
     std::vector<std::string> user_languages;
 
-    std::unique_ptr<SDL_Locale, decltype(SDL_free)*> locales{SDL_GetPreferredLocales(), SDL_free};
-    if (!locales) return user_languages;
+    std::unique_ptr<SDL_Locale, decltype(SDL_free)*> locales(SDL_GetPreferredLocales(), SDL_free);
+    // GCOV_EXCL_START: There is no portable way to let SDL_GetPreferredLocales fail.
+    if (!locales) {
+        return user_languages;
+    }
+    // GCOV_EXCL_END
 
     for (const SDL_Locale* locale = locales.get(); locale->language != nullptr; ++locale) {
         std::string language = locale->language;
         if (locale->country) {
-            language += "_";
+            language += '_';
             language += locale->country;
         }
         user_languages.emplace_back(std::move(language));
@@ -118,13 +128,13 @@ std::vector<std::string> Gosu::user_languages()
 
 std::vector<std::string> Gosu::user_languages()
 {
-    static const std::regex language_regex{"[a-z]{2}_[A-Z]{2}([^A-Z].*)?"};
+    static const std::regex language_regex("[a-z]{2}_[A-Z]{2}([^A-Z].*)?");
 
     const char* locale = std::getenv("LANG");
 
     if (locale && std::regex_match(locale, language_regex)) {
         // Trim off anything after the language code.
-        return {std::string{locale, locale + 5}};
+        return { std::string(locale, locale + 5) };
     }
 
     return {};
@@ -132,3 +142,56 @@ std::vector<std::string> Gosu::user_languages()
 
 #endif
 #endif
+
+bool Gosu::Rect::overlaps(const Rect& other) const
+{
+    return x < other.right() && other.x < right() && y < other.bottom() && other.y < bottom();
+}
+
+bool Gosu::Rect::contains(const Rect& other) const
+{
+    return x <= other.x && other.right() <= right() && y <= other.y && other.bottom() <= bottom();
+}
+
+void Gosu::Rect::clip_to(const Rect& bounding_box, int* adjust_x, int* adjust_y)
+{
+    // Cut off the area on the left that exceeds the bounding box, if any.
+    const int extra_pixels_left = bounding_box.x - x;
+    if (extra_pixels_left > 0) {
+        x += extra_pixels_left;
+        width -= extra_pixels_left;
+        if (adjust_x) {
+            *adjust_x += extra_pixels_left;
+        }
+    }
+
+    // Cut off the area on the right that exceeds the bounding box, if any.
+    const int extra_pixels_right = right() - bounding_box.right();
+    if (extra_pixels_right > 0) {
+        width -= extra_pixels_right;
+    }
+
+    // Cut off the area at the top that exceeds the bounding box, if any.
+    const int extra_pixels_top = bounding_box.y - y;
+    if (extra_pixels_top > 0) {
+        y += extra_pixels_top;
+        height -= extra_pixels_top;
+        if (adjust_y) {
+            *adjust_y += extra_pixels_top;
+        }
+    }
+
+    // Cut off the area at the bottom that exceeds the bounding box, if any.
+    const int extra_pixels_bottom = bottom() - bounding_box.bottom();
+    if (extra_pixels_bottom > 0) {
+        height -= extra_pixels_bottom;
+    }
+
+    // Leave 0 instead of negative values for width/height when the rect was clipped away.
+    if (width < 0) {
+        width = 0;
+    }
+    if (height < 0) {
+        height = 0;
+    }
+}

data/src/UtilityWin.cpp

@@ -0,0 +1,45 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
+#include <Gosu/Utility.hpp>
+#include <stdexcept>
+#include <windows.h>
+
+std::wstring Gosu::utf8_to_utf16(const std::string& utf8)
+{
+    if (utf8.empty()) {
+        return std::wstring();
+    }
+
+    // The UTF-16 result can never consist of more codepoints than we have bytes in UTF-8.
+    // -> Start with a size that we know is sufficient, then truncate later.
+    std::wstring utf16(utf8.size(), '\0');
+    int result = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.data(), utf8.size(),
+                                     utf16.data(), utf16.size());
+    if (result == 0) {
+        throw std::runtime_error("Could not convert UTF-8 to UTF-16, GetLastError() = "
+                                 + std::to_string(GetLastError()));
+    }
+    utf16.resize(result);
+    return utf16;
+}
+
+std::string Gosu::utf16_to_utf8(const std::wstring& utf16)
+{
+    if (utf16.empty()) {
+        return std::string();
+    }
+
+    int result = WideCharToMultiByte(CP_UTF8, 0, utf16.c_str(), utf16.size(), nullptr, 0, nullptr,
+                                     nullptr);
+    if (result == 0) {
+        throw std::runtime_error("Could not convert UTF-16 to UTF-8, GetLastError() = "
+                                 + std::to_string(GetLastError()));
+    }
+    std::string utf8(result, '\0');
+    WideCharToMultiByte(CP_UTF8, MB_ERR_INVALID_CHARS, utf16.c_str(), utf16.size(), utf8.data(),
+                        utf8.size(), nullptr, nullptr);
+    return utf8;
+}
+
+#endif