+
+/*-----------------------------------------------------------------------------
+ * Copyright (c) 1984, 1985, 1986 Xerox Corp.
+ *
+ * ipress - most of the code directly dependent on interpress used by dipress
+ * to produce an interpress file from device independent troff
+ * intermediate code.
+ *
+ * William LeFebvre
+ *
+ *
+ * HISTORY
+ * 12-Aug-86 Lee Moore (lee) at Xerox Webster Research Center
+ * Added positioning option to the RES command.
+ *
+ *
+ * 07-Jul-86 Lee Moore (lee) at Xerox Webster Research Center
+ * Updated IPDeviceType for services 10.0 .
+ *
+ * 24-Feb-86 Lee Moore (lee) at Xerox Webster Research Center
+ * Added a subroutine to emit the SequenceInsertFile command.
+ *
+ * John Mellor-Crummey 28-aug-1985
+ * restructuring and minor modifications
+ *
+ * ed flint 10-may-1985
+ * coerce device.num_char_wid to unsigned char, change
+ * ch argument in outputChar to unsigned int
+ * since we now have > 128 special characters
+ *---------------------------------------------------------------------------*/
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include <signal.h>
+#include <math.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+
+#include "deviceinfo.h" /* typesetter characteristics */
+
+#include "iptokens.h" /* \ */
+#include "literal.h" /* > interface levels for interpress */
+#include "operator.h" /* / */
+
+#include "defs.h" /* constant and macro definitions */
+#include "externs.h" /* declarations for global variables */
+
+
+
+/* initialize device */
+initDevice()
+{
+ int lines = 0;
+ int timapf;
+ int ret;
+ register char *ptr;
+ register char **ipp;
+ register char **trp;
+ char temp[60];
+ struct stat stbuf;
+
+ if (dbg) printf("initDevice called\n");
+
+ /* start the preamble */
+ ip_select(outputfile);
+ /* special master instructions go here... */
+ AppendOp(OP_beginBlock);
+ AppendOp(OP_beginBody);
+
+ /* save scaling transform that uses a mica co-ordinate system */
+ AppendRational(1L, 100000);
+ AppendOp(OP_scale);
+ AppendInteger((long) F_transform);
+ AppendOp(OP_fset);
+
+ /* select file that holds page bodies */
+ ip_select(pagebodyfile);
+
+ /* open file that maps troff names to interpress names */
+ (void) sprintf(temp, "%s/dev%s/interpress-fonts", fontdirectory, devicename);
+ if ((timapf = open(temp, O_RDONLY,0)) == -1)
+ reportError(QUIT, "can't open %s (%s)", temp, sys_errlist[errno]);
+
+ /* read in the whole thing */
+ ret = fstat(timapf, &stbuf);
+ if (dbg) printf("stat returned %d, errno %d\n", ret, errno);
+ timap = malloc((unsigned)(stbuf.st_size + 1));
+ if (dbg) printf("reading %d bytes from timapf\n", stbuf.st_size);
+ ret = read(timapf, timap, (int)stbuf.st_size);
+ if (dbg) printf("read returned %d, errno %d, timapf %d\n", ret, errno, timapf);
+ timap[(int)stbuf.st_size] = '\0';
+ (void) close(timapf);
+
+ /* count the newlines */
+ if (dbg) printf("pointer starts at %08x ... ", timap);
+
+ for (ptr = timap; *ptr != '\0'; ptr++)
+ if (*ptr == '\n') lines++;
+
+ if (dbg) printf("ends at %08x\n", ptr);
+ if (dbg) printf("found %d lines\n", lines);
+
+ /* allocate the mapping arrays */
+ trp = trname = (char **)malloc((unsigned)(lines * 2 * sizeof(char *)));
+ ipp = ipname = trname + lines;
+
+ /* break out the strings and store pointers in the arrays */
+ ptr = timap;
+ mapcnt = 0;
+ while (*ptr)
+ {
+ if (dbg) printf("loop: ptr = %08x, *ptr = %c\n", ptr, *ptr);
+ *trp++ = ptr;
+ while (!white(*ptr)) ptr++;
+ *ptr++ = '\0';
+ while (white(*ptr)) ptr++;
+ *ipp++ = ptr;
+ while (*++ptr != '\n') /* nothing */;
+ *ptr++ = '\0';
+ mapcnt++;
+ }
+
+ if (dbg)
+ {
+ int i;
+
+ for (i = 0; i < lines; i++)
+ printf("%s\t%s\n", trname[i], ipname[i]);
+ }
+
+ /* reset vertical and horizontal positions */
+ hor_pos = ver_pos = old_hor = old_ver = 0;
+
+ /* reset the font information */
+ bzero((char *) currfonts, sizeof(currfonts));
+}
+
+setScale(spi) /* set resolution */
+
+int spi;
+
+{
+ /* set the scaling variable used in all x and y calculations */
+ scale = floor(2540.0 / (double)spi + 0.5);
+ if (dbg) printf("setScale(%d) sets scale to %e\n", spi, scale);
+
+ /*
+ * Set the drawing scale based on the scale. This factor is applied to
+ * all points drawn in the bitmap for graphical objects. It is scaled
+ * down from micas to 508 dpi so that the bitmaps aren't of unwieldy
+ * size, but still retain enough information to look decent on a good
+ * device. 508/2540 == 0.2
+ */
+ drawscale = scale * .2;
+ if (dbg) printf("setScale(%d) sets drawscale to %e\n", spi, drawscale);
+}
+
+pushCurrentEnv() /* begin a new block */
+{
+ statep->ssize = size;
+ statep->sfont = font;
+ statep->shorig = hor_orig;
+ statep->svorig = ver_orig;
+ statep->shpos = hor_pos;
+ statep->svpos = ver_pos;
+ hor_orig = hor_pos;
+ ver_orig = ver_pos;
+ hor_pos = ver_pos = 0;
+ if (statep++ >= state + MAXSTATE)
+ {
+ reportError(QUIT, "{ nested too deep");
+ }
+ hor_pos = ver_pos = 0;
+}
+
+popSavedEnv() /* pop to previous state */
+{
+ if (--statep < state)
+ {
+ reportError(QUIT, "extra }");
+ }
+ size = statep->ssize;
+ font = statep->sfont;
+ hor_pos = statep->shpos;
+ ver_pos = statep->svpos;
+ hor_orig = statep->shorig;
+ ver_orig = statep->svorig;
+}
+
+newpage(n) /* new page */
+int n;
+{
+ int i;
+ char buff[15];
+
+ /* print any pending bitmap */
+
+ /* terminate previous page if outputting */
+ if (outputflag)
+ {
+ print_bitmap();
+ AppendOp(OP_endBody);
+ }
+ else flush_bitmap();
+
+ /* reset vertical positions */
+ ver_pos = old_ver = 0;
+
+ /* check new page number against those found in the nPageRanges */
+ if (nPageRanges == 0)
+ {
+ /* no -o specified -- do all pages */
+ outputflag = 1;
+ }
+ else
+ {
+ /* see if new page has been selected for output */
+ outputflag = 0;
+ for (i = 0; i < nPageRanges; i++)
+ {
+ if ((n >= pagerange[i][0]) && (n <= pagerange[i][1]))
+ {
+ outputflag = 1;
+ break;
+ }
+ }
+ }
+
+ /* start new page */
+ if (outputflag)
+ {
+ AppendOp(OP_beginBody);
+ (void) sprintf(buff, "Page %d", n);
+ AppendComment(buff);
+ Fget(F_transform);
+ AppendOp(OP_concatt);
+ AppendInteger(2L);
+ AppendInteger((long) I_strokeEnd);
+ AppendOp(OP_iset);
+ }
+
+ /* font/size no longer valid -- force a new assignment */
+ oldftsz = -1;
+}
+
+newLine() /* new line (no vertical motion implied) */
+{
+ if (dbg == 3)
+ putchar('\n');
+ flushbuff();
+ endcorrect();
+ hor_pos = 0;
+ virgin_line = 1;
+}
+
+internalSize(number) /* convert integer to internal size number */
+int number;
+{
+ int index;
+
+ if (number >= pointsizeTab[device.num_sizes - 1])
+ {
+ /* larger than largest -- use largest */
+ return(device.num_sizes-1);
+ }
+ else if (number <= pointsizeTab[0])
+ {
+ /* smaller than smallest -- use smallest */
+ return(0);
+ }
+
+ /* else find the size in pointsizeTab and return index */
+ for (index = 0; number > pointsizeTab[index]; index++);
+ return(index);
+}
+
+
+
+
+
+/* handle device stop command */
+resetDevice()
+{
+ int amt;
+ static int is_reset = 0;
+ char bigbuff[1024];
+
+ if (is_reset) return; /* ignore multiple resets */
+
+ print_bitmap();
+
+ /* this is the absolute last thing that we do */
+ /* wrap up the preamble and the body */
+ ip_select(outputfile);
+ AppendOp(OP_endBody);
+ ip_select(pagebodyfile);
+ AppendOp(OP_endBody);
+ AppendOp(OP_endBlock);
+ ip_close(); /* close the body */
+
+ /*
+ * Reopen the body and copy it onto the end of the real file (which is
+ * where we have been building the preamble). We don't need to ip_flush
+ * the preamble since that is done everytime we ip_select the body.
+ * Conveniently enough, "tempfilename" still holds the name of the body
+ * temporary.
+ */
+ pagebodyfile = open(tempfilename, O_RDONLY,0);
+ while ((amt = read(pagebodyfile, bigbuff, sizeof(bigbuff))) != 0)
+ {
+ (void) write(outputfile, bigbuff, amt);
+ }
+
+ /* close and unlink the body temporary file */
+ (void) close(pagebodyfile);
+ (void) unlink(tempfilename);
+
+ /* send the file off to the printer */
+ tempfilename[strlen(tempfilename) - 1] = '\0';
+ if (outputfile != 1)
+ {
+ IPprint(tempfilename);
+ }
+
+ /* we are now reset */
+ is_reset = 1;
+}
+
+outputString(character) /* print a "funny" character */
+char *character;
+{
+ int i;
+
+ if (!outputflag)
+ return;
+ if (dbg > 2) printf("\\(%s", character);
+ if (dbg > 3) putchar(' ');
+ for (i = 0; i < device.spec_char_num; i++)
+ if (strcmp(&specCharStrTab[specCharTab[i]], character) == 0)
+ break;
+ if (i < device.spec_char_num) {
+ /* printf(" i = %d so i+128 = %d\n", i, i+128); */
+ outputChar((unsigned int) i + 128);
+ }
+ else {
+ if (dbg > 3)
+ printf("-- character not found");
+ }
+
+ if (dbg > 2)
+ putchar('\n');
+}
+
+outputChar(character) /* put a character */
+unsigned int character;
+{
+ unsigned char *widp; /* pointer to appropriate width table */
+ register char *codep; /* pointer to appropriate table of codes */
+ register int i, old_font, fnt_index;
+ int j, value;
+
+ if (!outputflag)
+ return;
+
+ if (character <= 32)
+ {
+ if (dbg) printf("non-existent character 0%o\n", character);
+ charw = charWidthTab[font][0] * pointsizeTab[size-1] / device.width_units;
+ return;
+ }
+ character -= 32;
+
+ old_font= font;
+ i = fontIndexTab[font][character] & 255;
+ if (i != 0) /* it's on this font */
+ {
+ codep = charCodeTab[font];
+ widp = charWidthTab[font];
+ }
+ else if (specFontPos > 0) /* on special (we hope) */
+ {
+ /* assertion: i == 0 */
+ fnt_index= specFontPos;
+ for (j=0; j <= device.num_fonts; j++)
+ {
+ struct font_entry *fb;
+
+ fnt_index= (fnt_index+1) % (device.num_fonts+1);
+
+ if ((fb = fontPtr[fnt_index]) != NULL)
+ {
+ if (fb->special_flag && (i = fontIndexTab[fnt_index][character] & 255) != 0)
+ {
+ codep = charCodeTab[fnt_index];
+ widp = charWidthTab[fnt_index];
+ setFont(fnt_index);
+ break;
+ }
+ }
+ }
+ /* assertion: if j > device.num_fonts then i == 0 and character was not found */
+ }
+
+ value= codep[i] & 255;
+
+ if (i == 0 || value == 0)
+ {
+ if (dbg) printf("character not found 0%o\n", character+32);
+ return;
+ }
+
+ /* remember this character's width */
+ /* This MUST be done before calling showchar */
+ charw = (widp[i] * pointsizeTab[size-1] + device.width_units/2) / device.width_units;
+ if (dbg == 3)
+ {
+ if (isprint(character+32))
+ putchar(character+32);
+ }
+ if (dbg > 3)
+ {
+ if (isprint(character+32))
+ printf("character %c %d\n", character+32, value);
+ else
+ printf("character %03o %d\n", character+32, value);
+ }
+
+ if (value == 0377)
+ {
+ /* special escape to an extended code */
+ value = getexcode(i);
+ }
+
+ if (dbg < 6)
+ showchar(value);
+
+ if (font != old_font)
+ {
+ setFont(old_font);
+ }
+}
+
+
+/*
+ * set point size to n
+ */
+setPointSize(n)
+
+int n; /* internal value: index into pointsizeTab */
+
+{
+ size = n;
+ ftsz = ((long)font << 16) | ((long)size);
+}
+
+
+/*
+ * set the current font to number
+ */
+setFont(n)
+
+int n; /* internal index */
+
+{
+ font = n;
+ ftsz = ((long)font << 16) | ((long)size);
+}
+
+
+/*
+ * reportError an error reporting hack that uses dummy parameters
+ * as place holders for arguments that may or may not
+ * exist, fprintf will sort out how many should be there
+ */
+/*VARARGS 2*/
+reportError(f, s, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+char *s, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7, *arg8;
+{
+ fprintf(stderr, "dipress: ");
+ fprintf(stderr, s, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+ fprintf(stderr, "\nerror encountered near line %d\n", linenumber);
+ if (f == QUIT) goodbye();
+}
+
+
+
+
+/*
+ * Graphics drawing primitives. These use the vector drawing capabilities of
+ * interpress to draw straight lines. All other primitive objects (circle,
+ * ellipse, etc.) are built in a bitmap and printed with a pixel vector.
+ */
+
+drawline(dh, dv)
+int dh,dv;
+{
+
+ if(!outputflag) return;
+ AppendInteger((long) curr_strokewidth);
+ AppendInteger((long) I_strokeWidth);
+ AppendOp(OP_iset);
+ Moveto(xloc(hor_pos), yloc(ver_pos));
+ hor_pos += dh;
+ ver_pos += dv;
+ Lineto(xloc(hor_pos), yloc(ver_pos));
+ AppendOp(OP_maskstroke);
+}
+
+/* routines used by interpress dependent routines */
+
+char showbuff[Showbuff_size + 1];
+char *showp = showbuff;
+int showcnt = 0;
+
+showchar(ch) /* buffer "ch" for use in a "show" command */
+int ch;
+{
+ char *framep;
+ register int hdiff, vdiff;
+
+ /* set correct position */
+ vdiff = ver_pos - old_ver;
+ hdiff = hor_pos - old_hor;
+ if (dbg > 4)
+ {
+ printf("old_hor %d, hor_pos %d, hdiff %d; old_ver %d, ver_pos %d, vdiff %d %s\n",
+ old_hor, hor_pos, hdiff, old_ver, ver_pos, vdiff,
+ virgin_line ? "(virgin)" : "");
+ }
+
+ /* NOTE: this expression depends on boolean true being 1! */
+ /* See K&R, Appendix A, section 7.7, page 190 */
+ switch (((vdiff != 0) << 1) | (hdiff != 0))
+ {
+ case 0: /* no change */
+ break;
+ default:
+ flushbuff();
+ Setxy(xloc(hor_pos), yloc(ver_pos));
+ break;
+ }
+
+ /*
+ * Update old_hor and old_ver. Account for character width in old_hor but not in
+ * hor_pos. If the next hInc call is for the width of the character, the
+ * next time showchar gets called, old_hor will equal hor_pos.
+ */
+ old_ver = ver_pos;
+ old_hor = hor_pos + charw;
+
+ /* line is no longer virgin */
+ virgin_line = 0;
+
+ /* font and point still the same? */
+ if (ftsz != oldftsz)
+ {
+ flushbuff();
+ if ((framep = currfonts[font]->frames) == NULL)
+ {
+ /* previously unused -- give it a frame table */
+ framep = currfonts[font]->frames = malloc((unsigned)(device.num_sizes * sizeof(char)));
+ bzero(framep, device.num_sizes * sizeof(char));
+ }
+
+ if (framep[size] == 0)
+ {
+ /* make a new font */
+ ip_select(outputfile);
+ SetupFont(currfonts[font]->uname,
+ floor(pointsizeTab[size-1] * 35.28 + .5),
+ frameindex);
+ ip_select(pagebodyfile);
+ framep[size] = frameindex++;
+ }
+
+ /* switch to new font/size combo */
+ Setfont(framep[size]);
+ oldftsz = ftsz;
+ }
+
+ /* adjust for character codes > 0377 */
+ if (ch > 0377)
+ {
+ if (dbg > 4)
+ {
+ printf("processing large code: 0%o (%d)\n", ch, ch);
+ }
+
+ if (showcnt + 5 > Showbuff_size)
+ {
+ flushbuff();
+ }
+ *showp++ = '\377';
+ *showp++ = (ch & 0177400) >> 8;
+ *showp++ = ch & 255;
+ *showp++ = '\377';
+ *showp++ = '\0';
+ showcnt += 5;
+ }
+ else
+ {
+ *showp++ = ch;
+ if (++showcnt > Showbuff_size)
+ {
+ flushbuff();
+ }
+ }
+}
+
+/*
+ * getexcode(findex) - get the extended code for the character "findex"
+ */
+
+getexcode(findex)
+int findex;
+{
+ register int extfd;
+ register int i;
+ register unsigned short *tab;
+ char temp[132];
+
+ if (dbg > 4)
+ {
+ printf("getexcode(%d)\n", findex);
+ }
+
+ if ((tab = currfonts[font]->extab) == NULL)
+ {
+ /* load in the extended code table */
+
+ (void) sprintf(temp, "%s/dev%s/%s.out.ext",
+ fontdirectory, devicename, currfonts[font]->name);
+ if (dbg > 4)
+ {
+ printf("opening and reading %s\n", temp);
+ }
+ if ((extfd = open(temp, O_RDONLY,0)) == -1)
+ {
+ reportError(CONTINUE, "can't open %s (%s)", temp, sys_errlist[errno]);
+ return(0);
+ }
+ currfonts[font]->extab = tab = (unsigned short *)
+ malloc( (unsigned)(i = (device.spec_char_num + 128-32) * sizeof(short)) );
+ (void) read(extfd, (char *)tab, i); /* should test result! */
+ (void) close(extfd);
+ }
+
+ if (dbg > 4)
+ {
+ printf("getexcode returning %.7o\n", tab[findex]);
+ }
+ return(tab[findex]);
+}
+
+flushbuff() /* flush and reset "showbuff" */
+{
+ if (showcnt == 0)
+ return;
+
+ if (!in_correct)
+ {
+ startcorrect();
+ }
+
+ /* we must do the append_Sequence explicitly, */
+ /* because showbuff might have nulls in it. */
+ append_Sequence(sequenceString, showcnt, (unsigned char *)showbuff);
+ AppendOp(OP_show);
+ showp = showbuff;
+ showcnt = 0;
+}
+
+int hstart;
+
+startcorrect()
+{
+#ifdef CORRECT_BLOCKS
+ AppendOp(OP_correct);
+ AppendOp(OP_beginBody);
+#endif
+ in_correct = 1;
+ hstart = hor_pos;
+}
+
+endcorrect()
+{
+ /* append a Setcorrectmeasure operation */
+ /* "hor_pos" or "old_hor"??? Make it "old_hor" for now */
+#ifdef CORRECT_BLOCKS
+ Setcorrectmeasure(xloc(old_hor), 0.0);
+ AppendOp(OP_endBody);
+#endif
+ in_correct = 0;
+}
+
+/*
+ * IPprint(filename) - send the file "filename" to the interpress printer.
+ * This routine is *very* dependent on local
+ * environments.
+ */
+
+IPprint(filename)
+char *filename;
+{
+ if (dbg)
+ {
+ printf("interpress file saved in %s.\n", filename);
+ return;
+ }
+
+ if (vfork() == 0)
+ {
+ /* is child */
+ execl("/usr/local/bin/qip", "qip", "-nc", "-nk", filename, 0);
+ exit(1);
+ }
+}
+
+/* bitmap graphics object sizing functions */
+
+g_sizearc(x1, y1, xc, yc, x2, y2)
+int x1, y1, xc, yc, x2, y2;
+{
+ int minx;
+ int miny;
+ int maxx;
+ int maxy;
+ int quad1;
+ int quad2;
+ int radius;
+ int axc;
+ int ayc;
+ int i;
+
+ /* the center and the second point are offsets from the first */
+ /* calculate actual center and radius */
+ axc = x1 + xc;
+ ayc = y1 + yc;
+ radius = (int)(hypot((double)xc, (double)yc) + .5);
+ if (dbg > 1)
+ {
+ printf("g_sizearc(%d, %d, %d, %d, %d, %d): radius is %d\n",
+ x1, y1, xc, yc, x2, y2, radius);
+ }
+
+ /* preset the minmal and maximal points -- this is our first guess */
+ if ((minx = x1 + xc + x2) > x1)
+ {
+ maxx = minx;
+ minx = x1;
+ }
+ else
+ {
+ maxx = x1;
+ }
+ if ((miny = y1 + yc + y2) > y1)
+ {
+ maxy = miny;
+ miny = y1;
+ }
+ else
+ {
+ maxy = y1;
+ }
+
+ /* calculate the offset from the center to the first point */
+ x1 = -xc;
+ y1 = -yc; /* now all three arguments are offsets */
+
+ /* calculate the quadrant of each endpoint */
+ quad1 = quadrant(x1, y1);
+ quad2 = quadrant(x2, y2);
+ if (dbg > 1)
+ {
+ printf("(%d, %d) in quadrant %d ... ", x1, y1, quad1);
+ printf("(%d, %d) in quadrant %d\n", x2, y2, quad2);
+ }
+
+ /* insure that quad1 < quad2 */
+ if (quad2 < quad1)
+ {
+ quad2 += 4;
+ }
+
+ /* compensate for arc at each quadrant boundary */
+ for (i = quad1 + 1; i <= quad2; i++)
+ {
+ switch (i & 3)
+ {
+ case 0: /* 1st quadrant */
+ maxx = axc + radius;
+ break;
+
+ case 1: /* 2nd quadrant */
+ miny = ayc - radius;
+ break;
+
+ case 2: /* 3rd quadrant */
+ minx = axc - radius;
+ break;
+
+ case 3: /* 4th quadrant */
+ maxy = ayc + radius;
+ break;
+ }
+ }
+
+ /* now set the extremes */
+ if (dbg > 1)
+ {
+ printf("extremes are %d, %d, %d, %d\n", minx, miny, maxx, maxy);
+ }
+ gobj_size(minx, miny, maxx, maxy);
+}
+
+quadrant(dx, dy)
+int dx,dy;
+{
+ register int yplus;
+
+ yplus = dy > 0;
+ if (dx > 0)
+ {
+ return(yplus ? 3 : 0);
+ }
+ else
+ {
+ return(yplus ? 2 : 1);
+ }
+}
+
+
+g_sizeWigglyLine(str)
+char *str;
+{
+ int minx;
+ int miny;
+ int maxx;
+ int maxy;
+ int currx;
+ int curry;
+ int incx;
+ int incy;
+
+ currx = minx = maxx = hor_pos;
+ curry = miny = maxy = ver_pos;
+
+ while(white(*str)) str++; /* trim leading white space */
+
+ while (*str)
+ {
+
+ (void) readNumber(&str,&incx);
+ (void) readNumber(&str,&incy);
+ currx += incx;
+ curry += incy;
+ if (currx > maxx)
+ maxx = currx;
+ else if (currx < minx)
+ minx = currx;
+ if (curry > maxy)
+ maxy = curry;
+ else if (curry < miny)
+ miny = curry;
+ }
+ gobj_size(minx, miny, maxx, maxy);
+}
+
+
+/*
+ * Request the insertion of an Interpress master
+ */
+
+doSequenceInsertIP(fileName)
+char *fileName; {
+ AppendOp(OP_dosavesimplebody);
+ AppendOp(OP_beginBody);
+ /* set the IP position at the current troff position */
+ Setxy(xloc(hor_pos), yloc(ver_pos));
+
+ /* undo the Troff scaling */
+ AppendRational(spotsPerInch*10000L, 254L);
+ AppendOp(OP_scale);
+ AppendOp(OP_concatt);
+ AppendOp(OP_trans);
+
+ AppendInsertFile(fileName);
+ AppendOp(OP_endBody);
+}
+
+
+#define SAME 0
+
+/*
+ * define frame variables for the RES image
+ */
+#define IMAGE_EDIT 47L
+#define IMAGE_COLOR_OP 46L
+#define IMAGE_COLOR 45L
+#define IMAGE_MASK 44L
+#define IMAGE_Y 43L
+#define IMAGE_X 42L
+#define IMAGE_SCALE 41L
+
+/*
+ * Request the insertion of an RES file
+ */
+
+doSequenceInsertRES(anchor, resolutionString, fileName)
+char *anchor,
+ *resolutionString,
+ *fileName; {
+ int resolution;
+
+ resolution = atoi(resolutionString);
+
+ AppendOp(OP_dosavesimplebody);
+ AppendOp(OP_beginBody);
+ /* set the IP position at the current troff position */
+ Setxy(xloc(hor_pos), yloc(ver_pos));
+
+ AppendInsertFile(fileName);
+
+ /* pop and store */
+ AppendOp(OP_pop); /* for now, don't check the signature */
+ AppendInteger(IMAGE_EDIT);
+ AppendOp(OP_fset);
+ AppendInteger(IMAGE_COLOR_OP);
+ AppendOp(OP_fset);
+ AppendInteger(IMAGE_COLOR);
+ AppendOp(OP_fset);
+ AppendOp(OP_pop); /* discard mask image */
+ AppendInteger(IMAGE_Y);
+ AppendOp(OP_fset);
+ AppendInteger(IMAGE_X);
+ AppendOp(OP_fset);
+ AppendInteger(IMAGE_SCALE);
+ AppendOp(OP_fset);
+
+ /* undo the Troff scaling */
+ AppendRational(spotsPerInch*10000L, 254L);
+ AppendOp(OP_scale);
+
+ /* set the resolution */
+ if( resolution != 0 ) {
+ /* display the RES file at the specified resolution */
+ AppendRational(254L, resolution*10000L);
+ AppendOp(OP_scale); }
+ else
+ /* get the default scale from the RES file */
+ /* can the device do a "get" operator? */
+ if( IPDeviceType == Xerox8044_Services8 ||
+ IPDeviceType == Xerox8044_Services9 ||
+ IPDeviceType == Xerox8044_Services10 )
+ reportError(CONTINUE, "requested device can't read resolution from an RES file");
+ else {
+ /* Yes! Use the imageScale suggested by the image */
+ Fget(IMAGE_SCALE);
+ Get(1L);
+ Fget(IMAGE_SCALE);
+ Get(2L);
+ AppendOp(OP_scale2); }
+
+ AppendOp(OP_concat); /* concat undo-scale with image scale */
+
+ if( strcmp(anchor, "bl") == SAME ) /* bottom left */
+ ;
+ else if( strcmp(anchor, "tl") == SAME ) { /* top left */
+ AppendInteger(-1L); /* invert scale */
+ AppendOp(OP_scale);
+ AppendOp(OP_concat);
+ AppendOp(OP_concatt);
+
+ FGet(IMAGE_Y);
+ AppendOp(OP_setyrel);
+
+ AppendInteger(-1L);
+ AppendOp(OP_scale);
+ }
+ else if( strcmp(anchor, "c") == SAME ) { /* center */
+ AppendRational(-1L, 2L);
+ AppendOp(OP_scale);
+ AppendOp(OP_concat);
+ AppendOp(OP_concatt); /* half normal scale for centering */
+
+ FGet(IMAGE_X);
+ FGet(IMAGE_Y);
+ AppendOp(OP_setxyrel);
+
+ AppendRational(-2L, 1L);
+ AppendOp(OP_scale);
+ }
+ else if( strcmp(anchor, "br") == SAME ) { /* bottom right */
+ AppendInteger(-1L); /* invert scale */
+ AppendOp(OP_scale);
+ AppendOp(OP_concat);
+ AppendOp(OP_concatt);
+
+ FGet(IMAGE_X);
+ AppendOp(OP_setxrel);
+
+ AppendInteger(-1L); /* invert scale */
+ AppendOp(OP_scale);
+ }
+ else if( strcmp(anchor, "tr") == SAME ) { /* top right */
+ AppendInteger(-1L); /* invert scale */
+ AppendOp(OP_scale);
+ AppendOp(OP_concat);
+ AppendOp(OP_concatt);
+
+ FGet(IMAGE_X);
+ FGet(IMAGE_Y);
+ AppendOp(OP_setxyrel);
+
+ AppendInteger(-1L); /* invert scale */
+ AppendOp(OP_scale);
+ }
+ else
+ reportError(CONTINUE, "unknown position in RES command: %s", anchor );
+
+ AppendOp(OP_concatt);
+
+ AppendOp(OP_trans);
+
+ FGet(IMAGE_COLOR);
+ AppendOp(OP_maskpixel);
+ AppendOp(OP_endBody);
+}
projects / unix-history / commitdiff