Subversion Repositories HelenOS

/*	$OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray Exp $	*/

/*	$NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft Exp $	*/

/*-

 * Copyright (c) 1992, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Chris Torek and Darren F. Provine.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *	@(#)screen.c	8.1 (Berkeley) 5/31/93

 */

/*

 * Tetris screen control.

 */

#include <sys/ioctl.h>

#include <err.h>

//#include <setjmp.h>

//#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <term.h>

#include <termios.h>

#include <unistd.h>

#include "screen.h"

#include "tetris.h"

static cell curscreen[B_SIZE];	/* 1 => standout (or otherwise marked) */

static int curscore;

static int isset;		/* true => terminal is in game mode */

static struct termios oldtt;

static void (*tstp)(int);

static void	scr_stop(int);

static void	stopset(int);

/*

 * Capabilities from TERMCAP.

 */

char	PC, *BC, *UP;		/* tgoto requires globals: ugh! */

static char

	*bcstr,			/* backspace char */

	*CEstr,			/* clear to end of line */

	*CLstr,			/* clear screen */

	*CMstr,			/* cursor motion string */

#ifdef unneeded

	*CRstr,			/* "\r" equivalent */

#endif

	*HOstr,			/* cursor home */

	*LLstr,			/* last line, first column */

	*pcstr,			/* pad character */

	*TEstr,			/* end cursor motion mode */

	*TIstr;			/* begin cursor motion mode */

char

	*SEstr,			/* end standout mode */

	*SOstr;			/* begin standout mode */

static int

	COnum,			/* co# value */

	LInum,			/* li# value */

	MSflag;			/* can move in standout mode */

struct tcsinfo {		/* termcap string info; some abbrevs above */

	char tcname[3];

	char **tcaddr;

} tcstrings[] = {

	{"bc", &bcstr},

	{"ce", &CEstr},

	{"cl", &CLstr},

	{"cm", &CMstr},

#ifdef unneeded

	{"cr", &CRstr},

#endif

	{"le", &BC},		/* move cursor left one space */

	{"pc", &pcstr},

	{"se", &SEstr},

	{"so", &SOstr},

	{"te", &TEstr},

	{"ti", &TIstr},

	{"up", &UP},		/* cursor up */

	{ {0}, NULL}

};

/* This is where we will actually stuff the information */

static char combuf[1024], tbuf[1024];

/*

 * Routine used by tputs().

 */

int

put(int c)

{

	return (putchar(c));

}

/*

 * putstr() is for unpadded strings (either as in termcap(5) or

 * simply literal strings); putpad() is for padded strings with

 * count=1.  (See screen.h for putpad().)

 */

#define	putstr(s)	(void)fputs(s, stdout)

#define	moveto(r, c)	putpad(tgoto(CMstr, c, r))

/*

 * Set up from termcap.

 */

void

scr_init(void)

{

	static int bsflag, xsflag, sgnum;

#ifdef unneeded

	static int ncflag;

#endif

	char *term, *fill;

	static struct tcninfo {	/* termcap numeric and flag info */

		char tcname[3];

		int *tcaddr;

	} tcflags[] = {

		{"bs", &bsflag},

		{"ms", &MSflag},

#ifdef unneeded

		{"nc", &ncflag},

#endif

		{"xs", &xsflag},

		{ {0}, NULL}

	}, tcnums[] = {

		{"co", &COnum},

		{"li", &LInum},

		{"sg", &sgnum},

		{ {0}, NULL}

	};

	if ((term = getenv("TERM")) == NULL)

		stop("you must set the TERM environment variable");

	if (tgetent(tbuf, term) <= 0)

		stop("cannot find your termcap");

	fill = combuf;

	{

		struct tcsinfo *p;

		for (p = tcstrings; p->tcaddr; p++)

			*p->tcaddr = tgetstr(p->tcname, &fill);

	}

	if (classic)

		SOstr = SEstr = NULL;

	{

		struct tcninfo *p;

		for (p = tcflags; p->tcaddr; p++)

			*p->tcaddr = tgetflag(p->tcname);

		for (p = tcnums; p->tcaddr; p++)

			*p->tcaddr = tgetnum(p->tcname);

	}

	if (bsflag)

		BC = "\b";

	else if (BC == NULL && bcstr != NULL)

		BC = bcstr;

	if (CLstr == NULL)

		stop("cannot clear screen");

	if (CMstr == NULL || UP == NULL || BC == NULL)

		stop("cannot do random cursor positioning via tgoto()");

	PC = pcstr ? *pcstr : 0;

	if (sgnum > 0 || xsflag)

		SOstr = SEstr = NULL;

#ifdef unneeded

	if (ncflag)

		CRstr = NULL;

	else if (CRstr == NULL)

		CRstr = "\r";

#endif

}

