Annotation of OpenXM_contrib/gnuplot/term/pdf.trm, Revision 1.1.1.1
1.1 ohara 1: /*Hello, Emacs, this is -*-C-*- ! */
2: /*------------------------------
3: GNUPLOT - pdf.trm
4:
5: This file is included by ../term.c.
6:
7: This driver uses PDFlib from www.pdflib.com
8:
9: Author:
10:
11: Hans-Bernhard Br"oker
12: broeker@physik.rwth-aachen.de
13:
14: Licence: see the gnuplot copyright (to be merged into here...)
15:
16: Options: can #define PDF_DONT_COMPRESS to avoid PDF output
17: generated being compressed (by the 'deflate' algorithm as used
18: in 'zip' or 'gzip'). That helps in debugging.
19:
20: ------------------------------*/
21:
22: /* CODEME: Add patterned lines (?). Implement the PM3D stuff. */
23:
24: #include "driver.h"
25:
26: #ifdef TERM_REGISTER
27: register_term (pdf)
28: #endif
29:
30: #ifdef TERM_PROTO
31: TERM_PUBLIC void PDF_options __PROTO ((void));
32: TERM_PUBLIC void PDF_init __PROTO ((void));
33: TERM_PUBLIC void PDF_graphics __PROTO ((void));
34: TERM_PUBLIC void PDF_text __PROTO ((void));
35: TERM_PUBLIC void PDF_linetype __PROTO ((int linetype));
36: TERM_PUBLIC void PDF_move __PROTO ((unsigned int x, unsigned int y));
37: TERM_PUBLIC void PDF_vector __PROTO ((unsigned int x, unsigned int y));
38: TERM_PUBLIC void PDF_put_text __PROTO ((unsigned int x, unsigned int y, char *str));
39: TERM_PUBLIC void PDF_reset __PROTO ((void));
40: TERM_PUBLIC int PDF_justify_text __PROTO ((enum JUSTIFY mode));
41: TERM_PUBLIC int PDF_text_angle __PROTO ((int ang));
42: TERM_PUBLIC void PDF_point __PROTO ((unsigned int x, unsigned int y, int pointstyle));
43: TERM_PUBLIC int PDF_set_font __PROTO ((char *font));
44: TERM_PUBLIC void PDF_boxfill __PROTO((int style, unsigned int x1, unsigned int y1, unsigned int width, unsigned int height));
45: TERM_PUBLIC void PDF_linewidth __PROTO ((double linewidth));
46:
47: #define PDF_NUM_POINTTYPES 75 /* number of point symbol types not counting the dot */
48:
49: #define PDF_RESOLUTION (20) /* number of terminal pixels per pt */
50: #define PDF_XMAX (5*72*PDF_RESOLUTION) /* 5 inches, 72 pt/inch */
51: #define PDF_YMAX (3*72*PDF_RESOLUTION) /* 3 inches, 72 pt/inch */
52:
53: #endif /* TERM_PROTO */
54:
55: #ifndef TERM_PROTO_ONLY
56: #ifdef TERM_BODY
57:
58: #include <pdflib.h>
59:
60: PDF *myPDF = NULL;
61:
62: unsigned int PDF_xLast = UINT_MAX; /* current pen horizontal position*/
63: unsigned int PDF_yLast = UINT_MAX; /* current pen vertical position*/
64:
65: int PDF_LineType = -3; /* current line type*/
66: double PDF_LineWidth = 1.0; /* current line width*/
67: int PDF_TextAngle = 0; /* current text orientation*/
68: enum JUSTIFY PDF_TextJust = LEFT; /* current text justification*/
69:
70: char PDF_fontNameDef[MAX_ID_LEN + 1] = "Helvetica"; /* default text font family*/
71: double PDF_fontSizeDef = 6; /* default text size*/
72: char PDF_fontNameCur[MAX_ID_LEN + 1] = "Helvetica"; /* current text font family*/
73: double PDF_fontSizeCur = 6; /* current text size*/
74:
75: TBOOLEAN PDF_pageIsOpen = FALSE; /* already started a page ?? */
76: TBOOLEAN PDF_pathIsOpen = FALSE; /* open path flag*/
77:
78: int PDF_fontAscent = 0; /* estimated current font ascent*/
79: int PDF_fontDescent = 0; /* estimated current font descent*/
80: int PDF_fontLeading = 0; /* estimated current font leading*/
81: int PDF_fontAvWidth = 0; /* estimated current font char average width*/
82:
83: static short PDF_Pen_RealID __PROTO ((int));
84: static void PDF_PathOpen __PROTO ((void));
85: static void PDF_PathClose __PROTO ((void));
86: static void PDF_SetFont __PROTO ((void));
87:
88: /*------------------------ helper functions -------------------*/
89:
90: static short
91: PDF_Pen_RealID (inPenCode)
92: int inPenCode;
93: {
94: if (inPenCode >= 13)
95: inPenCode %= 13; /* normalize pen code*/
96: if (inPenCode < -2)
97: inPenCode = -2;
98:
99: return (inPenCode + 2);
100: }
101:
102: /* Functions to ensure that as many move() and vector() calls as
103: * possible get converted into a single long 'path', before closing it
104: * with a stroke or similar command. */
105: static void
106: PDF_PathOpen ()
107: {
108: PDF_pathIsOpen = TRUE;
109: }
110:
111: static void
112: PDF_PathClose ()
113: {
114: if (PDF_pathIsOpen) {
115: PDF_stroke(myPDF);
116:
117: PDF_pathIsOpen = FALSE;
118: }
119: }
120:
121: /* Helper function to deal with switching over to a newly selected
122: * font. For now, this does not try to embed fonts into the PDF
123: * file. This relies on the user restricting herself to the 14
124: * 'classical' fonts built into every valid PDF reader application */
125: static void
126: PDF_SetFont ()
127: {
128: int font_handle = PDF_findfont(myPDF, PDF_fontNameCur, "host", 0);
129:
130: PDF_setfont(myPDF, font_handle, PDF_fontSizeCur * PDF_RESOLUTION);
131:
132: /* Ask PDFlib for the actual numbers */
133: PDF_fontAscent = (int) (PDF_RESOLUTION * PDF_fontSizeCur * PDF_get_value(myPDF, "ascender", 0));
134: PDF_fontDescent = (int) (- PDF_RESOLUTION * PDF_fontSizeCur * PDF_get_value(myPDF, "descender", 0));
135: PDF_fontLeading = (int) (PDF_RESOLUTION * PDF_fontSizeCur * 0.25);
136:
137: /* Assume this particular string is a somewhat reasonable typical
138: * output, for getting at the average character width */
139: PDF_fontAvWidth = (int)
140: (PDF_RESOLUTION * PDF_stringwidth(myPDF, "01234567890123456789",
141: font_handle, PDF_fontSizeCur)
142: / 20.0);
143: }
144:
145: /*------------------- the terminal entry functions --------------------*/
146:
147:
148: TERM_PUBLIC void
149: PDF_options ()
150: {
151: struct value a;
152:
153: if (!END_OF_COMMAND) { /* get default font family name*/
154: if (almost_equals (c_token, "fn$ame")) {
155: c_token++;
156:
157: if (!END_OF_COMMAND && isstring (c_token)) {
158: quote_str (PDF_fontNameDef, c_token, MAX_ID_LEN);
159: c_token++;
160: } else
161: int_error("fname: expecting font name", c_token);
162: }
163: }
164:
165: if (!END_OF_COMMAND) { /* get default font size*/
166: if (almost_equals (c_token, "fs$ize")) {
167: c_token++;
168:
169: if (END_OF_COMMAND)
170: int_error("fsize: expecting font size", c_token);
171: PDF_fontSizeDef = real (const_express (&a));
172: }
173: }
174:
175: if (!END_OF_COMMAND)
176: int_error("unexpected text at end of command", c_token);
177:
178: /* Save options back into options string in normalized format */
179: sprintf(term_options, "fname '%s' fsize %g",
180: PDF_fontNameDef, PDF_fontSizeDef);
181: }
182:
183:
184: TERM_PUBLIC void
185: PDF_init ()
186: {
187: static TBOOLEAN PDFlib_booted = FALSE;
188:
189: if (!PDFlib_booted) {
190: PDF_boot();
191: PDFlib_booted = TRUE;
192: }
193:
194: if (!myPDF)
195: myPDF = PDF_new();
196:
197: /*open new PDF file */
198: if (PDF_open_fp(myPDF, gpoutfile) == -1)
199: int_error("Error:cannot open PDF file .\n", NO_CARET);
200:
201: #ifdef PDF_DONT_COMPRESS
202: /* for easier debugging of the output, turn off PDF stream
203: * compression */
204: PDF_set_value(myPDF, "compress", 0);
205: #endif
206:
207: PDF_set_info(myPDF,"Creator","gnuplot-3.8e");
208: PDF_set_info(myPDF,"Author","Hans-Bernhard Broeker"); /* FIXME: put in username? */
209: PDF_set_info(myPDF,"Title","gnuplot diagram"); /* FIXME: use 'set title', if any ? */
210:
211: PDF_LineType = -3;
212:
213: /* set current font to default */
214: strcpy(PDF_fontNameCur, PDF_fontNameDef);
215: PDF_fontSizeCur = PDF_fontSizeDef;
216:
217: /* Have to start the first page now, in order to know the actual
218: * size of the selected font */
219: PDF_graphics();
220:
221: /* set h_char, v_char*/
222: term->h_char = PDF_fontAvWidth;
223: term->v_char = (PDF_fontAscent + PDF_fontDescent + PDF_fontLeading);
224:
225: /* set h_tic, v_tic*/
226: term->h_tic = term->v_tic = 3 * PDF_RESOLUTION;
227:
228: /* initialize terminal's pointsize from "set pointsize" value */
229: term_pointsize = pointsize;
230: }
231:
232:
233: TERM_PUBLIC void
234: PDF_graphics ()
235: {
236: if (PDF_pageIsOpen)
237: return; /* already open --> nothing to do */
238:
239: PDF_pathIsOpen = FALSE;
240: PDF_xLast = PDF_yLast = UINT_MAX;
241:
242: /* set xmax, ymax*/
243: term->xmax = PDF_XMAX * xsize;
244: term->ymax = PDF_YMAX * ysize;
245:
246: PDF_begin_page(myPDF, (double)term->xmax / PDF_RESOLUTION,
247: (double)term->ymax / PDF_RESOLUTION);
248: PDF_scale(myPDF, 1.0/PDF_RESOLUTION, 1.0/PDF_RESOLUTION);
249: if (title.text && title.text[0])
250: /* a title has been set --> use it as the bookmark name, too */
251: PDF_add_bookmark(myPDF, title.text, 0, 1);
252: PDF_pageIsOpen = TRUE;
253:
254: PDF_SetFont();
255: }
256:
257:
258: TERM_PUBLIC void
259: PDF_text ()
260: {
261: PDF_PathClose();
262: PDF_end_page(myPDF);
263: PDF_pageIsOpen = FALSE;
264: }
265:
266:
267: TERM_PUBLIC void
268: PDF_reset ()
269: {
270: assert(PDF_pageIsOpen == FALSE);
271: PDF_close(myPDF);
272: PDF_delete(myPDF);
273: myPDF = NULL;
274: }
275:
276:
277: TERM_PUBLIC void
278: PDF_linetype (int linetype)
279: {
280: if (linetype != PDF_LineType) {
281: int real_linetype = PDF_Pen_RealID(linetype);
282: struct rgb *this_color = web_color_rgbs + 1 + real_linetype;
283:
284: PDF_PathClose ();
285: PDF_LineType = linetype;
286:
287: PDF_setrgbcolor(myPDF, this_color->r / 255.0,
288: this_color->g / 255.0, this_color->b / 255.0);
289: }
290: }
291:
292:
293: TERM_PUBLIC void
294: PDF_linewidth (double linewidth)
295: {
296: PDF_PathClose();
297: PDF_LineWidth = PDF_RESOLUTION * linewidth / 4.0;
298: PDF_setlinewidth(myPDF, PDF_LineWidth);
299: }
300:
301:
302: TERM_PUBLIC void
303: PDF_move (unsigned int x, unsigned int y)
304: {
305: if (PDF_pathIsOpen && x == PDF_xLast && y == PDF_yLast)
306: return;
307:
308: PDF_PathOpen ();
309: PDF_moveto(myPDF, x, y);
310:
311: PDF_xLast = x;
312: PDF_yLast = y;
313: }
314:
315:
316: TERM_PUBLIC void
317: PDF_vector (unsigned int x, unsigned int y)
318: {
319: if (PDF_pathIsOpen && x == PDF_xLast && y == PDF_yLast)
320: return;
321:
322: PDF_PathOpen ();
323: PDF_lineto(myPDF, x, y);
324:
325: PDF_xLast = x;
326: PDF_yLast = y;
327: }
328:
329: /* Helper function. Many symbols have an additional dot in their
330: * center, so isolate its drawing into a separate function. */
331: static GP_INLINE void
332: PDF_dot (unsigned int x, unsigned int y)
333: {
334: /* Imitate PS's way of creating a small dot by a zero-length line
335: * segment with rounded endpoints */
336: PDF_setlinecap(myPDF, 1); /* rounded ends */
337: PDF_moveto(myPDF, x, y);
338: PDF_lineto(myPDF, x, y);
339: PDF_stroke(myPDF);
340: }
341:
342:
343: TERM_PUBLIC void
344: PDF_point (unsigned int x, unsigned int y, int number)
345: {
346: PDF_PathClose ();
347: PDF_save(myPDF);
348:
349: if (number < 0) {
350: /* Like the PostScript driver, treat all negative numbers as
351: * 'with dots'. */
352: PDF_dot(x, y);
353: } else {
354: /* Change coordinate system so the point symbols themselves
355: * can be drawn without depending on position or size (-->
356: * better compression and less coding for gnuplot) */
357: /* NB: I use the do_pointsize() default implementation, which
358: * just stores the last set pointsize into `term_pointsize',
359: * to avoid introducing another static driver-local variable
360: * */
361: PDF_translate(myPDF, x, y);
362: PDF_scale(myPDF, term->h_tic / 2.0 * term_pointsize,
363: term->v_tic / 2.0 * term_pointsize);
364: /* Correct linewidth to counter the scaling effect --- assume
365: * h_tic is usable, to avoid having to average h_ and v_tic */
366: PDF_setlinewidth(myPDF,
367: PDF_LineWidth / (term->h_tic / 2.0 * term_pointsize));
368: switch (number %= PDF_NUM_POINTTYPES) {
369: case 0: /* Plus */
370: PDF_moveto(myPDF, -1, 0);
371: PDF_lineto(myPDF, 1, 0);
372: PDF_moveto(myPDF, 0, -1);
373: PDF_lineto(myPDF, 0, 1);
374: PDF_stroke(myPDF);
375: break;
376: case 2: /* Star */
377: PDF_moveto(myPDF, -1, 0);
378: PDF_lineto(myPDF, 1, 0);
379: PDF_moveto(myPDF, 0, -1);
380: PDF_lineto(myPDF, 0, 1);
381: /* FALLTHROUGH */
382: case 1: /* Cross */
383: PDF_moveto(myPDF, -1, -1);
384: PDF_lineto(myPDF, 1, 1);
385: PDF_moveto(myPDF, 1, -1);
386: PDF_lineto(myPDF, -1, 1);
387: PDF_stroke(myPDF);
388: break;
389:
390: /* For each x = 0..5, 4 shapes are defined:
391: * 3 + 2*x --> hollow symbol with a dot at its center
392: * 4 + 2*x --> solid symbol filled in linetype's color
393: * 63 + x --> hollow symbol without the center dot
394: * 69 + x --> symbol filled with white --> opaque symbol */
395:
396: case 63+0: /* BoxEmpty */
397: case 3+2*0: /* Box */
398: PDF_moveto(myPDF, -1, -1);
399: PDF_lineto(myPDF, 1, -1);
400: PDF_lineto(myPDF, 1, 1);
401: PDF_lineto(myPDF, -1, 1);
402: PDF_closepath_stroke(myPDF);
403: if (number == 3) PDF_dot(0,0);
404: break;
405: case 69+0: /* BoxWhitefilled */
406: PDF_setgray_fill(myPDF, 1);
407: /* FALLTHROUGH */
408: case 4+2*0: /* BoxFilled */
409: PDF_moveto(myPDF, -1, -1);
410: PDF_lineto(myPDF, 1, -1);
411: PDF_lineto(myPDF, 1, 1);
412: PDF_lineto(myPDF, -1, 1);
413: PDF_closepath_fill_stroke(myPDF);
414: break;
415:
416: case 63+1: /* CircleEmpty */
417: case 3+2*1: /* Circle */
418: PDF_circle(myPDF, 0, 0, 1);
419: PDF_stroke(myPDF);
420: if (number == 5) PDF_dot(0,0);
421: break;
422: case 69+1: /* CircleWhitefilled */
423: PDF_setgray_fill(myPDF, 1);
424: /* FALLTHROUGH */
425: case 4+2*1: /* CircleFilled */
426: PDF_circle(myPDF, 0, 0, 1);
427: PDF_fill_stroke(myPDF);
428: break;
429:
430: case 63+2: /* TriangleUpEmpty */
431: case 3+2*2: /* TriangleUp */
432: PDF_moveto(myPDF, 0, 1.12);
433: PDF_lineto(myPDF, -1, -0.5);
434: PDF_lineto(myPDF, 1, -0.5);
435: PDF_closepath_stroke(myPDF);
436: if (number == 7) PDF_dot(0,0);
437: break;
438: case 69+2: /* TriangleUpWhitefilled */
439: PDF_setgray_fill(myPDF, 1);
440: /* FALLTHROUGH */
441: case 4+2*2: /* TriangleUpFilled */
442: PDF_moveto(myPDF, 0, 1.12);
443: PDF_lineto(myPDF, -1, -0.5);
444: PDF_lineto(myPDF, 1, -0.5);
445: PDF_closepath_fill_stroke(myPDF);
446: break;
447:
448: case 63+3: /* TriangleDownEmpty */
449: case 3+2*3: /* TriangleDown */
450: PDF_moveto(myPDF, 0, -1.12);
451: PDF_lineto(myPDF, -1, 0.5);
452: PDF_lineto(myPDF, 1, 0.5);
453: PDF_closepath_stroke(myPDF);
454: if (number == 9) PDF_dot(0,0);
455: break;
456: case 69+3: /* TriangleDownWhitefilled */
457: PDF_setgray_fill(myPDF, 1);
458: /* FALLTHROUGH */
459: case 4+2*3: /* TriangleDownFilled */
460: PDF_moveto(myPDF, 0, -1.12);
461: PDF_lineto(myPDF, -1, 0.5);
462: PDF_lineto(myPDF, 1, 0.5);
463: PDF_closepath_fill_stroke(myPDF);
464: break;
465:
466: case 63+4: /* DiamondEmpty */
467: case 3+2*4: /* Diamond */
468: PDF_moveto(myPDF, 0, -1);
469: PDF_lineto(myPDF, 1, 0);
470: PDF_lineto(myPDF, 0, 1);
471: PDF_lineto(myPDF, -1, 0);
472: PDF_closepath_stroke(myPDF);
473: if (number == 11) PDF_dot(0,0);
474: break;
475: case 69+4: /* DiamondWhitefilled */
476: PDF_setgray_fill(myPDF, 1);
477: /* FALLTHROUGH */
478: case 4+2*4: /* DiamondFilled */
479: PDF_moveto(myPDF, 0, -1);
480: PDF_lineto(myPDF, 1, 0);
481: PDF_lineto(myPDF, 0, 1);
482: PDF_lineto(myPDF, -1, 0);
483: PDF_closepath_fill_stroke(myPDF);
484: break;
485:
486: case 63+5: /* PentagonEmpty */
487: case 3+2*5: /* Pentagon */
488: PDF_moveto(myPDF, 0, 1);
489: PDF_lineto(myPDF, -0.95, 0.31);
490: PDF_lineto(myPDF, -0.58, -0.81);
491: PDF_lineto(myPDF, +0.58, -0.81);
492: PDF_lineto(myPDF, +0.95, 0.31);
493: PDF_closepath_stroke(myPDF);
494: if (number == 13) PDF_dot(0,0);
495: break;
496: case 69+5: /* PentagonWhitefilled */
497: PDF_setgray_fill(myPDF, 1);
498: /* FALLTHROUGH */
499: case 4+2*5: /* PentagonFilled */
500: PDF_moveto(myPDF, 0, 1);
501: PDF_lineto(myPDF, -0.95, 0.31);
502: PDF_lineto(myPDF, -0.58, -0.81);
503: PDF_lineto(myPDF, +0.58, -0.81);
504: PDF_lineto(myPDF, +0.95, 0.31);
505: PDF_closepath_fill_stroke(myPDF);
506: break;
507:
508: /* 15 + (0..15): circles with varying parts of'em filled. The added
509: * number is a bit-pattern of the 4 quadrants: 1 signals a quadrant
510: * filled */
511: case 15+0:
512: PDF_moveto(myPDF, 0, 0);
513: PDF_lineto(myPDF, 0, 1);
514: PDF_arc(myPDF, 0, 0, 1, 90, 360+90);
515: PDF_closepath_stroke(myPDF);
516: break;
517:
518: /* Generalize common code into a macro... */
519: #define CIRCLE_SINGLE_PIESLICE(x, y, angle1, angle2) \
520: PDF_moveto(myPDF, 0, 0); \
521: PDF_lineto(myPDF, (x), (y)); \
522: PDF_arc(myPDF, 0, 0, 1, (angle1), (angle2)); \
523: PDF_lineto(myPDF, 0, 0); \
524: PDF_closepath(myPDF); \
525: PDF_fill_stroke(myPDF); \
526: PDF_arc(myPDF, 0, 0, 1, (angle2), (angle1) + 360); \
527: PDF_stroke(myPDF); \
528: break;
529:
530: #define CIRCLE_SINGLE_QUADRANT(x, y, angle) \
531: CIRCLE_SINGLE_PIESLICE(x, y, angle, angle+90);
532: case 15+1:
533: CIRCLE_SINGLE_QUADRANT(1, 0, 0);
534: case 15+2:
535: CIRCLE_SINGLE_QUADRANT(0, 1, 90);
536: case 15+4:
537: CIRCLE_SINGLE_QUADRANT(-1, 0, 180);
538: case 15+8:
539: CIRCLE_SINGLE_QUADRANT(0, -1, 270);
540: #undef CIRCLE_SINGLE_QUADRANT
541:
542: #define CIRCLE_TWO_NEIGHBOR_QUADRANTS(x, y, angle) \
543: CIRCLE_SINGLE_PIESLICE(x, y, angle, angle+180)
544: case 15+3:
545: CIRCLE_TWO_NEIGHBOR_QUADRANTS(1, 0, 0);
546: case 15+6:
547: CIRCLE_TWO_NEIGHBOR_QUADRANTS(0, 1, 90);
548: case 15+12:
549: CIRCLE_TWO_NEIGHBOR_QUADRANTS(-1, 0, 180);
550: case 15+9:
551: CIRCLE_TWO_NEIGHBOR_QUADRANTS(0, -1, 270);
552: #undef CIRCLE_TWO_NEIGHBOR_QUADRANTS
553:
554: #define CIRCLE_TWO_OPPOSING_QUADRANTS(x, y, angle) \
555: PDF_moveto(myPDF, 0, 0); \
556: PDF_lineto(myPDF, x, y); \
557: PDF_arc(myPDF, 0, 0, 1, angle, angle + 90); \
558: PDF_lineto(myPDF, 0, 0); \
559: PDF_fill_stroke(myPDF); \
560: PDF_moveto(myPDF, 0, 0); \
561: PDF_lineto(myPDF, -x, -y); \
562: PDF_arc(myPDF, 0, 0, 1, angle + 180, angle + 270); \
563: PDF_lineto(myPDF, 0, 0); \
564: PDF_fill_stroke(myPDF); \
565: PDF_arc(myPDF, 0, 0, 1, angle + 90, angle + 360); \
566: PDF_stroke(myPDF); \
567: break;
568: case 15+5:
569: CIRCLE_TWO_OPPOSING_QUADRANTS(1, 0, 0);
570: case 15+10:
571: CIRCLE_TWO_OPPOSING_QUADRANTS(0, 1, 90);
572: #undef CIRCLE_TWO_OPPOSING_QUADRANTS
573:
574: #define CIRCLE_THREE_QUADRANTS(x, y, angle) \
575: CIRCLE_SINGLE_PIESLICE(x, y, angle, angle+270)
576: case 15+7:
577: CIRCLE_THREE_QUADRANTS(1, 0, 0);
578: case 15+14:
579: CIRCLE_THREE_QUADRANTS(0, 1, 90);
580: case 15+13:
581: CIRCLE_THREE_QUADRANTS(-1, 0, 180);
582: case 15+11:
583: CIRCLE_THREE_QUADRANTS(0, -1, 270);
584: #undef CIRCLE_THREE_QUADRANTS
585: #undef CIRCLE_SINGLE_PIESLICE
586:
587: case 15+15:
588: PDF_circle(myPDF, 0, 0, 1);
589: PDF_closepath_fill_stroke(myPDF);
590: break;
591:
592:
593: /*************************************************************************/
594: /* 31 + (0..15): squares with different quadrants of them filled in. */
595: /*************************************************************************/
596: /*************************************************************************/
597: /* 47 + (0..15): diamonds with filled quadrants as given by bit pattern */
598: /* Diamonds are drawn as squares rotated by 45 degrees, so can use
599: * fall-through from diamond to squares, and re-use some macros. */
600: /*************************************************************************/
601: case 47+0:
602: PDF_rotate(myPDF, 45);
603: /* FALLTHROUGH */
604: case 31+0:
605: PDF_moveto(myPDF, 0, 0);
606: PDF_lineto(myPDF, 0, 1);
607: PDF_lineto(myPDF, -1, 1);
608: PDF_lineto(myPDF, -1, -1);
609: PDF_lineto(myPDF, 1, -1);
610: PDF_lineto(myPDF, 1, 1);
611: PDF_lineto(myPDF, 0, 1);
612: PDF_stroke(myPDF);
613: break;
614:
615: case 47+15:
616: PDF_rotate(myPDF, 45);
617: /* FALLTHROUGH */
618: case 31+15:
619: PDF_moveto(myPDF, -1, 1);
620: PDF_lineto(myPDF, -1, -1);
621: PDF_lineto(myPDF, 1, -1);
622: PDF_lineto(myPDF, 1, 1);
623: PDF_closepath_fill_stroke(myPDF);
624: break;
625:
626: /* macros defining shapes of the partly filled symbols. Done by
627: * rotating the starting point (x0, y0) by 90 degrees or 45 degrees
628: * (with length adjustment). The rotations can be done without
629: * trigonometric function calls, since their values are known:
630: * cos(90)=0, sin(90)=1, cos(45)=sin(45)=1/sqrt(2). A good compiler
631: * should be able to optimize away all the local variables and
632: * loops... */
633:
634: #define SQUARE_SINGLE_PIESLICE(x0, y0, quadrants) \
635: { \
636: int quadrant = 0; \
637: int x= x0, y=y0; \
638: PDF_moveto(myPDF, 0, 0); \
639: PDF_lineto(myPDF, x, y); \
640: /* poor man's rotation by 45 and 90 degrees around the \
641: * square's outline. */ \
642: while (quadrant++ < quadrants) { \
643: int dummy; \
644: PDF_lineto(myPDF, x-y, x+y); \
645: dummy = x; x = -y; y = dummy; \
646: } \
647: PDF_lineto(myPDF, x, y); \
648: PDF_closepath_fill_stroke(myPDF); \
649: PDF_moveto(myPDF, x, y); \
650: while (quadrant++ <= 4) { \
651: int dummy; \
652: PDF_lineto(myPDF, x-y, x+y); \
653: dummy = x; x = -y; y = dummy; \
654: } \
655: PDF_lineto(myPDF, x, y); \
656: PDF_stroke(myPDF); \
657: } \
658: break;
659:
660: #define SQUARE_TWO_OPPOSING_QUADRANTS(x0, y0, angle) \
661: { \
662: int x = x0, y = y0, dummy; \
663: int counter = 0; \
664: \
665: while (counter++ < 2) { \
666: PDF_moveto(myPDF, 0, 0); \
667: PDF_lineto(myPDF, x, y); \
668: PDF_lineto(myPDF, x-y, x+y); \
669: dummy = x; x = -y; y = dummy; \
670: PDF_lineto(myPDF, x, y); \
671: PDF_closepath_fill_stroke(myPDF); \
672: \
673: PDF_moveto(myPDF, x, y); \
674: PDF_lineto(myPDF, x-y, x+y); \
675: dummy = x; x = -y; y = dummy; \
676: PDF_lineto(myPDF, x, y); \
677: PDF_stroke(myPDF); \
678: } \
679: break; \
680: }
681:
682: /* Macros for diamonds just prepend the rotation and then call those
683: * for squares: */
684: #define DIAMOND_SINGLE_PIESLICE(x, y, quadrants) \
685: PDF_rotate(myPDF, 45); \
686: SQUARE_SINGLE_PIESLICE(x, y, quadrants);
687: #define DIAMOND_TWO_OPPOSING_QUADRANTS(x, y, angle) \
688: PDF_rotate(myPDF, 45); \
689: SQUARE_TWO_OPPOSING_QUADRANTS(x, y, angle);
690:
691: /* ... and now all the individual cases. The 'angle' arguments' are
692: * purely for the sake of easing cut'n'paste with the circle case */
693: #define SQUARE_SINGLE_QUADRANT(x, y, angle) \
694: SQUARE_SINGLE_PIESLICE(x, y, 1);
695: case 31+1:
696: SQUARE_SINGLE_QUADRANT(1, 0, 0);
697: case 31+2:
698: SQUARE_SINGLE_QUADRANT(0, 1, 90);
699: case 31+4:
700: SQUARE_SINGLE_QUADRANT(-1, 0, 180);
701: case 31+8:
702: SQUARE_SINGLE_QUADRANT(0, -1, 270);
703: #undef SQUARE_SINGLE_QUADRANT
704:
705: #define SQUARE_TWO_NEIGHBOR_QUADRANTS(x, y, angle) \
706: SQUARE_SINGLE_PIESLICE(x, y, 2)
707: case 31+3:
708: SQUARE_TWO_NEIGHBOR_QUADRANTS(1, 0, 0);
709: case 31+6:
710: SQUARE_TWO_NEIGHBOR_QUADRANTS(0, 1, 90);
711: case 31+12:
712: SQUARE_TWO_NEIGHBOR_QUADRANTS(-1, 0, 180);
713: case 31+9:
714: SQUARE_TWO_NEIGHBOR_QUADRANTS(0, -1, 270);
715: #undef SQUARE_TWO_NEIGHBOR_QUADRANTS
716:
717: case 31+5:
718: SQUARE_TWO_OPPOSING_QUADRANTS(1, 0, 0);
719: case 31+10:
720: SQUARE_TWO_OPPOSING_QUADRANTS(0, 1, 90);
721:
722: #define SQUARE_THREE_QUADRANTS(x, y, angle) \
723: SQUARE_SINGLE_PIESLICE(x, y, 3)
724: case 31+7:
725: SQUARE_THREE_QUADRANTS(1, 0, 0);
726: case 31+14:
727: SQUARE_THREE_QUADRANTS(0, 1, 90);
728: case 31+13:
729: SQUARE_THREE_QUADRANTS(-1, 0, 180);
730: case 31+11:
731: SQUARE_THREE_QUADRANTS(0, -1, 270);
732: #undef SQUARE_THREE_QUADRANTS
733:
734: #define DIAMOND_SINGLE_QUADRANT(x, y, angle) \
735: DIAMOND_SINGLE_PIESLICE(x, y, 1)
736: case 47+1:
737: DIAMOND_SINGLE_QUADRANT(1, 0, 0);
738: case 47+2:
739: DIAMOND_SINGLE_QUADRANT(0, 1, 90);
740: case 47+4:
741: DIAMOND_SINGLE_QUADRANT(-1, 0, 180);
742: case 47+8:
743: DIAMOND_SINGLE_QUADRANT(0, -1, 270);
744: #undef DIAMOND_SINGLE_QUADRANT
745:
746: #define DIAMOND_TWO_NEIGHBOR_QUADRANTS(x, y, angle) \
747: DIAMOND_SINGLE_PIESLICE(x, y, 2)
748: case 47+3:
749: DIAMOND_TWO_NEIGHBOR_QUADRANTS(1, 0, 0);
750: case 47+6:
751: DIAMOND_TWO_NEIGHBOR_QUADRANTS(0, 1, 90);
752: case 47+12:
753: DIAMOND_TWO_NEIGHBOR_QUADRANTS(-1, 0, 180);
754: case 47+9:
755: DIAMOND_TWO_NEIGHBOR_QUADRANTS(0, -1, 270);
756: #undef DIAMOND_TWO_NEIGHBOR_QUADRANTS
757:
758:
759: case 47+5:
760: DIAMOND_TWO_OPPOSING_QUADRANTS(1, 0, 0);
761: case 47+10:
762: DIAMOND_TWO_OPPOSING_QUADRANTS(0, 1, 90);
763: #undef DIAMOND_TWO_OPPOSING_QUADRANTS
764: #undef SQUARE_TWO_OPPOSING_QUADRANTS
765:
766: #define DIAMOND_THREE_QUADRANTS(x, y, angle) \
767: DIAMOND_SINGLE_PIESLICE(x, y, 3)
768: case 47+7:
769: DIAMOND_THREE_QUADRANTS(1, 0, 0);
770: case 47+14:
771: DIAMOND_THREE_QUADRANTS(0, 1, 90);
772: case 47+13:
773: DIAMOND_THREE_QUADRANTS(-1, 0, 180);
774: case 47+11:
775: DIAMOND_THREE_QUADRANTS(0, -1, 270);
776: #undef DIAMOND_THREE_QUADRANTS
777: #undef DIAMOND_SINGLE_PIESLICE
778: #undef SQUARE_SINGLE_PIESLICE
779:
780: default:
781: {
782: char temp[64];
783: sprintf(temp, "PDF: unknown point type number %d", number);
784: int_warn(temp,NO_CARET);
785: }
786: }
787: }
788:
789: PDF_restore(myPDF);
790: PDF_xLast = x;
791: PDF_yLast = y;
792: }
793:
794:
795: TERM_PUBLIC int
796: PDF_justify_text (enum JUSTIFY mode)
797: {
798: PDF_TextJust = mode;
799: return (TRUE);
800: }
801:
802:
803: TERM_PUBLIC int
804: PDF_text_angle (int ang)
805: {
806: if (ang == 0 || ang == 1) {
807: /* FIXME: need to do this in a different way? */
808: PDF_TextAngle = ang;
809: return (TRUE);
810: }
811:
812: return (FALSE);
813: }
814:
815:
816: TERM_PUBLIC void
817: PDF_put_text (unsigned int x, unsigned int y, char *str)
818: {
819: char *alignment = NULL;
820: double h = x, v = y;
821:
822: PDF_PathClose ();
823:
824: /* horizontal justification*/
825: switch (PDF_TextJust) {
826: case LEFT:
827: alignment = "left";
828: break;
829: case CENTRE:
830: alignment = "center";
831: break;
832: case RIGHT:
833: alignment = "right";
834: break;
835: }
836:
837: /* vertical justification*/
838: switch (PDF_TextAngle) {
839: case 1:
840: h += (PDF_fontAscent - PDF_fontDescent) / 2;
841: break; /* vertical text*/
842: default:
843: v -= (PDF_fontAscent - PDF_fontDescent) / 2;
844: break; /* horizontal text*/
845: }
846:
847: if (PDF_TextAngle) {
848: PDF_save(myPDF);
849: PDF_rotate(myPDF, 90);
850: PDF_show_boxed(myPDF, str, v , -h, 0, 0, alignment, NULL);
851: PDF_restore(myPDF);
852: } else {
853: PDF_show_boxed(myPDF, str, h , v, 0, 0, alignment, NULL);
854: }
855:
856: }
857:
858:
859: TERM_PUBLIC int
860: PDF_set_font (char *font)
861: {
862: if (strlen (font) > 0) { /* if available, parse the font specification ("fontname,fontsize")*/
863: short index;
864: char *token,
865: seps[] = ",", *buffer = (char *) malloc (strlen (font) + 1);
866:
867: if (buffer == NULL)
868: return (FALSE);
869: strcpy (buffer, font);
870:
871: for (token = strtok (buffer, seps), index = 1;
872: token != NULL; token = strtok (NULL, seps), index++
873: ) {
874: switch (index) {
875: case 1:
876: strcpy (PDF_fontNameCur, token);
877: break; /* font name*/
878: case 2:
879: PDF_fontSizeCur = atoi (token);
880: break; /* font size*/
881: default:
882: break;
883: }
884: }
885:
886: free (buffer);
887: } else { /* otherwise simply reset the default font*/
888: strcpy (PDF_fontNameCur, PDF_fontNameDef);
889: PDF_fontSizeCur = PDF_fontSizeDef;
890: }
891:
892:
893: PDF_PathClose();
894: PDF_SetFont();
895: return (TRUE);
896: }
897:
898: TERM_PUBLIC void
899: PDF_boxfill(int style, unsigned int x1, unsigned int y1,
900: unsigned int width, unsigned int height)
901: {
902: (void) style; /* unused */
903: PDF_PathClose();
904: PDF_save(myPDF);
905: PDF_setgray(myPDF, 1);
906: PDF_moveto(myPDF, x1, y1);
907: PDF_lineto(myPDF, x1+width, y1);
908: PDF_lineto(myPDF, x1+width, y1+height);
909: PDF_lineto(myPDF, x1, y1+height);
910: PDF_fill(myPDF);
911: PDF_restore(myPDF);
912: }
913:
914: #endif /* TERM_BODY */
915:
916: #ifdef TERM_TABLE
917: TERM_TABLE_START (pdf_driver)
918: "pdf", "PDF (Portable Document File) file driver",
919: 0 /* xmax */ , 0 /* ymax */ , 0 /* vchar */ , 0 /* hchar */ ,
920: 0 /* vtic */ , 0 /* htic */ ,
921: PDF_options, PDF_init, PDF_reset, PDF_text, null_scale, PDF_graphics,
922: PDF_move, PDF_vector, PDF_linetype, PDF_put_text, PDF_text_angle,
923: PDF_justify_text, PDF_point, do_arrow, PDF_set_font, do_pointsize,
924: TERM_BINARY,
925: 0 /* suspend */, 0 /* resume */ , PDF_boxfill, PDF_linewidth
926: TERM_TABLE_END (pdf_driver)
927: #undef LAST_TERM
928: #define LAST_TERM pdf_driver
929: #endif /* TERM_TABLE */
930:
931: #endif /* TERM_PROTO_ONLY */
932:
933: #ifdef TERM_HELP
934: START_HELP (pdf)
935: "1 pdf",
936: "?commands set terminal pdf",
937: "?set terminal pdf",
938: "?set term pdf",
939: "?terminal pdf",
940: "?term pdf",
941: "?pdf",
942: " This terminal produces files in the Adobe Portable Document Format",
943: " (PDF), useable for printing or display with tools like Acrobat Reader",
944: "",
945: " Syntax:",
946: " set terminal pdf {fname \"<font>\"} {fsize <fontsize>}",
947: "",
948: " where <font> is the name of the default font to use (default Helvetica)",
949: " and <fontsize> is the font size (in points, default 12)"
950: END_HELP (pdf)
951: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pdf.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term