home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / driver / util / dospecia.c < prev    next >
C/C++ Source or Header  |  1995-06-04  |  16KB  |  666 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from util/dospecia.c
  3. */
  4. /* dospecial.c
  5.  *
  6.  * enthaelt:
  7.  *    SkipDoSpecial()    - ueberliest beliebig langen Special-Text
  8.  *    DoSpecial()    - liest den Special-Text, schneidet "vorne"/"hinten"
  9.  *              Spaces/Ctrl-Zeichen ab und ruft
  10.  *                CallDoSpecial()
  11.  *              auf, in der dann der Text ausgewertet werden kann.
  12.  * ATARI-Teil:
  13.  *    CallDoSpecial()    - Auswertung von TPIC, Strunk-TeX und LindnerTeX
  14.  *              Specials, anschliessend Auswertung wie dvips5.4x
  15.  *
  16.  * AMIGA-Teil:
  17.  *    CallDoSpecial()    - Protokoll fuer specialhost-Programm
  18.  *              (zuvor sollte man noch die TPIC-specials heraus-
  19.  *              filtern und erst, wenn tatsaechlich gezeichnet wird,
  20.  *              die Punkte, Kreise, ... zu specialhost senden)
  21.  */
  22.  
  23. #include "defines.h"
  24. #include <stdio.h>
  25. #include <ctype.h>
  26.  
  27. #include "globals.h"
  28.  
  29. #ifdef ANSI
  30. #  include <stddef.h>
  31. #  include <stdlib.h>
  32. #  include <string.h>
  33. #  include <math.h>
  34. #endif
  35.  
  36. #include "bitmap.h"
  37.  
  38. #include "globals.i"
  39.  
  40. #ifndef AZTEC_C
  41. #  define fgetc(fp)    getc(fp)    /* Effizienz ? */
  42. #endif
  43.  
  44. #ifdef AMIGA
  45. #  include <exec/types.h>
  46. #  include <exec/exec.h>
  47. #  include <exec/ports.h>
  48. #  include "fast_cp.i"
  49. #  include "special.h"
  50. #  include "dvihand.i"
  51. #endif
  52.  
  53. #ifdef ATARI
  54. extern int access(char *, int);
  55. # include "atscreen.h"
  56. #endif
  57.  
  58. #ifndef ANSI
  59. char *strcpy(); 
  60. #endif
  61.  
  62.  
  63. /*
  64.  * Fuer die locale-Library:
  65.  *
  66.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  67.  * Achtung:
  68.  * Es muss/sollte 'multiple-include' erlaubt sein!
  69.  */
  70. #include "local.i"
  71.  
  72. #undef  CATCOMP_ARRAY
  73. #undef  CATCOMP_BLOCK
  74. #undef  CATCOMP_STRINGS
  75. #define CATCOMP_NUMBERS
  76. #include "localstr.h"
  77.  
  78.  
  79.  
  80.  
  81.  
  82. extern long  hh;                        /* current h on device */
  83. extern long  vv;                        /* current v on device */
  84.  
  85. #ifdef AMIGA
  86. extern struct bitmap    map;
  87. extern long        upper_limit;
  88. extern long        lower_limit;
  89. #endif
  90.  
  91.  
  92.  
  93. static void CallDoSpecial(char *specialstring);
  94.  
  95.  
  96.  
  97. /*-->SkipDoSpecial*/
  98. /*
  99.  * Wird beim Ueberlesen einer Seite aufgerufen.
  100.  * Evtl. sollten einige Specials, die global wirken, ausgefuehrt werden.
  101.  */
  102.  
  103.   void
  104. SkipDoSpecial(DVIFILE *fp, unsigned long n)
  105. { char buffer[256];
  106.   unsigned long count;
  107.  
  108.   while( n != 0L ) {
  109.     count = (n > 256) ? 256 : n;
  110.  
  111.     if (DVIfread(buffer, 1L, count, fp) != count) {
  112.       Fatal(3, MSG_DVI_FILE_ERROR);
  113.     }
  114.     n -= count;
  115.   }
  116. }
  117.  
  118.  
  119.  
  120. /*-->DoSpecial*/
  121. /*********************************************************************/
  122. /*****************************  DoSpecial  ***************************/
  123. /*********************************************************************/
  124.  
  125.    void
  126. DoSpecial(DVIFILE *fp, unsigned long n)
  127. { static char *cmdbuffer = NULL;
  128.   static long cmdlen = -1L;
  129.   register char *p;
  130.  
  131.   if( n == 0L )        /* before we forget this "special" case */
  132.     return;
  133.  
  134.   /* If special is too long, write a message and skip over it... */
  135.   if( n > 65535L ) {
  136.     Logging(MSG_SPECIAL_TOO_LONG);
  137.     SkipDoSpecial(fp, n);
  138.     return;
  139.   }
  140.  
  141.   /*
  142.    * Use old allocated buffer or
  143.    * allocate larger buffer for the special string
  144.    */
  145.   if( cmdlen < (long)n ) {
  146.     if( cmdbuffer != NULL ) {
  147.     xfree(cmdbuffer);
  148.     cmdlen = -1L;
  149.     }
  150.     if( (cmdbuffer = malloc( n + 1 )) == NULL ) {
  151.         Logging(MSG_NO_MEM_FOR_SPECIAL);
  152.     SkipDoSpecial(fp, n);
  153.     return;
  154.     }
  155.     cmdlen = (long)n;
  156.   }
  157.  
  158.   if( DVIfread(cmdbuffer, sizeof(char), (size_t)n, fp) != (size_t)n ) {
  159.     Fatal(3, MSG_DVI_FILE_ERROR);
  160.     return;
  161.   }
  162.  
  163.  
  164.   /* Trim the special string at both ends... */
  165.   while( n > 0 && cmdbuffer[n-1] <= ' ' )
  166.     n--;        /* trim trailing blanks (and Ctrl-Chars) */
  167.   if( n == 0 )
  168.     return;        /* all blanks is no-op */
  169.  
  170.   /* Make sure that special string ends correctly with a \0 char */
  171.   cmdbuffer[n] = '\0';
  172.  
  173.   p = cmdbuffer;
  174.   while( *p <= ' ' ) {
  175.     p++;
  176.     //n--;
  177.   }
  178.  
  179.   /*
  180.    *    Now the special string is null-terminated and trimmed
  181.    */
  182.  
  183.   CallDoSpecial(p);
  184.  
  185.   /* If special buffer is too large, release allocated memory */
  186.   if( cmdlen > 256 ) {
  187.     xfree(cmdbuffer);
  188.     cmdlen = -1L;
  189.   }
  190. }
  191.  
  192.  
  193.  
  194. /*----------------------------------------------------------------------*
  195.  *
  196.  *    Site specific special treatment...
  197.  *
  198.  *----------------------------------------------------------------------*/
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207. /***********************    A  M  I  G  A    ********************************/
  208.  
  209.  
  210.  
  211.  
  212. static void draw_border(struct special_map *bmap);
  213. static int call_tpic_command(int tpic, char *p);
  214. static int handle_tpic_command(int tpic, char *p);
  215.  
  216.  
  217. static void draw_border(struct special_map *bmap)
  218. {
  219.   long width,height;
  220.   long svv = vv, shh = hh;
  221.  
  222.   width = (((long)(((double)bmap->width/(double)hconvresolution*1000/mag)*72.27+0.5))<<16) + (1<<15);    /* *1000/mag : (hes) 2.6.95 */
  223.   height = (((long)(((double)bmap->height/(double)vconvresolution*1000/mag)*72.27+0.5))<<16) + (1<<15);
  224.  
  225.   vv += bmap->voffset + ((1<<15) / vconv);
  226.   hh += bmap->hoffset - ((1<<15) / hconv);
  227.  
  228.   SetRule(height, 1<<15, FALSE);    /* 1<<15 == 0.5 pt */
  229.   SetRule(1<<15, width, FALSE);
  230.  
  231.   vv -= (height + (vconv>>1) - (1<<15)) / vconv;
  232.   //vv -= bmap->height /*-vthickness*/;
  233.   SetRule(1<<15, width, FALSE);
  234.  
  235.   vv += (height + (vconv>>1) - (1<<15)) / vconv;
  236.   //vv += bmap->height /*-vthickness*/;
  237.   hh += (width + (hconv>>1)) / hconv;
  238.   //hh += bmap->width /*-hthickness*/;
  239.   SetRule(height, 1<<15, FALSE);
  240.  
  241.   vv = svv;
  242.   hh = shh;
  243. }
  244.  
  245.  
  246.  
  247. static void CallDoSpecial(char *str)
  248. {
  249.   struct special_map *bmap;
  250.   long x,y,width,height, xpos, ypos, pagewidth, xoff, shift, ystart;
  251.   long xstart, xend;
  252.   unsigned short *page, *image, it;
  253.   unsigned long copy, *insert;
  254.   FILE *iffile;
  255.   long buffer;
  256.   unsigned short *line;
  257.   long width_bit;
  258.   int tpic;
  259.   char *p;
  260.  
  261.  
  262.  
  263.   /* TPIC specials: for tpic 2.0 */
  264.  
  265.   tpic = TPIC_NO_TPIC;
  266.   p = str;
  267.  
  268.   if (strncmp(p, "pn ", 3) == 0)      { tpic = TPIC_PN;  }
  269.   else if (strncmp(p, "pa ", 3) == 0) { tpic = TPIC_PA;  }
  270.   else if (strcmp (p, "fp") == 0)     { tpic = TPIC_FP;  }
  271.   else if (strcmp (p, "ip") == 0)     { tpic = TPIC_IP;  } /* tpic 2.0 */
  272.   else if (strncmp(p, "da ", 3) == 0) { tpic = TPIC_DA;  }
  273.   else if (strncmp(p, "dt ", 3) == 0) { tpic = TPIC_DT;  }
  274.   else if (strcmp (p, "sp") == 0)     { tpic = TPIC_SP;  } /* tpic 2.0 */
  275.   else if (strncmp(p, "sp ", 3) == 0) { tpic = TPIC_SPB; } /* tpic 2.0 */
  276.   else if (strncmp(p, "ar ", 3) == 0) { tpic = TPIC_AR;  } /* tpic 2.0 */
  277.   else if (strncmp(p, "ia ", 3) == 0) { tpic = TPIC_IA;  } /* tpic 2.0 */
  278.   else if (strcmp (p, "sh") == 0)     { tpic = TPIC_SH;  } /* tpic 2.0 */
  279.   else if (strncmp(p, "sh ", 3) == 0) { tpic = TPIC_SHB; } /* tpic 2.0 */
  280.   else if (strcmp (p, "wh") == 0)     { tpic = TPIC_WH;  }
  281.   else if (strcmp (p, "bk") == 0)     { tpic = TPIC_BK;  }
  282.   else if (strncmp(p, "tx ", 3) == 0) { tpic = TPIC_TX;  }
  283.  
  284.   if (tpic != TPIC_NO_TPIC) {
  285.     (void)handle_tpic_command(tpic, p);
  286.     return;
  287.   }
  288.   /* else ... normaler \special-String */
  289.  
  290.   bmap = send_special(str);
  291.   xstart = 0;
  292.   //xend = 0;
  293.  
  294.  
  295.   if (bmap != NULL) {
  296.     /* hh und vv enthalten die gerundete Pixel-Position links oben */
  297.  
  298. #ifdef OLD_NO_OFFSET_VARS
  299.  
  300.     if (landscape) {
  301.       // wird spaeter noch gedreht, also jetzt etwas seltsame Offsets
  302.       x = hh + hconvresolution + bmap->hoffset;    // plus 1 inch
  303.       y = vv + hoffset + bmap->voffset; 
  304.     }
  305.     else {
  306.       x = hh + hoffset + bmap->hoffset;
  307.       y = vv + voffset + bmap->voffset; 
  308.     }
  309.  
  310.     // die rechte Seite wird direkt neben die linke gesetzt.
  311.     // Dazu wird der hoffset der rechten abgezogen, da dort kein Offset mehr benoetigt wird.
  312.     // hoffset gibt es wirklich nur am linken Rand. Ansonsten hat man ja den moffset.
  313.  
  314.     if (twopage && !leftpage) x += paper_width + moffset - hoffset;
  315.  
  316. #else
  317.  
  318.     x = hh + bmap->hoffset + OffsetBitmap_X;
  319.     y = vv + bmap->voffset + OffsetBitmap_Y; 
  320.  
  321. #endif
  322.  
  323.  
  324.     if (x < 0) {
  325.       Warning(MSG_PICT_OUT_LEFT,x);
  326.       xstart = (15-x)/16;    /* weglassen von Vielfachen von 16Bit (Word) */
  327.       x += xstart*16;
  328.     }
  329.  
  330.     switch (bmap->where_is) {
  331.       case LOC_BITMAP:
  332.       case LOC_BITMAP_BORDER:
  333.         //copy = 0;
  334.         width = (bmap->width + 15) / 16;    /* width in Words */
  335.         height = bmap->height;
  336.         y -= height;
  337.         xend = width;
  338.  
  339.         if (x+width*16 > map.width) {
  340.           Warning(MSG_PICT_OUT_RIGHT);
  341.           xend = width - (((x+width*16-map.width)+15)/16);
  342.         }
  343.  
  344.         xoff  = x >> 4;
  345.         shift = x - (xoff << 4);
  346.  
  347.         pagewidth = map.width >> 4;
  348.  
  349.     /* Test ob Bild im sichtbaren Bereich */
  350.     if (y >= lower_limit || y + height < upper_limit) {
  351.       break;
  352.     }
  353.  
  354.     /* Test oberer Rand */
  355.     if (y < upper_limit) {
  356.       ystart = upper_limit - y;
  357.           page  = ((unsigned short *)map.pixptr) + xoff;
  358.           image = (unsigned short *)bmap->loc.map + xstart + (width*ystart);
  359.     }
  360.     else {
  361.       ystart = 0;
  362.           page  = ((unsigned short *)map.pixptr) + (y-upper_limit) * pagewidth + xoff;
  363.           image = (unsigned short *)bmap->loc.map + xstart;
  364.     }
  365.  
  366.  
  367.     /* Test unterer Rand */
  368.         if (y + height >= lower_limit) {
  369.           height = lower_limit - y - 1;
  370.           /* height -= (lower_limit - y); that's a bug !! */
  371.         }
  372.         
  373.         for (ypos = ystart; ypos < height; ypos++) {
  374.           for (xpos = xstart; xpos < xend; xpos++) {
  375.             it = *((unsigned short *)image+xpos);
  376.             copy = ((unsigned long)it) << 16;
  377.             insert = (unsigned long *)(page + xpos);
  378.             *insert |= (copy >> shift); 
  379.           }
  380.           image += width;
  381.           page += pagewidth;
  382.         }
  383.         if (bmap->where_is == LOC_BITMAP_BORDER) {
  384.           draw_border(bmap);
  385.         }
  386.         break;
  387.  
  388.       case LOC_FILE:
  389.       case LOC_FILE_BORDER:
  390.         if ((iffile = fopen(bmap->loc.filename,"r")) != NULL) {
  391.       if (fread((char *)&buffer,4,1,iffile) == 1 && buffer == MAGIC_WORD) {
  392.         (void)fread((char *)&buffer,4,1,iffile);
  393.         if (fread((char *)&buffer,4,1,iffile) == 1) {
  394.               width = (buffer+15) / 16;            /* in words */
  395.               width_bit = buffer;
  396.           xend = width;
  397.           if (x+width*16 > map.width) {
  398.             Warning(MSG_PICT_OUT_RIGHT);
  399.             xend = width - (((x+width*16-map.width)+15)/16);
  400.           }
  401.  
  402.           if (fread((char *)&buffer,4,1,iffile) == 1) {
  403.                 height = buffer;
  404.             y -= height;
  405.                 if ((line = xmalloc(width*2)) == NULL) {
  406.                   Warning(MSG_NO_MEM_FOR_SPECIAL_BITMAP);
  407.                 }
  408.                 else {
  409.           xoff  = x >> 4;
  410.           shift = x - (xoff << 4);
  411.                 pagewidth = map.width >> 4;
  412.  
  413.           /* Test on Bild im sichtbaren Bereich */
  414.           if (y > lower_limit || y + height < upper_limit) {
  415.             fclose(iffile);
  416.             break;
  417.           }
  418.  
  419.           /* Test oberer Rand */
  420.           if (y < upper_limit) {
  421.             ystart = upper_limit - y;
  422.             page  = ((unsigned short *)map.pixptr) + xoff;
  423.             fseek(iffile,width * 2 * ystart, 1);    /* seek from actuall pos */
  424.           }
  425.           else {
  426.             page  = ((unsigned short *)map.pixptr) + (y-upper_limit) * pagewidth + xoff;
  427.             ystart = 0;
  428.           }
  429.  
  430.           /* Test unterer Rand */
  431.               if (y + height > lower_limit) {
  432.                 height = lower_limit - y;
  433.               }
  434.  
  435.           for (ypos = ystart; ypos < height; ypos++) {
  436.             if (fread((char *)line,2,width,iffile) == width) {
  437.               image = (unsigned short *)line+xstart;
  438.               for (xpos = xstart; xpos < xend; xpos++) {
  439.                 it = *((unsigned short *)image+xpos);
  440.                 copy = ((unsigned long)it) << 16;
  441.                 insert = (unsigned long *)(page + xpos);
  442.                 *insert |= (copy >> shift); 
  443.               }
  444.               page += pagewidth;
  445.             }
  446.           }
  447.           xfree(line);
  448.                 }
  449.             if (bmap->where_is == LOC_FILE_BORDER) {
  450.               bmap->width = width_bit;
  451.               bmap->height = height;
  452.               draw_border(bmap);
  453.             }
  454.               }
  455.         }
  456.       }
  457.           fclose(iffile);
  458.         }
  459.         break;
  460.  
  461.       case LOC_BORDER:
  462.         draw_border(bmap);
  463.         break;
  464.  
  465.       case LOC_RECTANGLE:
  466.         width = bmap->width;        /* width in Bits */
  467.         height = bmap->height;
  468.         width = ((long)(((double)width/(double)hconvresolution)*72.27+0.5))<<16;
  469.         height = ((long)(((double)height/(double)vconvresolution)*72.27+0.5))<<16;
  470.     vv += bmap->voffset;
  471.     hh += bmap->hoffset;
  472.     SetRule(height, width, FALSE);
  473.     vv -= bmap->voffset;
  474.     hh -= bmap->hoffset;
  475.         break;
  476.  
  477.       case LOC_NONE:
  478.         break;
  479.  
  480.       default:
  481.           Warning(MSG_UNKNOWN_PICT_LOC);
  482.           break;
  483.     }
  484.   }
  485.  
  486.   special_ok();
  487. }
  488.  
  489.  
  490.  
  491. #define    MAXPOINTS    300            /* Max points in a path */
  492. #define    TWOPI        (3.14159265359*2.0)
  493.  
  494.  
  495. static long xx[MAXPOINTS], yy[MAXPOINTS];    /* Path in milli-inches */
  496. static long path_len = 0;            /* # points in current path */
  497.  
  498. static char whiten = FALSE, blacken = FALSE;
  499. static long pen_size = 0L;
  500. static long shade;        /* float *1000 */
  501.  
  502. static struct tpic_msg tp;
  503.  
  504.  
  505. extern struct bitmap map;
  506. extern long upper_limit;
  507. extern long lower_limit;
  508.  
  509.  
  510. static int handle_tpic_command(int tpic, char *p)
  511. {
  512.   long ps;
  513.   long pathx, pathy;
  514.   float f;
  515.   int err = FALSE;
  516.  
  517.   switch (tpic) {
  518.     case TPIC_PN :                /* "pn " */
  519.       p += 2;
  520.       if (sscanf(p, "%ld", &ps) != 1) {
  521.         Warning(MSG_ILLEG_PS_COMM, p);
  522.         err = TRUE;
  523.       }
  524.       else {
  525.         pen_size = ps;
  526.       }
  527.       break;
  528.     case TPIC_PA :                /* "pa " */
  529.       p += 2;
  530.       if (path_len >= MAXPOINTS-1) {
  531.         Warning(MSG_TOO_MANY_POINTS, p);
  532.         err = TRUE;
  533.       }
  534.       else {
  535.         if (sscanf(p, "%ld %ld", &pathx, &pathy) != 2) {
  536.           Warning(MSG_MALFORMED_PATH_COMM, p);
  537.           err = TRUE;
  538.         }
  539.         else {
  540.           path_len++;        /* naja, beginen wir halt bei 1 (?) */
  541.           xx[path_len] = pathx;
  542.           yy[path_len] = pathy;
  543.         }
  544.       }
  545.       break;
  546.     case TPIC_FP :                /* "fp"  */
  547.     case TPIC_IP :                /* "ip"  */
  548.       err = call_tpic_command(tpic, p);
  549.       path_len = 0;
  550.       break;
  551.     case TPIC_DA :                /* "da " */
  552.     case TPIC_DT :                /* "dt " */
  553.     case TPIC_SP :                /* "sp"  */
  554.     case TPIC_SPB:                /* "sp " */
  555.       p += 2;
  556.       err = call_tpic_command(tpic, p);
  557.       path_len = 0;
  558.       break;
  559.     case TPIC_AR :                /* "ar " */
  560.     case TPIC_IA :                /* "ia " */
  561.       p += 2;
  562.       err = call_tpic_command(tpic, p);
  563.       break;
  564.     case TPIC_SH :                /* "sh"  */
  565.       blacken = whiten = FALSE;
  566.       shade = 5000;
  567.       break;
  568.     case TPIC_SHB:                /* "sh " */
  569.       p += 2;
  570.       blacken = whiten = FALSE;        /* noch nicht ganz korrekt... */
  571.       if (sscanf(p, "%f", &f) != 1) {
  572.         Warning(MSG_ILLEG_PS_COMM, p);
  573.         err = TRUE;
  574.       }
  575.       else {
  576.         shade = (long)(f*10000.0);
  577.       }
  578.       break;
  579.     case TPIC_WH :                /* "wh"  */
  580.       whiten = TRUE;
  581.       blacken = FALSE;
  582.       shade = 0;
  583.       break;
  584.     case TPIC_BK :                /* "bk"  */
  585.       blacken = TRUE;
  586.       whiten = FALSE;
  587.       shade = 10000;
  588.       break;
  589.     case TPIC_TX :                /* "tx"  */
  590.       break;
  591.   }
  592.   return err;
  593. }
  594.  
  595.  
  596. static int call_tpic_command(int tpic, char *p)
  597. {
  598.   int err = FALSE;
  599.   float f;
  600.   long t;
  601.   long x, y, rx, ry;
  602.   float s, e;
  603.  
  604.   tp.tpic_com     = tpic;
  605.   tp.whiten     = whiten;
  606.   tp.blacken     = blacken;
  607.   tp.shade     = shade;
  608.   tp.pen_size     = pen_size;
  609.   tp.path_len     = path_len;
  610.   tp.xx         = xx;
  611.   tp.yy         = yy;
  612.   tp.opt_long[0] = tp.opt_long[1] = tp.opt_long[2] = tp.opt_long[3] = 0;
  613.   tp.opt_float[0][0] = tp.opt_float[1][0] = '\0';
  614.  
  615.   switch (tpic) {
  616.     case TPIC_FP :                /* "fp"  */
  617.     case TPIC_IP :                /* "ip"  */
  618.       break;
  619.  
  620.     case TPIC_DA :                /* "da " */
  621.     case TPIC_DT :                /* "dt " */
  622.       if (sscanf(p, "%f", &f) != 1) {
  623.         Warning(MSG_ILLEG_PS_COMM, p);
  624.         err = TRUE;
  625.       }
  626.       else {
  627.         sprintf(tp.opt_float[0], "%10.5g", f);
  628.       }
  629.       break;
  630.  
  631.     case TPIC_SPB:                /* "sp " */
  632.       if (sscanf(p, "%ld", &t) != 1) {
  633.         Warning(MSG_ILLEG_PS_COMM, p);
  634.         err = TRUE;
  635.       }
  636.       else {
  637.         tp.opt_long[0] = t;
  638.       }
  639.       break;
  640.  
  641.     case TPIC_SP :                /* "sp"  */
  642.       tp.opt_long[0] = 0;
  643.       break;
  644.  
  645.     case TPIC_AR :                /* "ar " */
  646.     case TPIC_IA :                /* "ia " */
  647.       if (sscanf(p, "%ld %ld %ld %ld %f %f", &x, &y, &rx, &ry, &s, &e) != 6) {
  648.         Warning(MSG_ILLEG_PS_COMM, p);
  649.         err = TRUE;
  650.       }
  651.       else {
  652.         tp.opt_long[0] = x;
  653.         tp.opt_long[1] = y;
  654.         tp.opt_long[2] = rx;
  655.         tp.opt_long[3] = ry;
  656.         sprintf(tp.opt_float[0], "%10.5g", s);
  657.         sprintf(tp.opt_float[1], "%10.5g", e);
  658.       }
  659.       break;
  660.   }
  661.   send_tpic(&tp);
  662.   
  663.   return err;
  664. }
  665.  
  666.