Reorganized Win and WinMeta structs to use a common struct to organize curses window...

diff --git a/draw_wins.c b/draw_wins.c
index 7eadbe8cd7a69db1b50593fd3f6dae1352f7c2ec..9fa64c9a36398da6326965e181559e72caeea7f8 100644 (file)
--- a/draw_wins.c
+++ b/draw_wins.c
@@ -13,17 +13,17 @@ void draw_with_linebreaks (struct Win * win, char * text, uint16_t start_y) {
   char toggle;
   char fin = 0;
   int16_t z = -1;
-  for (y = start_y; y < win->size.y; y++) {
+  for (y = start_y; y < win->frame.size.y; y++) {
     if (0 == fin)
       toggle = 0;
-    for (x = 0; x < win->size.x; x++) {
+    for (x = 0; x < win->frame.size.x; x++) {
        if (0 == toggle) {
          z++;
          if ('\n' == text[z]) {
            toggle = 1;
            continue; }
          else
-           mvwaddch(win->curses, y, x, text[z]);
+           mvwaddch(win->frame.curses_win, y, x, text[z]);
          if ('\n' == text[z+1]) {
            z++;
            toggle = 1; }
@@ -37,7 +37,7 @@ void draw_text_from_bottom (struct Win * win, char * text) {
   uint16_t x, y, offset;
   int16_t z = -1;
   for (y = 0; 0 == toggle; y++)                           // Determine number of lines text would have in
-    for (x = 0; x < win->size.x; x++) {                   // a window of available width, but infinite height.
+    for (x = 0; x < win->frame.size.x; x++) {             // a window of available width, but infinite height.
       z++;
       if ('\n' == text[z])            // Treat \n and \0 as control characters for incrementing y and stopping
         break;                        // the loop. Make sure they don't count as cell space themselves.
@@ -49,12 +49,12 @@ void draw_text_from_bottom (struct Win * win, char * text) {
         break; } }
   z = -1;
   uint16_t start_y = 0;
-  if (y < win->size.y)             // Depending on what is bigger, determine start point in window or in text.
-    start_y = win->size.y - y;
-  else if (y > win->size.y) {
-    offset = y - win->size.y;
+  if (y < win->frame.size.y)       // Depending on what is bigger, determine start point in window or in text.
+    start_y = win->frame.size.y - y;
+  else if (y > win->frame.size.y) {
+    offset = y - win->frame.size.y;
     for (y = 0; y < offset; y++)
-      for (x = 0; x < win->size.x; x++) {
+      for (x = 0; x < win->frame.size.x; x++) {
         z++;
         if ('\n' == text[z])
           break;
@@ -79,16 +79,16 @@ void draw_map_win (struct Win * win) {
   uint16_t width_map_av = map->width - map->offset_x;
   uint16_t height_map_av = map->height - map->offset_y;
   uint16_t x, y, z;
-  for (y = 0; y < win->size.y; y++) {
+  for (y = 0; y < win->frame.size.y; y++) {
     z = map->offset_x + (map->offset_y + y) * (map->width);
-    for (x = 0; x < win->size.x; x++) {
+    for (x = 0; x < win->frame.size.x; x++) {
       if (y < height_map_av && x < width_map_av) {
         if (z == (map->width * player->y) + player->x)
-          mvwaddch(win->curses, y, x, '@');
+          mvwaddch(win->frame.curses_win, y, x, '@');
         else if (z == (map->width * monster->y) + monster->x)
-          mvwaddch(win->curses, y, x, 'M');
+          mvwaddch(win->frame.curses_win, y, x, 'M');
         else
-          mvwaddch(win->curses, y, x, cells[z]);
+          mvwaddch(win->frame.curses_win, y, x, cells[z]);
         z++; } } } }
 
 void draw_info_win (struct Win * win) {
@@ -103,37 +103,37 @@ void draw_horizontal_scroll_hint (struct Win * win, uint16_t y, uint32_t more_li
 // Draw scroll hint line in win at row y, announce more_lines more lines in direction dir.
   uint16_t x, offset;
   char phrase[] = "more lines";
-  char * scrolldesc = malloc((3 * sizeof(char)) + strlen(phrase) + 10); // 10 = max chars for uint32_t string
+  char * scrolldesc = malloc((3 * sizeof(char)) + strlen(phrase) + 10);  // 10 = max chars for uint32_t string
   sprintf(scrolldesc, " %d %s ", more_lines, phrase);
   offset = 1;
-  if (win->size.x > (strlen(scrolldesc) + 1))
-    offset = (win->size.x - strlen(scrolldesc)) / 2;
-  for (x = 0; x < win->size.x; x++)
+  if (win->frame.size.x > (strlen(scrolldesc) + 1))
+    offset = (win->frame.size.x - strlen(scrolldesc)) / 2;
+  for (x = 0; x < win->frame.size.x; x++)
     if (x >= offset && x < strlen(scrolldesc) + offset)
-      mvwaddch(win->curses, y, x, scrolldesc[x - offset] | A_REVERSE);
+      mvwaddch(win->frame.curses_win, y, x, scrolldesc[x - offset] | A_REVERSE);
     else
-      mvwaddch(win->curses, y, x, dir | A_REVERSE);
+      mvwaddch(win->frame.curses_win, y, x, dir | A_REVERSE);
   free(scrolldesc); }
 
 void draw_keys_win (struct Win * win) {
 // Draw keybindings window.
   struct World * world = (struct World *) win->data;
   uint16_t offset = 0, y, x;
-  if (world->keyswindata->max >= win->size.y) {
-    if (world->keyswindata->select > win->size.y / 2) {
-      if (world->keyswindata->select < (world->keyswindata->max - (win->size.y / 2)))
-        offset = world->keyswindata->select - (win->size.y / 2);
+  if (world->keyswindata->max >= win->frame.size.y) {
+    if (world->keyswindata->select > win->frame.size.y / 2) {
+      if (world->keyswindata->select < (world->keyswindata->max - (win->frame.size.y / 2)))
+        offset = world->keyswindata->select - (win->frame.size.y / 2);
       else
-        offset = world->keyswindata->max - win->size.y + 1; } }
+        offset = world->keyswindata->max - win->frame.size.y + 1; } }
   uint8_t keydescwidth = 9 + 1; // max length assured by get_keyname() + \0
   char * keydesc = malloc(keydescwidth), * keyname;
   attr_t attri;
-  for (y = 0; y <= world->keyswindata->max && y < win->size.y; y++) {
+  for (y = 0; y <= world->keyswindata->max && y < win->frame.size.y; y++) {
     if (0 == y && offset > 0) {
       draw_horizontal_scroll_hint (win, y, offset + 1, '^');
       continue; }
-    else if (win->size.y == y + 1 && 0 < world->keyswindata->max - (win->size.y + offset - 1)) {
-      draw_horizontal_scroll_hint (win, y, world->keyswindata->max - (offset + win->size.y) + 2, 'v');
+    else if (win->frame.size.y == y + 1 && 0 < world->keyswindata->max - (win->frame.size.y + offset - 1)) {
+      draw_horizontal_scroll_hint (win, y, world->keyswindata->max - (offset + win->frame.size.y) + 2, 'v');
       continue; }
     attri = 0;
     if (y == world->keyswindata->select - offset) {
@@ -143,11 +143,12 @@ void draw_keys_win (struct Win * win) {
     keyname = get_keyname(world->keybindings[y + offset].key);
     snprintf(keydesc, keydescwidth, "%-9s", keyname);
     free(keyname);
-    for (x = 0; x < win->size.x; x++)
+    for (x = 0; x < win->frame.size.x; x++)
       if (x < strlen(keydesc))
-        mvwaddch(win->curses, y, x, keydesc[x] | attri);
+        mvwaddch(win->frame.curses_win, y, x, keydesc[x] | attri);
       else if (strlen(keydesc) < x && x < strlen(world->keybindings[y + offset].name) + strlen(keydesc) + 1)
-        mvwaddch(win->curses, y, x, world->keybindings[y + offset].name[x - strlen(keydesc) - 1] | attri);
+        mvwaddch(win->frame.curses_win, y, x,
+                 world->keybindings[y + offset].name[x - strlen(keydesc) - 1] | attri);
       else
-        mvwaddch(win->curses, y, x, ' ' | attri); }
+        mvwaddch(win->frame.curses_win, y, x, ' ' | attri); }
   free(keydesc); }

diff --git a/roguelike.c b/roguelike.c
index 00b3ecc46c1f1335024b785a5f640ff23a0b5b34..9b858f3f1c872268d3d7bfa226b61ac232218515 100644 (file)
--- a/roguelike.c
+++ b/roguelike.c
@@ -67,7 +67,7 @@ void save_game(struct World * world) {
 
 void toggle_window (struct WinMeta * win_meta, struct Win * win) {
 // Toggle display of window win.
-  if (0 != win->curses)
+  if (0 != win->frame.curses_win)
     suspend_window(win_meta, win);
   else
     append_window(win_meta, win); }
@@ -82,8 +82,8 @@ void scroll_pad (struct WinMeta * win_meta, char dir) {
 void growshrink_active_window (struct WinMeta * win_meta, char change) {
 // Grow or shrink active window horizontally or vertically by one cell size.
   if (0 != win_meta->active) {
-    uint16_t height = win_meta->active->size.y;
-    uint16_t width = win_meta->active->size.x;
+    uint16_t height = win_meta->active->frame.size.y;
+    uint16_t width = win_meta->active->frame.size.x;
     if      (change == '-')
       height--;
     else if (change == '+')
@@ -345,10 +345,10 @@ int main (int argc, char *argv[]) {
   struct Win win_map = init_window(&win_meta, "Map", &world, draw_map_win);
   struct Win win_info = init_window(&win_meta, "Info", &world, draw_info_win);
   struct Win win_log = init_window(&win_meta, "Log", &world, draw_log_win);
-  win_keys.size.x = 29;
-  win_map.size.x = win_meta.size.x - win_keys.size.x - win_log.size.x - 2;
-  win_info.size.y = 1;
-  win_log.size.y = win_meta.size.y - 3;
+  win_keys.frame.size.x = 29;
+  win_map.frame.size.x = win_meta.pad.size.x - win_keys.frame.size.x - win_log.frame.size.x - 2;
+  win_info.frame.size.y = 1;
+  win_log.frame.size.y = win_meta.pad.size.y - 3;
   toggle_window(&win_meta, &win_keys);
   toggle_window(&win_meta, &win_map);
   toggle_window(&win_meta, &win_info);

diff --git a/windows.c b/windows.c
index a1c0875a964e65cece9f417edc97b77a3926d544..92e33234704b89ade844bba1924e76110edd36af 100644 (file)
--- a/windows.c
+++ b/windows.c
@@ -23,12 +23,12 @@ extern struct WinMeta init_win_meta (WINDOW * screen) {
 // Create and populate WinMeta struct with sane default values.
   struct WinMeta win_meta;
   win_meta.screen = screen;
-  win_meta.size.y = getmaxy(screen);
-  win_meta.size.x = getmaxx(screen);
+  win_meta.pad.size.y = getmaxy(screen);
+  win_meta.pad.size.x = getmaxx(screen);
   win_meta.chain_start = 0;
   win_meta.chain_end = 0;
   win_meta.pad_offset = 0;
-  win_meta.pad = newpad(win_meta.size.y, 1);
+  win_meta.pad.curses_win = newpad(win_meta.pad.size.y, 1);
   win_meta.active = 0;
   return win_meta; }
 
@@ -37,10 +37,10 @@ extern struct Win init_window (struct WinMeta * win_meta, char * title, void * d
   struct Win win;
   win.prev = 0;
   win.next = 0;
-  win.curses = 0;
+  win.frame.curses_win = 0;
   win.title = title;
-  win.size.x = 20;
-  win.size.y = win_meta->size.y - 1;
+  win.frame.size.x = 20;
+  win.frame.size.y = win_meta->pad.size.y - 1;
   win.data = data;
   win.draw = func;
   return win; }
@@ -61,11 +61,11 @@ static void refit_pad (struct WinMeta * win_meta) {
   uint16_t lastwincol = 0;
   struct Win * win_p = win_meta->chain_start;
   while (win_p != 0) {
-    if (win_p->start.x + win_p->size.x > lastwincol + 1)
-      lastwincol = win_p->start.x + win_p->size.x - 1;
+    if (win_p->start.x + win_p->frame.size.x > lastwincol + 1)
+      lastwincol = win_p->start.x + win_p->frame.size.x - 1;
     win_p = win_p->next; }
-  if (getmaxx(win_meta->pad) != lastwincol)
-    wresize(win_meta->pad, getmaxy(win_meta->pad), lastwincol + 2); }
+  if (getmaxx(win_meta->pad.curses_win) != lastwincol)
+    wresize(win_meta->pad.curses_win, getmaxy(win_meta->pad.curses_win), lastwincol + 2); }
 
 extern void suspend_window (struct WinMeta * win_meta, struct Win * win) {
 // Destroy win, suspend from chain. Update geometry of following rows and pad, as well as activity selection.
@@ -98,9 +98,10 @@ static void place_window (struct WinMeta * win_meta, struct Win * win) {
     struct Win * win_top = win->prev;
     while (win_top->start.y != 1)
       win_top = win_top->prev;                                   // else, default to placing window in new top
-    win->start.x = win_top->start.x + win_top->size.x + 1;       // column to the right of the last one
-    uint16_t winprev_maxy = win->prev->start.y + getmaxy(win->prev->curses);
-    if (win->size.x <= win->prev->size.x && win->size.y < win_meta->size.y - winprev_maxy) {
+    win->start.x = win_top->start.x + win_top->frame.size.x + 1; // column to the right of the last one
+    uint16_t winprev_maxy = win->prev->start.y + getmaxy(win->prev->frame.curses_win);
+    if (   win->frame.size.x <= win->prev->frame.size.x
+        && win->frame.size.y < win_meta->pad.size.y - winprev_maxy) {
       win->start.x = win->prev->start.x;                   // place window below previous window if it fits
       win->start.y = winprev_maxy + 1; }                   // vertically and is not wider than its predecessor
     else {
@@ -113,44 +114,45 @@ static void place_window (struct WinMeta * win_meta, struct Win * win) {
           if (win_up->start.y != win_upup->start.y)
             break;
           win_upup = win_upup->prev; }
-        winprev_maxy = win_upup->start.y + getmaxy(win_upup->curses);
-        widthdiff = (win_upup->start.x + win_upup->size.x) - (win_up->start.x + win_up->size.x);
-        if (win->size.y < win_meta->size.y - winprev_maxy && win->size.x < widthdiff) {
-          win->start.x = win_up->start.x + win_up->size.x + 1;   // else try to open new sub column under last
-          win->start.y = winprev_maxy + 1;                       // window below which enough space remains
+        winprev_maxy = win_upup->start.y + getmaxy(win_upup->frame.curses_win);
+        widthdiff = (win_upup->start.x + win_upup->frame.size.x) - (win_up->start.x + win_up->frame.size.x);
+        if (win->frame.size.y < win_meta->pad.size.y - winprev_maxy && win->frame.size.x < widthdiff) {
+          win->start.x = win_up->start.x + win_up->frame.size.x + 1 ; // else try to open new sub column under
+          win->start.y = winprev_maxy + 1;                     // last window below which enough space remains
           break; }
         win_up = win_upup; } } } }
 
 static void update_windows (struct WinMeta * win_meta, struct Win * win) {
 // Update geometry of win and its next of kin. Destroy (if visible), (re-)build window. If need, resize pad.
-  if (0 != win->curses)
+  if (0 != win->frame.curses_win)
     destroy_window (win);
   place_window(win_meta, win);
   refit_pad(win_meta);
-  win->curses = subpad(win_meta->pad, win->size.y, win->size.x, win->start.y, win->start.x);
+  win->frame.curses_win = subpad(win_meta->pad.curses_win, win->frame.size.y, win->frame.size.x, win->start.y,
+                                 win->start.x);
   if (0 != win->next)
     update_windows (win_meta, win->next); }
 
 static void destroy_window (struct Win * win) {
 // Delete window.
-  delwin(win->curses);
-  win->curses = 0; }
+  delwin(win->frame.curses_win);
+  win->frame.curses_win = 0; }
 
 static void draw_window_borders (struct Win * win, char active) {
 // Draw borders of window win, including title. Decorate in a special way if window is marked as active.
   uint16_t y, x;
-  for (y = win->start.y; y <= win->start.y + win->size.y; y++) {
-    mvwaddch(wgetparent(win->curses), y, win->start.x - 1, '|');
-    mvwaddch(wgetparent(win->curses), y, win->start.x + win->size.x, '|'); }
-  for (x = win->start.x; x <= win->start.x + win->size.x; x++) {
-    mvwaddch(wgetparent(win->curses), win->start.y - 1, x, '-');
-    mvwaddch(wgetparent(win->curses), win->start.y + win->size.y, x, '-'); }
+  for (y = win->start.y; y <= win->start.y + win->frame.size.y; y++) {
+    mvwaddch(wgetparent(win->frame.curses_win), y, win->start.x - 1, '|');
+    mvwaddch(wgetparent(win->frame.curses_win), y, win->start.x + win->frame.size.x, '|'); }
+  for (x = win->start.x; x <= win->start.x + win->frame.size.x; x++) {
+    mvwaddch(wgetparent(win->frame.curses_win), win->start.y - 1, x, '-');
+    mvwaddch(wgetparent(win->frame.curses_win), win->start.y + win->frame.size.y, x, '-'); }
   char min_title_length_visible = 3;        // 1 char minimal, plus 2 chars for decoration left/right of title
-  if (win->size.x >= min_title_length_visible) {
+  if (win->frame.size.x >= min_title_length_visible) {
     uint16_t title_offset = 0;
-    if (win->size.x > strlen(win->title) + 2)
-      title_offset = (win->size.x - (strlen(win->title) + 2)) / 2;                    // + 2 is for decoration
-    uint16_t length_visible = strnlen(win->title, win->size.x - 2);
+    if (win->frame.size.x > strlen(win->title) + 2)
+      title_offset = (win->frame.size.x - (strlen(win->title) + 2)) / 2;              // + 2 is for decoration
+    uint16_t length_visible = strnlen(win->title, win->frame.size.x - 2);
     char title[length_visible + 3];
     char decoration = ' ';
     if (1 == active)
@@ -158,9 +160,10 @@ static void draw_window_borders (struct Win * win, char active) {
     memcpy(title + 1, win->title, length_visible);
     title[0] = title[length_visible + 1] = decoration;
     title[length_visible + 2] = '\0';
-    mvwaddstr(wgetparent(win->curses), win->start.y - 1, win->start.x + title_offset, title); } }
+    mvwaddstr(wgetparent(win->frame.curses_win), win->start.y - 1, win->start.x + title_offset, title); } }
 
-static void draw_windows_borders (struct Win * win, struct Win * win_active, struct Corners * corners, uint16_t ccount) {
+static void draw_windows_borders (struct Win * win, struct Win * win_active, struct Corners * corners,
+                                  uint16_t ccount) {
 // Craw draw_window_borders() for all windows in chain from win on. Save current window's border corners.
   char active = 0;
   if (win == win_active)
@@ -169,11 +172,11 @@ static void draw_windows_borders (struct Win * win, struct Win * win_active, str
   corners[ccount].tl.y = win->start.y - 1;
   corners[ccount].tl.x = win->start.x - 1;
   corners[ccount].tr.y = win->start.y - 1;
-  corners[ccount].tr.x = win->start.x + win->size.x;
-  corners[ccount].bl.y = win->start.y + win->size.y;
+  corners[ccount].tr.x = win->start.x + win->frame.size.x;
+  corners[ccount].bl.y = win->start.y + win->frame.size.y;
   corners[ccount].bl.x = win->start.x - 1;
-  corners[ccount].br.y = win->start.y + win->size.y;
-  corners[ccount].br.x = win->start.x + win->size.x;
+  corners[ccount].br.y = win->start.y + win->frame.size.y;
+  corners[ccount].br.x = win->start.x + win->frame.size.x;
   if (0 != win->next) {
     draw_windows_borders (win->next, win_active, corners, ccount + 1); } }
 
@@ -187,23 +190,23 @@ static void draw_vertical_scroll_hint (struct WinMeta * win_meta, uint16_t x, ui
 // Draw scroll hint line in win at col x of pad display, announce more_cols more columns in direction dir.
   uint16_t y, offset;
   char phrase[] = "more columns";
-  char * scrolldesc = malloc((3 * sizeof(char)) + strlen(phrase) + 10); // 10 = max chars for uint32_t string
+  char * scrolldesc = malloc((3 * sizeof(char)) + strlen(phrase) + 10);  // 10 = max chars for uint32_t string
   sprintf(scrolldesc, " %d %s ", more_cols, phrase);
   offset = 1;
-  if (win_meta->size.y > (strlen(scrolldesc) + 1))
-    offset = (win_meta->size.y - strlen(scrolldesc)) / 2;
-  for (y = 0; y < win_meta->size.y; y++)
+  if (win_meta->pad.size.y > (strlen(scrolldesc) + 1))
+    offset = (win_meta->pad.size.y - strlen(scrolldesc)) / 2;
+  for (y = 0; y < win_meta->pad.size.y; y++)
     if (y >= offset && y < strlen(scrolldesc) + offset)
-      mvwaddch(win_meta->pad, y, x, scrolldesc[y - offset] | A_REVERSE);
+      mvwaddch(win_meta->pad.curses_win, y, x, scrolldesc[y - offset] | A_REVERSE);
     else
-      mvwaddch(win_meta->pad, y, x, dir | A_REVERSE);
+      mvwaddch(win_meta->pad.curses_win, y, x, dir | A_REVERSE);
   free(scrolldesc); }
 
 extern void draw_all_windows (struct WinMeta * win_meta) {
 // Draw pad with all windows and their borders, plus scrolling hints.
   erase();
   wnoutrefresh(win_meta->screen);
-  werase(win_meta->pad);
+  werase(win_meta->pad.curses_win);
   if (win_meta->chain_start) {
     uint16_t n_wins = 1;
     struct Win * win_p = win_meta->chain_start;
@@ -215,26 +218,29 @@ extern void draw_all_windows (struct WinMeta * win_meta) {
     draw_windows_borders (win_meta->chain_start, win_meta->active, all_corners, 0);
     uint16_t i;
     for (i = 0; i < n_wins; i++) {
-      mvwaddch(win_meta->pad, all_corners[i].tl.y, all_corners[i].tl.x, '+');
-      mvwaddch(win_meta->pad, all_corners[i].tr.y, all_corners[i].tr.x, '+');
-      mvwaddch(win_meta->pad, all_corners[i].bl.y, all_corners[i].bl.x, '+');
-      mvwaddch(win_meta->pad, all_corners[i].br.y, all_corners[i].br.x, '+'); }
+      mvwaddch(win_meta->pad.curses_win, all_corners[i].tl.y, all_corners[i].tl.x, '+');
+      mvwaddch(win_meta->pad.curses_win, all_corners[i].tr.y, all_corners[i].tr.x, '+');
+      mvwaddch(win_meta->pad.curses_win, all_corners[i].bl.y, all_corners[i].bl.x, '+');
+      mvwaddch(win_meta->pad.curses_win, all_corners[i].br.y, all_corners[i].br.x, '+'); }
     free(all_corners);
     uint16_t y;
     if (win_meta->pad_offset > 0)
       draw_vertical_scroll_hint(win_meta, win_meta->pad_offset, win_meta->pad_offset + 1, '<');
-    if (win_meta->pad_offset + win_meta->size.x < getmaxx(win_meta->pad) - 1)
-      for (y = 0; y < win_meta->size.y; y++)
-        draw_vertical_scroll_hint(win_meta, win_meta->pad_offset + win_meta->size.x - 1,
-                                  getmaxx(win_meta->pad) - (win_meta->pad_offset + win_meta->size.x), '>');
-    pnoutrefresh(win_meta->pad, 0, win_meta->pad_offset, 0, 0, win_meta->size.y, win_meta->size.x - 1); }
+    if (win_meta->pad_offset + win_meta->pad.size.x < getmaxx(win_meta->pad.curses_win) - 1)
+      for (y = 0; y < win_meta->pad.size.y; y++)
+        draw_vertical_scroll_hint(win_meta, win_meta->pad_offset + win_meta->pad.size.x - 1,
+                                  getmaxx(win_meta->pad.curses_win) - (win_meta->pad_offset
+                                                                       + win_meta->pad.size.x),
+                                  '>');
+    pnoutrefresh(win_meta->pad.curses_win, 0, win_meta->pad_offset, 0, 0, win_meta->pad.size.y,
+                 win_meta->pad.size.x - 1); }
   doupdate(); }
 
 extern void resize_active_window (struct WinMeta * win_meta, uint16_t height, uint16_t width) {
 // Grow or shrink currently active window. Correct its geometry and that of its followers.
-  if (0 != win_meta->active && width > 0 && height > 0 && height < win_meta->size.y) {
-    win_meta->active->size.y = height;
-    win_meta->active->size.x = width;
+  if (0 != win_meta->active && width > 0 && height > 0 && height < win_meta->pad.size.y) {
+    win_meta->active->frame.size.y = height;
+    win_meta->active->frame.size.x = width;
     update_windows(win_meta, win_meta->chain_start); } }
 
 extern void cycle_active_window (struct WinMeta * win_meta, char dir) {
@@ -290,5 +296,5 @@ extern void shift_active_window (struct WinMeta * win_meta, char dir) {
 
 extern void reset_pad_offset(struct WinMeta * win_meta, uint16_t new_offset) {
 // Apply new_offset to windows pad, if it proves to be sane.
-  if (new_offset >= 0 && new_offset + win_meta->size.x < getmaxx(win_meta->pad))
+  if (new_offset >= 0 && new_offset + win_meta->pad.size.x < getmaxx(win_meta->pad.curses_win))
     win_meta->pad_offset = new_offset; }

diff --git a/windows.h b/windows.h
index 7ea160a557d8f72f2212d0bbe88d075a9023458f..757386ade0746fee8c700a7b7d001e85f5c4d44e 100644 (file)
--- a/windows.h
+++ b/windows.h
@@ -2,21 +2,23 @@ struct yx_uint16 {
   uint16_t y;
   uint16_t x; };
 
+struct Frame {
+  WINDOW * curses_win;
+  struct yx_uint16 size; };
+
 struct WinMeta {
   WINDOW * screen;
-  WINDOW * pad;
   uint16_t pad_offset;
+  struct Frame pad;
   struct Win * chain_start;
   struct Win * chain_end;
-  struct Win * active;
-  struct yx_uint16 size; };
+  struct Win * active; };
 
 struct Win {
   struct Win * prev;
   struct Win * next;
   struct yx_uint16 start;
-  struct yx_uint16 size;
-  WINDOW * curses;
+  struct Frame frame;
   char * title;
   void (* draw) (struct Win *);
   void * data; };