Annotation of OpenXM_contrib/gnuplot/term/svg.trm, Revision 1.1
1.1 ! ohara 1: /*Hello, Emacs! this is -*-C-*- ! */
! 2: /*------------------------------------------------------------------------------------------------------------------------------------
! 3: GNUPLOT - svg.trm
! 4:
! 5: This file is included by ../term.c.
! 6:
! 7: This terminal driver supports:
! 8: W3C Scalable Vector Graphics
! 9:
! 10: AUTHOR
! 11:
! 12: Amedeo Farello
! 13: afarello@libero.it
! 14:
! 15: HEAVILY MODIFIED by
! 16:
! 17: Hans-Bernhard Br"oker
! 18: broeker@physik.rwth-aachen.de
! 19:
! 20: ------------------------------------------------------------------------------------------------------------------------------------*/
! 21: #include "driver.h"
! 22:
! 23: #ifdef TERM_REGISTER
! 24: register_term (svg)
! 25: #endif
! 26:
! 27: #ifdef TERM_PROTO
! 28: TERM_PUBLIC void SVG_options __PROTO ((void));
! 29: TERM_PUBLIC void SVG_init __PROTO ((void));
! 30: TERM_PUBLIC void SVG_graphics __PROTO ((void));
! 31: TERM_PUBLIC void SVG_text __PROTO ((void));
! 32: TERM_PUBLIC void SVG_linetype __PROTO ((int linetype));
! 33: TERM_PUBLIC void SVG_move __PROTO ((unsigned int x, unsigned int y));
! 34: TERM_PUBLIC void SVG_vector __PROTO ((unsigned int x, unsigned int y));
! 35: TERM_PUBLIC void SVG_put_text __PROTO ((unsigned int x, unsigned int y, char *str));
! 36: TERM_PUBLIC void SVG_reset __PROTO ((void));
! 37: TERM_PUBLIC int SVG_justify_text __PROTO ((enum JUSTIFY mode));
! 38: TERM_PUBLIC int SVG_text_angle __PROTO ((int ang));
! 39: TERM_PUBLIC void SVG_point __PROTO ((unsigned int x, unsigned int y, int pointstyle));
! 40: TERM_PUBLIC int SVG_set_font __PROTO ((char *font));
! 41: /* TERM_PUBLIC void SVG_pointsize __PROTO((double pointsize)); */
! 42: /* TERM_PUBLIC void SVG_fillbox __PROTO((int style, unsigned int x1, unsigned int y1, unsigned int width, unsigned int height)); */
! 43: TERM_PUBLIC void SVG_linewidth __PROTO ((double linewidth));
! 44:
! 45: #define SVG_XMAX 600
! 46: #define SVG_YMAX 480
! 47:
! 48: #endif /* TERM_PROTO */
! 49:
! 50: #ifndef TERM_PROTO_ONLY
! 51: #ifdef TERM_BODY
! 52:
! 53: struct SVG_PEN
! 54: {
! 55: double width;
! 56: char color[8];
! 57: };
! 58:
! 59: unsigned int SVG_xSize = SVG_XMAX; /* plot horizontal size */
! 60: unsigned int SVG_ySize = SVG_YMAX; /* plot vertical size*/
! 61:
! 62: unsigned int SVG_xLast = UINT_MAX; /* current pen horizontal position*/
! 63: unsigned int SVG_yLast = UINT_MAX; /* current pen vertical position*/
! 64:
! 65: int SVG_LineType = -3; /* current line type*/
! 66: double SVG_LineWidth = 1.0; /* current line width*/
! 67: int SVG_TextAngle = 0; /* current text orientation*/
! 68: enum JUSTIFY SVG_TextJust = LEFT; /* current text justification*/
! 69:
! 70: char SVG_fontNameDef[MAX_ID_LEN + 1] = "Arial"; /* default text font family*/
! 71: double SVG_fontSizeDef = 12; /* default text size*/
! 72: char SVG_fontNameCur[MAX_ID_LEN + 1] = "Arial"; /* current text font family*/
! 73: double SVG_fontSizeCur = 12; /* current text size*/
! 74: TBOOLEAN SVG_groupIsOpen = FALSE; /* open group flag*/
! 75: TBOOLEAN SVG_pathIsOpen = FALSE; /* open path flag*/
! 76: unsigned int SVG_path_count = 0; /* size of current path*/
! 77: struct SVG_PEN SVG_pens[16]; /* pen descriptors*/
! 78:
! 79: int SVG_fontAscent = 0; /* estimated current font ascent*/
! 80: int SVG_fontDescent = 0; /* estimated current font descent*/
! 81: int SVG_fontLeading = 0; /* estimated current font leading*/
! 82: int SVG_fontAvWidth = 0; /* estimated current font char average width*/
! 83:
! 84: static short SVG_Pen_RealID __PROTO ((int));
! 85: static void SVG_PathOpen __PROTO ((void));
! 86: static void SVG_PathClose __PROTO ((void));
! 87: static void SVG_PathLimit __PROTO ((void));
! 88: static void SVG_GroupOpen __PROTO ((void));
! 89: static void SVG_GroupClose __PROTO ((void));
! 90: static void SVG_SetFont __PROTO ((char *name, double size));
! 91: /*------------------------------------------------------------------------------------------------------------------------------------
! 92: SVG_Pen_RealID
! 93: ------------------------------------------------------------------------------------------------------------------------------------*/
! 94: static short
! 95: SVG_Pen_RealID (inPenCode)
! 96: int inPenCode;
! 97: {
! 98: if (inPenCode >= 13)
! 99: inPenCode %= 13; /* normalize pen code*/
! 100: if (inPenCode < -2)
! 101: inPenCode = -2;
! 102:
! 103: return (inPenCode + 2);
! 104: }
! 105:
! 106: /*------------------------------------------------------------------------------------------------------------------------------------
! 107: SVG_GroupOpen
! 108: ------------------------------------------------------------------------------------------------------------------------------------*/
! 109: static void
! 110: SVG_GroupOpen ()
! 111: {
! 112: if (!SVG_groupIsOpen) {
! 113: fprintf (gpoutfile,
! 114: "<g style=\"fill:none; stroke:%s; stroke-width:%.2f\">\n",
! 115: SVG_pens[SVG_Pen_RealID (SVG_LineType)].color,
! 116: SVG_pens[SVG_Pen_RealID (SVG_LineType)].width);
! 117:
! 118: SVG_groupIsOpen = TRUE;
! 119: }
! 120: }
! 121:
! 122: /*------------------------------------------------------------------------------------------------------------------------------------
! 123: SVG_GroupClose
! 124: ------------------------------------------------------------------------------------------------------------------------------------*/
! 125: static void
! 126: SVG_GroupClose ()
! 127: {
! 128: if (SVG_groupIsOpen)
! 129: {
! 130: fprintf (gpoutfile, "</g>\n");
! 131: SVG_groupIsOpen = FALSE;
! 132: }
! 133: }
! 134:
! 135: /*------------------------------------------------------------------------------------------------------------------------------------
! 136: SVG_PathOpen
! 137: ------------------------------------------------------------------------------------------------------------------------------------*/
! 138: static void
! 139: SVG_PathOpen ()
! 140: {
! 141: if (!SVG_pathIsOpen) {
! 142: fprintf (gpoutfile, "\t<path d=\"");
! 143: SVG_pathIsOpen = TRUE;
! 144: }
! 145: }
! 146:
! 147: /*------------------------------------------------------------------------------------------------------------------------------------
! 148: SVG_PathClose
! 149: ------------------------------------------------------------------------------------------------------------------------------------*/
! 150: static void
! 151: SVG_PathClose ()
! 152: {
! 153: if (SVG_pathIsOpen) {
! 154: fprintf (gpoutfile, "\"></path>\n");
! 155: SVG_path_count = 0;
! 156: SVG_pathIsOpen = FALSE;
! 157: }
! 158: }
! 159:
! 160: /*------------------------------------------------------------------------------------------------------------------------------------
! 161: SVG_PathLimit
! 162: ------------------------------------------------------------------------------------------------------------------------------------*/
! 163: static void
! 164: SVG_PathLimit ()
! 165: {
! 166: if (SVG_path_count >= 10) { /* avoid excessive line length*/
! 167: fprintf (gpoutfile, "\n\t\t");
! 168: SVG_path_count = 0;
! 169: }
! 170: }
! 171:
! 172: /*------------------------------------------------------------------------------------------------------------------------------------
! 173: SVG_SetFont
! 174: ------------------------------------------------------------------------------------------------------------------------------------*/
! 175: static void
! 176: SVG_SetFont (char *name, double size)
! 177: {
! 178: strcpy (SVG_fontNameCur, name);
! 179: SVG_fontSizeCur = size;
! 180:
! 181: /* since we cannot interrogate SVG about text properties and according
! 182: * to SVG 1.0 W3C Candidate Recommendation 2 August 2000 the
! 183: * "line-height" of the 'text' element is defined to be equal to the
! 184: * 'font-size' (!), we have to to define font properties in a less
! 185: * than optimal way */
! 186:
! 187: SVG_fontAscent = (int) (SVG_fontSizeCur * 1.00); /* estimated current font ascent*/
! 188: SVG_fontDescent = (int) (SVG_fontSizeCur * 0.25); /* estimated current font descent*/
! 189: SVG_fontLeading = (int) (SVG_fontSizeCur * 0.25); /* estimated current font leading*/
! 190: SVG_fontAvWidth = (int) (SVG_fontSizeCur * 0.70); /* estimated current font char average width*/
! 191: }
! 192:
! 193: /*------------------------------------------------------------------------------------------------------------------------------------
! 194: SVG_options
! 195: ------------------------------------------------------------------------------------------------------------------------------------*/
! 196: TERM_PUBLIC void
! 197: SVG_options ()
! 198: {
! 199: struct value a;
! 200:
! 201: if (!END_OF_COMMAND) { /* get terminal size*/
! 202: if (almost_equals (c_token, "s$ize")) {
! 203: c_token++;
! 204:
! 205: if (END_OF_COMMAND)
! 206: int_error("expecting x size", c_token);
! 207: SVG_xSize = (unsigned int) real (const_express (&a));
! 208: if (SVG_xSize < 2 || SVG_xSize > 8192)
! 209: int_error("x size out of range", c_token);
! 210:
! 211: if (END_OF_COMMAND)
! 212: int_error("expecting y size", c_token);
! 213: SVG_ySize = (unsigned int) real (const_express (&a));
! 214: if (SVG_ySize < 2 || SVG_ySize > 8192)
! 215: int_error("y size out of range", c_token);
! 216: }
! 217: }
! 218:
! 219: if (!END_OF_COMMAND) { /* get default font family name*/
! 220: if (almost_equals (c_token, "fn$ame")) {
! 221: c_token++;
! 222:
! 223: if (!END_OF_COMMAND && isstring (c_token)) {
! 224: quote_str (SVG_fontNameDef, c_token, MAX_ID_LEN);
! 225: c_token++;
! 226: } else
! 227: int_error("fname: expecting font name", c_token);
! 228: }
! 229: }
! 230:
! 231: if (!END_OF_COMMAND) { /* get default font size*/
! 232: if (almost_equals (c_token, "fs$ize")) {
! 233: c_token++;
! 234:
! 235: if (END_OF_COMMAND)
! 236: int_error("fsize: expecting font size", c_token);
! 237: SVG_fontSizeDef = real (const_express (&a));
! 238: }
! 239: }
! 240:
! 241: if (!END_OF_COMMAND)
! 242: int_error("unexpected text at end of command", c_token);
! 243:
! 244: /* Save options back into options string in normalized format */
! 245: sprintf(term_options, "size %d %d fname '%s' fsize %g",
! 246: SVG_xSize, SVG_ySize, SVG_fontNameDef, SVG_fontSizeDef);
! 247: }
! 248:
! 249: /*------------------------------------------------------------------------------------------------------------------------------------
! 250: SVG_init
! 251: ------------------------------------------------------------------------------------------------------------------------------------*/
! 252: TERM_PUBLIC void
! 253: SVG_init ()
! 254: {
! 255: /* setup pens*/
! 256: SVG_pens[0].width = SVG_LineWidth;
! 257: sprintf (SVG_pens[0].color, "black"); /* black*/
! 258: SVG_pens[1].width = SVG_LineWidth;
! 259: sprintf (SVG_pens[1].color, "gray"); /* medium gray*/
! 260: SVG_pens[2].width = SVG_LineWidth;
! 261: sprintf (SVG_pens[2].color, "red");
! 262: SVG_pens[3].width = SVG_LineWidth;
! 263: /* sprintf (SVG_pens[3].color, "#%2.2X%2.2X%2.2X", 0, 209, 0); */ /* green*/
! 264: sprintf (SVG_pens[3].color, "green");
! 265: SVG_pens[4].width = SVG_LineWidth;
! 266: /* sprintf (SVG_pens[4].color, "#%2.2X%2.2X%2.2X", 74, 77, 201); */ /* blue*/
! 267: sprintf (SVG_pens[4].color, "blue"); /* blue*/
! 268: SVG_pens[5].width = SVG_LineWidth;
! 269: /* sprintf (SVG_pens[5].color, "#%2.2X%2.2X%2.2X", 173, 0, 0); */ /* brick*/
! 270: sprintf (SVG_pens[5].color, "cyan");
! 271: SVG_pens[6].width = SVG_LineWidth;
! 272: sprintf (SVG_pens[6].color, "#%2.2X%2.2X%2.2X", 21, 117, 69); /* pine green*/
! 273: SVG_pens[7].width = SVG_LineWidth;
! 274: sprintf (SVG_pens[7].color, "#%2.2X%2.2X%2.2X", 0, 0, 148); /* navy*/
! 275: SVG_pens[8].width = SVG_LineWidth;
! 276: sprintf (SVG_pens[8].color, "#%2.2X%2.2X%2.2X", 255, 153, 0); /* orange*/
! 277: SVG_pens[9].width = SVG_LineWidth;
! 278: sprintf (SVG_pens[9].color, "#%2.2X%2.2X%2.2X", 0, 153, 161); /* green blue*/
! 279: SVG_pens[10].width = SVG_LineWidth;
! 280: sprintf (SVG_pens[10].color, "#%2.2X%2.2X%2.2X", 214, 214, 69); /* olive*/
! 281: SVG_pens[11].width = SVG_LineWidth;
! 282: sprintf (SVG_pens[11].color, "#%2.2X%2.2X%2.2X", 163, 145, 255); /* cornflower*/
! 283: SVG_pens[12].width = SVG_LineWidth;
! 284: sprintf (SVG_pens[12].color, "#%2.2X%2.2X%2.2X", 255, 204, 0); /* gold*/
! 285: SVG_pens[13].width = SVG_LineWidth;
! 286: sprintf (SVG_pens[13].color, "#%2.2X%2.2X%2.2X", 214, 0, 120); /* mulberry*/
! 287: SVG_pens[14].width = SVG_LineWidth;
! 288: sprintf (SVG_pens[14].color, "#%2.2X%2.2X%2.2X", 171, 214, 0); /* green yellow*/
! 289: SVG_pens[15].width = SVG_LineWidth;
! 290: sprintf (SVG_pens[15].color, "#%2.2X%2.2X%2.2X", 222, 0, 186); /* red violet*/
! 291:
! 292: SVG_LineType = -3;
! 293:
! 294: /* set xmax, ymax*/
! 295:
! 296: term->xmax = SVG_xSize;
! 297: term->ymax = SVG_ySize;
! 298:
! 299: /* set current font*/
! 300:
! 301: SVG_SetFont (SVG_fontNameDef, SVG_fontSizeDef);
! 302:
! 303: /* set h_char, v_char*/
! 304:
! 305: term->h_char = SVG_fontAvWidth;
! 306: term->v_char = (SVG_fontAscent + SVG_fontDescent + SVG_fontLeading);
! 307:
! 308: /* set h_tic, v_tic*/
! 309:
! 310: term->h_tic = term->v_char / 2;
! 311: term->v_tic = term->v_char / 2;
! 312:
! 313: /* write file header*/
! 314:
! 315: fprintf (gpoutfile,
! 316: "<?xml version=\"1.0\" standalone=\"no\"?>\n"
! 317: "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 20001102//EN\" \"svg-20001102.dtd\">\n"
! 318: "<svg width=\"%u\" height=\"%u\" viewBox=\"0 0 %u %u\">\n\n"
! 319: "<desc>Produced by GNUPLOT %s patchlevel %s</desc>\n\n",
! 320: term->xmax, term->ymax, term->xmax, term->ymax,
! 321: gnuplot_version, gnuplot_patchlevel);
! 322:
! 323: /* definitions of point symbols */
! 324: /* FIXME: SVG scales linewidth along with the marker itself, and
! 325: * there seems to be no way to avoid that without copying the
! 326: * marker definition into the file, rather than referencing a
! 327: * defined one :-( That would make for much larger files */
! 328:
! 329:
! 330: fprintf (gpoutfile,
! 331: "<defs>\n"
! 332: /* dot: */
! 333: "\t<circle id=\"gpDot\" r=\"1\"></circle>\n"
! 334: /* diamond: */
! 335: "\t<path id=\"gpPt0\" style=\"stroke-width:%.3f\" d=\"M-1,0 L0,-1 L1,0 L0 1 z\"></path>\n"
! 336: /* cross: */
! 337: "\t<path id=\"gpPt1\" style=\"stroke-width:%.3f\" d=\"M-1,0 h2 M0,-1 v2\"></path>\n"
! 338: /* square: */
! 339: "\t<path id=\"gpPt2\" style=\"stroke-width:%.3f\" d=\"M-1,-1 h2 v2 h-2 z\"></path>\n"
! 340: /* triangle: */
! 341: "\t<path id=\"gpPt3\" style=\"stroke-width:%.3f\" d=\"M0,1.33 L-1.33,-0.67 L1.33,-0.67 z\"></path>\n"
! 342: /* 6-pointed star: */
! 343: "\t<path id=\"gpPt4\" style=\"stroke-width:%.3f\" d=\"M-1,0 L1,0 M0,-1 L0,1 M-1,-1 L1,1 M-1,1 L1,-1\"></path>\n"
! 344: "</defs>\n"
! 345: , 2.0 / term->h_tic
! 346: , 2.0 / term->h_tic
! 347: , 2.0 / term->h_tic
! 348: , 2.0 / term->h_tic
! 349: , 2.0 / term->h_tic
! 350: );
! 351: }
! 352:
! 353: /*------------------------------------------------------------------------------------------------------------------------------------
! 354: SVG_graphics
! 355: ------------------------------------------------------------------------------------------------------------------------------------*/
! 356: TERM_PUBLIC void
! 357: SVG_graphics ()
! 358: {
! 359: /* fprintf (gpoutfile, "<svg>\n"); --- disabled HBB 20001116*/
! 360:
! 361: SVG_groupIsOpen = FALSE;
! 362: SVG_pathIsOpen = FALSE;
! 363:
! 364: /* reset position*/
! 365:
! 366: SVG_xLast = SVG_yLast = UINT_MAX;
! 367: }
! 368:
! 369: /*------------------------------------------------------------------------------------------------------------------------------------
! 370: SVG_text
! 371: ------------------------------------------------------------------------------------------------------------------------------------*/
! 372: TERM_PUBLIC void
! 373: SVG_text ()
! 374: {
! 375: SVG_PathClose ();
! 376: SVG_GroupClose ();
! 377:
! 378: /* fprintf (gpoutfile, "</svg>\n\n"); --- disabled HBB 20001116 */
! 379: }
! 380:
! 381: /*------------------------------------------------------------------------------------------------------------------------------------
! 382: SVG_reset
! 383: ------------------------------------------------------------------------------------------------------------------------------------*/
! 384: TERM_PUBLIC void
! 385: SVG_reset ()
! 386: {
! 387: fprintf (gpoutfile, "</svg>\n\n");
! 388: }
! 389:
! 390: /*------------------------------------------------------------------------------------------------------------------------------------
! 391: SVG_linetype
! 392: ------------------------------------------------------------------------------------------------------------------------------------*/
! 393: TERM_PUBLIC void
! 394: SVG_linetype (int linetype)
! 395: {
! 396: if (linetype != SVG_LineType) {
! 397: SVG_PathClose ();
! 398: SVG_GroupClose ();
! 399: SVG_LineType = linetype;
! 400: SVG_GroupOpen ();
! 401: }
! 402: }
! 403:
! 404: /*------------------------------------------------------------------------------------------------------------------------------------
! 405: SVG_linewidth - verificare
! 406: ------------------------------------------------------------------------------------------------------------------------------------*/
! 407: TERM_PUBLIC void
! 408: SVG_linewidth (double linewidth)
! 409: {
! 410: if (linewidth != SVG_LineWidth) {
! 411: short k;
! 412:
! 413: SVG_LineWidth = linewidth;
! 414:
! 415: for (k = 0; k < 16; k++)
! 416: SVG_pens[k].width = SVG_LineWidth;
! 417: }
! 418: }
! 419:
! 420: /*------------------------------------------------------------------------------------------------------------------------------------
! 421: SVG_move
! 422: ------------------------------------------------------------------------------------------------------------------------------------*/
! 423: TERM_PUBLIC void
! 424: SVG_move (unsigned int x, unsigned int y)
! 425: {
! 426: if (x != SVG_xLast || y != SVG_yLast) {
! 427: SVG_PathOpen ();
! 428:
! 429: fprintf (gpoutfile, "M%u,%u ", x, term->ymax - y);
! 430: SVG_path_count++;
! 431:
! 432: SVG_PathLimit ();
! 433:
! 434: SVG_xLast = x;
! 435: SVG_yLast = y;
! 436: }
! 437: }
! 438:
! 439: /*------------------------------------------------------------------------------------------------------------------------------------
! 440: SVG_vector
! 441: ------------------------------------------------------------------------------------------------------------------------------------*/
! 442: TERM_PUBLIC void
! 443: SVG_vector (unsigned int x, unsigned int y)
! 444: {
! 445: if (x != SVG_xLast || y != SVG_yLast) {
! 446: SVG_PathOpen ();
! 447:
! 448: fprintf (gpoutfile, "L%u,%u ", x, term->ymax - y);
! 449: SVG_path_count++;
! 450:
! 451: SVG_PathLimit ();
! 452:
! 453: SVG_xLast = x;
! 454: SVG_yLast = y;
! 455: }
! 456: }
! 457:
! 458: /*------------------------------------------------------------------------------------------------------------------------------------
! 459: SVG_point
! 460: ------------------------------------------------------------------------------------------------------------------------------------*/
! 461: TERM_PUBLIC void
! 462: SVG_point (unsigned int x, unsigned int y, int number)
! 463: {
! 464: SVG_PathClose ();
! 465:
! 466: if (number < 0) { /* do dot */
! 467: fprintf (gpoutfile,
! 468: "\t<use xlink:href=\"#gpDot\" x=\"%u\" y=\"%u\"></use>\n",
! 469: x, term->ymax - y);
! 470:
! 471: } else { /* draw a point symbol */
! 472: fprintf (
! 473: gpoutfile,
! 474: "\t<use xlink:href=\"#gpPt%1u\" transform=\"translate(%u,%u) scale(%.2f)\"></use>\n"
! 475: , number % 5, x, term->ymax - y
! 476: , term_pointsize * term->h_tic / 2
! 477: );
! 478: }
! 479: SVG_xLast = x;
! 480: SVG_yLast = y;
! 481: }
! 482:
! 483: /*------------------------------------------------------------------------------------------------------------------------------------
! 484: SVG_justify_text
! 485: ------------------------------------------------------------------------------------------------------------------------------------*/
! 486: TERM_PUBLIC int
! 487: SVG_justify_text (enum JUSTIFY mode)
! 488: {
! 489: SVG_TextJust = mode;
! 490: return (TRUE);
! 491: }
! 492:
! 493: /*------------------------------------------------------------------------------------------------------------------------------------
! 494: SVG_text_angle
! 495: ------------------------------------------------------------------------------------------------------------------------------------*/
! 496: TERM_PUBLIC int
! 497: SVG_text_angle (int ang)
! 498: {
! 499: if (ang == 0 || ang == 1) {
! 500: SVG_TextAngle = ang;
! 501: return (TRUE);
! 502: }
! 503:
! 504: return (FALSE);
! 505: }
! 506:
! 507: /*------------------------------------------------------------------------------------------------------------------------------------
! 508: SVG_put_text
! 509: ------------------------------------------------------------------------------------------------------------------------------------*/
! 510: TERM_PUBLIC void
! 511: SVG_put_text (unsigned int x, unsigned int y, char *str)
! 512: {
! 513: char *alignment;
! 514: int h = x, v = y;
! 515:
! 516: SVG_PathClose ();
! 517:
! 518: /* horizontal justification*/
! 519:
! 520: switch (SVG_TextJust) {
! 521: case LEFT:
! 522: alignment = "start";
! 523: break;
! 524: case CENTRE:
! 525: alignment = "middle";
! 526: break;
! 527: case RIGHT:
! 528: default: /* can't happen, just to make gcc happy */
! 529: alignment = "end";
! 530: break;
! 531: }
! 532:
! 533: /* vertical justification*/
! 534:
! 535: switch (SVG_TextAngle) {
! 536: case 1:
! 537: h += (SVG_fontAscent - SVG_fontDescent) / 2;
! 538: break; /* vertical text*/
! 539: default:
! 540: v -= (SVG_fontAscent - SVG_fontDescent) / 2;
! 541: break; /* orizontal text*/
! 542: }
! 543:
! 544: /* define text position and attributes*/
! 545:
! 546: fprintf (gpoutfile, "\t<g transform=\"translate(%d,%d)%s\" \
! 547: style=\"stroke:none; fill:%s; font-family:%s; font-size:%.2f; text-anchor:%s\">\n",
! 548: h, term->ymax - v,
! 549: SVG_TextAngle ? " rotate(-90)" : "",
! 550: SVG_pens[SVG_Pen_RealID (SVG_LineType)].color,
! 551: SVG_fontNameCur, SVG_fontSizeCur, alignment);
! 552:
! 553: /* output text*/
! 554:
! 555: fprintf (gpoutfile, "\t\t<text>%s</text>\n\t</g>\n", str);
! 556: }
! 557:
! 558: /*------------------------------------------------------------------------------------------------------------------------------------
! 559: SVG_set_font
! 560: ------------------------------------------------------------------------------------------------------------------------------------*/
! 561: TERM_PUBLIC int
! 562: SVG_set_font (char *font)
! 563: {
! 564: if (strlen (font) > 0) { /* if available, parse the font specification ("fontname,fontsize")*/
! 565: short index;
! 566: char *token,
! 567: seps[] = ",", *buffer = (char *) malloc (strlen (font) + 1);
! 568:
! 569: if (buffer == NULL)
! 570: return (FALSE);
! 571: strcpy (buffer, font);
! 572:
! 573: for (token = strtok (buffer, seps), index = 1;
! 574: token != NULL; token = strtok (NULL, seps), index++
! 575: ) {
! 576: switch (index) {
! 577: case 1:
! 578: strcpy (SVG_fontNameCur, token);
! 579: break; /* font name*/
! 580: case 2:
! 581: SVG_fontSizeCur = atoi (token);
! 582: break; /* font size*/
! 583: default:
! 584: break;
! 585: }
! 586: }
! 587:
! 588: free (buffer);
! 589: } else { /* otherwise simply reset the default font*/
! 590: strcpy (SVG_fontNameCur, SVG_fontNameDef);
! 591: SVG_fontSizeCur = SVG_fontSizeDef;
! 592: }
! 593:
! 594: return (TRUE);
! 595: }
! 596:
! 597: #endif /* TERM_BODY */
! 598:
! 599: #ifdef TERM_TABLE
! 600: TERM_TABLE_START (svg_driver)
! 601: "svg", "W3C Scalable Vector Graphics driver",
! 602: 0 /* xmax */ , 0 /* ymax */ , 0 /* vchar */ , 0 /* hchar */ ,
! 603: 0 /* vtic */ , 0 /* htic */ ,
! 604: SVG_options, SVG_init, SVG_reset, SVG_text, null_scale, SVG_graphics,
! 605: SVG_move, SVG_vector, SVG_linetype, SVG_put_text, SVG_text_angle,
! 606: SVG_justify_text, SVG_point, do_arrow, SVG_set_font, do_pointsize,
! 607: TERM_CAN_MULTIPLOT,
! 608: 0 /* suspend */, 0 /* resume */ , 0 /* fillbox */ , SVG_linewidth
! 609: TERM_TABLE_END (svg_driver)
! 610: #undef LAST_TERM
! 611: #define LAST_TERM svg_driver
! 612: #endif /* TERM_TABLE */
! 613:
! 614: #endif /* TERM_PROTO_ONLY */
! 615:
! 616: #ifdef TERM_HELP
! 617: START_HELP (svg)
! 618: "1 svg",
! 619: "?commands set terminal svg",
! 620: "?set terminal svg",
! 621: "?set term svg",
! 622: "?terminal svg",
! 623: "?term svg",
! 624: "?svg",
! 625: " This terminal produces files in the W3C Scalable Vector Graphics format.",
! 626: "",
! 627: " Syntax:",
! 628: " set terminal svg {size <x> <y>}",
! 629: " {fname \"<font>\"} {fsize <fontsize>}",
! 630: "",
! 631: " where <x> and <y> are the size of the SVG plot to generate,",
! 632: " <font> is the name of the default font to use (default Arial) and",
! 633: " <fontsize> is the font size (in points, default 12)"
! 634: END_HELP (svg)
! 635: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to svg.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term