1 files changed, 149 insertions, 213 deletions

diff --git a/src/user/raleigh/w/entry.cpp b/src/user/raleigh/w/entry.cpp
index 3053413..54535cc 100644
--- a/src/user/raleigh/w/entry.cpp
+++ b/src/user/raleigh/w/entry.cpp
@@ -1,274 +1,210 @@
+#include <raleigh/s/text_flower.h>
 #include <raleigh/w/entry.h>
-#include <knob/format.h>
-#include <knob/block.h>
-#include <knob/heap.h>
-#include <knob/key.h>
 
 namespace raleigh {
-  void entry::set_contents(const char *s) {
-    const uint32_t l = strlen(s);
-    const uint32_t cl = l > rows * cols - 1 ? rows * cols - 1 : l;
-    blockcpy(data, s, cl);
-    data[cl] = '\0';
-
-    line_indices[0] = 0;
-    get_indices(0, 0, 0);
-    cur_x = end_x;
-    cur_y = end_y;
-    cur_d = end_d;
-
-    next_paint_full = true;
-    if (w)
-      w->notify_needs_paint(*this);
-  }
-
   entry::entry(uint32_t rows, uint32_t cols, const char *default_text,
-    const char *font, _pixel_t bg, _pixel_t fg, _pixel_t border_color)
-    : rows(rows), cols(cols), bg(bg), fg(fg), border_color(border_color),
-      fi(get_font(font)), data(new char[rows * cols]),
-      line_indices(new uint32_t[rows + 1]), has_focus(false) {
+               const struct font_info *fi, _pixel_t bg, _pixel_t fg,
+               _pixel_t border_color)
+    : fi(fi), border_color(border_color), fg(fg), bg(bg), rows(rows),
+      cols(cols), text_back(default_text, strlen(default_text) + 1),
+      flower(text_back.buf, cols, rows) {
     size = coord(fi->space_width  * (cols - 1) + fi->char_width  + 6,
-                 fi->space_height * (rows - 1) + fi->char_height + 6);
+                 fi->space_height * (rows - 1) + fi->char_height + 6);\
     closest_opaque = this;
-    set_contents(default_text);
   }
 
