Repatch (from linux) of OSX IRAF

1 files changed, 692 insertions, 0 deletions

diff --git a/sys/gio/cursor/rcursor.x b/sys/gio/cursor/rcursor.x
new file mode 100644
index 00000000..cc7dc739
--- /dev/null
+++ b/sys/gio/cursor/rcursor.x
@@ -0,0 +1,692 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<ctype.h>
+include	<ttset.h>
+include	<gio.h>
+include	<gki.h>
+include	"gtr.h"
+include	"grc.h"
+
+define	SZ_CHARCON	5
+define	MARKLEN		0.01
+
+# Cursor step algorithm parameters.
+
+define	MAX_STEP	0.1		# max cursor step size, cursor motions
+define	MIN_STEP	0.002		# min cursor step size, cursor motions
+define	LARGER_STEP	2.0		# factor by which step size is increased
+define	SMALLER_STEP	0.5		# factor by step size is decreased
+define	NSTEP		2		# number of steps before larger step
+define	MANUAL_STEP	5.0		# gear ratio for F/V cursor control
+define	SLOW		1		# for fast/slow algorithm
+define	FAST		2
+
+# Zoom parameters.
+
+define	X_ZOOMFACTOR	0.5		# zoom factors
+define	Y_ZOOMFACTOR	0.5
+#define	X_ZOOMFACTOR	0.666		# zoom factors
+#define	Y_ZOOMFACTOR	0.666
+
+# Roam factors.
+
+define	X_ROAM		0.333		# fraction of the current window
+define	Y_ROAM		0.333		# fraction of the current window
+
+
+# RCURSOR -- Read the position of a cursor.  This is the main entry point to
+# cursor mode/cursor input from the CL; we are called by the QUERY procedure
+# of the CL when a cursor type parameter is read.  The cursor position is
+# returned as a string of the form
+#
+#	x y wcs key stringval
+#
+# where the "stringval" field may be absent if not appropriate for a given key.
+# If EOF is returned the cursor value string is undefined.
+
+int procedure rcursor (stream, outstr, maxch)
+
+int	stream			# graphics stream
+char	outstr[ARB]		# encoded cursor value (output)
+int	maxch
+
+bool	cminit
+int	xroam[9], yroam[9]
+pointer	rc, tr, sp, lbuf, ip
+char	charcon[SZ_CHARCON], ch
+real	x1, x2, y1, y2, xt, yt, v[10]
+real	lx1, lx2, ly1, ly2, aspect_ratio
+real	x, y, rx, ry, xw, yw, dx, dy, xc, yc
+int	junk, key, nukey, last_zoom, i, wcs, ppos, ucasein, raster
+
+bool	ttygetb()
+pointer	grc_open()
+int	envfind(), ctocc(), oscmd(), gtr_readcursor(), grc_readtty()
+int	grc_cursor(), grc_command(), grc_selectwcs(), grc_mapkey(), ttstati()
+real	ttygetr()
+
+errchk	grc_text, grc_readtty, grc_writecursor
+errchk	grc_init, grc_open, grc_command, grc_cursor, grc_message
+errchk	grc_readcursor, grc_mapkey, grc_redraw, envfind
+
+data	xroam /1,0,-1,1,0,-1,1,0,-1/
+data	yroam /1,1,1,0,0,0,-1,-1,-1/
+data	rc /NULL/
+define	done_ 91
+define	coloncmd_ 92
+
+begin
+	call smark (sp)
+	call salloc (lbuf, SZ_COMMAND, TY_CHAR)
+
+	# Allocate and initialize the RCURSOR descriptor.
+	if (rc == NULL) {
+	    call grc_init (rc)
+	    cminit = true
+	} else
+	    cminit = false
+
+	# Open or reopen the graphics kernel.
+	tr = grc_open ("", APPEND, stream, rc)
+
+	# Process CMINIT command string, if present in environment.  This is
+	# only done once.
+
+	if (cminit) {
+	    if (envfind ("cminit", Memc[lbuf], SZ_COMMAND) > 0) {
+		ip = lbuf
+		while (IS_WHITE(Memc[ip]) || Memc[ip] == '.')
+		    ip = ip + 1
+		junk = grc_command (rc, stream, 0.,0.,0,0.,0., Memc[ip])
+	    }
+	    cminit = false
+	}
+
+	# If the graphics device does not permit input, i.e., does not have
+	# a cursor, return EOF.
+
+	if (!ttygetb (TR_TTY(tr), "in")) {
+	    x = 0; y = 0
+	    key = EOF
+	    goto done_
+	}
+
+	# Determine if input keys are to be mapped to lower case by default,
+	# i.e., ucasein mode has been set for the terminal driver.
+
+	ucasein = ttstati (STDIN, TT_UCASEIN)
+
+	last_zoom = 3
+	ppos = NO
+
+	# Enter cursor mode loop.  The loop terminates when a non cursor mode
+	# keystroke is typed.
+
+	while (grc_cursor (rc, stream, key,x,y, raster,rx,ry, ppos) != EOF) {
+	    Memc[lbuf] = EOS
+
+	    # As a rule, no processing is performed on escaped keys.  The only
+	    # exception is when ucasein mode is set in the terminal driver,
+	    # causing upper case input to be mapped to lower case.  This mapping
+	    # is disabled in a raw mode cursor read, hence we must perform the
+	    # mapping explicitly here, returning a lower case key to the
+	    # applications program.  Unescaped upper case input keystrokes will
+	    # be intercepted by cursor mode when ucasein mode is in effect.
+
+	    if (key == '\\') {
+		junk = gtr_readcursor (stream, key, x, y, raster, rx, ry)
+		if (ucasein == YES && IS_UPPER(key))
+		    key = TO_LOWER (key)
+		break
+	    }
+
+	    # Map keystroke.  If the keystroke maps to a null value the key
+	    # is not recognized as a cursor mode keystroke and we exit.
+
+	    if (grc_mapkey (rc, key, nukey) == NULL)
+		break
+
+	    switch (nukey) {
+	    case 'M':
+		# Move the feature under the cursor to the center of the
+		# screen without changing the scaling.
+
+		call grc_scrtondc (x, y, xc, yc)
+		call gtr_gtran (stream, x1, x2, y1, y2)
+		xw = (x2 - x1) / 2.
+		yw = (y2 - y1) / 2.
+		call gtr_ptran (stream, xc-xw, xc+xw, yc-yw, yc+yw)
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call grc_restorecurpos (stream, xc, yc)
+
+	    case 'Z':
+		# Zoom in in both X and Y.
+		call grc_scrtondc (x, y, xc, yc)
+		call gtr_gtran (stream, x1, x2, y1, y2)
+		xw = (x2 - x1) * X_ZOOMFACTOR / 2.
+		yw = (y2 - y1) * Y_ZOOMFACTOR / 2.
+		call gtr_ptran (stream, xc-xw, xc+xw, yc-yw, yc+yw)
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call grc_restorecurpos (stream, xc, yc)
+		last_zoom = 3
+
+	    case 'X':
+		# Zoom in in X.
+		call grc_scrtondc (x, y, xc, yc)
+		call gtr_gtran (stream, x1, x2, y1, y2)
+		xw = (x2 - x1) * X_ZOOMFACTOR / 2.
+		call gtr_ptran (stream, xc-xw, xc+xw, y1, y2)
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call grc_restorecurpos (stream, xc, yc)
+		last_zoom = 1
+
+	    case 'Y':
+		# Zoom in in Y.
+		call grc_scrtondc (x, y, xc, yc)
+		call gtr_gtran (stream, x1, x2, y1, y2)
+		yw = (y2 - y1) * Y_ZOOMFACTOR / 2.
+		call gtr_ptran (stream, x1, x2, yc-yw, yc+yw)
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call grc_restorecurpos (stream, xc, yc)
+		last_zoom = 2
+
+	    case '>':
+		# Zoom in in Y by setting the upper limit of the viewport
+		# to the cursor Y position.
+
+		call grc_scrtondc (x, y, xc, yc)
+		call gtr_gtran (stream, lx1, lx2, ly1, ly2)
+		call gtr_ptran (stream, lx1, lx2, ly1,  yc)
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call gtr_writecursor (stream, x, 0.5)
+		last_zoom = 'E'
+
+	    case '<':
+		# Zoom in in Y by setting the lower limit of the viewport
+		# to the cursor Y position.
+
+		call grc_scrtondc (x, y, xc, yc)
+		call gtr_gtran (stream, lx1, lx2, ly1, ly2)
+		call gtr_ptran (stream, lx1, lx2,  yc, ly2)
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call gtr_writecursor (stream, x, 0.5)
+		last_zoom = 'E'
+
+	    case 'E':
+		# Expand by marking corners of new viewport.  If the range is
+		# small in either X or Y only the other axis will be expanded.
+
+		call gtr_gtran (stream, lx1, lx2, ly1, ly2)
+		call grc_scrtondc (x, y, x1, y1)
+		call grc_message (stream, "again:")
+		junk = grc_cursor (rc, stream, key,x2,y2, raster,rx,ry, ppos)
+		call grc_scrtondc (x2, y2, x2, y2)
+
+		if (x1 > x2)
+		    { xt = x2;  x2 = x1;  x1 = xt }
+		if (y1 > y2)
+		    { yt = y2;  y2 = y1;  y1 = yt }
+
+		if (abs (x1 - x2) < .01)
+		    call gtr_ptran (stream, lx1, lx2, y1, y2)
+		else if (abs (y1 - y2) < .01)
+		    call gtr_ptran (stream, x1, x2, ly1, ly2)
+		else
+		    call gtr_ptran (stream, x1, x2, y1, y2)
+
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call gtr_writecursor (stream, 0.5, 0.5)
+		last_zoom = 'E'
+
+	    case 'P':
+		# Zoom out.
+		call grc_scrtondc (x, y, xc, yc)
+		call gtr_gtran (stream, x1, x2, y1, y2)
+
+		if (last_zoom == 'E') {
+		    call gtr_ptran (stream, lx1, lx2, ly1, ly2)
+		    lx1 = x1; lx2 = x2; ly1 = y1; ly2 = y2
+		} else {
+		    if (last_zoom == 1 || last_zoom == 3) {
+			xw = (x2 - x1) / X_ZOOMFACTOR / 2.
+			x1 = xc - xw
+			x2 = xc + xw
+		    }
+		    if (last_zoom == 2 || last_zoom == 3) {
+			yw = (y2 - y1) / Y_ZOOMFACTOR / 2.
+			y1 = yc - yw
+			y2 = yc + yw
+		    }
+		    call gtr_ptran (stream, x1, x2, y1, y2)
+		}
+
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		call grc_restorecurpos (stream, xc, yc)
+
+	    case 'W':
+		# Select and fix WCS to be used for scr->wcs coordinate
+		# transformations.
+
+		call grc_scrtondc (x, y, xc, yc)
+		TR_WCS(tr) = grc_selectwcs (tr, raster, xc, yc)
+
+	    case 'C':
+		# Running tally of cursor position.
+		#if (ppos == NO) {
+		#    call grc_pcursor (stream, x, y, raster, rx, ry)
+		#    ppos = YES
+		#} else {
+		#    call grc_message (stream, "\n\n")
+		#    ppos = NO
+		#}
+
+		call grc_pcursor (stream, x, y, raster, rx, ry)
+
+	    case 'D':
+		# Draw a line by marking the endpoints.
+		call grc_scrtondc (x, y, v[1], v[2])
+		call grc_message (stream, "again:")
+		junk = grc_cursor (rc, stream, key,x2,y2, raster,rx,ry, ppos)
+		call grc_scrtondc (x2, y2, v[3], v[4])
+		call grc_polyline (stream, v, 2)
+
+	    case 'T':
+		# Draw a text string.
+		if (grc_readtty (stream, "text: ", Memc[lbuf], SZ_COMMAND) <= 0)
+		    next
+		call grc_scrtondc (x, y, xc, yc)
+		call grc_text (stream, xc, yc, Memc[lbuf])
+
+	    case 'A':
+		# Draw and label the axes of the viewport.
+		call grc_axes (stream, x, y, raster, rx, ry)
+
+	    case 'B':
+		# Backup one instruction in the frame buffer.
+		call gtr_backup (stream)
+
+	    case 'U':
+		# Undo the last frame buffer edit.
+		call gtr_undo (stream)
+
+	    case 'R':
+		# Redraw the screen.
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+
+	    case '0':
+		# Reset and redraw.
+		call gtr_ptran (stream, 0., 1., 0., 1.)
+		call gtr_writecursor (stream, .5, .5)
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+
+	    case '5':
+		# Redraw (null roam request).
+		call grc_redraw (rc, stream, x, y, raster, rx, ry)
+
+	    case '1','2','3','4','6','7','8','9':
+		# Roam.
+		i = TO_INTEG (key)
+		if (xroam[i] != 0 || yroam[i] != 0) {
+		    call gtr_gtran (stream, x1, x2, y1, y2)
+		    dx = (x2 - x1) * X_ROAM * xroam[i]
+		    dy = (y2 - y1) * Y_ROAM * yroam[i]
+		    call gtr_ptran (stream, x1+dx, x2+dx, y1+dy, y2+dy)
+		    call grc_redraw (rc, stream, x, y, raster, rx, ry)
+		}
+
+	    case ':':
+		# Enter a colon command string and terminate cursor mode.
+
+		# Get the string value.
+		if (grc_readtty (stream, ":", Memc[lbuf], SZ_COMMAND) <= 0)
+		    next
+
+		# All cursor mode commands must begin with a ".".  An osescape
+		# begins with an "!".
+
+		if (Memc[lbuf] == '!') {
+		    call gtr_page (STDERR, stream)
+		    if (oscmd (Memc[lbuf+1], "", "", "") == ERR)
+			call fprintf (STDERR, "\7")
+		    call gtr_waitpage (STDERR, stream)
+		    
+		} else if (Memc[lbuf] == '.') {
+		    # Save viewport for 'P'.
+coloncmd_
+		    call gtr_gtran (stream, lx1, lx2, ly1, ly2)
+		    last_zoom = 'E'
+
+		    TR_WAITPAGE(tr) = NO
+		    if (grc_command (rc, stream, x, y, raster, rx, ry,
+			    Memc[lbuf+1]) == EOF) {
+			key = EOF
+			goto done_
+		    }
+
+		    # The following is a no-op for most colon commands.
+		    if (TR_WAITPAGE(tr) == YES)
+			call gtr_waitpage (STDERR, stream)
+		} else
+		    break
+
+	    case '=':
+		# Shorthand for :.snap.  The latter must be used once to
+		# set the plotter device, else the default stdplot device
+		# will be used.
+
+		call strcpy (".snap", Memc[lbuf], SZ_COMMAND)
+		goto coloncmd_
+
+	    default:
+		call fprintf (STDERR, "\007")
+	    }
+	}
+
+	# Mark the cursor position if markcur enabled.
+	if (RC_MARKCUR(rc) == YES && key != EOF) {
+	    call grc_scrtondc (x, y, xc, yc)
+	    aspect_ratio = ttygetr (TR_TTY(tr), "ar")
+	    if (aspect_ratio < .001)
+		aspect_ratio = 1.0
+
+	    v[1]  = xc - MARKLEN * aspect_ratio
+	    v[2]  = yc
+	    v[3]  = xc + MARKLEN * aspect_ratio
+	    v[4]  = yc
+	    v[5]  = xc
+	    v[6]  = yc
+	    v[7]  = xc
+	    v[8]  = yc - MARKLEN
+	    v[9]  = xc
+	    v[10] = yc + MARKLEN
+	    call grc_polyline (stream, v, 5)
+	}
+
+	# Close the workstation, leave graphics mode, position alpha cursor to
+	# lower left corner of graphics terminal.
+
+	call grc_close (stream, rc)
+
+	# Encode the cursor value as a string for the CL.
+done_
+	if (key != EOF) {
+	    if (key == ' ')
+		call strcpy ("\\40", charcon, SZ_CHARCON)
+	    else {
+		ch = char (key)
+		junk = ctocc (ch, charcon, SZ_CHARCON)
+	    }
+	    call grc_scrtowcs (stream, x, y, raster, rx, ry, xc, yc, wcs)
+
+	    call sprintf (outstr, maxch, "%g %g %d %s %s\n")
+		call pargr (xc)
+		call pargr (yc)
+		call pargi (wcs)
+		call pargstr (charcon)
+		call pargstr (Memc[lbuf])
+	} else
+	    outstr[1] = EOS
+
+	call sfree (sp)
+	return (key)
+end
+
+
+# GRC_CURSOR -- Read the position of a cursor in screen coordinates.  Recognizes
+# the cursor movement keystrokes H, J, K, and L, exiting only when some other
+# keystroke is received.  The cursor movement algorithm is initialized upon
+# entry.  Two algorithms are provided for controlling the cursor step size.
+# The first algorithm (automatic control) starts with a large initial step
+# size.  In the vicinity of a feature the cursor will overshoot the feature
+# and the user will step back in the opposite direction, causing the step size
+# to be decreased, rapidly converging to the desired position.  Several steps
+# in the same direction cause the large step size to be restored.  The second
+# algorithm (manual control) uses the F and V keys to directly control the step
+# size.
+
+int procedure grc_cursor (rc, stream, key, x, y, raster, rx, ry, ppos)
+
+pointer	rc			#I rcursor descriptor
+int	stream			#I graphics stream
+int	key			#O keystroke typed
+real	x, y			#O cursor screen coordinates
+int	raster			#O raster number
+real	rx, ry			#O cursor raster coordinates
+int	ppos			#I print cursor position flag
+
+int	speed
+int	xdir, ydir, nukey
+real	xstep, ystep, newx, newy
+
+bool	ttygetb()
+pointer	gtr_gtty()
+int	gtr_readcursor(), grc_mapkey()
+errchk	gtr_readcursor, gtr_writecursor
+
+begin
+	# Reset the cursor step size to the default.
+	xstep = MAX_STEP
+	ystep = MAX_STEP
+	xdir  = 0
+	ydir  = 0
+	speed = 0
+
+	while (gtr_readcursor (stream, key, x, y, raster, rx, ry) != EOF) {
+	    if (grc_mapkey (rc, key, nukey) == NULL)
+		break
+
+	    newx = x
+	    newy = y
+
+	    switch (nukey) {
+	    case 'F':
+		# Faster.
+		xstep = min (MAX_STEP, xstep * MANUAL_STEP)
+		ystep = min (MAX_STEP, ystep * MANUAL_STEP)
+		speed = FAST
+
+	    case 'V':
+		# Slower.
+		xstep = max (MIN_STEP, xstep / MANUAL_STEP)
+		ystep = max (MIN_STEP, ystep / MANUAL_STEP)
+		speed = SLOW
+
+	    case 'H':
+		# Step cursor left.
+		if (speed == 0)
+		    if (xdir < -NSTEP) {
+			xstep = MAX_STEP
+			xdir = -1
+		    } else if (xdir > 0) {
+			xstep = max (MIN_STEP, xstep * SMALLER_STEP)
+			xdir = -1
+		    } else
+			xdir = xdir - 1
+		newx = newx - xstep
+		call gtr_writecursor (stream, newx, newy)
+
+	    case 'J':
+		# Step cursor down.
+		if (speed == 0)
+		    if (ydir < -NSTEP) {
+			ystep = MAX_STEP
+			ydir = -1
+		    } else if (ydir > 0) {
+			ystep = max (MIN_STEP, ystep * SMALLER_STEP)
+			ydir = -1
+		    } else
+			ydir = ydir - 1
+		newy = newy - ystep
+		call gtr_writecursor (stream, newx, newy)
+
+	    case 'K':
+		# Step cursor up.
+		if (speed == 0)
+		    if (ydir > NSTEP) {
+			ystep = MAX_STEP
+			ydir = 1
+		    } else if (ydir < 0) {
+			ystep = max (MIN_STEP, ystep * SMALLER_STEP)
+			ydir = 1
+		    } else
+			ydir = ydir + 1
+		newy = newy + ystep
+		call gtr_writecursor (stream, newx, newy)
+
+	    case 'L':
+		# Step cursor right.
+		if (speed == 0)
+		    if (xdir > NSTEP) {
+			xstep = MAX_STEP
+			xdir = 1
+		    } else if (xdir < 0) {
+			xstep = max (MIN_STEP, xstep * SMALLER_STEP)
+			xdir = 1
+		    } else
+			xdir = xdir + 1
+		newx = newx + xstep
+		call gtr_writecursor (stream, newx, newy)
+	    
+	    default:
+		break
+	    }
+
+	    # We assume the cursor may have moved if the WC capability exists
+	    # for this device.
+
+	    if (ttygetb (gtr_gtty (stream), "WC")) {
+		x = newx
+		y = newy
+	    }
+
+	    # Print the cursor position.
+	    if (ppos == YES)
+		call grc_pcursor (stream, x, y, raster, rx, ry)
+	}
+
+	return (key)
+end
+
+
+# GRC_MAPKEY -- Map keystroke.  If the keystroke maps to a null value the key
+# is not recognized as a cursor mode keystroke and we exit.  Note that if case
+# sensitivity is disabled, KEYS comparisions must be made in upper case but
+# only lower case is to be returned to the calling program.
+
+int procedure grc_mapkey (rc, key, nukey)
+
+pointer	rc			#I rcursor descriptor
+int	key			#U raw key value
+int	nukey			#O mapped key value
+
+begin
+	nukey = max(1, min(MAX_KEYS, key))
+	if (RC_CASE(rc) == NO && IS_LOWER(nukey))
+	    nukey = TO_UPPER(nukey)
+
+	nukey = RC_KEYS(rc,nukey)
+	if (nukey == NULL) {
+	    # Not a cursor mode key.
+	    if (RC_CASE(rc) == NO && IS_UPPER(nukey))
+		key = TO_LOWER(key)
+	} else if (IS_LOWER(nukey))
+	    nukey = TO_UPPER(nukey)
+
+	return (nukey)
+end
+
+
+# GRC_RESTORECURPOS -- Restore the cursor position in NDC coordinates
+# regardless of the current workstation transformation.
+
+procedure grc_restorecurpos (stream, x, y)
+
+int	stream			# graphics stream
+real	x, y			# new cursor position in NDC coords
+real	sx, sy
+include	"gtr.com"
+
+begin
+	call grc_ndctoscr (x, y, sx, sy)
+	call gtr_writecursor (stream, sx, sy)
+end
+
+
+# GRC_READTTY -- Read from the terminal via the graphics kernel.  If the
+# kernel already has message data buffered we merely return that data,
+# otherwise we issue the prompt given and interactively read the data.
+
+int procedure grc_readtty (stream, prompt, obuf, maxch)
+
+int	stream			#I graphics stream
+char	prompt[ARB]		#I prompt, if read is interactive
+char	obuf[ARB]		#O output buffer
+int	maxch			#I max chars out
+
+bool	issue_prompt
+int	nchars, index
+int	stg_msglen(), stg_readtty()
+int	stridxs(), strlen()
+
+begin
+	issue_prompt = (stg_msglen(STDIN) <= 0)
+	if (issue_prompt)
+	    call stg_putline (STDERR, prompt)
+
+	nchars = stg_readtty (STDIN, obuf, maxch)
+	index = stridxs ("\n", obuf)
+	if (index > 0)
+	    obuf[index] = EOS
+	nchars = strlen (obuf)
+
+	if (issue_prompt && nchars == 0)
+	    call grc_message (stream, "\n\n")
+
+	return (nchars)
+end
+
+
+# GRC_MESSAGE -- Write a message on the status line at the bottom of the
+# screen.  If the string is not newline terminated the terminal is left in
+# status line text mode.  To clear the status line and force the terminal
+# back into graphics mode, output the string "\n\n".
+
+procedure grc_message (stream, message)
+
+int	stream			# graphics stream
+char	message[ARB]		# message to be printed
+
+begin
+	call stg_putline (STDERR, message)
+end
+
+
+# GRC_PCURSOR -- Convert the cursor position in screen coordinates to world
+# coordinates and print on the standard output.
+
+procedure grc_pcursor (stream, sx, sy, raster, rx, ry)
+
+int	stream			#I graphics stream
+real	sx, sy			#I screen coords of cursor
+int	raster			#I raster number
+real	rx, ry			#I raster coords of cursor
+
+int	wcs
+real	xc, yc
+pointer	sp, lbuf
+
+begin
+	call smark (sp)
+	call salloc (lbuf, SZ_LINE, TY_CHAR)
+
+	call grc_scrtowcs (stream, sx, sy, raster, rx, ry, xc, yc, wcs)
+	if (abs(xc) > 1 && abs(xc) < 10000 && abs(yc) > 1 && abs(yc) < 10000)
+	    call sprintf (Memc[lbuf], SZ_LINE, "%10.3f %10.3f  \n")
+	else
+	    call sprintf (Memc[lbuf], SZ_LINE, "%12.7g %12.7g  \n")
+	call pargr (xc)
+	call pargr (yc)
+
+	call stg_putline (STDERR, Memc[lbuf])
+	call sfree (sp)
+end