1*c7ef0cfcSnicm /* $OpenBSD: resizeterm.c,v 1.5 2023/10/17 09:52:09 nicm Exp $ */
292dd1ec0Smillert
392dd1ec0Smillert /****************************************************************************
4*c7ef0cfcSnicm * Copyright 2020,2021 Thomas E. Dickey *
5*c7ef0cfcSnicm * Copyright 1998-2015,2016 Free Software Foundation, Inc. *
692dd1ec0Smillert * *
792dd1ec0Smillert * Permission is hereby granted, free of charge, to any person obtaining a *
892dd1ec0Smillert * copy of this software and associated documentation files (the *
992dd1ec0Smillert * "Software"), to deal in the Software without restriction, including *
1092dd1ec0Smillert * without limitation the rights to use, copy, modify, merge, publish, *
1192dd1ec0Smillert * distribute, distribute with modifications, sublicense, and/or sell *
1292dd1ec0Smillert * copies of the Software, and to permit persons to whom the Software is *
1392dd1ec0Smillert * furnished to do so, subject to the following conditions: *
1492dd1ec0Smillert * *
1592dd1ec0Smillert * The above copyright notice and this permission notice shall be included *
1692dd1ec0Smillert * in all copies or substantial portions of the Software. *
1792dd1ec0Smillert * *
1892dd1ec0Smillert * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
1992dd1ec0Smillert * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
2092dd1ec0Smillert * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
2192dd1ec0Smillert * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
2292dd1ec0Smillert * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
2392dd1ec0Smillert * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
2492dd1ec0Smillert * THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
2592dd1ec0Smillert * *
2692dd1ec0Smillert * Except as contained in this notice, the name(s) of the above copyright *
2792dd1ec0Smillert * holders shall not be used in advertising or otherwise to promote the *
2892dd1ec0Smillert * sale, use or other dealings in this Software without prior written *
2992dd1ec0Smillert * authorization. *
3092dd1ec0Smillert ****************************************************************************/
3192dd1ec0Smillert
3292dd1ec0Smillert /****************************************************************************
3381d8c4e1Snicm * Author: Thomas E. Dickey *
34*c7ef0cfcSnicm * and: Juergen Pfeifer *
3592dd1ec0Smillert ****************************************************************************/
3692dd1ec0Smillert
3792dd1ec0Smillert /*
3892dd1ec0Smillert * This is an extension to the curses library. It provides callers with a hook
3992dd1ec0Smillert * into the NCURSES data to resize windows, primarily for use by programs
4092dd1ec0Smillert * running in an X Window terminal (e.g., xterm). I abstracted this module
4192dd1ec0Smillert * from my application library for NCURSES because it must be compiled with
4292dd1ec0Smillert * the private data structures -- T.Dickey 1995/7/4.
4392dd1ec0Smillert */
4492dd1ec0Smillert
4592dd1ec0Smillert #include <curses.priv.h>
4692dd1ec0Smillert
47*c7ef0cfcSnicm #ifndef CUR
48*c7ef0cfcSnicm #define CUR SP_TERMTYPE
49*c7ef0cfcSnicm #endif
5081d8c4e1Snicm
51*c7ef0cfcSnicm MODULE_ID("$Id: resizeterm.c,v 1.5 2023/10/17 09:52:09 nicm Exp $")
5281d8c4e1Snicm
5381d8c4e1Snicm /*
5481d8c4e1Snicm * If we're trying to be reentrant, do not want any local statics.
5581d8c4e1Snicm */
5681d8c4e1Snicm #if USE_REENTRANT
5781d8c4e1Snicm #define EXTRA_ARGS , CurLines, CurCols
5881d8c4e1Snicm #define EXTRA_DCLS , int CurLines, int CurCols
5981d8c4e1Snicm #else
6081d8c4e1Snicm static int current_lines;
6181d8c4e1Snicm static int current_cols;
6281d8c4e1Snicm #define CurLines current_lines
6381d8c4e1Snicm #define CurCols current_cols
6481d8c4e1Snicm #define EXTRA_ARGS /* nothing */
6581d8c4e1Snicm #define EXTRA_DCLS /* nothing */
6681d8c4e1Snicm #endif
6781d8c4e1Snicm
68*c7ef0cfcSnicm #if NCURSES_SP_FUNCS && !defined(USE_SP_WINDOWLIST)
69*c7ef0cfcSnicm #define UNUSED_SP (void) sp
70*c7ef0cfcSnicm #else
71*c7ef0cfcSnicm #define UNUSED_SP /* nothing */
72*c7ef0cfcSnicm #endif
73*c7ef0cfcSnicm
7481d8c4e1Snicm #ifdef TRACE
7581d8c4e1Snicm static void
show_window_sizes(const char * name)7681d8c4e1Snicm show_window_sizes(const char *name)
7781d8c4e1Snicm {
78*c7ef0cfcSnicm SCREEN *sp;
7981d8c4e1Snicm WINDOWLIST *wp;
8081d8c4e1Snicm
8181d8c4e1Snicm _nc_lock_global(curses);
82*c7ef0cfcSnicm for (each_screen(sp)) {
83*c7ef0cfcSnicm _tracef("%s resizing: %p: %2d x %2d (%2d x %2d)", name, (void *) sp,
84*c7ef0cfcSnicm *(ptrLines(sp)),
85*c7ef0cfcSnicm *(ptrCols(sp)),
86*c7ef0cfcSnicm screen_lines(sp), screen_columns(sp));
87*c7ef0cfcSnicm for (each_window(sp, wp)) {
8881d8c4e1Snicm _tracef(" window %p is %2ld x %2ld at %2ld,%2ld",
89*c7ef0cfcSnicm (void *) &(wp->win),
9081d8c4e1Snicm (long) wp->win._maxy + 1,
9181d8c4e1Snicm (long) wp->win._maxx + 1,
9281d8c4e1Snicm (long) wp->win._begy,
9381d8c4e1Snicm (long) wp->win._begx);
9481d8c4e1Snicm }
95*c7ef0cfcSnicm }
9681d8c4e1Snicm _nc_unlock_global(curses);
9781d8c4e1Snicm }
9881d8c4e1Snicm #endif
9981d8c4e1Snicm
10081d8c4e1Snicm /*
10181d8c4e1Snicm * Return true if the given dimensions do not match the internal terminal
10281d8c4e1Snicm * structure's size.
10381d8c4e1Snicm */
10481d8c4e1Snicm NCURSES_EXPORT(bool)
NCURSES_SP_NAME(is_term_resized)105*c7ef0cfcSnicm NCURSES_SP_NAME(is_term_resized) (NCURSES_SP_DCLx int ToLines, int ToCols)
10681d8c4e1Snicm {
107*c7ef0cfcSnicm T((T_CALLED("is_term_resized(%p, %d, %d)"), (void *) SP_PARM, ToLines, ToCols));
10881d8c4e1Snicm returnCode(ToLines > 0
10981d8c4e1Snicm && ToCols > 0
110*c7ef0cfcSnicm && (ToLines != screen_lines(SP_PARM)
111*c7ef0cfcSnicm || ToCols != screen_columns(SP_PARM)));
11281d8c4e1Snicm }
11381d8c4e1Snicm
114*c7ef0cfcSnicm #if NCURSES_SP_FUNCS
115*c7ef0cfcSnicm NCURSES_EXPORT(bool)
is_term_resized(int ToLines,int ToCols)116*c7ef0cfcSnicm is_term_resized(int ToLines, int ToCols)
117*c7ef0cfcSnicm {
118*c7ef0cfcSnicm return NCURSES_SP_NAME(is_term_resized) (CURRENT_SCREEN, ToLines, ToCols);
119*c7ef0cfcSnicm }
120*c7ef0cfcSnicm #endif
121*c7ef0cfcSnicm
12281d8c4e1Snicm /*
12381d8c4e1Snicm */
12481d8c4e1Snicm static ripoff_t *
ripped_window(WINDOW * win)12581d8c4e1Snicm ripped_window(WINDOW *win)
12681d8c4e1Snicm {
12781d8c4e1Snicm ripoff_t *result = 0;
12881d8c4e1Snicm ripoff_t *rop;
12981d8c4e1Snicm
13081d8c4e1Snicm if (win != 0) {
131*c7ef0cfcSnicm #ifdef USE_SP_RIPOFF
132*c7ef0cfcSnicm SCREEN *sp = _nc_screen_of(win);
133*c7ef0cfcSnicm #endif
13481d8c4e1Snicm for (each_ripoff(rop)) {
13581d8c4e1Snicm if (rop->win == win && rop->line != 0) {
13681d8c4e1Snicm result = rop;
13781d8c4e1Snicm break;
13881d8c4e1Snicm }
13981d8c4e1Snicm }
14081d8c4e1Snicm }
14181d8c4e1Snicm return result;
14281d8c4e1Snicm }
14381d8c4e1Snicm
14481d8c4e1Snicm /*
14581d8c4e1Snicm * Returns the number of lines from the bottom for the beginning of a ripped
14681d8c4e1Snicm * off window.
14781d8c4e1Snicm */
14881d8c4e1Snicm static int
ripped_bottom(WINDOW * win)14981d8c4e1Snicm ripped_bottom(WINDOW *win)
15081d8c4e1Snicm {
15181d8c4e1Snicm int result = 0;
15281d8c4e1Snicm
15381d8c4e1Snicm if (win != 0) {
154*c7ef0cfcSnicm ripoff_t *rop;
155*c7ef0cfcSnicm
156*c7ef0cfcSnicm #ifdef USE_SP_RIPOFF
157*c7ef0cfcSnicm SCREEN *sp = _nc_screen_of(win);
158*c7ef0cfcSnicm #endif
15981d8c4e1Snicm for (each_ripoff(rop)) {
16081d8c4e1Snicm if (rop->line < 0) {
16181d8c4e1Snicm result -= rop->line;
16281d8c4e1Snicm if (rop->win == win) {
16381d8c4e1Snicm break;
16481d8c4e1Snicm }
16581d8c4e1Snicm }
16681d8c4e1Snicm }
16781d8c4e1Snicm }
16881d8c4e1Snicm return result;
16981d8c4e1Snicm }
17081d8c4e1Snicm
17181d8c4e1Snicm /*
17281d8c4e1Snicm * Return the number of levels of child-windows under the current window.
17381d8c4e1Snicm */
17481d8c4e1Snicm static int
child_depth(WINDOW * cmp)17581d8c4e1Snicm child_depth(WINDOW *cmp)
17681d8c4e1Snicm {
17781d8c4e1Snicm int depth = 0;
17881d8c4e1Snicm
17981d8c4e1Snicm if (cmp != 0) {
180*c7ef0cfcSnicm #ifdef USE_SP_WINDOWLIST
181*c7ef0cfcSnicm SCREEN *sp = _nc_screen_of(cmp);
182*c7ef0cfcSnicm #endif
18381d8c4e1Snicm WINDOWLIST *wp;
18481d8c4e1Snicm
185*c7ef0cfcSnicm for (each_window(sp, wp)) {
18681d8c4e1Snicm WINDOW *tst = &(wp->win);
18781d8c4e1Snicm if (tst->_parent == cmp) {
18881d8c4e1Snicm depth = 1 + child_depth(tst);
18981d8c4e1Snicm break;
19081d8c4e1Snicm }
19181d8c4e1Snicm }
19281d8c4e1Snicm }
19381d8c4e1Snicm return depth;
19481d8c4e1Snicm }
19581d8c4e1Snicm
19681d8c4e1Snicm /*
19781d8c4e1Snicm * Return the number of levels of parent-windows above the current window.
19881d8c4e1Snicm */
19981d8c4e1Snicm static int
parent_depth(WINDOW * cmp)20081d8c4e1Snicm parent_depth(WINDOW *cmp)
20181d8c4e1Snicm {
20281d8c4e1Snicm int depth = 0;
20381d8c4e1Snicm
20481d8c4e1Snicm if (cmp != 0) {
20581d8c4e1Snicm WINDOW *tst;
20681d8c4e1Snicm while ((tst = cmp->_parent) != 0) {
20781d8c4e1Snicm ++depth;
20881d8c4e1Snicm cmp = tst;
20981d8c4e1Snicm }
21081d8c4e1Snicm }
21181d8c4e1Snicm return depth;
21281d8c4e1Snicm }
21381d8c4e1Snicm
21481d8c4e1Snicm /*
215*c7ef0cfcSnicm * FIXME: must adjust position so it is within the parent!
21681d8c4e1Snicm */
21781d8c4e1Snicm static int
adjust_window(WINDOW * win,int ToLines,int ToCols,int stolen EXTRA_DCLS)21881d8c4e1Snicm adjust_window(WINDOW *win, int ToLines, int ToCols, int stolen EXTRA_DCLS)
21981d8c4e1Snicm {
22081d8c4e1Snicm int result;
221*c7ef0cfcSnicm int bottom = CurLines + _nc_screen_of(win)->_topstolen - stolen;
22281d8c4e1Snicm int myLines = win->_maxy + 1;
22381d8c4e1Snicm int myCols = win->_maxx + 1;
22481d8c4e1Snicm ripoff_t *rop = ripped_window(win);
22581d8c4e1Snicm
22681d8c4e1Snicm T((T_CALLED("adjust_window(%p,%d,%d)%s depth %d/%d currently %ldx%ld at %ld,%ld"),
227*c7ef0cfcSnicm (void *) win, ToLines, ToCols,
22881d8c4e1Snicm (rop != 0) ? " (rip)" : "",
22981d8c4e1Snicm parent_depth(win),
23081d8c4e1Snicm child_depth(win),
23181d8c4e1Snicm (long) getmaxy(win), (long) getmaxx(win),
23281d8c4e1Snicm (long) getbegy(win) + win->_yoffset, (long) getbegx(win)));
23381d8c4e1Snicm
23481d8c4e1Snicm if (rop != 0 && rop->line < 0) {
23581d8c4e1Snicm /*
23681d8c4e1Snicm * If it is a ripped-off window at the bottom of the screen, simply
23781d8c4e1Snicm * move it to the same relative position.
23881d8c4e1Snicm */
239*c7ef0cfcSnicm win->_begy = (NCURSES_SIZE_T) (ToLines - ripped_bottom(win) - 0 - win->_yoffset);
240*c7ef0cfcSnicm if (rop->hook == _nc_slk_initialize)
241*c7ef0cfcSnicm _nc_format_slks(
242*c7ef0cfcSnicm #if NCURSES_SP_FUNCS
243*c7ef0cfcSnicm _nc_screen_of(win),
244*c7ef0cfcSnicm #endif
245*c7ef0cfcSnicm ToCols);
24681d8c4e1Snicm } else if (win->_begy >= bottom) {
24781d8c4e1Snicm /*
24881d8c4e1Snicm * If it is below the bottom of the new screen, move up by the same
24981d8c4e1Snicm * amount that the screen shrank.
25081d8c4e1Snicm */
251*c7ef0cfcSnicm win->_begy = (NCURSES_SIZE_T) (win->_begy + (ToLines - CurLines));
25281d8c4e1Snicm } else {
25381d8c4e1Snicm if (myLines == (CurLines - stolen)
25481d8c4e1Snicm && ToLines != CurLines) {
25581d8c4e1Snicm myLines = ToLines - stolen;
25681d8c4e1Snicm } else if (myLines == CurLines
25781d8c4e1Snicm && ToLines != CurLines) {
25881d8c4e1Snicm myLines = ToLines;
25981d8c4e1Snicm }
26081d8c4e1Snicm }
26181d8c4e1Snicm
26281d8c4e1Snicm if (myLines > ToLines) {
26381d8c4e1Snicm myLines = ToLines;
26481d8c4e1Snicm }
26581d8c4e1Snicm
26681d8c4e1Snicm if (myCols > ToCols)
26781d8c4e1Snicm myCols = ToCols;
26881d8c4e1Snicm
26981d8c4e1Snicm if (myCols == CurCols
27081d8c4e1Snicm && ToCols != CurCols)
27181d8c4e1Snicm myCols = ToCols;
27281d8c4e1Snicm
27381d8c4e1Snicm result = wresize(win, myLines, myCols);
27481d8c4e1Snicm returnCode(result);
27581d8c4e1Snicm }
27681d8c4e1Snicm
27781d8c4e1Snicm /*
27881d8c4e1Snicm * If we're decreasing size, recursively search for windows that have no
27981d8c4e1Snicm * children, decrease those to fit, then decrease the containing window, etc.
28081d8c4e1Snicm */
28181d8c4e1Snicm static int
decrease_size(NCURSES_SP_DCLx int ToLines,int ToCols,int stolen EXTRA_DCLS)282*c7ef0cfcSnicm decrease_size(NCURSES_SP_DCLx int ToLines, int ToCols, int stolen EXTRA_DCLS)
28381d8c4e1Snicm {
28481d8c4e1Snicm bool found;
28581d8c4e1Snicm int depth = 0;
28681d8c4e1Snicm WINDOWLIST *wp;
28781d8c4e1Snicm
288*c7ef0cfcSnicm T((T_CALLED("decrease_size(%p, %d, %d)"), (void *) SP_PARM, ToLines, ToCols));
289*c7ef0cfcSnicm UNUSED_SP;
29081d8c4e1Snicm
29181d8c4e1Snicm do {
29281d8c4e1Snicm found = FALSE;
29381d8c4e1Snicm TR(TRACE_UPDATE, ("decreasing size of windows to %dx%d, depth=%d",
29481d8c4e1Snicm ToLines, ToCols, depth));
295*c7ef0cfcSnicm for (each_window(SP_PARM, wp)) {
29681d8c4e1Snicm WINDOW *win = &(wp->win);
29781d8c4e1Snicm
298*c7ef0cfcSnicm if (!IS_PAD(win)) {
29981d8c4e1Snicm if (child_depth(win) == depth) {
30081d8c4e1Snicm found = TRUE;
30181d8c4e1Snicm if (adjust_window(win, ToLines, ToCols,
30281d8c4e1Snicm stolen EXTRA_ARGS) != OK)
30381d8c4e1Snicm returnCode(ERR);
30481d8c4e1Snicm }
30581d8c4e1Snicm }
30681d8c4e1Snicm }
30781d8c4e1Snicm ++depth;
30881d8c4e1Snicm } while (found);
30981d8c4e1Snicm returnCode(OK);
31081d8c4e1Snicm }
31181d8c4e1Snicm
31281d8c4e1Snicm /*
31381d8c4e1Snicm * If we're increasing size, recursively search for windows that have no
31481d8c4e1Snicm * parent, increase those to fit, then increase the contained window, etc.
31581d8c4e1Snicm */
31681d8c4e1Snicm static int
increase_size(NCURSES_SP_DCLx int ToLines,int ToCols,int stolen EXTRA_DCLS)317*c7ef0cfcSnicm increase_size(NCURSES_SP_DCLx int ToLines, int ToCols, int stolen EXTRA_DCLS)
31881d8c4e1Snicm {
31981d8c4e1Snicm bool found;
32081d8c4e1Snicm int depth = 0;
32181d8c4e1Snicm WINDOWLIST *wp;
32281d8c4e1Snicm
323*c7ef0cfcSnicm T((T_CALLED("increase_size(%p, %d, %d)"), (void *) SP_PARM, ToLines, ToCols));
324*c7ef0cfcSnicm UNUSED_SP;
32581d8c4e1Snicm
32681d8c4e1Snicm do {
32781d8c4e1Snicm found = FALSE;
32881d8c4e1Snicm TR(TRACE_UPDATE, ("increasing size of windows to %dx%d, depth=%d",
32981d8c4e1Snicm ToLines, ToCols, depth));
330*c7ef0cfcSnicm for (each_window(SP_PARM, wp)) {
33181d8c4e1Snicm WINDOW *win = &(wp->win);
33281d8c4e1Snicm
333*c7ef0cfcSnicm if (!IS_PAD(win)) {
33481d8c4e1Snicm if (parent_depth(win) == depth) {
33581d8c4e1Snicm found = TRUE;
33681d8c4e1Snicm if (adjust_window(win, ToLines, ToCols,
33781d8c4e1Snicm stolen EXTRA_ARGS) != OK)
33881d8c4e1Snicm returnCode(ERR);
33981d8c4e1Snicm }
34081d8c4e1Snicm }
34181d8c4e1Snicm }
34281d8c4e1Snicm ++depth;
34381d8c4e1Snicm } while (found);
34481d8c4e1Snicm returnCode(OK);
34581d8c4e1Snicm }
34681d8c4e1Snicm
34781d8c4e1Snicm /*
34881d8c4e1Snicm * This function reallocates NCURSES window structures, with no side-effects
34981d8c4e1Snicm * such as ungetch().
35081d8c4e1Snicm */
35181d8c4e1Snicm NCURSES_EXPORT(int)
NCURSES_SP_NAME(resize_term)352*c7ef0cfcSnicm NCURSES_SP_NAME(resize_term) (NCURSES_SP_DCLx int ToLines, int ToCols)
35381d8c4e1Snicm {
35481d8c4e1Snicm int result = OK EXTRA_ARGS;
35581d8c4e1Snicm int was_stolen;
35681d8c4e1Snicm
357*c7ef0cfcSnicm T((T_CALLED("resize_term(%p,%d,%d) old(%d,%d)"),
358*c7ef0cfcSnicm (void *) SP_PARM, ToLines, ToCols,
359*c7ef0cfcSnicm (SP_PARM == 0) ? -1 : screen_lines(SP_PARM),
360*c7ef0cfcSnicm (SP_PARM == 0) ? -1 : screen_columns(SP_PARM)));
36181d8c4e1Snicm
362*c7ef0cfcSnicm if (SP_PARM == 0 || ToLines <= 0 || ToCols <= 0) {
36381d8c4e1Snicm returnCode(ERR);
36481d8c4e1Snicm }
36581d8c4e1Snicm
366*c7ef0cfcSnicm _nc_nonsp_lock_global(curses);
36781d8c4e1Snicm
368*c7ef0cfcSnicm was_stolen = (screen_lines(SP_PARM) - SP_PARM->_lines_avail);
369*c7ef0cfcSnicm if (NCURSES_SP_NAME(is_term_resized) (NCURSES_SP_ARGx ToLines, ToCols)) {
370*c7ef0cfcSnicm int myLines = CurLines = screen_lines(SP_PARM);
371*c7ef0cfcSnicm int myCols = CurCols = screen_columns(SP_PARM);
37281d8c4e1Snicm
37381d8c4e1Snicm #ifdef TRACE
37481d8c4e1Snicm if (USE_TRACEF(TRACE_UPDATE)) {
37581d8c4e1Snicm show_window_sizes("before");
37681d8c4e1Snicm _nc_unlock_global(tracef);
37781d8c4e1Snicm }
37881d8c4e1Snicm #endif
379*c7ef0cfcSnicm if (ToLines > screen_lines(SP_PARM)) {
380*c7ef0cfcSnicm result = increase_size(NCURSES_SP_ARGx
381*c7ef0cfcSnicm myLines = ToLines,
382*c7ef0cfcSnicm myCols,
383*c7ef0cfcSnicm was_stolen EXTRA_ARGS);
38481d8c4e1Snicm CurLines = myLines;
38581d8c4e1Snicm CurCols = myCols;
38681d8c4e1Snicm }
38781d8c4e1Snicm
388*c7ef0cfcSnicm if ((result == OK)
389*c7ef0cfcSnicm && (ToCols > screen_columns(SP_PARM))) {
390*c7ef0cfcSnicm result = increase_size(NCURSES_SP_ARGx
391*c7ef0cfcSnicm myLines,
392*c7ef0cfcSnicm myCols = ToCols,
393*c7ef0cfcSnicm was_stolen EXTRA_ARGS);
39481d8c4e1Snicm CurLines = myLines;
39581d8c4e1Snicm CurCols = myCols;
39681d8c4e1Snicm }
39781d8c4e1Snicm
398*c7ef0cfcSnicm if ((result == OK)
399*c7ef0cfcSnicm && (ToLines < myLines ||
400*c7ef0cfcSnicm ToCols < myCols)) {
401*c7ef0cfcSnicm result = decrease_size(NCURSES_SP_ARGx
402*c7ef0cfcSnicm ToLines,
403*c7ef0cfcSnicm ToCols,
404*c7ef0cfcSnicm was_stolen EXTRA_ARGS);
40581d8c4e1Snicm }
40681d8c4e1Snicm
407*c7ef0cfcSnicm if (result == OK) {
408*c7ef0cfcSnicm screen_lines(SP_PARM) = (NCURSES_SIZE_T) ToLines;
409*c7ef0cfcSnicm screen_columns(SP_PARM) = (NCURSES_SIZE_T) ToCols;
41081d8c4e1Snicm
411*c7ef0cfcSnicm #ifdef USE_TERM_DRIVER
412*c7ef0cfcSnicm CallDriver_2(SP_PARM, td_setsize, ToLines, ToCols);
413*c7ef0cfcSnicm #else
414*c7ef0cfcSnicm lines = (NCURSES_SIZE_T) ToLines;
415*c7ef0cfcSnicm columns = (NCURSES_SIZE_T) ToCols;
416*c7ef0cfcSnicm #endif
41781d8c4e1Snicm
418*c7ef0cfcSnicm SP_PARM->_lines_avail = (NCURSES_SIZE_T) (ToLines - was_stolen);
419*c7ef0cfcSnicm
420*c7ef0cfcSnicm if (SP_PARM->oldhash) {
421*c7ef0cfcSnicm FreeAndNull(SP_PARM->oldhash);
42281d8c4e1Snicm }
423*c7ef0cfcSnicm if (SP_PARM->newhash) {
424*c7ef0cfcSnicm FreeAndNull(SP_PARM->newhash);
42581d8c4e1Snicm }
42681d8c4e1Snicm #ifdef TRACE
42781d8c4e1Snicm if (USE_TRACEF(TRACE_UPDATE)) {
42881d8c4e1Snicm SET_LINES(ToLines - was_stolen);
42981d8c4e1Snicm SET_COLS(ToCols);
43081d8c4e1Snicm show_window_sizes("after");
43181d8c4e1Snicm _nc_unlock_global(tracef);
43281d8c4e1Snicm }
43381d8c4e1Snicm #endif
43481d8c4e1Snicm }
435*c7ef0cfcSnicm }
43681d8c4e1Snicm
437*c7ef0cfcSnicm if (result == OK) {
43881d8c4e1Snicm /*
43981d8c4e1Snicm * Always update LINES, to allow for call from lib_doupdate.c which
44081d8c4e1Snicm * needs to have the count adjusted by the stolen (ripped off) lines.
44181d8c4e1Snicm */
44281d8c4e1Snicm SET_LINES(ToLines - was_stolen);
44381d8c4e1Snicm SET_COLS(ToCols);
444*c7ef0cfcSnicm }
44581d8c4e1Snicm
446*c7ef0cfcSnicm _nc_nonsp_unlock_global(curses);
44781d8c4e1Snicm
44881d8c4e1Snicm returnCode(result);
44981d8c4e1Snicm }
45092dd1ec0Smillert
451*c7ef0cfcSnicm #if NCURSES_SP_FUNCS
452*c7ef0cfcSnicm NCURSES_EXPORT(int)
resize_term(int ToLines,int ToCols)453*c7ef0cfcSnicm resize_term(int ToLines, int ToCols)
454*c7ef0cfcSnicm {
455*c7ef0cfcSnicm int res;
456*c7ef0cfcSnicm _nc_sp_lock_global(curses);
457*c7ef0cfcSnicm res = NCURSES_SP_NAME(resize_term) (CURRENT_SCREEN, ToLines, ToCols);
458*c7ef0cfcSnicm _nc_sp_unlock_global(curses);
459*c7ef0cfcSnicm return (res);
460*c7ef0cfcSnicm }
461*c7ef0cfcSnicm #endif
462*c7ef0cfcSnicm
46392dd1ec0Smillert /*
46492dd1ec0Smillert * This function reallocates NCURSES window structures. It is invoked in
46592dd1ec0Smillert * response to a SIGWINCH interrupt. Other user-defined windows may also need
46692dd1ec0Smillert * to be reallocated.
46792dd1ec0Smillert *
46892dd1ec0Smillert * Because this performs memory allocation, it should not (in general) be
46992dd1ec0Smillert * invoked directly from the signal handler.
47092dd1ec0Smillert */
47184af20ceSmillert NCURSES_EXPORT(int)
NCURSES_SP_NAME(resizeterm)472*c7ef0cfcSnicm NCURSES_SP_NAME(resizeterm) (NCURSES_SP_DCLx int ToLines, int ToCols)
47392dd1ec0Smillert {
47481d8c4e1Snicm int result = ERR;
47592dd1ec0Smillert
476*c7ef0cfcSnicm T((T_CALLED("resizeterm(%p, %d,%d) old(%d,%d)"),
477*c7ef0cfcSnicm (void *) SP_PARM, ToLines, ToCols,
478*c7ef0cfcSnicm (SP_PARM == 0) ? -1 : screen_lines(SP_PARM),
479*c7ef0cfcSnicm (SP_PARM == 0) ? -1 : screen_columns(SP_PARM)));
48092dd1ec0Smillert
481*c7ef0cfcSnicm if (SP_PARM != 0 && ToLines > 0 && ToCols > 0) {
48281d8c4e1Snicm result = OK;
483*c7ef0cfcSnicm SP_PARM->_sig_winch = FALSE;
48492dd1ec0Smillert
485*c7ef0cfcSnicm if (NCURSES_SP_NAME(is_term_resized) (NCURSES_SP_ARGx ToLines, ToCols)) {
48681d8c4e1Snicm #if USE_SIGWINCH
48781d8c4e1Snicm ripoff_t *rop;
488*c7ef0cfcSnicm bool slk_visible = (SP_PARM != 0
489*c7ef0cfcSnicm && SP_PARM->_slk != 0
490*c7ef0cfcSnicm && !(SP_PARM->_slk->hidden));
49181d8c4e1Snicm
49281d8c4e1Snicm if (slk_visible) {
49381d8c4e1Snicm slk_clear();
49481d8c4e1Snicm }
49581d8c4e1Snicm #endif
496*c7ef0cfcSnicm result = NCURSES_SP_NAME(resize_term) (NCURSES_SP_ARGx ToLines, ToCols);
49792dd1ec0Smillert
49892dd1ec0Smillert #if USE_SIGWINCH
499*c7ef0cfcSnicm clearok(CurScreen(SP_PARM), TRUE); /* screen contents are unknown */
50092dd1ec0Smillert
50181d8c4e1Snicm /* ripped-off lines are a special case: if we did not lengthen
50281d8c4e1Snicm * them, we haven't moved them either. repaint them, too.
50381d8c4e1Snicm *
50481d8c4e1Snicm * for the rest - stdscr and other windows - the client has to
50581d8c4e1Snicm * decide which to repaint, since without panels, ncurses does
50681d8c4e1Snicm * not know which are really on top.
50792dd1ec0Smillert */
50881d8c4e1Snicm for (each_ripoff(rop)) {
509*c7ef0cfcSnicm if (rop->win != StdScreen(SP_PARM)
51081d8c4e1Snicm && rop->win != 0
51181d8c4e1Snicm && rop->line < 0) {
51292dd1ec0Smillert
51381d8c4e1Snicm if (rop->hook != _nc_slk_initialize) {
51481d8c4e1Snicm touchwin(rop->win);
51581d8c4e1Snicm wnoutrefresh(rop->win);
51681d8c4e1Snicm }
51781d8c4e1Snicm }
51881d8c4e1Snicm }
51981d8c4e1Snicm
52081d8c4e1Snicm /* soft-keys are a special case: we _know_ how to repaint them */
52181d8c4e1Snicm if (slk_visible) {
522*c7ef0cfcSnicm NCURSES_SP_NAME(slk_restore) (NCURSES_SP_ARG);
523*c7ef0cfcSnicm NCURSES_SP_NAME(slk_touch) (NCURSES_SP_ARG);
524*c7ef0cfcSnicm NCURSES_SP_NAME(slk_refresh) (NCURSES_SP_ARG);
52581d8c4e1Snicm }
52681d8c4e1Snicm #endif
52781d8c4e1Snicm }
528e283eadfSmillert #if USE_SIGWINCH
529*c7ef0cfcSnicm safe_ungetch(SP_PARM, KEY_RESIZE); /* so application can know this */
530e283eadfSmillert #endif
53181d8c4e1Snicm }
53281d8c4e1Snicm
53381d8c4e1Snicm returnCode(result);
53492dd1ec0Smillert }
535*c7ef0cfcSnicm
536*c7ef0cfcSnicm #if NCURSES_SP_FUNCS
537*c7ef0cfcSnicm NCURSES_EXPORT(int)
resizeterm(int ToLines,int ToCols)538*c7ef0cfcSnicm resizeterm(int ToLines, int ToCols)
539*c7ef0cfcSnicm {
540*c7ef0cfcSnicm return NCURSES_SP_NAME(resizeterm) (CURRENT_SCREEN, ToLines, ToCols);
541*c7ef0cfcSnicm }
542*c7ef0cfcSnicm #endif
543