X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fwindows.c;h=ef7a30dfade86df3759e6e44c3c0181f90205ed8;hb=4d9b6ac142740aa337fc3e622902c9595c36f6d0;hp=861b737681b2b1b6c4ae5b92273e4523df7ae668;hpb=8ca457975bc2d07cb8dd5c36a0bd5314d9b9c93a;p=plomrogue

diff --git a/src/windows.c b/src/windows.c
index 861b737..ef7a30d 100644
--- a/src/windows.c
+++ b/src/windows.c
@@ -9,29 +9,6 @@
 
 
 
-/* Stores a window's border corners. This is a helper to draw_all_wins() (and
- * filled by its helper draw_wins_borders()) which draws the horizontal and
- * vertical lines of all windows' borders first and the corner characters of
- * all windows only afterwards (so that corners are not overwritten by lines).
- * This delay of corner drawing necessitates temporarily storing their
- * coordinates (harvested during the previous border drawing activities) in a
- * series of such Corners structs to be released at the end.
- *
- * TODO: Maybe replace this complicated method by dropping the harvesting of
- * corners from draw_wins_borders() and instead collecting them in a second
- * border drawing cycle that repeats some cycles but works in a much more
- * straightforward way.
- */
-struct Corners
-{
-    struct yx_uint16 tl;
-    struct yx_uint16 tr;
-    struct yx_uint16 bl;
-    struct yx_uint16 br;
-};
-
-
-
 /* Fit virtual screen's width to minimum width demanded by current windows'
  * geometries.
  */
@@ -57,20 +34,22 @@ static void draw_wins(struct Win * w);
 
 
 
-/* draw_win_borders() Draws the vertical and horizontal borders of window "w"
- * sans corners, and draws the top border line as the windows' title bar
- * (highlighted if the window is described active by "active" being set).
- * draw_wins_borders().
+/* draw_win_borderlines() draws the vertical and horizontal borders of window
+ * "w" sans corners into the virtual screen "pad", and draws the top border
+ * line as the windows' title bar (highlighted if the window is described
+ * active by "active" being set). draw_wins_borderlines().
  *
- * draw_wins_borders() calls draw_win_borders() recursively on all windows from
- * "w" on. It also fills "corners" with coordinates of each window's corners,
- * iterating over its Corners structs via the "i" index incremented by 1 over
- * each handled window. "w_active" is a pointer to the one window that
- * draw_win_borders() is supposed to handle as the active window.
+ * draw_wins_borderlines() calls draw_win_borderlines() recursively on all
+ * windows from "w" on. "w_active" is a pointer to the one window that
+ * draw_win_borderlines() is supposed to handle as the active window.
+ *
+ * Finally, draw_wins_bordercorners draws into "pad" the borders of window "w"
+ * and all its successors.
  */
-static void draw_win_borders(struct Win * w, char active);
-static void draw_wins_borders(struct Win * w, struct Win * w_active,
-                              struct Corners * corners, uint16_t i);
+static void draw_win_borderlines(struct Win * w, char active, WINDOW * pad);
+static void draw_wins_borderlines(struct Win * w, struct Win * w_active,
+                                  WINDOW * pad);
+static void draw_wins_bordercorners(struct Win * w, WINDOW * pad);
 
 
 
@@ -89,10 +68,10 @@ static void refit_pad(struct WinMeta * wmeta)
     }
 
     /* Only resize the pad if the rightmost window column has changed. */
-    if (getmaxx(wmeta->pad.curses_win) != lastwincol)
+    if (getmaxx(wmeta->padframe.curses_win) != lastwincol)
     {
-        wresize(wmeta->pad.curses_win,
-                getmaxy(wmeta->pad.curses_win), lastwincol + 2);
+        wresize(wmeta->padframe.curses_win,
+                getmaxy(wmeta->padframe.curses_win), lastwincol + 2);
     }
 }
 
@@ -106,7 +85,7 @@ static void update_wins (struct WinMeta * wmeta, struct Win * w)
     }
     place_win(wmeta, w);
     refit_pad(wmeta);
