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