gosu 0.10.9.pre1 → 0.11.0

data/src/TextTTFWin.cpp

@@ -0,0 +1,251 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
+#include <Gosu/Utility.hpp>
+#include <cassert>
+#include <cstdio>
+#include <windows.h>
+
+// Adapted from http://www.codeproject.com/KB/GDI/xfont.aspx.
+// Kudos to Philip Patrick and Hans Dietrich!
+
+struct FONT_PROPERTIES_ANSI
+{
+    char csName[1024];
+    char csCopyright[1024];
+    char csTrademark[1024];
+    char csFamily[1024];
+};
+struct TT_OFFSET_TABLE
+{
+    USHORT    uMajorVersion;
+    USHORT    uMinorVersion;
+    USHORT    uNumOfTables;
+    USHORT    uSearchRange;
+    USHORT    uEntrySelector;
+    USHORT    uRangeShift;
+};
+struct TT_TABLE_DIRECTORY
+{
+    char    szTag[4];            //table name
+    ULONG    uCheckSum;            //Check sum
+    ULONG    uOffset;            //Offset from beginning of file
+    ULONG    uLength;            //length of the table in bytes
+};
+struct TT_NAME_TABLE_HEADER
+{
+    USHORT    uFSelector;            //format selector. Always 0
+    USHORT    uNRCount;            //Name Records count
+    USHORT    uStorageOffset;        //Offset for strings storage, from start of the table
+};
+struct TT_NAME_RECORD
+{
+    USHORT    uPlatformID;
+    USHORT    uEncodingID;
+    USHORT    uLanguageID;
+    USHORT    uNameID;
+    USHORT    uStringLength;
+    USHORT    uStringOffset;    //from start of storage area
+};
+
+#define SWAPWORD(x)        MAKEWORD(HIBYTE(x), LOBYTE(x))
+#define SWAPLONG(x)        MAKELONG(SWAPWORD(HIWORD(x)), SWAPWORD(LOWORD(x)))
+
+#define _T(x) x
+#define TRACE printf
+
+namespace Gosu
+{
+std::string get_name_from_ttf_file(const std::wstring& filename)
+{
+    FONT_PROPERTIES_ANSI fp;
+    FONT_PROPERTIES_ANSI * lpFontProps = &fp;
+    memset(lpFontProps, 0, sizeof(FONT_PROPERTIES_ANSI));
+
+    HANDLE hFile = INVALID_HANDLE_VALUE;
+    hFile = ::CreateFile(filename.c_str(),
+                         GENERIC_READ,// | GENERIC_WRITE,
+                         FILE_SHARE_READ,
+                         NULL,
+                         OPEN_EXISTING,
+                         FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
+                         NULL);
+
+    if (hFile == INVALID_HANDLE_VALUE)
+    {
+        TRACE(_T("ERROR:  failed to open '%s'\n"), wstring_to_utf8(filename).c_str());
+        TRACE(_T("ERROR: %s failed, GetLastError() = 0x%x\n"), _T("CreateFile"), (int)GetLastError());
+        return wstring_to_utf8(filename);
+    }
+
+    // get the file size
+    DWORD dwFileSize = ::GetFileSize(hFile, NULL);
+
+    if (dwFileSize == INVALID_FILE_SIZE)
+    {
+        TRACE(_T("ERROR: %s failed\n"), _T("GetFileSize"));
+        ::CloseHandle(hFile);
+        return wstring_to_utf8(filename);
+    }
+
+    //TRACE(_T("dwFileSize = %d\n"), dwFileSize);
+
+    // Create a file mapping object that is the current size of the file
+    HANDLE hMappedFile = NULL;
+    hMappedFile = ::CreateFileMapping(hFile,
+                                      NULL,
+                                      PAGE_READONLY, //PAGE_READWRITE,
+                                      0,
+                                      dwFileSize,
+                                      NULL);
+
+    if (hMappedFile == NULL)
+    {
+        TRACE(_T("ERROR: %s failed\n"), _T("CreateFileMapping"));
+        ::CloseHandle(hFile);
+        return wstring_to_utf8(filename);
+    }
+
+    LPBYTE lpMapAddress = (LPBYTE) ::MapViewOfFile(hMappedFile,        // handle to file-mapping object
+                                            FILE_MAP_READ,//FILE_MAP_WRITE,            // access mode
+                                            0,                        // high-order DWORD of offset
+                                            0,                        // low-order DWORD of offset
+                                            0);                        // number of bytes to map
+
+    if (lpMapAddress == NULL)
+    {
+        TRACE(_T("ERROR: %s failed\n"), _T("MapViewOfFile"));
+        ::CloseHandle(hMappedFile);
+        ::CloseHandle(hFile);
+        return wstring_to_utf8(filename);
+    }
+
+    BOOL bRetVal = FALSE;
+    int index = 0;
+
+    TT_OFFSET_TABLE ttOffsetTable;
+    memcpy(&ttOffsetTable, &lpMapAddress[index], sizeof(TT_OFFSET_TABLE));
+    index += sizeof(TT_OFFSET_TABLE);
+
+    ttOffsetTable.uNumOfTables = SWAPWORD(ttOffsetTable.uNumOfTables);
+    ttOffsetTable.uMajorVersion = SWAPWORD(ttOffsetTable.uMajorVersion);
+    ttOffsetTable.uMinorVersion = SWAPWORD(ttOffsetTable.uMinorVersion);
+
+    //check is this is a true type font and the version is 1.0
+    if (ttOffsetTable.uMajorVersion != 1 || ttOffsetTable.uMinorVersion != 0)
+        return wstring_to_utf8(filename);
+
+    TT_TABLE_DIRECTORY tblDir;
+    memset(&tblDir, 0, sizeof(TT_TABLE_DIRECTORY));
+    BOOL bFound = FALSE;
+    char szTemp[4096];
+    memset(szTemp, 0, sizeof(szTemp));
+
+    for (int i = 0; i< ttOffsetTable.uNumOfTables; i++)
+    {
+        //f.Read(&tblDir, sizeof(TT_TABLE_DIRECTORY));
+        memcpy(&tblDir, &lpMapAddress[index], sizeof(TT_TABLE_DIRECTORY));
+        index += sizeof(TT_TABLE_DIRECTORY);
+
+        strncpy(szTemp, tblDir.szTag, 4);
+        if (stricmp(szTemp, "name") == 0)
+        {
+            bFound = TRUE;
+            tblDir.uLength = SWAPLONG(tblDir.uLength);
+            tblDir.uOffset = SWAPLONG(tblDir.uOffset);
+            break;
+        }
+        else if (szTemp[0] == 0)
+        {
+            break;
+        }
+    }
+
+    if (bFound)
+    {
+        index = tblDir.uOffset;
+
+        TT_NAME_TABLE_HEADER ttNTHeader;
+        memcpy(&ttNTHeader, &lpMapAddress[index], sizeof(TT_NAME_TABLE_HEADER));
+        index += sizeof(TT_NAME_TABLE_HEADER);
+
+        ttNTHeader.uNRCount = SWAPWORD(ttNTHeader.uNRCount);
+        ttNTHeader.uStorageOffset = SWAPWORD(ttNTHeader.uStorageOffset);
+        TT_NAME_RECORD ttRecord;
+        bFound = FALSE;
+
+        for (int i = 0;
+             i < ttNTHeader.uNRCount &&
+             (lpFontProps->csCopyright[0] == 0 ||
+              lpFontProps->csName[0] == 0      ||
+              lpFontProps->csTrademark[0] == 0 ||
+              lpFontProps->csFamily[0] == 0);
+             i++)
+        {
+            memcpy(&ttRecord, &lpMapAddress[index], sizeof(TT_NAME_RECORD));
+            index += sizeof(TT_NAME_RECORD);
+
+            ttRecord.uNameID = SWAPWORD(ttRecord.uNameID);
+            ttRecord.uStringLength = SWAPWORD(ttRecord.uStringLength);
+            ttRecord.uStringOffset = SWAPWORD(ttRecord.uStringOffset);
+
+            if (ttRecord.uNameID == 1 || ttRecord.uNameID == 0 || ttRecord.uNameID == 7)
+            {
+                int nPos = index; //f.GetPosition();
+
+                index = tblDir.uOffset + ttRecord.uStringOffset + ttNTHeader.uStorageOffset;
+
+                memset(szTemp, 0, sizeof(szTemp));
+
+                memcpy(szTemp, &lpMapAddress[index], ttRecord.uStringLength);
+                index += ttRecord.uStringLength;
+
+                if (szTemp[0] != 0)
+                {
+                    assert (strlen(szTemp) < sizeof(lpFontProps->csName));
+
+                    switch (ttRecord.uNameID)
+                    {
+                        case 0:
+                            if (lpFontProps->csCopyright[0] == 0)
+                                strncpy(lpFontProps->csCopyright, szTemp,
+                                    sizeof(lpFontProps->csCopyright)-1);
+                            break;
+
+                        case 1:
+                            if (lpFontProps->csFamily[0] == 0)
+                                strncpy(lpFontProps->csFamily, szTemp,
+                                    sizeof(lpFontProps->csFamily)-1);
+                            bRetVal = TRUE;
+                            break;
+
+                        case 4:
+                            if (lpFontProps->csName[0] == 0)
+                                strncpy(lpFontProps->csName, szTemp,
+                                    sizeof(lpFontProps->csName)-1);
+                            break;
+
+                        case 7:
+                            if (lpFontProps->csTrademark[0] == 0)
+                                strncpy(lpFontProps->csTrademark, szTemp,
+                                    sizeof(lpFontProps->csTrademark)-1);
+                            break;
+
+                        default:
+                            break;
+                    }
+                }
+                index = nPos;
+            }
+        }
+    }
+
+    ::UnmapViewOfFile(lpMapAddress);
+    ::CloseHandle(hMappedFile);
+    ::CloseHandle(hFile);
+
+    return lpFontProps->csName[0] ? lpFontProps->csName : lpFontProps->csFamily;
+}
+}
+
+#endif

