/************************************************************************ 
 * 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: kernel.c,v 1.74 2007/06/14 14:11:30 wmcbrine Exp $")

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

  Name:								kernel

  Synopsis:
	int def_prog_mode(void);
	int def_shell_mode(void);
	int reset_prog_mode(void);
	int reset_shell_mode(void);
	int resetty(void);
	int savetty(void);
	void getsyx(int y, int x);
	void setsyx(int y, int x);
	int ripoffline(int line, int (*init)(WINDOW *, int));
	int curs_set(int visibility);
	int napms(int ms);

	int draino(int ms);
	int resetterm(void);
	int fixterm(void);
	int saveterm(void);

  Description:
	def_prog_mode() and def_shell_mode() save the current terminal
	modes as the "program" (in curses) or "shell" (not in curses)
	state for use by the reset_prog_mode() and reset_shell_mode()
	functions.  This is done automatically by initscr().

	reset_prog_mode() and reset_shell_mode() restore the terminal to
	"program" (in curses) or "shell" (not in curses) state.  These
	are done automatically by endwin() and doupdate() after an
	endwin(), so they would normally not be called before these
	functions.

	savetty() and resetty() save and restore the state of the
	terminal modes. savetty() saves the current state in a buffer,
	and resetty() restores the state to what it was at the last call
	to savetty().

	getsyx() obtains the coordinates of the virtual screen cursor.
	If leaveok() is currently TRUE, then -1, -1 is returned. If
	lines have been removed from the top of the screen with
	ripoffline(), then getsyx() includes those lines, so y and x
	should only be used by setyx(). setyx() sets the cursor position
	of the virtual screen to the y,x coordinates. If y, x are -1,
	-1, leaveok() is set TRUE. The getsyx() and setsyx() routines
	are designed to be used by a library routine that manipulates
	curses windows, but does not want to change the position of the
	cursor.

	Note that getsyx() and setsyx() are defined as macros only.

	curs_set() alters the appearance of the text cursor. A value of
	0 for visibility makes the cursor disappear; a value of 1 makes
	the cursor appear "normal" (usually an underline) and 2 makes
	the cursor "highly visible" (usually a block).

	ripoffline() allows the user to reduce the size of stdscr by 1
	line.  If the value of line is positive, the line is removed
	from the top of the screen; negative from the bottom. Up to 5
	lines can be ripped off stdscr by calling ripoffline()
	consecutively. The function argument, init, is called from
	within initscr() or newterm(), so ripoffline() must be called
	before either of these functions.  The init function is passed a
	pointer to a 1 line WINDOW, and the width of the window. Calling
	ripoffline() with a NULL initialise function pointer is not
	advised.

	The napms() function suspends the program for the specified
	number of milliseconds. draino() is an archaic equivalent.

	FYI: It is unclear whether savetty() and resetty() are meant to
	duplicate reset_prog_mode() and reset_shell_mode(), or be a
	backing store type of operation. At this time, they're
	implemented similarly to the reset_*_mode() routines.

	resetterm(), fixterm() and saveterm() are archaic equivalents
	for reset_shell_mode(), reset_prog_mode() and def_prog_mode(),
	respectively.

  Return Value:
	All functions return OK on success and ERR on error, except
	curs_set(), which returns the previous visibility.

  Portability				     X/Open    BSD    SYS V
	def_prog_mode				Y	Y	Y
	def_shell_mode				Y	Y	Y
	reset_prog_mode				Y	Y	Y
	reset_shell_mode			Y	Y	Y
	resetty					Y	Y	Y
	savetty					Y	Y	Y
	getsyx					-	-      3.0
	setsyx					-	-      3.0
	ripoffline				Y	-      3.0
	curs_set				Y	-      3.0
	napms					Y	Y	Y
	draino					-
	resetterm				-
	fixterm					-
	saveterm				-

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

#include <string.h>

RIPPEDOFFLINE linesripped[5];
char linesrippedoff = 0;

static struct cttyset
{
        bool    been_set;
        SCREEN  saved;
} ctty[3];

enum { PDC_SH_TTY, PDC_PR_TTY, PDC_SAVE_TTY };

static void _save_mode(int i)
{
	ctty[i].been_set = TRUE;

	memcpy(&(ctty[i].saved), SP, sizeof(SCREEN));

	PDC_save_screen_mode(i);
}

static int _restore_mode(int i)
{
	if (ctty[i].been_set == TRUE)
	{
		memcpy(SP, &(ctty[i].saved), sizeof(SCREEN));

		if (ctty[i].saved.raw_out)
			raw();

		PDC_restore_screen_mode(i);

		if ((LINES != ctty[i].saved.lines) ||
		    (COLS != ctty[i].saved.cols))
			resize_term(ctty[i].saved.lines, ctty[i].saved.cols);

		PDC_curs_set(ctty[i].saved.visibility);

		PDC_gotoyx(ctty[i].saved.cursrow, ctty[i].saved.curscol);
	}

	return ctty[i].been_set ? OK : ERR;
}

int def_prog_mode(void)
{
	PDC_LOG(("def_prog_mode() - called\n"));

	_save_mode(PDC_PR_TTY);

	return OK;
}

int def_shell_mode(void)
{
	PDC_LOG(("def_shell_mode() - called\n"));

	_save_mode(PDC_SH_TTY);

	return OK;
}

int reset_prog_mode(void)
{
	PDC_LOG(("reset_prog_mode() - called\n"));

	_restore_mode(PDC_PR_TTY);
	PDC_reset_prog_mode();

	return OK;
}

int reset_shell_mode(void)
{
	PDC_LOG(("reset_shell_mode() - called\n"));

	_restore_mode(PDC_SH_TTY);
	PDC_reset_shell_mode();

	return OK;
}

int resetty(void)
{
	PDC_LOG(("resetty() - called\n"));

	return _restore_mode(PDC_SAVE_TTY);
}

int savetty(void)
{
	PDC_LOG(("savetty() - called\n"));

	_save_mode(PDC_SAVE_TTY);

	return OK;
}

int curs_set(int visibility)
{
	int ret_vis;

	PDC_LOG(("curs_set() - called: visibility=%d\n", visibility));

	if ((visibility < 0) || (visibility > 2))
		return ERR;

	ret_vis = PDC_curs_set(visibility);

	/* If the cursor is changing from invisible to visible, update 
	   its position */

	if (visibility && !ret_vis)
		PDC_gotoyx(SP->cursrow, SP->curscol);

	return ret_vis;
}

int napms(int ms)
{
	PDC_LOG(("napms() - called: ms=%d\n", ms));

	if (ms)
		PDC_napms(ms);

	return OK;
}

int ripoffline(int line, int (*init)(WINDOW *, int))
{
	PDC_LOG(("ripoffline() - called: line=%d\n", line));

	if (linesrippedoff < 5 && line)
	{
		linesripped[(int)linesrippedoff].line = line;
		linesripped[(int)linesrippedoff++].init = init;
	}

	return OK;
}

int draino(int ms)
{
	PDC_LOG(("draino() - called\n"));

	return napms(ms);
}

int resetterm(void)
{
	PDC_LOG(("resetterm() - called\n"));

	return reset_shell_mode();
}

int fixterm(void)
{
	PDC_LOG(("fixterm() - called\n"));

	return reset_prog_mode();
}

int saveterm(void)
{
	PDC_LOG(("saveterm() - called\n"));

	return def_prog_mode();
}