Annotation of OpenXM_contrib/gnuplot/term/mif.trm, Revision 1.1
1.1 ! maekawa 1: /*
! 2: * $Id: $
! 3: */
! 4: /* GNUPLOT -- mif.trm */
! 5:
! 6: /*[
! 7: * Copyright 1992, 1993, 1998
! 8: *
! 9: * Permission to use, copy, and distribute this software and its
! 10: * documentation for any purpose with or without fee is hereby granted,
! 11: * provided that the above copyright notice appear in all copies and
! 12: * that both that copyright notice and this permission notice appear
! 13: * in supporting documentation.
! 14: *
! 15: * Permission to modify the software is granted, but not the right to
! 16: * distribute the complete modified source code. Modifications are to
! 17: * be distributed as patches to the released version. Permission to
! 18: * distribute binaries produced by compiling modified sources is granted,
! 19: * provided you
! 20: * 1. distribute the corresponding source modifications from the
! 21: * released version in the form of a patch file along with the binaries,
! 22: * 2. add special version identification to distinguish your version
! 23: * in addition to the base release version number,
! 24: * 3. provide your name and address as the primary contact for the
! 25: * support of your modified version, and
! 26: * 4. retain our contact information in regard to use of the base
! 27: * software.
! 28: * Permission to distribute the released version of the source code along
! 29: * with corresponding source modifications in the form of a patch file is
! 30: * granted with same provisions 2 through 4 for binary distributions.
! 31: *
! 32: * This software is provided "as is" without express or implied warranty
! 33: * to the extent permitted by applicable law.
! 34: ]*/
! 35:
! 36: /*
! 37: * This file is included by ../term.c.
! 38: *
! 39: * This terminal driver was developed for
! 40: * gnuplot for unix version 3.0 (patchlevel 1)
! 41: * gnuplot for unix version 3.2 (patchlevel 2)
! 42: *
! 43: * This terminal driver supports:
! 44: * Frame Maker MIF format version 3.00
! 45: *
! 46: * Options for this terminal driver (set terminal mif [options]):
! 47: * colour / Draw primitives with line types >= 0 in colour (sep. 2-7)
! 48: * monochrome Draw primitives in black (sep. 0)
! 49: *
! 50: * polyline / Draw lines as continous curves
! 51: * vectors Draw lines as collections of vectors
! 52: *
! 53: * help / ? Print short usage description on stderr
! 54: *
! 55: * Properties for this terminal driver:
! 56: * -Gnuplot size of worksheet: MIF_XMAX * MIF_YMAX
! 57: * -Unit in MIF output: cm
! 58: * -Plot primitives with the same pen will
! 59: * be grouped in the same MIF group.
! 60: * -Plot primitives with line types >= 0
! 61: * will as default be drawn in colour.
! 62: * -Lines are plotted as collections of
! 63: * vectors, or as continous lines (default)
! 64: * -Plot primitives in a plot will be in a
! 65: * Frame in MIF. Several plot Frames will
! 66: * be collected in one large Frame.
! 67: * -Point size of MIF output characters: MIF_PSIZE
! 68: * -Used font for MIF output characters: Times
! 69: * -Supports vertical text
! 70: * -points and dots as characters
! 71: * -character formats for TextLines
! 72: *
! 73: * AUTHORS:
! 74: * Olof Franksson, Physics IV, KTH, S-100 44 Stockholm, Sweden
! 75: *
! 76: * NEW TERMINAL FORMAT: David C. Schooley
! 77:
! 78: * COMMENTS:
! 79: * Send comments and/or suggestions to olof@fysik4.kth.se
! 80: *
! 81: * CHANGES:
! 82: * Changed to new terminal format 9/29/95 schooley@ee.gatech.edu
! 83: * Changed order of routine declarations. olof@fysik4.kth.se
! 84: * Changed mechanism for pen pattern selection. kssingvo@immd4.informatik.uni-erlangen.de
! 85: * Support for vertical text. kssingvo@immd4.informatik.uni-erlangen.de
! 86: * Fixed plot bug for "set size XS,YS", XS/YS > 1. olof@fysik4.kth.se
! 87: *
! 88: */
! 89:
! 90: #include "driver.h"
! 91:
! 92: #ifdef TERM_REGISTER
! 93: register_term(mif)
! 94: #endif
! 95:
! 96:
! 97:
! 98: #ifdef TERM_PROTO
! 99: TERM_PUBLIC void MIF_init __PROTO((void));
! 100: TERM_PUBLIC void MIF_graphics __PROTO((void));
! 101: TERM_PUBLIC void MIF_text __PROTO((void));
! 102: TERM_PUBLIC void MIF_linetype __PROTO((int linetype));
! 103: TERM_PUBLIC void MIF_move __PROTO((unsigned int x, unsigned int y));
! 104: TERM_PUBLIC void MIF_vector __PROTO((unsigned int x, unsigned int y));
! 105: TERM_PUBLIC void MIF_put_text __PROTO((unsigned int x, unsigned int y, char *str));
! 106: TERM_PUBLIC int MIF_text_angle __PROTO((int ang));
! 107: TERM_PUBLIC void MIF_reset __PROTO((void));
! 108: TERM_PUBLIC void MIF_options __PROTO((void));
! 109: TERM_PUBLIC int MIF_justify_text __PROTO((enum JUSTIFY mode));
! 110: TERM_PUBLIC void MIF_point __PROTO((unsigned int x, unsigned int y, int number));
! 111:
! 112: /** Coordinates **/
! 113: /* The cast to float is not necessary because we are dividing by a float */
! 114: /* On OSK the cast to a float is not allowed in a constant expression wich */
! 115: /* is used by the declaration and initialization of mif_line */
! 116: /* Converts gnuplot units to MIF units */
! 117: #define GNP_TO_MIF(P) ((P) / 1000.0)
! 118: /* Basic unit: 0.01 mm (15cm -> 15*10*100=15000) */
! 119: #define MIF_XMAX 15000
! 120: /* Basic unit: 0.01 mm (10cm -> 10*10*100=10000) */
! 121: #define MIF_YMAX 10000
! 122:
! 123: #define MIF_XLAST (MIF_XMAX - 1)
! 124: #define MIF_YLAST (MIF_YMAX - 1)
! 125:
! 126: static int insert_mif_line __PROTO((double fx, double fy));
! 127: static int proc_group_id __PROTO((int group_id));
! 128: static void free_mif_line __PROTO((void));
! 129: static void put_mif_line __PROTO((void));
! 130: static void MIF_set_font __PROTO((char *));
! 131: static void mif_put_point __PROTO((unsigned int x, unsigned int y, int np));
! 132:
! 133: #ifndef cfree
! 134: # define cfree free
! 135: #endif
! 136:
! 137: /* Declared in ../setshow.c */
! 138: extern char term_options[];
! 139:
! 140: /* From version.c */
! 141: extern char version[];
! 142: extern char patchlevel[];
! 143:
! 144: static struct mif_line { /* Line point structure specification */
! 145: float fpos_x; /* Line point X coordinate */
! 146: float fpos_y; /* Y coordinate */
! 147: struct mif_line *next; /* Pointer to next line point */
! 148: struct mif_line *prev; /* Pointer to previous line point */
! 149: } mif_line =
! 150: { /* Current position structure. Adjust for orign. Local for this file. */
! 151: GNP_TO_MIF(0),
! 152: GNP_TO_MIF(MIF_YLAST),
! 153: &mif_line,
! 154: &mif_line
! 155: };
! 156:
! 157: /** Characters **/
! 158: #define MIF_PSIZE 9 /* Point size of used characters */
! 159:
! 160: #define MIF_VCHAR (MIF_YMAX/31) /* Distance between rows (a guess) */
! 161: #define MIF_HCHAR (MIF_XMAX/95) /* Distance between characters (a guess) */
! 162:
! 163: /** Scale marks **/
! 164: #define MIF_VTIC (MIF_YMAX/150) /* Size of scale mark (vert) */
! 165: #define MIF_HTIC (MIF_XMAX/225) /* Size of scale mark (hor) */
! 166:
! 167: /** Drawing properties **/
! 168: static char mif_justify[64]; /* How to justify the used text */
! 169: static char mif_pen[64], mif_pen_width[64], mif_separation[64]; /* How to plot */
! 170:
! 171: #define MIF_TEXT_HOR 0
! 172: #define MIF_TEXT_VER 1
! 173: static int mif_text_ang = MIF_TEXT_HOR; /* Rotation angle of text */
! 174:
! 175: #define MIF_NPENS 16 /* Number of MIF pen types */
! 176: static int mif_pentype = 0; /* Pen type to use. Also used to create groups for graphics */
! 177: #define MIF_PEN_TO_GROUP(P) ( 1 + (P) ) /* Map pen type to group number. Must be >= 1 */
! 178:
! 179: static int mif_pattern_table[MIF_NPENS] =
! 180: { /* Table, which pattern should be used for drawing */
! 181: 0, /* border */
! 182: 1, /* not used */
! 183: 2, 3, 4, 8, 12, 13, /* other lines: functions, data, ... (5 is used for grid; 6,7 is (nearly) invisible) */
! 184: 5, /* grid */
! 185: 9, 10, 11, 12, 13, 14, 15 /* not used */
! 186: };
! 187:
! 188: /** MIF groups administration **/
! 189: #define MIF_NGROUP_ID 20
! 190: static struct mif_group_id {
! 191: int group_existance;
! 192: /* This group id should generate a MIF group */
! 193: #define MIF_GROUP_EXISTS 1
! 194: /* This group id should not generate a MIF group */
! 195: #define MIF_GROUP_NOT_EXISTS 0
! 196:
! 197: int group_id;
! 198: #define MIF_INVALID_GROUP_ID 0 /* An invalid MIF group ID */
! 199:
! 200: } mif_group_id[MIF_NGROUP_ID]; /* List of used group ID:s and corresponding MIF groups existance */
! 201:
! 202: /** Semaphores **/
! 203: static int mif_initialized = 0; /* != 0 when output is active */
! 204: static int mif_in_frame = 0; /* != 0 when inside a plot frame */
! 205: static int mif_frameno = -1; /* Current frame number */
! 206: static int mif_colour = TRUE; /* == TRUE when colour should be used */
! 207: static int mif_polyline = TRUE; /* == TRUE when lines are drawn as continous curves */
! 208:
! 209: struct mpt { /* point definition structure */
! 210: int chr; /* character for point */
! 211: float x_offset, y_offset; /* offset for vertical positioning */
! 212: char *font; /* font */
! 213: };
! 214:
! 215: char zgnuplot[] = "ZGnuplot"; /* character formats */
! 216: char zgnuplotp[] = "ZGnuplotP";
! 217: char zgnuplotd[] = "ZGnuplotD";
! 218: char *mif_font = NULL; /* actual character format */
! 219:
! 220: struct mpt mpt[POINT_TYPES + 1] =
! 221: { /* point definition data */
! 222: {'.', 0.000, 0.005, zgnuplotd, /* dot */ },
! 223:
! 224: {'G', 0.002, 0.084, zgnuplotp, /* diamond */ },
! 225: {';', 0.002, 0.084, zgnuplotp, /* plus */ },
! 226: {'n', 0.002, 0.084, zgnuplotp, /* box */ },
! 227: {'5', 0.002, 0.084, zgnuplotp, /* X */ },
! 228: {'s', 0.002, 0.062, zgnuplotp, /* triangle */ },
! 229: {'K', 0.005, 0.075, zgnuplotp, /* star */ },
! 230: };
! 231:
! 232: /* diamond is offset 0, dot is offset -1 */
! 233: struct mpt *mif_point = &(mpt[1]);
! 234:
! 235: #endif
! 236:
! 237:
! 238: #ifndef TERM_PROTO_ONLY
! 239: #ifdef TERM_BODY
! 240:
! 241:
! 242: /** Declaration of routine/s for internal use **/
! 243: static int insert_mif_line __PROTO((double fx, double fy));
! 244: static int proc_group_id __PROTO((int group_id));
! 245:
! 246: /** Routine/s **/
! 247:
! 248: /* Called when this terminal type is set in order to parse options */
! 249: TERM_PUBLIC void MIF_options()
! 250: {
! 251: if (!END_OF_COMMAND) {
! 252: /* Colour options */
! 253: if (!END_OF_COMMAND && almost_equals(c_token, "m$onochrome")) { /* Compare up to $ */
! 254: mif_colour = FALSE;
! 255: c_token++;
! 256: }
! 257: if (!END_OF_COMMAND && (almost_equals(c_token, "c$olor")
! 258: || almost_equals(c_token, "c$olour"))) { /* Compare up to $ */
! 259: mif_colour = TRUE;
! 260: c_token++;
! 261: }
! 262: /* Curve options */
! 263: if (!END_OF_COMMAND && almost_equals(c_token, "v$ectors")) { /* Compare up to $ */
! 264: mif_polyline = FALSE;
! 265: c_token++;
! 266: }
! 267: if (!END_OF_COMMAND && almost_equals(c_token, "p$olyline")) { /* Compare up to $ */
! 268: mif_polyline = TRUE;
! 269: c_token++;
! 270: }
! 271: /* Short help */
! 272: if (!END_OF_COMMAND &&
! 273: (almost_equals(c_token, "h$elp") ||
! 274: almost_equals(c_token, "?$"))) { /* Compare up to $ */
! 275: fprintf(stderr, "\
! 276: Usage: set terminal mif [options]\n\
! 277: \toptions:\n\
! 278: \t\tcolour / Draw primitives with line types >= 0 in colour (sep. 2-7)\n\
! 279: \t\tmonochrome Draw primitives in black (sep. 0)\n\n\
! 280: \t\tpolyline / Draw lines as continous curves\n\
! 281: \t\tvectors Draw lines as collections of vectors\n\n\
! 282: \t\thelp / ? Print short usage description on stderr\n");
! 283:
! 284: c_token++;
! 285: }
! 286: }
! 287: sprintf(term_options, "%s %s", (mif_colour == TRUE) ? "colour" : "monochrome",
! 288: (mif_polyline == TRUE) ? "polyline" : "vectors");
! 289: }
! 290:
! 291: /* Deallocate the used line structure elements */
! 292: static void free_mif_line()
! 293: {
! 294: struct mif_line *tline;
! 295:
! 296: while (mif_line.prev != &mif_line) {
! 297: /* Unlink */
! 298: tline = mif_line.prev;
! 299: mif_line.prev = mif_line.prev->prev;
! 300: mif_line.prev->next = &mif_line;
! 301:
! 302: /* Deallocate */
! 303: free(tline);
! 304: }
! 305:
! 306: /* Make sure that the list will be empty */
! 307: mif_line.prev = &mif_line;
! 308: mif_line.next = &mif_line;
! 309: }
! 310:
! 311: /* Draw the pending line. Change current position. */
! 312: static void put_mif_line()
! 313: {
! 314: int np, i;
! 315: struct mif_line *tline;
! 316:
! 317: /* Process if inside a Frame */
! 318: if (mif_initialized != 0 && mif_in_frame != 0) {
! 319:
! 320: /* Count the number of available points */
! 321: for (tline = mif_line.next, np = 1; tline != &mif_line; tline = tline->next, np++);
! 322:
! 323: /* Draw line (at least two points) */
! 324: if (np >= 2) {
! 325:
! 326: /* Line preamble */
! 327: fprintf(gpoutfile, "\t<PolyLine <GroupID %d> %s %s %s\n",
! 328: MIF_PEN_TO_GROUP(mif_pentype), mif_pen, mif_pen_width, mif_separation);
! 329:
! 330: /* Draw the line elements */
! 331: fprintf(gpoutfile, "\t\t<NumPoints %d> ", np);
! 332: for (i = 0, tline = &mif_line; i < np; i++, tline = tline->next) {
! 333: if (i % 4 == 0)
! 334: fputs("\n\t\t", gpoutfile);
! 335: fprintf(gpoutfile, "<Point %.3f %.3f> ",
! 336: tline->fpos_x, tline->fpos_y);
! 337: }
! 338:
! 339: /* Line post amble */
! 340: fputs("\n\t>\n", gpoutfile);
! 341:
! 342: /* Register the used group ID */
! 343: proc_group_id(MIF_PEN_TO_GROUP(mif_pentype));
! 344:
! 345: /* Avoid to redraw this. The MIF system should remember it. */
! 346: mif_pen[0] = '\0';
! 347: mif_pen_width[0] = '\0';
! 348: mif_separation[0] = '\0';
! 349:
! 350: /* Move current position to end of line */
! 351: mif_line.fpos_x = mif_line.prev->fpos_x;
! 352: mif_line.fpos_y = mif_line.prev->fpos_y;
! 353:
! 354: /* Restore the line */
! 355: free_mif_line();
! 356: }
! 357: } /* Line processed */
! 358: }
! 359:
! 360:
! 361: /* Draw a point */
! 362: static void mif_put_point(x, y, np)
! 363: unsigned int x, y;
! 364: int np;
! 365: {
! 366: /* Process if inside a Frame */
! 367: if (mif_initialized != 0 && mif_in_frame != 0) {
! 368:
! 369: /* Draw pending line */
! 370: if (mif_polyline == TRUE)
! 371: put_mif_line();
! 372:
! 373: /* Adjust current position for text-graphics alignment */
! 374: MIF_move(x, y);
! 375:
! 376: /* center text */
! 377: MIF_justify_text(CENTRE);
! 378:
! 379: /* Draw the point */
! 380: fprintf(gpoutfile, "\t<TextLine <GroupID %d>\n",
! 381: MIF_PEN_TO_GROUP(mif_pentype));
! 382:
! 383: MIF_set_font(mif_point[np].font);
! 384:
! 385: fprintf(gpoutfile, "\t\t<TLOrigin %.3f %.3f> %s <String `%c'>\n",
! 386: mif_line.fpos_x + mif_point[np].x_offset,
! 387: mif_line.fpos_y + mif_point[np].y_offset,
! 388: mif_justify,
! 389: mif_point[np].chr);
! 390: fputs("\t>\n", gpoutfile);
! 391:
! 392: /* Register the used group ID */
! 393: proc_group_id(MIF_PEN_TO_GROUP(mif_pentype));
! 394:
! 395: /* Avoid to redraw this. The MIF system should remember it. */
! 396: mif_justify[0] = '\0';
! 397:
! 398: } /* Point processed */
! 399: }
! 400:
! 401:
! 402: /*
! 403: * draw points
! 404: */
! 405: TERM_PUBLIC void MIF_point(x, y, number)
! 406: unsigned int x, y;
! 407: int number;
! 408: {
! 409: if (number < 0) { /* dot */
! 410: number = -1;
! 411: } else { /* point */
! 412: number %= POINT_TYPES;
! 413: }
! 414: mif_put_point(x, y, number);
! 415: }
! 416:
! 417:
! 418: /* Set up a MIF output file */
! 419: TERM_PUBLIC void MIF_init()
! 420: {
! 421: int i;
! 422:
! 423: /* Process if not inside a MIF file and Frame */
! 424: if (mif_initialized == 0 && mif_in_frame == 0) {
! 425: /* Tell this terminal driver that the output is initialized and no current frames are processed */
! 426: mif_initialized = 1;
! 427: mif_in_frame = 0;
! 428:
! 429: /* Reset internal position */
! 430: free_mif_line();
! 431: mif_line.fpos_x = GNP_TO_MIF(0);
! 432: mif_line.fpos_y = GNP_TO_MIF(MIF_YLAST);
! 433:
! 434: /* Reset drawing properties strings */
! 435: mif_pen[0] = '\0';
! 436: mif_pen_width[0] = '\0';
! 437: mif_separation[0] = '\0';
! 438:
! 439: MIF_justify_text(LEFT);
! 440:
! 441: /* Reset group ID generator */
! 442: for (i = 0; i < MIF_NGROUP_ID; i++) {
! 443: mif_group_id[i].group_id = MIF_INVALID_GROUP_ID;
! 444: mif_group_id[i].group_existance = MIF_GROUP_NOT_EXISTS;
! 445: }
! 446:
! 447: /* Identify ourselves */
! 448: /*bs show borders */
! 449: /* Setup a default environment to use */
! 450: fprintf(gpoutfile, "\
! 451: <MIFFile 3.00> # Generated by gnuplot version %s patchlevel %s; identifies this as a MIF file\n\
! 452: #\n\
! 453: # show borders\n\
! 454: <Document\n<DBordersOn Yes>\n>\n\
! 455: # Set a default pen pattern, pen width, unit and font for subsequent objects\n\
! 456: <Pen 0>\n\
! 457: <Fill 15>\n\
! 458: <PenWidth 0.5 pt>\n\
! 459: <Separation 0>\n\
! 460: <Units Ucm>\n\
! 461: <FontCatalog\n\
! 462: \t<Font <FTag `%s'><FFamily `Times'><FSize %d><FPlain Yes>>\n\
! 463: \t<Font <FTag `%s'><FFamily `ZapfDingbats'><FSize 7.0 pt><FPlain Yes>>\n\
! 464: \t<Font <FTag `%s'><FFamily `Symbol'><FSize 5.0 pt><FPlain Yes>>\n\
! 465: >\n\
! 466: #\n",
! 467: version, patchlevel,
! 468: zgnuplot, MIF_PSIZE,
! 469: zgnuplotp,
! 470: zgnuplotd);
! 471: } /* MIF file created */
! 472: }
! 473:
! 474: /* Finish of a MIF output file */
! 475: TERM_PUBLIC void MIF_reset()
! 476: {
! 477: /* Process if inside a MIF file and not inside a Frame */
! 478: if (mif_initialized != 0 && mif_in_frame == 0) {
! 479: /* Finish off the MIF file */
! 480: fputs("\
! 481: #\n\
! 482: # End of MIFFile\n", gpoutfile);
! 483:
! 484: /* Tell this terminal driver that the output is finished */
! 485: mif_initialized = 0;
! 486:
! 487: /* bs: reset frame number */
! 488: mif_frameno = -1;
! 489:
! 490: } /* MIF file finished */
! 491: }
! 492:
! 493: /* Start plotting a Frame (-> graphics mode) */
! 494: TERM_PUBLIC void MIF_graphics()
! 495: {
! 496: int i;
! 497:
! 498: /* Process if not inside a Frame */
! 499: if (mif_initialized != 0 && mif_in_frame == 0) {
! 500: /* Tell that this terminal driver is working with a plot frame */
! 501: mif_in_frame = 1;
! 502:
! 503: /* Update frame number */
! 504: mif_frameno++;
! 505:
! 506: /* Set current position */
! 507: free_mif_line();
! 508: mif_line.fpos_x = GNP_TO_MIF(0);
! 509: mif_line.fpos_y = GNP_TO_MIF(MIF_YLAST);
! 510:
! 511: /* Set drawing properties */
! 512: mif_pen[0] = '\0';
! 513: mif_pen_width[0] = '\0';
! 514: mif_separation[0] = '\0';
! 515:
! 516: MIF_justify_text(LEFT);
! 517:
! 518: /* Reset group ID generator */
! 519: for (i = 0; i < MIF_NGROUP_ID; i++) {
! 520: mif_group_id[i].group_id = MIF_INVALID_GROUP_ID;
! 521: mif_group_id[i].group_existance = MIF_GROUP_NOT_EXISTS;
! 522: }
! 523:
! 524: /* Frame preamble */
! 525: fprintf(gpoutfile, "\
! 526: #\n\
! 527: # Frame number %d with plot of graphics\n\
! 528: <Frame\n\
! 529: \t<Pen 15>\n\
! 530: \t<Fill 15>\n\
! 531: \t<PenWidth 0.5 pt>\n\
! 532: \t<Separation 0>\n\
! 533: \t<BRect 2.000 %.3f %.3f %.3f>\n\
! 534: \t<NSOffset 0.000>\n\
! 535: \t<BLOffset 0.000>\n",
! 536: mif_frameno,
! 537: ((float) mif_frameno) * GNP_TO_MIF(MIF_YMAX + 100),
! 538: GNP_TO_MIF(MIF_XMAX), GNP_TO_MIF(MIF_YMAX));
! 539: } /* Frame created */
! 540: }
! 541:
! 542: /* Stop plotting a Frame (-> text mode) */
! 543: TERM_PUBLIC void MIF_text()
! 544: {
! 545: int i;
! 546:
! 547: /* Process if inside a Frame */
! 548: if (mif_initialized != 0 && mif_in_frame != 0) {
! 549:
! 550: /* Draw pending line */
! 551: if (mif_polyline == TRUE)
! 552: put_mif_line();
! 553:
! 554: /* Group the used plot primitives */
! 555: fputs("\
! 556: \t#\n\
! 557: \t# Group the the objects in groups to make the chart easier to manipulate\n\
! 558: \t# after it's imported into FrameMaker.\n", gpoutfile);
! 559:
! 560: for (i = 0; i < MIF_NGROUP_ID; i++) {
! 561: if (mif_group_id[i].group_id != MIF_INVALID_GROUP_ID &&
! 562: mif_group_id[i].group_existance == MIF_GROUP_EXISTS) {
! 563: fprintf(gpoutfile, "\
! 564: \t<Group\n\
! 565: \t\t<ID %d>\n\
! 566: \t>\n", mif_group_id[i].group_id);
! 567: }
! 568: }
! 569:
! 570: /* Frame post amble */
! 571: fprintf(gpoutfile, "\
! 572: >\n\
! 573: # End of Frame number %d\n\
! 574: #\n",
! 575: mif_frameno);
! 576:
! 577: /* Tell that this terminal driver is not working with a plot frame */
! 578: mif_in_frame = 0;
! 579: } /* Frame finshed */
! 580: }
! 581:
! 582: /* Select type of line in grapics */
! 583: /* NOTE: actually written to output the first time a primitive
! 584: * is drawn AFTER this call */
! 585: TERM_PUBLIC void MIF_linetype(linetype)
! 586: /* -2=border, -1=X/Y-axis, 0-13=lines, and 14-=mapped back */
! 587: int linetype;
! 588: {
! 589: /* Process if inside a Frame */
! 590: if (mif_initialized != 0 && mif_in_frame != 0) {
! 591:
! 592: /* Draw pending line */
! 593: if (mif_polyline == TRUE)
! 594: put_mif_line();
! 595:
! 596: /* Translate gnuplot pen types to MIF pen types */
! 597: if (linetype < 0) { /* Special lines */
! 598: if (linetype == -1) {
! 599: mif_pentype = 8 + MIF_NPENS; /* -1 */
! 600: if (mif_colour == TRUE)
! 601: sprintf(mif_separation, " <Separation 0> ");
! 602: } else {
! 603: mif_pentype = 0 + MIF_NPENS; /* -2 or less */
! 604: if (mif_colour == TRUE)
! 605: sprintf(mif_separation, " <Separation 0> ");
! 606: }
! 607: sprintf(mif_pen_width, " <PenWidth 1.0 pt> ");
! 608: } else { /* Normal lines */
! 609: mif_pentype = (linetype) % MIF_NPENS; /* 0-(MIF_NPENS-1) */
! 610: sprintf(mif_pen_width, " <PenWidth 0.1 pt> ");
! 611: if (mif_colour == TRUE)
! 612: sprintf(mif_separation, " <Separation %d> ", 2 + (mif_pentype % 6)); /* 2-7 */
! 613: }
! 614:
! 615: /* Set pen type */
! 616: sprintf(mif_pen, " <Pen %d> ", mif_pattern_table[mif_pentype % MIF_NPENS]);
! 617:
! 618: } /* Primitive processed */
! 619: }
! 620:
! 621: /* Draw the text horisontally or vertically (90 degrees counterclockwise) */
! 622: TERM_PUBLIC int MIF_text_angle(ang)
! 623: int ang;
! 624: {
! 625: if (ang != 0)
! 626: mif_text_ang = MIF_TEXT_VER;
! 627: else
! 628: mif_text_ang = MIF_TEXT_HOR;
! 629:
! 630: return (TRUE);
! 631: }
! 632:
! 633: /* Justify following text lines (MIF_put_text()) relative to the insertion point */
! 634: TERM_PUBLIC int MIF_justify_text(mode)
! 635: /* NOTE: actually written to output in text primitives which are
! 636: * drawn AFTER this call */
! 637: enum JUSTIFY mode;
! 638: {
! 639: int rval = TRUE;
! 640:
! 641: /* Process if inside a Frame */
! 642: if (mif_initialized != 0 && mif_in_frame != 0) {
! 643: switch (mode) {
! 644: case LEFT:
! 645: sprintf(mif_justify, " <TLAlignment Left> ");
! 646: break;
! 647: case CENTRE:
! 648: sprintf(mif_justify, " <TLAlignment Center> ");
! 649: break;
! 650: case RIGHT:
! 651: sprintf(mif_justify, " <TLAlignment Right> ");
! 652: break;
! 653: default:
! 654: rval = FALSE;
! 655: break;
! 656: }
! 657:
! 658: }
! 659: /* Primitive processed */
! 660: else {
! 661: rval = FALSE;
! 662: }
! 663:
! 664: return (rval);
! 665: }
! 666:
! 667: /* Draw a vector from current position to (x, y) and change current position. */
! 668: /* NOTE: actually written to output the first time another primitive
! 669: * is called AFTER this call */
! 670: TERM_PUBLIC void MIF_vector(x, y)
! 671: unsigned int x, y;
! 672: {
! 673: /* Process if inside a Frame */
! 674: if (mif_initialized != 0 && mif_in_frame != 0) {
! 675:
! 676: /* Setup the vector as a part of the line */
! 677: insert_mif_line(GNP_TO_MIF(x), GNP_TO_MIF(MIF_YLAST - (int) y));
! 678:
! 679: /* Draw pending line -> vector */
! 680: if (mif_polyline == FALSE)
! 681: put_mif_line();
! 682:
! 683: } /* Vector processed */
! 684: }
! 685:
! 686: /* Move current position */
! 687: TERM_PUBLIC void MIF_move(x, y)
! 688: unsigned int x, y;
! 689: {
! 690: /* Process if inside a Frame */
! 691: if (mif_initialized != 0 && mif_in_frame != 0) {
! 692:
! 693: /* Draw pending line */
! 694: if (mif_polyline == TRUE)
! 695: put_mif_line();
! 696:
! 697: mif_line.fpos_x = GNP_TO_MIF(x);
! 698: mif_line.fpos_y = GNP_TO_MIF(MIF_YLAST - (int) y);
! 699: }
! 700: }
! 701:
! 702:
! 703: /* set font */
! 704: static void MIF_set_font(font)
! 705: char *font;
! 706: {
! 707: if (font != mif_font) {
! 708: fprintf(gpoutfile, "\t\t<Font\n\t\t\t<FTag `%s'>\n\t\t>\n", font);
! 709: mif_font = font;
! 710: }
! 711: }
! 712:
! 713:
! 714: /* Draw the text string str at (x, y). Adjust according to MIF_justify_text().
! 715: * Change current position. */
! 716: TERM_PUBLIC void MIF_put_text(x, y, str)
! 717: unsigned int x, y;
! 718: char str[];
! 719: {
! 720: /* Process if inside a Frame */
! 721: if (mif_initialized != 0 && mif_in_frame != 0) {
! 722:
! 723: /* Draw pending line */
! 724: if (mif_polyline == TRUE)
! 725: put_mif_line();
! 726:
! 727: /* Adjust current position for text-graphics alignment */
! 728: MIF_move(x, y - MIF_VCHAR / 5);
! 729:
! 730: if (strlen(str) > 0) {
! 731:
! 732: /* Draw the text */
! 733: fprintf(gpoutfile, "\t<TextLine <GroupID %d> %s %s %s\n",
! 734: MIF_PEN_TO_GROUP(mif_pentype), mif_pen,
! 735: mif_pen_width, mif_separation);
! 736:
! 737: MIF_set_font(zgnuplot);
! 738:
! 739: fprintf(gpoutfile, "\
! 740: \t\t<TLOrigin %.3f %.3f> %s %s <String `%s'>\n\
! 741: \t>\n",
! 742: mif_line.fpos_x, mif_line.fpos_y, mif_justify,
! 743: (mif_text_ang == MIF_TEXT_VER) ? "<Angle 90>" : "",
! 744: str);
! 745:
! 746: /* Register the used group ID */
! 747: proc_group_id(MIF_PEN_TO_GROUP(mif_pentype));
! 748:
! 749: /* Avoid to redraw this. The MIF system should remember it. */
! 750: mif_pen[0] = '\0';
! 751: mif_pen_width[0] = '\0';
! 752: mif_separation[0] = '\0';
! 753:
! 754: mif_justify[0] = '\0'; /* Independent of linetype */
! 755: }
! 756: } /* Text processed */
! 757: }
! 758:
! 759:
! 760: /* Insert one point in the line */
! 761: static int insert_mif_line(fx, fy)
! 762: double fx, fy;
! 763: {
! 764: int rval = TRUE;
! 765:
! 766: if ((mif_line.prev->next = (struct mif_line *) gp_alloc(sizeof(struct mif_line),
! 767: "MIF driver")) != (struct mif_line *) NULL) {
! 768: /* Link */
! 769: mif_line.prev->next->next = &mif_line;
! 770: mif_line.prev->next->prev = mif_line.prev;
! 771: mif_line.prev = mif_line.prev->next;
! 772:
! 773: /* Fill */
! 774: mif_line.prev->fpos_x = fx;
! 775: mif_line.prev->fpos_y = fy;
! 776:
! 777: rval = TRUE;
! 778: } else { /* Failed to allocate */
! 779: /* Relink */
! 780: mif_line.prev->next = &mif_line;
! 781:
! 782: rval = FALSE;
! 783: }
! 784:
! 785: return (rval);
! 786: }
! 787:
! 788: /* Register group ID. Update group ID existance. */
! 789: /* Returns: 1 group_id belongs to a MIF group
! 790: 0 group_id does not belong to a MIF group
! 791: -1 not inside a Frame
! 792: -2 group ID list is full
! 793: */
! 794: static int proc_group_id(group_id)
! 795: int group_id;
! 796: {
! 797: int i, rval = 0;
! 798:
! 799: /* Process if inside a Frame */
! 800: if (mif_initialized != 0 && mif_in_frame != 0) {
! 801:
! 802: /* Find out the group ID, or a free group ID slot index. */
! 803: for (i = 0; i < MIF_NGROUP_ID &&
! 804: mif_group_id[i].group_id != MIF_INVALID_GROUP_ID &&
! 805: mif_group_id[i].group_id != group_id;
! 806: i++) {
! 807: /* Don't check the group_existance variable */
! 808: }
! 809:
! 810: if (i < MIF_NGROUP_ID) {
! 811: if (mif_group_id[i].group_id == MIF_INVALID_GROUP_ID) {
! 812: /* Register as new group ID for eventual use as MIF group */
! 813: mif_group_id[i].group_id = group_id;
! 814: mif_group_id[i].group_existance = MIF_GROUP_NOT_EXISTS;
! 815: } else {
! 816: /* If second use of this group ID -> create a new MIF group */
! 817: if (mif_group_id[i].group_id == group_id) {
! 818: mif_group_id[i].group_existance = MIF_GROUP_EXISTS;
! 819: /* NOTE: a group MUST have at least two members. */
! 820: rval = 1;
! 821: }
! 822: }
! 823: } else {
! 824: rval = -2; /* No place for this group ID in the list */
! 825: }
! 826:
! 827: }
! 828: /* Group ID processed */
! 829: else {
! 830: rval = -1; /* Not inside a Frame */
! 831: }
! 832:
! 833: /* Return MIF group status */
! 834: return (rval);
! 835: }
! 836:
! 837:
! 838: #endif
! 839:
! 840:
! 841: #ifdef TERM_TABLE
! 842:
! 843: TERM_TABLE_START(mif_driver)
! 844: "mif", "Frame maker MIF 3.00 format",
! 845: MIF_XMAX, MIF_YMAX, MIF_VCHAR, MIF_HCHAR,
! 846: MIF_VTIC, MIF_HTIC, MIF_options, MIF_init, MIF_reset,
! 847: MIF_text, null_scale, MIF_graphics, MIF_move, MIF_vector,
! 848: MIF_linetype, MIF_put_text, MIF_text_angle,
! 849: MIF_justify_text, MIF_point, do_arrow, set_font_null
! 850: TERM_TABLE_END(mif_driver)
! 851:
! 852: #undef LAST_TERM
! 853: #define LAST_TERM mif_driver
! 854:
! 855: #endif
! 856: #endif /* TERM_PROTO_ONLY */
! 857:
! 858: #ifdef TERM_HELP
! 859: START_HELP(mif)
! 860: "1 mif",
! 861: "?commands set terminal mif",
! 862: "?set terminal mif",
! 863: "?set term mif",
! 864: "?terminal mif",
! 865: "?term mif",
! 866: "?mif",
! 867: " The `mif` terminal driver produces Frame Maker MIF format version 3.00. It",
! 868: " plots in MIF Frames with the size 15*10 cm, and plot primitives with the same",
! 869: " pen will be grouped in the same MIF group. Plot primitives in a `gnuplot`",
! 870: " page will be plotted in a MIF Frame, and several MIF Frames are collected in",
! 871: " one large MIF Frame. The MIF font used for text is \"Times\".",
! 872: "",
! 873: " Several options may be set in the MIF 3.00 driver.",
! 874: "",
! 875: " Syntax:",
! 876: " set terminal mif {colour | monochrome} {polyline | vectors}",
! 877: " {help | ?}",
! 878: "",
! 879: " `colour` plots lines with line types >= 0 in colour (MIF sep. 2--7) and",
! 880: " `monochrome` plots all line types in black (MIF sep. 0).",
! 881: " `polyline` plots curves as continuous curves and `vectors` plots curves as",
! 882: " collections of vectors.",
! 883: " `help` and `?` print online help on standard error output---both print a",
! 884: " short description of the usage; `help` also lists the options;",
! 885: "",
! 886: " Examples:",
! 887: " set term mif colour polylines # defaults",
! 888: " set term mif # defaults",
! 889: " set term mif vectors",
! 890: " set term mif help"
! 891: END_HELP(mif)
! 892: #endif /* TERM_HELP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mif.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term