gosu 0.7.19 → 0.7.20

data/Gosu/Input.hpp

@@ -34,21 +34,21 @@ namespace Gosu
 	//! Very lightweight class that identifies a button (keyboard, mouse or other device).
 	class Button
 	{
-		unsigned id;
+		unsigned id_;
 		
 	public:
 		//! For internal use.
-		explicit Button(unsigned id) : id(id) {}
+		explicit Button(unsigned id) : id_(id) {}
 		//! For internal use.
-		unsigned getId() const { return id; }
+		unsigned id() const { return id_; }
 
 		//! Default constructor; == noButton.
-		Button() : id(noButton) {}
+		Button() : id_(noButton) {}
 
 		//! Conversion from ButtonName constants.
-		Button(ButtonName name) : id(name) {}
+		Button(ButtonName name) : id_(name) {}
 	};
-	
+    
 	// Available even on non-iPhone platforms to make it easier to compile the
 	// same source for multiple platforms.
     
@@ -62,16 +62,20 @@ namespace Gosu
         double x, y;
     };
     typedef std::vector<Touch> Touches;
-
+    
 	//! Tests whether two Buttons identify the same physical button.
 	inline bool operator==(Button lhs, Button rhs)
 	{
-		return lhs.getId() == rhs.getId();
+		return lhs.id() == rhs.id();
 	}
 	inline bool operator!=(Button lhs, Button rhs)
 	{
 		return !(lhs == rhs);
 	}
+    inline bool operator<(Button lhs, Button rhs)
+    {
+        return lhs.id() < rhs.id();
+    }
 	
     //! Manages initialization and shutdown of the input system. Only one Input
 	//! instance can exist per application.

data/Gosu/Math.hpp

@@ -101,6 +101,19 @@ namespace Gosu
         return clamp(value, min, max);
     }
     
