home · contact · privacy
projects / plomrogue / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Client: Renamed some world members, commented world struct.
[plomrogue] / src / client / windows.c
diff --git a/src/client/windows.c b/src/client/windows.c
index 6bde9ef1ce2d5431e70bdabdb1680dd73038b320..e5c691d5c1e4305197487bb40ed871e17f29f666 100644 (file)
--- a/src/client/windows.c
+++ b/src/client/windows.c
@@ -31,7 +31,7 @@
 
 
 
-/* Get position of id "c" in world.windb.order or return Win before/after (or
+/* Get position of id "c" in world.winDB.order or return Win before/after (or
  * NULL if there is no window before/after).
  */
 static uint8_t get_pos_in_order(char c);
@@ -56,7 +56,7 @@ static void * get_drawfunc_by_char(char c);
 /* Write "win"'s size back to .target_(height/width) as per .target_*_type. */
 static void set_win_target_size(struct Win * win);
 
-/* Iterate over chars of world.windb.ids array / string. Restart after \0.*/
+/* Iterate over chars of world.winDB.ids array / string. Restart after \0.*/
 static char get_next_win_id();
 
 /* Make .v_screen just wide enough to contain all visible windows. */
@@ -100,15 +100,15 @@ static void draw_wins(struct Win * w);
 static void append_win(struct Win * w);
 static void suspend_win(struct Win * w);
 
-/* Copy Win content pointed to by "win" into appendend world.windb.wins area. */
-static void add_win_to_windb(struct Win * win);
+/* Copy Win content pointed to by "win" into appendend world.winDB.wins area. */
+static void add_win_to_winDB(struct Win * win);
 
 
 
 static uint8_t get_pos_in_order(char c)
 {
     uint8_t i;
-    for (i = 0; c != world.windb.order[i]; i++);
+    for (i = 0; c != world.winDB.order[i]; i++);
     return i;
 }
 
@@ -116,7 +116,7 @@ static uint8_t get_pos_in_order(char c)
 
 static struct Win * get_win_after(char c)
 {
-    return get_win_by_id(world.windb.order[get_pos_in_order(c) + 1]);
+    return get_win_by_id(world.winDB.order[get_pos_in_order(c) + 1]);
 }
 
 
@@ -126,7 +126,7 @@ static struct Win * get_win_before(char c)
     uint8_t i = get_pos_in_order(c);
     if (i > 0)
     {
-        return get_win_by_id(world.windb.order[i - 1]);
+        return get_win_by_id(world.winDB.order[i - 1]);
     }
     return NULL;
 }
@@ -136,26 +136,26 @@ static struct Win * get_win_before(char c)
 static void init_win_size_from_winconf_and_v_screen_size(char id)
 {
     struct Win * w = get_win_by_id(id);
-    w->frame_size.y  = world.windb.v_screen_size.y - 1;
+    w->frame_size.y  = world.winDB.v_screen_size.y - 1;
     if      (   0 < w->target_height
-             && w->target_height <= world.windb.v_screen_size.y - 1)
+             && w->target_height <= world.winDB.v_screen_size.y - 1)
     {
         w->frame_size.y = w->target_height;
     }
     else if (   0 > w->target_height
-             && world.windb.v_screen_size.y + (w->target_height - 1) > 0)
+             && world.winDB.v_screen_size.y + (w->target_height - 1) > 0)
     {
-        w->frame_size.y = world.windb.v_screen_size.y + (w->target_height - 1);
+        w->frame_size.y = world.winDB.v_screen_size.y + (w->target_height - 1);
     }
-    w->frame_size.x  = world.windb.v_screen_size.x;
+    w->frame_size.x  = world.winDB.v_screen_size.x;
     if      (0 < w->target_width)
     {
         w->frame_size.x = w->target_width;
     }
     else if (   0 > w->target_width
-             && world.windb.v_screen_size.x + w->target_width > 0)
+             && world.winDB.v_screen_size.x + w->target_width > 0)
     {
-        w->frame_size.x = world.windb.v_screen_size.x + w->target_width;
+        w->frame_size.x = world.winDB.v_screen_size.x + w->target_width;
     }
 }
 
