Plan 9 from Bell Labs’s /usr/web/sources/contrib/fgb/root/sys/src/ape/lib/curses/pdcurses/window.c

Copyright © 2021 Plan 9 Foundation.
Distributed under the MIT License.
Download the Plan 9 distribution.


/************************************************************************ 
 * This file is part of PDCurses. PDCurses is public domain software;	*
 * you may use it for any purpose. This software is provided AS IS with	*
 * NO WARRANTY whatsoever.						*
 *									*
 * If you use PDCurses in an application, an acknowledgement would be	*
 * appreciated, but is not mandatory. If you make corrections or	*
 * enhancements to PDCurses, please forward them to the current		*
 * maintainer for the benefit of other users.				*
 *									*
 * See the file maintain.er for details of the current maintainer.	*
 ************************************************************************/

#include <curspriv.h>

RCSID("$Id: window.c,v 1.59 2007/06/14 14:11:31 wmcbrine Exp $")

/*man-start**************************************************************

  Name:								window

  Synopsis:
	WINDOW *newwin(int nlines, int ncols, int begy, int begx);
  	WINDOW *derwin(WINDOW* orig, int nlines, int ncols,
		int begy, int begx);
	WINDOW *subwin(WINDOW* orig, int nlines, int ncols,
		int begy, int begx);
	WINDOW *dupwin(WINDOW *win);
	int delwin(WINDOW *win);
	int mvwin(WINDOW *win, int y, int x);
	int mvderwin(WINDOW *win, int pary, int parx);
	int syncok(WINDOW *win, bool bf);
	void wsyncup(WINDOW *win);
	void wcursyncup(WINDOW *win);
	void wsyncdown(WINDOW *win);

	WINDOW *resize_window(WINDOW *win, int nlines, int ncols);
	int wresize(WINDOW *win, int nlines, int ncols);
	WINDOW *PDC_makelines(WINDOW *win);
	WINDOW *PDC_makenew(int nlines, int ncols, int begy, int begx);
	void PDC_sync(WINDOW *win);

  Description:
	newwin() creates a new window with the given number of lines,
	nlines and columns, ncols. The upper left corner of the window
	is at line begy, column begx. If either nlines or ncols is zero,
	they will be defaulted to LINES - begy and COLS - begx. A new
	full-screen window is created by calling newwin(0, 0, 0, 0).

	delwin() deletes the named window, freeing all memory associated
	with it. In the case of overlapping windows, subwindows should
	be deleted before the main window.

	mvwin() moves the window so that the upper left-hand corner is
	at position (y,x). If the move would cause the window to be off
	the screen, it is an error and the window is not moved. Moving
	subwindows is allowed, but should be avoided. (I don't know why?)

	subwin() creates a new sub-window within a window.  The
	dimensions of the sub-window are nlines lines and ncols columns.
	The sub-window is at position (begy, begx) on the screen.  This
	position is relative to the screen, and not to the window orig.
	The sub-window is made in the middle of the window orig, so that
	changes made to either window will affect both.  When using this
	routine, it will often be necessary to call touchwin() before
	calling wrefresh().

	derwin() is the same as subwin(), except that begy and begx are
	relative to the origin of the window orig rather than the
	screen.  There is no difference between subwindows and derived
	windows.

	mvderwin() moves a derived window (or subwindow) inside its
	parent window.  The screen-relative parameters of the window are
	not changed.  This routine is used to display different parts of
	the parent window at the same physical position on the screen.

	dupwin() creates an exact duplicate of the window win.

	wsyncup() causes a touchwin() of all of the window's parents.

	If wsyncok() is called with a second argument of TRUE, this
	causes a wsyncup() to be called every time the window is
	changed.

	wcursyncup() causes the current cursor position of all of a
	window's ancestors to reflect the current cursor position of the
	current window.

	wsyncdown() causes a touchwin() of the current window if any of
	its parent's windows have been touched.

	resize_window() allows the user to resize an existing window. It 
	returns the pointer to the new window, or NULL on failure.

	wresize() is an ncurses-compatible wrapper for resize_window().
	Note that, unlike ncurses, it will NOT process any subwindows of
	the window. (However, you still can call it _on_ subwindows.) It 
	returns OK or ERR.

	PDC_makenew() allocates all data for a new WINDOW * except the
	actual lines themselves. If it's unable to allocate memory for
	the window structure, it will free all allocated memory and
	return a NULL pointer.

	PDC_makelines() allocates the memory for the lines.

	PDC_sync() handles wrefresh() and wsyncup() calls when a window
	is changed.

  Return Value:
	newwin(), subwin(), derwin() and dupwin() return a pointer
	to the new window, or NULL on failure. delwin(), mvwin(),
	mvderwin() and syncok() return OK or ERR. wsyncup(),
	wcursyncup() and wsyncdown() return nothing.

  Errors:
	It is an error to call resize_window() before calling initscr().
	Also, an error will be generated if we fail to create a newly
	sized replacement window for curscr, or stdscr. This could
	happen when increasing the window size. NOTE: If this happens,
	the previously successfully allocated windows are left alone;
	i.e., the resize is NOT cancelled for those windows.

  Portability				     X/Open    BSD    SYS V
	newwin					Y	Y	Y
	delwin					Y	Y	Y
	mvwin					Y	Y	Y
	subwin					Y	Y	Y
	derwin					Y	-	Y
	mvderwin				Y	-	Y
	dupwin					Y	-      4.0
	wsyncup					Y	-      4.0
	syncok					Y	-      4.0
	wcursyncup				Y	-      4.0
	wsyncdown				Y	-      4.0
	resize_window				-	-	-
	wresize					-	-	-
	PDC_makelines				-	-	-
	PDC_makenew				-	-	-
	PDC_sync				-	-	-

**man-end****************************************************************/

