gosu 1.1.0 → 1.4.0

data/src/RubyGosu.h

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.1.0
+ * Version 4.0.2
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -28,7 +28,7 @@ public:
 class SwigDirector_Window : public Gosu::Window, public Swig::Director {
 
 public:
-    SwigDirector_Window(VALUE self,int width,int height,unsigned int window_flags=Gosu::WF_WINDOWED,double update_interval=16.666666);
+    SwigDirector_Window(VALUE self, int width, int height, unsigned int window_flags = Gosu::WF_WINDOWED, double update_interval = 16.666666);
     virtual ~SwigDirector_Window();
     virtual void show();
     virtual bool tick();
@@ -37,6 +37,7 @@ public:
     virtual void draw();
     virtual bool needs_redraw() const;
     virtual bool needs_cursor() const;
+    virtual void gain_focus();
     virtual void lose_focus();
     virtual void release_memory();
     virtual void button_down(Gosu::Button arg0);

data/src/TexChunk.cpp

@@ -1,57 +1,66 @@
 #include "TexChunk.hpp"
-#include "DrawOpQueue.hpp"
-#include "Texture.hpp"
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
+#include "DrawOpQueue.hpp"
+#include "Texture.hpp"
 #include <stdexcept>
 
-using namespace std;
-
 void Gosu::TexChunk::set_tex_info()
 {
-    double width = texture->width(), height = texture->height();
+    double width = m_texture->width(), height = m_texture->height();
 
-    info.tex_name = texture->tex_name();
-    info.left   = x / width;
-    info.top    = y / height;
-    info.right  = (x + w) / width;
-    info.bottom = (y + h) / height;
+    m_info.tex_name = m_texture->tex_name();
+    m_info.left = m_x / width;
+    m_info.top = m_y / height;
+    m_info.right = (m_x + m_w) / width;
+    m_info.bottom = (m_y + m_h) / height;
 }
 
-Gosu::TexChunk::TexChunk(shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
-: texture(move(texture)), x(x), y(y), w(w), h(h), padding(padding)
+Gosu::TexChunk::TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
+: m_texture{move(texture)},
+  m_x{x},
+  m_y{y},
+  m_w{w},
+  m_h{h},
+  m_padding{padding}
 {
     set_tex_info();
 }
 
 Gosu::TexChunk::TexChunk(const TexChunk& parent, int x, int y, int w, int h)
-: texture(parent.texture), x(parent.x + x), y(parent.y + y), w(w), h(h), padding(0)
+: m_texture{parent.m_texture},
+  m_x{parent.m_x + x},
+  m_y{parent.m_y + y},
+  m_w{w},
+  m_h{h},
+  m_padding{0}
 {
-    if (x < 0 || y < 0 || x + w > parent.w || y + h > parent.h) {
-        throw invalid_argument("subimage bounds exceed those of its parent");
+    if (x < 0 || y < 0 || x + w > parent.m_w || y + h > parent.m_h) {
+        throw std::invalid_argument{"subimage bounds exceed those of its parent"};
     }
     if (w <= 0 || h <= 0) {
-        throw invalid_argument("cannot create empty image");
+        throw std::invalid_argument{"cannot create empty image"};
     }
-    
+
     set_tex_info();
-    texture->block(this->x, this->y, this->w, this->h);
+    m_texture->block(m_x, m_y, m_w, m_h);
 }
 
 Gosu::TexChunk::~TexChunk()
 {
-    texture->free(x - padding, y - padding, w + 2 * padding, h + 2 * padding);
+    m_texture->free(m_x - m_padding, m_y - m_padding, m_w + 2 * m_padding, m_h + 2 * m_padding);
 }
 
-void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
-    double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z, AlphaMode mode) const
+void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2, Color c2, //
+                          double x3, double y3, Color c3, double x4, double y4, Color c4, //
+                          ZPos z, BlendMode mode) const
 {
     DrawOp op;
-    op.render_state.texture = texture;
+    op.render_state.texture = m_texture;
     op.render_state.mode = mode;
-    
+
     normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
-    
+
     op.vertices_or_block_index = 4;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
@@ -63,34 +72,34 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2,
     op.vertices[3] = DrawOp::Vertex(x3, y3, c3);
     op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
 #endif
-    op.left = info.left;
-    op.top = info.top;
-    op.right = info.right;
-    op.bottom = info.bottom;
-    
+    op.left = m_info.left;
+    op.top = m_info.top;
+    op.right = m_info.right;
+    op.bottom = m_info.bottom;
+
     op.z = z;
     Graphics::schedule_draw_op(op);
 }
 
-unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
 {
-    return unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
+    return std::unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
 }
 
 Gosu::Bitmap Gosu::TexChunk::to_bitmap() const
 {
-    return texture->to_bitmap(x, y, w, h);
+    return m_texture->to_bitmap(m_x, m_y, m_w, m_h);
 }
 
 void Gosu::TexChunk::insert(const Bitmap& original_bitmap, int x, int y)
 {
     Bitmap clipped_bitmap;
     const Bitmap* bitmap = &original_bitmap;
-    
+
     // If inserting the bitmap at the given position exceeds the boundaries of the space allocated
     // for this image on the texture, we need to clip the bitmap and insert the clipped version
     // instead.
-    if (x < 0 || y < 0 || x + original_bitmap.width() > w || y + original_bitmap.height() > h) {
+    if (x < 0 || y < 0 || x + original_bitmap.width() > m_w || y + original_bitmap.height() > m_h) {
         // How many pixels to remove at the top and left sides.
         int clip_left = 0, clip_top = 0;
         // How large the clipped version needs to be.
@@ -109,22 +118,22 @@ void Gosu::TexChunk::insert(const Bitmap& original_bitmap, int x, int y)
             y = 0;
         }
         // Clip away pixels on the right side, if necessary.
-        if (x + clipped_width > w) {
-            clipped_width = (w - x);
+        if (x + clipped_width > m_w) {
+            clipped_width = (m_w - x);
         }
         // Clip away pixels on the bottom, if necessary.
-        if (y + clipped_height > h) {
-            clipped_height = (h - y);
+        if (y + clipped_height > m_h) {
+            clipped_height = (m_h - y);
         }
 
         if (clipped_width <= 0 || clipped_height <= 0) return;
-        
+
         clipped_bitmap.resize(clipped_width, clipped_height);
         clipped_bitmap.insert(-clip_left, -clip_top, original_bitmap);
         bitmap = &clipped_bitmap;
     }
-    
+
     glBindTexture(GL_TEXTURE_2D, tex_name());
-    glTexSubImage2D(GL_TEXTURE_2D, 0, this->x + x, this->y + y, bitmap->width(), bitmap->height(),
+    glTexSubImage2D(GL_TEXTURE_2D, 0, m_x + x, m_y + y, bitmap->width(), bitmap->height(),
                     Color::GL_FORMAT, GL_UNSIGNED_BYTE, bitmap->data());
 }

data/src/TexChunk.hpp

@@ -1,41 +1,41 @@
 #pragma once
 
-#include "GraphicsImpl.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
+#include "GraphicsImpl.hpp"
 #include <memory>
 #include <stdexcept>
 
 class Gosu::TexChunk : public Gosu::ImageData
 {
-    std::shared_ptr<Texture> texture;
-    int x, y, w, h, padding;
-    
-    GLTexInfo info;
-    
+    std::shared_ptr<Texture> m_texture;
+    int m_x, m_y, m_w, m_h, m_padding;
+
+    GLTexInfo m_info;
+
     void set_tex_info();
-    
+
 public:
     TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
     TexChunk(const TexChunk& parent, int x, int y, int w, int h);
     ~TexChunk() override;
 
-    int width() const override  { return w; }
-    int height() const override { return h; }
-    
-    GLuint tex_name() const { return info.tex_name; }
-    
-    void draw(double x1, double y1, Color c1,
-        double x2, double y2, Color c2,
-        double x3, double y3, Color c3,
-        double x4, double y4, Color c4,
-        ZPos z, AlphaMode mode) const override;
-
-    const GLTexInfo* gl_tex_info() const override { return &info; }
-    
+    int width() const override { return m_w; }
+    int height() const override { return m_h; }
+
+    GLuint tex_name() const { return m_info.tex_name; }
+
+    void draw(double x1, double y1, Color c1, //
+              double x2, double y2, Color c2, //
+              double x3, double y3, Color c3, //
+              double x4, double y4, Color c4, //
+              ZPos z, BlendMode mode) const override;
+
+    const GLTexInfo* gl_tex_info() const override { return &m_info; }
+
     std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
-    
+
     Gosu::Bitmap to_bitmap() const override;
-    
+
     void insert(const Bitmap& bitmap, int x, int y) override;
 };

data/src/Text.cpp

@@ -1,95 +1,94 @@
+#include <Gosu/Text.hpp>
+#include "GraphicsImpl.hpp"
 #include "MarkupParser.hpp"
 #include "TextBuilder.hpp"
-#include "GraphicsImpl.hpp"
 #include "TrueTypeFont.hpp"
-#include <Gosu/Text.hpp>
-#include <cassert>
-#include <cmath>
 #include <algorithm>
-#include <vector>
+#include <cmath>
 #include <stdexcept>
-using namespace std;
+#include <vector>
 
-double Gosu::text_width(const u32string& text,
-                        const string& font_name, double font_height, unsigned font_flags)
+double Gosu::text_width(const std::u32string& text, //
+                        const std::string& font_name, double font_height, unsigned font_flags)
 {
-    if (font_height <= 0)              throw invalid_argument("font_height must be > 0");
-    if (font_flags >= FF_COMBINATIONS) throw invalid_argument("Invalid font_flags");
-    
-    auto& font = font_by_name(font_name, font_flags);
+    if (font_height <= 0) throw std::invalid_argument{"font_height must be > 0"};
+    if (font_flags >= FF_COMBINATIONS) throw std::invalid_argument{"Invalid font_flags"};
+
+    TrueTypeFont& font = font_by_name(font_name, font_flags);
     return font.draw_text(text, font_height, nullptr, 0, 0, Gosu::Color::NONE);
 }
 
-double Gosu::draw_text(Bitmap& bitmap, double x, double y, Color c, const u32string& text,
-                       const string& font_name, double font_height, unsigned font_flags)
+double Gosu::draw_text(Bitmap& bitmap, double x, double y, Color c, const std::u32string& text,
+                       const std::string& font_name, double font_height, unsigned font_flags)
 {
-    if (font_height <= 0)              throw invalid_argument("font_height must be > 0");
-    if (font_flags >= FF_COMBINATIONS) throw invalid_argument("Invalid font_flags");
+    if (font_height <= 0) throw std::invalid_argument("font_height must be > 0");
+    if (font_flags >= FF_COMBINATIONS) throw std::invalid_argument("Invalid font_flags");
 
-    auto& font = font_by_name(font_name, font_flags);
+    TrueTypeFont& font = font_by_name(font_name, font_flags);
     return font.draw_text(text, font_height, &bitmap, x, y, c);
 }
 
-Gosu::Bitmap Gosu::layout_text(const string& text, const string& font_name,
-                               double font_height, double line_spacing,
-                               int width, Alignment align, unsigned font_flags)
+Gosu::Bitmap Gosu::layout_text(const std::string& text, const std::string& font_name, //
+                               double font_height, double line_spacing, int width,    //
+                               Alignment align, unsigned font_flags)
 {
     // Escape all markup and delegate to layout_markup.
-    return layout_markup(escape_markup(text), font_name,
-                         font_height, line_spacing,
-                         width, align, font_flags);
+    return layout_markup(escape_markup(text), font_name, font_height, line_spacing, width, align,
+                         font_flags);
 }
 
-Gosu::Bitmap Gosu::layout_markup(const string& markup, const string& font_name,
-                                 double font_height, double line_spacing,
-                                 int width, Alignment align, unsigned font_flags)
+Gosu::Bitmap Gosu::layout_markup(const std::string& markup, const std::string& font_name, //
+                                 double font_height, double line_spacing, int width,      //
+                                 Alignment align, unsigned font_flags)
 {
-    if (font_height <= 0)              throw invalid_argument("font_height must be > 0");
-    if (line_spacing < -font_height)   throw invalid_argument("line_spacing must be ≥ -font_height");
-    if (font_flags >= FF_COMBINATIONS) throw invalid_argument("Invalid font_flags");
-    
+    if (font_height <= 0) throw std::invalid_argument{"font_height must be > 0"};
+    if (line_spacing < -font_height) throw std::invalid_argument{"line_spacing < -font_height"};
+    if (font_flags >= FF_COMBINATIONS) throw std::invalid_argument{"Invalid font_flags"};
+
     if (width >= 0) {
-        TextBuilder text_builder(font_name, font_height, line_spacing, width, align);
-        
+        TextBuilder text_builder{font_name, static_cast<int>(font_height),
+                                 static_cast<int>(line_spacing), width, align};
+
         // Feed all formatted substrings to the TextBuilder, which will construct the result.
         // Split the input string into words, because this method implements word-wrapping.
-        MarkupParser parser(font_flags, true, [&text_builder](vector<FormattedString> word) {
-            text_builder.feed_word(move(word));
-        });
+        MarkupParser parser{font_flags, true, [&text_builder](std::vector<FormattedString> word) {
+                                text_builder.feed_word(move(word));
+                            }};
         parser.parse(markup);
-        
-        return text_builder.move_into_bitmap();
+
+        return std::move(text_builder).move_into_bitmap();
     }
     else {
-        vector<vector<FormattedString>> lines;
-        
+        std::vector<std::vector<FormattedString>> lines;
+
         // Split the text into lines (split_words = false) since this method does not wrap lines.
-        MarkupParser parser(font_flags, false, [&lines](vector<FormattedString>&& line) {
-            // Remove trailing \n characters from each line to avoid errors from Gosu::text_width().
-            if (line.back().text.back() == '\n') {
-                line.back().text.pop_back();
-            }
-            
-            lines.emplace_back(line);
-        });
+        MarkupParser parser{font_flags, false, [&lines](std::vector<FormattedString>&& line) {
+                                // Remove trailing \n characters from each line to avoid errors from
+                                // Gosu::text_width().
+                                if (!line.back().text.empty() && line.back().text.back() == '\n') {
+                                    line.back().text.pop_back();
+                                }
+
+                                lines.emplace_back(line);
+                            }};
         parser.parse(markup);
-        
+
         if (lines.empty()) return Bitmap();
-        
+
         // Measure every part of every line.
-        vector<double> line_widths;
+        std::vector<double> line_widths;
         double max_width = 0;
         for (auto& line : lines) {
             line_widths.push_back(0);
             for (auto& part : line) {
                 line_widths.back() += text_width(part.text, font_name, font_height, part.flags);
             }
-            max_width = max(max_width, line_widths.back());
+            max_width = std::max(max_width, line_widths.back());
         }
-        
-        double height = lines.size() * font_height + (lines.size() - 1) * line_spacing;
-        Bitmap result(ceil(max_width), ceil(height));
-        
+
+        double height = lines.size() * font_height + (lines.size() - 1.0) * line_spacing;
+        Bitmap result{static_cast<int>(std::ceil(max_width)), static_cast<int>(std::ceil(height))};
+
         // Render every part of every line.
         double y = 0;
         for (int i = 0; i < lines.size(); ++i) {
@@ -100,14 +99,14 @@ Gosu::Bitmap Gosu::layout_markup(const string& markup, const string& font_name,
             else if (align == AL_RIGHT) {
                 x = result.width() - line_widths[i];
             }
-            
+
             for (auto& part : lines[i]) {
-                x = draw_text(result, x, y, part.color, part.text,
-                              font_name, font_height, part.flags);
+                x = draw_text(result, x, y, part.color, part.text, font_name, font_height,
+                              part.flags);
             }
             y += (font_height + line_spacing);
         }
-        
+
         return result;
     }
 }

data/src/TextBuilder.cpp

@@ -1,17 +1,15 @@
 #include "TextBuilder.hpp"
 #include <Gosu/Text.hpp>
-
-#include <utf8proc.h>
-
 #include <cassert>
 #include <cmath>
-using namespace std;
+#include <utf8proc.h>
 
-Gosu::WordInfo::WordInfo(const string& font_name, double font_height, vector<FormattedString> parts)
+Gosu::WordInfo::WordInfo(const std::string& font_name, double font_height,
+                         std::vector<FormattedString> parts)
 {
-    assert (!parts.empty());
-    
-    auto* properties = utf8proc_get_property(parts.front().text.front());
+    assert(!parts.empty());
+
+    const auto* properties = utf8proc_get_property(parts.front().text.front());
 
     // Also check the BiDi class to filter out non-breaking spaces.
     is_whitespace = properties->category == UTF8PROC_CATEGORY_ZS &&
@@ -20,119 +18,124 @@ Gosu::WordInfo::WordInfo(const string& font_name, double font_height, vector<For
     is_end_of_line = parts.back().text.back() == '\n';
     // Remove the trailing backspace character to avoid errors from Gosu::text_width().
     if (is_end_of_line) parts.back().text.pop_back();
-    
+
     width = 0;
     for (const auto& part : parts) {
-        assert (is_end_of_line || !part.text.empty());
-        
+        assert(is_end_of_line || !part.text.empty());
+
         width += text_width(part.text, font_name, font_height, part.flags);
     }
-    
+
     this->parts = move(parts);
 }
 
 void Gosu::TextBuilder::flush_current_line(EndOfLineReason reason)
 {
-    if (current_line.empty()) {
+    if (m_current_line.empty()) {
         if (reason == END_OF_PARAGRAPH) allocate_next_line();
         return;
     }
-    
+
     allocate_next_line();
-    
+
     // Remove trailing whitespace so that justifying the text across the line works.
-    if (current_line.back().is_whitespace) current_line.pop_back();
-    
+    if (m_current_line.back().is_whitespace) m_current_line.pop_back();
+
     // Shouldn't happen because the first word on a line should never be whitespace.
-    assert (!current_line.empty());
-    
+    assert(!m_current_line.empty());
+
     double words_width = 0, whitespace_width = 0;
-    for (const auto& word : current_line) {
+    for (const auto& word : m_current_line) {
         (word.is_whitespace ? whitespace_width : words_width) += word.width;
     }
-    
+
     double x = 0;
-    if (align == AL_RIGHT) {
-        x = result.width() - words_width - whitespace_width;
+    if (m_align == AL_RIGHT) {
+        x = m_result.width() - words_width - whitespace_width;
     }
-    else if (align == AL_CENTER) {
-        x = (result.width() - words_width - whitespace_width) / 2.0;
+    else if (m_align == AL_CENTER) {
+        x = (m_result.width() - words_width - whitespace_width) / 2.0;
     }
-    
+
     double whitespace_factor = 1.0;
-    if (align == AL_JUSTIFY && whitespace_width != 0 && reason == LINE_TOO_LONG) {
-        whitespace_factor = (result.width() - words_width) / whitespace_width;
+    if (m_align == AL_JUSTIFY && whitespace_width != 0 && reason == LINE_TOO_LONG) {
+        whitespace_factor = (m_result.width() - words_width) / whitespace_width;
     }
-    
-    double y = (used_lines - 1) * (font_height + line_spacing);
-    
-    for (const auto& word : current_line) {
+
+    double y = (m_used_lines - 1) * (m_font_height + m_line_spacing);
+
+    for (const auto& word : m_current_line) {
         if (word.is_whitespace) {
             x += word.width * whitespace_factor;
         }
         else {
             for (const auto& part : word.parts) {
-                draw_text(result, x, y, part.color, part.text, font_name, font_height, part.flags);
+                draw_text(m_result, x, y, part.color, part.text, m_font_name, m_font_height,
+                          part.flags);
             }
             x += word.width;
         }
     }
-    
-    current_line.clear();
-    current_line_width = 0;
+
+    m_current_line.clear();
+    m_current_line_width = 0;
 }
 
 void Gosu::TextBuilder::allocate_next_line()
 {
-    if (used_lines == allocated_lines) {
-        allocated_lines += 10;
+    if (m_used_lines == m_allocated_lines) {
+        m_allocated_lines += 10;
         resize_to_allocated_lines();
     }
-    
-    ++used_lines;
+
+    ++m_used_lines;
 }
 
 void Gosu::TextBuilder::resize_to_allocated_lines()
 {
-    double new_height = font_height * allocated_lines + line_spacing * max(0, allocated_lines - 1);
-    result.resize(result.width(), ceil(new_height));
+    double new_height =
+            m_font_height * m_allocated_lines + m_line_spacing * std::max(0, m_allocated_lines - 1);
+    m_result.resize(m_result.width(), ceil(new_height));
 }
 
-Gosu::TextBuilder::TextBuilder(const string& font_name, int font_height, int line_spacing,
+Gosu::TextBuilder::TextBuilder(const std::string& font_name, int font_height, int line_spacing,
                                int width, Alignment align)
-: font_name(font_name), font_height(font_height), line_spacing(line_spacing), align(align)
+: m_font_name{font_name},
+  m_font_height{font_height * 1.0},
+  m_line_spacing{line_spacing * 1.0},
+  m_align{align}
 {
     // This class uses result.width() to remember its destination width, so store it in there.
-    result.resize(width, 0);
+    m_result.resize(width, 0);
 }
 
-Gosu::Bitmap Gosu::TextBuilder::move_into_bitmap()
+Gosu::Bitmap Gosu::TextBuilder::move_into_bitmap() &&
 {
     flush_current_line(END_OF_TEXT);
-    
+
     // Shrink to fit the currently used height.
-    allocated_lines = used_lines;
+    m_allocated_lines = m_used_lines;
     resize_to_allocated_lines();
-    return move(result);
+    return std::move(m_result);
 }
 
-void Gosu::TextBuilder::feed_word(vector<FormattedString>&& word)
+void Gosu::TextBuilder::feed_word(std::vector<FormattedString>&& word)
 {
-    WordInfo new_word(font_name, font_height, word);
-    
-    if (current_line_width + new_word.width > result.width()) {
+    WordInfo new_word(m_font_name, m_font_height, word);
+
+    if (m_current_line_width + new_word.width > m_result.width()) {
         // Can't fit it on the same line as before, so flush the last line before adding the word to
         // the next line.
         flush_current_line(LINE_TOO_LONG);
-        
+
         if (new_word.is_whitespace) {
             // Do not wrap trailing whitespace onto the start of the next line - discard this word.
             return;
         }
     }
-    
-    current_line.emplace_back(new_word);
-    current_line_width += new_word.width;
+
+    m_current_line.emplace_back(new_word);
+    m_current_line_width += new_word.width * 1.0;
 
     if (new_word.is_end_of_line) {
         flush_current_line(END_OF_PARAGRAPH);