From fa080de7afc95aa1c19a6e6fc0e0708ced2eadc4 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler Date: Wed, 8 Jul 2015 20:46:52 -0400 Subject: Initial commit --- sys/gio/nsppkern/README | 399 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 sys/gio/nsppkern/README (limited to 'sys/gio/nsppkern/README') diff --git a/sys/gio/nsppkern/README b/sys/gio/nsppkern/README new file mode 100644 index 00000000..0990eac0 --- /dev/null +++ b/sys/gio/nsppkern/README @@ -0,0 +1,399 @@ +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 . -- cgit