-  void entry::get_indices(uint32_t from_y, uint32_t from_x, uint32_t from_d) {
-    while (1) {
-      const uint32_t ln = str_find_any(data + from_d, " \n");
-      bool quit_after = !data[from_d + ln];
-      if ((from_x + ln <= cols) || (ln >= cols)) {
-        from_x += ln;
-        from_d += ln;
-        if (data[from_d] == '\n') {
-          ++from_y;
-          from_x = 0;
-          line_indices[from_y] = from_d + 1;
-        }
-        else
-          ++from_x;
-        ++from_d;
-        if (from_x >= cols) {
-          ++from_y;
-          from_x = 0;
-          line_indices[from_y] = from_d;
-        }
-        if (quit_after)
-          break;
-      }
-      else {
-        ++from_y;
-        from_x = 0;
-        line_indices[from_y] = from_d;
-      }
-    }
-    line_indices[from_y + 1] = from_d;
-    end_y = from_y;
-    end_x = from_x;
-    end_d = from_d;
+  __attribute__ ((pure))
+  const char *entry::get_contents() {
+    return text_back.buf;
   }
 
-  void entry::notify_window_change() {}
-
-  void entry::paint_text(_pixel_t *pixbuf, uint32_t pitch) {
-    for (uint32_t y = 0; y <= end_y; ++y) {
-      const char *const line = data + line_indices[y];
-      const uint32_t len = line_indices[y + 1] - line_indices[y] >= cols ? cols : line_indices[y + 1] - line_indices[y];
-      for (uint32_t x = 0; x < len; ++x)
-        if ((line[x] != '\n') && line[x])
-          put_char_no_bg(fi, line[x], pixbuf + (window_offset.y + 3 + y * fi->space_height) * pitch + (window_offset.x + 3 + x * fi->space_width), pitch, fg);
-    }
+  void entry::set_contents(const char *s) {
+    text_back.copy_from(s, strlen(s) + 1);
+    on_text_change();
   }
 
   void entry::paint(_pixel_t *pixbuf, uint32_t pitch) {
-    _pixel_t *const cur_ptr = pixbuf + (window_offset.y + 3 + cur_y * fi->space_height) * pitch + (window_offset.x + 3 + cur_x * fi->space_width);
-    _pixel_t *const old_cur_ptr = pixbuf + (window_offset.y + 3 + cur_y_last_paint * fi->space_height) * pitch + (window_offset.x + 3 + cur_x_last_paint * fi->space_width);
-
     if (next_paint_full) {
-      next_paint_full = false;
-
-      for (uint32_t x = 0; x < size.x; ++x) {
-        pixbuf[(window_offset.y) * pitch + window_offset.x + x] = border_color;
-        pixbuf[(window_offset.y + size.y - 1) * pitch + window_offset.x + x] = border_color;
+      for (uint32_t x = window_offset.x; x < window_offset.x + size.x; ++x) {
+        pixbuf[window_offset.y * pitch + x] = border_color;
+        pixbuf[(window_offset.y + size.y - 1) * pitch + x] = border_color;
       }
-      for (uint32_t y = 1; y < size.y - 1; ++y) {
-        pixbuf[(window_offset.y + y) * pitch + window_offset.x] = border_color;
-        pixbuf[(window_offset.y + y) * pitch + window_offset.x + size.x - 1] = border_color;
+      for (uint32_t y = window_offset.y + 1; y < window_offset.y + size.y - 1; ++y) {
+        pixbuf[y * pitch + window_offset.x] = border_color;
+        pixbuf[y * pitch + window_offset.x + size.x - 1] = border_color;
       }
+      for (uint32_t y = window_offset.y + 1; y < window_offset.y + size.y - 1; ++y)
+        for (uint32_t x = window_offset.x + 1; x < window_offset.x + size.x - 1; ++x)
+          pixbuf[y * pitch + x] = bg;
+    }
 
-      for (uint32_t y = 1; y < size.y - 1; ++y)
-        for (uint32_t x = 1; x < size.x - 1; ++x)
-          pixbuf[(window_offset.y + y) * pitch + (window_offset.x + x)] = bg;
-
-      paint_text(pixbuf, pitch);
+    if (next_paint_full || text_change) {
+      for (uint32_t y = window_offset.y + 3; y < window_offset.y + size.y - 3; ++y)
+        for (uint32_t x = window_offset.x + 3; x < window_offset.x + size.x - 3; ++x)
+          pixbuf[y * pitch + x] = bg;
+      flower.draw_text(pixbuf + (window_offset.y + 3) * pitch + window_offset.x + 3, pitch, fi, fg);
     }
 
-    else if (text_changed_since_last_paint) {
-      for (uint32_t y = 3; y < size.y - 3; ++y)
-        for (uint32_t x = 3; x < size.x - 3; ++x)
-          pixbuf[(window_offset.y + y) * pitch + (window_offset.x + x)] = bg;
-      paint_text(pixbuf, pitch);
-      text_changed_since_last_paint = false;
+    else if ((cursor_change || !is_cur) && was_cur_before) {
+      const uint32_t y_start = window_offset.y + 3 + fi->space_height * old_cur_y;
+      const uint32_t x_start = window_offset.x + 3 + fi->space_width  * old_cur_x;
+      if (old_cur_x == cols)
+        for (uint32_t y = y_start; y < y_start + fi->char_height; ++y) {
+          pixbuf[y * pitch + x_start] = bg;
+          pixbuf[y * pitch + x_start + 1] = bg;
+        }
+      else
+        put_char(fi, flower.get_nth_line(old_cur_y)[old_cur_x],
+                 pixbuf + y_start * pitch + x_start, pitch, bg, fg);
     }
 
-    else if (had_focus_last_paint) {
-      for (uint32_t y = 0; y < fi->char_height; ++y) {
-        old_cur_ptr[y * pitch] = bg;
-        old_cur_ptr[y * pitch + 1] = bg;
-      }
-      if (data[cur_d_last_paint] && (data[cur_d_last_paint] != '\n') && (cur_d_last_paint < line_indices[cur_y_last_paint + 1]))
-        put_char_no_bg(fi, data[cur_d_last_paint], old_cur_ptr, pitch, fg);
+    if (is_cur) {
+      const uint32_t y_start = window_offset.y + 3 + fi->space_height * cur_y;
+      const uint32_t x_start = window_offset.x + 3 + fi->space_width  * cur_x;
+      if (old_cur_x == cols)
+        for (uint32_t y = y_start; y < y_start + fi->char_height; ++y) {
+          pixbuf[y * pitch + x_start] = fg;
+          pixbuf[y * pitch + x_start + 1] = fg;
+        }
     }
 
-    if (has_focus)
-      for (uint32_t y = 0; y < fi->char_height; ++y) {
-        cur_ptr[y * pitch] = fg;
-        cur_ptr[y * pitch + 1] = fg;
-      }
+    next_paint_full = false;
+    text_change = false;
+    cursor_change = false;
 
-    cur_y_last_paint = cur_y;
-    cur_x_last_paint = cur_x;
-    cur_d_last_paint = cur_d;
-    had_focus_last_paint = has_focus;
+    was_cur_before = is_cur;
+    old_cur_x = cur_x;
+    old_cur_y = cur_y;
   }
 
-  void entry::ensure_cursor_in_line() {
-    cur_d = line_indices[cur_y] + cur_x;
-    if (cur_d >= line_indices[cur_y + 1]) {
-      cur_d = line_indices[cur_y + 1] - 1;
-      if (data[cur_d] && (data[cur_d] != '\n'))
-        ++cur_d;
-      cur_x = cur_d - line_indices[cur_y];
-    }
-  }
+  void entry::notify_has_opaque_parent(widget *parent) {}
 
   void entry::handle_click(coord window_coords, enum mouse_packet::mouse_button click_type, bool up) {
     if (up || (click_type != mouse_packet::LEFT))
       return;
 
-    if (window_coords.x - window_offset.x < 3)
-      window_coords.x = 3 + window_offset.x;
-    else if (window_coords.x - window_offset.x > size.x - 4)
-      window_coords.x = size.x - 4 + window_offset.x;
-    if (window_coords.y - window_offset.y < 3)
-      window_coords.y = 3 + window_offset.y;
-    else if (window_coords.y - window_offset.y > size.y - 4)
-      window_coords.y = size.y - 4 + window_offset.y;
+    if (window_coords.x < window_offset.x)
+      window_coords.x = window_offset.x;
+    if (window_coords.y < window_offset.y)
+      window_coords.y = window_offset.y;
 
-    cur_y = (window_coords.y - window_offset.y - 3) / fi->space_height;
-    cur_x = (window_coords.x - window_offset.x - 3) / fi->space_width;
-    if (cur_y > end_y) {
-      cur_y = end_y;
-      cur_x = end_x;
-    }
-    ensure_cursor_in_line();
+    cur_x = (window_coords.x - window_offset.x) / fi->space_width;
+    cur_y = (window_coords.y - window_offset.y) / fi->space_height;
 
-    if (has_focus)
-      w->notify_needs_paint(*this);
-    else
-      w->focus(*this);
+    check_y();
+    check_x();
+    on_cursor_change();
   }
 
-  void entry::notify_has_opaque_parent(widget *parent) {}
+  void entry::check_y() {
+    if (cur_y >= flower.get_n_lines())
+      cur_y = flower.get_n_lines() - 1;
+  }
 
-  bool entry::cursor_left() {
-    if (cur_x) {
-      --cur_x;
-      --cur_d;
-      return true;
-    }
-    if (!cur_y)
-      return false;
+  void entry::check_x() {
+    if (cur_x > strlen(flower.get_nth_line(cur_y)))
+      cur_x = strlen(flower.get_nth_line(cur_y));
+  }
 
-    --cur_y;
-    cur_x = line_indices[cur_y + 1] - line_indices[cur_y] - 1;
-    if (cur_x == cols)
-      --cur_x;
-    cur_d = line_indices[cur_y] + cur_x;
-    return true;
+  void entry::on_text_change() {
+    flower.s = text_back.buf;
+    flower.flow_text();
+    text_change = true;
+    w->notify_needs_paint(*this);
   }
 
-  bool entry::cursor_right() {
-    if (cur_d >= (end_d - 1))
-      return false;
+  void entry::on_cursor_change() {
+    cursor_change = true;
+    w->notify_needs_paint(*this);
+  }
 
-    ++cur_d;
-    ++cur_x;
+  void entry::handle_key(struct key_packet kp) {
+    const uint32_t pos = flower.get_line_offset(cur_y) + cur_x;
+    const char ch = key_to_char(kp);
+
+    if (kp.key_id == kp.KEY_BSPACE) {
+      if (pos) {
+        text_back.remove(pos - 1);
+        left();
+        on_text_change();
+      }
+    }
 
-    if (cur_d >= line_indices[cur_y + 1]) {
-      cur_x = 0;
-      ++cur_y;
-      cur_d = line_indices[cur_y];
+    else if (kp.key_id == kp.KEY_DELETE) {
+      if (pos != text_back.n_entries - 1) {
+        text_back.remove(pos);
+        on_text_change();
+      }
     }
 
-    return true;
+    else if (kp.key_id == kp.KEY_LEFT_ARROW)
+      left();
+    else if (kp.key_id == kp.KEY_RIGHT_ARROW)
+      right();
+    else if (kp.key_id == kp.KEY_UP_ARROW)
+      up();
+    else if (kp.key_id == kp.KEY_DOWN_ARROW)
+      down();
+
+    else if (ch) {
+      text_back.insert(pos, ch);
+      on_text_change();
+    }
   }
 
-  bool entry::cursor_up() {
-    if (!cur_y)
-      return false;
-
-    --cur_y;
-    ensure_cursor_in_line();
-    return true;
+  void entry::left() {
+    if (cur_x)
+      --cur_x;
+    else if (cur_y) {
+      --cur_y;
+      check_x();
+    }
+    else
+      return;
+    on_cursor_change();
   }
 
-  bool entry::cursor_down() {
-    if (cur_y == end_y)
-      return false;
+  void entry::right() {
+    if (++cur_x <= strlen(flower.get_nth_line(cur_y)))
+      on_cursor_change();
+    else if (cur_y != flower.get_n_lines()) {
+      ++cur_y;
+      cur_x = 0;
+      on_cursor_change();
+    }
+  }
 
-    ++cur_y;
-    ensure_cursor_in_line();
-    return true;
+  void entry::up() {
+    if (cur_y) {
+      --cur_y;
+      check_x();
+      on_cursor_change();
+    }
+    else if (!cur_x) {
+      cur_x = 0;
+      on_cursor_change();
+    }
   }
 
-  void entry::handle_key(struct key_packet kp) {
-    switch (kp.key_id) {
-    case kp.KEY_LEFT_ARROW:
-      if (cursor_left() && has_focus)
-        w->notify_needs_paint(*this);
-      break;
-    case kp.KEY_RIGHT_ARROW:
-      if (cursor_right() && has_focus)
-        w->notify_needs_paint(*this);
-      break;
-    case kp.KEY_DOWN_ARROW:
-      if (cursor_down() && has_focus)
-        w->notify_needs_paint(*this);
-      break;
-    case kp.KEY_UP_ARROW:
-      if (cursor_up() && has_focus)
-        w->notify_needs_paint(*this);
-      break;
-    case kp.KEY_HOME:
-      if (cur_x) {
-        cur_x = 0;
-        if (has_focus)
-          w->notify_needs_paint(*this);
-      }
-      break;
-    case kp.KEY_END:
-      cur_x = cols;
-      ensure_cursor_in_line();
-      if (has_focus)
-        w->notify_needs_paint(*this);
-      break;
-    default:
-      break;
+  void entry::down() {
+    if (cur_y != flower.get_n_lines()) {
+      ++cur_y;
+      check_x();
+      on_cursor_change();
+    }
+    else if (cur_x < strlen(flower.get_nth_line(cur_y))) {
+      cur_x = strlen(flower.get_nth_line(cur_y));
+      on_cursor_change();
     }
   }
 
   void entry::on_focus() {
-    has_focus = true;
+    is_cur = true;
     w->notify_needs_paint(*this);
   }
 
   void entry::on_unfocus() {
-    has_focus = false;
+    is_cur = false;
     w->notify_needs_paint(*this);
   }
-
-  const char *entry::get_contents() {
-    return data;
-  }
 }
\ No newline at end of file