# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. include include include include "sgk.h" .help sgk .nf --------------------------------------------------------------------------- SGK -- Simple graphics device interface. The purpose of this interface is to provide a simple means for interfacing new plotter devices to IRAF/GIO. The interface works by writing a binary metacode file and then disposing of it by issuing a command to the host system. g_out = sgk_open (device, tty) # device open sgk_close (g_out) # device close sgk_flush (g_out) # flush output sgk_frame (g_out) # start a new frame sgk_move (g_out, x, y) # move to (x,y) sgk_draw (g_out, x, y) # draw a vector to (x,y) sgk_linewidth (g_out, width) # set line width (>=1) The procedures comprising the top end of the SGK interface are summarized above and the code is included in this file. These procedures could be rewritten by the user to talk directly to a graphics device if desired, although the metacode file interface is likely to be simpler in most cases. The SGK kernel can produce either metacode or bitmap output. Metacode output is normally preferred for intelligent plotters and for pen plotters. Bitmap output is normally preferred for raster plotters. The type of output file to be generated is selected by the graphcap entry for an SGI/SGK device. The METACODE FORMAT written by the SGK interface is a sequence of 16 bit integer words containing binary opcodes and data. The metacode is extremely simple, consisting of only two drawing instructions (pen up move and pen down draw), a frame instruction, and an optional set line width instruction. All text is rendered into vectors by the SGI kernel hence there are no text drawing instructions. The SGK metacode instruction formats are summarized below. opcode / data words 1 0 0 # frame instruction 2 X Y # move to (x,y) 3 X Y # draw to (x,y) 4 W 0 # set line width (>= 1, 1=normal, 2=bold) All opcodes and data words are 16 bit positive integers encoded in the machine independent MII format, i.e., most significant byte first. Only 15 bits of each 16 bit word are actually used. Coordinates are specified in the range 0 to 32767. All instructions are zero padded to 3 words to simplify metacode translation programs. The BITMAP FORMAT written by the SGK is even simpler than the metacode format. Output consists of a binary raster file containing one or more bitmaps with no embedded header information. All bitmaps in a raster file are of the same size. The size is specified in the graphcap entry for the device and may be passed to the host dispose task on the foreign task command line if desired. Page offsets may also be passed on the command line, e.g., to position the plot on the plotter page. The following graphcap fields apply to both metacode and bitmap devices. DD host command to dispose of metacode file ($F) DB have the kernel print debug messages during execution RM boolean; if present, SGK will delete metacode file MF multiframe count (max frames per job) NF store each frame in a new file (rather than all in one file) RO rotate plot (swap x and y) YF y-flip plot (flip y axis) (done after rotate) The following additional fields are defined for bitmap devices. BI boolean; presence indicates a bitmapped or raster device LO width in device pixels of a line of size 1.0 LS difference in device pixels between line sizes PX physical x size (linelen) of bitmap as stored in memory, bits PY physical y size of bitmap, i.e., number of lines in bitmap XO,YO origin of plotting window in device pixels XW,YW width of plotting window in device pixels NB number of bits to be set in each 8 bit byte output BF bit-flip each byte in bitmap (easier here than later) BS byte swap the bitmap when output (swap every two bytes) WS word swap the bitmap when output (swap every four bytes) The multiframe count (MF) limits the number of frames per job, where a job refers to the dispose command submitted to the host to process the frames. If the new file flag (NF) is absent, all frames will be stored in the same physical file (this holds for both metacode and bitmap frames). If the new file flag (NF) is set, each frame will be stored in a separate file, with the N files having the names $F.1, $F.2, ... $F.N, where $F is the unique (root) filename generated from the template given in the DD string. The $F is replaced by the root filename, rather than by a list of all the filenames, to keep the OS command to a reasonable length and to permit the use of host file templates to perform operate upon the full set of files (and to avoid having to choose between spaces and commas to delimit the filenames). For example, if MF=8 and NF=yes, then "$F.[1-8]" will match the file set on a UNIX host. The template "$F.*" is less precise but would also work. The output raster will consist of PY lines each of length PX bits. If PX is chosen to be a multiple of 8, there will be PX/8 bytes per line of the output raster. Note that the values of PX and PY are arbitrary and should be chosen to simplify the code of the translator and maximize efficiency. In particular, PX and PY do not in general define the maximum physical resolution of the device, although if NB=8 the value of PX will typically approximate the physical resolution in X. If there are multiple bitmap frames per file, each frame will occupy an integral number of SPP char units of storage in the output file, with the values of any extra bits at the end of the bitmap being undefined (a char is 16 bits on most IRAF host machines). The plot will be rasterized in a logical window XW one-bit pixels wide and YW pixels high. The first YO lines of the output raster will be zero, with the plotting window beginning at line YO+1. The first XO bits of each output line will be zeroed, with the plotting window beginning at bit XO+1. The bytes in each output line may be bit-flipped if desired, and all of the bits in each output byte need not be used for pixel data. If the bit packing factor NB is set to 8 the plotting window will map into XW bits of storage of each output line. If fewer than 8 bits are used in each output byte more than XW physical bits of storage will be used, e.g., if NB=4, XW*2 bits of storage are required for a line of the plotting window. The unused bits are set to zero. The translator can later "or" a mask into the zeroed bits, flip the data bits, or perform any other bytewise operation using simple lookup table mapping techniques. .endhelp ---------------------------------------------------------------------- # NOTE -- The mf_physbit lookup table, used to map logical screen bits into # physical bits in the bitmap (for NB != 8) is equivalenced to the mf_obuf # array which is not otherwise used for bitmap devices. The length of the # mf_obuf array must therefore be >= PX. define mf_physbit mf_obuf # union these two arrays [[[NOTE]]] define BPW NBITS_INT # nbits in an integer define LEN_FBUF (2550*3300/BPW) # max size bitmap / frame buffer define LEN_OBUF 3300 # nwords in output buffer define SZ_DDSTR 256 # max size graphcap.DD define SZ_OSCMD 256 # OS dispose command from graphcap.DD # SGK_OPEN -- Open the metacode file. Parse the DD string from the graphcap # entry for the device to get the file template and OS dispose command. # Generate a unique file name and open the metacode file as a NEW_FILE. # Save the dispose command for later. int procedure sgk_open (device, tty) char device[ARB] # device name [NOT USED] pointer tty # pointer to graphcap descriptor char cap[2] int len_nodeprefix, byte, off, op, i, j pointer sp, raw_ddstr, ddstr, devname, spool, fname, tempfn, val, ip bool ttygetb() real ttygetr() int open(), ttygets(), ttygeti(), gstrcpy(), shifti() errchk open, ttygets, ttygeti, ttygetb include "sgk.com" begin call smark (sp) call salloc (raw_ddstr, SZ_DDSTR, TY_CHAR) call salloc (ddstr, SZ_DDSTR, TY_CHAR) call salloc (devname, SZ_FNAME, TY_CHAR) call salloc (spool, SZ_FNAME, TY_CHAR) call salloc (fname, SZ_PATHNAME, TY_CHAR) call salloc (tempfn, SZ_PATHNAME, TY_CHAR) call salloc (val, SZ_FNAME, TY_CHAR) # The DB flag may be set in the graphcap entry for an SGI device to # print debug messages during execution. mf_debug = ttygetb (tty, "DB") # The DD string is used to pass device dependent information to the # graphics device driver. if (ttygets (tty, "DD", Memc[raw_ddstr], SZ_DDSTR) <= 0) call error (1, "sgikern: missing DD parameter in graphcap") # Expand any $(XX) graphcap parameter references in the DD string. op = ddstr for (ip=raw_ddstr; Memc[ip] != EOS; ip=ip+1) if (Memc[ip] == '$' && Memc[ip+1] == '(' && Memc[ip-1] != '\\') { # Graphcap parameter substitution. call strcpy (Memc[ip+2], cap, 2) if (ttygets (tty, cap, Memc[val], SZ_FNAME) <= 0) { call eprintf ("Warning: graphcap field `%s' not found\n") call pargstr (cap) } else { for (off=val; Memc[off] == '#'; off=off+1) ; for (; Memc[off] != EOS; off=off+1) { Memc[op] = Memc[off] op = op + 1 } } ip = ip + 4 } else { # Ordinary character. Memc[op] = Memc[ip] op = op + 1 } Memc[op] = EOS # Parse the DD string into the node/device name, temp file name, # and host dispose command. # Get node and device name (e.g., "node!device,..."). len_nodeprefix = 0 ip = ddstr for (op=devname; Memc[ip] != EOS; ip=ip+1) if (Memc[ip] == ',') { if (Memc[ip-1] == '\\') { Memc[op-1] = ',' ip = ip - 1 } else { ip = ip + 1 break } } else { if (Memc[ip] == FNNODE_CHAR) len_nodeprefix = op - devname + 1 Memc[op] = Memc[ip] op = op + 1 } Memc[op] = EOS # Get spoolfile root name. op = spool + gstrcpy (Memc[devname], Memc[spool], len_nodeprefix) for (; Memc[ip] != EOS; ip=ip+1) if (Memc[ip] == ',') { if (Memc[ip-1] == '\\') { Memc[op-1] = ',' ip = ip - 1 } else { ip = ip + 1 break } } else { Memc[op] = Memc[ip] op = op + 1 } Memc[op] = EOS # Get OS pathname of spoofile. call mktemp (Memc[spool], Memc[tempfn], SZ_PATHNAME) call fmapfn (Memc[tempfn], mf_fname, SZ_PATHNAME) call strupk (mf_fname, mf_fname, SZ_PATHNAME) # Get pathname of spoolfile on the remote node. The call to # ki_fmapfn() is currently necessary to translate the filename for # the remote node, but may be replaced by the usual fmapfn() in a # future version of the kernel interface. call ki_fmapfn (Memc[tempfn], Memc[fname], SZ_PATHNAME) call strupk (Memc[fname], Memc[fname], SZ_PATHNAME) if (mf_debug) { call eprintf ("sgk: open device %s, outfile = %s\n") call pargstr (Memc[devname]) call pargstr (mf_fname) } # Copy OS command for disposing of metacode file into common, replacing # all $F sequences in the command by the OS pathname of the spool file. op = gstrcpy (Memc[devname], mf_dispose, len_nodeprefix) + 1 for (; Memc[ip] != EOS; ip=ip+1) if (Memc[ip] == '$' && Memc[ip-1] == '\\') { # Escape a $. mf_dispose[op-1] = '$' } else if (Memc[ip] == '$' && Memc[ip+1] == 'F') { # Filename substitution. for (i=fname; Memc[i] != EOS; i=i+1) { mf_dispose[op] = Memc[i] op = op + 1 } ip = ip + 1 } else { # Ordinary character. mf_dispose[op] = Memc[ip] op = op + 1 } mf_dispose[op] = EOS # Remove (delete) metacode file after issuing OS dispose command? mf_delete = ttygetb (tty, "RM") # Store each frame in a new file? mf_oneperfile = ttygetb (tty, "NF") mf_update = false mf_frame = 1 # Open a new metacode file. if (mf_oneperfile) call sgk_mkfname (mf_fname, mf_frame, Memc[fname], SZ_FNAME) else call strcpy (mf_fname, Memc[fname], SZ_FNAME) if (mf_debug) { call eprintf ("sgk: open frame %2d, outfile = %s\n") call pargi (mf_frame) call pargstr (Memc[fname]) } mf_fd = open (Memc[fname], NEW_FILE, BINARY_FILE) # Rotate plot (swap x,y)? Y-flip plot? mf_rotate = ttygetb (tty, "RO") mf_yflip = ttygetb (tty, "YF") # Raster (bitmap) or metacode device? mf_bitmap = ttygetb (tty, "BI") if (mf_bitmap) { # Bitmap output; initialize bitmap parameters. mf_pxsize = ttygeti (tty, "PX") mf_pysize = ttygeti (tty, "PY") mf_xorigin = ttygeti (tty, "XO") mf_yorigin = ttygeti (tty, "YO") mf_wxsize = ttygeti (tty, "XW") mf_wysize = ttygeti (tty, "YW") mf_nbpb = ttygeti (tty, "NB") mf_swap2 = ttygetb (tty, "BS") mf_swap4 = ttygetb (tty, "WS") mf_lworigin = max (1, ttygeti (tty, "LO")) mf_lwslope = ttygetr (tty, "LS") mf_lenframe = (mf_pxsize * mf_pysize + BPW-1) / BPW if (mf_wxsize == 0) mf_wxsize = mf_pxsize - mf_xorigin if (mf_wysize == 0) mf_wysize = mf_pysize - mf_yorigin if (mf_nbpb == 0) mf_nbpb = NBITS_BYTE mf_linewidth = mf_lworigin mf_cx = 0 mf_cy = 0 mf_xmin = mf_xorigin mf_ymin = mf_yorigin mf_xmax = mf_xmin + mf_wxsize - 1 mf_ymax = mf_ymin + mf_wysize - 1 mf_xscale = real(mf_wxsize) / real(GKI_MAXNDC) mf_yscale = real(mf_wysize) / real(GKI_MAXNDC) if (mf_lenframe > LEN_FBUF) call error (1, "sgikern: bitmap too large") # Initialize the bit mask table. If it is necessary to bit-flip # bytes in the bitmap, we can do that here by flipping each byte # of the word mask. Bit flipping can be done during rasterization # at no additional cost, but is an expensive operation if done # later with a filter. if (ttygetb (tty, "BF")) { do j = 1, (BPW/NBITS_BYTE) do i = 1, NBITS_BYTE { off = (j - 1) * NBITS_BYTE mf_bitmask[off+i] = shifti (1, off + NBITS_BYTE - i) } } else { do i = 1, BPW mf_bitmask[i] = shifti (1, i - 1) } # Initialize the bit offset lookup table. This gives the physical # x-offset into the lookup table of each addressable x-coordinate # on the device. If NB is NBITS_BYTE the mapping is one-to-one. # Note that the table contains zero-indexed bit offsets. do i = 1, mf_pxsize { byte = (i - 1) / mf_nbpb mf_physbit[i] = min (mf_pxsize, byte * NBITS_BYTE + (i - (byte * mf_nbpb))) - 1 } if (mf_debug) { call eprintf ("bitmap [%d,%d] origin=[%d,%d] wsize=[%d,%d]\n") call pargi (mf_pxsize); call pargi (mf_pysize) call pargi (mf_xorigin); call pargi (mf_yorigin) call pargi (mf_wxsize); call pargi (mf_wysize) } } else { # Metacode output; initialize the metacode output buffer. mf_op = 1 if (mf_debug) call eprintf ("metafile device\n") } call sfree (sp) return (mf_fd) end # SGK_CLOSE -- Close the metacode spool file and dispose of it to a host system # metacode translation task. Delete the spool file when the OS command # completes, unless it has already been deleted by the task run. procedure sgk_close (fd) int fd # output stream [NOT USED] int i pointer sp, fname int oscmd() errchk sgk_flush, close, oscmd include "sgk.com" begin call smark (sp) call salloc (fname, SZ_FNAME, TY_CHAR) if (mf_debug) call eprintf ("close device\n") if (mf_bitmap) call sgk_frame (mf_fd) else call sgk_flush (mf_fd) if (mf_debug) { call eprintf ("dispose: %s\n") call pargstr (mf_dispose) } if (mf_fd != NULL) { call close (mf_fd) mf_fd = NULL } # Send the dispose command to the host system. if (mf_dispose[1] != EOS) if (oscmd (mf_dispose, "", "", "") != OK) call eprintf ("Warning: SGK graphics output dispose error\n") # Delete the metacode or raster file if so indicated in the graphcap # entry for the device. if (mf_delete) { if (mf_debug) { call eprintf ("delete metafile %s\n") call pargstr (mf_fname) } if (mf_oneperfile) { do i = 1, mf_frame { call sgk_mkfname (mf_fname, i, Memc[fname], SZ_FNAME) iferr (call delete (Memc[fname])) ; } } else iferr (call delete (mf_fname)) ; } call sfree (sp) end # SGK_FLUSH -- Flush any buffered metacode output. procedure sgk_flush (fd) int fd # output stream [NOT USED] include "sgk.com" begin if (!mf_bitmap && mf_op > 1) { if (mf_debug) call eprintf ("flush graphics output\n") call miiwrites (mf_fd, mf_obuf, mf_op-1) mf_op = 1 } if (mf_fd != NULL) call flush (mf_fd) end # SGK_FRAME -- Output a frame advance instruction. procedure sgk_frame (fd) int fd # output stream [NOT USED] include "sgk.com" begin # Ignore frame commands if frame is empty. if (!mf_update) return if (mf_debug) call eprintf ("start a new frame\n") if (mf_bitmap) { # Write the bitmap to the output raster-file. if (mf_swap2) call bswap2 (mf_fbuf, 1, mf_fbuf, 1, mf_lenframe * SZ_INT * SZB_CHAR) if (mf_swap4) call bswap4 (mf_fbuf, 1, mf_fbuf, 1, mf_lenframe * SZ_INT * SZB_CHAR) call write (mf_fd, mf_fbuf, mf_lenframe * SZ_INT) } else { # Write the SGI frame instruction to the output mcode-file. if (mf_op + SGK_LENMCI > LEN_OBUF) { call miiwrites (mf_fd, mf_obuf, mf_op-1) mf_op = 1 } mf_obuf[mf_op] = SGK_FRAME mf_obuf[mf_op+1] = 0 mf_obuf[mf_op+2] = 0 mf_op = mf_op + SGK_LENMCI } mf_frame = mf_frame + 1 mf_update = false end # SGK_MOVE -- Output a pen move instruction. procedure sgk_move (fd, x, y) int fd # output stream [NOT USED] int x, y # point to move to include "sgk.com" begin if (mf_bitmap) { if (mf_rotate) { mf_cx = y mf_cy = x } else { mf_cx = x mf_cy = y } if (mf_yflip) mf_cy = GKI_MAXNDC - mf_cy # Convert to zero indexed coordinates and clip at boundary. # Allow room for line width shift near boundary. mf_cx = max (mf_xmin, min (mf_xmax, int (mf_cx * mf_xscale) + mf_xorigin)) mf_cy = max (mf_ymin, min (mf_ymax, int (mf_cy * mf_yscale) + mf_yorigin)) } else { if (mf_op + SGK_LENMCI > LEN_OBUF) { call miiwrites (mf_fd, mf_obuf, mf_op-1) mf_op = 1 } mf_obuf[mf_op] = SGK_MOVE if (mf_rotate) { mf_obuf[mf_op+1] = y mf_obuf[mf_op+2] = x } else { mf_obuf[mf_op+1] = x mf_obuf[mf_op+2] = y } if (mf_yflip) mf_obuf[mf_op+2] = GKI_MAXNDC - mf_obuf[mf_op+2] mf_op = mf_op + SGK_LENMCI } end # SGK_DRAW -- Output a pen draw instruction. procedure sgk_draw (fd, a_x, a_y) int fd # output stream [NOT USED] int a_x, a_y # point to draw to char fname[SZ_FNAME] int xshift, yshift, dx, dy int new_x, new_y, x1, y1, x2, y2, n, i int open() errchk open, close include "sgk.com" begin if (mf_rotate) { new_x = a_y new_y = a_x } else { new_x = a_x new_y = a_y } if (mf_yflip) new_y = GKI_MAXNDC - new_y if (!mf_update) { # We are called when the first drawing instruction is output for a # new frame. We clear the bitmap or close and open a new frame # file here, rather than at sgk_frame() time, as we do not want # to initialize the frame buffer or open a new frame file unless # we are actually going to write into the frame. # Zero out all the bits in a bitmap. if (mf_bitmap) call aclri (mf_fbuf, mf_lenframe) # Open a new frame file if the one frame per file flag is set. if (mf_oneperfile && mf_frame > 1) { if (mf_fd != NULL) call close (mf_fd) call sgk_mkfname (mf_fname, mf_frame, fname, SZ_FNAME) if (mf_debug) { call eprintf ("sgk: open frame %2d, outfile = %s\n") call pargi (mf_frame) call pargstr (fname) } mf_fd = open (fname, NEW_FILE, BINARY_FILE) } mf_update = true } if (mf_bitmap) { # Convert to zero indexed coordinates and clip at boundary. # Allow room for line width shift near boundary. new_x = max (mf_xmin, min (mf_xmax, int (new_x * mf_xscale) + mf_xorigin)) new_y = max (mf_ymin, min (mf_ymax, int (new_y * mf_yscale) + mf_yorigin)) if (mf_linewidth <= 1) call sgk_vector (mf_cx, mf_cy, new_x, new_y) else { # Redraw the vector several times with small normal shifts to # produce a wider line. xshift = 0 yshift = 0 if (abs (new_x - mf_cx) > abs (new_y - mf_cy)) { dx = 0 dy = 1 } else { dx = 1 dy = 0 } do i = 1, mf_linewidth { x1 = mf_cx + xshift y1 = mf_cy + yshift x2 = new_x + xshift y2 = new_y + yshift call sgk_vector (x1, y1, x2, y2) n = (i + 1) / 2 if (and (i, 1) == 0) { xshift = dx * n yshift = dy * n } else { xshift = -dx * n yshift = -dy * n } } } # Update the current pen position, and set the update flag so that # the bitmap will be written to the output file. mf_cx = new_x mf_cy = new_y } else { # Output a metacode draw instruction. if (mf_op + SGK_LENMCI > LEN_OBUF) { call miiwrites (mf_fd, mf_obuf, mf_op-1) mf_op = 1 } mf_obuf[mf_op] = SGK_DRAW mf_obuf[mf_op+1] = new_x mf_obuf[mf_op+2] = new_y mf_op = mf_op + SGK_LENMCI } end # SGK_VECTOR -- Write a vector (line) of unit width into the bitmap. The line # endpoints are expressed in physical device coordinates. procedure sgk_vector (a_x1, a_y1, a_x2, a_y2) int a_x1, a_y1 # start point of line int a_x2, a_y2 # end point of line real dydx, dxdy long fbit, wbit, word int wpln, mask, dx, dy, x, y, x1, y1, x2, y2, or() include "sgk.com" begin x1 = a_x1; y1 = a_y1 x2 = a_x2; y2 = a_y2 dx = x2 - x1 dy = y2 - y1 if (abs(dx) > abs(dy)) { if (x1 > x2) { x1 = a_x2; x2 = a_x1; dx = -dx y1 = a_y2; y2 = a_y1; dy = -dy } if (dy == 0 && mf_nbpb == NBITS_BYTE) { # Somewhat optimized code for the case of a horiz. vector. fbit = y1 * mf_pxsize + x1 word = fbit / BPW wbit = and (fbit, BPW-1) do x = x1, x2 { mf_fbuf[word+1] = or (mf_fbuf[word+1], mf_bitmask[wbit+1]) wbit = wbit + 1 if (wbit >= BPW) { wbit = 0 word = word + 1 } } } else { # The general case for a mostly-X vector. dydx = real(dy) / real(dx) do x = x1, x2 { y = int ((x - x1) * dydx) + y1 fbit = y * mf_pxsize + mf_physbit[x+1] word = fbit / BPW wbit = and (fbit, BPW-1) mf_fbuf[word+1] = or (mf_fbuf[word+1], mf_bitmask[wbit+1]) } } } else if (dy != 0) { if (y1 > y2) { x1 = a_x2; x2 = a_x1; dx = -dx y1 = a_y2; y2 = a_y1; dy = -dy } if (dx == 0) { # Optimized code for the case of a vertical vector. fbit = y1 * mf_pxsize + mf_physbit[x1+1] word = fbit / BPW + 1 wbit = and (fbit, BPW-1) wpln = (mf_pxsize + BPW-1) / BPW mask = mf_bitmask[wbit+1] do y = y1, y2 { mf_fbuf[word] = or (mf_fbuf[word], mask) word = word + wpln } } else { # The general case of a mostly-Y vector. dxdy = real(dx) / real(dy) do y = y1, y2 { x = int ((y - y1) * dxdy) + x1 fbit = y * mf_pxsize + mf_physbit[x+1] word = fbit / BPW wbit = and (fbit, BPW-1) mf_fbuf[word+1] = or (mf_fbuf[word+1], mf_bitmask[wbit+1]) } } } else { # Plot a single point (dx=dy=0). fbit = y1 * mf_pxsize + mf_physbit[x1+1] word = fbit / BPW wbit = and (fbit, BPW-1) mf_fbuf[word+1] = or (mf_fbuf[word+1], mf_bitmask[wbit+1]) } end # SGK_LINEWIDTH -- Output a line width set instruction. procedure sgk_linewidth (fd, width) int fd # output stream [NOT USED] int width # new line width int gap include "sgk.com" begin if (mf_bitmap) { # Set the line width in device pixels. mf_linewidth = max (1, mf_lworigin + int ((width-1) * mf_lwslope)) # Set the clipping limits. Allow for shifting to widen lines. gap = mf_linewidth - 1 mf_xmin = mf_xorigin + gap mf_ymin = mf_yorigin + gap mf_xmax = mf_xorigin + (mf_wxsize - 1) - gap mf_ymax = mf_yorigin + (mf_wysize - 1) - gap } else { if (mf_op + SGK_LENMCI > LEN_OBUF) { call miiwrites (mf_fd, mf_obuf, mf_op-1) mf_op = 1 } mf_obuf[mf_op] = SGK_SETLW mf_obuf[mf_op+1] = width mf_obuf[mf_op+2] = 0 mf_op = mf_op + SGK_LENMCI } end # SGK_MKFNAME -- Make the name of file N of a multiframe set. procedure sgk_mkfname (root, num, outstr, maxch) char root[ARB] # root filename int num # file number char outstr[maxch] # receives new filename int maxch begin call sprintf (outstr, maxch, "%s.%d") call pargstr (root) call pargi (num) end