/*
 * TNT interface for GNU Emacs.
 *
 * Author: 	Chris Maio
 * Modified:	Don Hopkins
 * Last edit:	May 30 1991
 */

#include <signal.h>
#include "config.h"

#ifdef HAVE_TNT
/* #include <wire/wire.h> */
#include <wire/wire.h>
#include "tnt_cps.h"			/* generated from tnt_cps.cps */
#undef NULL

#ifndef makedev
#include <sys/types.h>
#endif
#include "lisp.h"
#include "dispextern.h"
#include "termopts.h"
#include "termchar.h"
#include "termhooks.h"
#include "window.h"
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/errno.h>

static int
    blockinputmask,			/* sigblock mask */
    scrollregion,			/* 0 or bottom of scroll region */
    SavedX, SavedY, VisibleX, VisibleY,	/* our notion of cursor postition */
    updating,				/* 1 => inside update_screen */
    repaint,				/* 1 => screen repaint requested */
    highlight,				/* 1 => use inverse video */
    mapped,				/* 1 => window is mapped */
    keepalive,				/* <0 => window probably dead */
    outputstarted,			/* StartPS recursion depth */
    cursordown,				/* 1 => cursor is visible */
    nextevent,				/* next index into event queue */
    eventindex,				/* current index */
    eventcount,				/* count of pending events  */
    sbufstart, sbufend,			/* start, end of sbuf */
    ps_rows, ps_cols;			/* rows and columns of text */

static wire_Wire wire;

int ps_fix_screen (),			/* handle screen updates */
    ps_move_cursor (),			/* update cursor location */
    ps_clear_screen (),			/* clear the canvas */
    ps_clear_end_of_line (),		/* clear to end of line */
    ps_ins_del_lines (),		/* insert/delete lines with copyarea */
    ps_insert_chars (),			/* this hurts */
    ps_delete_chars (),			/* so does this */
    ps_output_chars (),			/* raw character output */
    ps_change_line_highlight (),	/* flip foreground/background colors */
    ps_reassert_line_highlight ();	/* " */
    ps_feep (),				/* ring the bell */
    ps_reset_terminal_modes (),		/* do nothing */
    ps_set_terminal_modes (),		/* do nothing */
    ps_update_begin (),			/* buffer output */
    ps_update_end (),			/* flush output */
    ps_set_terminal_window (),		/* set scroll region */
    ps_read_socket ();			/* input handler */

#define min(a,b) ((a)<(b) ? (a) : (b))
#define max(a,b) ((a)>(b) ? (a) : (b))

#ifndef sigmask
#define sigmask(no) (1L << ((no) - 1))
#endif

/*
 * If ps-fix-screen is called more than this many times without doing
 * any real output, we poke the connection to see if it is still alive.
 * This tickle function is what's responsible for the occasional cursor
 * toggle you may notice in an otherwise idle window.
 */
int KEEPALIVE_THRESHHOLD = 10;

assert (i)
     int i;
{ return 0; }

/*
 * StartPS and EndPS should be used around any output calls, to take
 * care of buffering output, lifting the cursor, and protecting the
 * wire library from SIGIO interrupts.
 */

StartPS ()
{
    if (cursordown)
	togglecursor ();		/* make sure cursor is protected */
    if (!updating && outputstarted == 0)
	    blockinputmask = sigblock (sigmask (SIGIO));
    ++outputstarted;
}

EndPS ()
{
    if (--outputstarted < 1)
	if (!updating) {
	    if (!cursordown)
		togglecursor ();
	    ps_flush_PostScript ();
	    sigsetmask(blockinputmask);
	    keepalive = KEEPALIVE_THRESHHOLD; /* reset keepalive counter */
	}
}

/*
 * Emacs will loop forever on a socket whose other end has gone away; we
 * try to detect this by looking for a lot of calls to ps_fix_screen
 * done with no i/o to the tnt window.  To confirm that the other end
 * has gone away, we send a linefeed to the server; since this will
 * induce a SIGPIPE signal which is normally not caught, we catch it
 * ourselves.  No checking is done to make sure that the SIGPIPE is for
 * our socket, but since SIGPIPE on another fd would be fatal anyway,
 * at least this way we have a shot at saving dirty buffers.  If SIGPIPE is
 * caught, we ignore it and fake a SIGHUP so that a subsequent SIGPIPE
 * is less likely to interrupt us while we're trying to save buffers.
 *
 */