#include <stdlib.h>

WINDOW *PDC_makenew(int nlines, int ncols, int begy, int begx)
{
	WINDOW *win;

	PDC_LOG(("PDC_makenew() - called: lines %d cols %d begy %d begx %d\n",
		nlines, ncols, begy, begx));

	/* allocate the window structure itself */

	if ((win = calloc(1, sizeof(WINDOW))) == (WINDOW *)NULL)
		return win;

	/* allocate the line pointer array */

	if ((win->_y = malloc(nlines * sizeof(chtype *))) == NULL)
	{
		free(win);
		return (WINDOW *)NULL;
	}

	/* allocate the minchng and maxchng arrays */

	if ((win->_firstch = malloc(nlines * sizeof(int))) == NULL)
	{
		free(win->_y);
		free(win);
		return (WINDOW *)NULL;
	}

	if ((win->_lastch = malloc(nlines * sizeof(int))) == NULL)
	{
		free(win->_firstch);
		free(win->_y);
		free(win);
		return (WINDOW *)NULL;
	}

	/* initialize window variables */

	win->_maxy = nlines;	/* real max screen size */
	win->_maxx = ncols;	/* real max screen size */
	win->_begy = begy;
	win->_begx = begx;
	win->_bkgd = ' '; /* wrs 4/10/93 -- initialize background to blank */
	win->_clear = (bool) ((nlines == LINES) && (ncols == COLS));
	win->_bmarg = nlines - 1;
	win->_parx = win->_pary = -1;

	/* init to say window all changed */

	touchwin(win);

	return win;
}

WINDOW *PDC_makelines(WINDOW *win)
{
	int i, j, nlines, ncols;

	PDC_LOG(("PDC_makelines() - called: lines %d cols %d\n",
		nlines, ncols));

	if (!win)
		return (WINDOW *)NULL;

	nlines = win->_maxy;
	ncols = win->_maxx;

	for (i = 0; i < nlines; i++)
	{
		if ((win->_y[i] = malloc(ncols * sizeof(chtype))) == NULL)
		{
			/* if error, free all the data */

			for (j = 0; j < i; j++)
				free(win->_y[j]);

			free(win->_firstch);
			free(win->_lastch);
			free(win->_y);
			free(win);

			return (WINDOW *)NULL;
		}
	}

	return win;
}

void PDC_sync(WINDOW *win)
{
	PDC_LOG(("PDC_sync() - called:\n"));

	if (win->_immed)
		wrefresh(win);
	if (win->_sync)
		wsyncup(win);
}

WINDOW *newwin(int nlines, int ncols, int begy, int begx)
{
	WINDOW *win;

	PDC_LOG(("newwin() - called:lines=%d cols=%d begy=%d begx=%d\n",
		nlines, ncols, begy, begx));

	if (!nlines)
		nlines = LINES - begy;
	if (!ncols)
		ncols  = COLS  - begx;

	if ((begy + nlines > SP->lines || begx + ncols > SP->cols)
	 || (win = PDC_makenew(nlines, ncols, begy, begx)) == (WINDOW *)NULL
	 || (win = PDC_makelines(win)) == (WINDOW *)NULL)
		return (WINDOW *)NULL;

	werase(win);

	return win;
}