/* this foolery is needed to modify tty state `atomically' */

//static jmp_buf scr_onstop;

/* static void */

/* stopset(int sig) */

/* { */

/* 	sigset_t sigset; */

/* 	(void) signal(sig, SIG_DFL); */

/* 	(void) kill(getpid(), sig); */

/* 	sigemptyset(&sigset); */

/* 	sigaddset(&sigset, sig); */

/* 	(void) sigprocmask(SIG_UNBLOCK, &sigset, (sigset_t *)0); */

/* 	longjmp(scr_onstop, 1); */

/* } */

static void

scr_stop(int sig)

{

//	sigset_t sigset;

	scr_end();

/* 	(void) kill(getpid(), sig); */

/* 	sigemptyset(&sigset); */

/* 	sigaddset(&sigset, sig); */

/* 	(void) sigprocmask(SIG_UNBLOCK, &sigset, (sigset_t *)0); */

	scr_set();

	scr_msg(key_msg, 1);

}

/*

 * Set up screen mode.

 */

void

scr_set(void)

{

	struct winsize ws;

	struct termios newtt;

//	sigset_t sigset, osigset;

	void (*ttou)(int);

/* 	sigemptyset(&sigset); */

/* 	sigaddset(&sigset, SIGTSTP); */

/* 	sigaddset(&sigset, SIGTTOU); */

/* 	(void) sigprocmask(SIG_BLOCK, &sigset, &osigset); */

/* 	if ((tstp = signal(SIGTSTP, stopset)) == SIG_IGN) */

/* 		(void) signal(SIGTSTP, SIG_IGN); */

/* 	if ((ttou = signal(SIGTTOU, stopset)) == SIG_IGN) */

/* 		(void) signal(SIGTTOU, SIG_IGN); */

/* 	/\* */

/* 	 * At last, we are ready to modify the tty state.  If */

/* 	 * we stop while at it, stopset() above will longjmp back */

/* 	 * to the setjmp here and we will start over. */

/* 	 *\/ */

/* 	(void) setjmp(scr_onstop); */

/* 	(void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0); */

	Rows = 0, Cols = 0;

	if (ioctl(0, TIOCGWINSZ, &ws) == 0) {

		Rows = ws.ws_row;

		Cols = ws.ws_col;

	}

	if (Rows == 0)

		Rows = LInum;

	if (Cols == 0)

	Cols = COnum;

	if (Rows < MINROWS || Cols < MINCOLS) {

		char smallscr[55];

		(void)snprintf(smallscr, sizeof(smallscr),

		    "the screen is too small (must be at least %dx%d)",

		    MINROWS, MINCOLS);

		stop(smallscr);

	}

	if (tcgetattr(0, &oldtt) < 0)

		stop("tcgetattr() fails");

	newtt = oldtt;

	newtt.c_lflag &= ~(ICANON|ECHO);

	newtt.c_oflag &= ~OXTABS;

	if (tcsetattr(0, TCSADRAIN, &newtt) < 0)

		stop("tcsetattr() fails");

/* 	(void) sigprocmask(SIG_BLOCK, &sigset, &osigset); */

	/*

	 * We made it.  We are now in screen mode, modulo TIstr

	 * (which we will fix immediately).

	 */

	if (TIstr)

		putstr(TIstr);	/* termcap(5) says this is not padded */

/* 	if (tstp != SIG_IGN) */

/* 		(void) signal(SIGTSTP, scr_stop); */

/* 	if (ttou != SIG_IGN) */

/* 		(void) signal(SIGTTOU, ttou); */

	isset = 1;

//	(void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0);

	scr_clear();

}

/*

 * End screen mode.

 */

void

scr_end(void)

{

//	sigset_t sigset, osigset;

/* 	sigemptyset(&sigset); */

/* 	sigaddset(&sigset, SIGTSTP); */

/* 	sigaddset(&sigset, SIGTTOU); */

/* 	(void) sigprocmask(SIG_BLOCK, &sigset, &osigset); */

	/* move cursor to last line */

	if (LLstr)

		putstr(LLstr);	/* termcap(5) says this is not padded */

	else

		moveto(Rows - 1, 0);

	/* exit screen mode */

	if (TEstr)

		putstr(TEstr);	/* termcap(5) says this is not padded */

//	(void) fflush(stdout);

	(void) tcsetattr(0, TCSADRAIN, &oldtt);

	isset = 0;

	/* restore signals */

/* 	(void) signal(SIGTSTP, tstp); */

/* 	(void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0); */

}