static
brokenpipe ()
{
    signal (SIGPIPE, SIG_IGN);
    unrequest_sigio ();
    (void) close (0);
    (void) open ("/dev/null", 0);
    fprintf (stderr, "emacs: lost connection to display.\n");
    fatal_error_signal (SIGHUP);
    abort ();				/* should not get here */
}

/*
 * First half of window initialization.  This is complicated by the fact
 * that Emacs wants to be able to write to the window before calling the
 * term_setup_hook, where the user may change the size, location, and font
 * used for the window.
 */

tnt_term_init ()
{
    meta_key = 1;			/* we support meta keys */
    visible_bell = 1;			/* visible bell is all we've got */
    interrupt_input = 1;		/* we use SIGIO */
    inverse_video = 0;			/* no support for inverse video yet */
    line_ins_del_ok = 1;		/* we do line insert/delete */
    char_ins_del_ok = 1;		/* we do char insert/delete
    scroll_region_ok = 1;		/* we do scroll regions */
    memory_below_screen = 0;		/* no offscreen memory */
    dont_calculate_costs = 1;		/* assume everything is cheap */
    must_write_spaces = 0;		/* this loses big */
#ifdef notdef
    baud_rate = 9600;			/* fake out speed-sensitive code */
#else
    baud_rate = 2400;			/* fake out speed-sensitive code */
#endif

    outputstarted = 0;			/* not within StartPS/EndPS */
    cursordown = 0;			/* cursor is not down */
    scrollregion = 0;			/* no scroll region defined */
    repaint = 0;			/* no repaint needed yet */
    updating = 0;			/* we are not inside update_screen */
    mapped = 0;				/* not fully initialized yet */
    nextevent = eventindex = eventcount = 0; /* no input events yet */
    sbufstart = sbufend = 0;		/* no strings in event queue */
    keepalive = KEEPALIVE_THRESHHOLD;	/* NeWS process hasn't died yet */

    /* set up hooks */

    fix_screen_hook =			ps_fix_screen;
    clear_screen_hook =			ps_clear_screen;
    clear_end_of_line_hook =		ps_clear_end_of_line;
    ins_del_lines_hook =		ps_ins_del_lines;
    insert_chars_hook =			ps_insert_chars;
    delete_chars_hook =			ps_delete_chars;
    output_chars_hook =			ps_output_chars;
    ring_bell_hook =			ps_feep;
    set_terminal_modes_hook =		ps_set_terminal_modes;
    reset_terminal_modes_hook =		ps_reset_terminal_modes;
    update_begin_hook =			ps_update_begin;
    update_end_hook =			ps_update_end;
    set_terminal_window_hook =		ps_set_terminal_window;
    read_socket_hook =			ps_read_socket;
    move_cursor_hook =			ps_move_cursor;
    change_line_highlight_hook =	ps_change_line_highlight;
    reassert_line_highlight_hook =	ps_reassert_line_highlight;

    /*
     * Handle window 'zaps' as gracefully as possible.  Note that
     * process.c must be modified to preserve the SIGPIPE handler.
     */
    (void) signal (SIGPIPE, brokenpipe);

    screen_height = ps_rows = 24;	/* keep emacs happy until our */
    screen_width = ps_cols = 80;	/*  term-setup-hook is run */

    (void) close (0);			/* emacs wants input on fd 0 */
#if 0
    if (((wire = wire_Open(0)) == wire_INVALID_WIRE)) {
	fprintf (stderr, "Cannot connect wire to NeWS server\n");
	exit (1);
    }
    StartPS ();
#else
    if (ps_open_PostScript () == 0) {
	fprintf (stderr, "Cannot connect to NeWS server\n");
	exit (1);
    }
    StartPS ();
#endif
    InitializeWire();			/* set up window, etc */

    /* query server for height and width of the window */
    (void) MeasureWindow(&ps_rows, &ps_cols);
/* XXX: use change_screen_size ?? */
    screen_height = ps_rows;
    screen_width = ps_cols;
    EndPS ();
    return 1;
}

/*
 * handle repaint requests, and try to detect a broken connection
 */

