fix initial config modification check, add wrap parameter to text object

src/Configuration.cpp

@@ -146,10 +146,6 @@ void Configuration::merge(const nlohmann::json& incoming)
 void Configuration::merge(const fs::path& path)
 {
     merge(json_from_file(path));
-
-#ifndef __ANDROID__
-    config_file_modification_time = fs::last_write_time(path);
-#endif
 }
 
 void Configuration::merge(const std::string& path)
@@ -233,12 +229,13 @@ void Configuration::refresh()
 #if !defined(__ANDROID__)
     for (const fs::path& path : files_to_refresh)
     {
-        if (fs::exists(path) && fs::last_write_time(path) > config_file_modification_time)
+        if (fs::exists(path) && fs::last_write_time(path) > config_modification_time)
         {
             std::ostringstream message;
             message << "config file modified, reloading " << path;
             sb::Log::log(message, sb::Log::DEBUG);
             merge(path);
+            config_modification_time = std::filesystem::file_time_type::clock::now();
             sb::Delegate::post("reconfig");
         }
     }

src/Configuration.hpp

@@ -32,7 +32,7 @@ class Configuration : public Node
 private:
 
     Animation auto_refresher = Animation(std::bind(&Configuration::refresh, this));
-    fs::file_time_type config_file_modification_time;
+    std::filesystem::file_time_type config_modification_time = std::filesystem::file_time_type::clock::now();
     std::vector<fs::path> files_to_refresh;
 
     /*!

src/Text.cpp

@@ -19,14 +19,12 @@ void Text::bind_textures() const
 void Text::content(const std::string& content)
 {
     _content = content;
-    refresh();
 }
 
 void Text::content(char content)
 {
     _content = "";
     _content += content;
-    refresh();
 }
 
 const std::string& Text::content() const
@@ -37,38 +35,47 @@ const std::string& Text::content() const
 void Text::foreground(const Color& foreground)
 {
     _foreground = foreground;
-    refresh();
 }
 
 void Text::background(const Color& background)
 {
     _background = background;
-    refresh();
 }
 
 void Text::font(std::shared_ptr<TTF_Font> font)
 {
     _font = font;
-    refresh();
 }
 
 void Text::dimensions(const glm::vec2 &dimensions)
 {
     _dimensions = dimensions;
-    refresh();
 }
 
 void Text::scaling_quality(GLint quality)
 {
     _scaling_quality = quality;
-    refresh();
+}
+
+void Text::wrap(int width)
+{
+    _wrap = width;
 }
 
 void Text::refresh()
 {
-    /* Render the text with transparent background as RGBA pixel data using the SDL image library. */
-    // std::shared_ptr<SDL_Surface> blended {TTF_RenderText_Blended(_font.get(), _content.c_str(), _foreground), SDL_FreeSurface};
-    std::shared_ptr<SDL_Surface> blended {TTF_RenderUTF8_Blended_Wrapped(_font.get(), _content.c_str(), _foreground, 3000), SDL_FreeSurface};
+    /* Render the text with transparent background as RGBA pixel data using the SDL image library. Apply wrap if it is set. */
+    std::shared_ptr<SDL_Surface> blended;
+    if (_wrap.has_value())
+    {
+        blended = std::shared_ptr<SDL_Surface>{TTF_RenderUTF8_Blended_Wrapped(_font.get(), _content.c_str(), _foreground, _wrap.value()), SDL_FreeSurface};
+    }
+    else
+    {
+        blended = std::shared_ptr<SDL_Surface>{TTF_RenderUTF8_Blended(_font.get(), _content.c_str(), _foreground), SDL_FreeSurface};
+    }
+
+    /* Composite the rendered text onto a background surface. */
     if (!blended)
     {
         Log::sdl_error("Could not create text");

src/Text.hpp

@@ -24,13 +24,14 @@ namespace sb
         std::shared_ptr<TTF_Font> _font;
         std::optional<glm::vec2> _dimensions;
         GLint _scaling_quality = GL_LINEAR;
+        std::optional<int> _wrap;
 
     public:
 
         /*!
-         * Construct a sb::Text object from a font, string, and background and foreground colors. A texture will be created and attached. The
-         * texture is not generated or rendered. Text::refresh() must be called afterward with the GL context loaded. The content, dimensions,
-         * foreground, background, font, and scaling quality functions call Text::refresh() automatically.
+         * Construct a sb::Text object from a font, string, and background and foreground colors. A texture will be created and attached at
+         * texture index 0. The texture is not generated or rendered. Text::refresh() must be called afterward with the GL context loaded to render
+         * the text to the constructed texture.
          *
          * The font must be wrapped in a shared pointer. A default loaded font is available from Game::font().
          *
@@ -53,54 +54,66 @@ namespace sb
         }
 
         /*!
-         * Bind the texture rendered from the text object's text content and any other textures attached.
+         * Bind textures attached to this model.
          */
         void bind_textures() const;
 
         /*!
-         * @param content    text to be displayed
+         * @param content  Text to be rendered
          */
         void content(const std::string& content);
 
         /*!
-         * @param content  Single character to be used for text content
+         * @param content  Single character to be rendered
          */
         void content(char content);
 
         /*!
-         * @return  Text content to be displayed
+         * @return  Text to be rendered
          */
         const std::string& content() const;
 
         /*!
-         * @param foreground   text color
+         * @param foreground  Text color
          */
         void foreground(const sb::Color& foreground);
 
         /*!
-         * @param background   text background color which fills the Plane
+         * @param background  Text background color
          */
         void background(const sb::Color& background);
 
         /*!
-         * @param font   shared pointer to a TTF_Font
+         * @param font  Shared pointer to a TTF_Font to use for rendering text
          */
         void font(std::shared_ptr<TTF_Font> font);
 
         /*!
-         * @param dimensions   force the texture to be a certain size in pixels, extra area is filled with the background color
+         * @param dimensions  Force the generated texture to be a certain size in pixels. Extra area is filled with the background color.
          */
         void dimensions(const glm::vec2& dimensions);
 
         /*!
          * This GL parameter will be passed to `glTexParameter` for `GL_TEXTURE_MIN_FILTER` and `GL_TEXTURE_MAG_FILTER`.
          * 
-         * @param quality   quality of texture scaling passed to `glTexParameter`
+         * @param quality  Quality of texture scaling passed to `glTexParameter`
          */
         void scaling_quality(GLint quality);
 
         /*!
-         * Load the texture with the appropriate SDL_Surface pixels created by the SDL TTF library.
+         * By default, there is no wrapping on the text added to this object. If this is set, however, the text will be rendered to a
+         * texture that is limited to the given pixel width. Any text that would exceed that width is moved to a new line in the
+         * rendering.
+         * 
+         * @param wrap  Pixel width where the text will wrap when rendered to a texture
+         */
+        void wrap(int width);
+
+        /*!
+         * Generate and load the texture at index 0. Render text to it using SDL_Surface pixels created by the SDL TTF library.
+         *
+         * The text must be set to a non-zero length string using Text::content(const std::string&) or it will fail to render with an
+         * error logged.
          */
         void refresh();