/*
 * |-----------------------------------------------------------|
 * | Copyright (c) 1991, 1990 MIPS Computer Systems, Inc.      |
 * | All Rights Reserved                                       |
 * |-----------------------------------------------------------|
 * |          Restricted Rights Legend                         |
 * | Use, duplication, or disclosure by the Government is      |
 * | subject to restrictions as set forth in                   |
 * | subparagraph (c)(1)(ii) of the Rights in Technical        |
 * | Data and Computer Software Clause of DFARS 252.227-7013.  |
 * |         MIPS Computer Systems, Inc.                       |
 * |         950 DeGuigne Avenue                               |
 * |         Sunnyvale, California 94088-3650, USA             |
 * |-----------------------------------------------------------|
 */
#ident	"$Header: output.c,v 1.8.2.1 92/06/24 13:43:28 marker Exp $"

/*
 * High level routines dealing with the output to the screen.
 */

#include "less.h"

public int errmsgs;	/* Count of messages displayed by error() */

extern int sigs;
extern int sc_width, sc_height;
extern int ul_width, ue_width;
extern int so_width, se_width;
extern int bo_width, be_width;
extern int tabstop;
extern int twiddle;
extern int any_display;
extern WCHAR_T *line;
extern char *first_cmd;
extern WCHAR_T w_mesg[];
extern short bufflag[];
extern int bs_mode;
#define BUFSIZ 1024

/*
 * Display the line which is in the line buffer.
 */
	public void
put_line()
{
	register WCHAR_T *p;
	register short   *flag;
	register int c;
	register int column;
	extern int auto_wrap, ignaw;
	WCHAR_T  NULL_LINE[2];

	if (sigs)
		/*
		 * Don't output if a signal is pending.
		 */
		return;

	if (line == NULL) {
	        NULL_LINE[1] = '\0';
		NULL_LINE[0] = (twiddle) ? 0176 : 0;
		line = NULL_LINE;
	}

	column = 0;
	for (p = line,flag = bufflag;  *p != '\0';  p++,flag++)
	{
	        if (*flag == KEY) {
		switch (c = *p)
		{
		case UL_CHAR:
			ul_enter();
			column += ul_width;
			break;
		case UE_CHAR:
			ul_exit();
			column += ue_width;
			break;
		case BO_CHAR:
			bo_enter();
			column += bo_width;
			break;
		case BE_CHAR:
			bo_exit();
			column += be_width;
			break;
		      }
	      }
		else {
		switch (c = *p)
		{
		case '\t':
			do
			{
				putchr(' ');
				column++;
			} while ((column % tabstop) != 0);
			break;
		case '\b':
			if (bs_mode != BS_CONTROL) 
			     { /* bs_mode == BS_SPECIAL && flag == DATA, 
				* output a real backspace */
			putbs();
			column--;
			break;
				/* if bs_mode == BS_CONTROL && flag == DATA,
				 * goto default print a control char "^H" */
		        }
		default:
			if (control_char(c))        
			{
				/*
				 * Control characters arrive here as the
				 * normal character [carat_char(c)] with
				 * the 0200 bit set.  See pappend().
				 */
				putchr('^');
				putchr(carat_char(c));
				column += 2;
			} else
			{
				putchr(c);
				column += scrwidth(c);
			}
	           }
	      }
	}
	if (column < sc_width || !auto_wrap || ignaw)
		putchr('\n');
}

/*
 * Is a given character a "control" character?
 * {{ ASCII DEPENDENT }}
 */
	public int
control_char(c)
	int c;
{
	return (((c > 0) && (c < ' ')) || c == '\177');
}

/*
 * Return the printable character used to identify a control character
 * (printed after a carat; e.g. '\3' => "^C").
 * {{ ASCII DEPENDENT }}
 */
	public int
carat_char(c)
	int c;
{
	return ((c == '\177') ? '?' : ((c | 0100) & 0x7F));
}


static WCHAR_T obuf[1024];
static WCHAR_T *ob = obuf;

/*
 * Flush buffered output.
 */
	public void
flush()
{
        writewchar(obuf, ob-obuf);
	ob = obuf;
}

/*
 * Discard buffered output.
 */
	public void
dropout()
{
	ob = obuf;
}

/*
 * Output a character.
 */
	public void
putchr(c)
	int c;
{
	if (ob >= obuf + BUFSIZ)
		flush();
	*ob++ = c;
}

/*
 * Output a string.
 */
	public void
putstr(s)
	register WCHAR_T *s;
{
	while (*s != '\0')
		putchr(*s++);
}

/*
 * Output a message in the lower left corner of the screen
 * and wait for carriage return.
 */

static char return_to_continue[] = "  (press RETURN)";

	public void
error(s)
	char *s;
{
	register int c;
	static char buf[2];

	errmsgs++;
	if (!any_display)
	{
		/*
		 * Nothing has been displayed yet.
		 * Output this message on error output (file
		 * descriptor 2) and don't wait for a keystroke
		 * to continue.
		 *
		 * This has the desirable effect of producing all
		 * error messages on error output if standard output
		 * is directed to a file.  It also does the same if
		 * we never produce any real output; for example, if
		 * the input file(s) cannot be opened.  If we do
		 * eventually produce output, code in edit() makes
		 * sure these messages can be seen before they are
		 * overwritten or scrolled away.
		 */
		write(2, s, strlen(s));
		write(2, "\n", 1);
		return;
	}

	lower_left();
	clear_eol();
	so_enter();
	putstr(strtows(w_mesg,s));
	putstr(strtows(w_mesg,return_to_continue));
	so_exit();

#if ONLY_RETURN
	while ((c = getchr()) != '\n' && c != '\r')
		bell();
#else
	c = getchr();
	if (c != '\n' && c != '\r' && c != ' ')
	{
		buf[0] = c;
		first_cmd = buf;
	}
#endif
	lower_left();

	if (strlen(s) + sizeof(return_to_continue) + 
		so_width + se_width + 1 > sc_width)
		/*
		 * Printing the message has probably scrolled the screen.
		 * {{ Unless the terminal doesn't have auto margins,
		 *    in which case we just hammered on the right margin. }}
		 */
		repaint();

	flush();
}


writewchar(wstr, n)
WCHAR_T  *wstr;
int      n;
{
   WCHAR_T     temp1[BUFSIZ];
   char        temp2[4*BUFSIZ];
  
   wsncpy(temp1, wstr, n);
   temp1[n] = '\0';
   wstostr(temp2, temp1);
   write(1, temp2, strlen(temp2));
 }