ps_fix_screen ()
{
    if (--keepalive < 0) {
	/*
	 * Poke the connection to avoid a loop if the other end goes away.
	 */
	pprintf (PostScript, "\n", 1);
	ps_flush_PostScript ();
	keepalive = KEEPALIVE_THRESHHOLD;
    }
    if (!mapped) {
	return;
    }

    if (repaint) {
	repaint = 0;
	++screen_garbaged;		/* XXX */
    }
    if (screen_garbaged)		/* XXX */
        redisplay_preserve_echo_area ();
}

/*
 * clear the screen, reset the cursor, etc
 */
ps_clear_screen ()
{
    cursordown = highlight = cursor_hpos = cursor_vpos =
      SavedX = SavedY = VisibleX = VisibleY = 0;
    StartPS();
    ClearScreen ();
    EndPS();
}

/*
 * clear to end of line.  arg is ignored since there's little point in
 * optimizing this one.
 */
ps_clear_end_of_line (first_blank)
register int first_blank;
{
    StartPS ();
    cleartoeol (cursor_hpos, cursor_vpos, highlight);
    EndPS ();
}

/*
 * set the current highlight mode, and clear this line to the highlight
 * background color.
 */

ps_change_line_highlight (new_highlight, vpos, first_unused_hpos)
int new_highlight, vpos, first_unused_hpos;
{
    highlight = new_highlight;
    StartPS ();
    ps_move_cursor (vpos, 0);		/* should this be first_unused_hpos? */
    ps_clear_end_of_line (0);
    EndPS ();
}

/*
 * set the highlight color, assuming that the line has already been painted.
 * ignoring vpos doesn't seem to hurt.
 */
ps_reassert_line_highlight (new_highlight, vpos)
int new_highlight, vpos;
{
    highlight = new_highlight;
}

ps_insert_chars (start, len)
register char *start;
register int len;
{
    if (len > 0) {
	StartPS ();
	InsertChars (VisibleX, VisibleY, len);
	if (start)
	    xyshow (VisibleX, VisibleY, start, len);
	VisibleX += len;
	EndPS ();
    }
}

ps_output_chars (start, len)
register char *start;
register int len;
{
    if (len > 0) {
	register int n;
	char *end;

	StartPS ();
	if (cursor_vpos >= 0 && cursor_vpos < screen_height) {
	    if (updating) {
		/*
		 * See if we can get a length for the line to be output.
		 * If we're not handed the whole thing, chances are an insert
		 * char sequence will follow so it's not safe to clear the
		 * rest of the line; in this case we just clear enough space
		 * for the string we're supposed to output.  This may be slower
		 * but it looks better on the displays I've tried it on.
		 */
/*
		n = new_screen->used[cursor_vpos];

		if (n >= (cursor_hpos + len))
*/
		    clearshow (cursor_hpos, cursor_vpos, start, len);
/*
		else {
		    cleartoeol (cursor_hpos, cursor_vpos, highlight);
		    xyshow (cursor_hpos, cursor_vpos, start, len);
		}
*/
		ps_move_cursor (cursor_vpos, cursor_hpos + len);
	    } else {
		if (VisibleX >= 0 && VisibleX < screen_width &&
		    VisibleY >= 0 && VisibleY < screen_height) {
		    /* can't trust cursor_hpos here? */
		    if ((VisibleX + len) >= screen_width)
			len = screen_width - 1 - VisibleX;
		    if (len > 0)
			xyshow (VisibleX, VisibleY, start, len);
		    VisibleX += len;
		}
	    }
	}
	EndPS ();
    }
}

ps_delete_chars (n)
{
    StartPS ();
    DeleteChars(VisibleX, VisibleY, n);
    EndPS ();
}

ps_feep ()
{
    StartPS ();
    Flash ();
    EndPS ();
}

/*
 * These routines don't seem to need to do anything except occupy their
 * respective hooks so Emacs doesn't mess with stdout.
 */

ps_reset_terminal_modes () {}
ps_set_terminal_modes () {}

ps_set_terminal_window (n)
int n;
{
    if (n <= 0 || n >= screen_height)
	scrollregion = 0;
    else
	scrollregion = n - 1;
}

ps_update_begin ()
{
    highlight = 0;
    StartPS ();
/*    BeginRepair(); */
    SavedX = cursor_hpos;
    SavedY = cursor_vpos;
    updating = 1;
    ResetCanvas();
}

