gosu 1.4.6 → 2.0.0.pre6

data/src/RenderState.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <Gosu/Transform.hpp>
 #include "GraphicsImpl.hpp"
+#include "OpenGLContext.hpp"
 #include "Texture.hpp"
 
 // Properties that potentially need to be changed between each draw operation.
@@ -11,13 +13,13 @@ struct Gosu::RenderState
     const Transform* transform;
     ClipRect clip_rect;
     BlendMode mode;
-    
+
     RenderState()
     : transform(0), mode(BM_DEFAULT)
     {
         clip_rect.width = NO_CLIPPING;
     }
-    
+
     bool operator==(const RenderState& rhs) const
     {
         return texture == rhs.texture &&
@@ -25,7 +27,7 @@ struct Gosu::RenderState
             clip_rect == rhs.clip_rect &&
             mode == rhs.mode;
     }
-    
+
     void apply_texture() const
     {
         if (texture) {
@@ -36,7 +38,7 @@ struct Gosu::RenderState
             glDisable(GL_TEXTURE_2D);
         }
     }
-    
+
     void apply_alpha_mode() const
     {
         if (mode == BM_ADD) {
@@ -49,7 +51,7 @@ struct Gosu::RenderState
             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         }
     }
-    
+
     void apply_clip_rect() const
     {
         if (clip_rect.width == NO_CLIPPING) {
@@ -60,7 +62,7 @@ struct Gosu::RenderState
             glScissor(clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
         }
     }
-    
+
     // Only used by Macro so far
     #ifndef GOSU_IS_OPENGLES
     void apply() const
@@ -79,24 +81,24 @@ class Gosu::RenderStateManager : private Gosu::RenderState
     // Not copyable
     RenderStateManager(const RenderStateManager&);
     RenderStateManager& operator=(const RenderStateManager&);
-    
+
     void apply_transform() const
     {
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
-        
+
         #ifndef GOSU_IS_OPENGLES
-        glMultMatrixd(&(*transform)[0]);
+        glMultMatrixd(transform->matrix.data());
         #else
         // TODO: Ouch, should always use floats!
         GLfloat matrix[16];
         for (int i = 0; i < 16; ++i) {
-            matrix[i] = (*transform)[i];
+            matrix[i] = transform->matrix[i];
         }
         glMultMatrixf(matrix);
         #endif
     }
-    
+
 public:
     RenderStateManager()
     {
@@ -105,7 +107,7 @@ public:
         glMatrixMode(GL_MODELVIEW);
         glPushMatrix();
     }
-    
+
     ~RenderStateManager()
     {
         ClipRect no_clipping;
@@ -116,7 +118,7 @@ public:
         glMatrixMode(GL_MODELVIEW);
         glPopMatrix();
     }
-    
+
     void set_render_state(const RenderState& rs)
     {
         set_texture(rs.texture);
@@ -124,7 +126,7 @@ public:
         set_clip_rect(rs.clip_rect);
         set_alpha_mode(rs.mode);
     }
-    
+
     void set_texture(std::shared_ptr<Texture> new_texture)
     {
         if (new_texture == texture) return;
@@ -141,11 +143,11 @@ public:
         }
         texture = new_texture;
     }
-    
+
     void set_transform(const Transform* new_transform)
     {
         if (new_transform == transform) return;
-        
+
         transform = new_transform;
         apply_transform();
     }
@@ -173,15 +175,15 @@ public:
             }
         }
     }
-    
+
     void set_alpha_mode(BlendMode new_mode)
     {
         if (new_mode == mode) return;
-        
+
         mode = new_mode;
         apply_alpha_mode();
     }