+    //! Returns (value-min) % (max-min) + min, where % always has a positive
+    //! result for max > min. The results are undefined for max <= min.
+    //! Note: This means that max is exclusive.
+    int wrap(int value, int min, int max);
+    //! Returns (value-min) % (max-min) + min, where % always has a positive
+    //! result for max > min. The results are undefined for max <= min.
+    //! Note: This means that max is exclusive.
+    float wrap(float value, float min, float max);
+    //! Returns (value-min) % (max-min) + min, where % always has a positive
+    //! result for max > min. The results are undefined for max <= min.
+    //! Note: This means that max is exclusive.
+    double wrap(double value, double min, double max);
+    
     //! Returns the square of the distance between two points.
     inline double distanceSqr(double x1, double y1, double x2, double y2)
     {

data/Gosu/TextInput.hpp

@@ -37,11 +37,16 @@ namespace Gosu
 
         //! Position of the caret as the index of the character that it's left to.
         unsigned caretPos() const;
+        //! Sets the caret position as returned by caretPos.
+        //! You usually also want to use setSelectionStart.
+        void setCaretPos(unsigned pos);
 
         //! If there is a selection, the selectionStart() member yields its beginning,
         //! using the same indexing scheme as caretPos. If there is no selection,
         //! selectionStart() is equal to caretPos().
         unsigned selectionStart() const;
+        //! Sets the start of the selection as returned by selectionStart.
+        void setSelectionStart(unsigned pos);
         
         // Platform-specific communication with Gosu::Input.
         #if defined(GOSU_IS_MAC)

data/Gosu/Version.hpp

@@ -3,7 +3,7 @@
 
 #define GOSU_MAJOR_VERSION 0
 #define GOSU_MINOR_VERSION 7
-#define GOSU_POINT_VERSION 19
-#define GOSU_VERSION "0.7.19"
+#define GOSU_POINT_VERSION 20
+#define GOSU_VERSION "0.7.20"
 
 #endif

data/GosuImpl/Graphics/TextUnix.cpp

@@ -0,0 +1,253 @@
+#include <Gosu/Text.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Utility.hpp>
+
+#include <pango/pango.h>
+#include <pango/pangoft2.h>
+#include <glib.h>
+#include <SDL/SDL_ttf.h>
+
+#include <boost/utility.hpp>
+#include <string>
+#include <cstring>
+#include <stdexcept>
+
+std::wstring Gosu::defaultFontName()
+{
+    return L"sans";
+}
+
+namespace Gosu
+{
+    // Used for system fonts
+    // Adapted from original version by Jan Lücker
+    class PangoRenderer : boost::noncopyable
+    {
+        int width, height;
+
+        PangoContext* context;
+        PangoLayout* layout;
+        PangoFontDescription *font_description;
+        PangoAttribute* attr;
+        PangoAttrList* attrList;
+
+    public:
+        PangoRenderer()
+        {
+            font_description = NULL;
+            attr = NULL;
+            attrList = NULL;
+        }
+        ~PangoRenderer()
+        {
+            g_object_unref(context);
+            g_object_unref(layout);
+
+            if(font_description)
+                pango_font_description_free(font_description);
+            if(attr)
+                pango_attribute_destroy(attr);
+        }
+        unsigned textWidth(const std::wstring& text,
+            const std::wstring& fontFace, unsigned fontHeight,
+            unsigned fontFlags)
+        {
+            g_type_init();
+
+            int dpi_x = 100, dpi_y = 100;
+
+            context = pango_ft2_get_context(dpi_x, dpi_y);
+
+            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_style(font_description,
+                (fontFlags & ffItalic) ? 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);
+            pango_font_description_set_stretch(font_description, PANGO_STRETCH_NORMAL);
+            int init_scale = int(fontHeight/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;
+                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);
+            }
+
+
+            // 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);
+
+            PangoDirection base_dir = pango_context_get_base_dir(context);
+            pango_layout_set_alignment(layout,
+                base_dir == PANGO_DIRECTION_LTR ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT);
+
+            pango_layout_set_width(layout, -1);
+
+            PangoRectangle logical_rect;
+
+            pango_layout_get_pixel_extents(layout, NULL, &logical_rect);
+            height = logical_rect.height;
+            width = logical_rect.width;
+
+            return width;
+        }
+        void drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+            Color c, const std::wstring& fontFace, unsigned fontHeight,
+            unsigned fontFlags)
+        {
+            textWidth(text, fontFace, fontHeight, fontFlags);
+
+            FT_Bitmap ft_bitmap;
+
+            guchar* buf = new guchar[width * height];
+            std::fill(buf, buf + width * height, 0x00);
+
+            ft_bitmap.rows = height;
+            ft_bitmap.width = width;
+            ft_bitmap.pitch = ft_bitmap.width;
+            ft_bitmap.buffer = buf;
+            ft_bitmap.num_grays = 256;
+            ft_bitmap.pixel_mode = ft_pixel_mode_grays;
+
+            int x_start = 0;
+            pango_ft2_render_layout(&ft_bitmap, layout, x_start, 0);
+
+
+            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];
+                    Color color = c;
+                    color.setAlpha(val);
+                    bitmap.setPixel(x2 + x, y2 + y, color);
+                }
+            }
+
+            delete[] buf;
+        }
+    };
+
+
+    // Used for custom TTF files
+    // Adapted from customFont class by José Tomás Tocino García (TheOm3ga)
+    class SDLTTFRenderer : boost::noncopyable
+    {
+        TTF_Font* font;
+        
+        class SDLSurface : boost::noncopyable
+        {
+            SDL_Surface* surface;
+            
+        public:
+            SDLSurface(TTF_Font* font, const std::wstring& text, Gosu::Color c)
+            {
+                SDL_Color color = { c.red(), c.green(), c.blue() };
+                surface = TTF_RenderUTF8_Blended(font, Gosu::wstringToUTF8(text).c_str(), color);
+                if (!surface)
+                    throw std::runtime_error("Could not render text " + Gosu::wstringToUTF8(text));
+            }
+            
+            ~SDLSurface()
+            {
+                SDL_FreeSurface(surface);
+            }
+            
+            unsigned height() const
+            {
+                return surface->h;
+            }
+            
+            unsigned width() const
+            {
+                return surface->w;
+            }
+            
+            const void* data() const
+            {
+                return surface->pixels;
+            }
+        };
+        
+    public:
+        SDLTTFRenderer(const std::wstring& fontName, unsigned fontHeight)
+        {
+            static int initResult = TTF_Init();
+            if (initResult < 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));
+        }
+        
+        ~SDLTTFRenderer()
+        {
+            TTF_CloseFont(font);
+        }
+
+        unsigned textWidth(const std::wstring& text){
+            return SDLSurface(font, text, 0xffffff).width();
+        }
+
+        void drawText(Bitmap& bmp, const std::wstring& text, int x, int y, Gosu::Color c) {
+            SDLSurface surf(font, text, c);
+            Gosu::Bitmap temp;
+            temp.resize(surf.width(), surf.height());
+            std::memcpy(temp.data(), surf.data(), temp.width() * temp.height() * 4);
+            bmp.insert(temp, x, y);
+        }
+    };
+}
+
+unsigned Gosu::textWidth(const std::wstring& text,
+    const std::wstring& fontName, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    if (fontName.find(L"/") == std::wstring::npos)
+        return PangoRenderer().textWidth(text, fontName, fontHeight, fontFlags);
+    else
+        return SDLTTFRenderer(fontName, fontHeight).textWidth(text);
+}
+
+void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+    Color c, const std::wstring& fontName, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    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);
+}

data/GosuImpl/InputMac.mm

@@ -606,8 +606,8 @@ bool Gosu::Input::feedNSEvent(void* event)
 
 wchar_t Gosu::Input::idToChar(Button btn)
 {
-    if (btn.getId() < numScancodes)
-        return idChars[btn.getId()];
+    if (btn.id() < numScancodes)
+        return idChars[btn.id()];
     else
         return 0;
 }
@@ -625,7 +625,7 @@ bool Gosu::Input::down(Gosu::Button btn) const
     if (btn == noButton)
         return false;
 
-    return buttonStates.at(btn.getId());
+    return buttonStates.at(btn.id());
 }
 
 double Gosu::Input::mouseX() const