ps_update_end ()
{
    updating = 0;
    ps_move_cursor (SavedY, SavedX);
/*    EndRepair(); */
    EndPS ();
    highlight = 0;
}

ps_ins_del_lines (vpos, n)
register int vpos, n;

{
    if ((vpos < 0) || ((vpos + (n > 0 ? n : -n)) >= screen_height))
	return;

    StartPS ();
    ps_move_cursor (vpos, 0);
    if (n > 0) {
	if (scrollregion)
	    InsertLines2 (vpos, scrollregion, n);
	else
	    InsertLines (vpos, n);
    }
    else if (n < 0) {
	n = -n;
	if (scrollregion)
	    DeleteLines2 (vpos, scrollregion, n);
	else
	    DeleteLines (vpos, n);
    }
    EndPS ();
}

/*
 * Beware changing VisibleX while not inside StartPS/EndPS, since they
 * hide the cursor while things are moving.
 */
ps_move_cursor (row, col)
register int row, col;
{
    cursor_hpos = col;
    cursor_vpos = row;
    /* need to put up cursor, maybe */
    VisibleX = col;
    VisibleY = row;
}

/*
 * Input queue support routines.   ps_read_socket() is called from a signal
 * handler and thus it can't act directly on its input; instead, it saves
 * the input events in a queue where (tnt-next-event) can find them.
 */

#define NEVENTS 256			/* must be a power of 2 */

typedef struct {
    int nelements;
    Lisp_Object list[NEVENTS];
} selectionevent;

static selectionevent selectionevents[NEVENTS];

#define EINCR(i) i = ((i+1)&(NEVENTS-1))

/*
 * Queue an event; "what" is one of:
 *	0 => insert string
 *	1 => execute string 
 *	2 => track event
 */
queue_event (what, rank, size, x, y)
int what, rank, size, x, y;
{
    selectionevent *se;
    if (eventcount >= NEVENTS)
	return 0;
    se = &selectionevents[eventindex];
    se->nelements = 5;
    XSET (se->list[0], Lisp_Int, what);
    XSET (se->list[1], Lisp_Int, rank);	/* for strings, buffer index */
    XSET (se->list[2], Lisp_Int, size);	/* for strings, string length */
    XSET (se->list[3], Lisp_Int, x);
    XSET (se->list[4], Lisp_Int, y);
    EINCR (eventindex);
    eventcount++;
    return 1;
}

/*
 * Queue a string for execution/insertion by Emacs.  We need to use a private
 * string buffer since the strings are queued from signal handlers.  It might
 * be useful to queue the current mouse position with the string, so commands
 * affect the buffer-window under the mouse.
 *
 * Strings are added to sbuf at sbufend, and removed from sbufstart;
 * when the queue is empty, sbufend and sbuftstart are reset to zero.
 */

#define SBUF_SIZE 4096
static unsigned char sbuf[SBUF_SIZE];

queue_string (s, exec)
unsigned char *s;
int exec;				/* 0=>insert, 1=>execute */
{
    int n = strlen (s);

    if (sbufend + n < sizeof sbuf) {
	strcpy (&sbuf[sbufend], s);
	if (queue_event (exec, sbufend, n, 0, 0)) {
	    sbufend += n;
	    return 1;
	}
    }
    return 0;
}