int delwin(WINDOW *win)
{
	int i;

	PDC_LOG(("delwin() - called\n"));

	if (!win)
		return ERR;

	/* subwindows use parents' lines */

	if (!(win->_flags & (_SUBWIN|_SUBPAD)))
		for (i = 0; i < win->_maxy && win->_y[i]; i++)
			if (win->_y[i])
				free(win->_y[i]);

	free(win->_firstch);
	free(win->_lastch);
	free(win->_y);
	free(win);

	return OK;
}

int mvwin(WINDOW *win, int y, int x)
{
	PDC_LOG(("mvwin() - called\n"));

	if (!win
	   || (y + win->_maxy > LINES || y < 0)
	   || (x + win->_maxx > COLS || x < 0))
		return ERR;

	win->_begy = y;
	win->_begx = x;
	touchwin(win);

	return OK;
}

WINDOW *subwin(WINDOW *orig, int nlines, int ncols, int begy, int begx)
{
	WINDOW *win;
	int i;
	int j = begy - orig->_begy;
	int k = begx - orig->_begx;

	PDC_LOG(("subwin() - called: lines %d cols %d begy %d begx %d\n",
		nlines, ncols, begy, begx));

	/* make sure window fits inside the original one */

	if (!orig || (begy < orig->_begy) || (begx < orig->_begx) ||
	    (begy + nlines) > (orig->_begy + orig->_maxy) ||
	    (begx + ncols) > (orig->_begx + orig->_maxx))
		return (WINDOW *)NULL;

	if (!nlines)
		nlines = orig->_maxy - 1 - j;
	if (!ncols)
		ncols  = orig->_maxx - 1 - k;

	if ((win = PDC_makenew(nlines, ncols, begy, begx)) == (WINDOW *)NULL)
		return (WINDOW *)NULL;

	/* initialize window variables */

	win->_attrs	= orig->_attrs;
	win->_bkgd	= orig->_bkgd;
	win->_leaveit	= orig->_leaveit;
	win->_scroll	= orig->_scroll;
	win->_nodelay	= orig->_nodelay;
	win->_use_keypad = orig->_use_keypad;
	win->_immed	= orig->_immed;
	win->_sync	= orig->_sync;
	win->_pary	= j;
	win->_parx	= k;
	win->_parent	= orig;

	for (i = 0; i < nlines; i++, j++)
		win->_y[i] = orig->_y[j] + k;

	win->_flags |= _SUBWIN;

	return win;
}

WINDOW *derwin(WINDOW *orig, int nlines, int ncols, int begy, int begx)
{
	return subwin(orig, nlines, ncols, begy + orig->_begy,
		begx + orig->_begx);
}

int mvderwin(WINDOW *win, int pary, int parx)
{
	int i, j;
	WINDOW *mypar;

	if (!win || !(win->_parent))
		return ERR;

	mypar = win->_parent;

	if (pary < 0 || parx < 0 ||
	    (pary + win->_maxy) > mypar->_maxy ||
	    (parx + win->_maxx) > mypar->_maxx)
		return ERR;

	j = pary;

	for (i = 0; i < win->_maxy; i++)
		win->_y[i] = (mypar->_y[j++]) + parx;

	win->_pary = pary;
	win->_parx = parx;

	return OK;
}

WINDOW *dupwin(WINDOW *win)
{
	WINDOW *new;
	chtype *ptr, *ptr1;
	int nlines, ncols, begy, begx, i;

	if (!win)
		return (WINDOW *)NULL;

	nlines	= win->_maxy;
	ncols	= win->_maxx;
	begy	= win->_begy;
	begx	= win->_begx;

	if ((new = PDC_makenew(nlines, ncols, begy, begx)) == (WINDOW *)NULL
	 || (new = PDC_makelines(new)) == (WINDOW *)NULL)
		return (WINDOW *)NULL;

	/* copy the contents of win into new */

	for (i = 0; i < nlines; i++)
	{
		for (ptr = new->_y[i], ptr1 = win->_y[i];
		     ptr < new->_y[i] + ncols; ptr++, ptr1++)
			*ptr = *ptr1;

		new->_firstch[i] = 0;
		new->_lastch[i] = ncols - 1;
	}

	new->_curx = win->_curx;
	new->_cury = win->_cury;
	new->_maxy = win->_maxy;
	new->_maxx = win->_maxx;
	new->_begy = win->_begy;
	new->_begx = win->_begx;
	new->_flags = win->_flags;
	new->_attrs = win->_attrs;
	new->_clear = win->_clear;
	new->_leaveit = win->_leaveit;
	new->_scroll = win->_scroll;
	new->_nodelay = win->_nodelay;
	new->_use_keypad = win->_use_keypad;
	new->_tmarg = win->_tmarg;
	new->_bmarg = win->_bmarg;
	new->_parx = win->_parx;
	new->_pary = win->_pary;
	new->_parent = win->_parent;
	new->_bkgd = win->_bkgd;
	new->_flags = win->_flags;

	return new;

}

