gosu 1.3.0 → 1.4.0

data/src/Text.cpp

@@ -1,17 +1,17 @@
+#include <Gosu/Text.hpp>
 #include "GraphicsImpl.hpp"
 #include "MarkupParser.hpp"
 #include "TextBuilder.hpp"
 #include "TrueTypeFont.hpp"
-#include <Gosu/Text.hpp>
 #include <algorithm>
 #include <cmath>
 #include <stdexcept>
 #include <vector>
 
-double Gosu::text_width(const std::u32string& text,
+double Gosu::text_width(const std::u32string& text, //
                         const std::string& font_name, double font_height, unsigned font_flags)
 {
-    if (font_height <= 0)              throw std::invalid_argument{"font_height must be > 0"};
+    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);
@@ -21,60 +21,60 @@ double Gosu::text_width(const std::u32string& text,
 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 std::invalid_argument("font_height must be > 0");
+    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, &bitmap, x, y, c);
 }
 
-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)
+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 std::string& markup, const std::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 std::invalid_argument{"font_height must be > 0"};
-    if (line_spacing < -font_height)   throw std::invalid_argument{"line_spacing must be ≥ -font_height"};
+    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, 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](std::vector<FormattedString> word) {
-            text_builder.feed_word(move(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 {
         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](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);
-        }};
+                                // 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.
         std::vector<double> line_widths;
         double max_width = 0;
@@ -85,10 +85,10 @@ Gosu::Bitmap Gosu::layout_markup(const std::string& markup, const std::string& f
             }
             max_width = std::max(max_width, line_widths.back());
         }
-        
+
         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) {
@@ -99,14 +99,14 @@ Gosu::Bitmap Gosu::layout_markup(const std::string& markup, const std::string& f
             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);

data/src/TextBuilder.hpp

@@ -12,44 +12,44 @@ namespace Gosu
         bool is_whitespace;
         bool is_end_of_line;
         double width;
-        
+
         WordInfo(const std::string& font_name, double font_height,
                  std::vector<FormattedString> parts);
     };
-    
+
     class TextBuilder
     {
         // Parameters.
-        std::string font_name;
-        double font_height;
-        double line_spacing;
-        Alignment align;
-        
-        enum EndOfLineReason {
+        std::string m_font_name;
+        double m_font_height;
+        double m_line_spacing;
+        Alignment m_align;
+
+        enum EndOfLineReason
+        {
             LINE_TOO_LONG,
             END_OF_PARAGRAPH,
             END_OF_TEXT
         };
-        
+
         // Input.
-        std::vector<WordInfo> current_line;
-        int current_line_width = 0;
+        std::vector<WordInfo> m_current_line;
+        int m_current_line_width = 0;
         void flush_current_line(EndOfLineReason reason);
 
         // Output.
-        Bitmap result;
-        int used_lines = 0;
-        int allocated_lines = 0;
+        Bitmap m_result;
+        int m_used_lines = 0;
+        int m_allocated_lines = 0;
         void allocate_next_line();
         void resize_to_allocated_lines();
-        
+
     public:
-        TextBuilder(const std::string& font_name, int font_height, int line_spacing,
-                    int width, Alignment align);
-        
+        TextBuilder(const std::string& font_name, int font_height, int line_spacing, int width,
+                    Alignment align);
+
         void feed_word(std::vector<FormattedString>&& word);
 
-        Bitmap move_into_bitmap();
+        Bitmap move_into_bitmap() &&;
     };
 }
-