ps_read_socket (fd, buffer, length)
int fd, length;
unsigned char *buffer;
{
    int x, y, i, n, a, c, top, left, rows, cols;

    x = y = i = 0;
    c = -1;

    do {
  	if (psio_eof (PostScriptInput) || psio_error (PostScriptInput))
	    brokenpipe ();
	if (TypeKey (&n)) {
	    buffer[i] = n;
	    i++;
	}
	else if (TrackEvent (&n, &a, &x, &y)) {
	    unsigned char *cp = &buffer[i];
	    if (queue_event (2, n, a, x, y)) {
		buffer[i++] = 'x' & 037; /* C-x C-@ */
		buffer[i++] = 0;
	    }
	}
	else if (TypeString (&buffer[i])) {
	    i += strlen (&buffer[i]);
	}
	else if (InsertString (&buffer[i])) {
	    if (queue_string (&buffer[i], 0)) {
		buffer[i++] = 'x' & 037; /* C-x C-@ */
		buffer[i++] = 0;
	    }
	}
	else if (ExecuteCommand (&buffer[i])) {
	    if (queue_string (&buffer[i], 1)) {
		buffer[i++] = 'x' & 037; /* C-x C-@ */
		buffer[i++] = 0;
	    }
	}
	else if (RepairWindow (&top, &left, &rows, &cols)) {
	    dumprectangle (top, left, rows, cols);
	}
	else if (ResizeWindow(&ps_rows, &ps_cols)) {
	    extern int delayed_size_change,
	               delayed_screen_height, delayed_screen_width;
	    delayed_size_change = 1;
	    delayed_screen_height = ps_rows;
	    delayed_screen_width = ps_cols;
	}
	else if (DebugMessage (&buffer[i])) {
	    fprintf (stderr, "debug: %s\n", &buffer[i]);
	}
	else {
	    c = psio_getc(PostScriptInput);
	    fprintf (stderr, "%c", c);
	}
    } while (psio_availinputbytes (PostScriptInput) != 0);

    return i;				/* return count of keyboard chars */
}

dumpchars (active_screen, cols, x, y, hl)
     struct matrix *active_screen;
     int cols;
     int x, y, hl;
{
    if (cols <= 0)
	return;

    if (cols-1+x > screen_width)
	cols = screen_width-x+1;

    if (x<0 || x>=screen_width || y<0 || y>=screen_height)
        return;

    if (hl)
        ClearShowInverted (x, y, cols, y,
			   &active_screen->contents[y][x], cols);
    else
        Show (x, y, &active_screen->contents[y][x], cols);
}

dumprectangle (top, left, rows, cols)
     int top, left, rows, cols;
{
    register struct matrix *active_screen;
    register int ourindex;
    int x, y, tc = 0;

    StartPS ();
    ResetCanvas ();

    if (top < 0) {
	rows += top;
	top = 0;
    }
    if (left < 0) {
	cols += left;
	left = 0;
    }

    if (rows>=0 && cols>=0 &&
	top<=(screen_height-1) &&
	left<=(screen_width-1)) {

	active_screen = updating ? new_screen : current_screen;

	for (y = top, ourindex = 0;
	     ourindex < rows && y < screen_height;
	     ++ourindex, ++y) {
	    if (y<0 || y>=screen_height ||
		!(active_screen->enable[y]) ||
		(left+1)>(active_screen->used[y]))
		continue;
	    x = left;
	    dumpchars (active_screen,
		       min (cols, active_screen->used[y]-x),
		       x, y, active_screen->highlight[y]);
	}
    }
    EndPS ();
}

/*
 * Display N chars from string S at row X, column Y
 */

xyshow (x, y, s, n)
int x, y, n;
char *s;
{
    if (highlight)
	ShowInverted (x, y, s, n);
    else
	Show (x, y, s, n);
}

/*
 * Display N chars from S at X, Y, after clearing background.
 */

clearshow (x, y, s, n)
int x, y, n;
char *s;
{
    if (highlight)
	ClearShowInverted (x, y, n, y, s, n);
    else
	ClearShow (x, y, n, y, s, n);
}

cleartoeol(x,y,highlight)
int x, y, highlight;
{
    if (highlight)
	InvertToEOL (x, y);
    else
	ClearToEOL (x, y);
}

togglecursor ()
{
    if (VisibleX >= 0 && VisibleX < screen_width &&
	VisibleY >= 0 && VisibleY < screen_height) {
	ToggleCursor (VisibleX, VisibleY);
	cursordown = !cursordown;
    }
}

CheckPS ()
{
    if (!PostScript)
	error ("Not connected to NeWS server");
}

DEFUN ("tnt-map-window", Ftnt_map_window, Stnt_map_window,
       0, 0, 0, "Make the tnt window visible on the display.") ()
{
    CheckPS ();

    if (mapped)
	return;

    MapWindow ();
    mapped = 1;

    setpgrp (0, getpid ());

    init_sigio ();			/* set up SIGIO handler */
    request_sigio ();
#ifdef F_SETOWN
    {
	extern int old_fcntl_owner;
	old_fcntl_owner = fcntl (0, F_GETOWN, 0);
	fcntl (0, F_SETOWN, getpid ());
    }
#endif F_SETOWN
    return Qnil;
}

