gosu 1.1.1.1 → 1.4.1

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() &&;
     };
 }
-

data/src/TextInput.cpp

@@ -1,125 +1,120 @@
-#include <Gosu/TextInput.hpp>
 #include <Gosu/Input.hpp>
 #include <Gosu/Platform.hpp>
+#include <Gosu/TextInput.hpp>
+#include <cctype>
 
 #ifndef GOSU_IS_IPHONE
 #include <SDL.h>
-#include <cctype>
 #endif
 
-using namespace std;
-
-struct Gosu::TextInput::Impl
+struct Gosu::TextInput::Impl : Gosu::Noncopyable
 {
-    string text;
-    
+    std::string text;
+
     // This is the current IME composition (not used on iOS).
     // http://wiki.libsdl.org/Tutorials/TextInput#CandidateList
-    string composition;
-    
+    std::string composition;
+
     // Indices into the UTF-8 encoded text.
     unsigned caret_pos = 0, selection_start = 0;
-    
+
     // Skip continuation characters, see: https://en.wikipedia.org/wiki/UTF-8#Description
     // (0xc0 = 11'000000, 0x80 = 10'000000)
-    bool should_skip(char ch)
-    {
-        return (static_cast<unsigned char>(ch) & 0xc0) == 0x80;
-    }
-    
-    void insert_text(const string& new_text)
+    static bool should_skip(char ch) { return (static_cast<unsigned char>(ch) & 0xc0) == 0x80; }
+
+    void insert_text(const std::string& new_text)
     {
         // Stop IME composition.
         composition.clear();
 
         // Delete (overwrite) previous selection.
         if (caret_pos != selection_start) {
-            unsigned from = min(caret_pos, selection_start);
-            unsigned to = max(caret_pos, selection_start);
+            unsigned from = std::min(caret_pos, selection_start);
+            unsigned to = std::max(caret_pos, selection_start);
             text.erase(text.begin() + from, text.begin() + to);
             caret_pos = selection_start = from;
         }
-        
+
         text.insert(text.begin() + caret_pos, new_text.begin(), new_text.end());
         caret_pos += new_text.size();
         selection_start = caret_pos;
     }
-    
+
     void move_left(bool modify_selection)
     {
         if (caret_pos > 0) {
             caret_pos -= 1;
-            
+
             // Skip UTF-8 continuation bytes.
             while (caret_pos > 0 && should_skip(text[caret_pos])) {
                 caret_pos -= 1;
             }
         }
-        
+
         if (modify_selection) {
             selection_start = caret_pos;
         }
     }
-    
+
     void move_right(bool modify_selection)
     {
         if (caret_pos < text.length()) {
             caret_pos += 1;
-            
+
             // Skip UTF-8 continuation bytes.
             while (caret_pos < text.length() && should_skip(text[caret_pos])) {
                 caret_pos += 1;
             }
         }
-        
+
         if (modify_selection) {
             selection_start = caret_pos;
         }
     }
-    
+
     void move_word_left(bool modify_selection)
     {
-        while (caret_pos > 0 && isspace(text[caret_pos - 1])) {
+        while (caret_pos > 0 && std::isspace(text[caret_pos - 1])) {
             move_left(modify_selection);
         }
-        while (caret_pos > 0 && !isspace(text[caret_pos - 1])) {
+        while (caret_pos > 0 && !std::isspace(text[caret_pos - 1])) {
             move_left(modify_selection);
         }
     }
 
     void move_word_right(bool modify_selection)
     {
-        while (caret_pos < text.length() && isspace(text.at(caret_pos))) {
+        while (caret_pos < text.length() && std::isspace(text.at(caret_pos))) {
             move_right(modify_selection);
         }
-        while (caret_pos < text.length() && !isspace(text.at(caret_pos))) {
+        while (caret_pos < text.length() && !std::isspace(text.at(caret_pos))) {
             move_right(modify_selection);
         }
     }
-    
+
     void move_to_beginning_of_line(bool modify_selection)
     {
         caret_pos = 0;
-        
+
         if (modify_selection) {
             selection_start = caret_pos;
         }
     }
-    
+
     void move_to_end_of_line(bool modify_selection)
     {
         caret_pos = static_cast<unsigned>(text.length());
-        
+
         if (modify_selection) {
             selection_start = caret_pos;
         }
     }
-    
+
     void delete_backward()
     {
         if (selection_start != caret_pos) {
-            unsigned from = min(caret_pos, selection_start);
-            unsigned to = max(caret_pos, selection_start);
+            unsigned from = std::min(caret_pos, selection_start);
+            unsigned to = std::max(caret_pos, selection_start);
             text.erase(text.begin() + from, text.begin() + to);
             selection_start = caret_pos = from;
         }
@@ -129,12 +124,12 @@ struct Gosu::TextInput::Impl
             selection_start = caret_pos;
         }
     }
-    
+
     void delete_forward()
     {
         if (selection_start != caret_pos) {
-            unsigned from = min(caret_pos, selection_start);
-            unsigned to = max(caret_pos, selection_start);
+            unsigned from = std::min(caret_pos, selection_start);
+            unsigned to = std::max(caret_pos, selection_start);
             text.erase(text.begin() + from, text.begin() + to);
             selection_start = caret_pos = from;
         }
@@ -147,150 +142,147 @@ struct Gosu::TextInput::Impl
 };
 
 Gosu::TextInput::TextInput()
-: pimpl(new Impl)
+: m_impl{new Impl}
 {
 }
 
-Gosu::TextInput::~TextInput()
-{
-    // TODO: Unset Input::text_input to avoid stale pointers?
-}
+Gosu::TextInput::~TextInput() = default;
 
-string Gosu::TextInput::text() const
+std::string Gosu::TextInput::text() const
 {
-    string composed_text = pimpl->text;
-    if (!pimpl->composition.empty()) {
-        composed_text.insert(pimpl->caret_pos, pimpl->composition);
+    std::string composed_text = m_impl->text;
+    if (!m_impl->composition.empty()) {
+        composed_text.insert(m_impl->caret_pos, m_impl->composition);
     }
     return composed_text;
 }
 
-void Gosu::TextInput::set_text(const string& text)
+void Gosu::TextInput::set_text(const std::string& text)
 {
-    pimpl->text = text;
-    pimpl->composition.clear();
-    pimpl->caret_pos = pimpl->selection_start = static_cast<unsigned>(pimpl->text.length());
+    m_impl->text = text;
+    m_impl->composition.clear();
+    m_impl->caret_pos = m_impl->selection_start = static_cast<unsigned>(m_impl->text.length());
 }
 
 unsigned Gosu::TextInput::caret_pos() const
 {
-    return pimpl->caret_pos;
+    return m_impl->caret_pos;
 }
 
 void Gosu::TextInput::set_caret_pos(unsigned caret_pos)
 {
-    pimpl->caret_pos = caret_pos;
+    m_impl->caret_pos = caret_pos;
 }
 
 unsigned Gosu::TextInput::selection_start() const
 {
-    return pimpl->selection_start;
+    return m_impl->selection_start;
 }
 
 void Gosu::TextInput::set_selection_start(unsigned selection_start)
 {
-    pimpl->selection_start = selection_start;
+    m_impl->selection_start = selection_start;
 }
 
 #ifndef GOSU_IS_IPHONE
 bool Gosu::TextInput::feed_sdl_event(void* event)
 {
     const SDL_Event* e = static_cast<SDL_Event*>(event);
-    
+
     switch (e->type) {
-    // Direct text input or completed IME composition.
-    case SDL_TEXTINPUT: {
-        pimpl->insert_text(filter(e->text.text));
-        return true;
-    }
-    // IME composition in progress.
-    case SDL_TEXTEDITING: {
-        pimpl->composition = e->edit.text;
-        return true;
-    }
-    // Emulate "standard" Windows/Linux keyboard behavior.
-    case SDL_KEYDOWN: {
-        // ...but not if the IME is currently compositing.
-        if (!pimpl->composition.empty()) return false;
-
-    #ifdef GOSU_IS_MAC
-        bool words = (e->key.keysym.mod & (KMOD_LALT | KMOD_RALT));
-        bool command_down = (e->key.keysym.mod & (KMOD_LGUI | KMOD_RGUI));
-    #else
-        bool words = (e->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL));
-    #endif
-        bool shift_down = (e->key.keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT));
-        SDL_Keycode key = e->key.keysym.sym;
-        
-        switch (key) {
-        case SDLK_LEFT:
-        #ifdef GOSU_IS_MAC
-            if (command_down) {
-                pimpl->move_to_beginning_of_line(!shift_down);
-                return true;
-            }
-        #endif
-            if (words) {
-                pimpl->move_word_left(!shift_down);
-            }
-            else {
-                pimpl->move_left(!shift_down);
-            }
-            return true;
-        case SDLK_RIGHT:
-        #ifdef GOSU_IS_MAC
-            if (command_down) {
-                pimpl->move_to_end_of_line(!shift_down);
-                return true;
-            }
-        #endif
-            if (words) {
-                pimpl->move_word_right(!shift_down);
-            }
-            else {
-                pimpl->move_right(!shift_down);
-            }
-            return true;
-        #ifdef GOSU_IS_MAC
-        case SDLK_UP:
-        #endif
-        case SDLK_HOME:
-            pimpl->move_to_beginning_of_line(!shift_down);
-            return true;
-        #ifdef GOSU_IS_MAC
-        case SDLK_DOWN:
-        #endif
-        case SDLK_END:
-            pimpl->move_to_end_of_line(!shift_down);
+        // Direct text input or completed IME composition.
+        case SDL_TEXTINPUT: {
+            m_impl->insert_text(filter(e->text.text));
             return true;
-        case SDLK_BACKSPACE:
-            pimpl->delete_backward();
-            return true;
-        case SDLK_DELETE:
-            pimpl->delete_forward();
+        }
+        // IME composition in progress.
+        case SDL_TEXTEDITING: {
+            m_impl->composition = e->edit.text;
             return true;
         }
-        break;
-    }
+        // Emulate "standard" Windows/Linux keyboard behavior.
+        case SDL_KEYDOWN: {
+            // ...but not if the IME is currently compositing.
+            if (!m_impl->composition.empty()) return false;
 
-    // TODO: Handle copy & paste.
+#ifdef GOSU_IS_MAC
+            bool words = (e->key.keysym.mod & (KMOD_LALT | KMOD_RALT));
+            bool command_down = (e->key.keysym.mod & (KMOD_LGUI | KMOD_RGUI));
+#else
+            bool words = (e->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL));
+#endif
+            bool shift_down = (e->key.keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT));
+            SDL_Keycode key = e->key.keysym.sym;
+
+            switch (key) {
+                case SDLK_LEFT:
+#ifdef GOSU_IS_MAC
+                    if (command_down) {
+                        m_impl->move_to_beginning_of_line(!shift_down);
+                        return true;
+                    }
+#endif
+                    if (words) {
+                        m_impl->move_word_left(!shift_down);
+                    }
+                    else {
+                        m_impl->move_left(!shift_down);
+                    }
+                    return true;
+                case SDLK_RIGHT:
+#ifdef GOSU_IS_MAC
+                    if (command_down) {
+                        m_impl->move_to_end_of_line(!shift_down);
+                        return true;
+                    }
+#endif
+                    if (words) {
+                        m_impl->move_word_right(!shift_down);
+                    }
+                    else {
+                        m_impl->move_right(!shift_down);
+                    }
+                    return true;
+#ifdef GOSU_IS_MAC
+                case SDLK_UP:
+#endif
+                case SDLK_HOME:
+                    m_impl->move_to_beginning_of_line(!shift_down);
+                    return true;
+#ifdef GOSU_IS_MAC
+                case SDLK_DOWN:
+#endif
+                case SDLK_END:
+                    m_impl->move_to_end_of_line(!shift_down);
+                    return true;
+                case SDLK_BACKSPACE:
+                    m_impl->delete_backward();
+                    return true;
+                case SDLK_DELETE:
+                    m_impl->delete_forward();
+                    return true;
+            }
+            break;
+        }
+
+            // TODO: Handle copy & paste.
     }
-    
+
     return false;
 }
 #endif
 
-void Gosu::TextInput::insert_text(string text)
+void Gosu::TextInput::insert_text(std::string text)
 {
-    pimpl->insert_text(text);
+    m_impl->insert_text(text);
 }
 
 void Gosu::TextInput::delete_forward()
 {
-    pimpl->delete_forward();
+    m_impl->delete_forward();
 }
 
 void Gosu::TextInput::delete_backward()
 {
-    pimpl->delete_backward();
+    m_impl->delete_backward();
 }