plomlompom.com Git - plomrogue/blob - src/draw_wins.c

   1 /* draw_wins.c */
   2
   3 #include "draw_wins.h"
   4 #include <stdlib.h>      /* for free() */
   5 #include <stdint.h>      /* for uint16_t */
   6 #include <string.h>      /* for strlen() */
   7 #include <ncurses.h>     /* for mvwaddch() */
   8 #include "windows.h"     /* for structs Win, Frame, for draw_scroll_hint() */
   9 #include "misc.h"        /* for center_offset(), try_malloc() */
  10 #include "keybindings.h" /* for struct KeyBinding, for get_name_to_keycode() */
  11 #include "map_objects.h" /* for structs MapObj, get_map_object_def(),
  12                           * get_player()
  13                           */
  14 #include "map.h"         /* for Map struct */
  15 #include "main.h"        /* for World struct */
  16 #include "rexit.h"       /* for err_exit() */
  17 #include "command_db.h"  /* for get_command_longdesc() */
  18 #include "wincontrol.h"  /* for WinConf struct, get_winconf_by_win() */
  19
  20
  21
  22 /* Write "text" into window "win" as far as possible. Start on row "start_y".
  23  * Break lines at newlines.
  24  */
  25 static void draw_with_linebreaks(struct Win * win, char * text,
  26                                  uint16_t start_y);
  27
  28 /* Write "line" into window "win" at line "y" as far as it fits into it; apply
  29  * ncurses attribute "attri" to all characters drawn; if "fill" is non-zero,
  30  * fill the entire line with empty characters ("attri" also applied on these).
  31  */
  32 static void draw_line(struct Win * win, uint16_t y, char * line, attr_t attri,
  33                       uint8_t fill);
  34
  35 /* Write "text" not starting from the top but from the bottom of "win". */
  36 static void draw_text_from_bottom(struct Win * win, char * text);
  37
  38 /* Draw onto "map" in "win" the objects in the chain at "start". */
  39 static void draw_map_objects(struct World * world, struct MapObj * start,
  40                              struct Map * map, struct Win * win);
  41
  42 /* Return keybinding list line via "kb_pp", iterate pointer pointed to by it. */
  43 static char * get_kb_line_and_iterate(struct World * world,
  44                                       struct KeyBinding ** kb_pp);
  45
  46 /* Draw horizontal scroll hints in "frame" at the end line or a start line of y
  47  * value "start" if the current "y" fits one of these lines and the number of
  48  * lines "n_owned" and the "offset" make it appropriate.
  49  *
  50  * Return 1 if a scroll hint was drawn, else 0.
  51  */
  52 static uint8_t scroll_hint_helper(struct World * world, uint16_t start,
  53                                   uint16_t y, uint16_t offset, uint16_t n_owned,
  54                                   struct Frame * frame, char * f_name);
  55
  56 /* Draw from line "start" on config view for keybindings defined at "kb". */
  57 static void draw_kb_view(struct World * world, struct Win * win,
  58                          char * f_name, struct KeyBiData * kb, uint8_t start);
  59
  60 /* Draw into window "win" from line "start" on a "title" followed by an empty
  61  * line followed by a list of all keybindings starting at kb_p.
  62  */
  63 static uint16_t draw_titled_keybinding_list(struct World * world,
  64                                             struct Win * win, uint16_t start,
  65                                             char * title,
  66                                             struct KeyBinding * kb_p);
  67
  68
  69
  70
  71
  72
  73 static void draw_with_linebreaks(struct Win * win, char * text,
  74                                  uint16_t start_y)
  75 {
  76     uint16_t x, y;
  77     char toggle;
  78     char fin = 0;
  79     int16_t z = -1;
  80     for (y = start_y; y < win->frame.size.y; y++)
  81     {
  82         if (0 == fin)
  83         {
  84             toggle = 0;
  85         }
  86         for (x = 0; x < win->frame.size.x; x++)
  87         {
  88             if (0 == toggle)
  89             {
  90                 z++;
  91                 if ('\n' == text[z])
  92                 {
  93                     toggle = 1;
  94                     continue;
  95                 }
  96                 else
  97                 {
  98                     mvwaddch(win->frame.curses_win, y, x, text[z]);
  99                 }
 100                 if ('\n' == text[z+1])
 101                 {
 102                     z++;
 103                     toggle = 1;
 104                 }
 105                 else if (0 == text[z+1])
 106                 {
 107                     toggle = 1;
 108                     fin = 1;
 109                 }
 110             }
 111         }
 112     }
 113 }
 114
 115
 116
 117 static void draw_line(struct Win * win, uint16_t y, char * line, attr_t attri,
 118                       uint8_t fill)
 119 {
 120     uint16_t x = 0;
 121     for (; x < win->frame.size.x && x < strlen(line); x++)
 122     {
 123         mvwaddch(win->frame.curses_win, y, x, line[x] | attri);
 124     }
 125     if (0 != fill)
 126     {
 127         for (; x < win->frame.size.x; x++)
 128         {
 129             mvwaddch(win->frame.curses_win, y, x, ' ' | attri);
 130         }
 131     }
 132 }
 133
 134
 135
 136 static void draw_text_from_bottom (struct Win * win, char * text)
 137 {
 138     /* Determine number of lines text would have in a window of win's width,
 139      * but infinite height. Treat \n and \0 as control chars for incrementing
 140      * y and stopping the loop. Make sure +they* don't count as cell space.
 141      */
 142     char toggle = 0;
 143     uint16_t x, y, offset;
 144     int16_t z = -1;
 145     for (y = 0; 0 == toggle; y++)
 146     {
 147         for (x = 0; x < win->frame.size.x; x++)
 148         {
 149             z++;
 150             if ('\n' == text[z])
 151             {
 152                 break;
 153             }
 154             if ('\n' == text[z+1])
 155             {
 156                 z++;
 157                 break;
 158             }
 159             else if (0 == text[z+1])
 160             {
 161                 toggle = 1;
 162                 break;
 163             }
 164         }
 165     }
 166     z = -1;
 167
 168     /* Depending on what's bigger, determine start point in window or text. */
 169     uint16_t start_y = 0;
 170     if (y < win->frame.size.y)
 171     {
 172         start_y = win->frame.size.y - y;
 173     }
 174     else if (y > win->frame.size.y)
 175     {
 176         offset = y - win->frame.size.y;
 177         for (y = 0; y < offset; y++)
 178         {
 179             for (x = 0; x < win->frame.size.x; x++)
 180             {
 181                 z++;
 182                 if ('\n' == text[z])
 183                 {
 184                     break;
 185                 }
 186                 if ('\n' == text[z+1])
 187                 {
 188                     z++;
 189                     break;
 190                 }
 191             }
 192         }
 193         text = text + (sizeof(char) * (z + 1));
 194     }
 195
 196     draw_with_linebreaks(win, text, start_y);
 197 }
 198
 199
 200
 201 static void draw_map_objects(struct World * world, struct MapObj * start,
 202                              struct Map * map, struct Win * win)
 203 {
 204     struct MapObj * o;
 205     struct MapObjDef * d;
 206     char c;
 207     uint8_t i;
 208     for (i = 0; i < 2; i++)
 209     {
 210         for (o = start; o != 0; o = o->next)
 211         {
 212             if (   (   (0 == i && 0 == o->lifepoints)      /* Draw in-animate */
 213                     || (1 == i && 0 < o->lifepoints))      /* objects first.  */
 214                 && o->pos.y >= map->offset.y
 215                 && o->pos.y <  map->offset.y + win->frame.size.y
 216                 && o->pos.x >= map->offset.x
 217                 && o->pos.x <  map->offset.x + win->frame.size.x)
 218             {
 219                 d = get_map_object_def(world, o->type);
 220                 c = d->char_on_map;
 221                 mvwaddch(win->frame.curses_win,
 222                          o->pos.y - map->offset.y, o->pos.x - map->offset.x, c);
 223             }
 224         }
 225     }
 226 }
 227
 228
 229
 230 static char * get_kb_line_and_iterate(struct World * world,
 231                                       struct KeyBinding ** kb_pp)
 232 {
 233     char * f_name = "get_kb_line_and_iterate()";
 234     struct KeyBinding * kb_p = * kb_pp;
 235     char * keyname = get_name_to_keycode(world, kb_p->key);
 236     char * cmd_dsc = get_command_longdsc(world, kb_p->name);
 237     uint16_t size = 9 + 1 + strlen(cmd_dsc) + 1;
 238     char * line = try_malloc(size, world, f_name);
 239     sprintf(line, "%-9s %s", keyname, cmd_dsc);
 240     free(keyname);
 241     * kb_pp = kb_p->next;
 242     return line;
 243 }
 244
 245
 246
 247 static uint8_t scroll_hint_helper(struct World * world, uint16_t start,
 248                                   uint16_t y, uint16_t offset, uint16_t n_owned,
 249                                   struct Frame * frame, char * f_name)
 250 {
 251     uint8_t ret = 0;
 252     char * err_hint = trouble_msg(world, f_name, "draw_scroll_hint()");
 253     if (start == y && offset > 0)
 254     {
 255         uint8_t test = draw_scroll_hint(frame, y, offset + 1, '^');
 256         exit_err(test, world, err_hint);
 257         ret = 1;
 258     }
 259     else if (   frame->size.y == y + 1
 260              && n_owned > frame->size.y + offset - 1 - start)
 261     {
 262         uint8_t pos = n_owned - (offset + frame->size.y) + 2 + start;
 263         uint8_t test = draw_scroll_hint(frame, y, pos, 'v');
 264         exit_err(test, world, err_hint);
 265         ret = 1;
 266     }
 267     free(err_hint);
 268     return ret;
 269 }
 270
 271
 272
 273 static void draw_kb_view(struct World * world, struct Win * win,
 274                          char * f_name, struct KeyBiData * kb, uint8_t start)
 275 {
 276     if (0 == kb->kbs)
 277     {
 278         draw_line(win, start, "(none)", 0, 0);
 279         return;
 280     }
 281     uint16_t kb_max = get_n_of_keybs(kb->kbs) - 1;
 282     uint16_t offset;
 283     offset = center_offset(kb->select, kb_max, win->frame.size.y - 1 - start);
 284     struct KeyBinding * kb_p = get_keyb_of_n(kb->kbs, offset + (offset > 0));
 285     uint16_t y;
 286     for (y = start; 0 != kb_p && y < win->frame.size.y; y++)
 287     {
 288         if (scroll_hint_helper(world, start, y, offset, kb_max, &win->frame,
 289                                f_name))
 290         {
 291             continue;
 292         }
 293         attr_t attri = 0;
 294         if (y - start == kb->select - offset)
 295         {
 296             attri = A_REVERSE;
 297             if (1 == kb->edit)
 298             {
 299                 attri = attri | A_BLINK;
 300             }
 301         }
 302         char * kb_line = get_kb_line_and_iterate(world, &kb_p);
 303         draw_line(win, y, kb_line, attri, 1);
 304
 305         free(kb_line);
 306     }
 307 }
 308
 309
 310
 311 static uint16_t draw_titled_keybinding_list(struct World * world,
 312                                             struct Win * win, uint16_t start,
 313                                             char * title,
 314                                             struct KeyBinding * kb_p)
 315 {
 316     uint16_t x, y;
 317     uint16_t i = 0;
 318     uint8_t state = 0;
 319     for (y = start; y < win->frame.size.y && (0 == state || 0 != kb_p); y++)
 320     {
 321         if (0 == state)
 322         {
 323             for (x = 0; x < win->frame.size.x; x++)
 324             {
 325                 if (i == strlen(title))
 326                 {
 327                     y++;
 328                     state = 1 + (0 == kb_p);
 329                     i = 0;
 330                     break;
 331                 }
 332                 mvwaddch(win->frame.curses_win, y, x, title[i]);
 333                 i++;
 334             }
 335             continue;
 336         }
 337         char * kb_line = get_kb_line_and_iterate(world, &kb_p);
 338         draw_line(win, y, kb_line, 0, 0);
 339         free(kb_line);
 340     }
 341     if (2 == state)
 342     {
 343         draw_line(win, y, "(none)", 0, 0);
 344         y++;
 345     }
 346     return y;
 347 }
 348
 349
 350
 351 extern void draw_win_log(struct Win * win)
 352 {
 353     struct World * world = (struct World *) win->data;
 354     draw_text_from_bottom(win, world->log);
 355 }
 356
 357
 358
 359 extern void draw_win_map(struct Win * win)
 360 {
 361     struct World * world = (struct World *) win->data;
 362     struct Map * map = world->map;
 363     char * cells = map->cells;
 364     uint16_t width_map_av  = map->size.x  - map->offset.x;
 365     uint16_t height_map_av = map->size.y - map->offset.y;
 366     uint16_t x, y, z;
 367     for (y = 0; y < win->frame.size.y; y++)
 368     {
 369         z = map->offset.x + (map->offset.y + y) * (map->size.x);
 370         for (x = 0; x < win->frame.size.x; x++)
 371         {
 372             if (y < height_map_av && x < width_map_av)
 373             {
 374                 mvwaddch(win->frame.curses_win, y, x, cells[z]);
 375                 z++;
 376             }
 377         }
 378     }
 379     draw_map_objects(world, world->map_objs, map, win);
 380 }
 381
 382
 383
 384 extern void draw_win_info(struct Win * win)
 385 {
 386     struct World * world = (struct World *) win->data;
 387     char * dsc_turn      = "Turn: ";
 388     char * dsc_hitpoints = "\nHitpoints: ";
 389     char * dsc_score     = "\nScore: ";
 390     uint16_t maxl = strlen(dsc_turn) + strlen(dsc_hitpoints) + strlen(dsc_score)
 391                     + 10 + 5 + 10;       /* max strlens of numbers to be used */
 392     char text[maxl + 1];
 393     struct MapObj * player = get_player(world);
 394     sprintf(text, "%s%d%s%d%s%d",
 395             dsc_turn, world->turn,
 396             dsc_hitpoints, player->lifepoints,
 397             dsc_score, world->score);
 398     draw_with_linebreaks(win, text, 0);
 399 }
 400
 401
 402
 403 extern void draw_win_inventory(struct Win * win)
 404 {
 405     struct World * world = (struct World *) win->data;
 406     struct MapObj * player = get_player(world);
 407     if (NULL == player->owns)
 408     {
 409         mvwaddstr(win->frame.curses_win, 0, 0, "(empty)");
 410         return;
 411     }
 412     char * f_name = "draw_win_inventory()";
 413     struct MapObj * owned = player->owns;
 414     uint8_t n_owned;
 415     for (n_owned = 0; NULL != owned->next; owned = owned->next, n_owned++);
 416     uint8_t offset = center_offset(world->inventory_select, n_owned,
 417                                    win->frame.size.y - 1);
 418     uint8_t i;
 419     for (i = 0, owned = player->owns; i < offset + (offset > 0);
 420          i++, owned = owned->next);
 421     uint8_t y;
 422     for (y = 0; NULL != owned && y < win->frame.size.y; y++)
 423     {
 424         if (scroll_hint_helper(world, 0, y, offset, n_owned, &win->frame,
 425                                f_name))
 426         {
 427             continue;
 428         }
 429         attr_t attri = 0;
 430         if (y == world->inventory_select - offset)
 431         {
 432             attri = A_REVERSE;
 433         }
 434         struct MapObjDef * mod = get_map_object_def(world, owned->type);
 435         draw_line(win, y, mod->name, attri, 0);
 436         owned = owned->next;
 437     }
 438 }
 439
 440
 441
 442 extern void draw_win_available_keybindings(struct Win * win)
 443 {
 444     struct World * world = (struct World *) win->data;
 445     char * title = "Active window's keybindings:";
 446     struct KeyBinding * kb_p;
 447     struct WinConf * wc = get_winconf_by_win(world, world->wmeta->active);
 448     if     (0 == wc->view)
 449     {
 450         kb_p = wc->kb.kbs;
 451     }
 452     else if (1 == wc->view)
 453     {
 454         kb_p = world->kb_wingeom.kbs;
 455     }
 456     else if (2 == wc->view)
 457     {
 458         kb_p = world->kb_winkeys.kbs;
 459     }
 460     uint16_t offset = draw_titled_keybinding_list(world, win, 0, title, kb_p);
 461     draw_titled_keybinding_list(world, win, offset + 1, "Global keybindings:",
 462                                 world->kb_global.kbs);
 463 }
 464
 465
 466
 467 extern void draw_win_keybindings_global(struct Win * win)
 468 {
 469     char * f_name = "draw_win_keybindings_global()";
 470     struct World * world = (struct World *) win->data;
 471     draw_kb_view(world, win, f_name, &world->kb_global, 0);
 472 }
 473
 474
 475
 476 extern void draw_win_keybindings_winconf_geometry(struct Win * win)
 477 {
 478     char * f_name = "draw_win_keybindings_winconf_geometry()";
 479     struct World * world = (struct World *) win->data;
 480     draw_kb_view(world, win, f_name, &world->kb_wingeom, 0);
 481 }
 482
 483
 484
 485 extern void draw_win_keybindings_winconf_keybindings(struct Win * win)
 486 {
 487     char * f_name = "draw_win_keybindings_winconf_keybindings()";
 488     struct World * world = (struct World *) win->data;
 489     draw_kb_view(world, win, f_name, &world->kb_winkeys, 0);
 490 }
 491
 492
 493
 494 extern void draw_winconf_keybindings(struct Win * win)
 495 {
 496     char * f_name = "draw_winconf_keybindings()";
 497     struct World * world = (struct World *) win->data;
 498     struct WinConf * wc = get_winconf_by_win(world, win);
 499     char * title = "Window's keybindings:";
 500     uint8_t title_space = strlen(title) / win->frame.size.x + 2;
 501     mvwaddstr(win->frame.curses_win, 0, 0, title);
 502     draw_kb_view(world, win, f_name, &wc->kb, title_space);
 503 }
 504
 505
 506
 507 extern void draw_winconf_geometry(struct Win * win)
 508 {
 509     struct World * world = (struct World *) win->data;
 510     struct WinConf * wcp = get_winconf_by_win(world, win);
 511     char * title = "Window's geometry:\n";
 512     char * h_d   = "\nHeight to save: ";
 513     char * h_pos = " (width in cells)";
 514     char * h_neg = " (negative diff: cells to maximum width)";
 515     char * w_d   = "\n\nWidth to save: ";
 516     char * w_pos = " (height in cells)";
 517     char * w_neg = " (negative diff: cells to maximum height)";
 518     char * h_t = h_pos;
 519     char * w_t = w_pos;
 520     if      (1 == wcp->height_type)
 521     {
 522         h_t = h_neg;
 523     }
 524     if     (1 == wcp->width_type)
 525     {
 526         w_t = w_neg;
 527     }
 528     uint16_t maxl = strlen(title)
 529                     + strlen(h_t) + strlen(h_d) + 6
 530                     + strlen(w_t) + strlen(w_d) + 6 + 1;
 531     char text[maxl + 1];
 532     sprintf(text, "%s%s%d%s%s%d%s", title, h_d, wcp->height, h_t,
 533                                            w_d, wcp->width,  w_t);
 534     draw_with_linebreaks(win, text, 0);
 535 }