-    
+
     // The cached values may have been messed with. Reset them again.
     void enforce_after_untrusted_gL() const
     {

data/src/Resolution.cpp

@@ -1,30 +1,30 @@
 #include <Gosu/Platform.hpp>
-#ifndef GOSU_IS_IPHONE // iPhone definitions live in WindowUIKit.cpp
+#ifndef GOSU_IS_IPHONE // Definitions for iOS live in WindowUIKit.cpp
 
 #include <Gosu/Window.hpp>
 #include "GraphicsImpl.hpp"
 #include <SDL.h>
 
-static SDL_DisplayMode display_mode(Gosu::Window* window)
+static SDL_DisplayMode display_mode(const Gosu::Window* window)
 {
-    static struct VideoSubsystem
+    static const struct VideoSubsystem : Gosu::Noncopyable
     {
         VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
 
-    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    int index = window ? SDL_GetWindowDisplayIndex(window->sdl_window()) : 0;
     SDL_DisplayMode result;
     SDL_GetDesktopDisplayMode(index, &result);
     return result;
 }
 
-int Gosu::screen_width(Window* window)
+int Gosu::screen_width(const Window* window)
 {
     return display_mode(window).w;
 }
 
-int Gosu::screen_height(Window* window)
+int Gosu::screen_height(const Window* window)
 {
     return display_mode(window).h;
 }
@@ -32,7 +32,7 @@ int Gosu::screen_height(Window* window)
 #ifdef GOSU_IS_MAC
 #import <AppKit/AppKit.h>
 
-static SDL_Rect max_window_size(Gosu::Window* window)
+static SDL_Rect max_window_size(const Gosu::Window* window)
 {
     // The extra size that a window needs depends on its style.
     // This logic must be kept in sync with SDL_cocoawindow.m to be 100% accurate.
@@ -48,7 +48,7 @@ static SDL_Rect max_window_size(Gosu::Window* window)
         style |= NSWindowStyleMaskResizable;
     }
 
-    auto index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    auto index = window ? SDL_GetWindowDisplayIndex(window->sdl_window()) : 0;
     NSRect screen_frame = NSScreen.screens[index].visibleFrame;
     NSRect content_rect = [NSWindow contentRectForFrameRect:screen_frame styleMask:style];
 
@@ -68,26 +68,26 @@ static SDL_Rect max_window_size(Gosu::Window* window)
 #include <windows.h>
 #pragma comment(lib, "Dwmapi.lib")
 
-static SDL_Rect max_window_size(Gosu::Window* window)
+static SDL_Rect max_window_size(const Gosu::Window* window)
 {
     // Replicate SDL's WIN_GetWindowBordersSize implementation (https://github.com/libsdl-org/SDL/blob/9f71a809e9bd6fbb5fa401a45c1537fc26abc1b4/src/video/windows/SDL_windowswindow.c#L514-L554)
     // until it's patched to ignore the window drop shadow (window border is 1px but with drop shadow it's reported as 8px)
     // REF: https://github.com/libsdl-org/SDL/issues/3835
 
-    static struct VideoSubsystem
+    static const struct VideoSubsystem : Gosu::Noncopyable
     {
         VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
 
-    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    int index = window ? SDL_GetWindowDisplayIndex(window->sdl_window()) : 0;
     SDL_Rect rect;
     SDL_GetDisplayUsableBounds(index, &rect);
 
     if (window) {
         SDL_SysWMinfo info;
         SDL_VERSION(&info.version);
-        SDL_GetWindowWMInfo(Gosu::shared_window(), &info);
+        SDL_GetWindowWMInfo(window->sdl_window(), &info);
         HWND hwnd = info.info.win.window;
 
         RECT rcClient, rcWindow;
@@ -137,33 +137,35 @@ static SDL_Rect max_window_size(Gosu::Window* window)
 #endif
 
 #ifdef GOSU_IS_X
-static SDL_Rect max_window_size(Gosu::Window* window)
+static SDL_Rect max_window_size(const Gosu::Window* window)
 {
-    static struct VideoSubsystem
+    static const struct VideoSubsystem : Gosu::Noncopyable
     {
         VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
 
-    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    int index = window ? SDL_GetWindowDisplayIndex(window->sdl_window()) : 0;
     SDL_Rect rect;
-    int top, left, bottom, right;
     SDL_GetDisplayUsableBounds(index, &rect);
-    SDL_GetWindowBordersSize(Gosu::shared_window(), &top, &left, &bottom, &right);
 
-    rect.w -= left + right;
-    rect.h -= top + bottom;
+    if (window) {
+        int top, left, bottom, right;
+        SDL_GetWindowBordersSize(window->sdl_window(), &top, &left, &bottom, &right);
+        rect.w -= left + right;
+        rect.h -= top + bottom;
+    }
 
     return rect;
 }
 #endif
 
-int Gosu::available_width(Window* window)
+int Gosu::available_width(const Window* window)
 {
     return max_window_size(window).w;
 }
 
-int Gosu::available_height(Window* window)
+int Gosu::available_height(const Window* window)
 {
     return max_window_size(window).h;
 }

data/src/TexChunk.cpp

@@ -5,50 +5,20 @@
 #include "Texture.hpp"
 #include <stdexcept>
 
-void Gosu::TexChunk::set_tex_info()
+Gosu::TexChunk::TexChunk(const std::shared_ptr<Texture>& texture, const Rect& rect,
+                         const std::shared_ptr<const Rect>& rect_handle)
+    : m_texture(texture),
+      m_rect(rect),
+      m_info { .tex_name = texture->tex_name(),
+               .left = 1.0 * m_rect.x / texture->width(),
+               .right = 1.0 * m_rect.right() / texture->width(),
+               .top = 1.0 * m_rect.y / texture->height(),
+               .bottom = 1.0 * m_rect.bottom() / texture->height() },
+      m_rect_handle(rect_handle)
 {
-    double width = m_texture->width(), height = m_texture->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(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)
-: 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.m_w || y + h > parent.m_h) {
-        throw std::invalid_argument{"subimage bounds exceed those of its parent"};
+    if (!Rect::covering(*texture).contains(rect)) {
+        throw std::invalid_argument("Gosu::TexChunk exceeds its Gosu::Texture");
     }
-    if (w <= 0 || h <= 0) {
-        throw std::invalid_argument{"cannot create empty image"};
-    }
-
-    set_tex_info();
-    m_texture->block(m_x, m_y, m_w, m_h);
-}
-
-Gosu::TexChunk::~TexChunk()
-{
-    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, //
@@ -59,6 +29,8 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2,
     op.render_state.texture = m_texture;
     op.render_state.mode = mode;
 
+    op.rect_handle = m_rect_handle;
+
     normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
 
     op.vertices_or_block_index = 4;
@@ -78,62 +50,45 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2,
     op.bottom = m_info.bottom;
 
     op.z = z;
-    Graphics::schedule_draw_op(op);
+    schedule_draw_op(op);
 }
 
-std::unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::Drawable> Gosu::TexChunk::subimage(const Rect& rect) const
 {
-    return std::unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
+    // Note: m_rect is relative to m_texture, but rect should be relative to m_rect.
+    if (!Rect::covering(*this).contains(rect)) {
+        throw std::invalid_argument("Gosu::TexChunk::subimage cannot exceed parent size");
+    }
+    const Rect nested_rect { m_rect.x + rect.x, m_rect.y + rect.y, rect.width, rect.height };
+    return std::make_unique<TexChunk>(m_texture, nested_rect, m_rect_handle);
 }
 
 Gosu::Bitmap Gosu::TexChunk::to_bitmap() const
 {
-    return m_texture->to_bitmap(m_x, m_y, m_w, m_h);
+    return m_texture->to_bitmap(m_rect);
 }
 
-void Gosu::TexChunk::insert(const Bitmap& original_bitmap, int x, int y)
+void Gosu::TexChunk::insert(const Bitmap& bitmap, int x, int y)
 {
     Bitmap clipped_bitmap;
-    const Bitmap* bitmap = &original_bitmap;
+    const Bitmap* source = &bitmap;
 
+    Rect target_rect { x, y, bitmap.width(), bitmap.height() };
+    int offset_x = 0, offset_y = 0;
     // 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() > 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.
-        int clipped_width = original_bitmap.width(), clipped_height = original_bitmap.height();
+    if (!Rect::covering(*this).contains(target_rect)) {
+        target_rect.clip_to(Rect::covering(*this), &offset_x, &offset_y);
 
-        // Clip away pixels on the left side, if necessary.
-        if (x < 0) {
-            clip_left = -x;
-            clipped_width -= -x;
-            x = 0;
+        if (target_rect.empty()) {
+            return;
         }
-        // Clip away pixels at the top, if necessary.
-        if (y < 0) {
-            clip_top = -y;
-            clipped_height -= -y;
-            y = 0;
-        }
-        // Clip away pixels on the right side, if necessary.
-        if (x + clipped_width > m_w) {
-            clipped_width = (m_w - x);
-        }
-        // Clip away pixels on the bottom, if necessary.
-        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;
+        clipped_bitmap.resize(target_rect.width, target_rect.height);
+        clipped_bitmap.insert(bitmap, -offset_x, -offset_y);
+        source = &clipped_bitmap;
     }
 
-    glBindTexture(GL_TEXTURE_2D, tex_name());
-    glTexSubImage2D(GL_TEXTURE_2D, 0, m_x + x, m_y + y, bitmap->width(), bitmap->height(),
-                    Color::GL_FORMAT, GL_UNSIGNED_BYTE, bitmap->data());
+    m_texture->insert(*source, m_rect.x + x + offset_x, m_rect.y + y + offset_y);
 }

data/src/TexChunk.hpp

@@ -1,41 +1,50 @@
 #pragma once
 
 #include <Gosu/Fwd.hpp>
-#include <Gosu/ImageData.hpp>
-#include "GraphicsImpl.hpp"
+#include <Gosu/Drawable.hpp>
+#include <Gosu/Utility.hpp>
+#include <cstdint>
 #include <memory>
-#include <stdexcept>
 
-class Gosu::TexChunk : public Gosu::ImageData
+namespace Gosu
 {
-    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 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;
-};
+    class Texture;
+
+    /// The most common Drawable implementation which uses a portion of, or a full, OpenGL texture
+    /// to store image data.
+    class TexChunk : public Drawable
+    {
+        const std::shared_ptr<Texture> m_texture;
+        const Rect m_rect;
+        const GLTexInfo m_info;
+        const std::shared_ptr<const Rect> m_rect_handle;
+
+    public:
+        /// @param texture The texture on which the image data resides.
+        /// @param rect The portion of the texture that will be represented by this TexChunk.
+        ///             This excludes any padding pixels.
+        /// @param rect_handle A shared_ptr that references the full rectangle that was allocated
+        ///                    for this TexChunk, including padding. When this TexChunk and all
+        ///                    of its subimages have been deleted, this rectangle will be reclaimed
+        ///                    for use by other image data.
+        TexChunk(const std::shared_ptr<Texture>& texture, const Rect& rect,
+                 const std::shared_ptr<const Rect>& rect_handle);
+
+        int width() const override { return m_rect.width; }
+        int height() const override { return m_rect.height; }
+
+        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<Drawable> subimage(const Rect& rect) const override;
+
+        Bitmap to_bitmap() const override;
+
+        void insert(const Bitmap& bitmap, int x, int y) override;
+    };
+}

data/src/Text.cpp

@@ -52,7 +52,7 @@ Gosu::Bitmap Gosu::layout_markup(const std::string& markup, const std::string& f
         // 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(std::move(word));
                             }};
         parser.parse(markup);
 

data/src/TextBuilder.cpp

@@ -8,16 +8,20 @@ Gosu::WordInfo::WordInfo(const std::string& font_name, double font_height,
                          std::vector<FormattedString> parts)
 {
     assert(!parts.empty());
+    assert(!parts[0].text.empty());
 
-    const auto* properties = utf8proc_get_property(parts.front().text.front());
+    const auto first_character = static_cast<utf8proc_int32_t>(parts.front().text.front());
+    const auto* properties = utf8proc_get_property(first_character);
 
     // Also check the BiDi class to filter out non-breaking spaces.
-    is_whitespace = properties->category == UTF8PROC_CATEGORY_ZS &&
-                    properties->bidi_class == UTF8PROC_BIDI_CLASS_WS;
+    is_whitespace = properties->category == UTF8PROC_CATEGORY_ZS
+        && properties->bidi_class == UTF8PROC_BIDI_CLASS_WS;
 
     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();
+    if (is_end_of_line) {
+        parts.back().text.pop_back();
+    }
 
     width = 0;
     for (const auto& part : parts) {
@@ -26,20 +30,31 @@ Gosu::WordInfo::WordInfo(const std::string& font_name, double font_height,
         width += text_width(part.text, font_name, font_height, part.flags);
     }
 
-    this->parts = move(parts);
+    this->parts = std::move(parts);
 }
 
+enum Gosu::TextBuilder::EndOfLineReason : int
+{
+    LINE_TOO_LONG,
+    END_OF_PARAGRAPH,
+    END_OF_TEXT
+};
+
 void Gosu::TextBuilder::flush_current_line(EndOfLineReason reason)
 {
     if (m_current_line.empty()) {
-        if (reason == END_OF_PARAGRAPH) allocate_next_line();
+        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 (m_current_line.back().is_whitespace) m_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(!m_current_line.empty());
@@ -84,26 +99,26 @@ void Gosu::TextBuilder::flush_current_line(EndOfLineReason reason)
 void Gosu::TextBuilder::allocate_next_line()
 {
     if (m_used_lines == m_allocated_lines) {
-        m_allocated_lines += 10;
-        resize_to_allocated_lines();
+        reallocate(m_allocated_lines += 10);
     }
 
     ++m_used_lines;
 }
 
-void Gosu::TextBuilder::resize_to_allocated_lines()
+void Gosu::TextBuilder::reallocate(int lines)
 {
-    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));
+    m_allocated_lines = lines;
+    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(), std::ceil(new_height));
 }
 
 Gosu::TextBuilder::TextBuilder(const std::string& font_name, int font_height, int line_spacing,
                                int width, Alignment align)
-: m_font_name{font_name},
-  m_font_height{font_height * 1.0},
-  m_line_spacing{line_spacing * 1.0},
-  m_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.
     m_result.resize(width, 0);
@@ -114,14 +129,13 @@ Gosu::Bitmap Gosu::TextBuilder::move_into_bitmap() &&
     flush_current_line(END_OF_TEXT);
 
     // Shrink to fit the currently used height.
-    m_allocated_lines = m_used_lines;
-    resize_to_allocated_lines();
+    reallocate(m_used_lines);
     return std::move(m_result);
 }
 
-void Gosu::TextBuilder::feed_word(std::vector<FormattedString>&& word)
+void Gosu::TextBuilder::feed_word(std::vector<FormattedString> word)
 {
-    WordInfo new_word(m_font_name, m_font_height, word);
+    WordInfo new_word(m_font_name, m_font_height, std::move(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