PLplot: plsym.c Source File

00001 /* $Id: plsym.c 9856 2009-04-26 20:01:32Z hbabcock $
00002 
00003     Point, symbol, and string plotting routines.
00004     Also font management code.  See the description of plLibOpen() for
00005     the search path used in finding the font files.
00006 
00007    Copyright (C) 1992  Geoffrey Furnish 
00008    Copyright (C) 1993, 1994, 1995, 2000, 2001, 2002  Maurice LeBrun
00009    Copyright (C) 2000, 2002, 2004, 2005  Alan W. Irwin
00010    Copyright (C) 2001, 2003, 2004  Rafael Laboissiere
00011    Copyright (C) 2002  Vincent Darley
00012    Copyright (C) 2004  Andrew Ross
00013    Copyright (C) 2007  Hazen Babcock
00014 
00015    This file is part of PLplot.
00016 
00017    PLplot is free software; you can redistribute it and/or modify
00018    it under the terms of the GNU General Library Public License as published
00019    by the Free Software Foundation; either version 2 of the License, or
00020    (at your option) any later version.
00021 
00022    PLplot is distributed in the hope that it will be useful,
00023    but WITHOUT ANY WARRANTY; without even the implied warranty of
00024    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00025    GNU Library General Public License for more details.
00026 
00027    You should have received a copy of the GNU Library General Public License
00028    along with PLplot; if not, write to the Free Software
00029    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00030 */
00031 
00032 #ifndef __PLSYM_H__
00033 #define __PLSYM_H__
00034 
00035 #include "plplotP.h"
00036 #include <float.h>
00037 #include <ctype.h>
00038 #include "plhershey-unicode.h"
00039 
00040 /* Declarations */
00041 
00042 static short int *fntlkup;
00043 static short int *fntindx;
00044 static signed char *fntbffr;
00045 static short int numberfonts, numberchars;
00046 static short int indxleng;
00047 
00048 static short fontloaded = 0;
00049 /* moved to plstr.h, plsc->cfont  static PLINT font = 1;  current font */
00050 
00051 #define PLMAXSTR    300
00052 #define STLEN       250
00053 
00054 static const char font_types[] = "nris";
00055 
00056 static short symbol_buffer[PLMAXSTR];
00057 static signed char xygrid[STLEN];
00058 
00059 int hershey2unicode ( int in );
00060 
00061 /* Static function prototypes */
00062 
00063 static void
00064 pldeco(short int **sym, PLINT *length, const char *text);
00065 
00066 static void
00067 plchar(signed char *xygrid, PLFLT *xform, PLINT base, PLINT oline, PLINT uline,
00068        PLINT refx, PLINT refy, PLFLT scale, PLFLT xpmm, PLFLT ypmm,
00069        PLFLT *p_xorg, PLFLT *p_yorg, PLFLT *p_width);
00070 
00071 static PLINT
00072 plcvec(PLINT ch, signed char **xygr);
00073 
00074 static void
00075 plhrsh(PLINT ch, PLINT x, PLINT y);
00076 
00077 static void
00078 plhrsh2(PLINT ch, PLINT x, PLINT y);
00079 
00080 /*--------------------------------------------------------------------------*\
00081  * void plsym()
00082  *
00083  * Plots array y against x for n points using Hershey symbol "code".
00084 \*--------------------------------------------------------------------------*/
00085 
00086 void
00087 c_plsym(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
00088 {
00089     PLINT i;
00090 
00091     if (plsc->level < 3) {
00092     plabort("plsym: Please set up window first");
00093     return;
00094     }
00095     if (code < 0) {
00096     plabort("plsym: Invalid code");
00097     return;
00098     }
00099 
00100     for (i = 0; i < n; i++)
00101       {
00102         plhrsh(code, plP_wcpcx(x[i]), plP_wcpcy(y[i]));
00103       }
00104 }
00105 
00106 /*--------------------------------------------------------------------------*\
00107  * void plpoin()
00108  *
00109  * Plots array y against x for n points using ASCII code "code".
00110  *
00111  * code=-1 means try to just draw a point.  Right now it's just a move and
00112  * a draw at the same place.  Not ideal, since a sufficiently intelligent
00113  * output device may optimize it away, or there may be faster ways of
00114  * doing it.  This is OK for now, though, and offers a 4X speedup over
00115  * drawing a Hershey font "point" (which is actually diamond shaped and
00116  * therefore takes 4 strokes to draw).
00117 \*--------------------------------------------------------------------------*/
00118 
00119 void
00120 c_plpoin(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
00121 {
00122     PLINT i, sym, ifont = plsc->cfont;
00123 
00124     if (plsc->level < 3) {
00125     plabort("plpoin: Please set up window first");
00126     return;
00127     }
00128     if (code < -1 || code > 127) {
00129     plabort("plpoin: Invalid code");
00130     return;
00131     }
00132 
00133     if (code == -1) {
00134     for (i = 0; i < n; i++)
00135         pljoin(x[i], y[i], x[i], y[i]);
00136     }
00137     else {
00138         if (ifont > numberfonts)
00139         ifont = 1;
00140     sym = *(fntlkup + (ifont - 1) * numberchars + code);
00141 
00142     for (i = 0; i < n; i++)
00143         plhrsh(sym, plP_wcpcx(x[i]), plP_wcpcy(y[i]));
00144     }
00145 }
00146 
00147 /*--------------------------------------------------------------------------*\
00148  * void plpoin3(n, x, y, z, code)
00149  *
00150  * Draws a series of points in 3 space.  Setup similar to plline3().
00151 \*--------------------------------------------------------------------------*/
00152 
00153 void
00154 c_plpoin3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code)
00155 {
00156     PLINT i, sym, ifont = plsc->cfont;
00157     PLFLT u, v;
00158     PLFLT xmin, xmax, ymin, ymax, zmin, zmax, zscale;
00159 
00160     if (plsc->level < 3) {
00161     plabort("plpoin3: Please set up window first");
00162     return;
00163     }
00164     if (code < -1 || code > 127) {
00165     plabort("plpoin3: Invalid code");
00166     return;
00167     }
00168 
00169     plP_gdom(&xmin, &xmax, &ymin, &ymax);
00170     plP_grange(&zscale, &zmin, &zmax);
00171 
00172     if (code == -1) {
00173     for (i = 0; i < n; i++) {
00174       if(x[i] >= xmin && x[i] <= xmax &&
00175          y[i] >= ymin && y[i] <= ymax &&
00176          z[i] >= zmin && z[i] <= zmax) {
00177         u = plP_wcpcx(plP_w3wcx( x[i], y[i], z[i] ));
00178         v = plP_wcpcy(plP_w3wcy( x[i], y[i], z[i] ));
00179         plP_movphy((PLINT)u,(PLINT)v);
00180         plP_draphy((PLINT)u,(PLINT)v);
00181       }
00182     }
00183     }
00184     else {
00185         if (ifont > numberfonts)
00186         ifont = 1;
00187     sym = *(fntlkup + (ifont - 1) * numberchars + code);
00188 
00189     for( i=0; i < n; i++ ) {
00190       if(x[i] >= xmin && x[i] <= xmax &&
00191          y[i] >= ymin && y[i] <= ymax &&
00192          z[i] >= zmin && z[i] <= zmax) {
00193         u = plP_wcpcx(plP_w3wcx( x[i], y[i], z[i] ));
00194         v = plP_wcpcy(plP_w3wcy( x[i], y[i], z[i] ));
00195         plhrsh(sym, (PLINT)u, (PLINT)v);
00196       }
00197     }
00198     }
00199     return;
00200 }
00201 
00202 /*--------------------------------------------------------------------------*\
00203  * static void plhrsh(PLINT ch, PLINT x, PLINT y)
00204  *    PLINT ch - hershey code to plot
00205  *    PLINT x - device-world x coordinate of hershey character
00206  *    PLINT y - device-world y coordinate of hershey character
00207  *
00208  *  Writes the Hershey symbol "ch" centred at the physical coordinate (x,y).
00209  *  This function is now just a "spoof" front end to the old plhersh,
00210  *  which has now been renamed to plhrsh2(). All this function does is
00211  *  decide whether or not we should render natively as unicode, and then
00212  *  convert between hershey and unicode.
00213  *
00214  *  If the function KNOWS there isn't a unicode equivalent, then it will
00215  *  try to render it as a hershey font. Understandably, this might make
00216  *  testing out the unicode functions a little tricky, so if you want
00217  *  to disable this behaviour, recompile with TEST_FOR_MISSING_GLYPHS
00218  *  defined.
00219 \*--------------------------------------------------------------------------*/
00220 
00221 static void
00222 plhrsh(PLINT ch, PLINT x, PLINT y)
00223 {
00224 EscText args;
00225 int idx;
00226 PLUNICODE unicode_char;
00227 
00228   /* Check to see if the device understands unicode and wants to draw
00229    * symbols.
00230    */
00231   if ((plsc->dev_text)&&(plsc->dev_unicode)&&(!plsc->dev_hrshsym))
00232     {
00233       idx=plhershey2unicode(ch); /* Get the index in the lookup table */
00234       unicode_char=hershey_to_unicode_lookup_table[idx].Unicode;
00235 
00236     /*
00237      *  Test to see if there is a defined unicode glyph for this hershey code;
00238      *  if there isn't, then we pass the glyph to plhersh, and have it
00239      *  rendered the old fashioned way.
00240      *  Otherwise, we let the driver render it as unicode
00241      */
00242 
00243       if ((unicode_char==0)||(idx==-1))
00244         {
00245 #ifndef TEST_FOR_MISSING_GLYPHS
00246           plhrsh2(ch, x, y);
00247 #endif
00248         }
00249       else
00250         {
00251       PLUNICODE  plhrsh_unicode_buffer[3], fci;
00252       PLFLT xform[] = {1.0, 0.0, 0.0, 1.0};
00253       char esc;
00254           args.unicode_char=unicode_char;
00255           args.font_face=hershey_to_unicode_lookup_table[idx].Font;
00256           /* Comment out to fix problem with ps, psttf drivers */
00257           /*args.base = 1;*/
00258           args.base = 0;
00259           args.just = .5;
00260           args.xform = 0;
00261           args.x = x;
00262           args.y = y;
00263       args.string=NULL;  /* Since we are using unicode, we want this to be NULL */
00264       /* "array method" */
00265       plgesc(&esc);
00266       args.xform = xform;
00267       args.unicode_array_len=2;
00268       /* Temporary Symbol font for every character. */
00269       plgfci(&fci);
00270       plP_hex2fci(PL_FCI_SYMBOL, PL_FCI_FAMILY, &fci);
00271       plhrsh_unicode_buffer[0] = fci;
00272       plhrsh_unicode_buffer[1] = unicode_char;
00273       /* watch out for escape character and unescape it by appending
00274        * one extra. */
00275       if (unicode_char == esc) {
00276          args.unicode_array_len=3;
00277          plhrsh_unicode_buffer[2] = unicode_char;
00278       }
00279 
00280       /* No need to change font back since only one character. */
00281       args.unicode_array=&plhrsh_unicode_buffer[0];   /* Get address of the unicode buffer (even though it is currently static) */
00282 
00283           plsc->original_chrht=plsc->chrht;
00284           plsc->original_chrdef=plsc->chrdef;
00285           plsc->chrht=plsc->symht;
00286           plsc->chrdef=plsc->symdef;
00287 
00288       if (plsc->alt_unicode){
00289         args.n_fci = fci;
00290         args.n_char = unicode_char;
00291         plP_esc(PLESC_BEGIN_TEXT, &args);
00292         plP_esc(PLESC_TEXT_CHAR, &args);
00293         plP_esc(PLESC_END_TEXT, &args);
00294       } else {
00295         plP_esc(PLESC_HAS_TEXT, &args);
00296       }
00297 
00298           plsc->chrht=plsc->original_chrht;
00299           plsc->chrdef=plsc->original_chrdef;
00300         }
00301 
00302     }
00303   else
00304     {
00305        plhrsh2(ch, x, y);
00306     }
00307 }
00308 
00309 /*--------------------------------------------------------------------------*\
00310  * void plhrsh2()
00311  *
00312  * Writes the Hershey symbol "ch" centred at the physical coordinate (x,y).
00313 \*--------------------------------------------------------------------------*/
00314 
00315 static void
00316 plhrsh2(PLINT ch, PLINT x, PLINT y)
00317 {
00318     PLINT cx, cy, k, penup, style;
00319     signed char *vxygrid = 0;
00320     PLFLT scale, xscale, yscale;
00321     PLINT llx[STLEN], lly[STLEN], l = 0;
00322 
00323     penup = 1;
00324     scale = 0.05 * plsc->symht;
00325 
00326     if ( ! plcvec(ch, &vxygrid)) {
00327     plP_movphy(x, y);
00328     return;
00329     }
00330 
00331 /* Line style must be continuous */
00332 
00333     style = plsc->nms;
00334     plsc->nms = 0;
00335 
00336 /* Compute how many physical pixels correspond to a character pixel */
00337 
00338     xscale = scale * plsc->xpmm;
00339     yscale = scale * plsc->ypmm;
00340 
00341     k = 4;
00342     for (;;) {
00343     cx = vxygrid[k++];
00344     cy = vxygrid[k++];
00345     if (cx == 64 && cy == 64) {
00346       if (l) {
00347         plP_draphy_poly(llx, lly, l);
00348         l = 0;
00349       }
00350       plP_movphy(x, y);
00351       plsc->nms = style;
00352       return;
00353     }
00354     else if (cx == 64 && cy == 0)
00355         penup = 1;
00356     else {
00357         if (penup == 1) {
00358              if (l) {
00359            plP_draphy_poly(llx, lly, l);
00360            l = 0;
00361          }
00362              llx[l] = ROUND(x+ xscale * cx);
00363          lly[l++] = ROUND(y + yscale * cy);
00364              plP_movphy(llx[l-1], lly[l-1]);
00365          penup = 0;
00366         }
00367         else {
00368           llx[l] = ROUND(x+ xscale * cx);
00369           lly[l++] = ROUND(y + yscale * cy);
00370         }
00371     }
00372     }
00373 }
00374 
00375 /*--------------------------------------------------------------------------*\
00376  * void pllab()
00377  *
00378  * Simple routine for labelling graphs.
00379 \*--------------------------------------------------------------------------*/
00380 
00381 void
00382 c_pllab(const char *xlabel, const char *ylabel, const char *tlabel)
00383 {
00384     if (plsc->level < 2) {
00385     plabort("pllab: Please set up viewport first");
00386     return;
00387     }
00388 
00389     plmtex("t", (PLFLT) 2.0, (PLFLT) 0.5, (PLFLT) 0.5, tlabel);
00390     plmtex("b", (PLFLT) 3.2, (PLFLT) 0.5, (PLFLT) 0.5, xlabel);
00391     plmtex("l", (PLFLT) 5.0, (PLFLT) 0.5, (PLFLT) 0.5, ylabel);
00392 }
00393 
00394 /*--------------------------------------------------------------------------*\
00395  * void plmtex()
00396  *
00397  * Prints out "text" at specified position relative to viewport
00398  * (may be inside or outside)
00399  *
00400  * side String which is one of the following:
00401  *  B or b  :  Bottom of viewport
00402  *  T or t  :  Top of viewport
00403  *  BV or bv : Bottom of viewport, vertical text
00404  *  TV or tv : Top of viewport, vertical text
00405  *  L or l  :  Left of viewport
00406  *  R or r  :  Right of viewport
00407  *  LV or lv : Left of viewport, vertical text
00408  *  RV or rv : Right of viewport, vertical text
00409  *
00410  * disp Displacement from specified edge of viewport, measured outwards from
00411  *  the viewport in units of the current character height. The
00412  *  centerlines of the characters are aligned with the specified
00413  *  position.
00414  *
00415  * pos  Position of the reference point of the string relative to the
00416  *  viewport edge, ranging from 0.0 (left-hand edge) to 1.0 (right-hand
00417  *  edge)
00418  *
00419  * just Justification of string relative to reference point
00420  *  just = 0.0 => left hand edge of string is at reference
00421  *  just = 1.0 => right hand edge of string is at reference
00422  *  just = 0.5 => center of string is at reference
00423 \*--------------------------------------------------------------------------*/
00424 
00425 void
00426 c_plmtex(const char *side, PLFLT disp, PLFLT pos, PLFLT just,
00427      const char *text)
00428 {
00429     PLINT clpxmi, clpxma, clpymi, clpyma;
00430     PLINT vert, refx, refy, x, y;
00431     PLFLT xdv, ydv, xmm, ymm, refxmm, refymm, shift, xform[4];
00432     PLFLT chrdef, chrht;
00433     PLFLT dispx, dispy;
00434 
00435     if (plsc->level < 2) {
00436     plabort("plmtex: Please set up viewport first");
00437     return;
00438     }
00439 
00440 /* Open clip limits to subpage limits */
00441 
00442     plP_gclp(&clpxmi, &clpxma, &clpymi, &clpyma); /* get and store current clip limits */
00443     plP_sclp(plsc->sppxmi, plsc->sppxma, plsc->sppymi, plsc->sppyma);
00444 
00445     if (plP_stindex(side, "BV") != -1 || plP_stindex(side, "bv") != -1) {
00446     vert = 1;
00447     xdv  = plsc->vpdxmi + (plsc->vpdxma - plsc->vpdxmi) * pos;
00448     ydv  = plsc->vpdymi;
00449     dispx = 0;
00450     dispy = -disp;
00451     }
00452     else if (plP_stindex(side, "TV") != -1 || plP_stindex(side, "tv") != -1) {
00453     vert = 1;
00454     xdv  = plsc->vpdxmi + (plsc->vpdxma - plsc->vpdxmi) * pos;
00455     ydv  = plsc->vpdyma;
00456     dispx = 0;
00457     dispy = disp;
00458     }
00459     else if (plP_stsearch(side, 'b')) {
00460     vert = 0;
00461     xdv = plsc->vpdxmi + (plsc->vpdxma - plsc->vpdxmi) * pos;
00462     ydv = plsc->vpdymi;
00463     dispx = 0;
00464     dispy = -disp;
00465 
00466     } else if (plP_stsearch(side, 't')) {
00467     vert = 0;
00468     xdv = plsc->vpdxmi + (plsc->vpdxma - plsc->vpdxmi) * pos;
00469     ydv = plsc->vpdyma;
00470     dispx = 0;
00471     dispy = disp;
00472 
00473     } else if (plP_stindex(side, "LV") != -1 || plP_stindex(side, "lv") != -1) {
00474     vert = 0;
00475     xdv = plsc->vpdxmi;
00476     ydv = plsc->vpdymi + (plsc->vpdyma - plsc->vpdymi) * pos;
00477     dispx = -disp;
00478     dispy = 0;
00479 
00480     } else if (plP_stindex(side, "RV") != -1 || plP_stindex(side, "rv") != -1) {
00481     vert = 0;
00482     xdv = plsc->vpdxma;
00483     ydv = plsc->vpdymi + (plsc->vpdyma - plsc->vpdymi) * pos;
00484     dispx = disp;
00485     dispy = 0;
00486 
00487     } else if (plP_stsearch(side, 'l')) {
00488     vert = 1;
00489     xdv = plsc->vpdxmi;
00490     ydv = plsc->vpdymi + (plsc->vpdyma - plsc->vpdymi) * pos;
00491     dispx = -disp;
00492     dispy = 0;
00493 
00494     } else if (plP_stsearch(side, 'r')) {
00495     vert = 1;
00496     xdv = plsc->vpdxma;
00497     ydv = plsc->vpdymi + (plsc->vpdyma - plsc->vpdymi) * pos;
00498     dispx = disp;
00499     dispy = 0;
00500 
00501     } else {
00502     plP_sclp(clpxmi, clpxma, clpymi, clpyma); /* restore initial clip limits */
00503     return;
00504     }
00505 
00506 /* Transformation matrix */
00507 
00508     if (vert != 0) {
00509     xform[0] = 0.0;
00510     xform[1] = -1.0;
00511     xform[2] = 1.0;
00512     xform[3] = 0.0;
00513     } else {
00514     xform[0] = 1.0;
00515     xform[1] = 0.0;
00516     xform[2] = 0.0;
00517     xform[3] = 1.0;
00518     }
00519 
00520 /* Convert to physical units (mm) and compute shifts */
00521 
00522     plgchr(&chrdef, &chrht);
00523     shift = (just == 0.0) ? 0.0 : plstrl(text) * just;
00524 
00525     xmm = plP_dcmmx(xdv) + dispx * chrht;
00526     ymm = plP_dcmmy(ydv) + dispy * chrht;
00527     refxmm = xmm - shift * xform[0];
00528     refymm = ymm - shift * xform[2];
00529 
00530 /* Convert to device units (pixels) and call text plotter */
00531 
00532     x = plP_mmpcx(xmm);
00533     y = plP_mmpcy(ymm);
00534     refx = plP_mmpcx(refxmm);
00535     refy = plP_mmpcy(refymm);
00536 
00537     plP_text(0, just, xform, x, y, refx, refy, text);
00538     plP_sclp(clpxmi, clpxma, clpymi, clpyma); /* restore clip limits */
00539 }
00540 
00541 /*--------------------------------------------------------------------------*\
00542  * void plptex()
00543  *
00544  * Prints out "text" at world cooordinate (wx,wy). The text may be
00545  * at any angle "angle" relative to the horizontal. The parameter
00546  * "just" adjusts the horizontal justification of the string:
00547  *  just = 0.0 => left hand edge of string is at (wx,wy)
00548  *  just = 1.0 => right hand edge of string is at (wx,wy)
00549  *  just = 0.5 => center of string is at (wx,wy) etc.
00550 \*--------------------------------------------------------------------------*/
00551 
00552 void
00553 c_plptex(PLFLT wx, PLFLT wy, PLFLT dx, PLFLT dy, PLFLT just, const char *text)
00554 {
00555     PLINT x, y, refx, refy;
00556     PLFLT xdv, ydv, xmm, ymm, refxmm, refymm, shift, cc, ss;
00557     PLFLT xform[4], diag;
00558     PLFLT chrdef, chrht;
00559     PLFLT dispx, dispy;
00560 
00561     if (plsc->level < 3) {
00562     plabort("plptex: Please set up window first");
00563     return;
00564     }
00565 
00566     if (dx == 0.0 && dy == 0.0) {
00567     dx = 1.0;
00568     dy = 0.0;
00569     }
00570     cc = plsc->wmxscl * dx;
00571     ss = plsc->wmyscl * dy;
00572     diag = sqrt(cc * cc + ss * ss);
00573     cc /= diag;
00574     ss /= diag;
00575 
00576     xform[0] = cc;
00577     xform[1] = -ss;
00578     xform[2] = ss;
00579     xform[3] = cc;
00580 
00581     xdv = plP_wcdcx(wx);
00582     ydv = plP_wcdcy(wy);
00583 
00584     dispx = 0.;
00585     dispy = 0.;
00586 
00587 /* Convert to physical units (mm) and compute shifts */
00588 
00589     plgchr(&chrdef, &chrht);
00590     shift = (just == 0.0) ? 0.0 : plstrl(text) * just;
00591 
00592     xmm = plP_dcmmx(xdv) + dispx * chrht;
00593     ymm = plP_dcmmy(ydv) + dispy * chrht;
00594     refxmm = xmm - shift * xform[0];
00595     refymm = ymm - shift * xform[2];
00596 
00597     x = plP_mmpcx(xmm);
00598     y = plP_mmpcy(ymm);
00599     refx = plP_mmpcx(refxmm);
00600     refy = plP_mmpcy(refymm);
00601 
00602     plP_text(0, just, xform, x, y, refx, refy, text);
00603 }
00604 
00605 /*--------------------------------------------------------------------------*\
00606  * void plstr()
00607  *
00608  * Prints out a "string" at reference position with physical coordinates
00609  * (refx,refy). The coordinates of the vectors defining the string are
00610  * passed through the linear mapping defined by the 2 x 2 matrix xform()
00611  * before being plotted.  The reference position is at the left-hand edge of
00612  * the string. If base = 1, it is aligned with the baseline of the string.
00613  * If base = 0, it is aligned with the center of the character box.
00614  *
00615  * Note, all calculations are done in terms of millimetres. These are scaled
00616  * as necessary before plotting the string on the page.
00617 \*--------------------------------------------------------------------------*/
00618 
00619 void
00620 plstr(PLINT base, PLFLT *xform, PLINT refx, PLINT refy, const char *string)
00621 {
00622     short int *symbol;
00623     signed char *vxygrid = 0;
00624 
00625     PLINT ch, i, length, level = 0, style, oline = 0, uline = 0;
00626     PLFLT width = 0., xorg = 0., yorg = 0., def, ht, dscale, scale;
00627 
00628     plgchr(&def, &ht);
00629     dscale = 0.05 * ht;
00630     scale = dscale;
00631 
00632 /* Line style must be continuous */
00633 
00634     style = plsc->nms;
00635     plsc->nms = 0;
00636 
00637     pldeco(&symbol, &length, string);
00638 
00639     for (i = 0; i < length; i++) {
00640     ch = symbol[i];
00641     if (ch == -1) { /* super-script */
00642         level++;
00643         yorg += 16.0 * scale;
00644         scale = dscale * pow(0.75, (double) ABS(level));
00645     }
00646     else if (ch == -2) { /* sub-script */
00647         level--;
00648         scale = dscale * pow(0.75, (double) ABS(level));
00649         yorg -= 16.0 * scale;
00650     }
00651     else if (ch == -3) /* back-char */
00652         xorg -= width * scale;
00653     else if (ch == -4) /* toogle overline */
00654         oline = !oline;
00655     else if (ch == -5)  /* toogle underline */
00656         uline = !uline;
00657     else {
00658         if (plcvec(ch, &vxygrid))
00659         plchar(vxygrid, xform, base, oline, uline, refx, refy, scale,
00660                plsc->xpmm, plsc->ypmm, &xorg, &yorg, &width);
00661     }
00662     }
00663     plsc->nms = style;
00664 }
00665 
00666 /*--------------------------------------------------------------------------*\
00667  * plchar()
00668  *
00669  * Plots out a given stroke font character.
00670 \*--------------------------------------------------------------------------*/
00671 
00672 static void
00673 plchar(signed char *vxygrid, PLFLT *xform, PLINT base, PLINT oline, PLINT uline,
00674        PLINT refx, PLINT refy, PLFLT scale, PLFLT xpmm, PLFLT ypmm,
00675        PLFLT *p_xorg, PLFLT *p_yorg, PLFLT *p_width)
00676 {
00677     PLINT xbase, ybase, ydisp, lx, ly, cx, cy;
00678     PLINT k, penup;
00679     PLFLT x, y;
00680     PLINT llx[STLEN], lly[STLEN], l = 0;
00681 
00682     xbase = vxygrid[2];
00683     *p_width = vxygrid[3] - xbase;
00684     if (base == 0) {
00685     ybase = 0;
00686     ydisp = vxygrid[0];
00687     }
00688     else {
00689     ybase = vxygrid[0];
00690     ydisp = 0;
00691     }
00692     k = 4;
00693     penup = 1;
00694 
00695     for (;;) {
00696     cx = vxygrid[k++];
00697     cy = vxygrid[k++];
00698     if (cx == 64 && cy == 64) {
00699       if (l) {
00700         plP_draphy_poly(llx, lly, l);
00701         l = 0;
00702       }
00703       break;
00704     }
00705     if (cx == 64 && cy == 0) {
00706       if (l) {
00707         plP_draphy_poly(llx, lly, l);
00708         l = 0;
00709       }
00710       penup = 1;
00711     }
00712     else {
00713         x = *p_xorg + (cx - xbase) * scale;
00714         y = *p_yorg + (cy - ybase) * scale;
00715         lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
00716         ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
00717         if (penup == 1) {
00718           if (l) {
00719         plP_draphy_poly(llx, lly, l);
00720         l = 0;
00721           }
00722           llx[l] = lx;
00723           lly[l++] = ly; /* store 1st point ! */
00724           plP_movphy(lx, ly);
00725           penup = 0;
00726         }
00727         else {
00728           llx[l] = lx;
00729           lly[l++] = ly;
00730         }
00731     }
00732     }
00733 
00734     if (oline) {
00735     x = *p_xorg;
00736     y = *p_yorg + (30 + ydisp) * scale;
00737     lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
00738     ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
00739     plP_movphy(lx, ly);
00740     x = *p_xorg + *p_width * scale;
00741     lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
00742     ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
00743     plP_draphy(lx, ly);
00744     }
00745     if (uline) {
00746     x = *p_xorg;
00747     y = *p_yorg + (-5 + ydisp) * scale;
00748     lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
00749     ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
00750     plP_movphy(lx, ly);
00751     x = *p_xorg + *p_width * scale;
00752     lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
00753     ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
00754     plP_draphy(lx, ly);
00755     }
00756     *p_xorg = *p_xorg + *p_width * scale;
00757 }
00758 
00759 /*--------------------------------------------------------------------------*\
00760  * PLFLT plstrl()
00761  *
00762  * Computes the length of a string in mm, including escape sequences.
00763 \*--------------------------------------------------------------------------*/
00764 
00765 PLFLT
00766 plstrl(const char *string)
00767 {
00768     short int *symbol;
00769     signed char *vxygrid = 0;
00770     PLINT ch, i, length, level = 0;
00771     PLFLT width = 0., xorg = 0., dscale, scale, def, ht;
00772 
00773     plgchr(&def, &ht);
00774     dscale = 0.05 * ht;
00775     scale = dscale;
00776     pldeco(&symbol, &length, string);
00777 
00778     for (i = 0; i < length; i++) {
00779     ch = symbol[i];
00780     if (ch == -1) {
00781         level++;
00782         scale = dscale * pow(0.75, (double) ABS(level));
00783     }
00784     else if (ch == -2) {
00785         level--;
00786         scale = dscale * pow(0.75, (double) ABS(level));
00787     }
00788     else if (ch == -3)
00789         xorg -= width * scale;
00790     else if (ch == -4 || ch == -5);
00791     else {
00792         if (plcvec(ch, &vxygrid)) {
00793         width = vxygrid[3] - vxygrid[2];
00794         xorg += width * scale;
00795         }
00796     }
00797     }
00798     return (PLFLT) xorg;
00799 }
00800 
00801 /*--------------------------------------------------------------------------*\
00802  * PLINT plcvec()
00803  *
00804  * Gets the character digitisation of Hershey table entry "char".
00805  * Returns 1 if there is a valid entry.
00806 \*--------------------------------------------------------------------------*/
00807 
00808 static PLINT
00809 plcvec(PLINT ch, signed char **xygr)
00810 {
00811     PLINT k = 0, ib;
00812     signed char x, y;
00813 
00814     ch--;
00815     if (ch < 0 || ch >= indxleng)
00816     return (PLINT) 0;
00817     ib = fntindx[ch] - 2;
00818     if (ib == -2)
00819     return (PLINT) 0;
00820 
00821     do {
00822     ib++;
00823     x = fntbffr[2 * ib];
00824     y = fntbffr[2 * ib + 1];
00825     xygrid[k++] = x;
00826     xygrid[k++] = y;
00827     } while ((x != 64 || y != 64) && k <= (STLEN - 2));
00828 
00829     if (k == (STLEN-1)) {
00830     /* This is bad if we get here */
00831     xygrid[k] = 64;
00832     xygrid[k] = 64;
00833     }
00834 
00835     *xygr = xygrid;
00836     return (PLINT) 1;
00837 }
00838 
00839 /*--------------------------------------------------------------------------*\
00840  * void pldeco()
00841  *
00842  * Decode a character string, and return an array of float integer symbol
00843  * numbers. This routine is responsible for interpreting all escape sequences.
00844  * At present the following escape sequences are defined (the letter following
00845  * the <esc> may be either upper or lower case):
00846  *
00847  * <esc>u   : up one level (returns -1)
00848  * <esc>d   : down one level (returns -2)
00849  * <esc>b   : backspace (returns -3)
00850  * <esc>+   : toggles overline mode (returns -4)
00851  * <esc>-   : toggles underline mode (returns -5)
00852  * <esc><esc>   : <esc>
00853  * <esc>gx  : greek letter corresponding to roman letter x
00854  * <esc>fn  : switch to Normal font
00855  * <esc>fr  : switch to Roman font
00856  * <esc>fi  : switch to Italic font
00857  * <esc>fs  : switch to Script font
00858  * <esc>(nnn)   : Hershey symbol number nnn (any number of digits)
00859  *
00860  * The escape character defaults to '#', but can be changed to any of
00861  * [!#$%&*@^~] via a call to plsesc.
00862 \*--------------------------------------------------------------------------*/
00863 
00864 static void
00865 pldeco(short int **symbol, PLINT *length, const char *text)
00866 {
00867     PLINT ch, ifont = plsc->cfont, ig, j = 0, lentxt = strlen(text);
00868     char test, esc;
00869     short int *sym = symbol_buffer;
00870 
00871 /* Initialize parameters. */
00872 
00873     *length = 0;
00874     *symbol = symbol_buffer;
00875     plgesc(&esc);
00876     if (ifont > numberfonts)
00877     ifont = 1;
00878 
00879 /* Get next character; treat non-printing characters as spaces. */
00880 
00881     while (j < lentxt) {
00882     if (*length >= PLMAXSTR)
00883         return;
00884     test = text[j++];
00885     ch = test;
00886     if (ch < 0 || ch > 175)
00887         ch = 32;
00888 
00889     /* Test for escape sequence (#) */
00890 
00891     if (ch == esc && (lentxt - j) >= 1) {
00892         test = text[j++];
00893         if (test == esc)
00894         sym[(*length)++] = *(fntlkup + (ifont - 1) * numberchars + ch);
00895 
00896         else if (test == 'u' || test == 'U')
00897         sym[(*length)++] = -1;
00898 
00899         else if (test == 'd' || test == 'D')
00900         sym[(*length)++] = -2;
00901 
00902         else if (test == 'b' || test == 'B')
00903         sym[(*length)++] = -3;
00904 
00905         else if (test == '+')
00906         sym[(*length)++] = -4;
00907 
00908         else if (test == '-')
00909         sym[(*length)++] = -5;
00910 
00911         else if (test == '(') {
00912         sym[*length] = 0;
00913         while ('0' <= text[j] && text[j] <= '9') {
00914             sym[*length] = sym[*length] * 10 + text[j] - '0';
00915             j++;
00916         }
00917         (*length)++;
00918         if (text[j] == ')')
00919             j++;
00920         }
00921         else if (test == 'f' || test == 'F') {
00922         test = text[j++];
00923         ifont = 1 + plP_strpos(font_types,
00924                        isupper(test) ? tolower(test) : test);
00925         if (ifont == 0 || ifont > numberfonts)
00926             ifont = 1;
00927         }
00928         else if (test == 'g' || test == 'G') {
00929         test = text[j++];
00930         ig = plP_strpos(plP_greek_mnemonic, test) + 1;
00931         sym[(*length)++] =
00932             *(fntlkup + (ifont - 1) * numberchars + 127 + ig);
00933         }
00934         else {
00935         ;
00936         }
00937     }
00938     else {
00939 
00940     /* Decode character. */
00941     /* >>PC<< removed increment from following expression to fix */
00942     /* compiler bug */
00943 
00944         sym[(*length)] = *(fntlkup + (ifont - 1) * numberchars + ch);
00945         (*length)++;
00946     }
00947     }
00948 }
00949 
00950 /*--------------------------------------------------------------------------*\
00951  * PLINT plP_strpos()
00952  *
00953  * Searches string str for first occurence of character chr.  If found
00954  * the position of the character in the string is returned (the first
00955  * character has position 0).  If the character is not found a -1 is
00956  * returned.
00957 \*--------------------------------------------------------------------------*/
00958 
00959 PLINT
00960 plP_strpos(const char *str, int chr)
00961 {
00962     char *temp;
00963 
00964     if ((temp = strchr(str, chr)))
00965     return (PLINT) (temp - str);
00966     else
00967     return (PLINT) -1;
00968 }
00969 
00970 /*--------------------------------------------------------------------------*\
00971  * PLINT plP_stindex()
00972  *
00973  * Similar to strpos, but searches for occurence of string str2.
00974 \*--------------------------------------------------------------------------*/
00975 
00976 PLINT
00977 plP_stindex(const char *str1, const char *str2)
00978 {
00979     PLINT base, str1ind, str2ind;
00980 
00981     for (base = 0; *(str1 + base) != '\0'; base++) {
00982     for (str1ind = base, str2ind = 0; *(str2 + str2ind) != '\0' &&
00983          *(str2 + str2ind) == *(str1 + str1ind); str1ind++, str2ind++)
00984         ;
00985 
00986     if (*(str2 + str2ind) == '\0')
00987         return (PLINT) base;
00988     }
00989     return (PLINT) -1;      /* search failed */
00990 }
00991 
00992 /*--------------------------------------------------------------------------*\
00993  * PLBOOL plP_stsearch()
00994  *
00995  * Searches string str for character chr (case insensitive).
00996 \*--------------------------------------------------------------------------*/
00997 
00998 PLBOOL
00999 plP_stsearch(const char *str, int chr)
01000 {
01001     if (strchr(str, chr))
01002     return TRUE;
01003     else if (strchr(str, toupper(chr)))
01004     return TRUE;
01005     else
01006     return FALSE;
01007 }
01008 
01009 /*--------------------------------------------------------------------------*\
01010  * void c_plfont(ifont)
01011  *
01012  * Sets the global font flag to 'ifont'.
01013 \*--------------------------------------------------------------------------*/
01014 
01015 void
01016 c_plfont(PLINT ifont)
01017 {
01018     PLUNICODE fci = PL_FCI_MARK;
01019     if (plsc->level < 1) {
01020     plabort("plfont: Please call plinit first");
01021     return;
01022     }
01023     if (ifont < 1 || ifont > 4) {
01024     plabort("plfont: Invalid font");
01025     return;
01026     }
01027 
01028     plsc->cfont = ifont;
01029 
01030    /* Provide some degree of forward compatibility if dealing with 
01031     * unicode font. But better procedure is to call plsfci directly rather
01032     * than using this lame Hershey font interface.
01033     */
01034     switch(ifont)
01035      {
01036       case 1:
01037     /* normal = (medium, upright, sans serif) */
01038     plP_hex2fci(PL_FCI_SANS, PL_FCI_FAMILY, &fci);
01039     plsfci(fci);
01040     break;
01041     /* roman = (medium, upright, serif) */
01042       case 2:
01043     plP_hex2fci(PL_FCI_SERIF, PL_FCI_FAMILY, &fci);
01044     plsfci(fci);
01045     break;
01046     /* italic = (medium, italic, serif) */
01047       case 3:
01048     plP_hex2fci(PL_FCI_ITALIC, PL_FCI_STYLE, &fci);
01049     plP_hex2fci(PL_FCI_SERIF, PL_FCI_FAMILY, &fci);
01050     plsfci(fci);
01051     break;
01052     /* script = (medium, upright, script) */
01053       case 4:
01054     plP_hex2fci(PL_FCI_SCRIPT, PL_FCI_FAMILY, &fci);
01055     plsfci(fci);
01056     break;
01057      }
01058 }
01059 
01060 /*--------------------------------------------------------------------------*\
01061  * void plfntld(fnt)
01062  *
01063  * Loads either the standard or extended font.
01064 \*--------------------------------------------------------------------------*/
01065 
01066 void
01067 plfntld(PLINT fnt)
01068 {
01069     static PLINT charset;
01070     short bffrleng;
01071     PDFstrm *pdfs;
01072 
01073     if (fontloaded && (charset == fnt))
01074     return;
01075 
01076     plfontrel();
01077     fontloaded = 1;
01078     charset = fnt;
01079 
01080     if (fnt)
01081     pdfs = plLibOpenPdfstrm(PL_XFONT);
01082     else
01083     pdfs = plLibOpenPdfstrm(PL_SFONT);
01084 
01085     if (pdfs == NULL)
01086     plexit("Unable to either (1) open/find or (2) allocate memory for the font file");
01087 
01088 /* Read fntlkup[] */
01089 
01090     pdf_rd_2bytes(pdfs, (U_SHORT *) &bffrleng);
01091     numberfonts = bffrleng / 256;
01092     numberchars = bffrleng & 0xff;
01093     bffrleng = numberfonts * numberchars;
01094     fntlkup = (short int *) malloc(bffrleng * sizeof(short int));
01095     if ( ! fntlkup)
01096     plexit("plfntld: Out of memory while allocating font buffer.");
01097 
01098     pdf_rd_2nbytes(pdfs, (U_SHORT *) fntlkup, bffrleng);
01099 
01100 /* Read fntindx[] */
01101 
01102     pdf_rd_2bytes(pdfs, (U_SHORT *) &indxleng);
01103     fntindx = (short int *) malloc(indxleng * sizeof(short int));
01104     if ( ! fntindx)
01105     plexit("plfntld: Out of memory while allocating font buffer.");
01106 
01107     pdf_rd_2nbytes(pdfs, (U_SHORT *) fntindx, indxleng);
01108 
01109 /* Read fntbffr[] */
01110 /* Since this is an array of char, there are no endian problems */
01111 
01112     pdf_rd_2bytes(pdfs, (U_SHORT *) &bffrleng);
01113     fntbffr = (signed char *) malloc(2 * bffrleng * sizeof(signed char));
01114     if ( ! fntbffr)
01115     plexit("plfntld: Out of memory while allocating font buffer.");
01116 
01117 #if PLPLOT_USE_TCL_CHANNELS
01118     pdf_rdx(fntbffr, sizeof(signed char)*(2 * bffrleng), pdfs);
01119 #else
01120     plio_fread((void *) fntbffr, (size_t) sizeof(signed char),
01121       (size_t) (2 * bffrleng), pdfs->file);
01122 #endif
01123 
01124 /* Done */
01125 
01126     pdf_close(pdfs);
01127 }
01128 
01129 /*--------------------------------------------------------------------------*\
01130  * void plfontrel()
01131  *
01132  * Release memory for fonts.
01133 \*--------------------------------------------------------------------------*/
01134 
01135 void
01136 plfontrel(void)
01137 {
01138     if (fontloaded) {
01139     free_mem(fntindx)
01140     free_mem(fntbffr)
01141     free_mem(fntlkup)
01142     fontloaded = 0;
01143     }
01144 }
01145 
01146 /*--------------------------------------------------------------------------*\
01147  *  int plhershey2unicode ( int in )
01148  *
01149  *  Function searches for in, the input hershey code, in a lookup table and
01150  *  returns the corresponding index in that table.
01151  *  Using this index you can work out the unicode equivalent as well as
01152  *  the closest approximate to the font-face. If the returned index is
01153  *  -1 then no match was possible.
01154  *
01155  *  Two versions of the function exist, a simple linear search version,
01156  *  and a more complex, but significantly faster, binary search version.
01157  *  If there seem to be problems with the binary search method, the brain-dead
01158  *  linear search can be enabled by defining SIMPLE_BUT_SAFE_HERSHEY_LOOKUP
01159  *  at compile time.
01160 \*--------------------------------------------------------------------------*/
01161 
01162 int plhershey2unicode ( int in )
01163 {
01164 #ifdef SIMPLE_BUT_SAFE_HERSHEY_LOOKUP
01165   int ret=-1;
01166   int i;
01167 
01168   for (i=0;(i<number_of_entries_in_hershey_to_unicode_table)&&(ret==-1);i++)
01169     {
01170       if (hershey_to_unicode_lookup_table[i].Hershey==in) ret=i;
01171     }
01172 
01173   return(ret);
01174 
01175 #else
01176 
01177    int jlo = -1, jmid, jhi = number_of_entries_in_hershey_to_unicode_table;
01178    while (jhi - jlo > 1) 
01179      {
01180     /* Note that although jlo or jhi can be just outside valid
01181      * range (see initialization above) because of while condition
01182      * jlo < jmid < jhi and jmid must be in valid range.
01183      */
01184     jmid = (jlo+jhi)/2;
01185   /* convert hershey_to_unicode_lookup_table[jmid].Hershey to signed 
01186      integer since we don't loose information - the number range
01187      is from 1 and 2932 at the moment */
01188     if (in > (int)(hershey_to_unicode_lookup_table[jmid].Hershey))
01189       jlo = jmid;
01190     else if (in < (int)(hershey_to_unicode_lookup_table[jmid].Hershey))
01191       jhi = jmid;
01192     else
01193       /* We have found it!
01194        * in == hershey_to_unicode_lookup_table[jmid].Hershey 
01195        */
01196       return (jmid);
01197      }
01198    /* jlo is invalid or it is valid and in > hershey_to_unicode_lookup_table[jlo].Hershey.
01199     * jhi is invalid or it is valid and in < hershey_to_unicode_lookup_table[jhi].Hershey.
01200     * All these conditions together imply in cannot be found in
01201     * hershey_to_unicode_lookup_table[j].Hershey, for all j.
01202     */
01203    return(-1);
01204 #endif
01205 }
01206 
01207 /*--------------------------------------------------------------------------*\
01208  *  char *
01209  *  plP_FCI2FontName ( PLUNICODE fci, 
01210  *                     const FCI_to_FontName_Table lookup[], const int nlookup)
01211  *
01212  *  Function takes an input FCI (font characterization integer) index, 
01213  *  looks through the lookup table (which must be sorted by PLUNICODE fci),
01214  *  then returns the corresponding pointer to a valid font name.  If the FCI
01215  *  index is not present the returned value is NULL.
01216  \*--------------------------------------------------------------------------*/
01217 
01218 char *
01219 plP_FCI2FontName ( PLUNICODE fci, 
01220              const FCI_to_FontName_Table lookup[], const int nlookup)
01221 {
01222    int jlo = -1, jmid, jhi = nlookup;
01223    while (jhi - jlo > 1) 
01224      {
01225     /* Note that although jlo or jhi can be just outside valid
01226      * range (see initialization above) because of while condition
01227      * jlo < jmid < jhi and jmid must be in valid range.
01228      */
01229     jmid = (jlo+jhi)/2;
01230     if (fci > lookup[jmid].fci)
01231       jlo = jmid;
01232     else if (fci < lookup[jmid].fci)
01233       jhi = jmid;
01234     else
01235       /* We have found it!
01236        * fci == lookup[jmid].fci 
01237        */
01238       return (char *) (lookup[jmid].pfont);
01239      }
01240    /* jlo is invalid or it is valid and fci > lookup[jlo].Unicode.
01241     * jhi is invalid or it is valid and fci < lookup[jhi].Unicode.
01242     * All these conditions together imply fci index cannot be found in lookup.
01243     * Mark lookup failure with NULL pointer.
01244     */
01245    return(NULL);
01246 }
01247 
01248 /*--------------------------------------------------------------------------*\
01249  * void plmtex3()
01250  *
01251  * This is the 3d equivalent of plmtex(). It prints out "text" at specified 
01252  * position relative to viewport (may be inside or outside)
01253  *
01254  * side String contains one or more of the following characters
01255  *  x,y,z : Specify which axis is to be labeled
01256  *  p,s   : Label the "primary" or the "secondary" axis. The "primary" axis
01257  *            being somewhat arbitrary, but basically it is the one that you'd
01258  *            expect to labeled in a 3d graph of standard orientation. Example:
01259  *            for z this would be the left hand axis.
01260  *  v     : draw the text perpendicular to the axis.
01261  *
01262  * disp Displacement from specified edge of axis, measured outwards from
01263  *  the axis in units of the current character height. The
01264  *  centerlines of the characters are aligned with the specified
01265  *  position.
01266  *
01267  * pos  Position of the reference point of the string relative to the
01268  *  axis ends, ranging from 0.0 (left-hand end) to 1.0 (right-hand
01269  *  end)
01270  *
01271  * just Justification of string relative to reference point
01272  *  just = 0.0 => left hand edge of string is at reference
01273  *  just = 1.0 => right hand edge of string is at reference
01274  *  just = 0.5 => center of string is at reference
01275  * 
01276  * All calculations are done in physical coordinates.
01277  *
01278 \*--------------------------------------------------------------------------*/
01279 
01280 void
01281 c_plmtex3(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
01282 {
01283     /* local storage */
01284     PLFLT xmin, xmax, ymin, ymax, zmin, zmax, zscale;
01285     PLFLT chrdef, chrht;
01286     
01287     /* calculated */
01288     PLFLT xpc, ypc, xrefpc, yrefpc;
01289     PLFLT epx1, epy1, epx2, epy2, epx3, epy3;
01290     PLFLT dispx, dispy, xform[4];
01291     PLFLT shift, theta, temp;
01292 
01293     /* check that the plotting environment is set up */
01294     if (plsc->level < 3) {
01295         plabort("plmtex3: Please set up window first");
01296         return;
01297     }
01298     
01299     /* get plotting environment information */
01300     plP_gdom(&xmin, &xmax, &ymin, &ymax);
01301     plP_grange(&zscale, &zmin, &zmax);
01302     plgchr(&chrdef, &chrht);
01303 
01304     /* handle x/y axises */
01305     if((plP_stindex(side, "x") != -1)||(plP_stindex(side, "y") != -1)){
01306     
01307         /* get the locations of the end points of the relevant axis */
01308 
01309         /* x axis label */
01310         if(plP_stindex(side, "x") != -1){
01311     
01312             /* primary */
01313             if(plP_stindex(side, "p") != -1){
01314                 epx1 = plP_wcpcx(plP_w3wcx(xmin, ymin, zmin));
01315                 epy1 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmin));
01316                 epx2 = plP_wcpcx(plP_w3wcx(xmax, ymin, zmin));
01317                 epy2 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmin));
01318             } else {
01319                 epx1 = plP_wcpcx(plP_w3wcx(xmin, ymax, zmin));
01320                 epy1 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmin));
01321                 epx2 = plP_wcpcx(plP_w3wcx(xmax, ymax, zmin));
01322                 epy2 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmin));
01323             }
01324         } else {
01325 
01326             if(plP_stindex(side, "p") != -1){
01327                 epx1 = plP_wcpcx(plP_w3wcx(xmin, ymin, zmin));
01328                 epy1 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmin));
01329                 epx2 = plP_wcpcx(plP_w3wcx(xmin, ymax, zmin));
01330                 epy2 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmin));
01331             } else {
01332                 epx1 = plP_wcpcx(plP_w3wcx(xmax, ymin, zmin));
01333                 epy1 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmin));
01334                 epx2 = plP_wcpcx(plP_w3wcx(xmax, ymax, zmin));
01335                 epy2 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmin));
01336             }
01337         }
01338 
01339         /* text always goes from left to right */
01340         if(epx1 > epx2){
01341             temp = epx1;
01342             epx1 = epx2;
01343             epx2 = temp;
01344             temp = epy1;
01345             epy1 = epy2;
01346             epy2 = temp;
01347             /* recalculate position assuming the user specified
01348              * it in the min -> max direction of the axis. */
01349             pos = 1.0 - pos;
01350         }
01351 
01352         /* calculate location of text center point */
01353 
01354         /* 1. calculate the angle of the axis we are to
01355          * draw the text on relative to the horizontal */
01356                                 
01357         if((epx2-epx1)!=0.0){
01358             theta = atan((epy2 - epy1)/(epx2 - epx1));
01359         } else {
01360             if(epy2 > epy1){
01361                 theta = 0.5 * PI;
01362             } else {
01363                 theta = -0.5 * PI;          
01364             }
01365         }
01366         
01367         /* 2. calculate the perpendicular vector */
01368 
01369         dispy = disp * chrht;
01370 
01371         /* 3. calculate x & y center points */
01372         
01373         xpc = pos * (epx2 - epx1) + epx1;
01374         ypc = pos * (epy2 - epy1) + epy1;
01375         
01376         /* 4. compute reference point
01377          *  It appears that drivers that cannot handle text justification 
01378          *   use this as the starting point of the string.
01379          *  Calculations must be done in millimeters for this part
01380          *   so we convert to mm, do the calculation and convert back.
01381          *  The calculation is also dependent of the orientation
01382          *   (perpendicular or parallel) of the text. */
01383 
01384         xpc = plP_dcmmx(plP_pcdcx((PLINT)xpc));  
01385         ypc = plP_dcmmy(plP_pcdcy((PLINT)ypc)) - dispy;
01386         
01387         shift = plstrl(text) * just;
01388         
01389         if(plP_stindex(side, "v") != -1){
01390             xrefpc = xpc;
01391             yrefpc = ypc - shift;
01392         } else {
01393             xrefpc = xpc - cos(theta) * shift;
01394             yrefpc = ypc - sin(theta) * shift;
01395         }
01396 
01397         xpc = plP_mmpcx(xpc);
01398         ypc = plP_mmpcy(ypc);
01399         xrefpc = plP_mmpcx(xrefpc);
01400         yrefpc = plP_mmpcy(yrefpc);
01401 
01402         /* 5. compute transform matrix & draw text */
01403 
01404         /* perpendicular, rotate 90 degrees & shear */
01405 
01406         if(plP_stindex(side, "v") != -1){           
01407             xform[0] = 0.0;
01408             xform[1] = -cos(theta);
01409             xform[2] = 1.0;
01410             xform[3] = -sin(theta);
01411             plP_text(0, just, xform, (PLINT)xpc, (PLINT)ypc, (PLINT)xrefpc, (PLINT)yrefpc, text);
01412         }
01413 
01414         /* parallel, rotate & shear by angle */
01415         else {
01416             xform[0] = cos(theta);
01417             xform[1] = 0.0;
01418             xform[2] = sin(theta);
01419             xform[3] = 1.0;
01420 
01421             plP_text(0, just, xform, (PLINT)xpc, (PLINT)ypc, (PLINT)xrefpc, (PLINT)yrefpc, text);
01422         }
01423     }
01424 
01425     /* handle z axises */
01426     if(plP_stindex(side, "z") != -1){
01427 
01428         /* Find the left most of the 4 z axis options for "primary"
01429          * Also find the location of frontmost point in the graph,
01430          *  which will be needed to calculate at what angle to shear
01431          *  the text. */
01432 
01433         if(plP_stindex(side, "p") != -1){
01434 
01435             epx1 = plP_wcpcx(plP_w3wcx(xmin, ymin, zmin));
01436             epy1 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmin));
01437             epy2 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmax));
01438             epx3 = plP_wcpcx(plP_w3wcx(xmax, ymin, zmin));
01439             epy3 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmin));
01440             
01441             if(plP_wcpcx(plP_w3wcx(xmin, ymax, zmin)) < epx1){
01442                 epx1 = plP_wcpcx(plP_w3wcx(xmin, ymax, zmin));          
01443                 epy1 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmin));
01444                 epy2 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmax));
01445                 epx3 = plP_wcpcx(plP_w3wcx(xmin, ymin, zmin));
01446                 epy3 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmin));
01447             }
01448 
01449             if(plP_wcpcx(plP_w3wcx(xmax, ymin, zmin)) < epx1){
01450                 epx1 = plP_wcpcx(plP_w3wcx(xmax, ymin, zmin));          
01451                 epy1 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmin));
01452                 epy2 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmax));
01453                 epx3 = plP_wcpcx(plP_w3wcx(xmax, ymax, zmin));
01454                 epy3 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmin));
01455             }
01456 
01457             if(plP_wcpcx(plP_w3wcx(xmax, ymax, zmin)) < epx1){
01458                 epx1 = plP_wcpcx(plP_w3wcx(xmax, ymax, zmin));          
01459                 epy1 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmin));
01460                 epy2 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmax));
01461                 epx3 = plP_wcpcx(plP_w3wcx(xmin, ymax, zmin));
01462                 epy3 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmin));
01463             }
01464         }
01465 
01466         /* find the right most of the 4 z axis options for "primary" */
01467         if(plP_stindex(side, "s") != -1){
01468 
01469             epx1 = plP_wcpcx(plP_w3wcx(xmin, ymin, zmin));
01470             epy1 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmin));
01471             epy2 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmax));
01472             epx3 = plP_wcpcx(plP_w3wcx(xmin, ymax, zmin));
01473             epy3 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmin));
01474             
01475             if(plP_wcpcx(plP_w3wcx(xmin, ymax, zmin)) > epx1){
01476                 epx1 = plP_wcpcx(plP_w3wcx(xmin, ymax, zmin));          
01477                 epy1 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmin));
01478                 epy2 = plP_wcpcy(plP_w3wcy(xmin, ymax, zmax));
01479                 epx3 = plP_wcpcx(plP_w3wcx(xmax, ymax, zmin));
01480                 epy3 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmin));
01481             }
01482 
01483             if(plP_wcpcx(plP_w3wcx(xmax, ymin, zmin)) > epx1){
01484                 epx1 = plP_wcpcx(plP_w3wcx(xmax, ymin, zmin));          
01485                 epy1 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmin));
01486                 epy2 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmax));
01487                 epx3 = plP_wcpcx(plP_w3wcx(xmin, ymin, zmin));
01488                 epy3 = plP_wcpcy(plP_w3wcy(xmin, ymin, zmin));
01489             }
01490 
01491             if(plP_wcpcx(plP_w3wcx(xmax, ymax, zmin)) > epx1){
01492                 epx1 = plP_wcpcx(plP_w3wcx(xmax, ymax, zmin));          
01493                 epy1 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmin));
01494                 epy2 = plP_wcpcy(plP_w3wcy(xmax, ymax, zmax));
01495                 epx3 = plP_wcpcx(plP_w3wcx(xmax, ymin, zmin));
01496                 epy3 = plP_wcpcy(plP_w3wcy(xmax, ymin, zmin));
01497             }
01498         }
01499 
01500         /* Calculate location of text center point.
01501          * This is very similiar for the z axis. */
01502 
01503         /* primary and secondary have to be handled separately here */
01504 
01505         if(plP_stindex(side, "p") != -1){
01506 
01507             /* 1. Calculate the angle of the axis we are to
01508              * draw the text on relative to the horizontal. */
01509                                 
01510             if((epx3-epx1)!=0.0){
01511                 theta = atan((epy3 - epy1)/(epx3 - epx1));
01512             } else {
01513                 if(epy3 > epy1){
01514                     theta = 0.5 * PI;
01515                 } else {
01516                     theta = -0.5 * PI;          
01517                 }
01518             }
01519         
01520             /* 2. Calculate the perpendicular vector. */
01521 
01522             dispx = -cos(theta) * disp * chrht;
01523             dispy = -sin(theta) * disp * chrht;
01524         } else {
01525             if((epx1-epx3)!=0.0){
01526                 theta = -atan((epy3 - epy1)/(epx1 - epx3));
01527             } else {
01528                 if(epy3 > epy1){
01529                     theta = -0.5 * PI;
01530                 } else {
01531                     theta = 0.5 * PI;           
01532                 }
01533             }
01534             
01535             dispx = cos(theta) * disp * chrht;
01536             dispy = sin(theta) * disp * chrht;
01537         }
01538         
01539         /* 3. Calculate x & y center points. */
01540         
01541         xpc = epx1;
01542         ypc = pos * (epy2 - epy1) + epy1;
01543         
01544         /* 4. Compute the reference point. */
01545 
01546         xpc = plP_dcmmx(plP_pcdcx((PLINT)xpc)) + dispx;
01547         ypc = plP_dcmmy(plP_pcdcy((PLINT)ypc)) + dispy;
01548         
01549         shift = plstrl(text) * just;
01550 
01551         if(plP_stindex(side, "v") != -1){
01552             xrefpc = xpc - cos(theta) * shift;
01553             yrefpc = ypc - sin(theta) * shift;
01554         } else {
01555             xrefpc = xpc;
01556             yrefpc = ypc - shift;
01557         }
01558         
01559         xpc = plP_mmpcx(xpc);
01560         ypc = plP_mmpcy(ypc);
01561         xrefpc = plP_mmpcx(xrefpc);
01562         yrefpc = plP_mmpcy(yrefpc);
01563 
01564         /* 5. Compute transform matrix & draw text. */
01565 
01566         if(plP_stindex(side, "v") != -1){
01567             xform[0] = cos(theta);
01568             xform[1] = 0.0;
01569             xform[2] = sin(theta);
01570             xform[3] = 1.0;
01571 
01572             plP_text(0, just, xform, (PLINT)xpc, (PLINT)ypc, (PLINT)xrefpc, (PLINT)yrefpc, text);
01573         }
01574 
01575         else {
01576             xform[0] = 0.0;
01577             xform[1] = -cos(theta);
01578             xform[2] = 1.0;
01579             xform[3] = -sin(theta);
01580 
01581             plP_text(0, just, xform, (PLINT)xpc, (PLINT)ypc, (PLINT)xrefpc, (PLINT)yrefpc, text);
01582         }
01583 
01584     }
01585 }
01586 
01587 /*--------------------------------------------------------------------------*\
01588  * void plptex3()
01589  *
01590  * Prints out "text" at world cooordinate (wx,wy,wz).
01591  *
01592  * The text is drawn parallel to the line between (wx,wy,wz) and 
01593  * (wx+dx,wy+dy,wz+dz).
01594  *
01595  * The text is sheared so that it is "vertically" parallel to the
01596  * line between (wx,wy,wz) and (wx+sx, wy+sy, wz+sz). If sx=sy=sz=0 then
01597  * the text is simply rotated to parallel to the baseline.
01598  *
01599  * "just" adjusts the horizontal justification of the string:
01600  *  just = 0.0 => left hand edge of string is at (wx,wy)
01601  *  just = 1.0 => right hand edge of string is at (wx,wy)
01602  *  just = 0.5 => center of string is at (wx,wy) etc.
01603  *
01604  * Calculations are done in physical coordinates.
01605  *
01606 \*--------------------------------------------------------------------------*/
01607 
01608 void
01609 c_plptex3(PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, 
01610     PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text)
01611 {
01612   PLFLT xpc, ypc, xrefpc, yrefpc, xdpc, ydpc, xspc, yspc, ld, ls, cp, shift;
01613   PLFLT x_o, y_o, z_o, x_dx, y_dy, z_dz;
01614   PLFLT theta, phi, stride, xform[4];
01615 
01616   /* check that the plotting environment is set up */
01617   if (plsc->level < 3) {
01618     plabort("plptex3: Please set up window first");
01619     return;
01620   }
01621   
01622   /* compute text x,y location in physical coordinates */
01623   xpc = plP_wcpcx(plP_w3wcx(wx, wy, wz));
01624   ypc = plP_wcpcy(plP_w3wcy(wx, wy, wz));
01625   
01626   /* determine angle to rotate text in the x-y plane */
01627   xdpc = plP_wcpcx(plP_w3wcx(wx+dx, wy+dy, wz+dz));
01628   ydpc = plP_wcpcy(plP_w3wcy(wx+dx, wy+dy, wz+dz));
01629   theta = atan2(ydpc - ypc, xdpc - xpc);
01630 
01631   /* Determine angle to shear text in the x-y plane. This is a little
01632    * messy, but basically the idea is:
01633    *
01634    * Compute the dot product of the vector d and the vector s to
01635    * determine the angle between them (acos(t) = d . s / |d| |s|).
01636    * Then because acos will return a number from 0.0 to PI, i.e.
01637    * only in quadrants 1 or 2, compute the cross product of the
01638    * two vectors. If this is negative then the angle is adjusted
01639    * 0.0 to -PI. */
01640   
01641   if((sx == 0.0) && (sy == 0.0) && (sz == 0.0)){
01642     phi = 0.0;
01643   } else {
01644     xspc = plP_wcpcx(plP_w3wcx(wx+sx, wy+sy, wz+sz));
01645     yspc = plP_wcpcy(plP_w3wcy(wx+sx, wy+sy, wz+sz));
01646     ld = sqrt((xpc - xdpc) * (xpc - xdpc) + (ypc - ydpc) * (ypc - ydpc));
01647     ls = sqrt((xpc - xspc) * (xpc - xspc) + (ypc - yspc) * (ypc - yspc));
01648     phi = acos(((xdpc - xpc) * (xspc - xpc) + (ydpc - ypc) * (yspc - ypc))/(ld * ls));
01649     cp = (xdpc - xpc) * (yspc - ypc) - (ydpc - ypc) * (xspc - xpc);
01650     if(cp < 0.0){ phi = -phi; }
01651     phi = 1.570796 - phi;
01652   }
01653   
01654   /* Determine how to adjust the "stride" of the text to make it 
01655      appear that it is going into (or out of) the page. Basically
01656      scale the x baseline of the text by the normalized length of
01657      the d vector projected into the x-y plane. */
01658   x_o = plP_w3wcx(wx, wy, wz);
01659   y_o = plP_w3wcy(wx, wy, wz);
01660   z_o = plP_w3wcz(wx, wy, wz);
01661   x_dx = x_o - plP_w3wcx(wx+dx, wy+dy, wz+dz);
01662   y_dy = y_o - plP_w3wcy(wx+dx, wy+dy, wz+dz);
01663   z_dz = z_o - plP_w3wcz(wx+dx, wy+dy, wz+dz);
01664 
01665   stride = sqrt(x_dx*x_dx + y_dy*y_dy);
01666   stride = stride/sqrt(x_dx*x_dx + y_dy*y_dy + z_dz*z_dz);
01667 
01668   /* compute the reference point */ 
01669   xpc = plP_dcmmx(plP_pcdcx((PLINT)xpc));
01670   ypc = plP_dcmmy(plP_pcdcy((PLINT)ypc));
01671   
01672   shift = plstrl(text) * just;
01673   xrefpc = xpc - cos(theta) * shift;
01674   yrefpc = ypc - sin(theta) * shift;
01675   
01676   xpc = plP_mmpcx(xpc);
01677   ypc = plP_mmpcy(ypc);
01678   xrefpc = plP_mmpcx(xrefpc);
01679   yrefpc = plP_mmpcy(yrefpc);
01680   
01681   /* compute the transform */
01682   xform[0] = cos(theta) * stride;
01683   xform[1] = cos(theta) * sin(phi) - sin(theta) * cos(phi);
01684   xform[2] = sin(theta) * stride;
01685   xform[3] = sin(theta) * sin(phi) + cos(theta) * cos(phi);
01686 
01687   plP_text(0, just, xform, (PLINT)xpc, (PLINT)ypc, (PLINT)xrefpc, (PLINT)yrefpc, text); 
01688 }
01689 
01690 /*------------------------------------------------------------------------*\
01691  * void plsfont()
01692  *
01693  * Set the family, style and weight of the current font.
01694  * This is a user-friendly front-end to plsfci.
01695  * Note: A negative value signifies that this element should not be changed.
01696 \*------------------------------------------------------------------------*/ 
01697 void
01698 c_plsfont(PLINT family, PLINT style, PLINT weight)
01699 {
01700   PLUNICODE fci;
01701 
01702   plgfci(&fci);
01703   
01704   if (family >= 0) {
01705     /* Bounds checking assumes symbol is last font */
01706     if (family > PL_FCI_SYMBOL) 
01707       plwarn("plsfont: Value for family is out of range");
01708     else
01709       plP_hex2fci((unsigned char)family,PL_FCI_FAMILY,&fci);
01710   }
01711 
01712   if (style >= 0) {
01713     /* Bounds checking assumes oblique is last style */
01714     if (style > PL_FCI_OBLIQUE) 
01715       plwarn("plsfont: Value for style is out of range");
01716     else
01717     plP_hex2fci((unsigned char)style,PL_FCI_STYLE,&fci);
01718   }
01719 
01720   if (weight >= 0) {
01721     /* Bounds checking assumes bold is last weight */
01722     if (weight > PL_FCI_BOLD) 
01723       plwarn("plsfont: Value for weight is out of range");
01724     else
01725     plP_hex2fci((unsigned char)weight,PL_FCI_WEIGHT,&fci);
01726   }
01727 
01728   plsfci(fci);
01729 }
01730 
01731 /*------------------------------------------------------------------------*\
01732  * void plgfont()
01733  *
01734  * Get the family, style and weight of the current font.
01735  * This is a user-friendly front-end to plgfci.
01736  * Note: A NULL pointer signifies that this value should not be returned.
01737 \*------------------------------------------------------------------------*/ 
01738 void
01739 c_plgfont(PLINT *p_family, PLINT *p_style, PLINT *p_weight)
01740 {
01741   PLUNICODE fci;
01742   unsigned char val;
01743 
01744   plgfci(&fci);
01745 
01746   if (p_family) {
01747     plP_fci2hex(fci, &val, PL_FCI_FAMILY);
01748     *p_family = (PLINT) val;
01749   } 
01750 
01751   if (p_style) {
01752     plP_fci2hex(fci, &val, PL_FCI_STYLE);
01753     *p_style= (PLINT) val;
01754   } 
01755 
01756   if (p_weight) {
01757     plP_fci2hex(fci, &val, PL_FCI_WEIGHT);
01758     *p_weight= (PLINT) val;
01759   } 
01760 
01761 }
01762 
01763 
01764 #undef PLSYM_H
01765 #endif