From: Christian Heller <c.heller@plomlompom.de>
Date: Mon, 28 Oct 2013 05:13:26 +0000 (+0100)
Subject: Don't use ncurses windows besides the virtual screen pad. Eliminated some ncurses... 
X-Git-Tag: tce~940
X-Git-Url: https://plomlompom.com/repos/%7B%7Bdb.prefix%7D%7D/%7B%7Byoutube_prefix%7D%7D%7B%7Bvideo_data.id_%7D%7D?a=commitdiff_plain;h=d1dfbfa5a6f5f05d761238010b4f853088e3a373;p=plomrogue

Don't use ncurses windows besides the virtual screen pad. Eliminated some ncurses dependencies and Frame struct.
---

diff --git a/src/draw_wins.c b/src/draw_wins.c
index ac48bdc..106d73a 100644
--- a/src/draw_wins.c
+++ b/src/draw_wins.c
@@ -4,7 +4,7 @@
 #include <stdlib.h>      /* for free() */
 #include <stdint.h>      /* for uint16_t */
 #include <string.h>      /* for strlen() */
-#include <ncurses.h>     /* for attri_t, chtype, mvwaddch(), wresize() */
+#include <ncurses.h>     /* for attri_t, chtype */
 #include "windows.h"     /* for struct Win */
 #include "misc.h"        /* for try_malloc() */
 #include "keybindings.h" /* for struct KeyBinding, for get_name_to_keycode() */
@@ -18,27 +18,33 @@
 
 
 
-/* Widen the ncurses window below "win" to "minx" if it is below that. */
-static void rewiden_if_less_than(struct Win * win, uint16_t minx);
+/* Apply to the winmap of Win "w" the new sizes "new_size_y" and "new_size_x"
+ * to the degree that they extend it. Re-shape the window content accordingly.
+ */
+static void try_resize_winmap(struct World * world, struct Win * w,
+                              int new_size_y, int new_size_x);
+
+/* In Win "w", write "ch" to coordinate "y"/"x". */
+static void set_ch_on_yx(struct Win * w, int y, int x, chtype ch);
 
-/* Write "text" into window "win". Start on row "start_y". Break text at
- * right window edge. Also break at newlines.
+/* Add "text" into window "win". Break text at right window edge. Also break at
+ * newlines.
  */
-static void draw_with_linebreaks(struct Win * win, char * text,
-                                 uint16_t start_y);
+static void add_text_with_linebreaks(struct World * world, struct Win * win,
+                                     char * text);
 
-/* Write "line" into window "w" at line "y"; apply ncurses attribute
- * "attri" to all characters drawn; if "fill" is non-zero, fill the
- * entire line until the right window edge with empty characters
- * ("attri" also applied on these).
+/* Add "line" into window "w". Apply ncurses attribute "attri" to all
+ * characters drawn. If "fill" is non-zero, fill the entire line until the
+ * right window edge with empty characters ("attri" also applied on these).
  */
-static void draw_line(struct Win * w, uint16_t y, char * line, attr_t attri,
-                      uint8_t fill);
+static void add_line(struct World * world, struct Win * w, char * line,
+                     attr_t attri, uint8_t fill);
 
-/* Write "text" with draw_with_linebreaks() as not starting from the top but
+/* Write "text" with add_text_with_linebreaks() as not starting from the top but
  * from bottom of "win". Draw only what fits in window (avoid scroll hints).
  */
