X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fwindows.c;h=5165179029e60eeec252cc6963b849bdbd7fdaca;hb=181e40411dc49b42aba7619992394fa0b595a47e;hp=ec176ed7ea2f11414a43c97feeedf4438881e754;hpb=598eeab09f9c377e65f886b147e037e7972dadf9;p=plomrogue diff --git a/src/windows.c b/src/windows.c index ec176ed..5165179 100644 --- a/src/windows.c +++ b/src/windows.c @@ -1,19 +1,20 @@ /* windows.c */ #include "windows.h" -#include /* for uint8_t, uint16_t, uint32_t */ +#include /* for uint8_t, uint16_t, uint32_t, UINT16_MAX */ #include /* for typedefs WINDOW, chtype, wresize(), getmaxx(), */ - /* getmaxy(), supbad(), delwin(), mvwaddch(), */ - /* mvwaddstr(), newpad(), wnoutrefres(), erase(), */ - /* werase(), pnoutrefresh(), doupdate() */ + /* getmaxy(), delwin(), mvwaddch(), mvwaddstr(), */ + /* newpad(), wnoutrefres(), erase(), werase(), */ + /* pnoutrefresh(), doupdate(), getmaxyx() */ #include /* for malloc(), free() */ #include /* for strlen(), strnlen(), memcpy() */ -#include "yx_uint16.h" /* for yx_uint16 coordinates */ +#include "yx_uint16.h" /* for struct yx_uint16 */ +#include "misc.h" /* for center_offset() */ /* Fit virtual screen's width to minimum width demanded by current windows' - * geometries. Returns 0 on success, 1 on (pad memory allocation) error. + * geometries. */ static uint8_t refit_pad(struct WinMeta * wmeta); @@ -21,34 +22,43 @@ 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 uint8_t update_wins(struct WinMeta * wmeta, struct Win * w); static void place_win(struct WinMeta * wmeta, struct Win * w); -/* Destroy window "w"'s ncurses window (and set w.Frame.curses_win to 0). */ -static void destroy_win(struct Win * w); +/* Draw scroll hint (a line saying that there are "dist" more elements of + * "unit" further into the direction symbolized by the "dir" char) into virtual + * screen pad, onto an appropriate edge of either a window or the screen; the + * left or right edge if "dir" is "<" or ">", or the upper or lower edge if it + * is "^" or "v". "start" should be either the start coordinate of a window's + * frame or .y=0, .x=wm->pad_offset if it describes the virtual screen pad. + * winscroll_hint() and padscroll_hint() are wrappers to simplify these uses. + */ +static void scroll_hint(struct WinMeta * wm, struct yx_uint16 fsize, char dir, + uint16_t dist, char * unit, struct yx_uint16 start); +static void winscroll_hint(struct WinMeta * wm, struct Win * w, char dir, + uint16_t dist); +static void padscroll_hint(struct WinMeta * wm, char dir, uint16_t dist); /* Draw contents of all windows in window chain from window "w" onwards. */ -static void draw_wins(struct Win * w); +static uint8_t draw_wins(struct WinMeta * wm, struct Win * w); /* 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(). + * active by "active" being == 1). * * 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. * - * Finally, draw_wins_bordercorners draws into "pad" the borders of window "w" + * Finally, draw_wins_bordercorners() draws into "pad" the borders of window "w" * and all its successors. */ static void draw_win_borderlines(struct Win * w, char active, WINDOW * pad); @@ -67,23 +77,25 @@ static void shift_win_backward(struct WinMeta * wmeta); static uint8_t refit_pad(struct WinMeta * wmeta) { /* Determine rightmost window column. */ - uint16_t lastwincol = 0; - struct Win * w_p = wmeta->chain_start; - while (w_p != 0) + uint32_t lastwcol = 0; + struct Win * wp = wmeta->chain_start; + while (wp != 0) { - if (w_p->start.x + w_p->frame.size.x > lastwincol + 1) + if ((uint32_t) wp->start.x + (uint32_t) wp->framesize.x > lastwcol + 1) { - lastwincol = w_p->start.x + w_p->frame.size.x - 1; + lastwcol = (uint32_t) wp->start.x + (uint32_t) wp->framesize.x - 1; } - w_p = w_p->next; + wp = wp->next; } /* Only resize the pad if the rightmost window column has changed. */ - if (getmaxx(wmeta->padframe.curses_win) != lastwincol) + if (getmaxx(wmeta->pad) + 1 != lastwcol) { - return (ERR == wresize(wmeta->padframe.curses_win, - getmaxy(wmeta->padframe.curses_win), - lastwincol + 2)); + if (lastwcol + 2 > UINT16_MAX) + { + return 2; + } + return (ERR == wresize(wmeta->pad, getmaxy(wmeta->pad), lastwcol + 2)); } return 0; } @@ -92,23 +104,12 @@ static uint8_t refit_pad(struct WinMeta * wmeta) static uint8_t update_wins(struct WinMeta * wmeta, struct Win * w) { - if (0 != w->frame.curses_win) - { - destroy_win(w); - } place_win(wmeta, w); - if (0 != refit_pad(wmeta)) + uint8_t test_refit = refit_pad(wmeta); + if (0 != test_refit) { - return 1; + return test_refit; } - 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) { return update_wins(wmeta, w->next); @@ -132,15 +133,14 @@ static void place_win(struct WinMeta * wmeta, struct Win * w) { w_top = w_top->prev; } - w->start.x = w_top->start.x + w_top->frame.size.x + 1; + w->start.x = w_top->start.x + w_top->framesize.x + 1; /* Fit window below its predecessor if that one directly thrones over * empty space wide and high enough. */ - 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->padframe.size.y - w_prev_maxy) + uint16_t w_prev_maxy = w->prev->start.y + w->prev->framesize.y; + if ( w->framesize.x <= w->prev->framesize.x + && w->framesize.y < wmeta->padsize.y - w_prev_maxy) { w->start.x = w->prev->start.x; w->start.y = w_prev_maxy + 1; @@ -165,14 +165,13 @@ static void place_win(struct WinMeta * wmeta, struct Win * w) } w_upup = w_upup->prev; } - w_prev_maxy = w_upup->start.y - + 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->padframe.size.y - w_prev_maxy - && w->frame.size.x < widthdiff) + w_prev_maxy = w_upup->start.y + w_upup->framesize.y; + widthdiff = (w_upup->start.x + w_upup->framesize.x) + - (w_up->start.x + w_up->framesize.x); + if ( w->framesize.y < wmeta->padsize.y - w_prev_maxy + && w->framesize.x < widthdiff) { - w->start.x = w_up->start.x + w_up->frame.size.x + 1 ; + w->start.x = w_up->start.x + w_up->framesize.x + 1 ; w->start.y = w_prev_maxy + 1; break; } @@ -184,21 +183,122 @@ static void place_win(struct WinMeta * wmeta, struct Win * w) -static void destroy_win(struct Win * w) +static void scroll_hint(struct WinMeta * wm, struct yx_uint16 fsize, char dir, + uint16_t dist, char * unit, struct yx_uint16 start) +{ + /* Decide on alignment (vertical/horizontal?), thereby hint text space. */ + char * more = "more"; + uint16_t dsc_space = fsize.x; + if ('<' == dir || '>' == dir) + { + dsc_space = fsize.y; + } /* vv-- 10 = max strlen for uint16_t */ + char scrolldsc[1 + strlen(more) + 1 + 10 + 1 + strlen(unit) + 1 + 1]; + sprintf(scrolldsc, " %d %s %s ", dist, more, unit); + + /* Decide on offset of the description text inside the scroll hint line. */ + uint16_t dsc_offset = 1; + if (dsc_space > strlen(scrolldsc) + 1) + { + dsc_offset = (dsc_space - strlen(scrolldsc)) / 2; + } + + /* Draw scroll hint line as dir symbols bracketing description text. */ + uint16_t draw_offset = 0; + if ('>' == dir) + { + draw_offset = fsize.x - 1; + } + else if ('v' == dir) + { + draw_offset = fsize.y - 1; + } + uint16_t q = 0; + for (; q < dsc_space; q++) + { + chtype symbol = dir | A_REVERSE; + if (q >= dsc_offset && q < strlen(scrolldsc) + dsc_offset) + { + symbol = scrolldsc[q - dsc_offset] | A_REVERSE; + } + if ('<' == dir || '>' == dir) + { + mvwaddch(wm->pad, start.y + q, start.x + draw_offset, symbol); + } + else + { + mvwaddch(wm->pad, start.y + draw_offset, start.x + q, symbol); + } + } +} + + +static void padscroll_hint(struct WinMeta * wm, char dir, uint16_t dist) { - delwin(w->frame.curses_win); - w->frame.curses_win = 0; + struct yx_uint16 start; + start.y = 0; + start.x = wm->pad_offset; + scroll_hint(wm, wm->padsize, dir, dist, "columns", start); } -static void draw_wins(struct Win * w) +static void winscroll_hint(struct WinMeta * wm, struct Win * w, char dir, + uint16_t dist) +{ + char * unit = "lines"; + if ('<' == dir || '>' == dir) + { + unit = "columns"; + } + struct yx_uint16 start = w->start; + scroll_hint(wm, w->framesize, dir, dist, unit, start); +} + + + +static uint8_t draw_wins(struct WinMeta * wm, struct Win * w) { w->draw(w); + uint16_t y, x, size_y, size_x; + size_y = w->winmapsize.y; + size_x = w->winmapsize.x; + uint16_t offset_y = center_offset(w->center.y, size_y, w->framesize.y); + uint16_t offset_x = center_offset(w->center.x, size_x, w->framesize.x); + for (y = offset_y; y < w->framesize.y + offset_y && y < size_y; y++) + { + for (x = offset_x; x < w->framesize.x + offset_x && x < size_x; x++) + { + chtype ch = w->winmap[(y * w->winmapsize.x) + x]; + mvwaddch(wm->pad, w->start.y + (y - offset_y), + w->start.x + (x - offset_x), ch); + } + } + free(w->winmap); + w->winmap = NULL; + w->winmapsize.y = 0; + w->winmapsize.x = 0; + if (offset_y > 0) + { + winscroll_hint(wm, w, '^', offset_y + 1); + } + if (size_y > offset_y + w->framesize.y) + { + winscroll_hint(wm, w, 'v', size_y - ((offset_y + w->framesize.y) - 1)); + } + if (offset_x > 0) + { + winscroll_hint(wm, w, '<', offset_x + 1); + } + if (size_x > offset_x + w->framesize.x) + { + winscroll_hint(wm, w, '>', size_x - ((offset_x + w->framesize.x) - 1)); + } if (0 != w->next) { - draw_wins(w->next); + return draw_wins(wm, w->next); } + return 0; } @@ -207,27 +307,27 @@ 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++) + for (y = w->start.y; y <= w->start.y + w->framesize.y; y++) { - mvwaddch(pad, y, w->start.x - 1, '|'); - mvwaddch(pad, y, w->start.x + w->frame.size.x, '|'); + mvwaddch(pad, y, w->start.x - 1, '|'); + mvwaddch(pad, y, w->start.x + w->framesize.x, '|'); } - for (x = w->start.x; x <= w->start.x + w->frame.size.x; x++) + for (x = w->start.x; x <= w->start.x + w->framesize.x; x++) { - mvwaddch(pad, w->start.y - 1, x, '-'); - mvwaddch(pad, w->start.y + w->frame.size.y, x, '-'); + mvwaddch(pad, w->start.y - 1, x, '-'); + mvwaddch(pad, w->start.y + w->framesize.y, x, '-'); } /* Draw as much as possible of the title into center of top border line. */ char min_title_length_visible = 3; /* min. 1 char + 2 padding/decoration */ - if (w->frame.size.x >= min_title_length_visible) + if (w->framesize.x >= min_title_length_visible) { uint16_t title_offset = 0; - if (w->frame.size.x > strlen(w->title) + 2) + if (w->framesize.x > strlen(w->title) + 2) { - title_offset = (w->frame.size.x - (strlen(w->title) + 2)) / 2; - } /* +2 is for padding/decoration */ - uint16_t length_visible = strnlen(w->title, w->frame.size.x - 2); + title_offset = (w->framesize.x - (strlen(w->title) + 2)) / 2; + } /* +2 is for padding/decoration */ + uint16_t length_visible = strnlen(w->title, w->framesize.x - 2); char title[length_visible + 3]; char decoration = ' '; if (1 == active) @@ -263,10 +363,9 @@ static void draw_wins_borderlines(struct Win * w, struct Win * w_active, static void draw_wins_bordercorners(struct Win * w, WINDOW * pad) { 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, '+'); + mvwaddch(pad, w->start.y - 1, w->start.x + w->framesize.x, '+'); + mvwaddch(pad, w->start.y + w->framesize.y, w->start.x - 1, '+'); + mvwaddch(pad, w->start.y + w->framesize.y, w->start.x + w->framesize.x,'+'); if (0 != w->next) { draw_wins_bordercorners(w->next, pad); @@ -357,55 +456,92 @@ static void shift_win_backward(struct WinMeta * wmeta) -extern uint8_t init_win_meta(WINDOW * screen, struct WinMeta * wmeta) +extern uint8_t init_win_meta(WINDOW * screen, struct WinMeta ** wmp) { + struct WinMeta * wmeta = malloc(sizeof(struct WinMeta)); wmeta->screen = screen; - wmeta->padframe.size.y = getmaxy(screen); - wmeta->padframe.size.x = getmaxx(screen); + uint32_t maxy_test = getmaxy(screen); + uint32_t maxx_test = getmaxx(screen); + if (maxy_test > UINT16_MAX || maxx_test > UINT16_MAX) + { + return 2; + } + wmeta->padsize.y = maxy_test; + wmeta->padsize.x = maxx_test; wmeta->chain_start = 0; wmeta->chain_end = 0; wmeta->pad_offset = 0; - WINDOW * test; - test = newpad(wmeta->padframe.size.y, 1); - if (NULL == test) + WINDOW * pad_test = newpad(wmeta->padsize.y, 1); + if (NULL == pad_test) { return 1; } - wmeta->padframe.curses_win = test; + wmeta->pad = pad_test; wmeta->active = 0; + *wmp = wmeta; return 0; } -extern struct Win init_win(struct WinMeta * wmeta, char * title, - uint16_t height, uint16_t width, - void * data, void * func) +extern uint8_t init_win(struct WinMeta * wmeta, struct Win ** wp, char * title, + int16_t height, int16_t width, + void * data, void * func) { - struct Win w; - w.prev = 0; - w.next = 0; - w.frame.curses_win = 0; - w.title = title; - w.data = data; - w.draw = func; - if (width > 0) + struct Win * w = malloc(sizeof(struct Win)); + if (NULL == w) { - w.frame.size.x = width; + return 1; } - else + w->prev = 0; + w->next = 0; + w->winmapsize.y = 0; + w->winmapsize.x = 0; + w->winmap = NULL; + w->title = malloc(strlen(title) + 1); + if (NULL == w->title) { - w.frame.size.x = 1; + return 1; } - if (height > 0 && height <= wmeta->padframe.size.y - 1) + sprintf(w->title, "%s", title); + w->data = data; + w->draw = func; + w->center.y = 0; + w->center.x = 0; + if (0 < width) { - w.frame.size.y = height; + w->framesize.x = width; } - else + else if (0 >= width) { - w.frame.size.y = wmeta->padframe.size.y - 1; + w->framesize.x = wmeta->padsize.x + width; } - return w; + if (0 < height && height <= wmeta->padsize.y - 1) + { + w->framesize.y = height; + } + else if (0 >= height && wmeta->padsize.y + (height - 1) > 0) + { + w->framesize.y = wmeta->padsize.y + (height - 1); + } + *wp = w; + return 0; +} + + + +extern void free_winmeta(struct WinMeta * wmeta) +{ + delwin(wmeta->pad); + free(wmeta); +} + + + +extern void free_win(struct Win * win) +{ + free(win->title); + free(win); } @@ -430,8 +566,6 @@ extern uint8_t append_win(struct WinMeta * wmeta, struct Win * w) extern uint8_t suspend_win(struct WinMeta * wmeta, struct Win * w) { - destroy_win(w); - if (wmeta->chain_start != w) { w->prev->next = w->next; @@ -448,12 +582,13 @@ extern uint8_t suspend_win(struct WinMeta * wmeta, struct Win * w) { wmeta->active = w->next; } - 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. */ + uint8_t test = update_wins(wmeta, w->next); /* Positioning of */ + if (0 != test) /* successor windows may */ + { /* be affected / need */ + return test; /* correction. Note that */ + } /* update_wins() already */ + pad_refitted = 1; /* refits the pad, voiding*/ + } /* later need for that. */ else { wmeta->chain_end = w->prev; @@ -479,8 +614,7 @@ extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset) { if (new_offset >= 0 && (new_offset < wmeta->pad_offset - || new_offset + wmeta->padframe.size.x - < getmaxx(wmeta->padframe.curses_win))) + || new_offset + wmeta->padsize.x < getmaxx(wmeta->pad))) { wmeta->pad_offset = new_offset; } @@ -491,22 +625,21 @@ extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset) 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->padframe.size.y) + && size.x > 0 && size.y > 0 && size.y < wmeta->padsize.y) { - wmeta->active->frame.size = size; - return update_wins(wmeta, wmeta->chain_start); /* Succeeding windows' */ - } /* positioning may be */ - return 0; /* affected. */ -} /* TODO: Why start at */ - /* chain_start then? */ + wmeta->active->framesize = size; + return update_wins(wmeta, wmeta->active); /* Positioning of following */ + } /* windows may be affected. */ + return 0; +} + extern void cycle_active_win(struct WinMeta * wmeta, char dir) { if (0 != wmeta->active) { - if ('n' == dir) + if ('f' == dir) { if (wmeta->active->next != 0) { @@ -533,116 +666,12 @@ extern void cycle_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 2 windows visible. */ - && (dir == 'f' || dir == 'b')) /* and wrong dir char. */ - { - struct Win * w_shift = wmeta->active, * w_p, * w_p_next; - - /* Check if shifting will lead to wrapping. */ - char wrap = 0; - if ( (dir == 'f' && w_shift == wmeta->chain_end) - || (dir == 'b' && w_shift == wmeta->chain_start)) - { - wrap = 1; - } - - /* Suspend all visible windows, remember their order in wins[]. */ - uint16_t i, i_max; - for (w_p = wmeta->chain_start, i_max = 1; - w_p != wmeta->chain_end; - w_p = w_p->next) - { - 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++) - { - w_p_next = w_p->next; - suspend_win(wmeta, w_p); - wins[i] = w_p; - w_p = w_p_next; - } - - /* Re-append all previously visible windows in the new order. */ - if (wrap) - { - if (dir == 'f') - { - if (0 != append_win(wmeta, w_shift)) - { - return 1; - } - for (i = 0; i < i_max - 1; i++) - { - if (0 != append_win(wmeta, wins[i])) - { - return 1; - } - } - } - else - { - for (i = 1; i < i_max; i++) - { - if (0 != append_win(wmeta, wins[i])) - { - return 1; - } - } - if (0 != append_win(wmeta, w_shift)) - { - return 1; - } - } - } - else - { - for (i = 0; i < i_max; i++) - { - if ( (dir == 'f' && w_shift == wins[i]) - || (dir == 'b' && w_shift == wins[i+1])) - { - if ( 0 != append_win(wmeta, wins[i+1]) - || 0 != append_win(wmeta, wins[i])) - { - return 1; - } - i++; - } - else - { - if (0 != append_win(wmeta, wins[i])) - { - return 1; - } - } - } - } - free(wins); - - wmeta->active = w_shift; /* Otherwise lastly appended win is active. */ - } - return 0; -} - - - -extern void shift_active_win(struct WinMeta * wmeta, char dir) +extern uint8_t shift_active_win(struct WinMeta * wmeta, char dir) { - if ( 0 == wmeta->active - || wmeta->chain_start == wmeta->chain_end - || (dir != 'f' && dir != 'b')) + if ( 0 == wmeta->active /* No shifting with < 2 */ + || wmeta->chain_start == wmeta->chain_end) /* windows visible. */ { - return; + return 0; } if ('f' == dir) { @@ -652,105 +681,46 @@ extern void shift_active_win(struct WinMeta * wmeta, char dir) { shift_win_backward(wmeta); } - update_wins(wmeta, wmeta->chain_start); + return update_wins(wmeta, wmeta->chain_start); } -extern void draw_all_wins(struct WinMeta * wmeta) +extern uint8_t draw_all_wins(struct WinMeta * wm) { /* Empty everything before filling it a-new. */ erase(); - wnoutrefresh(wmeta->screen); - werase(wmeta->padframe.curses_win); - if (wmeta->chain_start) + wnoutrefresh(wm->screen); + werase(wm->pad); + if (wm->chain_start) { - /* 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 windows' borders first, then windows. */ + draw_wins_borderlines(wm->chain_start, wm->active, wm->pad); + draw_wins_bordercorners(wm->chain_start, wm->pad); + if (1 == draw_wins(wm, wm->chain_start)) + { + return 1; + } /* Draw virtual screen scroll hints. */ - if (wmeta->pad_offset > 0) + if (wm->pad_offset > 0) { - draw_scroll_hint(&wmeta->padframe, - wmeta->pad_offset, wmeta->pad_offset + 1, '<'); + padscroll_hint(wm, '<', wm->pad_offset + 1); } - if (wmeta->pad_offset + wmeta->padframe.size.x - < getmaxx(wmeta->padframe.curses_win) - 1) + uint16_t size_x = getmaxx(wm->pad); + uint16_t right_edge = wm->pad_offset + wm->padsize.x; + if (right_edge < size_x - 1) { - 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), - '>'); + padscroll_hint(wm, '>', size_x - right_edge); } - /* Write virtual screen segment to be shown on physical screen into */ - /* ncurses screen buffer. */ - pnoutrefresh(wmeta->padframe.curses_win, 0, wmeta->pad_offset, 0, 0, - wmeta->padframe.size.y, wmeta->padframe.size.x-1); + /* Write pad segment to be shown on physical screen to screen buffer. */ + pnoutrefresh(wm->pad, 0, wm->pad_offset, 0, 0, + wm->padsize.y, wm->padsize.x - 1); } /* Only at the end write accumulated changes to the physical screen. */ doupdate(); -} - - - -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"; - char * unit_cols = "columns"; - char * unit_rows = "lines"; - uint16_t dsc_space = frame->size.x; - char * unit = unit_rows; - if ('<' == dir || '>' == dir) - { - dsc_space = frame->size.y; - unit = unit_cols; - } - 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. */ - char offset = 1, q; - if (dsc_space > strlen(scrolldsc) + 1) - { - offset = (dsc_space - strlen(scrolldsc)) / 2; - } - - /* Draw scroll hint line as dir symbols bracketing description text. */ - chtype symbol; - for (q = 0; q < dsc_space; q++) - { - if (q >= offset && q < strlen(scrolldsc) + offset) - { - symbol = scrolldsc[q - offset] | A_REVERSE; - } - else - { - symbol = dir | A_REVERSE; - } - if ('<' == dir || '>' == dir) - { - mvwaddch(frame->curses_win, q, pos, symbol); - } - else - { - mvwaddch(frame->curses_win, pos, q, symbol); - } - } - - free(scrolldsc); return 0; }