path: root/sys/gio/nsppkern/README

This directory contains the source for the NSPP/GIO kernel, the interface
between GIO and the old Ncar system plot package and associated metacode
translators.

Special graphcap entries used by this kernel:

	MF		maximum frame count per metafile
	FS		frame advance req'd at start of metafile
	FE		frame advance req'd at end of metafile

Rev 1.0 installed in March 1985.
----------------------------------------------------------------------------

Differences between Rev 1.0 and Rev 1.1 of the NSPP/GIO kernel.
Collated at installation of Rev 1.1 on 24 April 1985.
----------------------------------------------------------------------------

gktclose.x
+ diff gktclose.x ../nsppkern.old/gktclose.x 
12,13d11
< 	call frame
< 	call gkt_flush
+ echo gktclosews.x 
gktinit.x
+ diff gktinit.x ../nsppkern.old/gktinit.x 
49a50,59
> 	# get the window offsets
> 
> 	g_xoff = ttygeti (tty, "XO")
> 	if (g_xoff < 0)
> 	    g_xoff = 0
> 	g_yoff = ttygeti (tty, "YO")
> 	if (g_yoff < 0)
> 	    g_yoff = 0
> 
> 
112d121
< 	GKT_PIXREP(g_kt)     = btoi (ttygetb (tty, "pr"))
gktopenws.x
+ diff gktopenws.x ../nsppkern.old/gktopenws.x 
98,104c98,99
< 	if (mode == NEW_FILE) {
< 	    # Frame call only if NEW_FILE and not first time open with
< 	    # this device.  This prevents frame before first data.
< 	    if (!need_open)
< 	        call frame
< 	    call gkt_reset
< 	}
---
> 	if (mode == NEW_FILE)
> 	    call frame()
+ echo gktpcell.x 
gktpcell.x
+ diff gktpcell.x ../nsppkern.old/gktpcell.x 
8a9
> 
12c13
< procedure gkt_putcellarray (m, nc, nr, ax1,ay1, ax2,ay2)
---
> procedure gkt_putcellarray (m, nc, nr, x1,y1, x2,y2)
17,18c18,19
< int	ax1, ay1		# lower left corner of output window
< int	ax2, ay2		# upper right corner of output window
---
> int	x1, y1			# lower left corner of output window
> int	x2, y2			# upper right corner of output window
20d20
< int	x1,y1,x2,y2		# device coordinates
22c22
< int	nx, ny, y
---
> int	nx, ny
28c28
< bool	ca, use_orig, new_row, pr
---
> bool	ca, use_orig, new_row
31,32d30
< real	delta_y
< int	xrep, yrep
43c41
< 	# Determine if can do real cell array.  If not, use character
---
> 	# determine if can do real cell array.  If not, use character
49d46
< 	pr = false
53d49
< 	    pr = (GKT_PIXREP(g_kt) != 0)
65,66c61
< 	# Input arguments (ax, ay) refer to corners of put cell array;
< 	# we need corners of the corresponding device array.
---
> 	# find out how many real pixels we have to fill
68,73c63,66
< 	x1 = ax1
< 	x2 = ax2
< 	y1 = ay1
< 	y2 = ay2
< 	call adjust(x1,x2,xres)
< 	call adjust(y1,y2,yres)
---
> 	px1 = real(x1)/GKI_MAXNDC
> 	py1 = real(y1)/GKI_MAXNDC
> 	px2 = real(x2)/GKI_MAXNDC
> 	py2 = real(y2)/GKI_MAXNDC
75,79c68,69
< 	# Find out how many real pixels we have to fill
< 	px1 = real(x1)/(GKI_MAXNDC+1)
< 	py1 = real(y1)/(GKI_MAXNDC+1)
< 	px2 = real(x2)/(GKI_MAXNDC+1)
< 	py2 = real(y2)/(GKI_MAXNDC+1)
---
> 	nx = int( (px2 - px1) * (xres-1.0) + 1.5 )
> 	ny = int( (py2 - py1) * (yres-1.0) + 1.5 )
81,90c71
< 	nx = int( px2 * xres ) - int( px1 * xres ) + 1
< 	ny = int( py2 * yres ) - int( py1 * yres ) + 1
< 
< 	if ( ny > 1)
< 	     delta_y = (real(y2) - real(y1))/ny
< 	else {
< 	     delta_y = 0.
< 	}
< 
< 	# If too many data points in input, set skip.  If skip is close
---
> 	# if too many data points in input, set skip.  If skip is close
92,93c73,74
< 	# Set block replication factors - will be > 1.0 if too few input points.
< 	# Cannot set to 1.0 if "close" enough, since, if > 1.0, we don't have
---
> 	# set block replication factors - will be > 1.0 if too few input points.
> 	# cannot set to 1.0 if "close" enough, since, if > 1.0, we don't have
110c91,101
< 	# Allocate storage for a row of pixels.  This is quite inefficient
---
> 
> 	# try for the simplest case: 1:1 match with input data
> 
> 	if ( ca && (nx == nc) && (ny == nr) ) {
> 	    call pixels( real(x1)/GKI_MAXNDC, real(y1)/GKI_MAXNDC,
> 		nx, ny, m)
> 	    call sfree(sp)
> 	    return
> 	}
> 
> 	# allocate storage for a row of pixels.  This is quite inefficient
113d103
< 	# need nx+1 in case nx odd ... pixels() wants to pad output.
115,116c105
< 	call salloc ( cell, nx+1, TY_SHORT)
< 	Mems[cell + nx] = 0
---
> 	call salloc ( cell, nx, TY_SHORT)
118c107
< 	# Initialize counters
---
> 	# initialize counters
125c114
< 	# See if we can use original data ... no massaging
---
> 	# see if we can use original data ... no massaging
128c117
< 	# Note that if blockx > 1.0, skip_x must be 1.0, and vv
---
> 	# note that if blockx > 1.0, skip_x must be 1.0, and vv
138,152c127
< 	# If device can pixel replicate, use that feature where we can
< 	if( pr) {
< 	    if( (skip_x == 1.0) && ( int(blockx) == blockx) ) {
< 		 xrep = int(blockx)
< 		 use_orig = true
< 		 nx = nc
< 	    } else
< 		 xrep = 1
< 	    if( (skip_y == 1.0) && ( int(blocky) == blocky) ) {
< 		 yrep = int(blocky)
< 		 ny = 1
< 	    } else
< 		 yrep = 1
< 	}
< 	call pixel0(1,0,xrep,0,1,yrep)
---
> 	# do it
154c129
< 	# Do it
---
> 	for (i = 1;  i <= ny;  i = i + 1) {
156c131
< 	for ( i = 1; i <= ny ; i = i + 1) {
---
> 	    # Build the row data.
158,159d132
< 	    # Build the row data
< 
161c134
< 		if ( skip_x == 1.0) {
---
> 		if ( skip_x == 1.0)
163c136
< 		} else {
---
> 		else {
181d153
< 		y = y1 + ((i - 1)*delta_y + 0.5)
183,184c155,159
< 		        call pixels( px1, real(y)/GKI_MAXNDC,
< 			    nx, 1, m[element])
---
> 		    if ( i == 1 )
> 		        call pixelr( real(x1)/GKI_MAXNDC, real(y1)/GKI_MAXNDC,
> 			    nx, ny, m[element])
> 		    else
> 		        call pixeli( 0., 0., nx, 1, m[element])
186c161,165
< 		        call pixels( px1, real(y)/GKI_MAXNDC, nx, 1, Mems[cell])
---
> 		    if ( i == 1 )
> 		        call pixelr( real(x1)/GKI_MAXNDC, real(y1)/GKI_MAXNDC,
> 			    nx, ny, Mems[cell])
> 		    else
> 		        call pixeli( 0., 0., nx, 1, Mems[cell])
188,189c167
< 	    }   
< 	    else
---
> 	    } else
192c170
< 	    # Advance a row
---
> 	    # Advance a row.
206c184
< 	# All done, restore text parameters and release storage
---
> 	# all done, restore text parameters and release storage
209c187
< 	    call restoretx (txsave,tx)
---
> 	    call restoretx(txsave,tx)
212a191
> 
218d196
< pointer savep, txp
219a198
> pointer savep, txp
254a234
> 
258d237
< pointer savep, txp
259a239
> pointer savep, txp
263c243
< 	# Restore values
---
> 	# restore values
283a264
> 
287c268,269
< procedure fakepc (indata, outdata, nx,  scale)
---
> procedure fakepc( indata, outdata, nx,  scale)
> 
298c280
< data cdata /' ', '.', ':', '|', 'i', 'l', 'J', 'm', '#', 'S', 'B', EOS/
---
> data	cdata /' ', '.', ':', '|', 'i', 'l', 'J', 'm', '#', 'S', 'B', EOS/
330,374d311
< end
< 
< # ADJUST -- round/truncate putcell array corners to device coordinates
< # move up lower bound if it is above center point of device cell,
< # move down upper bound if below.  Don't allow bounds to go beyond
< # resolution or below zero.  Do not allow bounds to cross.  Part of the
< # assumptions behind all this is that putcells will be continguous and
< # rows/columns must not be plotted twice.
< 
< procedure adjust ( lower, upper, res)
< 
< int	lower, upper
< real	res
< 
< real	factor
< real	low, up
< 
< begin
< 	factor = res/(GKI_MAXNDC+1)
< 	low = real(lower) * factor
< 	up  = real(upper) * factor
< 
< 	# if boundaries result in same row, return
< 	if ( int(low) == int(up) )
< 	    return
< 
< 	# if low is in upper half of device pixel, round up
< 	if ( (low - int(low)) >= 0.5 ) {
< 	    low = int(low) + 1
< 	    # don't go to or beyond upper bound
< 	    if ( low < up ) {
< 	        # ... 0.2 just for "rounding protection";
< 		lower = (low + 0.2)/factor
< 	        # if now reference same cell, return
< 		if ( int(low) == int(up) )
< 		    return
< 	    }
< 	}
< 
< 	# if "up" in bottom half of pixel, drop down one.  Note that
< 	# due to two "==" tests above, upper will not drop below lower.
< 	# 0.2 means drop partway down into pixel below; calling code will
< 	# truncate.
< 	if ( (up - int(up)) < 0.5 )
< 	    upper = real(int(up) - 0.2)/factor
+ echo gktpl.x 
gktpl.x
+ diff gktpl.x ../nsppkern.old/gktpl.x 
51,52c51,52
< 	x = p[1]
< 	y = p[2]
---
> 	x = p[1] + g_xoff
> 	y = p[2] + g_yoff
58,59c58,59
< 	    x = p[i]
< 	    y = p[i+1]
---
> 	    x = p[i] + g_xoff
> 	    y = p[i+1] + g_yoff
gktpm.x
+ diff gktpm.x ../nsppkern.old/gktpm.x 
48,49c48,49
< 	x = p[1]
< 	y = p[2]
---
> 	x = p[1] + g_xoff
> 	y = p[2] + g_yoff
63,64c63,64
< 	    x = p[i]
< 	    y = p[i+1]
---
> 	    x = p[i] + g_xoff
> 	    y = p[i+1] + g_yoff
+ echo gktpmset.x 
gkttx.x
+ diff gkttx.x ../nsppkern.old/gkttx.x 
109,110c109,110
< 		call pwrity (real(x)/GKI_MAXNDC,
< 			real(y)/GKI_MAXNDC, Memc[pstring], seglen,
---
> 		call pwrity (real(x+g_xoff)/GKI_MAXNDC,
> 			real(y+g_yoff)/GKI_MAXNDC, Memc[pstring], seglen,
_____________________________________________________________________________

25Apr85	gktpl.x
	Call to optn to set line width changed to set option "inten" instead
	of "spot size", which was not changing the line width.

26Apr85 gktpm.x
	Same change as one to gktpl.x

	Character size as used in gkttx.x is a floating point number, but
	NCAR pwry.f uses an integer value -- the conversion was causing
	centering errors as gkttx.x would calculate a "path length" for
	the text based on one size, and pwry.f would use a different size
	to generate the text.  Changed pwry.f to use a floating point
	size as an input variable, changed gkttx.x to send same.

	gktpcell.x
	Moved pixel0 call inside the "if (pr) {" statment, where it should
	have been.

	graphcap
	Added  "pr" capablility flag to dicomed entry.  Changed character
	height to reflect the 9 to 8 ratio that pwry uses.


---------------------------------------------------------------------------
Rev 1.2 10 May 1985 Dct.

Fairly extensive modifications made to minimize the number of frame calls
and metafiles generated.  Redundant CLEAR calls or clear calls immediately
after open workstation are ignored.  Multiple frames are permitted in a
metafile (formerly the metafile was disposed after each frame).  Graphcap
parameters were added to control automatic frame advances at the beginning
and end of metafiles.

---------------------------------------------------------------------------
Rev 1.3 1 June 1985 Dct.

[1] Fixed a bug in polymarker; was drawing polylines.

[2] Replaced the old character generation code by all new code, using the stroke
table from the NCAR/GKS code.  Replaced "pwry.f" by the much simpler
"gktdrawch.x".  Largely copied the stdgraph "stgtx.x", including the clipping
logic therein.

17-Aug-85 Dct.
	Added support for the new DD graphcap parameter, used to pass device
	dependent information to the device driver.  This information was
	formerly encoded in a table at compile time, with the table defined
	in <libc/kernel.h>.