gosu 0.13.3 → 0.14.0.pre2

data/lib/gosu/swig_patches.rb

@@ -1,6 +1,3 @@
-# SWIG workarounds
-# These are offloaded into a separate file because rb_eval_string() is weird on Ruby 1.8.
-
 # Exceptions in Window callbacks often get lost, this is especially annoying in draw/update.
 # It is not clear whether this is a SWIG issue or if some stack frame is not exception
 # compatible, but I just call protected_update etc. in the Ruby wrapper so I can add this
@@ -66,7 +63,7 @@ module Gosu
   end
 end
 
-# SWIG won't let me rename my method to '[]='.
+# SWIG will not let me rename my method to '[]=', so use alias here.
 class Gosu::Font
   alias []= set_image
 end

data/rdoc/gosu.rb

@@ -679,9 +679,20 @@ module Gosu
     #   def input.filter(text_in)
     #     text_in.upcase.gsub(/[^A-Z0-9]/, '')
     #   end
-    def filter text_in
-      text_in
-    end
+    def filter; end
+
+    ##
+    # Replaces the current selection (if any) and inserts the given string at the current caret position.
+    # The filter method will not be applied before appending the string.
+    def insert_text(str); end
+
+    ##
+    # Deletes the current selection, if any, or the next character.
+    def delete_forward; end
+
+    ##
+    # Deletes the current selection, if any, or the previous character.
+    def delete_backward; end
   end
 
   ##
@@ -1024,21 +1035,35 @@ module Gosu
     def clip_to(x, y, w, h); end
 
     ##
-    # Records all drawing operations inside the block as a reusable "image". This method can be used to speed rendering of multiple static images, e.g., a fixed tile map.
+    # Records all drawing operations inside the block as a macro (a special {Gosu::Image}) that can be reused later on.
+    # This is useful for rendering larger groups of images (e.g. a tiled map in a game) and then rendering this group with a single call to {Gosu::Image#draw}.
     #
-    # @note Because the returned object is not a true image---it's implemented using vertex buffers and is not backed by a texture---there are restrictions on how it can be used.
+    # @note Because the returned object is not backed by a bitmap texture, there are restrictions on how it can be used. For example, you can not use any color other than {Gosu::Color#WHITE} when drawing the image.
     #
-    # @note The width and height of the returned object will be the same values you passed to {record}, regardless of the area you draw on. It is important to pass accurate values if you plan on using {Gosu::Image#draw_as_quad} or {Gosu::Image#draw_rot} with the result later.
+    # @note The width and height of the returned image will be the values you passed to {record}, regardless of the area you draw on.
+    # It is important to pass accurate values if you plan on calling {Gosu::Image#draw_as_quad} or {Gosu::Image#draw_rot} on the result later.
     #
     # @return [Gosu::Image] the recorded drawing operations.
-    # @param width [Float] the width of the recorded image.
-    # @param height [Float] the height of the recorded image.
+    # @param width [Integer] the width of the recorded image.
+    # @param height [Integer] the height of the recorded image.
     # @yield rendering code.
     #
-    # @see Window#draw
+    # @see Window#render
     # @see Gosu::Image
     def record(width, height); end
 
+    ##
+    # Records all drawing operations inside the block and returns the result as a new {Gosu::Image}.
+    #
+    # @return [Gosu::Image] the rendered drawing operations.
+    # @param width [Integer] the width of the recorded image.
+    # @param height [Integer] the height of the recorded image.
+    # @yield rendering code.
+    #
+    # @see Window#record
+    # @see Gosu::Image
+    def render(width, height); end
+
     ##
     # Rotates all drawing operations inside the block.
     #

data/src/Audio.cpp