-static void draw_text_from_bottom(struct Win * win, char * text);
+static void draw_text_from_bottom(struct World * world, struct Win * win,
+                                  char * text);
 
 /* Draw onto "map" in "win" the objects in the chain at "start". */
 static void draw_map_objects(struct World * world, struct MapObj * start,
@@ -61,26 +67,61 @@ static uint16_t draw_titled_keybinding_list(struct World * world, char * title,
 
 
 
-static void rewiden_if_less_than(struct Win * win, uint16_t minx)
+static void try_resize_winmap(struct World * world, struct Win * w,
+                              int new_size_y, int new_size_x)
 {
-    if (minx > getmaxx(win->frame.curses_win))
+    char * f_name = "try_resize_winmap()";
+    if (w->winmapsize.y >= new_size_y && w->winmapsize.x >= new_size_x)
+    {
+        return;
+    }
+    if      (w->winmapsize.y > new_size_y)
     {
-        wresize(win->frame.curses_win, getmaxy(win->frame.curses_win), minx);
+        new_size_y = w->winmapsize.y;
     }
+    else if (w->winmapsize.x > new_size_x)
+    {
+        new_size_x = w->winmapsize.x;
+    }
+    chtype * old_winmap = w->winmap;
+    uint32_t new_size = sizeof(chtype) * new_size_y * new_size_x;
+    w->winmap = try_malloc(new_size, world, f_name);
+    uint16_t y, x;
+    for (y = 0; y < new_size_y; y++)
+    {
+        for (x = 0; y < w->winmapsize.y && x < w->winmapsize.x; x++)
+        {
+            chtype ch = old_winmap[(y * w->winmapsize.x) + x];
+            w->winmap[(y * new_size_x) + x] = ch;
+        }
+        for (; x < new_size_x; x++)
+        {
+            w->winmap[(y * new_size_x) + x] = ' ';
+        }
+    }
+    free(old_winmap);
+    w->winmapsize.y = new_size_y;
+    w->winmapsize.x = new_size_x;
 }
 
 
 
-static void draw_with_linebreaks(struct Win * win, char * text,
-                                 uint16_t start_y)
+static void set_ch_on_yx(struct Win * w, int y, int x, chtype ch)
+{
+    w->winmap[(y * w->winmapsize.x) + x] = ch;
+}
+
+
+
+static void add_text_with_linebreaks(struct World * world, struct Win * win,
+                                     char * text)
 {
     uint16_t x, y;
     int16_t z = -1;
-    rewiden_if_less_than(win, win->frame.size.x);
-    for (y = start_y; ; y++)
+    for (y = win->winmapsize.y; ; y++)
     {
-        wresize(win->frame.curses_win, y + 1, getmaxx(win->frame.curses_win));
-        for (x = 0; x < win->frame.size.x; x++)
+        try_resize_winmap(world, win, y + 1, win->framesize.x);
+        for (x = 0; x < win->framesize.x; x++)
         {
             z++;
             if ('\n' == text[z])
@@ -89,7 +130,7 @@ static void draw_with_linebreaks(struct Win * win, char * text,
             }
             else
             {
-                mvwaddch(win->frame.curses_win, y, x, text[z]);
+                set_ch_on_yx(win, y, x, text[z]);
             }
             if ('\n' == text[z+1])
             {
@@ -106,39 +147,49 @@ static void draw_with_linebreaks(struct Win * win, char * text,
 
 
 
-static void draw_line(struct Win * w, uint16_t y, char * line, attr_t attri,
-                      uint8_t fill)
+static void add_line(struct World * world, struct Win * w, char * line,
+                     attr_t attri, uint8_t fill)
 {
+    uint16_t y = w->winmapsize.y;
+    uint16_t len_line = strlen(line);
+    if (0 != fill
+        && w->winmapsize.x < w->framesize.x && w->framesize.x > len_line)
+    {
+        try_resize_winmap(world, w, y + 1, w->framesize.x);
+    }
+    else
+    {
+        try_resize_winmap(world, w, y + 1, strlen(line));
+    }
     uint16_t x = 0;
-    for (; x < strlen(line); x++)
+    for (; x < len_line; x++)
     {
-        rewiden_if_less_than(w, x + 1);
-        mvwaddch(w->frame.curses_win, y, x, line[x] | attri);
+        set_ch_on_yx(w, y, x, line[x] | attri);
     }
     if (0 != fill)
     {
-        for (; x < w->frame.size.x; x++)
+        for (; x < w->framesize.x; x++)
         {
-            rewiden_if_less_than(w, x + 1);
-            mvwaddch(w->frame.curses_win, y, x, ' ' | attri);
+            set_ch_on_yx(w, y, x, ' ' | attri);
         }
     }
 }
 
 
 
-static void draw_text_from_bottom(struct Win * win, char * text)
+static void draw_text_from_bottom(struct World * world, struct Win * win,
+                                  char * text)
 {
     /* Determine number of lines text would have in a window of win's width,
      * but infinite height. Treat \n and \0 as control chars for incrementing
      * y and stopping the loop. Make sure +they* don't count as cell space.
      */
     char toggle = 0;
-    uint16_t x, y, offset;
+    uint16_t x, y;
     int16_t z = -1;
     for (y = 0; 0 == toggle; y++)
     {
-        for (x = 0; x < win->frame.size.x; x++)
+        for (x = 0; x < win->framesize.x; x++)
         {
             z++;
             if ('\n' == text[z])
@@ -161,16 +212,16 @@ static void draw_text_from_bottom(struct Win * win, char * text)
 
     /* Depending on what's bigger, determine start point in window or text. */
     uint16_t start_y = 0;
-    if (y < win->frame.size.y)
+    if (y < win->framesize.y)
     {
-        start_y = win->frame.size.y - y;
+        start_y = win->framesize.y - y;
     }
-    else if (y > win->frame.size.y)
+    else if (y > win->framesize.y)
     {
-        offset = y - win->frame.size.y;
+        uint16_t offset = y - win->framesize.y;
         for (y = 0; y < offset; y++)
         {
-            for (x = 0; x < win->frame.size.x; x++)
+            for (x = 0; x < win->framesize.x; x++)
             {
                 z++;
                 if ('\n' == text[z])
@@ -187,7 +238,8 @@ static void draw_text_from_bottom(struct Win * win, char * text)
         text = text + (sizeof(char) * (z + 1));
     }
 
-    draw_with_linebreaks(win, text, start_y);
+    try_resize_winmap(world, win, start_y, 1);
+    add_text_with_linebreaks(world, win, text);
 }
 
 
@@ -208,7 +260,7 @@ static void draw_map_objects(struct World * world, struct MapObj * start,
             {
                 d = get_map_object_def(world, o->type);
                 c = d->char_on_map;
-                mvwaddch(win->frame.curses_win, o->pos.y, o->pos.x, c);
+                set_ch_on_yx(win, o->pos.y, o->pos.x, c);
             }
         }
     }
@@ -238,15 +290,13 @@ static void draw_kb_view(struct World * world, struct Win * w,
 {
     if (0 == kb->kbs)
     {
-        wresize(w->frame.curses_win, start + 1, getmaxx(w->frame.curses_win));
-        draw_line(w, start, "(none)", 0, 0);
+        add_line(world, w, "(none)", 0, 0);
         return;
     }
     struct KeyBinding * kb_p = kb->kbs;
     uint16_t y;
     for (y = start; 0 != kb_p; y++)
     {
-        wresize(w->frame.curses_win, y + 1, getmaxx(w->frame.curses_win));
         attr_t attri = 0;
         if (y - start == kb->select)
         {
@@ -257,7 +307,7 @@ static void draw_kb_view(struct World * world, struct Win * w,
             }
         }
         char * kb_line = get_kb_line_and_iterate(world, &kb_p);
-        draw_line(w, y, kb_line, attri, 1);
+        add_line(world, w, kb_line, attri, 1);
         free(kb_line);
     }
 }
@@ -268,49 +318,26 @@ static uint16_t draw_titled_keybinding_list(struct World * world, char * title,
                                             struct Win * w, uint16_t start,
                                             struct KeyBinding * kb_p)
 {
-    uint16_t x, y;
-    uint16_t i = 0;
+    uint16_t y;
     uint8_t state = 0;
     for (y = start; (0 == state || 0 != kb_p); y++)
     {
-        wresize(w->frame.curses_win, y + 1, getmaxx(w->frame.curses_win));
         if (0 == state)
         {
-            for (x = 0; ; x++)
-            {
-                if (i == strlen(title))
-                {
-                    y++;
-                    state = 1 + (0 == kb_p);
-                    i = 0;
-                    break;
-                }
-                rewiden_if_less_than(w, x + 1);
-                mvwaddch(w->frame.curses_win, y, x, title[i]);
-                i++;
-            }
+            add_line(world, w, title, 0, 0);
+            y++;
+            add_line(world, w, " ", 0, 0);
+            state = 1 + (0 == kb_p);
             continue;
         }
         char * kb_line = get_kb_line_and_iterate(world, &kb_p);
-        if (strlen(kb_line) > getmaxx(w->frame.curses_win))
-        {
-            wresize(w->frame.curses_win, y + 1, strlen(kb_line));
-        }
-        draw_line(w, y, kb_line, 0, 0);
+        add_line(world, w, kb_line, 0, 0);
         free(kb_line);
     }
     if (2 == state)
     {
         char * none = "(none)";
-        if (strlen(none) > getmaxx(w->frame.curses_win))
-        {
-            wresize(w->frame.curses_win, y + 1, strlen(none));
-        }
-        else
-        {
-            wresize(w->frame.curses_win, y + 1, getmaxx(w->frame.curses_win));
-        }
-        draw_line(w, y, none, 0, 0);
+        add_line(world, w, none, 0, 0);
         y++;
     }
     return y;
@@ -321,7 +348,7 @@ static uint16_t draw_titled_keybinding_list(struct World * world, char * title,
 extern void draw_win_log(struct Win * win)
 {
     struct World * world = (struct World *) win->data;
-    draw_text_from_bottom(win, world->log);
+    draw_text_from_bottom(world, win, world->log);
 }
 
 
@@ -331,13 +358,14 @@ extern void draw_win_map(struct Win * win)
     struct World * world = (struct World *) win->data;
     struct Map * map = world->map;
     char * cells = map->cells;
-    wresize(win->frame.curses_win, map->size.y, map->size.x);
-    uint16_t x, y, z;
+    try_resize_winmap(world, win, map->size.y, map->size.x);
+    uint16_t z = 0;
+    uint16_t x, y;
     for (y = 0; y < map->size.y; y++)
     {
         for (x = 0; x < map->size.x; x++)
         {
-            mvwaddch(win->frame.curses_win, y, x, cells[z]);
+            set_ch_on_yx(win, y, x, cells[z]);
             z++;
         }
     }
@@ -360,7 +388,7 @@ extern void draw_win_info(struct Win * win)
             dsc_turn, world->turn,
             dsc_hitpoints, player->lifepoints,
             dsc_score, world->score);
-    draw_with_linebreaks(win, text, 0);
+    add_text_with_linebreaks(world, win, text);
 }
 
 
@@ -371,7 +399,7 @@ extern void draw_win_inventory(struct Win * win)
     struct MapObj * player = get_player(world);
     if (NULL == player->owns)
     {
-        draw_line(win, 0, "(none)", 0, 0);
+        add_line(world, win, "(none)", 0, 0);
         return;
     }
     win->center.y = world->inventory_select;
@@ -379,14 +407,13 @@ extern void draw_win_inventory(struct Win * win)
     uint8_t y;
     for (y = 0; NULL != owned; y++)
     {
-        wresize(win->frame.curses_win, y + 1, getmaxx(win->frame.curses_win));
         attr_t attri = 0;
         if (y == world->inventory_select)
         {
             attri = A_REVERSE;
         }
         struct MapObjDef * mod = get_map_object_def(world, owned->type);
-        draw_line(win, y, mod->name, attri, 0);
+        add_line(world, win, mod->name, attri, 0);
         owned = owned->next;
     }
 }
@@ -412,6 +439,7 @@ extern void draw_win_available_keybindings(struct Win * win)
         kb_p = world->kb_winkeys.kbs;
     }
     uint16_t offset = draw_titled_keybinding_list(world, title, win, 0, kb_p);
+    add_line(world, win, " ", 0, 0);
     draw_titled_keybinding_list(world, "Global keybindings", win, offset + 1,
                                 world->kb_global.kbs);
 }
@@ -450,7 +478,8 @@ extern void draw_winconf_keybindings(struct Win * win)
     struct World * world = (struct World *) win->data;
     struct WinConf * wc = get_winconf_by_win(world, win);
     char * title = "Window's keybindings:";
-    draw_line(win, 0, title, 0, 0);
+    add_line(world, win, title, 0, 0);
+    add_line(world, win, " ", 0, 0);
     draw_kb_view(world, win, &wc->kb, 2);
     win->center.y = wc->kb.select + 2;
 }
@@ -484,5 +513,5 @@ extern void draw_winconf_geometry(struct Win * win)
     char text[maxl + 1];
     sprintf(text, "%s%s%d%s%s%d%s", title, h_d, wcp->height, h_t,
                                            w_d, wcp->width,  w_t);
-    draw_with_linebreaks(win, text, 0);
+    add_text_with_linebreaks(world, win, text);
 }
diff --git a/src/map.c b/src/map.c
index 16b2782..92d1558 100644
--- a/src/map.c
+++ b/src/map.c
@@ -57,10 +57,10 @@ struct Map init_map(struct World * world)
 void map_scroll(struct Win * win, struct yx_uint16 map_size, enum dir d)
 {
     uint16_t offset;
-    if ((NORTH == d || SOUTH == d) && map_size.y > win->frame.size.y)
+    if ((NORTH == d || SOUTH == d) && map_size.y > win->framesize.y)
     {
-        offset = center_offset(win->center.y, map_size.y, win->frame.size.y);
-        win->center.y = offset + (win->frame.size.y / 2);
+        offset = center_offset(win->center.y, map_size.y, win->framesize.y);
+        win->center.y = offset + (win->framesize.y / 2);
         if      (NORTH == d && win->center.y > 0)
         {
             win->center.y--;
@@ -70,10 +70,10 @@ void map_scroll(struct Win * win, struct yx_uint16 map_size, enum dir d)
             win->center.y++;
         }
     }
-    else if ((WEST == d || EAST == d) && map_size.x > win->frame.size.x)
+    else if ((WEST == d || EAST == d) && map_size.x > win->framesize.x)
     {
-        offset = center_offset(win->center.x, map_size.x, win->frame.size.x);
-        win->center.x = offset + (win->frame.size.x / 2);
+        offset = center_offset(win->center.x, map_size.x, win->framesize.x);
+        win->center.x = offset + (win->framesize.x / 2);
         if      (WEST == d && win->center.x > 0)
         {
             win->center.x--;
diff --git a/src/wincontrol.c b/src/wincontrol.c
index d444623..5680ff9 100644
--- a/src/wincontrol.c
+++ b/src/wincontrol.c
@@ -240,20 +240,19 @@ static void set_winconf_geometry(struct World * world, char id)
     struct WinConf * wcp = get_winconf_by_id(world, id);
     if      (0 == wcp->height_type)
     {
-        wcp->height = wcp->win->frame.size.y;
+        wcp->height = wcp->win->framesize.y;
     }
     else if (1 == wcp->height_type)
     {
-        wcp->height = wcp->win->frame.size.y - world->wmeta->padframe.size.y
-                      + 1;
+        wcp->height = wcp->win->framesize.y - world->wmeta->padsize.y + 1;
     }
     if      (0 == wcp->width_type)
     {
-        wcp->width = wcp->win->frame.size.x;
+        wcp->width = wcp->win->framesize.x;
     }
     else if (1 == wcp->width_type)
     {
-        wcp->width = wcp->win->frame.size.x - world->wmeta->padframe.size.x;
+        wcp->width = wcp->win->framesize.x - world->wmeta->padsize.x;
     }
 }
 
@@ -562,8 +561,7 @@ extern void toggle_win_height_type(struct World * world, struct Win * win)
 extern void toggle_win_width_type(struct World * world, struct Win * win)
 {
     struct WinConf * wcp = get_winconf_by_win(world, win);
-    if (   0 == wcp->width_type
-        && win->frame.size.x <= world->wmeta->padframe.size.x)
+    if (0 == wcp->width_type && win->framesize.x <= world->wmeta->padsize.x)
     {
         wcp->width_type = 1;
     }
@@ -594,7 +592,7 @@ extern uint8_t growshrink_active_window(struct World * world, char change)
 {
     if (0 != world->wmeta->active)
     {
-        struct yx_uint16 size = world->wmeta->active->frame.size;
+        struct yx_uint16 size = world->wmeta->active->framesize;
         if      (change == '-')
         {
             size.y--;
@@ -614,8 +612,7 @@ extern uint8_t growshrink_active_window(struct World * world, char change)
         uint8_t x = resize_active_win(world->wmeta, size);
         struct WinConf * wcp = get_winconf_by_win(world, world->wmeta->active);
         if (   1 == wcp->width_type
-            && world->wmeta->active->frame.size.x
-               > world->wmeta->padframe.size.x)
+            && world->wmeta->active->framesize.x > world->wmeta->padsize.x)
         {
             wcp->width_type = 0;
         }
diff --git a/src/wincontrol.h b/src/wincontrol.h
index a422f5f..09d78c9 100644
--- a/src/wincontrol.h
+++ b/src/wincontrol.h
@@ -33,7 +33,7 @@ struct WinConf
                /* after toggling window configuration view */
     struct yx_uint16 center; /* designated center for Win->draw view; to be */
                              /* returned to after toggling winconf view */
-    uint8_t view; /* 0: use ->draw as Win->_draw; 1, 2: use draw_winconf()_* */
+    uint8_t view; /* 0: use ->draw as Win->draw; 1, 2: use draw_winconf()_* */
     uint8_t height_type; /* both: 0: interpret ->height/->width as size in   */
     uint8_t width_type;  /* positive cells; 1: as negative diff to max width */
     struct KeyBiData kb; /* the window's specific keybindings */
diff --git a/src/windows.c b/src/windows.c
index 069e08f..5165179 100644
--- a/src/windows.c
+++ b/src/windows.c
@@ -28,15 +28,15 @@ static void place_win(struct WinMeta * wmeta, struct Win * w);
 
 
 
-/* Draw scroll hint (a line stating that there are "dist" more elements of
+/* Draw scroll hint (a line saying that there are "dist" more elements of
  * "unit" further into the direction symbolized by the "dir" char) into virtual
- * screen pad, onto an appropriate edge of "frame": the left or right edge if
- * "dir" is "<" or ">", or the upper or lower edge if it is "^" or "v". "start"
- * should be either the start coordinate of "frame" if it describes a window or
- * .y=, .x=wm->pad_offset if it describes the virtual screen. winscroll_hint()
- * and padscroll_hint() are wrappers to simplify the use of scroll_hint().
+ * screen pad, onto an appropriate edge of either a window or the screen; the
+ * left or right edge if "dir" is "<" or ">", or the upper or lower edge if it
+ * is "^" or "v". "start" should be either the start coordinate of a window's
+ * frame or .y=0, .x=wm->pad_offset if it describes the virtual screen pad.
+ * winscroll_hint() and padscroll_hint() are wrappers to simplify these uses.
  */
-static void scroll_hint(struct WinMeta * wm, struct Frame * frame, char dir,
+static void scroll_hint(struct WinMeta * wm, struct yx_uint16 fsize, char dir,
                         uint16_t dist, char * unit, struct yx_uint16 start);
 static void winscroll_hint(struct WinMeta * wm, struct Win * w, char dir,
                            uint16_t dist);
@@ -77,29 +77,25 @@ static void shift_win_backward(struct WinMeta * wmeta);
 static uint8_t refit_pad(struct WinMeta * wmeta)
 {
     /* Determine rightmost window column. */
-    uint32_t lastwincol = 0;
-    struct Win * w_p = wmeta->chain_start;
-    while (w_p != 0)
+    uint32_t lastwcol = 0;
+    struct Win * wp = wmeta->chain_start;
+    while (wp != 0)
     {
-        if ((uint32_t) w_p->start.x + (uint32_t) w_p->frame.size.x
-            > lastwincol + 1)
+        if ((uint32_t) wp->start.x + (uint32_t) wp->framesize.x > lastwcol + 1)
         {
-            lastwincol = (uint32_t) w_p->start.x
-                         + (uint32_t) w_p->frame.size.x - 1;
+            lastwcol = (uint32_t) wp->start.x + (uint32_t) wp->framesize.x - 1;
         }
-        w_p = w_p->next;
+        wp = wp->next;
     }
 
     /* Only resize the pad if the rightmost window column has changed. */
-    if (getmaxx(wmeta->padframe.curses_win) + 1 != lastwincol)
+    if (getmaxx(wmeta->pad) + 1 != lastwcol)
     {
-        if (lastwincol + 2 > UINT16_MAX)
+        if (lastwcol + 2 > UINT16_MAX)
         {
             return 2;
         }
-        return (ERR == wresize(wmeta->padframe.curses_win,
-                               getmaxy(wmeta->padframe.curses_win),
-                               lastwincol + 2));
+        return (ERR == wresize(wmeta->pad, getmaxy(wmeta->pad), lastwcol + 2));
     }
     return 0;
 }
@@ -137,14 +133,14 @@ static void place_win(struct WinMeta * wmeta, struct Win * w)
         {
             w_top = w_top->prev;
         }
-        w->start.x = w_top->start.x + w_top->frame.size.x + 1;
+        w->start.x = w_top->start.x + w_top->framesize.x + 1;
 
         /* Fit window below its predecessor if that one directly thrones over
          * empty space wide and high enough.
          */
-        uint16_t w_prev_maxy = w->prev->start.y + w->prev->frame.size.y;
-        if (   w->frame.size.x <= w->prev->frame.size.x
-            && w->frame.size.y <  wmeta->padframe.size.y - w_prev_maxy)
+        uint16_t w_prev_maxy = w->prev->start.y + w->prev->framesize.y;
+        if (   w->framesize.x <= w->prev->framesize.x
+            && w->framesize.y <  wmeta->padsize.y - w_prev_maxy)
         {
             w->start.x = w->prev->start.x;
             w->start.y = w_prev_maxy + 1;
@@ -169,13 +165,13 @@ static void place_win(struct WinMeta * wmeta, struct Win * w)
                     }
                     w_upup = w_upup->prev;
                 }
-                w_prev_maxy = w_upup->start.y + w_upup->frame.size.y;
-                widthdiff = (w_upup->start.x + w_upup->frame.size.x)
-                            - (w_up->start.x + w_up->frame.size.x);
-                if (   w->frame.size.y < wmeta->padframe.size.y - w_prev_maxy
-                    && w->frame.size.x < widthdiff)
+                w_prev_maxy = w_upup->start.y + w_upup->framesize.y;
+                widthdiff = (w_upup->start.x + w_upup->framesize.x)
+                            - (w_up->start.x + w_up->framesize.x);
+                if (   w->framesize.y < wmeta->padsize.y - w_prev_maxy
+                    && w->framesize.x < widthdiff)
                 {
-                    w->start.x = w_up->start.x + w_up->frame.size.x + 1 ;
+                    w->start.x = w_up->start.x + w_up->framesize.x + 1 ;
                     w->start.y = w_prev_maxy + 1;
                     break;
                 }
@@ -187,15 +183,15 @@ static void place_win(struct WinMeta * wmeta, struct Win * w)
 
 
 
-static void scroll_hint(struct WinMeta * wm, struct Frame * frame, char dir,
+static void scroll_hint(struct WinMeta * wm, struct yx_uint16 fsize, char dir,
                         uint16_t dist, char * unit, struct yx_uint16 start)
 {
     /* Decide on alignment (vertical/horizontal?), thereby hint text space. */
     char * more = "more";
-    uint16_t dsc_space = frame->size.x;
+    uint16_t dsc_space = fsize.x;
     if ('<' == dir || '>' == dir)
     {
-        dsc_space = frame->size.y;
+        dsc_space = fsize.y;
     }                                  /* vv-- 10 = max strlen for uint16_t */
     char scrolldsc[1 + strlen(more) + 1 + 10 + 1 + strlen(unit) + 1 + 1];
     sprintf(scrolldsc, " %d %s %s ", dist, more, unit);
@@ -211,11 +207,11 @@ static void scroll_hint(struct WinMeta * wm, struct Frame * frame, char dir,
     uint16_t draw_offset = 0;
     if      ('>' == dir)
     {
-        draw_offset = frame->size.x - 1;
+        draw_offset = fsize.x - 1;
     }
     else if ('v' == dir)
     {
-        draw_offset = frame->size.y - 1;
+        draw_offset = fsize.y - 1;
     }
     uint16_t q = 0;
     for (; q < dsc_space; q++)
@@ -227,13 +223,11 @@ static void scroll_hint(struct WinMeta * wm, struct Frame * frame, char dir,
         }
         if ('<' == dir || '>' == dir)
         {
-            mvwaddch(wm->padframe.curses_win,
-                     start.y + q, start.x + draw_offset, symbol);
+            mvwaddch(wm->pad, start.y + q, start.x + draw_offset, symbol);
         }
         else
         {
-            mvwaddch(wm->padframe.curses_win,
-                     start.y + draw_offset, start.x + q, symbol);
+            mvwaddch(wm->pad, start.y + draw_offset, start.x + q, symbol);
         }
     }
 }
@@ -244,7 +238,7 @@ static void padscroll_hint(struct WinMeta * wm, char dir, uint16_t dist)
     struct yx_uint16 start;
     start.y = 0;
     start.x = wm->pad_offset;
-    scroll_hint(wm, &wm->padframe, dir, dist, "columns", start);
+    scroll_hint(wm, wm->padsize, dir, dist, "columns", start);
 }
 
 
@@ -258,46 +252,47 @@ static void winscroll_hint(struct WinMeta * wm, struct Win * w, char dir,
         unit = "columns";
     }
     struct yx_uint16 start = w->start;
-    scroll_hint(wm, &w->frame, dir, dist, unit, start);
+    scroll_hint(wm, w->framesize, dir, dist, unit, start);
 }
 
 
 
 static uint8_t draw_wins(struct WinMeta * wm, struct Win * w)
 {
-    if (ERR == wresize(w->frame.curses_win, 1, 1))
-    {
-        return 1;
-    }
     w->draw(w);
     uint16_t y, x, size_y, size_x;
-    getmaxyx(w->frame.curses_win, size_y, size_x);
-    uint16_t offset_y = center_offset(w->center.y, size_y, w->frame.size.y);
-    uint16_t offset_x = center_offset(w->center.x, size_x, w->frame.size.x);
-    for (y = offset_y; y < w->frame.size.y + offset_y && y < size_y; y++)
+    size_y = w->winmapsize.y;
+    size_x = w->winmapsize.x;
+    uint16_t offset_y = center_offset(w->center.y, size_y, w->framesize.y);
+    uint16_t offset_x = center_offset(w->center.x, size_x, w->framesize.x);
+    for (y = offset_y; y < w->framesize.y + offset_y && y < size_y; y++)
     {
-        for (x = offset_x; x < w->frame.size.x + offset_x && x < size_x; x++)
+        for (x = offset_x; x < w->framesize.x + offset_x && x < size_x; x++)
         {
-            chtype ch = mvwinch(w->frame.curses_win, y, x);
-            mvwaddch(wm->padframe.curses_win, w->start.y + (y - offset_y),
-                                              w->start.x + (x - offset_x), ch);
+            chtype ch = w->winmap[(y * w->winmapsize.x) + x];
+            mvwaddch(wm->pad, w->start.y + (y - offset_y),
+                              w->start.x + (x - offset_x), ch);
         }
     }
+    free(w->winmap);
+    w->winmap = NULL;
+    w->winmapsize.y = 0;
+    w->winmapsize.x = 0;
     if (offset_y > 0)
     {
         winscroll_hint(wm, w, '^', offset_y + 1);
     }
-    if (size_y > offset_y + w->frame.size.y)
+    if (size_y > offset_y + w->framesize.y)
     {
-        winscroll_hint(wm, w, 'v', size_y - ((offset_y + w->frame.size.y) - 1));
+        winscroll_hint(wm, w, 'v', size_y - ((offset_y + w->framesize.y) - 1));
     }
     if (offset_x > 0)
     {
         winscroll_hint(wm, w, '<', offset_x + 1);
     }
-    if (size_x > offset_x + w->frame.size.x)
+    if (size_x > offset_x + w->framesize.x)
     {
-        winscroll_hint(wm, w, '>', size_x - ((offset_x + w->frame.size.x) - 1));
+        winscroll_hint(wm, w, '>', size_x - ((offset_x + w->framesize.x) - 1));
     }
     if (0 != w->next)
     {
@@ -312,27 +307,27 @@ static void draw_win_borderlines(struct Win * w, char active, WINDOW * pad)
 {
     /* Draw vertical and horizontal border lines. */
     uint16_t y, x;
-    for (y = w->start.y; y <= w->start.y + w->frame.size.y; y++)
+    for (y = w->start.y; y <= w->start.y + w->framesize.y; y++)
     {
-        mvwaddch(pad, y, w->start.x - 1,               '|');
-        mvwaddch(pad, y, w->start.x + w->frame.size.x, '|');
+        mvwaddch(pad, y, w->start.x - 1,              '|');
+        mvwaddch(pad, y, w->start.x + w->framesize.x, '|');
     }
-    for (x = w->start.x; x <= w->start.x + w->frame.size.x; x++)
+    for (x = w->start.x; x <= w->start.x + w->framesize.x; x++)
     {
-        mvwaddch(pad, w->start.y - 1,               x, '-');
-        mvwaddch(pad, w->start.y + w->frame.size.y, x, '-');
+        mvwaddch(pad, w->start.y - 1,              x, '-');
+        mvwaddch(pad, w->start.y + w->framesize.y, x, '-');
     }
 
     /* Draw as much as possible of the title into center of top border line. */
     char min_title_length_visible = 3;  /* min. 1 char + 2 padding/decoration */
-    if (w->frame.size.x >= min_title_length_visible)
+    if (w->framesize.x >= min_title_length_visible)
     {
         uint16_t title_offset = 0;
-        if (w->frame.size.x > strlen(w->title) + 2)
+        if (w->framesize.x > strlen(w->title) + 2)
         {
-            title_offset = (w->frame.size.x - (strlen(w->title) + 2)) / 2;
+            title_offset = (w->framesize.x - (strlen(w->title) + 2)) / 2;
         }                                    /* +2 is for padding/decoration */
-        uint16_t length_visible = strnlen(w->title, w->frame.size.x - 2);
+        uint16_t length_visible = strnlen(w->title, w->framesize.x - 2);
         char title[length_visible + 3];
         char decoration = ' ';
         if (1 == active)
@@ -368,10 +363,9 @@ static void draw_wins_borderlines(struct Win * w, struct Win * w_active,
 static void draw_wins_bordercorners(struct Win * w, WINDOW * pad)
 {
     mvwaddch(pad, w->start.y - 1, w->start.x - 1, '+');
-    mvwaddch(pad, w->start.y - 1, w->start.x + w->frame.size.x, '+');
-    mvwaddch(pad, w->start.y + w->frame.size.y, w->start.x - 1, '+');
-    mvwaddch(pad,
-             w->start.y + w->frame.size.y, w->start.x + w->frame.size.x, '+');
+    mvwaddch(pad, w->start.y - 1, w->start.x + w->framesize.x, '+');
+    mvwaddch(pad, w->start.y + w->framesize.y, w->start.x - 1, '+');
+    mvwaddch(pad, w->start.y + w->framesize.y, w->start.x + w->framesize.x,'+');
     if (0 != w->next)
     {
         draw_wins_bordercorners(w->next, pad);
@@ -472,17 +466,17 @@ extern uint8_t init_win_meta(WINDOW * screen, struct WinMeta ** wmp)
     {
         return 2;
     }
-    wmeta->padframe.size.y     = maxy_test;
-    wmeta->padframe.size.x     = maxx_test;
+    wmeta->padsize.y           = maxy_test;
+    wmeta->padsize.x           = maxx_test;
     wmeta->chain_start         = 0;
     wmeta->chain_end           = 0;
     wmeta->pad_offset          = 0;
-    WINDOW * pad_test          = newpad(wmeta->padframe.size.y, 1);
+    WINDOW * pad_test          = newpad(wmeta->padsize.y, 1);
     if (NULL == pad_test)
     {
         return 1;
     }
-    wmeta->padframe.curses_win = pad_test;
+    wmeta->pad = pad_test;
     wmeta->active              = 0;
     *wmp = wmeta;
     return 0;
@@ -499,38 +493,36 @@ extern uint8_t init_win(struct WinMeta * wmeta, struct Win ** wp, char * title,
     {
         return 1;
     }
-    w->prev             = 0;
-    w->next             = 0;
-    w->frame.curses_win = newpad(1, 1);
-    if (NULL == w->frame.curses_win)
-    {
-        return 1;
-    }
-    w->title            = malloc(strlen(title) + 1);
+    w->prev         = 0;
+    w->next         = 0;
+    w->winmapsize.y = 0;
+    w->winmapsize.x = 0;
+    w->winmap = NULL;
+    w->title        = malloc(strlen(title) + 1);
     if (NULL == w->title)
     {
         return 1;
     }
     sprintf(w->title, "%s", title);
-    w->data             = data;
-    w->draw             = func;
-    w->center.y         = 0;
-    w->center.x         = 0;
+    w->data         = data;
+    w->draw         = func;
+    w->center.y     = 0;
+    w->center.x     = 0;
     if      (0 < width)
     {
-        w->frame.size.x = width;
+        w->framesize.x = width;
     }
     else if (0 >= width)
     {
-        w->frame.size.x = wmeta->padframe.size.x + width;
+        w->framesize.x = wmeta->padsize.x + width;
     }
-    if      (0 < height && height <= wmeta->padframe.size.y - 1)
+    if      (0 < height && height <= wmeta->padsize.y - 1)
     {
-        w->frame.size.y = height;
+        w->framesize.y = height;
     }
-    else if (0 >= height && wmeta->padframe.size.y + (height - 1) > 0)
+    else if (0 >= height && wmeta->padsize.y + (height - 1) > 0)
     {
-        w->frame.size.y = wmeta->padframe.size.y + (height - 1);
+        w->framesize.y = wmeta->padsize.y + (height - 1);
     }
     *wp = w;
     return 0;
@@ -540,7 +532,7 @@ extern uint8_t init_win(struct WinMeta * wmeta, struct Win ** wp, char * title,
 
 extern void free_winmeta(struct WinMeta * wmeta)
 {
-    delwin(wmeta->padframe.curses_win);
+    delwin(wmeta->pad);
     free(wmeta);
 }
 
@@ -548,7 +540,6 @@ extern void free_winmeta(struct WinMeta * wmeta)
 
 extern void free_win(struct Win * win)
 {
-    delwin(win->frame.curses_win);
     free(win->title);
     free(win);
 }
@@ -623,8 +614,7 @@ extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset)
 {
     if (new_offset >= 0
         && (new_offset < wmeta->pad_offset
-            || new_offset + wmeta->padframe.size.x
-               < getmaxx(wmeta->padframe.curses_win)))
+            || new_offset + wmeta->padsize.x < getmaxx(wmeta->pad)))
     {
         wmeta->pad_offset = new_offset;
     }
@@ -635,10 +625,9 @@ extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset)
 extern uint8_t resize_active_win(struct WinMeta * wmeta, struct yx_uint16 size)
 {
     if (0 != wmeta->active
-        && size.x > 0 && size.y > 0
-        && size.y < wmeta->padframe.size.y)
+        && size.x > 0 && size.y > 0 && size.y < wmeta->padsize.y)
     {
-        wmeta->active->frame.size = size;
+        wmeta->active->framesize = size;
         return update_wins(wmeta, wmeta->active); /* Positioning of following */
     }                                             /* windows may be affected. */
     return 0;
@@ -702,15 +691,13 @@ extern uint8_t draw_all_wins(struct WinMeta * wm)
     /* Empty everything before filling it a-new. */
     erase();
     wnoutrefresh(wm->screen);
-    werase(wm->padframe.curses_win);
+    werase(wm->pad);
     if (wm->chain_start)
     {
 
         /* Draw windows' borders first, then windows. */
-        draw_wins_borderlines(wm->chain_start, wm->active,
-                              wm->padframe.curses_win);
-        draw_wins_bordercorners(wm->chain_start, wm->padframe.curses_win);
-
+        draw_wins_borderlines(wm->chain_start, wm->active, wm->pad);
+        draw_wins_bordercorners(wm->chain_start, wm->pad);
         if (1 == draw_wins(wm, wm->chain_start))
         {
             return 1;
@@ -721,16 +708,16 @@ extern uint8_t draw_all_wins(struct WinMeta * wm)
         {
             padscroll_hint(wm, '<', wm->pad_offset + 1);
         }
-        uint16_t size_x = getmaxx(wm->padframe.curses_win);
-        uint16_t right_edge = wm->pad_offset + wm->padframe.size.x;
+        uint16_t size_x = getmaxx(wm->pad);
+        uint16_t right_edge = wm->pad_offset + wm->padsize.x;
         if (right_edge < size_x - 1)
         {
             padscroll_hint(wm, '>', size_x - right_edge);
         }
 
         /* Write pad segment to be shown on physical screen to screen buffer. */
-        pnoutrefresh(wm->padframe.curses_win, 0, wm->pad_offset, 0, 0,
-                     wm->padframe.size.y, wm->padframe.size.x - 1);
+        pnoutrefresh(wm->pad, 0, wm->pad_offset, 0, 0,
+                     wm->padsize.y, wm->padsize.x - 1);
     }
 
     /* Only at the end write accumulated changes to the physical screen. */
diff --git a/src/windows.h b/src/windows.h
index eed33ff..abebe0d 100644
--- a/src/windows.h
+++ b/src/windows.h
@@ -37,35 +37,30 @@
 
 
 #include <stdint.h>    /* for uint8_t, uint16_t, uint32_t */
-#include <ncurses.h>   /* for the WINDOW typedef */
-#include "yx_uint16.h" /* for yx_uint16 coordinates */
+#include <ncurses.h>   /* for the WINDOW and chtype typedefs */
+#include "yx_uint16.h" /* for yx_uint16 struct */
 
 
 
-/* Individual windows consist of potential (real only if window is visible
- * inside the virtual screen) ncurses WINDOWs wrapped inside Frame structs (that
- * keep a window's designated size even when it is invisible) wrapped inside
- * metadata-rich Win structs. Win structs are chained into a linked list of all
- * the windows visible on the virtual screen and also contain pointers to what
- * content is to be drawn inside the window, and by use of what method.
+/* Individual windows are represented by "Win" structs. They describe frames
+ * located inside the virtual screen pad through which "winmaps" are visible,
+ * 2-dimensional maps of ncurses chtypes. Win structs are chained into a linked
+ * list of all the windows visible on the virtual screen and also contain
+ * pointers to what content is to be drawn inside the window, and by use of what
+ * method.
  */
-
-struct Frame               /* If Frame is Win's "frame", "size" is the        */
-{                          /* designated size of curses_win's ncurses WINDOW. */
-    WINDOW * curses_win;   /* If Frame is WinMeta's "padframe", curses_win is */
-    struct yx_uint16 size; /* the ncurses pad representing the virtual screen */
-};                         /* and "size" desribes the terminal screen size.   */
-
 struct Win
 {
     struct Win * prev;  /* chain pointers; if 0, they mark the start or end  */
     struct Win * next;  /* of the chain; if both are 0, Win is outside chain */
-    struct yx_uint16 start;       /* upper left corner of "frame" WINDOW */
+    struct yx_uint16 framesize;   /* window frame size to see winmap through */
+    struct yx_uint16 start;       /* upper left corner of window in pad */
     struct yx_uint16 center;      /* window content center to focus window on */
     char * title;                 /* title to be used in window title bar */
     void (* draw) (struct Win *); /* how to draw window content ("data") */
-    struct Frame frame;
     void * data;                  /* window content to be drawn by _draw() */
+    chtype * winmap;              /* sequence of cells, sorted into lines ... */
+    struct yx_uint16 winmapsize;  /* ... with these geometry infos  */
 };
 
 
@@ -76,10 +71,11 @@ struct Win
 struct WinMeta
 {
     WINDOW * screen;          /* ncurses' pointer to the terminal screen */
+    WINDOW * pad;             /* ncurses pad of virtual screen */
+    uint16_t pad_offset;      /* number of cells view is moved to the right */
+    struct yx_uint16 padsize; /* virtual screen size */
     struct Win * chain_start; /* first Win in chain; its _prev == 0 */
     struct Win * chain_end;   /* last Win in chain; its _next == 0 */
-    uint16_t pad_offset;      /* number of cells view is moved to the right */
-    struct Frame padframe;    /* virtual screen fitted into terminal screen */
     struct Win * active;      /* Win highlighted/selected for manipulation */
 };