X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fwindows.c;h=ec176ed7ea2f11414a43c97feeedf4438881e754;hb=598eeab09f9c377e65f886b147e037e7972dadf9;hp=7e0ba723a3d3978850bac3ab99709de8c73ab064;hpb=a69666dfbbc1c27f0b29f4a591a69630c470df87;p=plomrogue diff --git a/src/windows.c b/src/windows.c index 7e0ba72..ec176ed 100644 --- a/src/windows.c +++ b/src/windows.c @@ -1,48 +1,30 @@ /* windows.c */ #include "windows.h" -#include /* for uint16_t, uint32_t */ -#include /* for LOTS of stuff */ +#include /* for uint8_t, uint16_t, uint32_t */ +#include /* for typedefs WINDOW, chtype, wresize(), getmaxx(), */ + /* getmaxy(), supbad(), delwin(), mvwaddch(), */ + /* mvwaddstr(), newpad(), wnoutrefres(), erase(), */ + /* werase(), pnoutrefresh(), doupdate() */ #include /* for malloc(), free() */ -#include /* for strlen(), memcpy() */ +#include /* for strlen(), strnlen(), memcpy() */ #include "yx_uint16.h" /* for yx_uint16 coordinates */ -/* 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. + * geometries. Returns 0 on success, 1 on (pad memory allocation) error. */ -static void refit_pad(struct WinMeta * wmeta); +static uint8_t refit_pad(struct WinMeta * wmeta); /* Update geometry (sizes, positions) of window "w" and its successors in the * window chain. For the positioning algorithm place_win() is used. + * + * update_wins() returns 0 on success, 1 on (pad/window memory alloc.) error. */ -static void update_wins(struct WinMeta * wmeta, struct Win * w); +static uint8_t update_wins(struct WinMeta * wmeta, struct Win * w); static void place_win(struct WinMeta * wmeta, struct Win * w); @@ -57,24 +39,32 @@ 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_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. * - * 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. + * 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); -static void refit_pad(struct WinMeta * wmeta) +/* Shift active window forwards / backwards in window chain. */ +static void shift_win_forward(struct WinMeta * wmeta); +static void shift_win_backward(struct WinMeta * wmeta); + + + +static uint8_t refit_pad(struct WinMeta * wmeta) { /* Determine rightmost window column. */ uint16_t lastwincol = 0; @@ -89,35 +79,46 @@ 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); + return (ERR == wresize(wmeta->padframe.curses_win, + getmaxy(wmeta->padframe.curses_win), + lastwincol + 2)); } + return 0; } -static void update_wins (struct WinMeta * wmeta, struct Win * w) +static uint8_t update_wins(struct WinMeta * wmeta, struct Win * w) { if (0 != w->frame.curses_win) { - destroy_win (w); + destroy_win(w); } place_win(wmeta, w); - refit_pad(wmeta); - w->frame.curses_win = subpad(wmeta->pad.curses_win, - w->frame.size.y, w->frame.size.x, - w->start.y, w->start.x); + if (0 != refit_pad(wmeta)) + { + return 1; + } + WINDOW * test = subpad(wmeta->padframe.curses_win, + w->frame.size.y, w->frame.size.x, + w->start.y, w->start.x); + if (NULL == test) + { + return 1; + } + w->frame.curses_win = test; if (0 != w->next) { - update_wins (wmeta, w->next); + return update_wins(wmeta, w->next); } + return 0; } -static void place_win (struct WinMeta * wmeta, struct Win * w) +static void place_win(struct WinMeta * wmeta, struct Win * w) { /* First window goes into the upper-left corner. */ w->start.x = 0; @@ -139,7 +140,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 +169,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 ; @@ -183,7 +184,7 @@ static void place_win (struct WinMeta * wmeta, struct Win * w) -static void destroy_win (struct Win * w) +static void destroy_win(struct Win * w) { delwin(w->frame.curses_win); w->frame.curses_win = 0; @@ -191,32 +192,30 @@ static void destroy_win (struct Win * w) -static void draw_wins (struct Win * w) +static void draw_wins(struct Win * w) { w->draw(w); if (0 != w->next) { - draw_wins (w->next); + draw_wins(w->next); } } -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,55 +237,149 @@ 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_borders (w->next, w_active, corners, i + 1); + draw_wins_borderlines(w->next, w_active, pad); } } -extern struct WinMeta init_win_meta(WINDOW * screen) +static void draw_wins_bordercorners(struct Win * w, WINDOW * pad) { - 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; - return wmeta; + 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_bordercorners(w->next, pad); + } +} + + + +static void shift_win_forward(struct WinMeta * wmeta) +{ + if (wmeta->active == wmeta->chain_end) + { + wmeta->chain_end = wmeta->active->prev; + wmeta->chain_end->next = 0; + wmeta->active->next = wmeta->chain_start; + wmeta->active->next->prev = wmeta->active; + wmeta->chain_start = wmeta->active; + wmeta->chain_start->prev = 0; + } + else + { + struct Win * old_prev = wmeta->active->prev; + struct Win * old_next = wmeta->active->next; + if (wmeta->chain_end == wmeta->active->next) + { + wmeta->chain_end = wmeta->active; + wmeta->active->next = 0; + } + else + { + wmeta->active->next = old_next->next; + wmeta->active->next->prev = wmeta->active; + } + if (wmeta->chain_start == wmeta->active) + { + wmeta->chain_start = old_next; + } + else + { + old_prev->next = old_next; + } + old_next->prev = old_prev; + old_next->next = wmeta->active; + wmeta->active->prev = old_next; + } +} + + + +static void shift_win_backward(struct WinMeta * wmeta) +{ + if (wmeta->active == wmeta->chain_start) + { + wmeta->chain_start = wmeta->active->next; + wmeta->chain_start->prev = 0; + wmeta->active->prev = wmeta->chain_end; + wmeta->active->prev->next = wmeta->active; + wmeta->chain_end = wmeta->active; + wmeta->chain_end->next = 0; + } + else + { + struct Win * old_prev = wmeta->active->prev; + struct Win * old_next = wmeta->active->next; + if (wmeta->chain_start == wmeta->active->prev) + { + wmeta->chain_start = wmeta->active; + wmeta->active->prev = 0; + } + else + { + wmeta->active->prev = old_prev->prev; + wmeta->active->prev->next = wmeta->active; + } + if (wmeta->chain_end == wmeta->active) + { + wmeta->chain_end = old_prev; + } + else + { + old_next->prev = old_prev; + } + old_prev->next = old_next; + old_prev->prev = wmeta->active; + wmeta->active->next = old_prev; + } +} + + + +extern uint8_t init_win_meta(WINDOW * screen, struct WinMeta * wmeta) +{ + 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; + WINDOW * test; + test = newpad(wmeta->padframe.size.y, 1); + if (NULL == test) + { + return 1; + } + wmeta->padframe.curses_win = test; + wmeta->active = 0; + return 0; } extern struct Win init_win(struct WinMeta * wmeta, char * title, + uint16_t height, uint16_t width, void * data, void * func) { struct Win w; @@ -294,16 +387,30 @@ 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; } -extern void append_win(struct WinMeta * wmeta, struct Win * w) +extern uint8_t append_win(struct WinMeta * wmeta, struct Win * w) { if (0 != wmeta->chain_start) { @@ -316,12 +423,12 @@ extern void append_win(struct WinMeta * wmeta, struct Win * w) wmeta->chain_start = w; } wmeta->chain_end = w; - update_wins(wmeta, w); + return update_wins(wmeta, w); } -extern void suspend_win(struct WinMeta * wmeta, struct Win * w) +extern uint8_t suspend_win(struct WinMeta * wmeta, struct Win * w) { destroy_win(w); @@ -341,10 +448,13 @@ extern void suspend_win(struct WinMeta * wmeta, struct Win * w) { wmeta->active = w->next; } - update_wins(wmeta, w->next); /* Positioning of successor windows may */ - pad_refitted = 1; /* be affected / need correction. Note */ - } /* that update_wins() already refits the */ - else /* pad, voiding later need for that. */ + if (0 != update_wins(wmeta, w->next)) /* Positioning of successor */ + { /* windows may be affected / */ + return 1; /* need correction. */ + } /* Note that update_wins() */ + pad_refitted = 1; /* already refits the pad, */ + } /* voiding later need for that. */ + else { wmeta->chain_end = w->prev; if (wmeta->active == w) @@ -358,8 +468,9 @@ extern void suspend_win(struct WinMeta * wmeta, struct Win * w) if (0 == pad_refitted) { - refit_pad(wmeta); + return refit_pad(wmeta); } + return 0; } @@ -368,7 +479,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; } @@ -376,17 +488,18 @@ extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset) -extern void resize_active_win(struct WinMeta * wmeta, struct yx_uint16 size) +extern uint8_t 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 */ - } /* windows may be affected. */ -} - + return update_wins(wmeta, wmeta->chain_start); /* Succeeding windows' */ + } /* positioning may be */ + return 0; /* affected. */ +} /* TODO: Why start at */ + /* chain_start then? */ extern void cycle_active_win(struct WinMeta * wmeta, char dir) @@ -420,11 +533,11 @@ extern void cycle_active_win(struct WinMeta * wmeta, char dir) -extern void shift_active_win(struct WinMeta * wmeta, char dir) +extern uint8_t shift_active_win_old(struct WinMeta * wmeta, char dir) { - if (0 != wmeta->active /* No shifting with less */ - && wmeta->chain_start != wmeta->chain_end /* than one window visible. */ - && (dir == 'f' || dir == 'b')) + if (0 != wmeta->active /* No shifting with less */ + && wmeta->chain_start != wmeta->chain_end /* than 2 windows visible. */ + && (dir == 'f' || dir == 'b')) /* and wrong dir char. */ { struct Win * w_shift = wmeta->active, * w_p, * w_p_next; @@ -445,6 +558,10 @@ extern void shift_active_win(struct WinMeta * wmeta, char dir) i_max++; } struct Win ** wins = malloc(i_max * sizeof(struct Win *)); + if (NULL == wins) + { + return 1; + } for (i = 0, w_p = wmeta->chain_start; i < i_max; i++) @@ -460,19 +577,31 @@ extern void shift_active_win(struct WinMeta * wmeta, char dir) { if (dir == 'f') { - append_win(wmeta, w_shift); + if (0 != append_win(wmeta, w_shift)) + { + return 1; + } for (i = 0; i < i_max - 1; i++) { - append_win(wmeta, wins[i]); + if (0 != append_win(wmeta, wins[i])) + { + return 1; + } } } else { for (i = 1; i < i_max; i++) { - append_win(wmeta, wins[i]); + if (0 != append_win(wmeta, wins[i])) + { + return 1; + } + } + if (0 != append_win(wmeta, w_shift)) + { + return 1; } - append_win(wmeta, w_shift); } } else @@ -482,13 +611,19 @@ extern void shift_active_win(struct WinMeta * wmeta, char dir) if ( (dir == 'f' && w_shift == wins[i]) || (dir == 'b' && w_shift == wins[i+1])) { - append_win(wmeta, wins[i+1]); - append_win(wmeta, wins[i]); + if ( 0 != append_win(wmeta, wins[i+1]) + || 0 != append_win(wmeta, wins[i])) + { + return 1; + } i++; } else { - append_win(wmeta, wins[i]); + if (0 != append_win(wmeta, wins[i])) + { + return 1; + } } } } @@ -496,6 +631,28 @@ extern void shift_active_win(struct WinMeta * wmeta, char dir) wmeta->active = w_shift; /* Otherwise lastly appended win is active. */ } + return 0; +} + + + +extern void shift_active_win(struct WinMeta * wmeta, char dir) +{ + if ( 0 == wmeta->active + || wmeta->chain_start == wmeta->chain_end + || (dir != 'f' && dir != 'b')) + { + return; + } + if ('f' == dir) + { + shift_win_forward(wmeta); + } + else + { + shift_win_backward(wmeta); + } + update_wins(wmeta, wmeta->chain_start); } @@ -505,55 +662,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. */ @@ -562,8 +700,8 @@ extern void draw_all_wins(struct WinMeta * wmeta) -extern void draw_scroll_hint(struct Frame * frame, uint16_t pos, uint32_t dist, - char dir) +extern uint8_t draw_scroll_hint(struct Frame * frame, uint16_t pos, + uint32_t dist, char dir) { /* Decide on alignment (vertical/horizontal?), thereby scroll hint text. */ char * more = "more"; @@ -578,6 +716,10 @@ extern void draw_scroll_hint(struct Frame * frame, uint16_t pos, uint32_t dist, } char * scrolldsc = malloc((4 * sizeof(char)) + strlen(more) + strlen(unit) + 10); /* 10 = uint32 max strlen */ + if (NULL == scrolldsc) + { + return 1; + } sprintf(scrolldsc, " %d %s %s ", dist, more, unit); /* Decide on offset of the description text inside the scroll hint line. */ @@ -610,4 +752,5 @@ extern void draw_scroll_hint(struct Frame * frame, uint16_t pos, uint32_t dist, } free(scrolldsc); + return 0; }