many, many changes; settings is broken

45 files changed, 894 insertions, 810 deletions

diff --git a/src/user/filetest/filetest.c b/src/user/filetest/filetest.c
index e7792ff..af01e1c 100644
--- a/src/user/filetest/filetest.c
+++ b/src/user/filetest/filetest.c
@@ -1,7 +1,7 @@
 #include <libterm/terminal.h>
 #include <knob/file.h>
 
-#define TEST_FILE "user/test.txt"
+#define TEST_FILE "/user/test.txt"
 
 void main() {
   struct file *f = open_file(TEST_FILE);
diff --git a/src/user/highway/main.c b/src/user/highway/main.c
index bcc3e01..8aa40b8 100644
--- a/src/user/highway/main.c
+++ b/src/user/highway/main.c
@@ -8,7 +8,7 @@
 #include "vars.h"
 
 void main(const char *arg) {
-  source(*arg ? arg : "user/default.rc");
+  source(*arg ? arg : "/user/default.rc");
   ensure_color();
 
   term_add_sz("Portland Highway\nType \"help\" for help.\n");
diff --git a/src/user/include/cxx/raleigh/d/dialog.h b/src/user/include/cxx/raleigh/d/dialog.h
index f207033..1712b03 100644
--- a/src/user/include/cxx/raleigh/d/dialog.h
+++ b/src/user/include/cxx/raleigh/d/dialog.h
@@ -14,15 +14,21 @@ namespace raleigh {
     YES,
     NO,
     CANCEL,
-    RETRY
+    RETRY,
+    OKAY
   };
-  extern alist<duple<const char *, diag_result_t>> &yes_no_cancel;
-  extern alist<duple<const char *, diag_result_t>> &yes_no_retry;
+
+  typedef alist<duple<const char *, diag_result_t>> button_list;
+  extern button_list &yes_no_cancel;
+  extern button_list &yes_no_retry;
+  extern button_list &okay_cancel;
+  extern button_list &okay;
+
   class dialog : public window {
   public:
     //button names are copied
     //alist isn't needed past constructor
-    dialog(widget &top_part, alist<duple<const char *, diag_result_t>> buttons);
+    dialog(widget &top_part, button_list buttons);
 
     //zero means not set yet
     diag_result_t result;
diff --git a/src/user/include/cxx/raleigh/s/text_flower.h b/src/user/include/cxx/raleigh/s/text_flower.h
new file mode 100644
index 0000000..f5cfcca
--- /dev/null
+++ b/src/user/include/cxx/raleigh/s/text_flower.h
@@ -0,0 +1,40 @@
+#ifndef RALEIGH_S_TEXT_FLOWER_H
+#define RALEIGH_S_TEXT_FLOWER_H
+
+#include <libfont/fonts.h>
+#include <structs/alist.h>
+
+namespace raleigh {
+  class text_flower {
+  public:
+    //max_rows or cols 0 means no limit
+    //s is not copied
+    text_flower(const char *s, uint32_t cols=50, uint32_t max_rows=0);
+
+    uint32_t get_n_lines() __attribute__ ((pure));
+    //not a copy
+    char *get_nth_line(uint32_t n) __attribute__ ((pure));
+    uint32_t get_line_offset(uint32_t n) __attribute__ ((pure));
+
+    void draw_text(_pixel_t *start, uint32_t pitch, const struct font_info *fi, _pixel_t color);
+    void flow_text();
+
+    //call flow_text after any changes
+    const char *s;
+
+  private:
+    alist<char *> lines;
+    alist<uint32_t> offsets;
+
+    uint32_t max_rows;
+    uint32_t cols;
+
+    //for use inside flow_text
+    const char *on_char;
+    const char *line_start;
+    uint32_t row_len;
+    void push_line();
+  };
+}
+
+#endif
\ No newline at end of file
diff --git a/src/user/include/cxx/raleigh/util.h b/src/user/include/cxx/raleigh/util.h
index 9142b69..c366e80 100644
--- a/src/user/include/cxx/raleigh/util.h
+++ b/src/user/include/cxx/raleigh/util.h
@@ -5,6 +5,9 @@
 
 #define RGB(R, G, B) ((_pixel_t){.r = 0x##R, .g = 0x##G, .b = 0x##B})
 
+#define RALEIGH_FG RGB(00, 00, 00)
+#define RALEIGH_BG RGB(bf, bf, bf)
+
 namespace raleigh {
   struct coord {
     uint32_t x;
@@ -14,6 +17,7 @@ namespace raleigh {
   };
 
   void show_error_and_quitf(const char *fmt, ...) __attribute__ ((noreturn));
+  void show_error_popup_and_quitf(const char *fmt, ...) __attribute__ ((noreturn));
 }
 
 #endif
\ No newline at end of file
diff --git a/src/user/include/cxx/raleigh/w/entry.h b/src/user/include/cxx/raleigh/w/entry.h
index c86b281..cc797b0 100644
--- a/src/user/include/cxx/raleigh/w/entry.h
+++ b/src/user/include/cxx/raleigh/w/entry.h
@@ -1,72 +1,61 @@
 #ifndef RALEIGH_W_ENTRY_H
 #define RALEIGH_W_ENTRY_H
 
+#include <raleigh/s/text_flower.h>
 #include <raleigh/widget.h>
 #include <libfont/fonts.h>
 
 namespace raleigh {
   class entry : public widget {
   public:
-    //default_text's data is copied, so it's okay if it changes or if the memory is freed
     entry(uint32_t rows=25, uint32_t cols=25, const char *default_text="",
-          const char *font="fixed-10", _pixel_t bg=RGB(ff, ff, ff),
+          const struct font_info *fi=get_font("fixed-10"), _pixel_t bg=RGB(ff, ff, ff),
           _pixel_t fg=RGB(00, 00, 00), _pixel_t border_color=RGB(00, 00, 00));
 
     //not a copy
-    const char *get_contents();
-    //s's data is copied
+    const char *get_contents() __attribute__ ((pure));
+    //s is copied
     void set_contents(const char *s);
 
-    void notify_window_change() override;
     void paint(_pixel_t *pixbuf, uint32_t pitch) override;
-    void handle_click(coord window_coords, enum mouse_packet::mouse_button click_type, bool up) override;
     void notify_has_opaque_parent(widget *parent) override;
+    void handle_click(coord window_coords, enum mouse_packet::mouse_button click_type, bool up) override;
     void handle_key(struct key_packet kp) override;
     void on_focus() override;
     void on_unfocus() override;
+
   private:
+    const struct font_info *fi;
+    _pixel_t border_color;
+    _pixel_t fg;
+    _pixel_t bg;
     uint32_t rows;
     uint32_t cols;
-    _pixel_t bg;
-    _pixel_t fg;
-    _pixel_t border_color;
 
-    struct font_info *fi;
-    char *data;
-    //line_indices[end_y + 1] == end_d
-    uint32_t *line_indices;
+    void left();
+    void right();
+    void up();
+    void down();
 
-    uint32_t cur_y;
-    uint32_t cur_x;
-    uint32_t cur_d;
+    void check_y();
+    void check_x();
 
-    //the row of the last character
-    uint32_t end_y;
-    //the column after the last character
-    uint32_t end_x;
-    //the index of the null terminator
-    uint32_t end_d;
+    void on_text_change();
+    void on_cursor_change();
 
-    bool has_focus;
-    bool had_focus_last_paint;
-    bool text_changed_since_last_paint;
-    uint32_t cur_y_last_paint;
-    uint32_t cur_x_last_paint;
-    uint32_t cur_d_last_paint;
+    alist<char> text_back;
+    text_flower flower;
 
-    //uses cur_x, not cur_d; sets both
-    //will not modify cur_y
-    void ensure_cursor_in_line();
+    bool text_change;
+    bool cursor_change;
 
-    void paint_text(_pixel_t *pixbuf, uint32_t pitch);
-    //sets line_indices[from_y + 1 .. end_y + 1], end_y, end_x and end_d
-    void get_indices(uint32_t from_y, uint32_t from_x, uint32_t from_d);
+    bool was_cur_before;
+    uint32_t old_cur_x;
+    uint32_t old_cur_y;
 
-    //these four return true on success, and do not send a paint request to the window
-    bool cursor_left();
-    bool cursor_right();
-    bool cursor_up();
-    bool cursor_down();
+    bool is_cur;
+    uint32_t cur_x;
+    uint32_t cur_y;
   };
 }
 
diff --git a/src/user/include/cxx/raleigh/w/label.h b/src/user/include/cxx/raleigh/w/label.h
index a78ce46..ebc6890 100644
--- a/src/user/include/cxx/raleigh/w/label.h
+++ b/src/user/include/cxx/raleigh/w/label.h
@@ -1,6 +1,7 @@
 #ifndef RALEIGH_W_LABEL_H
 #define RALEIGH_W_LABEL_H
 
+#include <raleigh/s/text_flower.h>
 #include <raleigh/widget.h>
 #include <libfont/fonts.h>
 
@@ -8,20 +9,27 @@ namespace raleigh {
   class label : public widget {
   public:
     //value's data is copied
-    label(const char *value, const char *font="fixed-10", bool bg_transparent=true,
-      _pixel_t fg=RGB(00, 00, 00), _pixel_t bg=RGB(bf, bf, bf));
+    label(const char *value, const char *font="fixed-10",
+          uint32_t cols=0, bool bg_transparent=true,
+          _pixel_t fg=RALEIGH_FG, _pixel_t bg=RALEIGH_BG);
 
+    ~label();
+
+    //new_value's data is copied
     void change_value(const char *new_value);
 
     void paint(_pixel_t *pixbuf, uint32_t pitch) override;
     void notify_has_opaque_parent(widget *parent) override;
   private:
-    char *value;
-    uint32_t v_size;
     const struct font_info *const fi;
+    uint32_t cols;
     bool bg_transparent;
     const _pixel_t fg;
     const _pixel_t bg;
+
+    text_flower tf;
+
+    coord determine_size();
   };
 }
 
diff --git a/src/user/include/cxx/raleigh/widget.h b/src/user/include/cxx/raleigh/widget.h
index b53718a..cbd499c 100644
--- a/src/user/include/cxx/raleigh/widget.h
+++ b/src/user/include/cxx/raleigh/widget.h
@@ -12,7 +12,7 @@ namespace raleigh {
 namespace raleigh {
   class widget {
   public:
-    //these three are set by window class (or parent widget)
+    //these four are set by window class (or parent widget)
     widget *parent;//set to zero when root widget
     window *w;
     coord window_offset;
diff --git a/src/user/include/cxx/raleigh/window.h b/src/user/include/cxx/raleigh/window.h
index 3448536..63a3786 100644
--- a/src/user/include/cxx/raleigh/window.h
+++ b/src/user/include/cxx/raleigh/window.h
@@ -20,7 +20,7 @@ namespace raleigh {
     friend void start_runtime();
   public:
     //pass on_close to specify a close handler. if on_close returns false, the window will not be closed.
-    window(widget &root, _pixel_t bg_color=RGB(bf, bf, bf), bool (*on_close)(window_tag_t)=0, window_tag_t tag=0);
+    window(widget &root, _pixel_t bg_color=RALEIGH_BG, bool (*on_close)(window_tag_t)=0, window_tag_t tag=0);
     void add_keybind(struct key_packet kp, void (*handler)(window_tag_t));
 
     void notify_needs_paint(widget &from);
diff --git a/src/user/include/cxx/structs/alist.h b/src/user/include/cxx/structs/alist.h
index 050f775..13a24c4 100644
--- a/src/user/include/cxx/structs/alist.h
+++ b/src/user/include/cxx/structs/alist.h
@@ -15,20 +15,67 @@ public:
   uint32_t expand_by;
   data *buf;
 
-  alist(uint32_t default_size=10, uint32_t expand_by=10)
+  alist(uint32_t default_size = 10, uint32_t expand_by = 10)
     : n_entries(0), buf_size(default_size), expand_by(expand_by),
-      buf((data *)get_block(default_size * sizeof(data))) {}
+      buf(new data[default_size]) {}
+
+  //from is copied
+  alist(const data *from, uint32_t count, uint32_t extra_size = 10, uint32_t expand_by = 10)
+    : n_entries(count), buf_size(count + extra_size), expand_by(expand_by),
+      buf(new data[count + extra_size]) {
+    for (uint32_t i = 0; i < count; ++i)
+      buf[i] = from[i];
+  }
+
+  ~alist() {
+    delete[] buf;
+  }
+
+  void copy_from(const data *from, uint32_t count) {
+    expand_to(count);
+    n_entries = count;
+    for (uint32_t i = 0; i < count; ++i)
+      buf[i] = from[i];
+  }
+
+  void expand_to(uint32_t size) {
+    if (size <= buf_size)
+      return;
+    data *const new_buf = new data[size * sizeof(data)];
+    for (uint32_t i = 0; i < buf_size; ++i)
+      new_buf[i] = buf[i];
+    delete[] buf;
+    buf = new_buf;
+    buf_size = size;
+  }
+
+  void copy_from(const alist<data> &other) {
+    expand_to(n_entries = other.n_entries);
+    for (uint32_t i = 0; i < n_entries; ++i)
+      buf[i] = other.buf[i];
+  }
 
   void add_back(data d) {
-    if (n_entries == buf_size) {
-      data *const new_buf = (data *)get_block((buf_size += expand_by) * sizeof(data));
-      blockcpy(new_buf, buf, n_entries * sizeof(data));
-      free_block(buf);
-      buf = new_buf;
-    }
+    if (n_entries == buf_size)
+      expand_to(buf_size + expand_by);
     buf[n_entries++] = d;
   }
 
+  void insert(uint32_t i, data d) {
+    if (n_entries == buf_size)
+      expand_to(buf_size + expand_by);
+    for (uint32_t n = n_entries; n > i; --n)
+      buf[n] = buf[n - 1];
+    buf[i] = d;
+    ++n_entries;
+  }
+
+  void remove(uint32_t i) {
+    --n_entries;
+    for (uint32_t n = i; n < n_entries; ++n)
+      buf[n] = buf[n + 1];
+  }
+
   //returns -1 if not found
   uint32_t index_of(data d) {
     for (uint32_t i = 0; i < n_entries; ++i)
diff --git a/src/user/include/cxx/structs/duple.h b/src/user/include/cxx/structs/duple.h
index 874e4f6..0b23c92 100644
--- a/src/user/include/cxx/structs/duple.h
+++ b/src/user/include/cxx/structs/duple.h
@@ -4,6 +4,7 @@
 template<class at, class bt>
 class duple {
 public:
+  duple() : a(), b() {}
   duple(at a, bt b)
     : a(a), b(b) {}
   at a;
diff --git a/src/user/include/cxx/structs/map.h b/src/user/include/cxx/structs/map.h
index f9c477f..311bfa9 100644
--- a/src/user/include/cxx/structs/map.h
+++ b/src/user/include/cxx/structs/map.h
@@ -3,12 +3,7 @@
 
 #include <structs/alist.h>
 
-template<class type>
-bool default_equals(type a, type b) {
-  return a == b;
-}
-
-template<class key, class value, bool (*equals)(key, key) = &default_equals<key>>
+template<class key, class value, bool (*equals)(key, key) = &key::operator==>
 class map {
 public:
   alist<key> keys;
diff --git a/src/user/include/knob/block.h b/src/user/include/knob/block.h
index 27cb83b..5766245 100644
--- a/src/user/include/knob/block.h
+++ b/src/user/include/knob/block.h
@@ -16,6 +16,7 @@ uint32_t strcpy(char *to, const char *from);
 
 //allocates new memory
 char *strdup(const char *from);
+char *strndup(const char *from, uint32_t new_len);
 
 //without null-terminator
 uint32_t strlen(const char *str) __attribute__ ((pure));
diff --git a/src/user/include/knob/file.h b/src/user/include/knob/file.h
index 04fc201..f98a15c 100644
--- a/src/user/include/knob/file.h
+++ b/src/user/include/knob/file.h
@@ -10,13 +10,11 @@ extern "C" {
 
 struct file;
 
-const char *remove_prefix(const char *path, uint8_t *dn_out);
-
 struct file *open_file(const char *path);
 void close_file(struct file *f);
 
 uint32_t read_from_file(struct file *f, uint32_t max, void *buf);
-uint32_t write_to_file(struct file *f, uint32_t max, void *buf);
+uint32_t write_to_file(struct file *f, uint32_t max, const void *buf);
 //return value and max_length don't include null terminator
 uint32_t read_line_from_file(struct file *f, char *sz, uint32_t max_length);
 uint32_t seek_file_to(struct file *f, uint32_t to);
diff --git a/src/user/include/knob/heap.h b/src/user/include/knob/heap.h
index c0d7006..d7b0773 100644
--- a/src/user/include/knob/heap.h
+++ b/src/user/include/knob/heap.h
@@ -8,7 +8,7 @@ extern "C" {
 #include <stdint.h>
 
 void *get_block(uint32_t bytes) __attribute__ ((malloc));
-void free_block(void *block);
+void free_block(const void *block);
 
 #ifdef __cplusplus
 }
diff --git a/src/user/include/libterm/terminal.h b/src/user/include/libterm/terminal.h
index 40536e0..a069a22 100644
--- a/src/user/include/libterm/terminal.h
+++ b/src/user/include/libterm/terminal.h
@@ -1,6 +1,10 @@
 #ifndef LIBTERM_TERMINAL_H
 #define LIBTERM_TERMINAL_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <pland/syscall.h>
 
 #include <stdarg.h>
@@ -32,4 +36,8 @@ void term_addf(const char *fmt, ...);
 
 struct key_packet term_get_key_blocking();
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
\ No newline at end of file
diff --git a/src/user/include/pland/syscall.h b/src/user/include/pland/syscall.h
index 1e040f4..566e7b8 100644
--- a/src/user/include/pland/syscall.h
+++ b/src/user/include/pland/syscall.h
@@ -127,8 +127,8 @@ static inline void _exit_task() {
   __builtin_unreachable();
 }
 
-static inline _file_handle_t _open_file(_drive_number_t drive_number, const char *path) {
-  return (_file_handle_t)_sc2(_SCN_OPEN_FILE, drive_number, (uint32_t)path);
+static inline _file_handle_t _open_file(const char *path) {
+  return (_file_handle_t)_sc1(_SCN_OPEN_FILE, (uint32_t)path);
 }
 
 static inline void _close_file(_file_handle_t handle) {
@@ -143,8 +143,8 @@ static inline uint32_t _file_size(_file_handle_t handle) {
   return _sc1(_SCN_FILE_SIZE, handle);
 }
 
-static inline _task_handle_t _start_task(_drive_number_t drive_number, const char *path, const char *pass, _task_handle_t stdio_task) {
-  return (_task_handle_t)_sc4(_SCN_START_TASK, drive_number, (uint32_t)path, (uint32_t)pass, (uint32_t)stdio_task);
+static inline _task_handle_t _start_task(const char *path, const char *pass, _task_handle_t stdio_task) {
+  return (_task_handle_t)_sc3(_SCN_START_TASK, (uint32_t)path, (uint32_t)pass, (uint32_t)stdio_task);
 }
 
 static inline uint32_t _ipc_send(_task_handle_t handle, uint32_t count, const void *buffer) {
@@ -183,12 +183,12 @@ static inline void _wait_for_task(_task_handle_t handle) {
   _sc1(_SCN_WAIT_FOR_TASK, handle);
 }
 
-static inline uint32_t _enumerate_dir(_drive_number_t drive_number, const char *path, _dir_info_entry_t *buffer, uint32_t max_count) {
-  return _sc4(_SCN_ENUMERATE_DIR, drive_number, (uint32_t)path, (uint32_t)buffer, max_count);
+static inline uint32_t _enumerate_dir(const char *path, _dir_info_entry_t *buffer, uint32_t max_count) {
+  return _sc3(_SCN_ENUMERATE_DIR, (uint32_t)path, (uint32_t)buffer, max_count);
 }
 
-static inline uint32_t _count_of_dir(uint8_t drive_number, const char *path) {
-  return _sc2(_SCN_COUNT_OF_DIR, drive_number, (uint32_t)path);
+static inline uint32_t _count_of_dir(const char *path) {
+  return _sc1(_SCN_COUNT_OF_DIR, (uint32_t)path);
 }
 
 static inline _window_handle_t _new_window(uint16_t width, uint16_t height, _pixel_t *pixel_buffer) {
diff --git a/src/user/init/init.c b/src/user/init/init.c
index 860c45f..0934943 100644
--- a/src/user/init/init.c
+++ b/src/user/init/init.c
@@ -1,7 +1,8 @@
+#include <knob/block.h>
 #include <knob/file.h>
 #include <knob/task.h>
 
-#define STARTUP_FILE_PATH "sys/startup.rc"
+#define STARTUP_FILE_PATH "/sys/startup.rc"
 #define CMD_BUF_LEN 1024
 
 char cmdbuf[CMD_BUF_LEN];
@@ -16,11 +17,9 @@ void main() {
   while (read_line_from_file(f, cmdbuf, CMD_BUF_LEN - 1)) {
     if (cmdbuf[0] == '#')
       continue;
-  //syslogf(run_command(cmdbuf)
-  //  ? "[init] Started %s."
-  //  : "[init] Could not run %s."
-  //, cmdbuf);
-    run_command(cmdbuf, 0);
+    bool started = (bool)run_command(cmdbuf, 0);
+    str_trunc_fill(cmdbuf, 30);
+    syslogf(started ? "Started %s" : "Could not start %s", cmdbuf);
   }
 
   close_file(f);
diff --git a/src/user/knob/block.c b/src/user/knob/block.c
index 9f3f353..8b9971f 100644
--- a/src/user/knob/block.c
+++ b/src/user/knob/block.c
@@ -1,4 +1,5 @@
 #include <knob/panic.h>
+#include <knob/block.h>
 #include <knob/heap.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -28,13 +29,22 @@ uint32_t strcpy(char *to, const char *from) {
 }
 
 char *strdup(const char *from) {
-  const char *end = from;
-  while (*(end++))
-    ;
-  char *buf = get_block(end - from);
-  if (!buf)
-    PANIC("get_block returned 0 in strdup");
-  blockcpy(buf, from, end - from);
+  const uint32_t len = strlen(from) + 1;
+  char *buf = get_block(len);
+  blockcpy(buf, from, len);
+  return buf;
+}
+
+char *strndup(const char *from, uint32_t n) {
+  uint32_t len = strlen(from) + 1;
+  if (n < len) {
+    char *buf = get_block(n + 1);
+    blockcpy(buf, from, n);
+    buf[n] = '\0';
+    return buf;
+  }
+  char *buf = get_block(len);
+  blockcpy(buf, from, len);
   return buf;
 }
 
diff --git a/src/user/knob/file.c b/src/user/knob/file.c
index 999778e..d844588 100644
--- a/src/user/knob/file.c
+++ b/src/user/knob/file.c
@@ -29,7 +29,7 @@ struct file {
 };
 
 struct file *open_file(const char *path) {
-  _file_handle_t h = _open_file(0, path);
+  _file_handle_t h = _open_file(path);
   if (!h)
     return 0;
 
@@ -125,13 +125,13 @@ void trunc_file(struct file *f) {
 
 //return value must be manually freed, unless it is a null pointer
 _dir_info_entry_t *get_directory_info(const char *path, uint32_t *count_out) {
-  uint32_t count = _count_of_dir(0, path);
+  uint32_t count = _count_of_dir(path);
   if (!count) {
     *count_out = 0;
     return 0;
   }
 
   _dir_info_entry_t *buffer = get_block(count * sizeof(_dir_info_entry_t));
-  *count_out = _enumerate_dir(0, path, buffer, count);
+  *count_out = _enumerate_dir(path, buffer, count);
   return buffer;
 }
\ No newline at end of file
diff --git a/src/user/knob/heap.c b/src/user/knob/heap.c
index 6e57000..c4b810e 100644
--- a/src/user/knob/heap.c
+++ b/src/user/knob/heap.c
@@ -1,128 +1,141 @@
-#include <knob/format.h>
-
 #include <pland/syscall.h>
-
+#include <pland/pcrt.h>
 #include <stdbool.h>
 #include <stdint.h>
 
-//structure appears at the start of each block
-struct block_header {
-  struct block_header *next;
-  struct block_header *prev;
+#define MIN_NEW_CHUNK_PAGES 16
 
-  //does not include header
-  uint32_t length;
-  bool allocated;
+struct desc_page_head {
+  void *next_page;//0 for last one
 };
 
-static struct block_header *first_block = 0;
+struct chunk_desc {
+  void *start;//0 for a desc not in use
+  uint32_t length;
+  bool available;
+} __attribute__ ((packed));
+//without packing, it is 12 bytes and we get 341 per page
+//with    packing, it is  9 bytes and we get 454 per page
+//maybe i should make available just the top bit of length
+//then we get 511 per page, but length has a max of 2^31-1
+
+static struct desc_page_head *first_desc_page = 0;
+static struct desc_page_head *last_desc_page = 0;
+
+#define DESCS_PER_PAGE ((4096 - sizeof(struct desc_page_head)) / sizeof(struct chunk_desc))
+#define PAGE_AS_ARRAY(p) ((struct chunk_desc *)((void *)p + sizeof(struct desc_page_head)))
+
+static char size_was_buf[] = "size was ......... kB";
+//kb should be < 1 000 000 000
+static void log_size_was(uint32_t kb) {
+  for (int8_t d = 9; d != -1; --d) {
+    size_was_buf[9 + d] = (kb % 10) + '0';
+    kb /= 10;
+  }
+  _system_log(size_was_buf);
+}
 
-static void add_header(struct block_header *bh) {
-  bh->next = first_block;
-  bh->prev = 0;
-  if (first_block)
-    first_block->prev = bh;
-  first_block = bh;
+static const char *const hextab = "0123456789abcdef";
+static char caller_was_buf[] = "return address is 0x........";
+static void log_caller_was(void *addr) {
+  const uint32_t as_int = (uint32_t)addr;
+  for (uint8_t i = 0; i < 8; ++i)
+    caller_was_buf[27 - i] = hextab[(as_int >> (4 * i)) & 0xf];
+  _system_log(caller_was_buf);
 }
 
-//static const char *const hextab = "0123456789abcdef";
-//static char *const get_debug = "getting 0x........ byte block";
-//static char *const free_debug = "freeing 0x........ byte block";
+static struct desc_page_head *new_desc_page() {
+  struct desc_page_head *dph = _allocate_ram(1);
+  if (!dph) {
+    _system_log("knob heap could not allocate new descriptor page");
+    log_size_was(4);
+    __pcrt_quit();
+  }
+  dph->next_page = 0;
+  if (last_desc_page)
+    last_desc_page->next_page = dph;
+  last_desc_page = dph;
+
+  struct chunk_desc *const a = PAGE_AS_ARRAY(dph);
+  for (uint32_t i = 0; i < DESCS_PER_PAGE; ++i)
+    a[i].start = 0;
 
-__attribute__ ((malloc))
-void *get_block(uint32_t bytes) {
-  if (!bytes)
-    return 0;
-//for (uint8_t i = 0; i < 8; ++i)
-//  get_debug[10 + 7 - i] = hextab[(bytes >> (i * 4)) & 0xf];
-//_system_log(get_debug);
-
-  struct block_header *header = 0;
-  for (struct block_header *ptr = first_block; ptr; ptr = ptr->next) {
-    if (ptr->allocated)
-      continue;
-    if (ptr->length == bytes) {
-      header = ptr;
-      break;
-    }
-    if (ptr->length > bytes + sizeof(struct block_header)) {
-      struct block_header *bh = (void *)ptr + sizeof(struct block_header) + bytes;
+  return dph;
+}
+
+static struct chunk_desc *unused_desc() {
+  for (struct desc_page_head *i = first_desc_page; i; i = i->next_page) {
+    struct chunk_desc *const a = PAGE_AS_ARRAY(i);
+    for (uint32_t i = 0; i < DESCS_PER_PAGE; ++i)
+      if (!a[i].start)
+        return a + i;
+  }
 
-      bh->length = ptr->length - sizeof(struct block_header) - bytes;
-      bh->allocated = false;
-      add_header(bh);
+  return PAGE_AS_ARRAY(new_desc_page());
+}
 
-      ptr->length = bytes;
-      header = ptr;
-      break;
+__attribute__ ((malloc))
+void *get_block(uint32_t bytes) {
+  if (!first_desc_page)
+    first_desc_page = new_desc_page();
+
+  struct chunk_desc *best_fit = 0;
+
+  for (struct desc_page_head *i = first_desc_page; i; i = i->next_page) {
+    struct chunk_desc *const a = PAGE_AS_ARRAY(i);
+    for (uint32_t i = 0; i < DESCS_PER_PAGE; ++i) {
+      if (!a[i].start || !a[i].available || (a[i].length < bytes))
+        continue;
+      if (a[i].length == bytes) {
+        a[i].available = false;
+        return a[i].start;
+      }
+      if (!best_fit || (a[i].length < best_fit->length))
+        best_fit = a + i;
     }
   }
 
-  if (!header) {
-    uint32_t size_with_header = bytes + sizeof(struct block_header);
-    if (!(size_with_header % 4096)) {
-      header = _allocate_ram(size_with_header / 4096);
-      if (!header)
-        return 0;
-      header->length = bytes;
-      add_header(header);
+  if (!best_fit) {
+    const uint32_t pages_needed = (bytes - 1) / 4096 + 1;
+    const uint32_t allocating = pages_needed < MIN_NEW_CHUNK_PAGES ? MIN_NEW_CHUNK_PAGES : pages_needed;
+    void *const new_chunk = _allocate_ram(allocating);
+    if (!new_chunk) {
+      _system_log("knob heap could not allocate new chunk");
+      log_size_was(allocating * 4);
+      log_caller_was(__builtin_return_address(0));
+      __pcrt_quit();
     }
-    else {
-      uint32_t pages = (bytes + sizeof(struct block_header) * 2) / 4096 + 1;
-      header = _allocate_ram(pages);
-      if (!header)
-        return 0;
-      header->length = bytes;
-      add_header(header);
-
-      struct block_header *bh = (void *)header + sizeof(struct block_header) + bytes;
-      bh->length = pages * 4096 - bytes - 2 * sizeof(struct block_header);
-      bh->allocated = false;
-      add_header(bh);
+    best_fit = unused_desc();
+    best_fit->start = new_chunk;
+    best_fit->length = allocating * 4096;
+
+    if (bytes == allocating * 4096) {
+      best_fit->available = false;
+      return new_chunk;
     }
   }
 
-  header->allocated = true;
-  return (void *)header + sizeof(struct block_header);
-}
-
-static void remove_header(struct block_header *bh) {
-  if (bh == first_block)
-    first_block = bh->next;
-  if (bh->prev)
-    bh->prev->next = bh->next;
-  if (bh->next)
-    bh->next->prev = bh->prev;
-}
+  void *const old_end = best_fit->start + best_fit->length;
+  void *const new_end = best_fit->start + bytes;
 
-void free_block(void *block) {
-  struct block_header *header = block - sizeof(struct block_header);
+  best_fit->length = bytes;
+  best_fit->available = false;
 
-//for (uint8_t i = 0; i < 8; ++i)
-//  free_debug[10 + 7 - i] = hextab[(header->length >> (i * 4)) & 0xf];
-//_system_log(free_debug);
+  struct chunk_desc *const leftover = unused_desc();
+  leftover->start = new_end;
+  leftover->length = old_end - new_end;
 
-  header->allocated = false;
+  return best_fit->start;
+}
 
-  void *after = block + header->length;
-  for (struct block_header *ptr = first_block; ptr; ptr = ptr->next) {
-    if (ptr == after) {
-      if (!ptr->allocated) {
-        header->length += ptr->length + sizeof(struct block_header);
-        remove_header(ptr);
+void free_block(const void *block) {
+  for (struct desc_page_head *i = first_desc_page; i; i = i->next_page) {
+    struct chunk_desc *const a = PAGE_AS_ARRAY(i);
+    for (uint32_t i = 0; i < DESCS_PER_PAGE; ++i)
+      if (a[i].start == block) {
+        //TODO: consolidate this with surrounding free chunks
+        a[i].available = true;
+        return;
       }
-      break;
-    }
   }
-
-  //we traverse the linked list twice. it would probably be more efficient
-  //to do both finding the after and finding the before in the same loop.
-  for (struct block_header *ptr = first_block; ptr; ptr = ptr->next)
-    if ((void *)ptr + sizeof(struct block_header) + ptr->length == header) {
-      if (!ptr->allocated) {
-        ptr->length += sizeof(struct block_header) + header->length;
-        remove_header(header);
-      }
-      break;
-    }
-}
\ No newline at end of file
+}
diff --git a/src/user/knob/task.c b/src/user/knob/task.c
index 9bf2c83..ba0ac36 100644
--- a/src/user/knob/task.c
+++ b/src/user/knob/task.c
@@ -14,12 +14,12 @@ _task_handle_t run_command(const char *path, _task_handle_t stdio_task) {
       blockcpy(new_path, path, ptr - path);
       new_path[ptr - path] = '\0';
 
-      _task_handle_t handle = _start_task(0, new_path, ptr + 1, stdio_task);
+      _task_handle_t handle = _start_task(new_path, ptr + 1, stdio_task);
       free_block(new_path);
       return handle;
     }
 
-  return _start_task(0, path, "", stdio_task);
+  return _start_task(path, "", stdio_task);
 }
 
 bool try_run_command_blocking(const char *path, _task_handle_t stdio_task) {
diff --git a/src/user/libfont/fonts.c b/src/user/libfont/fonts.c
index d63a5d9..331fc47 100644
--- a/src/user/libfont/fonts.c
+++ b/src/user/libfont/fonts.c
@@ -8,8 +8,8 @@
 #include "bdf.h"
 #include "pbf.h"
 
-#define FONT_PATH "fonts/"
-#define FONT_PATH_L 6
+#define FONT_PATH "/fonts/"
+#define FONT_PATH_L 7
 
 struct font_loader_t {
   const char *ext;
diff --git a/src/user/meminfo/meminfo.cpp b/src/user/meminfo/meminfo.cpp
index 03f7ae9..c750e8b 100644
--- a/src/user/meminfo/meminfo.cpp
+++ b/src/user/meminfo/meminfo.cpp
@@ -1,49 +1,24 @@
-#include <raleigh/w/padding.h>
-#include <raleigh/w/vbox.h>
 #include <raleigh/w/label.h>
-
 #include <raleigh/runtime.h>
 #include <raleigh/window.h>
-
 #include <pland/syscall.h>
 #include <knob/format.h>
-#include <pland/pcrt.h>
 
 using namespace raleigh;
 
-label *kmem;
-label *umem;
+label *l;
 
 void refresh(window_tag_t) {
-  char *const kstr = format("kernel memory free: %uk", _kernel_dynamic_area_left() * 4);
-  char *const ustr = format("userspace memory free: %uk / %uk", _total_userspace_left() * 4, _total_userspace_size() * 4);
-
-  kmem->change_value(kstr);
-  umem->change_value(ustr);
-
-  free_block(kstr);
-  free_block(ustr);
+  char *fmt = format("Kernel memory free: %ukB\nUser memory free: %ukB\nF5 to refresh, Alt+F4 to quit", _kernel_dynamic_area_left() * 4, _total_userspace_left() * 4);
+  l->change_value(fmt);
+  free_block(fmt);
 }
 
 void main() {
-  kmem = new label("");
-  umem = new label("");
-  label msg("press Alt+F4 to quit, or F5 to refresh");
-
-  padding pkmem(*kmem, 1);
-  padding pumem(*umem, 1);
-  padding pmsg(msg, 1);
-
-  dllist<widget &> ll;
-  ll.add_front(pmsg);
-  ll.add_front(pumem);
-  ll.add_front(pkmem);
-  vbox box(ll);
-
-  padding pbox(box, 3);
-  window w(pbox);
-  w.add_keybind((struct key_packet){.key_id = key_packet::KEY_F5, .modifiers = key_packet::NO_MODS}, &refresh);
+  l = new label("");
 
+  window w(*l);
+  w.add_keybind((key_packet){.key_id = key_packet::KEY_F5, .modifiers = key_packet::NO_MODS}, &refresh);
   refresh(0);
 
   w.show();
diff --git a/src/user/mkpopup/main.cpp b/src/user/mkpopup/main.cpp
index 5e3310c..8b3746c 100644
--- a/src/user/mkpopup/main.cpp
+++ b/src/user/mkpopup/main.cpp
@@ -1,41 +1,35 @@
 #include <raleigh/w/padding.h>
 #include <raleigh/w/label.h>
-#include <raleigh/w/vbox.h>
 #include <raleigh/window.h>
-#include <knob/block.h>
 
 using namespace raleigh;
 
-widget *make_line(const char *str) {
-  return new label(str);
-}
-
 void main(const char *text) {
-  dllist<widget &> box_widgets;
-
-  char *const data = strdup(text);
-
-  char *this_string = data;
-  while (*this_string) {
-    char *i = this_string;
-    while (1) {
-      if (!i[0]) {
-        box_widgets.add_back(*make_line(this_string));
-        this_string = i;
-        break;
-      }
-      if ((i[0] == '\\') && (i[1] == 'n')) {
-        i[0] = '\0';
-        box_widgets.add_back(*make_line(this_string));
-        this_string = i + 2;
-        break;
-      }
-      ++i;
+  char *unescaped = new char[strlen(text) + 1];
+  char *ui = unescaped;
+  while (1) {
+    const uint32_t len = str_find_any(text, "\\");
+    if (len) {
+      blockcpy(ui, text, len);
+      text += len;
+      ui += len;
+    }
+    if (!*text)
+      break;
+    if (text[1] == 'n') {
+      *(ui++) = '\n';
+      text += 2;
+    }
+    else {
+      *(ui++) = '\\';
+      ++text;
     }
   }
+  *ui = '\0';
 
-  vbox box(box_widgets);
-  padding p(box, 4);
+  label l(unescaped);
+  delete[] unescaped;
+  padding p(l, 4);
   window w(p);
 
   w.show();
diff --git a/src/user/raleigh/d/dialog.cpp b/src/user/raleigh/d/dialog.cpp
index 38ca310..33f137e 100644
--- a/src/user/raleigh/d/dialog.cpp
+++ b/src/user/raleigh/d/dialog.cpp
@@ -54,21 +54,36 @@ dialog::dialog(widget &top_part, alist<duple<const char *, diag_result_t>> butto
   main_box->add_end(*pbot);
 }
 
-alist<duple<const char *, diag_result_t>> &mk_yes_no_cancel() {
-  alist<duple<const char *, diag_result_t>> *list = new alist<duple<const char *, diag_result_t>>(3, 1);
+button_list &mk_yes_no_cancel() {
+  button_list *list = new button_list(3, 1);
   list->add_back(duple<const char *, diag_result_t>("Yes", YES));
   list->add_back(duple<const char *, diag_result_t>("No", NO));
   list->add_back(duple<const char *, diag_result_t>("Cancel", CANCEL));
   return *list;
 }
 
-alist<duple<const char *, diag_result_t>> &mk_yes_no_retry() {
-  alist<duple<const char *, diag_result_t>> *list = new alist<duple<const char *, diag_result_t>>(3, 1);
+button_list &mk_yes_no_retry() {
+  button_list *list = new button_list(3, 1);
   list->add_back(duple<const char *, diag_result_t>("Yes", YES));
   list->add_back(duple<const char *, diag_result_t>("No", NO));
   list->add_back(duple<const char *, diag_result_t>("Retry", RETRY));
   return *list;
 }
 
-alist<duple<const char *, diag_result_t>> &raleigh::yes_no_cancel(mk_yes_no_cancel());
-alist<duple<const char *, diag_result_t>> &raleigh::yes_no_retry(mk_yes_no_retry());
\ No newline at end of file
+button_list &mk_okay_cancel() {
+  button_list *list = new button_list(2, 1);
+  list->add_back(duple<const char *, diag_result_t>("Okay", OKAY));
+  list->add_back(duple<const char *, diag_result_t>("Cancel", CANCEL));
+  return *list;
+}
+
+button_list &mk_okay() {
+  button_list *list = new button_list(1, 1);
+  list->add_back(duple<const char *, diag_result_t>("Okay", OKAY));
+  return *list;
+}
+
+button_list &raleigh::yes_no_cancel(mk_yes_no_cancel());
+button_list &raleigh::yes_no_retry(mk_yes_no_retry());
+button_list &raleigh::okay_cancel(mk_okay_cancel());
+button_list &raleigh::okay(mk_okay());
\ No newline at end of file
diff --git a/src/user/raleigh/s/text_flower.cpp b/src/user/raleigh/s/text_flower.cpp
new file mode 100644
index 0000000..bd4ecd8
--- /dev/null
+++ b/src/user/raleigh/s/text_flower.cpp
@@ -0,0 +1,96 @@
+#include <raleigh/s/text_flower.h>
+#include <knob/block.h>
+
+namespace raleigh {
+  text_flower::text_flower(const char *s, uint32_t cols, uint32_t max_rows)
+    : s(s), lines(max_rows ? max_rows : 10), offsets(max_rows ? max_rows : 10),
+      max_rows(max_rows), cols(cols) {
+    flow_text();
+  }
+
+  __attribute__ ((pure))
+  uint32_t text_flower::get_n_lines() {
+    return lines.n_entries;
+  }
+
+  __attribute__ ((pure))
+  char *text_flower::get_nth_line(uint32_t n) {
+    return lines.buf[n];
+  }
+
+  __attribute__ ((pure))
+  uint32_t text_flower::get_line_offset(uint32_t n) {
+    return offsets.buf[n];
+  }
+
+  void text_flower::draw_text(_pixel_t *start, uint32_t pitch, const struct font_info *fi, _pixel_t color) {
+    for (uint32_t y = 0; y < lines.n_entries; ++y) {
+      const char *line = lines.buf[y];
+      for (uint32_t x = 0; line[x]; ++x)
+        put_char_no_bg(fi, line[x], start + y * fi->space_height * pitch + x * fi->space_width, pitch, color);
+    }
+  }
+
+  void text_flower::push_line() {
+    lines.add_back(strndup(line_start, row_len));
+    offsets.add_back(line_start - s);
+    line_start = on_char;
+    row_len = 0;
+    if (max_rows && (lines.n_entries == max_rows))
+      on_char = "";
+  }
+
+  void text_flower::flow_text() {
+    for (uint32_t i = 0; i < lines.n_entries; ++i)
+      free_block(lines.buf[i]);
+
+    lines.n_entries = 0;
+    offsets.n_entries = 0;
+    line_start = on_char = s;
+    row_len = 0;
+
+    while (*on_char) {
+      if (*on_char == '\n') {
+        ++on_char;
+        push_line();
+      }
+
+      else if (*on_char == ' ') {
+        ++on_char;
+        if (row_len != 0) {
+          if (++row_len == cols)
+            push_line();
+        }
+        else
+          ++line_start;
+      }
+
+      else {
+        uint32_t word_len = str_find_any(on_char, " \n");
+        if (!cols) {
+          row_len += word_len;
+          on_char += word_len;
+        }
+
+        else if (row_len + word_len <= cols) {
+          row_len += word_len;
+          on_char += word_len;
+          if (row_len == cols)
+            push_line();
+        }
+
+        else if (word_len > cols) {
+          on_char += cols - row_len;
+          row_len = cols;
+          push_line();
+        }
+
+        else
+          push_line();
+      }
+    }
+
+    if (row_len && (!max_rows || (lines.n_entries != max_rows)))
+      push_line();
+  }
+}
\ No newline at end of file
diff --git a/src/user/raleigh/util.cpp b/src/user/raleigh/util.cpp
index a300d01..1687ea6 100644
--- a/src/user/raleigh/util.cpp
+++ b/src/user/raleigh/util.cpp
@@ -1,3 +1,5 @@
+#include <raleigh/d/dialog.h>
+#include <raleigh/w/label.h>
 #include <raleigh/util.h>
 #include <knob/format.h>
 #include <pland/pcrt.h>
@@ -17,4 +19,18 @@ namespace raleigh {
 
     __pcrt_quit();
   }
+
+  __attribute__ ((noreturn))
+  void show_error_popup_and_quitf(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+
+    char *ch = format_v(fmt, args);
+    label l(ch);
+
+    dialog d(l, okay);
+    d.show_modal();
+
+    __pcrt_quit();
+  }
 }
\ No newline at end of file
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
diff --git a/src/user/raleigh/w/label.cpp b/src/user/raleigh/w/label.cpp
index 21df2a2..e8be703 100644
--- a/src/user/raleigh/w/label.cpp
+++ b/src/user/raleigh/w/label.cpp
@@ -3,26 +3,36 @@
 #include <knob/block.h>
 
 namespace raleigh {
-  label::label(const char *value, const char *font, bool bg_transparent, _pixel_t fg, _pixel_t bg)
-    : fi(get_font(font)), bg_transparent(bg_transparent), fg(fg), bg(bg) {
+  coord label::determine_size() {
+    uint32_t longest = 0;
 
-    v_size = strlen(value) + 1;
-    this->value = new char[v_size];
-    blockcpy(this->value, value, v_size);
-    size = coord(fi->space_width * (v_size - 2) + fi->char_width, fi->char_height);
+    for (uint32_t i = 0; i < tf.get_n_lines(); ++i)
+      if (strlen(tf.get_nth_line(i)) > longest)
+        longest = strlen(tf.get_nth_line(i));
 
-    closest_opaque = 0;
+    const int32_t width  = fi->space_width  * (longest -          1) + fi->char_width;
+    const int32_t height = fi->space_height * (tf.get_n_lines() - 1) + fi->char_height;
+    return coord(width < 0 ? 0 : width, height < 0 ? 0 : height);
+  }
+
+  label::label(const char *value, const char *font, uint32_t cols,
+               bool bg_transparent, _pixel_t fg, _pixel_t bg)
+    : fi(get_font(font)), cols(cols), bg_transparent(bg_transparent),
+      fg(fg), bg(bg), tf(strdup(value), cols) {
+
+    size = determine_size();
+    closest_opaque = bg_transparent ? 0 : this;
+  }
+
+  label::~label() {
+    free_block(tf.s);
   }
 
   void label::change_value(const char *new_value) {
-    delete[] value;
-    const uint32_t ns = strlen(new_value) + 1;
-    if (ns != v_size) {
-      v_size = ns;
-      value = new char[ns];
-      set_size(coord(fi->space_width * (ns - 2) + fi->char_width, fi->char_height));
-    }
-    blockcpy(value, new_value, ns);
+    free_block(tf.s);
+    tf.s = strdup(new_value);
+    tf.flow_text();
+    set_size(determine_size());
     w->notify_needs_paint(*this);
   }
 
@@ -31,14 +41,11 @@ namespace raleigh {
       for (uint32_t y = window_offset.y; y < window_offset.y + size.y; ++y)
         for (uint32_t x = window_offset.x; x < window_offset.x + size.x; ++x)
           pixbuf[y * pitch + x] = bg;
-    _pixel_t *ptr = pixbuf + window_offset.y * pitch + window_offset.x;
-    for (const char *c = value; *c; ++c) {
-      put_char_no_bg(fi, *c, ptr, pitch, fg);
-      ptr += fi->space_width;
-    }
+    tf.draw_text(pixbuf + window_offset.y * pitch + window_offset.x, pitch, fi, fg);
   }
 
   void label::notify_has_opaque_parent(widget *parent) {
-    closest_opaque = parent;
+    if (bg_transparent)
+      closest_opaque = parent;
   }
 }
\ No newline at end of file
diff --git a/src/user/raleigh/window.cpp b/src/user/raleigh/window.cpp
index 5fa82c3..607b58e 100644
--- a/src/user/raleigh/window.cpp
+++ b/src/user/raleigh/window.cpp
@@ -74,7 +74,13 @@ namespace raleigh {
   }
 
   void window::paint_full() {
-    for (uint32_t i = 0; i < size.x * size.y; ++i)
+  //syslogf("paint_full called with");
+  //syslogf("  pixbuf = 0x%x", pixbuf);
+  //syslogf("  size.x = %u", size.x);
+  //syslogf("  size.y = %u", size.y);
+
+    const uint32_t n = size.x * size.y;
+    for (uint32_t i = 0; i < n; ++i)
       pixbuf[i] = bg_color;
     root.next_paint_full = true;
     root.paint(pixbuf, size.x);
diff --git a/src/user/runtimes/cxx/extra.ld b/src/user/runtimes/cxx/extra.ld
index 048877e..df51439 100644
--- a/src/user/runtimes/cxx/extra.ld
+++ b/src/user/runtimes/cxx/extra.ld
@@ -8,4 +8,7 @@ _Znaj = get_block;
 _ZdlPvj = free_block;
 
 /* void operator delete[](void *) */
-_ZdaPv = free_block;
\ No newline at end of file
+_ZdaPv = free_block;
+
+/* void operator delete[](void *, size_t) */
+_ZdaPvj = free_block;
\ No newline at end of file
diff --git a/src/user/settings/color_editor.cpp b/src/user/settings/color_editor.cpp
deleted file mode 100644
index 1673824..0000000
--- a/src/user/settings/color_editor.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "color_editor.h"
-
-color_editor::color_editor(struct setting *s, const char *sname)
-  : c(&s->data.color), p(s->data.color) {
-  editing_widget_ready(p, sname);
-}
-
-#include <knob/format.h>
-
-void color_editor::set_data() {
-  const _pixel_t new_c = p.get_picked_color();
-  if ((c->r != new_c.r) || (c->g != new_c.g) || (c->b != new_c.b)) {
-    *c = new_c;
-    main_w->is_saved = false;
-  }
-}
\ No newline at end of file
diff --git a/src/user/settings/color_editor.h b/src/user/settings/color_editor.h
deleted file mode 100644
index c41ec3f..0000000
--- a/src/user/settings/color_editor.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef COLOR_EDITOR_H
-#define COLOR_EDITOR_H
-
-#include <raleigh/w/colorpicker.h>
-
-#include "editor.h"
-#include "model.h"
-
-class color_editor : public editor {
-public:
-  color_editor(struct setting *s, const char *sname);
-  void set_data() override;
-
-private:
-  _pixel_t *c;
-  colorpicker p;
-};
-
-#endif
\ No newline at end of file
diff --git a/src/user/settings/color_kind.cpp b/src/user/settings/color_kind.cpp
new file mode 100644
index 0000000..08fb2d9
--- /dev/null
+++ b/src/user/settings/color_kind.cpp
@@ -0,0 +1,36 @@
+#include "color_kind.h"
+
+#include <raleigh/w/colorpicker.h>
+
+void write_color_main(uint32_t &data_offset, file *f, const backing_t backing) {
+  _pixel_t main[2];
+  main[0] = *(const _pixel_t *)backing;
+  write_to_file(f, 8, main);
+}
+
+void write_color_data(file *f, const backing_t backing) {}
+
+backing_t read_color_backing(file *f, uint32_t data_start) {
+  _pixel_t *p = new _pixel_t[1];
+  read_from_file(f, 3, p);
+  return (backing_t)p;
+}
+
+void load_into_picker(raleigh::colorpicker &e, _pixel_t *s) {
+  e.set_picked_color(*s);
+}
+
+void save_from_picker(raleigh::colorpicker &e, _pixel_t *&s) {
+  *s = e.get_picked_color();
+}
+
+void open_color_editor(setting &s) {
+  do_common_editor<_pixel_t *, raleigh::colorpicker, &load_into_picker, &save_from_picker>(s);
+}
+
+const setting_kind_info color_kind = {
+  &write_color_main,
+  &write_color_data,
+  &read_color_backing,
+  &open_color_editor
+};
\ No newline at end of file
diff --git a/src/user/settings/color_kind.h b/src/user/settings/color_kind.h
new file mode 100644
index 0000000..b5a12c8
--- /dev/null
+++ b/src/user/settings/color_kind.h
@@ -0,0 +1,8 @@
+#ifndef COLOR_KIND_H
+#define COLOR_KIND_H
+
+#include "model.h"
+
+extern const setting_kind_info color_kind;
+
+#endif
\ No newline at end of file
diff --git a/src/user/settings/editor.cpp b/src/user/settings/editor.cpp
deleted file mode 100644
index 1804a85..0000000
--- a/src/user/settings/editor.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <raleigh/w/padding.h>
-#include <raleigh/w/button.h>
-#include <raleigh/w/label.h>
-#include <raleigh/w/vbox.h>
-#include "editor.h"
-
-bool editor_save(window_tag_t e) {
-  ((editor *)e)->set_data();
-  return true;
-}
-
-editor::editor()
-  : w(0) {}
-
-void editor::editing_widget_ready(widget &e, const char *s) {
-  label *l = new label(s);
-  padding *p = new padding(*l, 4);
-
-  dllist<widget &> *list = new dllist<widget &>();
-  list->add_back(*p);
-  list->add_back(e);
-
-  vbox *box = new vbox(*list);
-
-  w = new window(*box, RGB(bf, bf, bf), &editor_save, this);
-}
-
-void editor::show() {
-  w->show();
-}
\ No newline at end of file
diff --git a/src/user/settings/editor.h b/src/user/settings/editor.h
deleted file mode 100644
index 2980884..0000000
--- a/src/user/settings/editor.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef EDITOR_H
-#define EDITOR_H
-
-#include <raleigh/d/saving_window.h>
-
-using namespace raleigh;
-
-class editor {
-  friend bool editor_save(window_tag_t e);
-public:
-  void show();
-protected:
-  editor();
-  void editing_widget_ready(widget &e, const char *sname);
-  virtual void set_data() = 0;
-private:
-  window *w;
-};
-
-#endif
\ No newline at end of file
diff --git a/src/user/settings/main.cpp b/src/user/settings/main.cpp
index 2045137..cb318b1 100644
--- a/src/user/settings/main.cpp
+++ b/src/user/settings/main.cpp
@@ -1,191 +1,35 @@
-#include <raleigh/d/saving_window.h>
-#include <raleigh/w/padding.h>
+#include "model.h"
+
 #include <raleigh/w/button.h>
 #include <raleigh/w/label.h>
 #include <raleigh/w/vbox.h>
-#include <structs/map.h>
-#include <knob/format.h>
-#include <knob/file.h>
-#include <stdint.h>
-
-#include "color_editor.h"
-#include "str_editor.h"
-#include "model.h"
 
-struct file_header {
-  uint32_t main_offset;
-  uint32_t main_entries;
-  uint32_t names_offset;
-  uint32_t data_offset;
-} __attribute__ ((packed));
-
-struct main_entry {
-  uint32_t name_offset;
-  uint8_t name_len;
-  enum : uint8_t {
-    STRING = 0,
-    COLOR
-  } kind;
-  uint16_t pad;
-  union {
-    struct {
-      uint32_t data_offset;
-      uint32_t data_len;
-    } as_string;
-    _pixel_t as_color;
-  };
-} __attribute__ ((packed));
-
-#define SETTINGS_FILE "sys/settings.pls"
+#define SETTINGS_FILE "/sys/settings.pls"
 
 using namespace raleigh;
 
-bool save(save_tag_t) {
-  struct file *f = open_file(SETTINGS_FILE);
-  struct file_header fh;
-  fh.main_offset = sizeof(struct file_header);
-  fh.main_entries = settings.n_entries;
-  fh.names_offset = fh.main_offset + sizeof(struct main_entry) * settings.n_entries;
-
-  uint32_t name_i = 0;
-  uint32_t data_i = 0;
-  seek_file_to(f, sizeof(struct file_header));
-  struct main_entry me;
-
-  for (struct setting *i = settings.buf; i < settings.buf + settings.n_entries; ++i) {
-    me.name_offset = name_i;
-    me.name_len = strlen(i->name);
-    name_i += me.name_len;
-
-    switch (i->kind) {
-    case setting::STRING:
-      me.kind = main_entry::STRING;
-      me.as_string.data_offset = data_i;
-      me.as_string.data_len = strlen(i->data.string);
-      data_i += me.as_string.data_len;
-      break;
-    case setting::COLOR:
-      me.kind = main_entry::COLOR;
-      me.as_color = i->data.color;
-      break;
-    }
-
-    write_to_file(f, sizeof(struct main_entry), &me);
-  }
-
-  seek_file_to(f, fh.names_offset);
-  for (struct setting *i = settings.buf; i < settings.buf + settings.n_entries; ++i)
-    write_to_file(f, strlen(i->name), (void *)i->name);
-
-  fh.data_offset = get_file_pos(f);
-  for (struct setting *i = settings.buf; i < settings.buf + settings.n_entries; ++i)
-    switch (i->kind) {
-    case setting::STRING:
-      write_to_file(f, strlen(i->data.string), (void *)i->data.string);
-      break;
-    default:
-      break;
-    }
-
-  trunc_file(f);
-  seek_file_to(f, 0);
-  write_to_file(f, sizeof(struct file_header), &fh);
-  close_file(f);
-
-  main_w->is_saved = true;
-  return true;
-}
-
-void on_button_click(button_tag_t n) {
-  struct setting *const s = settings.buf + (uint32_t)n;
-  editor *e;
-  switch (s->kind) {
-  case setting::STRING:
-    e = new str_editor(s, s->name);
-    break;
-  case setting::COLOR:
-    e = new color_editor(s, s->name);
-    break;
-  default:
-    show_error_and_quitf("Internal model corrupted: setting %s had type 0x%2x.", s->name, s->kind);
-  }
-  e->show();
-}
-
-button *make_button(uint32_t i) {
-  label *l = new label(settings.buf[i].name);
-  padding *p = new padding(*l, 2);
-  return new button(*p, &on_button_click, (button_tag_t)i);
+void on_button(button_tag_t tag) {
+  setting *s = (setting *)tag;
+  s->kind->open_editor(*s);
 }
 
 void main() {
-  struct file *f = open_file(SETTINGS_FILE);
-
-  struct file_header file_head;
-  read_from_file(f, sizeof(struct file_header), &file_head);
-
-  settings = alist<struct setting>(file_head.main_entries + 10);
-
-  dllist<widget &> for_vbox;
+  settings_model sm(SETTINGS_FILE);
 
-  label l("Click a setting name below to edit its value.");
-  label l2("A restart is required for changes to take effect.");
+  label instructions("Click a button below to edit that setting.");
 
-  dllist<widget &> for_subbox;
-  for_subbox.add_back(l);
-  for_subbox.add_back(l2);
-  vbox subbox(for_subbox);
+  dllist<widget &> box_widgets;
+  box_widgets.add_back(instructions);
 
-  padding p_subbox(subbox, 2);
-  for_vbox.add_back(p_subbox);
-
-  for (uint32_t i = 0; i < file_head.main_entries; ++i) {
-    struct main_entry entry;
-    seek_file_to(f, file_head.main_offset + i * sizeof(struct main_entry));
-    read_from_file(f, sizeof(struct main_entry), &entry);
-
-    char *const sname = new char[entry.name_len + 1];
-    seek_file_to(f, file_head.names_offset + entry.name_offset);
-    read_from_file(f, entry.name_len, sname);
-    sname[entry.name_len] = '\0';
-
-    switch (entry.kind) {
-      char *sz;
-      struct setting s;
-    case main_entry::STRING:
-      sz = new char[entry.as_string.data_len + 1];
-      seek_file_to(f, file_head.data_offset + entry.as_string.data_offset);
-      read_from_file(f, entry.as_string.data_len, sz);
-      sz[entry.as_string.data_len] = '\0';
-      
-      s.kind = setting::STRING;
-      s.data.string = sz;
-      s.name = sname;
-      settings.add_back(s);
-      break;
-
-    case main_entry::COLOR:
-      s.kind = setting::COLOR;
-      s.data.color = entry.as_color;
-      s.name = sname;
-      settings.add_back(s);
-      break;
-    default:
-      show_error_and_quitf("Refusing to open " SETTINGS_FILE ":\n\"%s\" has unrecognized type id 0x%2x.\nHighest known is 0x01.", sname, entry.kind);
-    }
-
-    button *const b = make_button(settings.n_entries - 1);
-
-    padding *p = new padding(*b, 2);
-    for_vbox.add_back(*p);
+  for (uint32_t i = 0; i < sm.settings.n_entries; ++i) {
+    label *l = new label(sm.settings.buf[i].name);
+    button *b = new button(*l, &on_button, (button_tag_t)&sm.settings.buf[i]);
+    box_widgets.add_back(*b);
   }
 
-  close_file(f);
-
-  vbox box(for_vbox);
-  padding pbox(box, 2);
+  vbox box(box_widgets);
+  window w(box);
+  w.show();
 
-  main_w = new saving_window(&save, 0, pbox);
-  main_w->show();
   start_runtime();
 }
\ No newline at end of file
diff --git a/src/user/settings/model.cpp b/src/user/settings/model.cpp
index e27de0d..db0a4ce 100644
--- a/src/user/settings/model.cpp
+++ b/src/user/settings/model.cpp
@@ -1,4 +1,58 @@
-#include "model.h"
+#include <raleigh/util.h>
 
-alist<struct setting> settings;
-raleigh::saving_window *main_w;
\ No newline at end of file
+#include "string_kind.h"
+#include "color_kind.h"
+
+#define N_SETTING_KINDS 2
+const setting_kind_info *setting_kinds[] = {
+  &string_kind,
+  &color_kind
+};
+
+struct file_head {
+  uint32_t main_start;
+  uint32_t count;
+  uint32_t names_start;
+  uint32_t data_start;
+} __attribute__ ((__packed__));
+
+struct setting_head {
+  uint32_t name_offset;
+  uint8_t name_length;
+  uint8_t type;
+} __attribute__ ((__packed__));
+
+settings_model::settings_model(const char *from_file)
+  : settings() {
+  file *f = open_file(from_file);
+
+  file_head header;
+  read_from_file(f, 16, &header);
+  settings.expand_to(header.count);
+  settings.n_entries = header.count;
+
+  for (uint32_t i = 0; i < header.count; ++i) {
+    setting_head shead;
+    seek_file_to(f, header.main_start + i * 16);
+    read_from_file(f, sizeof(setting_head), &shead);
+
+    char *name = new char[shead.name_length + 1];
+    seek_file_to(f, header.names_start + shead.name_offset);
+    read_from_file(f, shead.name_length, name);
+    name[shead.name_length] = '\0';
+
+    if (shead.type >= N_SETTING_KINDS)
+      raleigh::show_error_popup_and_quitf("setting \"%s\" has unkown type 0x%2x.", name, shead.type);
+
+    setting ns;
+    ns.name = name;
+    ns.kind = setting_kinds[shead.type];
+
+    seek_file_to(f, header.main_start + i * 16 + 8);
+    ns.backing = ns.kind->read_backing(f, header.data_start);
+
+    settings.buf[i] = ns;
+  }
+
+  close_file(f);
+}
\ No newline at end of file
diff --git a/src/user/settings/model.h b/src/user/settings/model.h
index 0c9b1d2..410121f 100644
--- a/src/user/settings/model.h
+++ b/src/user/settings/model.h
@@ -1,24 +1,60 @@
 #ifndef MODEL_H
 #define MODEL_H
 
-#include <raleigh/d/saving_window.h>
-#include <structs/alist.h>
+#include <raleigh/d/dialog.h>
+#include <raleigh/w/button.h>
+#include <raleigh/w/label.h>
+#include <raleigh/w/vbox.h>
+#include <raleigh/window.h>
+#include <structs/map.h>
+#include <knob/file.h>
 
-union setting_data {
-  char *string;
-  _pixel_t color;
+typedef void *backing_t;
+
+struct setting;
+
+struct setting_kind_info {
+  void (*write_main)(uint32_t &data_offset, file *f, const backing_t backing);
+  void (*write_data)(file *f, const backing_t backing);
+  backing_t (*read_backing)(file *f, uint32_t data_start);
+  void (*open_editor)(setting &s);
 };
 
 struct setting {
-  enum {
-    STRING,
-    COLOR
-  } kind;
-  union setting_data data;
   const char *name;
+  const setting_kind_info *kind;
+  void *backing;
+};
+
+class settings_model {
+public:
+  settings_model(const char *from_file);
+
+  void write_to_file(const char *to_file);
+
+  alist<setting> settings;
 };
 
-extern alist<struct setting> settings;
-extern raleigh::saving_window *main_w;
+using namespace raleigh;
+
+template<class backing_type, class editing_widget, void (*load_into_widget)(editing_widget &ew, backing_type s), void (*save_from_widget)(editing_widget &ew, backing_type &s)>
+void do_common_editor(setting &s) {
+  dllist<widget &> widgets;
+
+  label l(s.name);
+  widgets.add_back(l);
+
+  editing_widget ew;
+  load_into_widget(ew, (backing_type)s.backing);
+  widgets.add_back(ew);
+
+  vbox box(widgets);
+
+  dialog d(box, okay_cancel);
+  d.show_modal();
+
+  if (d.result == OKAY)
+    save_from_widget(ew, (backing_type &)s.backing);
+}
 
 #endif
\ No newline at end of file
diff --git a/src/user/settings/str_editor.cpp b/src/user/settings/str_editor.cpp
deleted file mode 100644
index 5e86e96..0000000
--- a/src/user/settings/str_editor.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <knob/block.h>
-
-#include "str_editor.h"
-
-str_editor::str_editor(struct setting *s, const char *sname)
-  : e(10, 25, s->data.string), s(&s->data.string) {
-  editing_widget_ready(e, sname);
-}
-
-void str_editor::set_data() {
-  const char *const contents = e.get_contents();
-  if (strequ(contents, *s))
-    return;
-  delete *s;
-  *s = strdup(contents);
-  main_w->is_saved = false;
-}
\ No newline at end of file
diff --git a/src/user/settings/str_editor.h b/src/user/settings/str_editor.h
deleted file mode 100644
index 02bd7d8..0000000
--- a/src/user/settings/str_editor.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef STR_EDITOR_H
-#define STR_EDITOR_H
-
-#include <raleigh/w/entry.h>
-
-#include "editor.h"
-#include "model.h"
-
-class str_editor : public editor {
-public:
-  str_editor(struct setting *s, const char *sname);
-  void set_data() override;
-
-private:
-  entry e;
-  char **s;
-};
-
-#endif
\ No newline at end of file
diff --git a/src/user/settings/string_kind.cpp b/src/user/settings/string_kind.cpp
new file mode 100644
index 0000000..0afe102
--- /dev/null
+++ b/src/user/settings/string_kind.cpp
@@ -0,0 +1,52 @@
+#include "string_kind.h"
+
+#include <raleigh/w/entry.h>
+
+void write_string_main(uint32_t &data_offset, file *f, const backing_t backing) {
+  const uint32_t len = strlen((const char *)backing);
+
+  uint32_t main[2];
+  main[0] = data_offset;
+  main[1] = len;
+
+  data_offset += len;
+
+  write_to_file(f, 8, main);
+}
+
+void write_string_data(file *f, const backing_t backing) {
+  const char *b = (const char *)backing;
+  write_to_file(f, strlen(b), b);
+}
+
+backing_t read_string_backing(file *f, uint32_t data_start) {
+  uint32_t main[2];
+  read_from_file(f, 8, main);
+
+  seek_file_to(f, data_start + main[0]);
+
+  char *buf = new char[main[1] + 1];
+  read_from_file(f, main[1], buf);
+  buf[main[1]] = '\0';
+
+  return (backing_t)buf;
+}
+
+void load_into_entry(raleigh::entry &e, const char *s) {
+  e.set_contents(s);
+}
+
+void save_from_entry(raleigh::entry &e, const char *&s) {
+  s = e.get_contents();
+}
+
+void open_string_editor(setting &s) {
+  do_common_editor<const char *, raleigh::entry, &load_into_entry, &save_from_entry>(s);
+}
+
+const setting_kind_info string_kind = {
+  &write_string_main,
+  &write_string_data,
+  &read_string_backing,
+  &open_string_editor
+};
\ No newline at end of file
diff --git a/src/user/settings/string_kind.h b/src/user/settings/string_kind.h
new file mode 100644
index 0000000..b62244f
--- /dev/null
+++ b/src/user/settings/string_kind.h
@@ -0,0 +1,8 @@
+#ifndef STRING_KIND_H
+#define STRING_KIND_H
+
+#include "model.h"
+
+extern const setting_kind_info string_kind;
+
+#endif
\ No newline at end of file