WINDOW *resize_window(WINDOW *win, int nlines, int ncols)
{
	WINDOW *new;
	int i, save_cury, save_curx, new_begy, new_begx;

	PDC_LOG(("resize_window() - called: nlines %d ncols %d\n",
		nlines, ncols));

	if (!win)
		return (WINDOW *)NULL;

	if (win->_flags & _SUBPAD)
	{
		if ((new = subpad(win->_parent, nlines, ncols,
		     win->_begy, win->_begx)) == (WINDOW *)NULL)
			return (WINDOW *)NULL;
	}
	else if (win->_flags & _SUBWIN)
	{
		if ((new = subwin(win->_parent, nlines, ncols,
		     win->_begy, win->_begx)) == (WINDOW *)NULL)
			return (WINDOW *)NULL;
	}
	else
	{
		if (win == SP->slk_winptr)
		{
			new_begy = SP->lines - SP->slklines;
			new_begx = 0;
		}
		else
		{
			new_begy = win->_begy;
			new_begx = win->_begx;
		}

		if ((new = PDC_makenew(nlines, ncols, new_begy, 
		     new_begx)) == (WINDOW *)NULL)
			return (WINDOW *)NULL;
	}

	save_curx = min(win->_curx, new->_maxx);
	save_cury = min(win->_cury, new->_maxy);

	if (!(win->_flags & (_SUBPAD|_SUBWIN)))
	{
		if ((new = PDC_makelines(new)) == (WINDOW *)NULL)
			return (WINDOW *)NULL;

		werase(new);

		copywin(win, new, 0, 0, 0, 0, min(win->_maxy, new->_maxy) - 1,
			min(win->_maxx, new->_maxx) - 1, FALSE);

		for (i = 0; i < win->_maxy && win->_y[i]; i++)
			if (win->_y[i])
				free(win->_y[i]);
	}

	new->_flags = win->_flags;
	new->_attrs = win->_attrs;
	new->_clear = win->_clear;
	new->_leaveit = win->_leaveit;
	new->_scroll = win->_scroll;
	new->_nodelay = win->_nodelay;
	new->_use_keypad = win->_use_keypad;
	new->_tmarg = (win->_tmarg > new->_maxy - 1) ? 0 : win->_tmarg;
	new->_bmarg = (win->_bmarg == win->_maxy - 1) ?
		new->_maxy - 1 : min(win->_bmarg, (new->_maxy - 1));
	new->_parent = win->_parent;
	new->_immed = win->_immed;
	new->_sync = win->_sync;
	new->_bkgd = win->_bkgd;

	new->_curx = save_curx;
	new->_cury = save_cury;

	free(win->_firstch);
	free(win->_lastch);
	free(win->_y);

	*win = *new;
	free(new);

	return win;
}

int wresize(WINDOW *win, int nlines, int ncols)
{
	return (resize_window(win, nlines, ncols) ? OK : ERR);
}

void wsyncup(WINDOW *win)
{
	WINDOW *tmp;

	PDC_LOG(("wsyncup() - called\n"));

	for (tmp = win; tmp; tmp = tmp->_parent)
		touchwin(tmp);
}

int syncok(WINDOW *win, bool bf)
{
	PDC_LOG(("syncok() - called\n"));

	if (!win)
		return ERR;

	win->_sync = bf;

	return OK;
}

void wcursyncup(WINDOW *win)
{
	WINDOW *tmp;

	PDC_LOG(("wcursyncup() - called\n"));

	for (tmp = win; tmp && tmp->_parent; tmp = tmp->_parent)
		wmove(tmp->_parent, tmp->_pary + tmp->_cury,
			tmp->_parx + tmp->_curx);
}

void wsyncdown(WINDOW *win)
{
	WINDOW *tmp;

	PDC_LOG(("wsyncdown() - called\n"));

	for (tmp = win; tmp; tmp = tmp->_parent)
	{
		if (is_wintouched(tmp))
		{
			touchwin(win);
			break;
		}
	}
}

Bell Labs OSI certified Powered by Plan 9

(Return to Plan 9 Home Page)

Copyright © 2021 Plan 9 Foundation. All Rights Reserved.
Comments to [email protected].