-    w->frame.curses_win = subpad(wmeta->pad.curses_win,
+    w->frame.curses_win = subpad(wmeta->padframe.curses_win,
                                  w->frame.size.y, w->frame.size.x,
                                  w->start.y, w->start.x);
     if (0 != w->next)
@@ -139,7 +118,7 @@ static void place_win (struct WinMeta * wmeta, struct Win * w)
         uint16_t w_prev_maxy = w->prev->start.y
                                + getmaxy(w->prev->frame.curses_win);
         if (   w->frame.size.x <= w->prev->frame.size.x
-            && w->frame.size.y <  wmeta->pad.size.y - w_prev_maxy)
+            && w->frame.size.y <  wmeta->padframe.size.y - w_prev_maxy)
         {
             w->start.x = w->prev->start.x;
             w->start.y = w_prev_maxy + 1;
@@ -168,7 +147,7 @@ static void place_win (struct WinMeta * wmeta, struct Win * w)
                               + getmaxy(w_upup->frame.curses_win);
                 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->pad.size.y - w_prev_maxy
+                if (   w->frame.size.y < wmeta->padframe.size.y - w_prev_maxy
                     && w->frame.size.x < widthdiff)
                 {
                     w->start.x = w_up->start.x + w_up->frame.size.x + 1 ;
@@ -202,21 +181,19 @@ static void draw_wins (struct Win * w)
 
 
 
-static void draw_win_borders(struct Win * w, char active)
+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++)
     {
-        mvwaddch(wgetparent(w->frame.curses_win), y, w->start.x - 1, '|');
-        mvwaddch(wgetparent(w->frame.curses_win),
-                 y, w->start.x + w->frame.size.x, '|');
+        mvwaddch(pad, y, w->start.x - 1,               '|');
+        mvwaddch(pad, y, w->start.x + w->frame.size.x, '|');
     }
     for (x = w->start.x; x <= w->start.x + w->frame.size.x; x++)
     {
-        mvwaddch(wgetparent(w->frame.curses_win), w->start.y - 1, x, '-');
-        mvwaddch(wgetparent(w->frame.curses_win),
-                 w->start.y + w->frame.size.y, x, '-');
+        mvwaddch(pad, w->start.y - 1,               x, '-');
+        mvwaddch(pad, w->start.y + w->frame.size.y, x, '-');
     }
 
     /* Draw as much as possible of the title into center of top border line. */
@@ -238,33 +215,39 @@ static void draw_win_borders(struct Win * w, char active)
         memcpy(title + 1, w->title, length_visible);
         title[0] = title[length_visible + 1] = decoration;
         title[length_visible + 2] = '\0';
-        mvwaddstr(wgetparent(w->frame.curses_win),
-                  w->start.y - 1, w->start.x + title_offset, title);
+        mvwaddstr(pad, w->start.y - 1, w->start.x + title_offset, title);
     }
 }
 
 
 
-static void draw_wins_borders(struct Win * w, struct Win * w_active,
-                              struct Corners * corners, uint16_t i)
+static void draw_wins_borderlines(struct Win * w, struct Win * w_active,
+                                  WINDOW * pad)
 {
     char active = 0;
     if (w == w_active)
     {
         active = 1;
     }
-    draw_win_borders(w, active);
-    corners[i].tl.y = w->start.y - 1;
-    corners[i].tl.x = w->start.x - 1;
-    corners[i].tr.y = w->start.y - 1;
-    corners[i].tr.x = w->start.x + w->frame.size.x;
-    corners[i].bl.y = w->start.y + w->frame.size.y;
-    corners[i].bl.x = w->start.x - 1;
-    corners[i].br.y = w->start.y + w->frame.size.y;
-    corners[i].br.x = w->start.x + w->frame.size.x;
+    draw_win_borderlines(w, active, pad);
+    if (0 != w->next)
+    {
+        draw_wins_borderlines (w->next, w_active, pad);
+    }
+}
+
+
+
+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, '+');
     if (0 != w->next)
     {
-        draw_wins_borders (w->next, w_active, corners, i + 1);
+        draw_wins_bordercorners(w->next, pad);
     }
 }
 
@@ -273,20 +256,21 @@ static void draw_wins_borders(struct Win * w, struct Win * w_active,
 extern struct WinMeta init_win_meta(WINDOW * screen)
 {
     struct WinMeta wmeta;
-    wmeta.screen         = screen;
-    wmeta.pad.size.y     = getmaxy(screen);
-    wmeta.pad.size.x     = getmaxx(screen);
-    wmeta.chain_start    = 0;
-    wmeta.chain_end      = 0;
-    wmeta.pad_offset     = 0;
-    wmeta.pad.curses_win = newpad(wmeta.pad.size.y, 1);
-    wmeta.active         = 0;
+    wmeta.screen              = screen;
+    wmeta.padframe.size.y     = getmaxy(screen);
+    wmeta.padframe.size.x     = getmaxx(screen);
+    wmeta.chain_start         = 0;
+    wmeta.chain_end           = 0;
+    wmeta.pad_offset          = 0;
+    wmeta.padframe.curses_win = newpad(wmeta.padframe.size.y, 1);
+    wmeta.active              = 0;
     return wmeta;
 }
 
 
 
 extern struct Win init_win(struct WinMeta * wmeta, char * title,
+                           uint16_t height, uint16_t width,
                            void * data, void * func)
 {
     struct Win w;
@@ -294,10 +278,24 @@ extern struct Win init_win(struct WinMeta * wmeta, char * title,
     w.next             = 0;
     w.frame.curses_win = 0;
     w.title            = title;
-    w.frame.size.x     = 20;
-    w.frame.size.y     = wmeta->pad.size.y - 1;
     w.data             = data;
     w.draw             = func;
+    if (width > 0)
+    {
+        w.frame.size.x = width;
+    }
+    else
+    {
+        w.frame.size.x = 1;
+    }
+    if (height > 0 && height <= wmeta->padframe.size.y - 1)
+    {
+        w.frame.size.y = height;
+    }
+    else
+    {
+        w.frame.size.y = wmeta->padframe.size.y - 1;
+    }
     return w;
 }
 
@@ -368,7 +366,8 @@ extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset)
 {
     if (new_offset >= 0
         && (new_offset < wmeta->pad_offset
-            || new_offset + wmeta->pad.size.x < getmaxx(wmeta->pad.curses_win)))
+            || new_offset + wmeta->padframe.size.x
+               < getmaxx(wmeta->padframe.curses_win)))
     {
         wmeta->pad_offset = new_offset;
     }