@@ -45,7 +45,7 @@ static bool cur_song_looping;
 
 struct Gosu::Sample::SampleData
 {
-    ALuint buffer, source;
+    ALuint buffer;
 
     SampleData(AudioFile& audio_file)
     {
@@ -114,7 +114,7 @@ Gosu::Channel Gosu::Sample::play(double volume, double speed, bool looping) cons
 
 Gosu::Channel Gosu::Sample::play_pan(double pan, double volume, double speed, bool looping) const
 {
-    if (!data) return Channel(NO_CHANNEL, 0);
+    if (!data) return Channel();
 
     Channel channel = allocate_channel();
     
@@ -133,8 +133,8 @@ Gosu::Channel Gosu::Sample::play_pan(double pan, double volume, double speed, bo
 
 class Gosu::Song::BaseData
 {
-    BaseData(const BaseData&);
-    BaseData& operator=(const BaseData&);
+    BaseData(const BaseData&) = delete;
+    BaseData& operator=(const BaseData&) = delete;
     
     double volume_;
 
@@ -169,7 +169,7 @@ class Gosu::Song::ModuleData : public BaseData
 {
     AVAudioPlayer* player;
     
-    void apply_volume()
+    void apply_volume() override
     {
         player.volume = volume();
     }
@@ -203,7 +203,7 @@ public:
     bool paused() const override
     {
         return !player.playing;
-    };
+    }
     
     void stop() override
     {

data/src/AudioImpl.cpp

@@ -72,7 +72,7 @@ Gosu::Channel Gosu::allocate_channel()
     }
 
     // No free channel, return an object that is immediately expired.
-    return Channel(NO_CHANNEL, 0);
+    return Channel();
 }
 
 bool Gosu::channel_expired(int channel, int token)
@@ -82,7 +82,7 @@ bool Gosu::channel_expired(int channel, int token)
 
 ALuint Gosu::al_source_for_channel(int channel)
 {
-    if (channel <= 0 || channel >= CHANNELS) {
+    if (channel < 0 || channel >= CHANNELS) {
         throw invalid_argument("No such channel: " + to_string(channel));
     }
     return _sources[channel];

data/src/Bitmap.cpp

@@ -13,8 +13,7 @@ void Gosu::Bitmap::swap(Bitmap& other)
 
 void Gosu::Bitmap::resize(unsigned width, unsigned height, Color c)
 {
-    if (width == w && height == h)
-        return;
+    if (width == w && height == h) return;
 
     Bitmap temp(width, height, c);
     temp.insert(*this, 0, 0);

data/src/BitmapIO.cpp

@@ -9,8 +9,18 @@
 #define STBI_NO_STDIO
 #define STBI_NO_LINEAR
 
+// Disable comma warnings in stb headers.
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcomma"
+#endif
+
 #include "stb_image.h"
 
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
 using namespace std;
 
 namespace
@@ -80,9 +90,19 @@ void Gosu::load_image_file(Gosu::Bitmap& bitmap, Reader input)
     }
 }
 
+// Disable comma warnings in stb headers.
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcomma"
+#endif
+
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "stb_image_write.h"
 
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
 void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const string& filename)
 {
     int ok;
@@ -102,8 +122,7 @@ void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const string& filename)
 
 static void stbi_write_to_writer(void* context, void* data, int size)
 {
-    Gosu::Writer* writer = reinterpret_cast<Gosu::Writer*>(context);
-    writer->write(data, size);
+    reinterpret_cast<Gosu::Writer*>(context)->write(data, size);
 }
 
 void Gosu::save_image_file(const Gosu::Bitmap& bitmap, Gosu::Writer writer,

data/src/BlockAllocator.cpp

@@ -111,7 +111,7 @@ bool Gosu::BlockAllocator::alloc(unsigned a_width, unsigned a_height, Block& b)
 
 void Gosu::BlockAllocator::block(unsigned left, unsigned top, unsigned width, unsigned height)
 {
-    pimpl->blocks.push_back(Block(left, top, width, height));
+    pimpl->blocks.emplace_back(left, top, width, height);
 }
 
 void Gosu::BlockAllocator::free(unsigned left, unsigned top, unsigned width, unsigned height)

data/src/Channel.cpp

@@ -3,7 +3,8 @@
 using namespace std;
 
 // Returns the current state of a source
-static ALint state(int& channel) {
+static ALint state(int& channel)
+{
     ALint state;
     alGetSourcei(Gosu::al_source_for_channel(channel), AL_SOURCE_STATE, &state);
     if (state != AL_PLAYING && state != AL_PAUSED) {
@@ -12,6 +13,11 @@ static ALint state(int& channel) {
     return state;
 }
 
+Gosu::Channel::Channel()
+: channel(NO_CHANNEL), token(0)
+{
+}
+
 Gosu::Channel::Channel(int channel, int token)
 : channel(channel), token(token)
 {

data/src/ClipRectStack.hpp

@@ -40,7 +40,10 @@ class Gosu::ClipRectStack
         // TODO: Doesn't this affect Retina Macs as well?
         // TODO: This should be handled by a global transform.
         int fac = clip_rect_base_factor();
-        result.x *= fac, result.y *= fac, result.width *= fac, result.height *= fac;
+        result.x *= fac;
+        result.y *= fac;
+        result.width *= fac;
+        result.height *= fac;
         
         // Normal clipping.
         effective_rect     = result;

data/src/Color.cpp

@@ -1,5 +1,6 @@
 #include <Gosu/Color.hpp>
 #include <Gosu/Math.hpp>
+#include <cmath>
 #include <algorithm>
 
 namespace
@@ -61,7 +62,7 @@ Gosu::Color Gosu::Color::from_ahsv(Channel alpha, double h, double s, double v)
     s = clamp(s, 0.0, 1.0);
     v = clamp(v, 0.0, 1.0);
     
-    int sector       = h / 60;
+    int sector = static_cast<int>(h / 60);
     double factorial = h / 60 - sector;
     
     double p = v * (1 - s);

data/src/DirectoriesWin.cpp

@@ -46,7 +46,7 @@ string Gosu::resource_prefix()
     if (result.empty()) {
         result = exe_filename();
         auto last_delim = result.find_last_of("\\/");
-        result.resize(last_delim == result.npos ? 0 : last_delim + 1);
+        result.resize(last_delim == string::npos ? 0 : last_delim + 1);
     }
     return result;
 }

data/src/DrawOp.hpp

@@ -147,10 +147,14 @@ namespace Gosu
             RenderState va_render_state = render_state;
             va_render_state.transform   = 0;
             
-            result[0].tex_coords[0] = left,  result[0].tex_coords[1] = top;
-            result[1].tex_coords[0] = right, result[1].tex_coords[1] = top;
-            result[2].tex_coords[0] = right, result[2].tex_coords[1] = bottom;
-            result[3].tex_coords[0] = left,  result[3].tex_coords[1] = bottom;
+            result[0].tex_coords[0] = left;
+            result[0].tex_coords[1] = top;
+            result[1].tex_coords[0] = right;
+            result[1].tex_coords[1] = top;
+            result[2].tex_coords[0] = right;
+            result[2].tex_coords[1] = bottom;
+            result[3].tex_coords[0] = left;
+            result[3].tex_coords[1] = bottom;
             
             if (vas.empty() || !(vas.back().render_state == va_render_state)) {
                 vas.push_back(VertexArray());

data/src/DrawOpQueue.hpp

@@ -15,32 +15,25 @@ class Gosu::DrawOpQueue
 {
     TransformStack transform_stack;
     ClipRectStack clip_rect_stack;
-    bool rec;
+    QueueMode queue_mode = QM_RENDER_TO_SCREEN;
 
     std::vector<DrawOp> ops;
     std::vector<std::function<void ()>> gl_blocks;
 
 public:
-    DrawOpQueue()
-    : rec(false)
+    DrawOpQueue(QueueMode mode)
+    : queue_mode(mode)
     {
     }
     
-    bool recording() const
+    QueueMode mode() const
     {
-        return rec;
-    }
-    
-    void set_recording()
-    {
-        rec = true;
+        return queue_mode;
     }
     
     void schedule_draw_op(DrawOp op)
     {
-        if (clip_rect_stack.clipped_world_away()) {
-            return;
-        }
+        if (clip_rect_stack.clipped_world_away()) return;
 
     #ifdef GOSU_IS_OPENGLES
         // No triangles, no lines supported
@@ -57,9 +50,7 @@ public:
     void gl(std::function<void ()> gl_block, ZPos z)
     {
         // TODO: Document this case: Clipped-away GL blocks are *not* being run.
-        if (clip_rect_stack.clipped_world_away()) {
-            return;
-        }
+        if (clip_rect_stack.clipped_world_away()) return;
 
         int complement_of_block_index = ~(int)gl_blocks.size();
         gl_blocks.push_back(gl_block);
@@ -76,7 +67,7 @@ public:
 
     void begin_clipping(double x, double y, double width, double height, double screen_height)
     {
-        if (recording()) {
+        if (mode() == QM_RECORD_MACRO) {
             throw std::logic_error("Clipping is not allowed while creating a macro");
         }
         
@@ -119,9 +110,9 @@ public:
         transform_stack.pop();
     }
 
-    void perform_draw_ops_andCode()
+    void perform_draw_ops_and_code()
     {
-        if (recording()) {
+        if (mode() == QM_RECORD_MACRO) {
             throw std::logic_error("Flushing to the screen is not allowed while recording a macro");
         }
         
@@ -131,9 +122,7 @@ public:
         RenderStateManager manager;
         
     #ifdef GOSU_IS_OPENGLES
-        if (ops.empty()) {
-            return;
-        }
+        if (ops.empty()) return;
 
         auto current = ops.begin(), last = ops.end() - 1;
         for (; current != last; ++current) {
@@ -141,12 +130,12 @@ public:
             current->perform(&*(current + 1));
         }
         manager.set_render_state(last->render_state);
-        last->perform(0);
+        last->perform(nullptr);
     #else
         for (const auto& op : ops) {
             manager.set_render_state(op.render_state);
             if (op.vertices_or_block_index >= 0) {
-                op.perform(0);
+                op.perform(nullptr);
             }
             else {
                 // GL code

data/src/FileUnix.cpp

@@ -44,6 +44,8 @@ Gosu::File::File(const string& filename, FileMode mode)
     case FM_ALTER:
         flags = O_RDWR | O_CREAT;
         break;
+    default:
+        throw invalid_argument("Unknown file mode: " + to_string(mode));
     }
 
     // TODO: Locking flags?
@@ -66,7 +68,7 @@ Gosu::File::~File()
 size_t Gosu::File::size() const
 {
     // TODO: Error checking?
-    return lseek(pimpl->fd, 0, SEEK_END);
+    return static_cast<size_t>(lseek(pimpl->fd, 0, SEEK_END));
 }
 
 void Gosu::File::resize(size_t new_size)

data/src/Font.cpp

@@ -1,4 +1,4 @@
-#include "FormattedString.hpp"
+#include "MarkupParser.hpp"
 #include "GraphicsImpl.hpp"
 #include <Gosu/Font.hpp>
 #include <Gosu/Graphics.hpp>
@@ -6,129 +6,119 @@
 #include <Gosu/Math.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
+#include "utf8proc.h"
 #include <array>
 #include <cassert>
 #include <map>
 using namespace std;
 
+static const int FONT_RENDER_SCALE = 2;
+
 struct Gosu::Font::Impl
 {
     string name;
-    unsigned height, flags;
+    int height;
+    unsigned base_flags;
 
-    // Unicode planes of 2^16 characters each. On Windows, where wchar_t is only 16 bits wide, only
-    // the first plane will ever be touched.
-    struct CharInfo
-    {
-        unique_ptr<Image> image;
-        double factor;
-    };
-    typedef array<CharInfo, 65536> Plane;
-    unique_ptr<Plane> planes[16][FF_COMBINATIONS];
-    
-    map<string, shared_ptr<Image>> entity_cache;
+    // The most common characters are stored directly in an array for maximum performance.
+    // (This is the start of the Basic Multilingual Plane, up until the part where right-to-left
+    // languages begin, which don't really work with Gosu yet.)
+    array<array<Image, 0x58f>, FF_COMBINATIONS> fast_glyphs;
+    // Everything else is looked up through a map...
+    array<map<utf8proc_int32_t, Image>, FF_COMBINATIONS> other_glyphs;
     
-    CharInfo& char_info(wchar_t wc, unsigned flags)
+    const Image& image(char32_t codepoint, unsigned font_flags)
     {
-        size_t plane_index = wc / 65536;
-        size_t char_index  = wc % 65536;
-        
-        if (plane_index >= 16) throw invalid_argument("Unicode plane out of reach");
-        if (flags >= FF_COMBINATIONS) throw invalid_argument("Font flags out of range");
-        
-        if (!planes[plane_index][flags].get()) {
-            planes[plane_index][flags].reset(new Plane);
+        Image* image;
+        if (codepoint < fast_glyphs.size()) {
+            image = &fast_glyphs[font_flags][codepoint];
         }
-        return (*planes[plane_index][flags])[char_index];
-    }
-    
-    const Image& image_at(const FormattedString& fs, unsigned i)
-    {
-        if (const char* entity = fs.entity_at(i)) {
-            shared_ptr<Image>& ptr = entity_cache[entity];
-            if (!ptr) {
-                ptr.reset(new Image(entity_bitmap(fs.entity_at(i)), IF_SMOOTH));
-            }
-            return *ptr;
+        else {
+            image = &other_glyphs[font_flags][codepoint];
         }
         
-        wchar_t wc     = fs.char_at(i);
-        unsigned flags = fs.flags_at(i);
-        CharInfo& info = char_info(wc, flags);
-        
-        if (info.image.get()) return *info.image;
-        
-        string char_string = wstring_to_utf8(wstring(1, wc));
-        // TODO: Would be nice to have.
-        // if (is_formatting_char(wc))
-        //     char_string.clear();
-        unsigned char_width = Gosu::text_width(char_string, name, height, flags);
+        // If this codepoint has not been rendered before, do it now.
+        if (image->width() == 0 && image->height() == 0) {
+            auto scaled_height = height * FONT_RENDER_SCALE;
+            
+            u32string string(1, codepoint);
+            Bitmap bitmap(scaled_height, scaled_height);
+            auto required_width = ceil(draw_text(bitmap, 0, 0, Color::WHITE, string,
+                                                 name, scaled_height, font_flags));
+            if (required_width > bitmap.width()) {
+                // If the character was wider than high, we need to render it again.
+                Bitmap(required_width, scaled_height).swap(bitmap);
+                draw_text(bitmap, 0, 0, Color::WHITE, string,
+                          name, scaled_height, font_flags);
+            }
+            
+            *image = Image(bitmap, 0, 0, required_width, scaled_height);
+        }
         
-        Bitmap bitmap(char_width, height, 0x00ffffff);
-        draw_text(bitmap, char_string, 0, 0, Color::WHITE, name, height, flags);
-        info.image.reset(new Image(bitmap));
-        info.factor = 0.5;
-        return *info.image;
-    }
-    
-    double factor_at(const FormattedString& fs, unsigned index)
-    {
-        if (fs.entity_at(index)) return 1;
-        return char_info(fs.char_at(index), fs.flags_at(index)).factor;
+        return *image;
     }
 };
 
-Gosu::Font::Font(unsigned font_height, const string& font_name, unsigned font_flags)
+Gosu::Font::Font(int font_height, const string& font_name, unsigned font_flags)
 : pimpl(new Impl)
 {
     pimpl->name = font_name;
-    pimpl->height = font_height * 2;
-    pimpl->flags = font_flags;
+    pimpl->height = font_height;
+    pimpl->base_flags = font_flags;
 }
 
-string Gosu::Font::name() const
+const string& Gosu::Font::name() const
 {
     return pimpl->name;
 }
 
-unsigned Gosu::Font::height() const
+int Gosu::Font::height() const
 {
-    return pimpl->height / 2;
+    return pimpl->height;
 }
 
 unsigned Gosu::Font::flags() const
 {
-    return pimpl->flags;
+    return pimpl->base_flags;
 }
 
 double Gosu::Font::text_width(const string& text, double scale_x) const
 {
-    wstring wtext = utf8_to_wstring(text);
-    FormattedString fs(wtext.c_str(), flags());
-    double result = 0;
-    for (unsigned i = 0; i < fs.length(); ++i) {
-        const Image& image = pimpl->image_at(fs, i);
-        double factor = pimpl->factor_at(fs, i);
-        result += image.width() * factor;
-    }
-    return result * scale_x;
+    int width = 0;
+
+    // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
+    MarkupParser(text.c_str(), pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
+        int line_width = 0;
+        for (auto& part : line) {
+            for (auto codepoint : part.text) {
+                line_width += pimpl->image(codepoint, part.flags).width();
+            }
+        }
+        width = max(width, line_width);
+    }).parse();
+    
+    return scale_x * width / FONT_RENDER_SCALE;
 }
 
 void Gosu::Font::draw(const string& text, double x, double y, ZPos z,
     double scale_x, double scale_y, Color c, AlphaMode mode) const
 {
-    wstring wtext = utf8_to_wstring(text);
-    FormattedString fs(wtext.c_str(), flags());
+    double current_y = y;
     
-    for (unsigned i = 0; i < fs.length(); ++i) {
-        const Image& image = pimpl->image_at(fs, i);
-        double factor = pimpl->factor_at(fs, i);
-        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;
-    }
+    // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
+    MarkupParser(text.c_str(), pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
+        double current_x = x;
+        for (auto& part : line) {
+            for (auto codepoint : part.text) {
+                auto& image = pimpl->image(codepoint, part.flags);
+                image.draw(current_x, current_y, z,
+                           scale_x / FONT_RENDER_SCALE, scale_y / FONT_RENDER_SCALE,
+                           c, mode);
+                current_x += scale_x * image.width() / FONT_RENDER_SCALE;
+            }
+        }
+        current_y += scale_y * height();
+    }).parse();
 }
 
 void Gosu::Font::draw_rel(const string& text, double x, double y, ZPos z,
@@ -140,25 +130,31 @@ void Gosu::Font::draw_rel(const string& text, double x, double y, ZPos z,
     draw(text, x, y, z, scale_x, scale_y, c, mode);
 }
 
-void Gosu::Font::set_image(wchar_t wc, const Image& image)
+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
 {
-    for (unsigned flags = 0; flags < FF_COMBINATIONS; ++flags) {
-        set_image(wc, flags, image);
-    }
+    Graphics::transform(rotate(angle, x, y), [&] {
+        draw(text, x, y, z, scale_x, scale_y, c, mode);
+    });
 }
 
-void Gosu::Font::set_image(wchar_t wc, unsigned font_flags, const Image& image)
+void Gosu::Font::set_image(std::string codepoint, unsigned font_flags, const Gosu::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 Image(image));
-    ci.factor = 1.0;
+    auto utc4 = utf8_to_composed_utc4(codepoint);
+    if (utc4.length() != 1) {
+        throw invalid_argument("Could not compose '" + codepoint + "' into a single codepoint");
+    }
+    
+    if (utc4[0] < pimpl->fast_glyphs[font_flags].size()) {
+        pimpl->fast_glyphs[font_flags][utc4[0]] = image;
+    } else {
+        pimpl->other_glyphs[font_flags][utc4[0]] = image;
+    }
 }
 
-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
+void Gosu::Font::set_image(std::string codepoint, const Gosu::Image& image)
 {
-    Graphics::transform(rotate(angle, x, y), [&] {
-        draw(text, x, y, z, scale_x, scale_y, c, mode);
-    });
+    for (unsigned font_flags = 0; font_flags < FF_COMBINATIONS; ++font_flags) {
+        set_image(codepoint, font_flags, image);
+    }
 }