@@ -197,7 +197,7 @@ static void set_win_target_size(struct Win * wcp)
     }
     else if (1 == wcp->target_height_type)
     {
-        wcp->target_height = wcp->frame_size.y - world.windb.v_screen_size.y +1;
+        wcp->target_height = wcp->frame_size.y - world.winDB.v_screen_size.y +1;
     }
     if      (0 == wcp->target_width_type)
     {
@@ -205,7 +205,7 @@ static void set_win_target_size(struct Win * wcp)
     }
     else if (1 == wcp->target_width_type)
     {
-        wcp->target_width = wcp->frame_size.x - world.windb.v_screen_size.x;
+        wcp->target_width = wcp->frame_size.x - world.winDB.v_screen_size.x;
     }
 }
 
@@ -214,7 +214,7 @@ static void set_win_target_size(struct Win * wcp)
 static char get_next_win_id()
 {
     static uint8_t i = 0;
-    char c = world.windb.ids[i];
+    char c = world.winDB.ids[i];
     if (0 == c)
     {
         i = 0;
@@ -230,7 +230,7 @@ static void refit_v_screen()
 {
     /* Determine rightmost window column. */
     uint32_t lastwcol = 0;
-    struct Win * wp = get_win_by_id(world.windb.order[0]);
+    struct Win * wp = get_win_by_id(world.winDB.order[0]);
     while (wp != 0)
     {
         if ((uint32_t) wp->start.x + (uint32_t) wp->frame_size.x > lastwcol + 1)
@@ -243,11 +243,11 @@ static void refit_v_screen()
     /* Only resize .v_screen if the rightmost window column has changed. */
     char * err_s = "refit_v_screen() grows virtual screen beyond legal sizes.";
     char * err_m = "refit_v_screen() triggers memory alloc error in wresize().";
-    if (getmaxx(world.windb.v_screen) + 1 != lastwcol)
+    if (getmaxx(world.winDB.v_screen) + 1 != lastwcol)
     {
         uint8_t t = (lastwcol + 2 > UINT16_MAX);
         exit_err(t, err_s);
-        t = wresize(world.windb.v_screen, getmaxy(world.windb.v_screen),
+        t = wresize(world.winDB.v_screen, getmaxy(world.winDB.v_screen),
                     lastwcol + 2);
         exit_err(t, err_m);
     }
@@ -287,7 +287,7 @@ static void place_win(struct Win * w)
         /* Fit w's top left to bottom left of its ->prev if enough space. */
         uint16_t w_prev_maxy = w_prev->start.y + w_prev->frame_size.y;
         if (   w->frame_size.x <= w_prev->frame_size.x
-            && w->frame_size.y <  world.windb.v_screen_size.y - w_prev_maxy)
+            && w->frame_size.y <  world.winDB.v_screen_size.y - w_prev_maxy)
         {
             w->start.x = w_prev->start.x;
             w->start.y = w_prev_maxy + 1;
@@ -310,7 +310,7 @@ static void place_win(struct Win * w)
             uint16_t w_thr_bottom = w_thr->start.y + w_thr->frame_size.y;
             uint16_t free_width =   (w_thr->start.x + w_thr->frame_size.x)
                                   - (w_test->start.x + w_test->frame_size.x);
-            if (   w->frame_size.y < world.windb.v_screen_size.y - w_thr_bottom
+            if (   w->frame_size.y < world.winDB.v_screen_size.y - w_thr_bottom
                 && w->frame_size.x < free_width)
             {
                 w->start.x = w_test->start.x + w_test->frame_size.x + 1;
@@ -364,10 +364,10 @@ static void scroll_hint(struct yx_uint16 fsize, char dir, uint16_t dist,
         }
         if ('<' == dir || '>' == dir)
         {
-            mvwaddch(world.windb.v_screen, start.y+q, start.x+draw_offset, c);
+            mvwaddch(world.winDB.v_screen, start.y+q, start.x+draw_offset, c);
             continue;
         }
-        mvwaddch(world.windb.v_screen, start.y + draw_offset, start.x + q, c);
+        mvwaddch(world.winDB.v_screen, start.y + draw_offset, start.x + q, c);
     }
 }
 
@@ -392,13 +392,13 @@ static void draw_win_borderlines(struct Win * w)
     uint16_t y, x;
     for (y = w->start.y; y <= w->start.y + w->frame_size.y; y++)
     {
-        mvwaddch(world.windb.v_screen, y, w->start.x - 1,              '|');
-        mvwaddch(world.windb.v_screen, y, w->start.x + w->frame_size.x, '|');
+        mvwaddch(world.winDB.v_screen, y, w->start.x - 1,              '|');
+        mvwaddch(world.winDB.v_screen, y, w->start.x + w->frame_size.x, '|');
     }
     for (x = w->start.x; x <= w->start.x + w->frame_size.x; x++)
     {
-        mvwaddch(world.windb.v_screen, w->start.y - 1,              x, '-');
-        mvwaddch(world.windb.v_screen, w->start.y + w->frame_size.y, x, '-');
+        mvwaddch(world.winDB.v_screen, w->start.y - 1,              x, '-');
+        mvwaddch(world.winDB.v_screen, w->start.y + w->frame_size.y, x, '-');
     }
 
     /* Draw as much as possible of the title into center of top border line. */
@@ -413,14 +413,14 @@ static void draw_win_borderlines(struct Win * w)
         uint16_t length_visible = strnlen(w->title, w->frame_size.x - 2);
         char title[length_visible + 3];
         char decoration = ' ';
-        if (w->id == world.windb.active)
+        if (w->id == world.winDB.active)
         {
             decoration = '$';
         }
         memcpy(title + 1, w->title, length_visible);
         title[0] = title[length_visible + 1] = decoration;
         title[length_visible + 2] = '\0';
-        mvwaddstr(world.windb.v_screen, w->start.y-1, w->start.x+offset, title);
+        mvwaddstr(world.winDB.v_screen, w->start.y-1, w->start.x+offset, title);
     }
 }
 
@@ -440,13 +440,13 @@ static void draw_wins_borderlines(struct Win * w)
 
 static void draw_wins_bordercorners(struct Win * w)
 {
-    mvwaddch(world.windb.v_screen,
+    mvwaddch(world.winDB.v_screen,
              w->start.y - 1, w->start.x - 1,              '+');
-    mvwaddch(world.windb.v_screen,
+    mvwaddch(world.winDB.v_screen,
              w->start.y - 1, w->start.x + w->frame_size.x, '+');
-    mvwaddch(world.windb.v_screen,
+    mvwaddch(world.winDB.v_screen,
              w->start.y + w->frame_size.y, w->start.x - 1, '+');
-    mvwaddch(world.windb.v_screen, w->start.y + w->frame_size.y,
+    mvwaddch(world.winDB.v_screen, w->start.y + w->frame_size.y,
              w->start.x + w->frame_size.x,                 '+');
     struct Win * next = get_win_after(w->id);
     if (next)
@@ -479,7 +479,7 @@ static void draw_wins(struct Win * w)
         for (x = offset_x; x < w->frame_size.x + offset_x && x < size_x; x++)
         {
             chtype ch = w->winmap[(y * w->winmap_size.x) + x];
-            mvwaddch(world.windb.v_screen, w->start.y + (y - offset_y),
+            mvwaddch(world.winDB.v_screen, w->start.y + (y - offset_y),
                                       w->start.x + (x - offset_x), ch);
         }
     }
@@ -514,14 +514,14 @@ static void draw_wins(struct Win * w)
 static void append_win(struct Win * w)
 {
     char * f_name = "append_win()";
-    uint8_t old_size = strlen(world.windb.order) + 1;
+    uint8_t old_size = strlen(world.winDB.order) + 1;
     char * new_order = try_malloc(old_size + 1, f_name);
-    memcpy(new_order, world.windb.order, old_size - 1);
+    memcpy(new_order, world.winDB.order, old_size - 1);
     new_order[old_size - 1] = w->id;
     new_order[old_size] = '\0';
-    free(world.windb.order);
-    world.windb.order = new_order;
-    world.windb.active = w->id;
+    free(world.winDB.order);
+    world.winDB.order = new_order;
+    world.winDB.active = w->id;
     update_wins(w);
 }
 
@@ -530,21 +530,21 @@ static void append_win(struct Win * w)
 static void suspend_win(struct Win * w)
 {
     char * f_name = "suspend_win()";
-    uint8_t new_size = strlen(world.windb.order);
+    uint8_t new_size = strlen(world.winDB.order);
     char * new_order = try_malloc(new_size, f_name);
     uint8_t i = get_pos_in_order(w->id);
-    char next_char = world.windb.order[i + 1];
-    world.windb.order[i] = '\0';
-    char * second_part = &world.windb.order[i + 1];
-    sprintf(new_order, "%s%s", world.windb.order, second_part);
-    free(world.windb.order);
-    world.windb.order = new_order;
-    world.windb.active = world.windb.order[i];
-    if (!world.windb.order[i] && 0 < i)
+    char next_char = world.winDB.order[i + 1];
+    world.winDB.order[i] = '\0';
+    char * second_part = &world.winDB.order[i + 1];
+    sprintf(new_order, "%s%s", world.winDB.order, second_part);
+    free(world.winDB.order);
+    world.winDB.order = new_order;
+    world.winDB.active = world.winDB.order[i];
+    if (!world.winDB.order[i] && 0 < i)
     {
-        world.windb.active = world.windb.order[i - 1];
+        world.winDB.active = world.winDB.order[i - 1];
     }
-    if (world.windb.order[i])
+    if (world.winDB.order[i])
     {
         update_wins(get_win_by_id(next_char)); /* Already calls               */
         return;                                /* refit_v_screen(), so leave. */
@@ -554,29 +554,29 @@ static void suspend_win(struct Win * w)
 
 
 
-static void add_win_to_windb(struct Win * win)
+static void add_win_to_winDB(struct Win * win)
 {
-    char * f_name = "add_win_to_windb()";
-    if (world.windb.ids)
+    char * f_name = "add_win_to_winDB()";
+    if (world.winDB.ids)
     {
-        uint8_t old_ids_size = strlen(world.windb.ids);
+        uint8_t old_ids_size = strlen(world.winDB.ids);
         char * new_ids = try_malloc(old_ids_size + 1 + 1, f_name);
-        sprintf(new_ids, "%s%c", world.windb.ids, win->id);
-        free(world.windb.ids);
-        world.windb.ids = new_ids;
+        sprintf(new_ids, "%s%c", world.winDB.ids, win->id);
+        free(world.winDB.ids);
+        world.winDB.ids = new_ids;
         uint16_t old_wins_size = old_ids_size * sizeof(struct Win);
         uint16_t new_wins_size = old_wins_size + sizeof(struct Win);
         struct Win * new_wins = try_malloc(new_wins_size, f_name);
-        memcpy(new_wins, world.windb.wins, old_wins_size);
+        memcpy(new_wins, world.winDB.wins, old_wins_size);
         new_wins[old_ids_size] = *win;
-        free(world.windb.wins);
-        world.windb.wins = new_wins;
+        free(world.winDB.wins);
+        world.winDB.wins = new_wins;
         return;
     }
-    world.windb.ids = try_malloc(2, f_name);
-    sprintf(world.windb.ids, "%c", win->id);
-    world.windb.wins = try_malloc(sizeof(struct Win), f_name);
-    world.windb.wins[0] = *win;
+    world.winDB.ids = try_malloc(2, f_name);
+    sprintf(world.winDB.ids, "%c", win->id);
+    world.winDB.wins = try_malloc(sizeof(struct Win), f_name);
+    world.winDB.wins[0] = *win;
 }
 
 
@@ -607,11 +607,11 @@ extern uint16_t center_offset(uint16_t position, uint16_t mapsize,
 extern struct Win * get_win_by_id(char id)
 {
     uint8_t i = 0;
-    while ('\0' != world.windb.ids[i])
+    while ('\0' != world.winDB.ids[i])
     {
-        if (id == world.windb.ids[i])
+        if (id == world.winDB.ids[i])
         {
-            return &world.windb.wins[i];
+            return &world.winDB.wins[i];
         }
         i++;
     }
@@ -644,7 +644,7 @@ extern uint8_t read_winconf_from_file(char * line, uint32_t linemax,
     win.target_width = atoi(line);
     win.target_width_type = (0 >= win.target_width);
     read_keybindings_from_file(line, linemax, file, &win.kb);
-    add_win_to_windb(&win);
+    add_win_to_winDB(&win);
     return 1;
 }
 
@@ -680,12 +680,12 @@ extern void read_order_wins_visible_active(char * line, uint32_t linemax,
     char win_order[linemax + 1];
     try_fgets(win_order, linemax + 1, file, f_name);
     win_order[strlen(win_order) - 1] = '\0';
-    world.windb.order = try_malloc(strlen(win_order) + 1, f_name);
-    sprintf(world.windb.order, "%s", win_order);
+    world.winDB.order = try_malloc(strlen(win_order) + 1, f_name);
+    sprintf(world.winDB.order, "%s", win_order);
     int char_or_eof = try_fgetc(file, f_name);
     char * err_eof = "fgetc() unexpectedly hitting EOF";
     exit_trouble(EOF == char_or_eof, f_name, err_eof);
-    world.windb.active = (uint8_t) char_or_eof;
+    world.winDB.active = (uint8_t) char_or_eof;
     exit_trouble(EOF == try_fgetc(file, f_name), f_name, err_eof);
     try_fgets(line, linemax + 1, file, f_name);
 }
@@ -695,9 +695,9 @@ extern void read_order_wins_visible_active(char * line, uint32_t linemax,
 extern void write_order_wins_visible_active(FILE * file, char * delim)
 {
     char * f_name = "write_order_wins_visible_active()";
-    try_fwrite(world.windb.order, strlen(world.windb.order), 1, file, f_name);
+    try_fwrite(world.winDB.order, strlen(world.winDB.order), 1, file, f_name);
     try_fputc('\n', file, f_name);
-    try_fputc(world.windb.active, file, f_name);
+    try_fputc(world.winDB.active, file, f_name);
     try_fputc('\n', file, f_name);
     try_fwrite(delim, strlen(delim), 1, file, f_name);
 }
@@ -709,13 +709,13 @@ extern void make_v_screen_and_init_win_sizes()
     char * f_name = "make_v_screen_and_init_win_sizes()";
     char * err_s = "creating an illegaly large virtual screen";
     char * err_m = "triggering a memory allocation error via newpad()";
-    uint32_t maxy_test = getmaxy(world.windb.t_screen);
-    uint32_t maxx_test = getmaxx(world.windb.t_screen);
+    uint32_t maxy_test = getmaxy(world.winDB.t_screen);
+    uint32_t maxx_test = getmaxx(world.winDB.t_screen);
     exit_trouble(maxy_test>UINT16_MAX || maxx_test>UINT16_MAX, f_name, err_s);
-    world.windb.v_screen_size.y = maxy_test;
-    world.windb.v_screen_size.x = maxx_test;
-    world.windb.v_screen = newpad(world.windb.v_screen_size.y, 1);
-    exit_trouble(NULL == world.windb.v_screen, f_name, err_m);
+    world.winDB.v_screen_size.y = maxy_test;
+    world.winDB.v_screen_size.x = maxx_test;
+    world.winDB.v_screen = newpad(world.winDB.v_screen_size.y, 1);
+    exit_trouble(NULL == world.winDB.v_screen, f_name, err_m);
     char id;
     while (0 != (id = get_next_win_id()))
     {
@@ -725,7 +725,7 @@ extern void make_v_screen_and_init_win_sizes()
 
 
 
-extern void free_windb()
+extern void free_winDB()
 {
     char id;
     while (0 != (id = get_next_win_id()))
@@ -734,10 +734,10 @@ extern void free_windb()
         free(wc->title);
         free_keybindings(wc->kb.kbs);
     }
-    free(world.windb.ids);  /* NULL this too since add_win_to_windb() checks  */
-    world.windb.ids = NULL; /* for it to detect its first post-DB-purge round.*/
-    free(world.windb.wins);
-    free(world.windb.order);
+    free(world.winDB.ids);  /* NULL this too since add_win_to_winDB() checks  */
+    world.winDB.ids = NULL; /* for it to detect its first post-DB-purge round.*/
+    free(world.winDB.wins);
+    free(world.winDB.order);
 }
 
 
@@ -753,15 +753,15 @@ extern void reset_windows_on_winch()
 {
     endwin();  /* "[S]tandard way" to recalibrate ncurses post SIGWINCH, says */
     refresh(); /* <http://invisible-island.net/ncurses/ncurses-intro.html>.   */
-    char tmp_order[strlen(world.windb.order) + 1];
-    sprintf(tmp_order, "%s", world.windb.order);
+    char tmp_order[strlen(world.winDB.order) + 1];
+    sprintf(tmp_order, "%s", world.winDB.order);
     uint8_t i;
-    char tmp_active = world.windb.active;
+    char tmp_active = world.winDB.active;
     for (i = 0; i < strlen(tmp_order); toggle_window(tmp_order[i]), i++);
-    delwin(world.windb.v_screen);
+    delwin(world.winDB.v_screen);
     make_v_screen_and_init_win_sizes();
     for (i = 0; i < strlen(tmp_order); toggle_window(tmp_order[i]), i++);
-    world.windb.active = tmp_active;
+    world.winDB.active = tmp_active;
 }
 
 
@@ -770,39 +770,39 @@ extern void draw_all_wins()
 {
     /* Empty everything before filling it a-new. */
     erase();
-    wnoutrefresh(world.windb.t_screen);
-    werase(world.windb.v_screen);
-    if (world.windb.active)
+    wnoutrefresh(world.winDB.t_screen);
+    werase(world.winDB.v_screen);
+    if (world.winDB.active)
     {
 
         /* Draw borders, wins. Order matters: corners should overwrite lines. */
-        draw_wins_borderlines(get_win_by_id(world.windb.order[0]));
-        draw_wins_bordercorners(get_win_by_id(world.windb.order[0]));
-        draw_wins(get_win_by_id(world.windb.order[0]));
+        draw_wins_borderlines(get_win_by_id(world.winDB.order[0]));
+        draw_wins_bordercorners(get_win_by_id(world.winDB.order[0]));
+        draw_wins(get_win_by_id(world.winDB.order[0]));
 
         /* Draw .v_screen scroll hints. */
         struct yx_uint16 start;
         start.y = 0;
-        start.x = world.windb.v_screen_offset;
+        start.x = world.winDB.v_screen_offset;
         char * cols_string = "columns";
-        if (world.windb.v_screen_offset > 0)
+        if (world.winDB.v_screen_offset > 0)
         {
-            scroll_hint(world.windb.v_screen_size, '<',
-                        world.windb.v_screen_offset + 1, cols_string, start);
+            scroll_hint(world.winDB.v_screen_size, '<',
+                        world.winDB.v_screen_offset + 1, cols_string, start);
         }
-        uint16_t size_x = getmaxx(world.windb.v_screen);
-        uint16_t right_edge =   world.windb.v_screen_offset
-                              + world.windb.v_screen_size.x;
+        uint16_t size_x = getmaxx(world.winDB.v_screen);
+        uint16_t right_edge =   world.winDB.v_screen_offset
+                              + world.winDB.v_screen_size.x;
         if (right_edge < size_x - 1)
         {
-            scroll_hint(world.windb.v_screen_size, '>',
+            scroll_hint(world.winDB.v_screen_size, '>',
                         size_x - right_edge, cols_string, start);
         }
 
         /* Put .v_screen segment to be shown on .t_screen to .t_screen buffer.*/
-        pnoutrefresh(world.windb.v_screen, 0, world.windb.v_screen_offset, 0, 0,
-                     world.windb.v_screen_size.y,
-                     world.windb.v_screen_size.x - 1);
+        pnoutrefresh(world.winDB.v_screen, 0, world.winDB.v_screen_offset, 0, 0,
+                     world.winDB.v_screen_size.y,
+                     world.winDB.v_screen_size.x - 1);
     }
 
     /* Only at the end write accumulated changes to .t_screen. */
@@ -814,7 +814,7 @@ extern void draw_all_wins()
 extern void toggle_window(char id)
 {
     struct Win * win = get_win_by_id(id);
-    if (NULL == strchr(world.windb.order, id))
+    if (NULL == strchr(world.winDB.order, id))
     {
         append_win(win);
         return;
@@ -826,11 +826,11 @@ extern void toggle_window(char id)
 
 extern void toggle_winconfig()
 {
-    if (!world.windb.active)
+    if (!world.winDB.active)
     {
         return;
     }
-    struct Win * w = get_win_by_id(world.windb.active);
+    struct Win * w = get_win_by_id(world.winDB.active);
     if      (0 == w->view)
     {
         w->view          = 1;
@@ -852,7 +852,7 @@ extern void toggle_winconfig()
 
 extern void toggle_win_size_type(char axis)
 {
-    struct Win * w = get_win_by_id(world.windb.active);
+    struct Win * w = get_win_by_id(world.winDB.active);
     if ('y' == axis)
     {
         w->target_height_type = (0 == w->target_height_type);
@@ -860,7 +860,7 @@ extern void toggle_win_size_type(char axis)
         return;
     }
     w->target_width_type = (   0 == w->target_width_type
-                            && w->frame_size.x <= world.windb.v_screen_size.x);
+                            && w->frame_size.x <= world.winDB.v_screen_size.x);
     set_win_target_size(w);
 }
 
@@ -868,9 +868,9 @@ extern void toggle_win_size_type(char axis)
 
 extern void resize_active_win(char change)
 {
-    if (world.windb.active)
+    if (world.winDB.active)
     {
-        struct Win * w = get_win_by_id(world.windb.active);
+        struct Win * w = get_win_by_id(world.winDB.active);
         if      (change == '-' && w->frame_size.y > 1)
         {
             w->frame_size.y--;
@@ -880,7 +880,7 @@ extern void resize_active_win(char change)
             w->frame_size.x--;
         }
         else if (   change == '+'
-                 && w->frame_size.y < world.windb.v_screen_size.y - 1)
+                 && w->frame_size.y < world.winDB.v_screen_size.y - 1)
         {
             w->frame_size.y++;
         }
@@ -889,7 +889,7 @@ extern void resize_active_win(char change)
             w->frame_size.x++;
         }
         if (   1 == w->target_width_type
-            && w->frame_size.x > world.windb.v_screen_size.x)
+            && w->frame_size.x > world.winDB.v_screen_size.x)
         {
             w->target_width_type = 0;
         }
@@ -902,41 +902,41 @@ extern void resize_active_win(char change)
 
 extern void shift_active_win(char dir)
 {
-    uint8_t len_order = strlen(world.windb.order);
+    uint8_t len_order = strlen(world.winDB.order);
     if (1 < len_order)
     {
         char tmp[len_order + 1];
         tmp[len_order] = '\0';
-        uint8_t pos = get_pos_in_order(world.windb.active);
+        uint8_t pos = get_pos_in_order(world.winDB.active);
         if ('f' == dir)
         {
             if (pos == len_order - 1)
             {
-                memcpy(tmp + 1, world.windb.order, len_order - 1);
-                tmp[0] = world.windb.active;
-                memcpy(world.windb.order, tmp, len_order + 1);
+                memcpy(tmp + 1, world.winDB.order, len_order - 1);
+                tmp[0] = world.winDB.active;
+                memcpy(world.winDB.order, tmp, len_order + 1);
             }
             else
             {
-                world.windb.order[pos] = world.windb.order[pos + 1];
-                world.windb.order[pos + 1] = world.windb.active;
+                world.winDB.order[pos] = world.winDB.order[pos + 1];
+                world.winDB.order[pos + 1] = world.winDB.active;
             }
         }
         else
         {
             if (pos == 0)
             {
-                memcpy(tmp, world.windb.order + 1, len_order - 1);
-                tmp[len_order - 1] = world.windb.active;
-                memcpy(world.windb.order, tmp, len_order + 1);
+                memcpy(tmp, world.winDB.order + 1, len_order - 1);
+                tmp[len_order - 1] = world.winDB.active;
+                memcpy(world.winDB.order, tmp, len_order + 1);
             }
             else
             {
-                world.windb.order[pos] = world.windb.order[pos - 1];
-                world.windb.order[pos - 1] = world.windb.active;
+                world.winDB.order[pos] = world.winDB.order[pos - 1];
+                world.winDB.order[pos - 1] = world.winDB.active;
             }
         }
-        update_wins(get_win_by_id(world.windb.order[0]));
+        update_wins(get_win_by_id(world.winDB.order[0]));
     }
 }
 
@@ -945,15 +945,15 @@ extern void shift_active_win(char dir)
 extern void scroll_v_screen(char dir)
 {
     if      (   '+' == dir
-             &&   world.windb.v_screen_offset + world.windb.v_screen_size.x + 1
-                < getmaxx(world.windb.v_screen))
+             &&   world.winDB.v_screen_offset + world.winDB.v_screen_size.x + 1
+                < getmaxx(world.winDB.v_screen))
     {
-        world.windb.v_screen_offset++;
+        world.winDB.v_screen_offset++;
     }
     else if (   '-' == dir
-             && world.windb.v_screen_offset > 0)
+             && world.winDB.v_screen_offset > 0)
     {
-        world.windb.v_screen_offset--;
+        world.winDB.v_screen_offset--;
     }
 }
 
@@ -961,24 +961,24 @@ extern void scroll_v_screen(char dir)
 
 extern void cycle_active_win(char dir)
 {
-    uint8_t len_order = strlen(world.windb.order);
+    uint8_t len_order = strlen(world.winDB.order);
     if (1 < len_order)
     {
-        uint8_t pos = get_pos_in_order(world.windb.active);
+        uint8_t pos = get_pos_in_order(world.winDB.active);
         if ('f' == dir)
         {
-            world.windb.active = world.windb.order[pos + 1];
-            if ('\0' == world.windb.active)
+            world.winDB.active = world.winDB.order[pos + 1];
+            if ('\0' == world.winDB.active)
             {
-                world.windb.active = world.windb.order[0];
+                world.winDB.active = world.winDB.order[0];
             }
             return;
         }
         if (pos > 0)
         {
-            world.windb.active = world.windb.order[pos - 1];
+            world.winDB.active = world.winDB.order[pos - 1];
             return;
         }
-        world.windb.active = world.windb.order[len_order - 1];
+        world.winDB.active = world.winDB.order[len_order - 1];
     }
 }
plom's roguelike engine