![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / X / xdvi|
Return to dv.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / xdvi |
1.1 root 1: /*
2: * DVI previewer for X.
3: *
4: * Eric Cooper, CMU, September 1985.
5: *
6: * Code derived from dvi-imagen.c.
7: *
8: * Modified for X.10 by Bob Scheifler, MIT LCS, January 1986.
9: *
10: */
11: #ifndef lint
12: static char *dv_c = "$Header: dv.c,v 10.5 86/02/01 15:44:22 tony Rel $";
13: #endif lint
14:
15: #include <sys/types.h>
16: #include <X/Xlib.h>
17: #include <stdio.h>
18: #include <ctype.h>
19: #include "dvi.h"
20: #include "pxl.h"
21:
22: /* These are probably site dependent */
23: #define FONT_DIRECTORY "/usr/lib/tex/fonts"
24: #define FONT_SUFFIX ".%dpxl"
25:
26: #define PAPER_WIDTH ROUNDUP(17*pixels_per_inch,shrink_factor*2)
27: #define PAPER_HEIGHT ROUNDUP(11*pixels_per_inch,shrink_factor)
28: #define X_PAGE_OFFSET ROUNDUP(pixels_per_inch,shrink_factor)
29: #define Y_PAGE_OFFSET ROUNDUP(pixels_per_inch,shrink_factor)
30:
31: #define pixel_round(x) ((long) (conv * (double) (x) + 0.5))
32: #define dvi_round(x) ((long) ((double) (x) / conv + 0.5))
33:
34: #define one(fp) num (fp, 1)
35: #define two(fp) num (fp, 2)
36: #define stwo(fp) snum(fp, 2)
37: #define four(fp) num (fp, 4)
38: #define sfour(fp) snum(fp, 4)
39:
40: typedef unsigned char ubyte;
41:
42: struct frame {
43: long pxl_h, dvi_h, pxl_v, dvi_v, w, x, y, z;
44: };
45:
46: struct frame *stack;
47: int stackp;
48:
49: #define PXL_H stack[stackp].pxl_h
50: #define PXL_V stack[stackp].pxl_v
51: #define DVI_H stack[stackp].dvi_h
52: #define DVI_V stack[stackp].dvi_v
53: #define WW stack[stackp].w
54: #define XX stack[stackp].x
55: #define YY stack[stackp].y
56: #define ZZ stack[stackp].z
57:
58: #define DBG_BITMAP 0x1
59: #define DBG_DVI 0x2
60: #define DBG_ALL (DBG_BITMAP|DBG_DVI)
61:
62: /*
63: * Command line flags.
64: */
65: int debug = 0;
66: int list_fonts = 0;
67:
68: int pixels_per_inch = 300;
69: int shrink_factor = 4;
70:
71: FILE *dvi_file; /* user's file */
72:
73: int font_not_found = 0;
74: struct font *current_font = NULL; /* ptr into circular list of fonts */
75: #define MAX_OPEN_FONTS 12
76: int n_open_fonts = 0; /* for LRU management of fonts */
77:
78: /*
79: * DVI preamble and postamble information.
80: */
81: char job_id[300];
82: int total_pages, maxstack;
83: int current_page;
84: double fraction, conv;
85: long numerator, denominator, magnification;
86:
87: /*
88: * Offset in DVI file of last page, set in read_postamble().
89: */
90: long last_page_offset;
91:
92: /*
93: * Table of page offsets in DVI file, indexed by page number - 1.
94: * Initialized in prepare_pages().
95: */
96: long *page_offset;
97:
98: #define xdvi_width 15
99: #define xdvi_height 15
100: #define xdvi_x_hot 7
101: #define xdvi_y_hot 7
102: static short xdvi_bits[] = {
103: 0x0080, 0x01c0, 0x03e0, 0x06b0,
104: 0x0c98, 0x188c, 0x3086, 0x7fff,
105: 0x3086, 0x188c, 0x0c98, 0x06b0,
106: 0x03e0, 0x01c0, 0x0080};
107:
108: Window win;
109: int forepix, backpix, highpix;
110:
111: long screen_w, screen_h, page_w, page_h;
112: long min_x, max_x, min_y, max_y, base_x, base_y;
113: long smin_x, smax_x, smin_y, smax_y;
114: int redisplay = 0;
115:
116: unsigned long num();
117: long snum();
118:
119: extern char reverse_byte[];
120: char *malloc(), *calloc(), *index();
121:
122: main(argc, argv)
123: int argc;
124: char **argv;
125: {
126: char *prog, *file;
127: char *display = NULL;
128: char *option;
129: OpaqueFrame frame;
130: int reverse = 0;
131: int bwidth = 2;
132: char *fore_color;
133: char *back_color;
134: char *high_color;
135: char *brdr_color;
136: char *mous_color;
137: char *geometry = NULL, def[32];
138: int backmap, bdrmap, mouspix;
139: Color cdef;
140:
141: prog = *argv++;
142: argc--;
143: if ((option = XGetDefault(prog, "ReverseVideo")) &&
144: strcmp(option, "on") == 0)
145: reverse = 1;
146: if (option = XGetDefault(prog, "BorderWidth"))
147: bwidth = atoi(option);
148: fore_color = XGetDefault(prog, "ForeGround");
149: back_color = XGetDefault(prog, "BackGround");
150: high_color = XGetDefault(prog, "Highlight");
151: brdr_color = XGetDefault(prog, "Border");
152: mous_color = XGetDefault(prog, "Mouse");
153: file = NULL;
154: while (argc) {
155: if (strncmp(*argv, "-d", 2) == 0)
156: debug = isdigit(argv[0][2]) ? atoi(&argv[0][2]) : DBG_ALL;
157: else if (strcmp(*argv, "-l") == 0)
158: list_fonts = 1;
159: else if (strcmp(*argv, "-s") == 0 && argc > 1) {
160: argv++;
161: argc--;
162: shrink_factor = atoi(*argv);
163: if (shrink_factor <= 0) goto usage;
164: } else if (strcmp(*argv, "-p") == 0 && argc > 1) {
165: argv++;
166: argc--;
167: pixels_per_inch = atoi(*argv);
168: if (pixels_per_inch <= 0) goto usage;
169: } else if (strcmp(*argv, "-rv") == 0) {
170: reverse = 1;
171: } else if (strcmp(*argv, "-fg") == 0 && argc > 1) {
172: argv++;
173: argc--;
174: fore_color = *argv;
175: } else if (strcmp(*argv, "-bg") == 0 && argc > 1) {
176: argv++;
177: argc--;
178: back_color = *argv;
179: } else if (strcmp(*argv, "-hl") == 0 && argc > 1) {
180: argv++;
181: argc--;
182: high_color = *argv;
183: } else if (strcmp(*argv, "-bd") == 0 && argc > 1) {
184: argv++;
185: argc--;
186: brdr_color = *argv;
187: } else if (strcmp(*argv, "-ms") == 0 && argc > 1) {
188: argv++;
189: argc--;
190: mous_color = *argv;
191: } else if (**argv == '=') {
192: geometry = *argv;
193: } else if (**argv != '-') {
194: if (index(*argv, ':') != NULL)
195: display = *argv;
196: else
197: file = *argv;
198: } else {
199: usage:
200: fprintf(stderr, "Usage: xdvi [-s <shrink>] [-p <pixels>] [-l] [-rv] [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] [-ms <color>] [=<geometry>] [host:display] dvi_file\n");
201: exit(1);
202: }
203: argv++;
204: argc--;
205: }
206: if (file == NULL)
207: goto usage;
208: if ((dvi_file = fopen(file, "r")) == NULL) {
209: int n = strlen(file);
210: char *dvi_name;
211:
212: if (strcmp(file + n - sizeof(".dvi") + 1, ".dvi") == 0) {
213: perror(file);
214: exit(1);
215: }
216: dvi_name = malloc((unsigned) n + sizeof(".dvi"));
217: sprintf(dvi_name, "%s.dvi", file);
218: if ((dvi_file = fopen(dvi_name, "r")) == NULL) {
219: perror(dvi_name);
220: exit(1);
221: }
222: }
223: process_preamble();
224: find_postamble();
225: read_postamble();
226: prepare_pages();
227: init_page();
228: if (XOpenDisplay(display) == NULL) {
229: fprintf(stderr, "Can't open display %s!\n", display);
230: exit(1);
231: }
232: if (reverse) {
233: forepix = WhitePixel;
234: highpix = WhitePixel;
235: backpix = BlackPixel;
236: backmap = BlackPixmap;
237: bdrmap = WhitePixmap;
238: mouspix = WhitePixel;
239: } else {
240: forepix = BlackPixel;
241: highpix = BlackPixel;
242: backpix = WhitePixel;
243: backmap = WhitePixmap;
244: bdrmap = BlackPixmap;
245: mouspix = BlackPixel;
246: }
247: if (DisplayCells() > 2) {
248: if (fore_color && XParseColor(fore_color, &cdef) &&
249: XGetHardwareColor(&cdef))
250: forepix = cdef.pixel;
251: if (back_color && XParseColor(back_color, &cdef) &&
252: XGetHardwareColor(&cdef)) {
253: backpix = cdef.pixel;
254: backmap = XMakeTile(backpix);
255: }
256: if (high_color && XParseColor(high_color, &cdef) &&
257: XGetHardwareColor(&cdef))
258: highpix = cdef.pixel;
259: if (brdr_color && XParseColor(brdr_color, &cdef) &&
260: XGetHardwareColor(&cdef))
261: bdrmap = XMakeTile(cdef.pixel);
262: if (mous_color && XParseColor(mous_color, &cdef) &&
263: XGetHardwareColor(&cdef))
264: mouspix = cdef.pixel;
265: }
266: frame.bdrwidth = bwidth;
267: frame.height = page_h;
268: if (frame.height + (bwidth << 1) > DisplayHeight())
269: frame.height = DisplayHeight() - (bwidth << 1);
270: frame.width = page_w;
271: if (frame.width + (bwidth << 1) > DisplayWidth())
272: frame.width = DisplayWidth() - (bwidth << 1);
273: frame.border = bdrmap;
274: frame.background = backmap;
275: frame.x = 0;
276: frame.y = 0;
277: sprintf(def, "=%dx%d+0+0", frame.width, frame.height);
278: win = XCreate("DVI Previewer", prog, geometry, def, &frame, 50, 50);
279: screen_h = frame.height;
280: screen_w = frame.width;
281: XMapWindow(win);
282: XSelectInput(win, KeyPressed|ButtonPressed|ExposeWindow|ExposeRegion);
283: XDefineCursor(win,
284: XCreateCursor(xdvi_width, xdvi_height, xdvi_bits, xdvi_bits,
285: xdvi_x_hot, xdvi_y_hot, mouspix, backpix, GXcopy));
286: do_pages();
287: stop_output(0);
288: }
289:
290: /*
291: ** process_preamble reads the information in the preamble and stores
292: ** it into global variables for later use.
293: */
294: process_preamble()
295: {
296: ubyte k;
297:
298: if (one(dvi_file) != PRE)
299: error("xdvi: DVI file doesn't start with preamble");
300: if (one(dvi_file) != 2)
301: error("xdvi: Wrong version of DVI output for this program");
302: numerator = four(dvi_file);
303: denominator = four(dvi_file);
304: magnification = four(dvi_file);
305: fraction = (((double) numerator * magnification)
306: / ((double) denominator * 1000.));
307: define_conv();
308: k = one(dvi_file);
309: fread(job_id, sizeof(char), k, dvi_file);
310: job_id[k] = '\0';
311: }
312:
313: define_conv ()
314: {
315: conv = ((fraction * pixels_per_inch) / 100000) / (2.54 * shrink_factor);
316: }
317:
318: /*
319: ** find_postamble locates the beginning of the postamble
320: ** and leaves the file ready to start reading at that location.
321: */
322: find_postamble()
323: {
324: ubyte byte;
325: long offset = -4; /* At least 4 TRAILERS */
326:
327: do {
328: offset -= 1;
329: fseek(dvi_file, offset, 2);
330: byte = one(dvi_file);
331: } while (byte == TRAILER);
332: if (byte != 2)
333: error("xdvi: Wrong version of DVI output for this program");
334: offset -= 4;
335: fseek(dvi_file, offset, 2);
336: fseek(dvi_file, sfour(dvi_file), 0);
337: }
338:
339: /*
340: ** read_postamble reads the information in the postamble,
341: ** storing it into global variables.
342: ** It also takes care of reading in all of the PXL files for the fonts
343: ** used in the job.
344: */
345: read_postamble()
346: {
347: ubyte cmnd;
348: int page_width, page_height;
349:
350: if (one(dvi_file) != POST)
351: error("xdvi: Postamble doesn't begin with POST");
352: last_page_offset = four(dvi_file);
353: if (numerator != four(dvi_file)
354: || denominator != four(dvi_file)
355: || magnification != four(dvi_file))
356: error("xdvi: Postamble doesn't match preamble");
357: page_height = pixel_round(four(dvi_file));
358: page_width = pixel_round(four(dvi_file));
359: maxstack = two(dvi_file);
360: total_pages = two(dvi_file);
361: do {
362: switch(cmnd = one(dvi_file)) {
363: case FNTDEF1:
364: case FNTDEF2:
365: case FNTDEF3:
366: case FNTDEF4:
367: define_font(cmnd);
368: break;
369: case POSTPOST:
370: break;
371: default:
372: error("xdvi: Non-fntdef cmnd found in postamble");
373: }
374: } while (cmnd != POSTPOST);
375: if (font_not_found)
376: error("xdvi: Not all PXL files were found");
377: list_fonts = 0;
378: }
379:
380: prepare_pages()
381: {
382: int i;
383:
384: stack = (struct frame *) malloc((unsigned) sizeof(struct frame) * (maxstack+1));
385: if (stack == NULL)
386: error("xdvi: Can't allocate stack space (%d frames)", maxstack);
387: page_offset = (long *) malloc((unsigned) total_pages * sizeof(long));
388: if (page_offset == NULL)
389: error("xdvi: Can't allocate page directory (%d pages)", total_pages);
390: i = total_pages;
391: page_offset[--i] = last_page_offset;
392: fseek(dvi_file, last_page_offset, 0);
393: /*
394: * Follow back pointers through pages in the DVI file,
395: * storing the offsets in the page_offset table.
396: */
397: while (i > 0) {
398: num(dvi_file, 1+4+(9*4));
399: fseek(dvi_file, page_offset[--i] = four(dvi_file), 0);
400: }
401: }
402:
403: /*
404: ** define_font reads the rest of the fntdef command and then reads in
405: ** the specified PXL file, adding it to the global linked-list holding
406: ** all of the fonts used in the job.
407: */
408: define_font(cmnd)
409: ubyte cmnd;
410: {
411: register struct font *fontp;
412: int len;
413: int unmodsize;
414: float realsize;
415: int size;
416: long checksum;
417:
418: fontp = (struct font *) malloc((unsigned) sizeof(struct font));
419: if (fontp == NULL)
420: error("xdvi: Can't allocate memory for font");
421: fontp->TeXnumber = num(dvi_file, cmnd - FNTDEF1 + 1);
422: checksum = four(dvi_file);
423: fontp->scale = four(dvi_file);
424: fontp->design = four(dvi_file);
425: len = one(dvi_file) + one(dvi_file);
426: fontp->fontname = malloc(len + 10); /* leave space for magnification */
427: fread(fontp->fontname, sizeof(char), len, dvi_file);
428: fontp->fontname[len] = '\0';
429: fontp->file = NULL;
430: /*
431: ** In the actual implementation, scaled-size/design-size hasn't been
432: ** stored with sufficient precision, hence the messing around to find
433: ** its actual value.
434: */
435: realsize = (magnification/1000.)*((float) fontp->scale / fontp->design);
436: unmodsize = (realsize * 1000) + 0.5;
437: /* a real hack to correct for rounding in some cases */
438: switch (unmodsize) {
439: case 1095:
440: realsize = 1.095445; /* stephalf */
441: break;
442: case 1315:
443: realsize = 1.314534; /* stepihalf */
444: break;
445: case 2074:
446: realsize = 2.0736; /* stepiv */
447: break;
448: case 2488:
449: realsize = 2.48832; /* stepv */
450: break;
451: case 2986:
452: realsize = 2.985984; /* stepiv */
453: break;
454: }
455: /*
456: * the remaining magnification steps are represented
457: * with sufficient accuracy already
458: */
459: size = (realsize * pixels_per_inch * 5) + 0.5;
460: sprintf(&fontp->fontname[len], FONT_SUFFIX, size);
461: if (!open_pxl_file(fontp))
462: return;
463: read_glyphs(fontp);
464: if (current_font == NULL) {
465: fontp->next = fontp;
466: fontp->prev = fontp;
467: } else {
468: fontp->next = current_font;
469: fontp->prev = current_font->prev;
470: current_font->prev->next = fontp;
471: current_font->prev = fontp;
472: }
473: current_font = fontp;
474: }
475:
476: open_pxl_file(font)
477: struct font *font;
478: {
479: char filename[300];
480: extern int errno;
481:
482: if (font->file == NULL) {
483: sprintf(filename, "%s/%s",
484: FONT_DIRECTORY, font->fontname);
485: if (n_open_fonts == MAX_OPEN_FONTS)
486: close_lru();
487: font->file = fopen(filename, "r");
488: if (font->file == NULL) {
489: font_not_found = 1;
490: printf("%s [not found]\n", font->fontname);
491: return (0);
492: }
493: n_open_fonts += 1;
494: }
495: if (list_fonts)
496: printf("%s\n", font->fontname);
497: return (1);
498: }
499:
500: read_pxl_bitmap(ch, g)
501: ubyte ch;
502: register struct glyph *g;
503: {
504: register struct bitmap *bitmap;
505: register int file_bytes_wide;
506: register char *ptr;
507: register int i, j;
508:
509: bitmap = &g->bitmap;
510:
511: /* in file, bitmap rows are multiples of 32 bits wide */
512: file_bytes_wide = ROUNDUP(bitmap->w, BITS_PER_LONG)*BYTES_PER_LONG;
513: /* width must be multiple of 16 bits for raster_op */
514: bitmap->bytes_wide = ROUNDUP(bitmap->w, BITS_PER_SHORT)*BYTES_PER_SHORT;
515: ptr = bitmap->bits = malloc((unsigned) bitmap->h * bitmap->bytes_wide);
516: if (ptr == NULL)
517: error("xdvi: Can't allocate bitmap for character %d of font %s (%d by %d)",
518: ch, current_font->fontname, bitmap->h, bitmap->w);
519: if (!open_pxl_file(current_font))
520: error("xdvi: Can't find font file %s", current_font->fontname);
521: fseek(current_font->file, g->addr, 0);
522: for (i = 0; i < bitmap->h; i += 1)
523: for (j = 0; j < file_bytes_wide; j += 1)
524: if (j < bitmap->bytes_wide)
525: *ptr++ = reverse_byte[one(current_font->file)];
526: else
527: one(current_font->file);
528: if (shrink_factor != 1)
529: shrink_bitmap(bitmap, shrink_factor, shrink_factor);
530: if (debug & DBG_BITMAP)
531: print_char(ch, g);
532: }
533:
534: /*
535: * Find font #n and move it to the head of the list.
536: */
537: change_font(n)
538: unsigned long n;
539: {
540: register struct font *fontp;
541:
542: fontp = current_font;
543: for (;;) {
544: if (fontp->TeXnumber == n)
545: break;
546: fontp = fontp->next;
547: if (fontp == current_font)
548: error("xdvi: Non-existent font #%d", n);
549: }
550: if (current_font == fontp)
551: return;
552: fontp->prev->next = fontp->next;
553: fontp->next->prev = fontp->prev;
554: fontp->next = current_font;
555: fontp->prev = current_font->prev;
556: current_font->prev->next = fontp;
557: current_font->prev = fontp;
558: current_font = fontp;
559: }
560:
561: /*
562: * Close the PXL file for the least recently used font.
563: */
564: close_lru()
565: {
566: register struct font *f;
567:
568: f = current_font->prev;
569: for (;;) {
570: if (f->file != NULL)
571: break;
572: f = f->prev;
573: if (f == current_font->prev)
574: error("xdvi: Can't find an open PXL file to close");
575: }
576: fclose(f->file);
577: f->file = NULL;
578: n_open_fonts -= 1;
579: }
580:
581: reset_fonts()
582: {
583: register struct font *f;
584: register struct glyph *g;
585:
586: f = current_font;
587: for (;;) {
588: open_pxl_file(f);
589: for (g = &f->glyph[0]; g < &f->glyph[MAXCHARS]; g += 1) {
590: if (g->bitmap.bits) free(g->bitmap.bits);
591: }
592: read_glyphs(f);
593: f = f->next;
594: if (f == current_font) break;
595: }
596: }
597:
598: read_glyphs (fontp)
599: register struct font *fontp;
600: {
601: register struct glyph *g;
602: long checksum, magnify, design_size, font_dir_ptr, pxl_id_word;
603:
604: /* seek to trailer info */
605: fseek(fontp->file, (long) -(5 * BYTES_PER_LONG), 2);
606: checksum = four(fontp->file);
607: magnify = four(fontp->file);
608: design_size = four(fontp->file);
609: font_dir_ptr = sfour(fontp->file) * 4;
610: pxl_id_word = four(fontp->file);
611: #ifdef lint
612: magnify = design_size = pxl_id_word = magnify;
613: #endif
614: /* seek to font directory */
615: fseek(fontp->file, font_dir_ptr, 0);
616: for (g = &fontp->glyph[0]; g < &fontp->glyph[MAXCHARS]; g += 1) {
617: g->bitmap.bits = NULL;
618: g->bitmap.w = two(fontp->file); /* leave this for shrink_bitmap */
619: g->bitmap.h = two(fontp->file); /* leave this for shrink_bitmap */
620: g->x = stwo(fontp->file) / shrink_factor;
621: g->y = stwo(fontp->file) / shrink_factor;
622: g->addr = four(fontp->file) * 4;
623: /*
624: ** The TFM-width word is kind of funny in the units
625: ** it is expressed in. It works this way:
626: **
627: ** If a glyph has width 'w' in a font with design-size
628: ** 'd' (both in same units), the TFM-width word is
629: **
630: ** (w/d) * 2^20
631: **
632: ** Therefore, in order to find the glyph width in
633: ** DVI units (1 / 2^16 points), we take the design-size
634: ** 'd' (in DVI's), the magnification 'm' of the PXL file
635: ** and the TFM-width word 't' to the width (in DVI's)
636: ** as follows:
637: **
638: ** dmt
639: ** w = -----
640: ** 2^20
641: **
642: ** But the magnification of the PXL file is just the
643: ** scaled size 's' over the design size, so the final
644: ** expression for the width is
645: **
646: ** st
647: ** w = ----
648: ** 2^20
649: **
650: */
651: g->dvi_adv =
652: ((double) fontp->scale * four(fontp->file)) / (1 << 20);
653: g->pxl_adv = pixel_round(g->dvi_adv);
654: }
655: }
656:
657: #define nope(str) error("xdvi: %s not implemented", str)
658: #define correct() (PXL_H = pixel_round(DVI_H))
659:
660: do_pages()
661: {
662: ubyte ch;
663:
664: min_x = 0;
665: min_y = 0;
666: max_x = screen_w;
667: max_y = screen_h;
668: base_x = min_x;
669: base_y = min_y;
670: current_page = 0;
671: for (;;) {
672: ch = one(dvi_file);
673: if (debug & DBG_DVI)
674: print_dvi(ch);
675: if (ch <= SETCHAR0 + 127) {
676: set_char(ch);
677: DVI_H += current_font->glyph[ch].dvi_adv;
678: PXL_H += current_font->glyph[ch].pxl_adv;
679: correct();
680: } else if (FNTNUM0 <= ch && ch <= FNTNUM0 + 63) {
681: change_font((unsigned long) (ch - FNTNUM0));
682: } else {
683: long a, b;
684:
685: switch (ch) {
686: case SET1:
687: nope("SET1");
688: break;
689:
690: case SETRULE:
691: a = sfour(dvi_file); b = sfour(dvi_file);
692: if (a > 0 && b > 0) {
693: correct();
694: set_rule(pixel_round(a), pixel_round(b));
695: }
696: DVI_H += b;
697: PXL_H = pixel_round(DVI_H);
698: break;
699:
700: case PUT1:
701: nope("PUT1");
702: break;
703:
704: case PUTRULE:
705: a = sfour(dvi_file); b = sfour(dvi_file);
706: if (a > 0 && b > 0) {
707: correct();
708: set_rule(pixel_round(a), pixel_round(b));
709: }
710: break;
711:
712: case NOP:
713: break;
714:
715: case BOP:
716: num(dvi_file, 11*4);
717: stackp = 0;
718: DVI_H = dvi_round(X_PAGE_OFFSET);
719: PXL_H = X_PAGE_OFFSET;
720: DVI_V = dvi_round(Y_PAGE_OFFSET);
721: PXL_V = Y_PAGE_OFFSET;
722: WW = XX = YY = ZZ = 0;
723: begin_page();
724: break;
725:
726: case EOP:
727: if (stackp > 0)
728: error("Stack not empty at EOP (%d)",
729: stackp);
730: end_page();
731: if (ftell(dvi_file) > last_page_offset)
732: return;
733: break;
734:
735: case PUSH:
736: stackp++;
737: if (stackp > maxstack)
738: error("xdvi: More PUSHes than were promised");
739: stack[stackp] = stack[stackp - 1];
740: break;
741:
742: case POP:
743: stackp--;
744: if (stackp < 0)
745: error("xdvi: More POPs than PUSHes");
746: break;
747:
748: case RIGHT1:
749: case RIGHT2:
750: case RIGHT3:
751: case RIGHT4:
752: DVI_H += snum(dvi_file, ch - RIGHT1 + 1);
753: PXL_H = pixel_round(DVI_H);
754: break;
755:
756: case X0:
757: case X1:
758: case X2:
759: case X3:
760: case X4:
761: if (ch != X0)
762: XX = snum(dvi_file, ch - X0);
763: DVI_H += XX;
764: PXL_H += pixel_round(XX);
765: correct();
766: break;
767:
768: case W0:
769: case W1:
770: case W2:
771: case W3:
772: case W4:
773: if (ch != W0)
774: WW = snum(dvi_file, ch - W0);
775: DVI_H += WW;
776: PXL_H = pixel_round(DVI_H);
777: break;
778:
779: case Y0:
780: case Y1:
781: case Y2:
782: case Y3:
783: case Y4:
784: if (ch != Y0)
785: YY = snum(dvi_file, ch - Y0);
786: DVI_V += YY;
787: PXL_V = pixel_round(DVI_V);
788: break;
789:
790: case Z0:
791: case Z1:
792: case Z2:
793: case Z3:
794: case Z4:
795: if (ch != Z0)
796: ZZ = snum(dvi_file, ch - Z0);
797: DVI_V += ZZ;
798: PXL_V = pixel_round(DVI_V);
799: break;
800:
801: case DOWN1:
802: case DOWN2:
803: case DOWN3:
804: case DOWN4:
805: DVI_V += snum(dvi_file, ch - DOWN1 + 1);
806: PXL_V = pixel_round(DVI_V);
807: break;
808:
809: case FNT1:
810: case FNT2:
811: case FNT3:
812: case FNT4:
813: change_font(num(dvi_file, ch - FNT1 + 1));
814: break;
815:
816: case XXX1:
817: case XXX2:
818: case XXX3:
819: case XXX4:
820: a = num(dvi_file, ch - XXX1 + 1);
821: if(a > 0)
822: special((unsigned long) a);
823: break;
824:
825: case FNTDEF1:
826: case FNTDEF2:
827: case FNTDEF3:
828: case FNTDEF4:
829: fseek(dvi_file, (long) (12 + ch - FNTDEF1 + 1), 1);
830: a = one(dvi_file) + one(dvi_file);
831: fseek(dvi_file, (long) a, 1);
832: break;
833:
834: case PRE:
835: error("xdvi: Shouldn't happen: PRE encountered.");
836: break;
837:
838: case POST:
839: error("xdvi: Shouldn't happen: POST encountered.");
840: break;
841:
842: case POSTPOST:
843: error("xdvi: Shouldn't happen: POSTPOST encountered.");
844: break;
845:
846: default:
847: error("xdvi: Unknown op-code %d, offset %d",
848: ch, ftell(dvi_file));
849: } /* end switch*/
850: } /* end else (ch not a SETCHAR or FNTNUM) */
851: } /* end for */
852: }
853:
854: set_char(ch)
855: ubyte ch;
856: {
857: register struct glyph *g;
858:
859: g = ¤t_font->glyph[ch];
860: if (g->bitmap.bits == NULL)
861: read_pxl_bitmap(ch, g);
862: put_bitmap(&g->bitmap, (PXL_H - g->x), (PXL_V - g->y), forepix);
863: }
864:
865: set_rule(h, w)
866: long h, w;
867: {
868: /* (w,h) specifies lower left corner of rule box */
869: put_rectangle(PXL_H, PXL_V - h, w, h, forepix);
870: }
871:
872: begin_page()
873: {
874: if (debug)
875: return;
876: if (!redisplay)
877: clear_page();
878: put_border(0, 0, page_w, page_h, 1);
879: }
880:
881: end_page()
882: {
883: int ch, arg, sign, number, next_page;
884: XEvent event;
885: char *string;
886: int nbytes;
887:
888: #ifdef lint
889: number = 0;
890: #endif
891: if (debug) {
892: if (++current_page == total_pages)
893: exit(0);
894: return;
895: }
896: if (redisplay) {
897: min_x = smin_x;
898: max_x = smax_x;
899: min_y = smin_y;
900: max_y = smax_y;
901: redisplay = 0;
902: }
903: arg = 0;
904: for (;;) {
905: XNextEvent (&event);
906: switch (event.type) {
907: case ExposeWindow:
908: screen_h = ((XExposeEvent *)(&event))->height;
909: screen_w = ((XExposeEvent *)(&event))->width;
910: max_x = min_x + screen_w;
911: max_y = min_y + screen_h;
912: string = "\f";
913: nbytes = 1;
914: break;
915: case ExposeRegion:
916: smin_x = min_x;
917: smax_x = max_x;
918: smin_y = min_y;
919: smax_y = max_y;
920: min_x = min_x + ((XExposeEvent *)(&event))->x;
921: min_y = min_y + ((XExposeEvent *)(&event))->y;
922: max_x = min_x + ((XExposeEvent *)(&event))->width;
923: max_y = min_y + ((XExposeEvent *)(&event))->height;
924: redisplay = 1;
925: string = "\f";
926: nbytes = 1;
927: break;
928: case ButtonPressed:
929: {
930: short detail = ((XButtonPressedEvent *) (&event))->detail;
931: switch (detail & ValueMask) {
932: case LeftButton:
933: if (detail & ShiftMask)
934: string = "l";
935: else
936: string = "b";
937: nbytes = 1;
938: break;
939: case MiddleButton:
940: if (detail & ShiftMask)
941: string = "u";
942: else
943: string = "d";
944: nbytes = 1;
945: break;
946: case RightButton:
947: if (detail & ShiftMask)
948: string = "r";
949: else
950: string = "f";
951: nbytes = 1;
952: break;
953: }
954: }
955: break;
956: case KeyPressed:
957: string = XLookupMapping (&event, &nbytes);
958: break;
959: }
960: if (nbytes == 0) continue;
961: if (nbytes > 1) goto bad;
962: switch (ch = *string) {
963: case 'q':
964: case '\003': /* control-C */
965: case '\004': /* control-D */
966: stop_output(0);
967: break;
968: case 'n':
969: case 'f':
970: case ' ':
971: /* scroll forward */
972: min_x = 0;
973: min_y = 0;
974: max_x = screen_w;
975: max_y = screen_h;
976: next_page = current_page + 1;
977: break;
978: case 'p':
979: case 'b':
980: case '\b':
981: /* scroll backward */
982: min_x = 0;
983: min_y = 0;
984: max_x = screen_w;
985: max_y = screen_h;
986: next_page = current_page - 1;
987: break;
988: case 'u':
989: if (min_y == 0) goto bad;
990: min_y -= screen_h;
991: if (min_y < 0)
992: min_y = 0;
993: base_y = min_y;
994: max_y = min_y + screen_h;
995: next_page = current_page;
996: break;
997: case 'd':
998: if (min_y >= page_h - screen_h) goto bad;
999: min_y += screen_h;
1000: if (min_y > page_h - screen_h)
1001: min_y = page_h - screen_h;
1002: if (min_y < 0)
1003: min_y = 0;
1004: base_y = min_y;
1005: max_y = min_y + screen_h;
1006: next_page = current_page;
1007: break;
1008: case 'l':
1009: if (min_x == 0) goto bad;
1010: min_x -= screen_w;
1011: if (min_x < 0)
1012: min_x = 0;
1013: base_x = min_x;
1014: max_x = min_x + screen_w;
1015: next_page = current_page;
1016: break;
1017: case 'r':
1018: if (min_x >= page_w - screen_w) goto bad;
1019: min_x += screen_w;
1020: if (min_x > page_w - screen_w)
1021: min_x = page_w - screen_w;
1022: if (min_x < 0)
1023: min_x = 0;
1024: base_x = min_x;
1025: max_x = min_x + screen_w;
1026: next_page = current_page;
1027: break;
1028: case 's':
1029: if (!arg) {
1030: int shrink = shrink_factor;
1031: long fac1, fac2;
1032: shrink_factor = 1;
1033: fac1 = ROUNDUP(PAPER_WIDTH, screen_w);
1034: fac2 = ROUNDUP(PAPER_HEIGHT, screen_h);
1035: if (fac1 < fac2)
1036: number = fac2;
1037: else
1038: number = fac1;
1039: shrink_factor = shrink;
1040: }
1041: if (number <= 0) goto bad;
1042: if (number != shrink_factor) {
1043: shrink_factor = number;
1044: min_x = 0;
1045: min_y = 0;
1046: max_x = screen_w;
1047: max_y = screen_h;
1048: init_page();
1049: define_conv();
1050: reset_fonts();
1051: }
1052: case '\f':
1053: /* redisplay current page */
1054: next_page = current_page;
1055: break;
1056: case '\r':
1057: case '\n':
1058: /* go to relative page */
1059: min_x = 0;
1060: min_y = 0;
1061: max_x = screen_w;
1062: max_y = screen_h;
1063: next_page = current_page + (arg ? number : 1);
1064: break;
1065: case 'g':
1066: /* go to absolute page */
1067: min_x = 0;
1068: min_y = 0;
1069: max_x = screen_w;
1070: max_y = screen_h;
1071: next_page = (arg ? number : total_pages) - 1;
1072: break;
1073: case '0': case '1': case '2': case '3': case '4':
1074: case '5': case '6': case '7': case '8': case '9':
1075: if (! arg) {
1076: arg = 1;
1077: sign = 1;
1078: number = 0;
1079: }
1080: number = 10*number + sign*(ch - '0');
1081: continue;
1082: case '-':
1083: if (! arg) {
1084: arg = 1;
1085: sign = -1;
1086: number = 0;
1087: continue;
1088: } else
1089: goto bad;
1090: default:
1091: goto bad;
1092: }
1093: if (0 <= next_page && next_page < total_pages) {
1094: current_page = next_page;
1095: fseek(dvi_file, page_offset[current_page], 0);
1096: break;
1097: }
1098: bad:
1099: XFeep(0);
1100: arg = 0; /* throw away numeric argument */
1101: continue;
1102: }
1103: }
1104:
1105: special(nbytes)
1106: unsigned long nbytes;
1107: {
1108: char *cmd;
1109: int i;
1110:
1111: cmd = malloc((unsigned) nbytes+1);
1112: if (cmd == NULL)
1113: error("xdvi: Can't allocate memory for special (%d bytes)", nbytes);
1114: for (i = 0; i < nbytes; i += 1)
1115: cmd[i] = getc(dvi_file);
1116: cmd[i] = '\0';
1117: fprintf(stderr, "special ``%s'' not implemented\n", cmd);
1118: free(cmd);
1119: }
1120:
1121: /*
1122: **
1123: ** Read size bytes from the FILE fp, constructing them into a
1124: ** signed/unsigned integer.
1125: **
1126: */
1127: unsigned long
1128: num(fp, size)
1129: register FILE *fp;
1130: register int size;
1131: {
1132: register int i;
1133: register long x;
1134:
1135: x = 0;
1136: for (i = 0; i < size; i += 1)
1137: x = x * 0x100 + (unsigned) getc(fp);
1138: return (x);
1139: }
1140:
1141: long
1142: snum(fp, size)
1143: register FILE *fp;
1144: register int size;
1145: {
1146: register int i;
1147: register long x;
1148:
1149: x = getc(fp) & 0xff;
1150: if (x & 0x80)
1151: x -= 0x100;
1152: for (i = 1; i < size; i += 1)
1153: x = x * 0x100 + (unsigned) getc(fp);
1154: return (x);
1155: }
1156:
1157: stop_output(sig)
1158: {
1159: exit(sig);
1160: }
1161:
1162: /* VARARGS1 */
1163: error(message, a, b, c, d, e, f)
1164: char *message;
1165: {
1166: fprintf(stderr, message, a, b, c, d, e, f);
1167: putc('\n', stderr);
1168: exit(1);
1169: }
1170:
1171: init_page()
1172: {
1173: page_h = PAPER_HEIGHT;
1174: page_w = PAPER_WIDTH;
1175: }
1176:
1177: clear_page()
1178: {
1179: XClear(win);
1180: }
1181:
1182: put_border(x, y, w, h, t)
1183: long x, y, w, h, t;
1184: {
1185: put_rectangle(x, y, w, t, highpix);
1186: put_rectangle(x, y, t, h, highpix);
1187: put_rectangle(x, y + h - t, w, t, highpix);
1188: put_rectangle(x + w - t, y, t, h, highpix);
1189: }
1190:
1191: put_rectangle(x, y, w, h, pix)
1192: long x, y, w, h;
1193: int pix;
1194: {
1195: if (x < max_x && x + w >= min_x && y < max_y && y + h >= min_y)
1196: XPixSet(win, x - base_x, y - base_y, w, h, pix);
1197: }
1198:
1199: put_bitmap(bitmap, x, y, pix)
1200: register struct bitmap *bitmap;
1201: register long x, y;
1202: int pix;
1203: {
1204: if (x < max_x && x + bitmap->w >= min_x &&
1205: y < max_y && y + bitmap->h >= min_y)
1206: XBitmapBitsPut(win, x - base_x, y - base_y,
1207: bitmap->w, bitmap->h, (char *) bitmap->bits,
1208: pix, backpix, NULL, GXcopy, AllPlanes);
1209: }
1210:
1211: sample(bitmap, x, y, w, h)
1212: register struct bitmap *bitmap;
1213: int x, y, w, h;
1214: {
1215: register char *ptr, *endp;
1216: register int b, i, j, m, n;
1217:
1218: ptr = bitmap->bits
1219: + (y * bitmap->bytes_wide)
1220: + (x / BITS_PER_BYTE);
1221: endp = bitmap->bits + (bitmap->h * bitmap->bytes_wide);
1222: b = (1 << (x % BITS_PER_BYTE));
1223: n = 0;
1224: for (i = 0; i < h && ptr < endp; i += 1, ptr += bitmap->bytes_wide)
1225: for (m = b, j = 0; j < w; j += 1, m <<= 1)
1226: if (*ptr & m)
1227: n += 1;
1228: return (n >= (i * w) / 3);
1229: }
1230:
1231: shrink_bitmap(bitmap, x_factor, y_factor)
1232: register struct bitmap *bitmap;
1233: int x_factor, y_factor;
1234: {
1235: char *shrunk_bits;
1236: int shrunk_height, shrunk_width, shrunk_bytes_wide;
1237: register char *ptr;
1238: char *cp;
1239: register int x, y, b, m;
1240:
1241: shrunk_height = ROUNDUP(bitmap->h, y_factor);
1242: shrunk_width = ROUNDUP(bitmap->w, x_factor);
1243: shrunk_bytes_wide = ROUNDUP(shrunk_width, BITS_PER_SHORT)*BYTES_PER_SHORT;
1244: /* width must be multiple of 16 bits for raster_op */
1245: ptr = shrunk_bits = calloc((unsigned) shrunk_height * shrunk_bytes_wide, 1);
1246: if (ptr == NULL)
1247: error("Can't allocate shrunken bitmap (%d by %d)",
1248: shrunk_height, shrunk_width);
1249: for (y = 0; y < bitmap->h; y += y_factor) {
1250: b = 0;
1251: m = (1 << 0);
1252: cp = ptr;
1253: for (x = 0; x < bitmap->w; x += x_factor) {
1254: if (sample(bitmap, x, y, x_factor, y_factor))
1255: *ptr |= m;
1256: else
1257: *ptr &= ~m;
1258: b += 1;
1259: m <<= 1;
1260: if (b % BITS_PER_BYTE == 0) {
1261: b = 0;
1262: m = (1 << 0);
1263: ptr += 1;
1264: }
1265: }
1266: ptr = cp + shrunk_bytes_wide;
1267: }
1268: free(bitmap->bits);
1269: bitmap->bits = shrunk_bits;
1270: bitmap->h = shrunk_height;
1271: bitmap->w = shrunk_width;
1272: bitmap->bytes_wide = shrunk_bytes_wide;
1273: }
1274:
1275: print_char(ch, g)
1276: ubyte ch;
1277: struct glyph *g;
1278: {
1279: printf("char %d", ch);
1280: if (isprint(ch))
1281: printf(" (%c)", ch);
1282: putchar('\n');
1283: printf("x = %d, y = %d, pxl = %d, dvi = %d\n",
1284: g->x, g->y, g->pxl_adv, g->dvi_adv);
1285: print_bitmap(&g->bitmap);
1286: }
1287:
1288: print_bitmap(bitmap)
1289: register struct bitmap *bitmap;
1290: {
1291: register char *ptr;
1292: register int x, y, i;
1293:
1294: ptr = bitmap->bits;
1295: if (ptr == NULL)
1296: return;
1297: printf("w = %d, h = %d, bytes wide = %d\n",
1298: bitmap->w, bitmap->h, bitmap->bytes_wide);
1299: for (y = 0; y < bitmap->h; y += 1) {
1300: for (x = 0; x < bitmap->bytes_wide; x += 1) {
1301: for (i = 0; i < BITS_PER_BYTE; i += 1)
1302: if (*ptr & (1 << i))
1303: putchar('@');
1304: else
1305: putchar(' ');
1306: ptr += 1;
1307: }
1308: putchar('\n');
1309: }
1310: }
1311:
1312: print_dvi(ch)
1313: ubyte ch;
1314: {
1315: printf("%4d %4d ", PXL_H, PXL_V);
1316: if (ch <= SETCHAR0 + 127) {
1317: printf("SETCHAR%-3d", ch - SETCHAR0);
1318: if (isprint(ch))
1319: printf(" (%c)", ch);
1320: } else if (FNTNUM0 <= ch && ch <= FNTNUM0 + 63) {
1321: printf("FNTNUM%d", ch - FNTNUM0);
1322: } else {
1323: switch (ch) {
1324: case SET1:
1325: printf("SET1");
1326: break;
1327: case SETRULE:
1328: printf("SETRULE");
1329: break;
1330: case PUT1:
1331: printf("PUT1");
1332: break;
1333: case PUTRULE:
1334: printf("PUTRULE");
1335: break;
1336: case NOP:
1337: printf("NOP");
1338: break;
1339: case BOP:
1340: printf("BOP");
1341: break;
1342: case EOP:
1343: printf("EOP");
1344: break;
1345: case PUSH:
1346: printf("PUSH");
1347: break;
1348: case POP:
1349: printf("POP");
1350: break;
1351: case RIGHT1:
1352: case RIGHT2:
1353: case RIGHT3:
1354: case RIGHT4:
1355: printf("RIGHT%d", ch - RIGHT1 + 1);
1356: break;
1357: case X0:
1358: case X1:
1359: case X2:
1360: case X3:
1361: case X4:
1362: printf("X%d", ch - X0);
1363: break;
1364: case W0:
1365: case W1:
1366: case W2:
1367: case W3:
1368: case W4:
1369: printf("W%d", ch - W0);
1370: break;
1371: case Y0:
1372: case Y1:
1373: case Y2:
1374: case Y3:
1375: case Y4:
1376: printf("Y%d", ch - Y0);
1377: break;
1378: case Z0:
1379: case Z1:
1380: case Z2:
1381: case Z3:
1382: case Z4:
1383: printf("Z%d", ch - Z0);
1384: break;
1385: case DOWN1:
1386: case DOWN2:
1387: case DOWN3:
1388: case DOWN4:
1389: printf("DOWN%d", ch - DOWN1 + 1);
1390: break;
1391: case FNT1:
1392: case FNT2:
1393: case FNT3:
1394: case FNT4:
1395: printf("FNT%d", ch - FNT1 + 1);
1396: break;
1397: case XXX1:
1398: case XXX2:
1399: case XXX3:
1400: case XXX4:
1401: printf("XXX%d", ch - XXX1 + 1);
1402: break;
1403: case FNTDEF1:
1404: case FNTDEF2:
1405: case FNTDEF3:
1406: case FNTDEF4:
1407: printf("FNTDEF%d", ch - FNTDEF1 + 1);
1408: break;
1409: case PRE:
1410: printf("PRE");
1411: break;
1412: case POST:
1413: printf("POST");
1414: break;
1415: case POSTPOST:
1416: printf("POSTPOST");
1417: break;
1418: default:
1419: error("xdvi: Unknown op-code %d, offset %d",
1420: ch, ftell(dvi_file));
1421: } /* end switch*/
1422: } /* end else (ch not a SETCHAR or FNTNUM) */
1423: putchar('\n');
1424: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.