data/src/{Text/TextUnix.cpp → TextUnix.cpp}

@@ -1,19 +1,22 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_X)
+
 #include <Gosu/Text.hpp>
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Utility.hpp>
 
+#include <SDL_ttf.h>
+#include <glib.h>
 #include <pango/pango.h>
 #include <pango/pangoft2.h>
-#include <glib.h>
-#include <SDL_ttf.h>
 
-#include <string>
 #include <cstring>
 #include <stdexcept>
+#include <string>
 
-std::wstring Gosu::defaultFontName()
+std::string Gosu::default_font_name()
 {
-    return L"sans";
+    return "sans";
 }
 
 namespace Gosu
@@ -29,30 +32,34 @@ namespace Gosu
 
         PangoContext* context;
         PangoLayout* layout;
-        PangoFontDescription *font_description;
+        PangoFontDescription* font_description;
         PangoAttribute* attr;
-        PangoAttrList* attrList;
+        PangoAttrList* attr_list;
 
     public:
         PangoRenderer()
         {
             font_description = NULL;
             attr = NULL;
-            attrList = NULL;
+            attr_list = NULL;
         }
+        
         ~PangoRenderer()
         {
             g_object_unref(context);
             g_object_unref(layout);
 
-            if(font_description)
+            if (font_description) {
                 pango_font_description_free(font_description);
-            if(attr)
+            }
+            
+            if (attr) {
                 pango_attribute_destroy(attr);
+            }
         }