void

stop(char *why)

{

	if (isset)

		scr_end();

	errx(1, "aborting: %s", why);

}

/*

 * Clear the screen, forgetting the current contents in the process.

 */

void

scr_clear(void)

{

	putpad(CLstr);

	curscore = -1;

	memset((char *)curscreen, 0, sizeof(curscreen));

}

#if vax && !__GNUC__

typedef int regcell;	/* pcc is bad at `register char', etc */

#else

typedef cell regcell;

#endif

/*

 * Update the screen.

 */

void

scr_update(void)

{

	cell *bp, *sp;

	regcell so, cur_so = 0;

	int i, ccol, j;

//	sigset_t sigset, osigset;

	static const struct shape *lastshape;

/* 	sigemptyset(&sigset); */

/* 	sigaddset(&sigset, SIGTSTP); */

/* 	(void) sigprocmask(SIG_BLOCK, &sigset, &osigset); */

	/* always leave cursor after last displayed point */

	curscreen[D_LAST * B_COLS - 1] = -1;

	if (score != curscore) {

		if (HOstr)

			putpad(HOstr);

		else

			moveto(0, 0);

		(void) printf("Score: %d", score);

		curscore = score;

	}

	/* draw preview of next pattern */

	if (showpreview && (nextshape != lastshape)) {

		int i;

		static int r=5, c=2;

		int tr, tc, t;

		lastshape = nextshape;

		/* clean */

		putpad(SEstr);

		moveto(r-1, c-1); putstr("          ");

		moveto(r,   c-1); putstr("          ");

		moveto(r+1, c-1); putstr("          ");

		moveto(r+2, c-1); putstr("          ");

		moveto(r-3, c-2);

		putstr("Next shape:");

		/* draw */

		if (SOstr)

			putpad(SOstr);

		moveto(r, 2 * c);

		putstr(SOstr ? "  " : "[]");

		for (i = 0; i < 3; i++) {

			t = c + r * B_COLS;

			t += nextshape->off[i];

			tr = t / B_COLS;

			tc = t % B_COLS;

			moveto(tr, 2*tc);

			putstr(SOstr ? "  " : "[]");

		}

		putpad(SEstr);

	}

	bp = &board[D_FIRST * B_COLS];

	sp = &curscreen[D_FIRST * B_COLS];

	for (j = D_FIRST; j < D_LAST; j++) {

		ccol = -1;

		for (i = 0; i < B_COLS; bp++, sp++, i++) {

			if (*sp == (so = *bp))

				continue;

			*sp = so;

			if (i != ccol) {

				if (cur_so && MSflag) {

					putpad(SEstr);

					cur_so = 0;

				}

				moveto(RTOD(j), CTOD(i));

			}

			if (SOstr) {

				if (so != cur_so) {

					putpad(so ? SOstr : SEstr);

					cur_so = so;

				}

				putstr("  ");

			} else

				putstr(so ? "[]" : "  ");

			ccol = i + 1;

			/*

			 * Look ahead a bit, to avoid extra motion if

			 * we will be redrawing the cell after the next.

			 * Motion probably takes four or more characters,

			 * so we save even if we rewrite two cells

			 * `unnecessarily'.  Skip it all, though, if

			 * the next cell is a different color.

			 */

#define	STOP (B_COLS - 3)

			if (i > STOP || sp[1] != bp[1] || so != bp[1])

				continue;

			if (sp[2] != bp[2])

				sp[1] = -1;

			else if (i < STOP && so == bp[2] && sp[3] != bp[3]) {

				sp[2] = -1;

				sp[1] = -1;

			}

		}

	}

	if (cur_so)

		putpad(SEstr);

/* 	(void) fflush(stdout); */

/* 	(void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0); */

}

/*

 * Write a message (set!=0), or clear the same message (set==0).

 * (We need its length in case we have to overwrite with blanks.)

 */

void

scr_msg(char *s, int set)

{

	if (set || CEstr == NULL) {

		int l = strlen(s);

		moveto(Rows - 2, ((Cols - l) >> 1) - 1);

		if (set)

			putstr(s);

		else

			while (--l >= 0)

				(void) putchar(' ');

	} else {

		moveto(Rows - 2, 0);

		putpad(CEstr);

	}

}