@@ -667,7 +667,7 @@ void Gosu::Input::update()
     for (unsigned i = 0; i < pimpl->queue.size(); ++i)
     {
         Impl::WaitingButton& wb = pimpl->queue[i];
-        buttonStates.at(wb.btn.getId()) = wb.down;
+        buttonStates.at(wb.btn.id()) = wb.down;
         if (wb.down && onButtonDown)
             onButtonDown(wb.btn);
         else if (!wb.down && onButtonUp)

data/GosuImpl/InputWin.cpp

@@ -383,17 +383,17 @@ Gosu::Button Gosu::Input::charToId(wchar_t ch)
 wchar_t Gosu::Input::idToChar(Gosu::Button btn)
 {
 	// Only translate keyboard ids.
-    if (btn.getId() > 255)
+    if (btn.id() > 255)
         return 0;
 
     // Special case...?
-    if (btn.getId() == kbSpace)
+    if (btn.id() == kbSpace)
         return L' ';
 
     // Try to get the key name.
     // (Three elements so too-long names will make GKNT return 3 and we'll know.)
     wchar_t buf[3];
-    if (::GetKeyNameText(btn.getId() << 16, buf, 3) == 1)
+    if (::GetKeyNameText(btn.id() << 16, buf, 3) == 1)
 		return /*std::*/towlower(buf[0]);
 
     return 0;
@@ -405,7 +405,7 @@ bool Gosu::Input::down(Button btn) const
 	if (btn == noButton)
 		return false;
 
-    return buttons.at(btn.getId());
+    return buttons.at(btn.id());
 }
 
 double Gosu::Input::mouseX() const

data/GosuImpl/InputX.cpp

@@ -53,7 +53,7 @@ bool Gosu::Input::down(Gosu::Button btn) const
         return false;
 
     // Will default to false for unknown indices (good).
-    return pimpl->keyMap[btn.getId()];
+    return pimpl->keyMap[btn.id()];
 }
 
 Gosu::Button Gosu::Input::charToId(wchar_t ch)
@@ -74,16 +74,16 @@ namespace
 wchar_t Gosu::Input::idToChar(Button btn)
 {
     // ASCII chars
-    if (btn.getId() >= 32 && btn.getId() <= 255)
-        return btn.getId();
+    if (btn.id() >= 32 && btn.id() <= 255)
+        return btn.id();
     
     // Looking at SDL source suggests that this is to be interpreted depending on the third byte.
     // Should find solid literature on that if it exists.
     // Commented out: This is pretty pointless since LATIN-1 maps to Unicode directly...
     // BUT could serve as a basis for more?!
-    //if ((btn.getId() >> 8) == 0)
+    //if ((btn.id() >> 8) == 0)
     //{
-    //    unsigned char in[] = { btn.getId() & 0xff, 0 };
+    //    unsigned char in[] = { btn.id() & 0xff, 0 };
     //    std::wstring converted = iconvert<std::wstring, UCS_4_INTERNAL, LATIN>(std::string(reinterpret_cast<char*>(in)));
     //    return converted.at(0);
     //}
@@ -167,8 +167,8 @@ void Gosu::Input::update()
             pimpl->keyMap[id] = true;
             // TODO: Here, above, below, who came up with that cast? Uh :)
             if (onButtonDown)
-                onButtonDown(Button(id));
-            if (onButtonUp and id == msWheelUp or id == msWheelDown)
+                onButtonDown(Button(id));
+            if (onButtonUp and id == msWheelUp or id == msWheelDown)
                 onButtonUp(Button(id));
         }
         else if (event.type == ButtonRelease)
@@ -189,12 +189,12 @@ void Gosu::Input::update()
         {
             pimpl->mouseX = event.xbutton.x;
             pimpl->mouseY = event.xbutton.y;
-        }
-        else if (event.type == EnterNotify || event.type == LeaveNotify)
+        }
+        else if (event.type == EnterNotify || event.type == LeaveNotify)
         {
             pimpl->mouseX = event.xcrossing.x;
             pimpl->mouseY = event.xcrossing.y;
-        }
+        }
     }
     pimpl->eventList.clear();
 }
@@ -202,11 +202,11 @@ void Gosu::Input::update()
 void Gosu::Input::setMousePosition(double x, double y)
 {
     ::XWarpPointer(pimpl->display, None, pimpl->window, 0, 0, 0, 0,
-				   x / pimpl->mouseFactorX, y / pimpl->mouseFactorY);
-    ::XSync(pimpl->display, False);
-    // Couldn't find a way to fetch the current mouse position. These
-    // values may not be correct if the cursor was grabbed, for example.
-    pimpl->mouseX = x, pimpl->mouseY = y;
+				   x / pimpl->mouseFactorX, y / pimpl->mouseFactorY);
+    ::XSync(pimpl->display, False);
+    // Couldn't find a way to fetch the current mouse position. These
+    // values may not be correct if the cursor was grabbed, for example.
+    pimpl->mouseX = x, pimpl->mouseY = y;
 }
 
 Gosu::TextInput* Gosu::Input::textInput() const