cleanup cursor render function too

Author: dhthwy

library/SDLConsole_impl.cpp

@@ -1605,6 +1605,68 @@ class Widget : public SignalEmitter {
     Widget& operator=(const Widget&) = delete;
 };
 
+class Cursor {
+private:
+    // 1x1 texture stretched to font's single character dimensions
+    SDL_Texture* texture_;
+    SDL_Renderer* renderer_;
+    size_t position_ { 0 };
+    SDL_Rect rect_ {};
+public:
+    Cursor(SDL_Renderer* renderer) : renderer_(renderer)
+    {
+        texture_ = sdl_tsd.CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STATIC, 1, 1);
+        if (texture_ == nullptr) {
+            throw(std::runtime_error(sdl_console::SDL_GetError()));
+        }
+
+        // FFFFFF = rgb white, 7F = 50% transparant
+        Uint32 pixel = 0xFFFFFF7F;
+        if (sdl_console::SDL_UpdateTexture(texture_, NULL, &pixel, sizeof(Uint32)) != 0) {
+            throw(std::runtime_error(sdl_console::SDL_GetError()));
+        }
+        // For transparancy
+        sdl_console::SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
+    }
+
+    size_t position() const
+    {
+        return position_;
+    }
+
+    void reset_position()
+    {
+        position_ = 0;
+    }
+
+    void set_rect(const SDL_Rect& r)
+    {
+        rect_ = r;
+    }
+
+    void render() const
+    {
+        render_texture(renderer_, texture_, rect_);
+    }
+
+    Cursor& operator=(size_t position) {
+        position_ = position;
+        return *this;
+    }
+
+    Cursor& operator++() { ++position_; return *this; }
+    Cursor& operator--() { if (position_ > 0) { --position_; } return *this; }
+
+    Cursor& operator+=(std::size_t n) { position_ += n; return *this; }
+    Cursor& operator-=(std::size_t n) { position_ = (n > position_) ? 0 : position_ - n; return *this; }
+
+    Cursor(const Cursor&) = delete;
+    Cursor& operator=(const Cursor&) = delete;
+    Cursor(Cursor&&) = delete;
+    Cursor& operator=(Cursor&&) = delete;
+
+};
+
 class Prompt : public Widget {
 public:
     // Holds wrapped lines from input
@@ -1614,9 +1676,7 @@ class Prompt : public Widget {
     // The input portion of the prompt.
     std::u32string* input;
     std::u32string saved_input;
-    size_t cursor { 0 }; // position of cursor within an entry
-    // 1x1 texture stretched to font's single character dimensions
-    SDL_Texture* cursor_texture;
+    Cursor cursor;
     /*
      * For input history.
      * use deque to hold a stable reference.
@@ -1625,14 +1685,12 @@ class Prompt : public Widget {
     int history_index;
 
     Prompt(Widget* parent)
-        : Widget(parent)
+        : Widget(parent), cursor(renderer())
     {
         input = &history.emplace_back(U"");
 
         set_prompt_text(props().get(property::PROMPT_TEXT).value_or(U"> "));
 
-        create_cursor_texture();
-
         connect_global<SDL_KeyboardEvent>(SDL_KEYDOWN, [this](SDL_KeyboardEvent& e) {
             on_SDL_KEYDOWN(e);
         });
@@ -1647,22 +1705,6 @@ class Prompt : public Widget {
         //sdl_tsd.DestroyTexture(cursor_texture);
     }
 
-    // NOTE: Only called by constructor.
-    void create_cursor_texture()
-    {
-        cursor_texture = sdl_tsd.CreateTexture(renderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STATIC, 1, 1);
-        if (cursor_texture == nullptr)
-            throw(std::runtime_error(sdl_console::SDL_GetError()));
-
-        // FFFFFF = rgb white, 7F = 50% transparant
-        Uint32 pixel = 0xFFFFFF7F;
-        if (sdl_console::SDL_UpdateTexture(cursor_texture, NULL, &pixel, sizeof(Uint32)) != 0) {
-            throw(std::runtime_error(sdl_console::SDL_GetError()));
-        }
-        // For transparancy
-        sdl_console::SDL_SetTextureBlendMode(cursor_texture, SDL_BLENDMODE_BLEND);
-    }
-
     /* OutputPane does this */
     void render() override
     {
@@ -1671,8 +1713,9 @@ class Prompt : public Widget {
     void put_input_from_clipboard()
     {
         auto* str = sdl_console::SDL_GetClipboardText();
-        if (*str != '\0')
+        if (*str != '\0') {
             put_input_at_cursor(text::from_utf8(str));
+        }
         // Always free, even when empty.
         sdl_console::SDL_free(str);
     }
@@ -1715,13 +1758,13 @@ class Prompt : public Widget {
 
         case SDLK_b:
             if (sdl_console::SDL_GetModState() & KMOD_CTRL) {
-                cursor = text::find_prev_word(*input, cursor);
+                cursor = text::find_prev_word(*input, cursor.position());
             }
             break;
 
         case SDLK_f:
             if (sdl_console::SDL_GetModState() & KMOD_CTRL) {
-                cursor = text::find_next_word(*input, cursor);
+                cursor = text::find_next_word(*input, cursor.position());
             }
             break;
         case SDLK_c:
@@ -1742,19 +1785,20 @@ class Prompt : public Widget {
         std::swap(history, saved_history);
         input = &history.emplace_back(U"");
         history_index = history.size() - 1;
-        reset_cursor();
+        cursor.reset_position();
     }
 
     void new_command_input()
     {
         emit(InternalEventType::new_command_input, input);
 
         // If empty, log an empty line? But don't add it to history.
-        if (input->empty()) return;
+        if (input->empty()) { return; }
 
         input = &history.emplace_back(U"");
         history_index = history.size() - 1;
-        reset_cursor();
+        //reset_cursor();
+        cursor.reset_position();
         wrap_text();
     }
 
@@ -1763,7 +1807,7 @@ class Prompt : public Widget {
         saved_input = *input;
         emit(InternalEventType::new_input, input);
         input->clear();
-        reset_cursor();
+        cursor.reset_position();
         wrap_text();
     }
 
@@ -1774,11 +1818,6 @@ class Prompt : public Widget {
         wrap_text();
     }
 
-    void reset_cursor()
-    {
-        cursor = 0;
-    }
-
     void set_prompt_text(const std::u32string& value)
     {
         prompt_text = value;
@@ -1793,7 +1832,7 @@ class Prompt : public Widget {
      */
     void set_input_from_history(const ScrollAction sa)
     {
-        if (history.empty()) return;
+        if (history.empty()) { return; }
 
         if (sa == ScrollAction::up && history_index > 0) {
             history_index--;
@@ -1810,6 +1849,7 @@ class Prompt : public Widget {
 
     void put_input_at_cursor(const std::u32string& str)
     {
+#if 0
         /* if cursor is at end of line, it's a simple concatenation */
         if (cursor == input->length()) {
             *input += str;
@@ -1818,6 +1858,16 @@ class Prompt : public Widget {
             input->insert(cursor, str);
         }
         cursor += str.length();
+#endif
+        /* if cursor is at end of line, it's a simple concatenation */
+        if (cursor.position() == input->length()) {
+            *input += str;
+        } else {
+        /* else insert text into line at cursor's index */
+            input->insert(cursor.position(), str);
+        }
+        cursor += str.length();
+
         wrap_text();
     }
 
@@ -1830,30 +1880,31 @@ class Prompt : public Widget {
 
     void erase_input()
     {
-        if (cursor == 0 || input->empty())
+        if (cursor.position() == 0 || input->empty()) {
             return;
+        }
 
-        if (input->length() == cursor) {
+        if (input->length() == cursor.position()) {
             input->pop_back();
         } else {
             /* else shift the text from cursor left by one character */
-            input->erase(cursor-1, 1);
+            input->erase(cursor.position()-1, 1);
         }
-        cursor -= 1;
+        --cursor;
         wrap_text();
     }
 
     void move_cursor_left()
     {
-        if (cursor > 0) {
-            cursor--;
+        if (cursor.position() > 0) {
+            --cursor;
         }
     }
 
     void move_cursor_right()
     {
-        if (cursor < input->length()) {
-            cursor++;
+        if (cursor.position() < input->length()) {
+            ++cursor;
         }
     }
 
@@ -1867,51 +1918,61 @@ class Prompt : public Widget {
     {
         entry.text = prompt_text + *input;
         entry.wrap_text(font->char_width, frame.w);
+        update_cursor_geometry_for_render();
     }
 
-    // TODO: The cursor x,y position should be updated
-    // elsewhere, such as when the cursor position changes.
-    // instead of within its rendering function.
-    void render_cursor(int scroll_offset)
+    void update_cursor_geometry_for_render()
     {
-        if (entry.fragments().empty())
+        if (entry.fragments().empty()) {
             return;
+        }
 
         // cursor's starting position
-        auto cursor_pos = cursor + prompt_text.length();
+        auto cursor_pos = cursor.position() + prompt_text.length();
         TextEntry::Fragment *line;
 
         // cursor is at the end
         if (cursor_pos == entry.text.length()) {
+#if 0
             if (scroll_offset > 0) {
                 // cursor is not visible.
                 return;
             }
+#endif
             line = &entry.fragments().back();
-        // else find the line containing the cursor
+            // else find the line containing the cursor
         } else {
             auto line_opt = entry.fragment_from_offset(cursor_pos);
-            if (!line_opt.has_value())
+            if (!line_opt.has_value()) {
                 return; // should not happen
+            }
 
             line = &line_opt.value().get();
+
+#if 0
             // the very bottom of the prompt is the last entry
             // entry_offset = entry.size-1 at bottom
             int r = (entry.size - 1) - line->entry_offset;
+
             // scroll_offset starts at 0.
             if (scroll_offset > r) {
                 // cursor is not visible.
                 return;
             }
+#endif
         }
 
         auto lh = font->line_height_with_spacing();
         auto cw = font->char_width;
         auto cx = (cursor_pos - line->start_offset) * cw;
         auto cy = line->coord.y;
 
-        SDL_Rect rect{ (int)cx, cy, cw, lh };
-        render_texture(renderer(), cursor_texture, rect);
+        cursor.set_rect({ (int)cx, cy, cw, lh });
+    }
+
+    void render_cursor(int scroll_offset)
+    {
+        cursor.render();
     }
 
     Prompt(const Prompt&) = delete;
@@ -2785,7 +2846,6 @@ class OutputPane : public Widget {
         }
     }
 
-    // FIXME: Position and rows to render calculations should be done elsewhere.
     std::vector<VisibleRow> get_visible_entry_rows(TextEntry& entry, int& ypos, int& row_counter, int max_row)
     {
         std::vector<VisibleRow> vrows;
@@ -2819,7 +2879,7 @@ class OutputPane : public Widget {
         }
 
         for (const auto& row : visible_rows_cache.rows) {
-            font->set_color(row.color);
+            auto sc = font->set_color(row.color);
             font->render(row.text, row.coord.x, row.coord.y);
         }
     }