DEFUN ("tnt-set-font", Ftnt_set_font, Stnt_set_font, 2, 2,
       "sFont: \nnSize: ", "Set font to FONT at SIZE points.") (font,size)
Lisp_Object font, size;
{
    CHECK_STRING (font, 1);
    CHECK_NUMBER (size, 2);
    if (XINT (size) < 1)
	args_out_of_range (font, size);

    StartPS ();
    SetFont (XSTRING (font)->data, strlen (XSTRING (font)->data), size);
    /*
     * update window size so rows & cols don't change next time NeWS asks
     * for a repaint.
     */
    SetWindowSize (screen_width, screen_height);
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-set-window-location",
       Ftnt_set_window_location, Stnt_set_window_location, 2, 2,
       "nX: \nnY: ", "Move the tnt window to X, Y.") (x, y)
Lisp_Object x, y;
{
    CHECK_NUMBER (x, 1);
    CHECK_NUMBER (y, 2);
    if (XINT (x) < 0 || XINT (y) < 0)
	args_out_of_range (x, y);

    StartPS ();
    SetWindowLocation (XINT (x), XINT (y));
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-set-window-size", Ftnt_set_window_size, Stnt_set_window_size, 2, 2,
       "nColumns: \nnRows: ", "Set tnt window size to COLUMNS and ROWS")
(cols, rows)
Lisp_Object cols, rows;
{
    CHECK_NUMBER (cols, 1);
    CHECK_NUMBER (rows, 2);
    if (XINT (cols) < 1 || XINT (cols) >= 10000 ||
	XINT (rows) < 1 || XINT (cols) >= 10000)
	args_out_of_range (cols, rows);

    StartPS ();
    SetWindowSize (XINT (cols), XINT (rows));
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-set-window-label",
       Ftnt_set_window_label, Stnt_set_window_label, 1, 1,
       "sWindow Label: ", "Set the tnt window label to STRING") (s)
Lisp_Object s;
{
    CHECK_STRING (s, 1);

    StartPS ();
    SetWindowLabel (XSTRING (s)->data, XSTRING (s)->size);
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-set-option", Ftnt_set_option, Stnt_set_option, 2, 2, 0,
       "Set tnt OPTION's value to BOOLEAN.  Don't call this.") (option, value)
Lisp_Object option, value;
{
    CHECK_NUMBER (option, 1);

    CheckPS ();
    switch (XINT (option)) {
      case 1:
	line_ins_del_ok = !NULL (value);
	break;
      case 2:
	char_ins_del_ok = !NULL (value);
	break;
      case 3:
	scroll_region_ok = !NULL (value);
	if (!scroll_region_ok)
	    scrollregion = 0;
	break;
      default:
	args_out_of_range (option, value);
    }
    return Qnil;
}       

/*
 * Return a list representing the current input event:
 *
 *	(0 string)			; insert string
 * 	(1 string)			; execute string
 *	(2 name action x y)		; track event
 */

DEFUN ("tnt-next-event", Ftnt_next_event, Stnt_next_event, 0, 0, 0,
       "Return a list describing the next available tnt input event.") ()
{
    selectionevent *se;

    unrequest_sigio ();			/* lock out queue_event */
    se = &selectionevents[nextevent];
    if (eventcount < 1)
	return Qnil;

    eventcount--;

    switch (XFASTINT (se->list[0])) {
      case 0:				/* insert string */
      case 1:				/* execute string */
	se->list[1] = make_string (&sbuf[XFASTINT (se->list[1])],
				   XFASTINT (se->list[2]));
	sbufstart += XFASTINT (se->list[2]); /* chase tail of queue */
	if (sbufstart >= sbufend)
	    sbufstart = sbufend = 0;
	se->nelements = 2;
    }
    EINCR (nextevent);

    request_sigio ();			/* allow sigio interrupts again */
    return Flist (se->nelements, se->list);
}

DEFUN ("tnt-send-ps", Ftnt_send_ps, Stnt_send_ps,
       1, 1, 0,"Send PostScript STRING to NeWS server & execute.")
(s)
Lisp_Object s;
{
    CHECK_STRING (s, 1);
    
    StartPS ();
    SendPS (XSTRING (s)->data, XSTRING (s)->size);
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-send-string", Ftnt_send_string, Stnt_send_string,
       1, 1, 0,"Send STRING to NeWS server & push on stack.")
