home · contact · privacy
Enforced three empty lines between functions / large meaningful blocks.
[plomrogue] / src / windows.c
1 /* windows.c */
2
3 #include "windows.h"
4 #include <stdint.h>    /* for uint16_t, uint32_t */
5 #include <ncurses.h>   /* for LOTS of stuff */
6 #include <stdlib.h>    /* for malloc(), free() */
7 #include <string.h>    /* for strlen(), memcpy() */
8 #include "yx_uint16.h" /* for yx_uint16 coordinates */
9
10
11
12 /* Stores a window's border corners. This is a helper to draw_all_wins() (and
13  * filled by its helper draw_wins_borders()) which draws the horizontal and
14  * vertical lines of all windows' borders first and the corner characters of
15  * all windows only afterwards (so that corners are not overwritten by lines).
16  * This delay of corner drawing necessitates temporarily storing their
17  * coordinates (harvested during the previous border drawing activities) in a
18  * series of such Corners structs to be released at the end.
19  *
20  * TODO: Maybe replace this complicated method by dropping the harvesting of
21  * corners from draw_wins_borders() and instead collecting them in a second
22  * border drawing cycle that repeats some cycles but works in a much more
23  * straightforward way.
24  */
25 struct Corners
26 {
27     struct yx_uint16 tl;
28     struct yx_uint16 tr;
29     struct yx_uint16 bl;
30     struct yx_uint16 br;
31 };
32
33
34
35 /* Fit virtual screen's width to minimum width demanded by current windows'
36  * geometries.
37  */
38 static void refit_pad(struct WinMeta * wmeta);
39
40
41
42 /* Update geometry (sizes, positions) of window "w" and its successors in the
43  * window chain. For the positioning algorithm place_win() is used.
44  */
45 static void update_wins(struct WinMeta * wmeta, struct Win * w);
46 static void place_win(struct WinMeta * wmeta, struct Win * w);
47
48
49
50 /* Destroy window "w"'s ncurses window (and set w.Frame.curses_win to 0). */
51 static void destroy_win(struct Win * w);
52
53
54
55 /* Draw contents of all windows in window chain from window "w" onwards. */
56 static void draw_wins(struct Win * w);
57
58
59
60 /* draw_win_borders() Draws the vertical and horizontal borders of window "w"
61  * sans corners, and draws the top border line as the windows' title bar
62  * (highlighted if the window is described active by "active" being set).
63  * draw_wins_borders().
64  *
65  * draw_wins_borders() calls draw_win_borders() recursively on all windows from
66  * "w" on. It also fills "corners" with coordinates of each window's corners,
67  * iterating over its Corners structs via the "i" index incremented by 1 over
68  * each handled window. "w_active" is a pointer to the one window that
69  * draw_win_borders() is supposed to handle as the active window.
70  */
71 static void draw_win_borders(struct Win * w, char active);
72 static void draw_wins_borders(struct Win * w, struct Win * w_active,
73                               struct Corners * corners, uint16_t i);
74
75
76
77 static void refit_pad(struct WinMeta * wmeta)
78 {
79     /* Determine rightmost window column. */
80     uint16_t lastwincol = 0;
81     struct Win * w_p = wmeta->chain_start;
82     while (w_p != 0)
83     {
84         if (w_p->start.x + w_p->frame.size.x > lastwincol + 1)
85         {
86             lastwincol = w_p->start.x + w_p->frame.size.x - 1;
87         }
88         w_p = w_p->next;
89     }
90
91     /* Only resize the pad if the rightmost window column has changed. */
92     if (getmaxx(wmeta->pad.curses_win) != lastwincol)
93     {
94         wresize(wmeta->pad.curses_win,
95                 getmaxy(wmeta->pad.curses_win), lastwincol + 2);
96     }
97 }
98
99
100
101 static void update_wins (struct WinMeta * wmeta, struct Win * w)
102 {
103     if (0 != w->frame.curses_win)
104     {
105         destroy_win (w);
106     }
107     place_win(wmeta, w);
108     refit_pad(wmeta);
109     w->frame.curses_win = subpad(wmeta->pad.curses_win,
110                                  w->frame.size.y, w->frame.size.x,
111                                  w->start.y, w->start.x);
112     if (0 != w->next)
113     {
114         update_wins (wmeta, w->next);
115     }
116 }
117
118
119
120 static void place_win (struct WinMeta * wmeta, struct Win * w)
121 {
122     /* First window goes into the upper-left corner. */
123     w->start.x = 0;
124     w->start.y = 1;                             /* Leave space for title bar. */
125     if (0 != w->prev)
126     {
127
128         /* Non-first window fallbacks to: fit rightwards of rightmost border. */
129         struct Win * w_top = w->prev;
130         while (w_top->start.y != 1)
131         {
132             w_top = w_top->prev;
133         }
134         w->start.x = w_top->start.x + w_top->frame.size.x + 1;
135
136         /* Fit window below its predecessor if that one directly thrones over
137          * empty space wide and high enough.
138          */
139         uint16_t w_prev_maxy = w->prev->start.y
140                                + getmaxy(w->prev->frame.curses_win);
141         if (   w->frame.size.x <= w->prev->frame.size.x
142             && w->frame.size.y <  wmeta->pad.size.y - w_prev_maxy)
143         {
144             w->start.x = w->prev->start.x;
145             w->start.y = w_prev_maxy + 1;
146         }
147
148         /* Failing that, try to open a new sub column below the nearest
149          * predecessor window that thrones over enough empty space.
150          */
151         else
152         {
153             struct Win * w_up = w->prev;
154             struct Win * w_upup = w_up;
155             uint16_t widthdiff;
156             while (w_up != w_top)
157             {
158                 w_upup = w_up->prev;
159                 while (1)
160                 {
161                     if (w_up->start.y != w_upup->start.y)
162                     {
163                         break;
164                     }
165                     w_upup = w_upup->prev;
166                 }
167                 w_prev_maxy = w_upup->start.y
168                               + getmaxy(w_upup->frame.curses_win);
169                 widthdiff = (w_upup->start.x + w_upup->frame.size.x)
170                             - (w_up->start.x + w_up->frame.size.x);
171                 if (   w->frame.size.y < wmeta->pad.size.y - w_prev_maxy
172                     && w->frame.size.x < widthdiff)
173                 {
174                     w->start.x = w_up->start.x + w_up->frame.size.x + 1 ;
175                     w->start.y = w_prev_maxy + 1;
176                     break;
177                 }
178                 w_up = w_upup;
179             }
180         }
181     }
182 }
183
184
185
186 static void destroy_win (struct Win * w)
187 {
188     delwin(w->frame.curses_win);
189     w->frame.curses_win = 0;
190 }
191
192
193
194 static void draw_wins (struct Win * w)
195 {
196     w->draw(w);
197     if (0 != w->next)
198     {
199         draw_wins (w->next);
200     }
201 }
202
203
204
205 static void draw_win_borders(struct Win * w, char active)
206 {
207   /* Draw vertical and horizontal border lines. */
208   uint16_t y, x;
209   for (y = w->start.y; y <= w->start.y + w->frame.size.y; y++)
210   {
211     mvwaddch(wgetparent(w->frame.curses_win), y, w->start.x - 1, '|');
212     mvwaddch(wgetparent(w->frame.curses_win),
213              y, w->start.x + w->frame.size.x, '|');
214   }
215   for (x = w->start.x; x <= w->start.x + w->frame.size.x; x++)
216   {
217     mvwaddch(wgetparent(w->frame.curses_win), w->start.y - 1, x, '-');
218     mvwaddch(wgetparent(w->frame.curses_win),
219              w->start.y + w->frame.size.y, x, '-');
220   }
221
222   /* Draw as much as possible of the title into center of top border line. */
223   char min_title_length_visible = 3; /* minimum 1 char + 2 padding/decoration */
224   if (w->frame.size.x >= min_title_length_visible)
225   {
226     uint16_t title_offset = 0;
227     if (w->frame.size.x > strlen(w->title) + 2)
228     {
229       title_offset = (w->frame.size.x - (strlen(w->title) + 2)) / 2; /* + 2 */
230     }                                          /* is for padding/decoration */
231     uint16_t length_visible = strnlen(w->title, w->frame.size.x - 2);
232     char title[length_visible + 3];
233     char decoration = ' ';
234     if (1 == active)
235     {
236       decoration = '$';
237     }
238     memcpy(title + 1, w->title, length_visible);
239     title[0] = title[length_visible + 1] = decoration;
240     title[length_visible + 2] = '\0';
241     mvwaddstr(wgetparent(w->frame.curses_win),
242               w->start.y - 1, w->start.x + title_offset, title);
243   }
244 }
245
246
247
248 static void draw_wins_borders(struct Win * w, struct Win * w_active,
249                               struct Corners * corners, uint16_t i)
250 {
251     char active = 0;
252     if (w == w_active)
253     {
254         active = 1;
255     }
256     draw_win_borders(w, active);
257     corners[i].tl.y = w->start.y - 1;
258     corners[i].tl.x = w->start.x - 1;
259     corners[i].tr.y = w->start.y - 1;
260     corners[i].tr.x = w->start.x + w->frame.size.x;
261     corners[i].bl.y = w->start.y + w->frame.size.y;
262     corners[i].bl.x = w->start.x - 1;
263     corners[i].br.y = w->start.y + w->frame.size.y;
264     corners[i].br.x = w->start.x + w->frame.size.x;
265     if (0 != w->next)
266     {
267         draw_wins_borders (w->next, w_active, corners, i + 1);
268     }
269 }
270
271
272
273 extern struct WinMeta init_win_meta(WINDOW * screen)
274 {
275     struct WinMeta wmeta;
276     wmeta.screen         = screen;
277     wmeta.pad.size.y     = getmaxy(screen);
278     wmeta.pad.size.x     = getmaxx(screen);
279     wmeta.chain_start    = 0;
280     wmeta.chain_end      = 0;
281     wmeta.pad_offset     = 0;
282     wmeta.pad.curses_win = newpad(wmeta.pad.size.y, 1);
283     wmeta.active         = 0;
284     return wmeta;
285 }
286
287
288
289 extern struct Win init_win(struct WinMeta * wmeta, char * title,
290                            void * data, void * func)
291 {
292     struct Win w;
293     w.prev             = 0;
294     w.next             = 0;
295     w.frame.curses_win = 0;
296     w.title            = title;
297     w.frame.size.x     = 20;
298     w.frame.size.y     = wmeta->pad.size.y - 1;
299     w.data             = data;
300     w.draw             = func;
301     return w;
302 }
303
304
305
306 extern void append_win(struct WinMeta * wmeta, struct Win * w)
307 {
308     if (0 != wmeta->chain_start)
309     {
310         w->prev = wmeta->chain_end;
311         wmeta->chain_end->next = w;
312     }
313     else
314     {
315         wmeta->active = w;
316         wmeta->chain_start = w;
317     }
318     wmeta->chain_end = w;
319     update_wins(wmeta, w);
320 }
321
322
323
324 extern void suspend_win(struct WinMeta * wmeta, struct Win * w)
325 {
326     destroy_win(w);
327
328     if (wmeta->chain_start != w)
329     {
330         w->prev->next = w->next;
331     }
332     else
333     {
334         wmeta->chain_start = w->next;
335     }
336     char pad_refitted = 0;
337     if (wmeta->chain_end != w)
338     {
339         w->next->prev = w->prev;
340         if (wmeta->active == w)
341         {
342             wmeta->active = w->next;
343         }
344         update_wins(wmeta, w->next); /* Positioning of successor windows may  */
345         pad_refitted = 1;            /* be affected / need correction. Note   */
346     }                                /* that update_wins() already refits the */
347     else                             /* pad, voiding later need for that.     */
348     {
349         wmeta->chain_end = w->prev;
350         if (wmeta->active == w)
351         {
352             wmeta->active = w->prev;
353         }
354     }
355
356     w->prev = 0;
357     w->next = 0;
358
359     if (0 == pad_refitted)
360     {
361         refit_pad(wmeta);
362     }
363 }
364
365
366
367 extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset)
368 {
369     if (new_offset >= 0
370         && (new_offset < wmeta->pad_offset
371             || new_offset + wmeta->pad.size.x < getmaxx(wmeta->pad.curses_win)))
372     {
373         wmeta->pad_offset = new_offset;
374     }
375 }
376
377
378
379 extern void resize_active_win(struct WinMeta * wmeta, struct yx_uint16 size)
380 {
381     if (0 != wmeta->active
382         && size.x > 0 && size.y > 0
383         && size.y < wmeta->pad.size.y)
384     {
385         wmeta->active->frame.size = size;
386         update_wins(wmeta, wmeta->chain_start);   /* Positioning of successor */
387     }                                             /* windows may be affected. */
388 }
389
390
391
392 extern void cycle_active_win(struct WinMeta * wmeta, char dir)
393 {
394     if (0 != wmeta->active)
395     {
396         if ('n' == dir)
397         {
398             if (wmeta->active->next != 0)
399             {
400                 wmeta->active = wmeta->active->next;
401             }
402             else
403             {
404                 wmeta->active = wmeta->chain_start;
405             }
406         }
407         else
408         {
409             if (wmeta->active->prev != 0)
410             {
411                 wmeta->active = wmeta->active->prev;
412             }
413             else
414             {
415                 wmeta->active = wmeta->chain_end;
416             }
417         }
418     }
419 }
420
421
422
423 extern void shift_active_win(struct WinMeta * wmeta, char dir)
424 {
425     if (0 != wmeta->active                        /* No shifting with less    */
426         && wmeta->chain_start != wmeta->chain_end /* than one window visible. */
427         && (dir == 'f' || dir == 'b'))
428     {
429         struct Win * w_shift = wmeta->active, * w_p, * w_p_next;
430
431         /* Check if shifting will lead to wrapping. */
432         char wrap = 0;
433         if (   (dir == 'f' && w_shift == wmeta->chain_end)
434             || (dir == 'b' && w_shift == wmeta->chain_start))
435         {
436             wrap = 1;
437         }
438
439         /* Suspend all visible windows. */
440         uint16_t i, i_max;
441         for (i_max = 1, w_p = wmeta->chain_start;
442              w_p != wmeta->chain_end;
443              i_max++)
444         {
445             w_p = w_p->next;
446         }
447         struct Win ** wins = malloc(i_max * sizeof(struct Win *));
448         for (i = 0, w_p = wmeta->chain_start; i < i_max; i++)
449         {
450             w_p_next = w_p->next;
451             suspend_win(wmeta, w_p);
452             wins[i] = w_p;
453             w_p = w_p_next;
454         }
455
456         /* Re-append all previously visible windows in the new order. */
457         if (wrap)
458         {
459             if (dir == 'f')
460             {
461                 append_win(wmeta, w_shift);
462                 for (i = 0; i < i_max - 1; i++)
463                 {
464                     append_win(wmeta, wins[i]);
465                 }
466             }
467             else
468             {
469                 for (i = 1; i < i_max; i++)
470                 {
471                     append_win(wmeta, wins[i]);
472                 }
473                 append_win(wmeta, w_shift);
474             }
475         }
476         else
477         {
478             for (i = 0; i < i_max; i++)
479             {
480                 if (   (dir == 'f' && w_shift == wins[i])
481                     || (dir == 'b' && w_shift == wins[i+1]))
482                 {
483                     append_win(wmeta, wins[i+1]);
484                     append_win(wmeta, wins[i]);
485                     i++;
486                 }
487                 else
488                 {
489                     append_win(wmeta, wins[i]);
490                 }
491             }
492         }
493         free(wins);
494
495         wmeta->active = w_shift;      /* TODO: Is this necessary? If so, why? */
496     }
497 }
498
499
500
501 extern void draw_all_wins(struct WinMeta * wmeta)
502 {
503     /* Empty everything before filling it a-new. */
504     erase();
505     wnoutrefresh(wmeta->screen);
506     werase(wmeta->pad.curses_win);
507     if (wmeta->chain_start)
508     {
509
510         /* Only draw the windows' *contents* first. */
511         draw_wins (wmeta->chain_start);
512
513         /* Draw windows' borders. Lines first, then line crossings / corners. */
514         uint16_t n_wins = 1, i;
515         struct Win * win_p = wmeta->chain_start;
516         while (0 != win_p->next)
517         {
518             win_p = win_p->next;
519             n_wins++;
520         }
521         struct Corners * all_corners = malloc(sizeof(struct Corners) * n_wins);
522         draw_wins_borders (wmeta->chain_start, wmeta->active, all_corners, 0);
523         for (i = 0; i < n_wins; i++)
524         {
525             mvwaddch(wmeta->pad.curses_win,
526                      all_corners[i].tl.y, all_corners[i].tl.x, '+');
527             mvwaddch(wmeta->pad.curses_win,
528                      all_corners[i].tr.y, all_corners[i].tr.x, '+');
529             mvwaddch(wmeta->pad.curses_win,
530                      all_corners[i].bl.y, all_corners[i].bl.x, '+');
531             mvwaddch(wmeta->pad.curses_win,
532                      all_corners[i].br.y, all_corners[i].br.x, '+');
533         }
534         free(all_corners);
535
536         /* Draw virtual screen scroll hints. */
537         if (wmeta->pad_offset > 0)
538         {
539             draw_scroll_hint(&wmeta->pad,
540                              wmeta->pad_offset, wmeta->pad_offset + 1, '<');
541         }
542         if (wmeta->pad_offset + wmeta->pad.size.x
543             < getmaxx(wmeta->pad.curses_win) - 1)
544         {
545             draw_scroll_hint(&wmeta->pad,
546                              wmeta->pad_offset + wmeta->pad.size.x - 1,
547                              getmaxx(wmeta->pad.curses_win)
548                              - (wmeta->pad_offset + wmeta->pad.size.x), '>');
549         }
550
551         /* Write virtual screen segment to be shown on physical screen into */
552         /* ncurses screen buffer. */
553         pnoutrefresh(wmeta->pad.curses_win, 0, wmeta->pad_offset, 0, 0,
554                      wmeta->pad.size.y, wmeta->pad.size.x-1);
555     }
556
557     /* Only at the end write accumulated changes to the physical screen. */
558     doupdate();
559 }
560
561
562
563 extern void draw_scroll_hint(struct Frame * frame, uint16_t pos, uint32_t dist,
564                              char dir)
565 {
566     /* Decide on alignment (vertical/horizontal?), thereby scroll hint text. */
567     char * more = "more";
568     char * unit_cols = "columns";
569     char * unit_rows = "lines";
570     uint16_t dsc_space = frame->size.x;
571     char * unit = unit_rows;
572     if ('<' == dir || '>' == dir)
573     {
574         dsc_space = frame->size.y;
575         unit = unit_cols;
576     }
577     char * scrolldsc = malloc((4 * sizeof(char)) + strlen(more) + strlen(unit)
578                               + 10);  /* 10 = uint32 max strlen */
579     sprintf(scrolldsc, " %d %s %s ", dist, more, unit);
580
581     /* Decide on offset of the description text inside the scroll hint line. */
582     char offset = 1, q;
583     if (dsc_space > strlen(scrolldsc) + 1)
584     {
585         offset = (dsc_space - strlen(scrolldsc)) / 2;
586     }
587
588     /* Draw scroll hint line as dir symbols bracketing description text. */
589     chtype symbol;
590     for (q = 0; q < dsc_space; q++)
591     {
592         if (q >= offset && q < strlen(scrolldsc) + offset)
593         {
594             symbol = scrolldsc[q - offset] | A_REVERSE;
595         }
596         else
597         {
598             symbol = dir | A_REVERSE;
599         }
600         if ('<' == dir || '>' == dir)
601         {
602             mvwaddch(frame->curses_win, q, pos, symbol);
603         }
604         else
605         {
606             mvwaddch(frame->curses_win, pos, q, symbol);
607         }
608     }
609
610     free(scrolldsc);
611 }