@@ -380,7 +379,7 @@ extern void resize_active_win(struct WinMeta * wmeta, struct yx_uint16 size)
 {
     if (0 != wmeta->active
         && size.x > 0 && size.y > 0
-        && size.y < wmeta->pad.size.y)
+        && size.y < wmeta->padframe.size.y)
     {
         wmeta->active->frame.size = size;
         update_wins(wmeta, wmeta->chain_start);   /* Positioning of successor */
@@ -505,55 +504,36 @@ extern void draw_all_wins(struct WinMeta * wmeta)
     /* Empty everything before filling it a-new. */
     erase();
     wnoutrefresh(wmeta->screen);
-    werase(wmeta->pad.curses_win);
+    werase(wmeta->padframe.curses_win);
     if (wmeta->chain_start)
     {
 
-        /* Only draw the windows' *contents* first. */
-        draw_wins (wmeta->chain_start);
-
-        /* Draw windows' borders. Lines first, then line crossings / corners. */
-        uint16_t n_wins = 1, i;
-        struct Win * win_p = wmeta->chain_start;
-        while (0 != win_p->next)
-        {
-            win_p = win_p->next;
-            n_wins++;
-        }
-        struct Corners * all_corners = malloc(sizeof(struct Corners) * n_wins);
-        draw_wins_borders(wmeta->chain_start, wmeta->active, all_corners, 0);
-        for (i = 0; i < n_wins; i++)
-        {
-            mvwaddch(wmeta->pad.curses_win,
-                     all_corners[i].tl.y, all_corners[i].tl.x, '+');
-            mvwaddch(wmeta->pad.curses_win,
-                     all_corners[i].tr.y, all_corners[i].tr.x, '+');
-            mvwaddch(wmeta->pad.curses_win,
-                     all_corners[i].bl.y, all_corners[i].bl.x, '+');
-            mvwaddch(wmeta->pad.curses_win,
-                     all_corners[i].br.y, all_corners[i].br.x, '+');
-        }
-        free(all_corners);
+        /* Draw windows' contents first, then their borders. */
+        draw_wins(wmeta->chain_start);
+        draw_wins_borderlines(wmeta->chain_start, wmeta->active,
+                              wmeta->padframe.curses_win);
+        draw_wins_bordercorners(wmeta->chain_start, wmeta->padframe.curses_win);
 
         /* Draw virtual screen scroll hints. */
         if (wmeta->pad_offset > 0)
         {
-            draw_scroll_hint(&wmeta->pad,
+            draw_scroll_hint(&wmeta->padframe,
                              wmeta->pad_offset, wmeta->pad_offset + 1, '<');
         }
-        if (wmeta->pad_offset + wmeta->pad.size.x
-            < getmaxx(wmeta->pad.curses_win) - 1)
+        if (wmeta->pad_offset + wmeta->padframe.size.x
+            < getmaxx(wmeta->padframe.curses_win) - 1)
         {
-            draw_scroll_hint(&wmeta->pad,
-                             wmeta->pad_offset + wmeta->pad.size.x - 1,
-                             getmaxx(wmeta->pad.curses_win)
-                             - (wmeta->pad_offset + wmeta->pad.size.x), '>');
+            draw_scroll_hint(&wmeta->padframe,
+                             wmeta->pad_offset + wmeta->padframe.size.x - 1,
+                             getmaxx(wmeta->padframe.curses_win)
+                             - (wmeta->pad_offset + wmeta->padframe.size.x),
+                             '>');
         }
 
         /* Write virtual screen segment to be shown on physical screen into */
         /* ncurses screen buffer. */
-        pnoutrefresh(wmeta->pad.curses_win, 0, wmeta->pad_offset, 0, 0,
-                     wmeta->pad.size.y, wmeta->pad.size.x-1);
+        pnoutrefresh(wmeta->padframe.curses_win, 0, wmeta->pad_offset, 0, 0,
+                     wmeta->padframe.size.y, wmeta->padframe.size.x-1);
     }
 
     /* Only at the end write accumulated changes to the physical screen. */