(s)
Lisp_Object s;
{
    CHECK_STRING (s, 1);
    
    StartPS ();
    SendString (XSTRING (s)->data, XSTRING (s)->size);
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-send-number", Ftnt_send_number, Stnt_send_number,
       1, 1, 0,"Send NUMBER to NeWS server & push on stack.")
(s)
Lisp_Object s;
{
    CHECK_NUMBER (s, 1);
    
    StartPS ();
    SendNumber (XINT (s));
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-send-boolean", Ftnt_send_boolean, Stnt_send_boolean,
       1, 1, 0,"Send PostScript BOOLEAN to NeWS server & push on stack.")
(s)
Lisp_Object s;
{
    StartPS ();
    SendBoolean (NULL (s) ? 0 : 1);
    EndPS ();
    return Qnil;
}

DEFUN ("tnt-start-ps", Ftnt_start_ps, Stnt_start_ps,
       0, 0, 0,"Start a batch of PostScript output to NeWS server.") ()
{
    StartPS ();
    return make_number (outputstarted);
}

DEFUN ("tnt-end-ps", Ftnt_end_ps, Stnt_end_ps,
       0, 0, 0,"Start a batch of PostScript output to NeWS server.") ()
{
    EndPS ();
    return make_number (outputstarted);
}

/*
 * This could be implemented in lisp, I suppose, but as long as we're here...
 */

DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 2, 0,
       "Convert COLUMN and ROW into local window coordinates.\n\
Result is a list: (WINDOW LOCAL-COLUMN LOCAL-ROW), or NIL if the window is\n\
inactive.  Do not use this function in code intended to be portable.") (x, y)
Lisp_Object x, y;
{
    Lisp_Object window = selected_window;

    CHECK_NUMBER (x, 1);
    CHECK_NUMBER (y, 1);
    x = XINT (x);
    y = XINT (y);
    do {
	struct window *w = XWINDOW (window);
	int wx = w->left, wy = w->top;

	if (x >= wx && x < wx + w->width && y >= wy && y < wy + w->height) {
	    Lisp_Object list[3];

	    list[0] = window;
	    XSET (list[1], Lisp_Int, x - wx);
	    XSET (list[2], Lisp_Int, y - wy);
	    return Flist (3, list);
	}
    } while ((window = Fnext_window (window, Qnil)) != selected_window);

    return Qnil;
}

/*
 * This could be implemented in lisp, I suppose, but as long as we're here...
 */

DEFUN ("window-point-row", Fwindow_point_row, Swindow_point_row, 1, 1, 0,
       "Return the row of the point in WINDOW.") (window)
Lisp_Object window;
{
    CHECK_WINDOW (window, 1);

    return make_number (XWINDOW(window)->last_point_y);
}

DEFUN ("window-point-column", Fwindow_point_column, Swindow_point_column,
       1, 1, 0,
       "Return the column of the point in WINDOW.") (window)
Lisp_Object window;
{
    CHECK_WINDOW (window, 1);

    return make_number (XWINDOW(window)->last_point_x);
}

DEFUN ("window-end-pos", Fwindow_end_pos, Swindow_end_pos,
       1, 1, 0,
       "Number of characters in buffer past bottom of WINDOW,\n\
as of last redisplay that finished.") (window)
Lisp_Object window;
{
    CHECK_WINDOW (window, 1);

    return make_number (XWINDOW(window)->window_end_pos);
}

syms_of_tnt ()
{
    defsubr (&Stnt_map_window);
    defsubr (&Stnt_set_font);
    defsubr (&Stnt_set_window_location);
    defsubr (&Stnt_set_window_size);
    defsubr (&Stnt_set_window_label);
    defsubr (&Stnt_set_option);
    defsubr (&Stnt_next_event);
    defsubr (&Stnt_send_ps);
    defsubr (&Stnt_send_string);
    defsubr (&Stnt_send_number);
    defsubr (&Stnt_send_boolean);
    defsubr (&Stnt_start_ps);
    defsubr (&Stnt_end_ps);
    defsubr (&Swindow_at);
    defsubr (&Swindow_point_row);
    defsubr (&Swindow_point_column);
    defsubr (&Swindow_end_pos);
}

#endif HAVE_TNT