-        unsigned textWidth(const std::wstring& text,
-            const std::wstring& fontFace, unsigned fontHeight,
-            unsigned fontFlags)
+        
+        unsigned text_width(const std::string& text, const std::string& font_face,
+            unsigned font_height, unsigned font_flags)
         {
             g_type_init();
 
@@ -60,47 +67,37 @@ namespace Gosu
 
             context = pango_ft2_get_context(dpi_x, dpi_y);
 
-            pango_context_set_language(context, pango_language_from_string ("en_US"));
+            pango_context_set_language(context, pango_language_from_string("en_US"));
             PangoDirection init_dir = PANGO_DIRECTION_LTR;
             pango_context_set_base_dir(context, init_dir);
 
             font_description = pango_font_description_new();
 
-            pango_font_description_set_family(font_description,
-                g_strdup(narrow(fontFace).c_str()));
+            pango_font_description_set_family(font_description, g_strdup(font_face.c_str()));
             pango_font_description_set_style(font_description,
-                (fontFlags & ffItalic) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
+                (font_flags & FF_ITALIC) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
             pango_font_description_set_variant(font_description, PANGO_VARIANT_NORMAL);
             pango_font_description_set_weight(font_description,
-                (fontFlags & ffBold) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
+                (font_flags & FF_BOLD) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
             pango_font_description_set_stretch(font_description, PANGO_STRETCH_NORMAL);
-            int init_scale = int(fontHeight/2.0 + 0.5);
+            int init_scale = int(font_height / 2.0 + 0.5);
             pango_font_description_set_size(font_description, init_scale * PANGO_SCALE);
 
             pango_context_set_font_description(context, font_description);
 
-
             layout = pango_layout_new(context);
 
-
-            if(fontFlags & ffUnderline)
-            {
-        //        PangoAttribute *attr;
+            if (font_flags & FF_UNDERLINE) {
                 attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
                 attr->start_index = 0;
                 attr->end_index = text.length();
-        //        PangoAttrList* attrList;
-                attrList = pango_attr_list_new();
-                pango_attr_list_insert(attrList, attr);
-                pango_layout_set_attributes(layout, attrList);
-                pango_attr_list_unref(attrList);
+                attr_list = pango_attr_list_new();
+                pango_attr_list_insert(attr_list, attr);
+                pango_layout_set_attributes(layout, attr_list);
+                pango_attr_list_unref(attr_list);
             }
 
-
-            // IMPR: Catch errors? (Last NULL-Pointer)
-            gchar* utf8Str = g_ucs4_to_utf8((gunichar*)text.c_str(), text.length(), NULL, NULL, NULL);
-            pango_layout_set_text(layout, utf8Str, -1);
-            g_free(utf8Str);
+            pango_layout_set_text(layout, text.c_str(), -1);
 
             PangoDirection base_dir = pango_context_get_base_dir(context);
             pango_layout_set_alignment(layout,
@@ -116,11 +113,11 @@ namespace Gosu
 
             return width;
         }
-        void drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
-            Color c, const std::wstring& fontFace, unsigned fontHeight,
-            unsigned fontFlags)
+        
+        void draw_text(Bitmap& bitmap, const std::string& text, int x, int y, Color c,
+            const std::string& font_face, unsigned font_height, unsigned font_flags)
         {
-            textWidth(text, fontFace, fontHeight, fontFlags);
+            text_width(text, font_face, font_height, font_flags);
 
             FT_Bitmap ft_bitmap;
 
@@ -137,22 +134,16 @@ namespace Gosu
             int x_start = 0;
             pango_ft2_render_layout(&ft_bitmap, layout, x_start, 0);
 
+            int min_height = std::min<int>(height, font_height);
 
-            int min_height = height;
-            if((unsigned)height > fontHeight) min_height = fontHeight;
-
-            for(int y2 = 0; y2 < min_height; y2++)
-            {
-                if (y + y2 < 0 || y + y2 >= bitmap.height())
-                    break;
-
-                for(int x2 = 0; x2 < width; x2++)
-                {
-                    if (x + x2 < 0 || x + x2 >= bitmap.width())
-                        break;
-                    unsigned val = ft_bitmap.buffer[y2*width+x2];
+            for (int y2 = 0; y2 < min_height; y2++) {
+                if (y + y2 < 0 || y + y2 >= bitmap.height()) break;
+                
+                for (int x2 = 0; x2 < width; x2++) {
+                    if (x + x2 < 0 || x + x2 >= bitmap.width()) break;
+                    unsigned val = ft_bitmap.buffer[y2 * width + x2];
                     Color color = multiply(c, Gosu::Color(val, 255, 255, 255));
-                    bitmap.setPixel(x2 + x, y2 + y, color);
+                    bitmap.set_pixel(x2 + x, y2 + y, color);
                 }
             }
 
@@ -160,13 +151,14 @@ namespace Gosu
         }
     };
 
-
     // Used for custom TTF files
-    // Adapted from customFont class by José Tomás Tocino García (TheOm3ga)
+    // Adapted from custom_font class by José Tomás Tocino García (TheOm3ga)
     class SDLTTFRenderer
     {
-        SDLTTFRenderer(const SDLTTFRenderer&);
-        SDLTTFRenderer& operator=(const SDLTTFRenderer&);
+        SDLTTFRenderer(const SDLTTFRenderer&) = delete;
+        SDLTTFRenderer& operator=(const SDLTTFRenderer&) = delete;
+        SDLTTFRenderer(SDLTTFRenderer&&) = delete;
+        SDLTTFRenderer& operator=(SDLTTFRenderer&&) = delete;
         
         TTF_Font* font;
         
@@ -178,14 +170,15 @@ namespace Gosu
             SDL_Surface* surface;
             
         public:
-            SDLSurface(TTF_Font* font, const std::wstring& text, Gosu::Color c)
+            SDLSurface(TTF_Font* font, const std::string& text, Gosu::Color c)
             {
                 // This is intentionally re-ordered to BGR. This way, the surface pixels do not
                 // have to be converted from RGB to BGR later in the process.
                 SDL_Color color = { c.blue(), c.green(), c.red() };
-                surface = TTF_RenderUTF8_Blended(font, Gosu::wstringToUTF8(text).c_str(), color);
-                if (!surface)
-                    throw std::runtime_error("Could not render text " + Gosu::wstringToUTF8(text));
+                surface = TTF_RenderUTF8_Blended(font, text.c_str(), color);
+                if (!surface) {
+                    throw std::runtime_error("Could not render text: " + text);
+                }
             }
             
             ~SDLSurface()
@@ -210,24 +203,27 @@ namespace Gosu
         };
         
     public:
-        SDLTTFRenderer(const std::wstring& fontName, unsigned fontHeight)
+        SDLTTFRenderer(const std::string& font_name, unsigned font_height)
         {
-            static int initResult = TTF_Init();
-            if (initResult < 0)
+            static int init_result = TTF_Init();
+            if (init_result < 0) {
                 throw std::runtime_error("Could not initialize SDL_TTF");
+            }
 
-	          // Try to open the font at the given path
-	          font = TTF_OpenFont(Gosu::wstringToUTF8(fontName).c_str(), fontHeight);
-	          if (!font)
-                throw std::runtime_error("Could not open TTF file " + Gosu::wstringToUTF8(fontName));
+            // Try to open the font at the given path
+            font = TTF_OpenFont(font_name.c_str(), font_height);
+            if (!font) {
+                throw std::runtime_error("Could not open TTF file " + font_name);
+            }
             
             // Re-open with scaled height so that ascenders/descenders fit
-            int tooLargeHeight = TTF_FontHeight(font);
-            int realHeight = fontHeight * fontHeight / tooLargeHeight;
+            int too_large_height = TTF_FontHeight(font);
+            int real_height = font_height * font_height / too_large_height;
             TTF_CloseFont(font);
-	          font = TTF_OpenFont(Gosu::wstringToUTF8(fontName).c_str(), realHeight);
-	          if (!font)
-                throw std::runtime_error("Could not open TTF file " + Gosu::wstringToUTF8(fontName));
+            font = TTF_OpenFont(font_name.c_str(), real_height);
+            if (!font) {
+                throw std::runtime_error("Could not open TTF file " + font_name);
+            }
         }
         
         ~SDLTTFRenderer()
@@ -235,11 +231,13 @@ namespace Gosu
             TTF_CloseFont(font);
         }
 
-        unsigned textWidth(const std::wstring& text){
+        unsigned text_width(const std::string& text)
+        {
             return SDLSurface(font, text, 0xffffff).width();
         }
 
-        void drawText(Bitmap& bmp, const std::wstring& text, int x, int y, Gosu::Color c) {
+        void draw_text(Bitmap& bmp, const std::string& text, int x, int y, Gosu::Color c)
+        {
             SDLSurface surf(font, text, c);
             Gosu::Bitmap temp;
             temp.resize(surf.width(), surf.height());
@@ -249,28 +247,34 @@ namespace Gosu
     };
 }
 
-unsigned Gosu::textWidth(const std::wstring& text,
-    const std::wstring& fontName, unsigned fontHeight,
-    unsigned fontFlags)
+unsigned Gosu::text_width(const std::string& text, const std::string& font_name,
+    unsigned font_height, unsigned font_flags)
 {
-    if (text.find_first_of(L"\r\n") != std::wstring::npos)
-        throw std::invalid_argument("the argument to textWidth cannot contain line breaks");
+    if (text.find_first_of("\r\n") != text.npos) {
+        throw std::invalid_argument("the argument to text_width cannot contain line breaks");
+    }
     
-    if (fontName.find(L"/") == std::wstring::npos)
-        return PangoRenderer().textWidth(text, fontName, fontHeight, fontFlags);
-    else
-        return SDLTTFRenderer(fontName, fontHeight).textWidth(text);
+    if (font_name.find("/") == font_name.npos) {
+        return PangoRenderer().text_width(text, font_name, font_height, font_flags);
+    }
+    else {
+        return SDLTTFRenderer(font_name, font_height).text_width(text);
+    }
 }
 
-void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
-    Color c, const std::wstring& fontName, unsigned fontHeight,
-    unsigned fontFlags)
+void Gosu::draw_text(Bitmap& bitmap, const std::string& text, int x, int y, Color c,
+    const std::string& font_name, unsigned font_height, unsigned font_flags)
 {
-    if (text.find_first_of(L"\r\n") != std::wstring::npos)
-        throw std::invalid_argument("the argument to drawText cannot contain line breaks");
+    if (text.find_first_of("\r\n") != text.npos) {
+        throw std::invalid_argument("the argument to draw_text cannot contain line breaks");
+    }
     
-    if (fontName.find(L"/") == std::wstring::npos)
-        PangoRenderer().drawText(bitmap, text, x, y, c, fontName, fontHeight, fontFlags);
-    else
-        SDLTTFRenderer(fontName, fontHeight).drawText(bitmap, text, x, y, c);
+    if (font_name.find("/") == font_name.npos) {
+        PangoRenderer().draw_text(bitmap, text, x, y, c, font_name, font_height, font_flags);
+    }
+    else {
+        SDLTTFRenderer(font_name, font_height).draw_text(bitmap, text, x, y, c);
+    }
 }
+
+#endif