home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / c / amivogl-1.03.lzh / vogl / drivers / tek.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-12  |  6.7 KB  |  434 lines
  1.  
  2. /*
  3.  *    Driver for tekronix 401x or equivalent
  4.  */
  5. #include <stdio.h>
  6. #ifdef BSD
  7. #include <sgtty.h>
  8. #else
  9. #include <sys/termio.h>
  10. #endif
  11. #include "vogl.h"
  12.  
  13. #define         MASK            037
  14. #define         BELL            '\007'
  15. #define         FF              '\014'
  16. #define         CAN             '\030'
  17. #define         SUB             '\032'
  18. #define         ESC             '\033'
  19. #define         GS              '\035'
  20. #define         US              '\037'
  21.  
  22. #define    TEK_X_SIZE        1023
  23. #define    TEK_Y_SIZE        767
  24.  
  25. #include <signal.h>
  26.  
  27. static int    LoYold = -1, HiYold = -1, HiXold = -1;
  28. static int    tlstx, tlsty;
  29. static int    click;            /* to emulate a mouse click */
  30.  
  31. /*
  32.  * noop
  33.  *
  34.  *      do nothing but return -1
  35.  */
  36. static int noop(void)
  37. {
  38.     return(-1);
  39. }
  40.  
  41. /*
  42.  * TEK_init
  43.  *
  44.  *    set up the graphics mode.
  45.  */
  46. int TEK_init(void)
  47. {
  48.     /*
  49.      *      actually only need to set modes in xhair and pause routines
  50.      */
  51.  
  52.     vdevice.depth = 1;
  53.  
  54.     putchar(GS);            /* enter graphics mode */
  55.  
  56.     vdevice.sizeX = vdevice.sizeY = TEK_Y_SIZE;
  57.     vdevice.sizeSx = TEK_X_SIZE;
  58.     vdevice.sizeSy = TEK_Y_SIZE;
  59.                   
  60.     tlstx = tlsty = -1;
  61.  
  62.         return(1);
  63. }
  64.  
  65.  
  66. /*
  67.  * TEK_exit
  68.  *
  69.  *    cleans up before going back to normal mode
  70.  */
  71. int TEK_exit(void)
  72. {
  73.     putchar(US);
  74.     putchar(CAN);
  75. }
  76.  
  77. /*
  78.  * out_bytes
  79.  *
  80.  *    output 2 optomized bytes to the terminal
  81.  */
  82. static out_bytes(
  83.   int x,
  84.   int y)
  85. {
  86.     int HiY, LoY, HiX, LoX;
  87.  
  88.     if (x < 0)            /* a bit of last minute checking */
  89.         x = 0;
  90.     if (y < 0)
  91.         y = 0;
  92.     if (x > 1023)
  93.         x = 1023;
  94.     if (y > 1023)
  95.         y = 1023;
  96.  
  97.     HiY = y / 32  +  32;
  98.     LoY = y % 32  +  96;
  99.     HiX = x / 32  +  32;
  100.     LoX = x % 32  +  64;
  101.  
  102.     /*
  103.      * optomize the output stream. Ref: Tektronix Manual.
  104.      */
  105.  
  106.     if (HiYold != HiY) {
  107.         printf("%c", HiY);
  108.         HiYold = HiY;
  109.     }
  110.  
  111.     if ((LoYold != LoY) || (HiXold != HiX)) {
  112.         printf("%c", LoY);
  113.         LoYold = LoY;
  114.         if (HiXold != HiX) {
  115.             printf("%c", HiX);
  116.             HiXold = HiX;
  117.         }
  118.     }
  119.  
  120.     printf("%c", LoX);
  121. }
  122.  
  123. /*
  124.  * TEK_draw
  125.  *
  126.  *    draw from the current graphics position to the new one (x, y)
  127.  */
  128. int TEK_draw(
  129.   int x,
  130.   int y)
  131. {
  132.     if (tlstx != vdevice.cpVx || tlsty != vdevice.cpVy) {
  133.         putchar(GS);
  134.         LoYold = HiYold = HiXold = -1;  /* Force output of all bytes */
  135.         out_bytes(vdevice.cpVx, vdevice.cpVy);
  136.     }
  137.  
  138.     out_bytes(x, y);
  139.     tlstx = x;
  140.     tlsty = y;
  141.  
  142.     fflush(stdout);
  143. }
  144.  
  145. /*
  146.  * TEK_getkey
  147.  *
  148.  *    return the next key typed.
  149.  */
  150. int TEK_getkey(void)
  151. {
  152. #ifdef BSD
  153.     struct sgttyb    oldtty, newtty;
  154.     char        c;
  155.  
  156.     ioctl(0, TIOCGETP, &oldtty);
  157.  
  158.     newtty = oldtty;
  159.     newtty.sg_flags = RAW;
  160.  
  161.     ioctl(0, TIOCSETP, &newtty);
  162.  
  163.     read(0, &c, 1);
  164.  
  165.     ioctl(0, TIOCSETP, &oldtty);
  166. #else
  167.     struct termio   oldtty, newtty;
  168.     char            c;
  169.       
  170.     ioctl(0, TCGETA, &oldtty);
  171.  
  172.     newtty = oldtty;
  173.     newtty.c_iflag = BRKINT | IXON | ISTRIP;
  174.     newtty.c_lflag = 0;
  175.     newtty.c_cc[VEOF] = 1;
  176.  
  177.     ioctl(0, TCSETA, &newtty);
  178.  
  179.     read(0, &c, 1);
  180.  
  181.     ioctl(0, TCSETA, &oldtty);
  182. #endif
  183.  
  184.     return(c);
  185. }
  186.  
  187. /*
  188.  * TEK_locator
  189.  *
  190.  *    get the position of the crosshairs. This gets a bit sticky since
  191.  * we have no mouse, and the crosshairs do not beahve like a mouse - even a rat!
  192.  * In this case the keys 1 to 9 are used, with each one returning a power of
  193.  * two.
  194.  */
  195. int TEK_locator(
  196.   int *x,
  197.   int *y)
  198. {
  199.     char        buf[5];
  200.     int        c, i;
  201. #ifdef BSD
  202.     struct sgttyb   oldtty, newtty;
  203. #else
  204.     struct termio   oldtty, newtty;
  205. #endif
  206.  
  207.     if (click) {            /* for compatability with other devs */
  208.         click = 0;
  209.         return(0);
  210.     }
  211.  
  212.     click = 1;
  213.  
  214. #ifdef BSD
  215.     ioctl(0, TIOCGETP, &oldtty);
  216.  
  217.     newtty = oldtty;
  218.     newtty.sg_flags = RAW;
  219.  
  220.     ioctl(0, TIOCSETP, &newtty);
  221. #else
  222.     ioctl(0, TCGETA, &oldtty);
  223.  
  224.     newtty = oldtty;
  225.     newtty.c_iflag = BRKINT | IXON | ISTRIP;
  226.     newtty.c_lflag = 0;
  227.     newtty.c_cc[VEOF] = 1;
  228.  
  229.     ioctl(0, TCSETA, &newtty);
  230. #endif
  231.  
  232.     fputs("\037\033\032", stdout); 
  233.     fflush(stdout);
  234.  
  235.     /* Tek 4010/4014 return 8 bytes upon cross-hair read:
  236.      *
  237.      *
  238.      *        0    character pressed
  239.      *
  240.      *        1,2    encoded x position
  241.      *        3,4    encoded y position
  242.      *        5,6    CR,LF        - ignored
  243.      *        7    EOF        - ignored
  244.      */
  245.  
  246.     /* first we read in the five meaningfull bytes */
  247.  
  248.     for (i = 0; i < 5; i++)
  249.         buf[i] = getchar();
  250.  
  251.     /* just in case we get the newline chars */
  252.  
  253. #ifdef BSD
  254.     ioctl(0, TIOCFLUSH, (char *)NULL);
  255. #else
  256.     ioctl(0, TCFLSH, (char *)NULL);
  257. #endif
  258.  
  259.     *x = ((buf[1] & MASK) << 5) | (buf[2] & MASK); 
  260.     *y = ((buf[3] & MASK) << 5) | (buf[4] & MASK);
  261.  
  262. #ifdef BSD
  263.     ioctl(0, TIOCSETP, &newtty);
  264. #else
  265.     ioctl(0, TCSETA, &oldtty);
  266. #endif
  267.  
  268.     tlstx = tlsty = -1;
  269.  
  270.     return(1 << ((int)buf[0] - '1'));
  271. }
  272.  
  273. /*
  274.  * TEK_clear
  275.  *
  276.  *    clear the screen.
  277.  *
  278.  *    NOTE - You may need to actually output a certain number of
  279.  *    NUL chars here to get the (at least) 1 second delay.
  280.  *    This may occur if running through a communication package
  281.  *    or with something like ethernet. If this is the case then
  282.  *    throw away the sleep(2) above and bung in a loop.
  283.  *    Here's a sample ...
  284.  *
  285.  *    for (i = 0; i < 960; i++) putchar(0);
  286.  *
  287.  *    (for 9600 baud rate)
  288.  *
  289.  */
  290. int TEK_clear(void)
  291. {
  292.     putchar(US);
  293.     putchar(ESC);
  294.     putchar(FF);
  295.     fflush(stdout);
  296.  
  297.     tlstx = tlsty = -1;
  298.  
  299.     sleep(2); /* for tekronix slow erase */
  300. }
  301.  
  302. /*
  303.  * TEK_font
  304.  *
  305.  *    set for large or small mode.
  306.  */
  307. int TEK_font(char *font)
  308. {
  309.     if (strcmp(font, "small") == 0) {
  310.         printf("\033:");
  311.         vdevice.hwidth = 8.0;
  312.         vdevice.hheight = 15.0;
  313.     } else if (strcmp(font, "large") == 0) {
  314.         printf("\0338");
  315.         vdevice.hwidth = 14.0;
  316.         vdevice.hheight = 17.0;
  317.     } else
  318.         return(0);
  319.  
  320.     tlstx = tlsty = -1;
  321.  
  322.     return(1);
  323. }
  324.  
  325. /*
  326.  * TEK_char
  327.  *
  328.  *    outputs one char
  329.  */
  330. int TEK_char(char c)
  331. {
  332.     if (tlstx != vdevice.cpVx || tlsty != vdevice.cpVy) {
  333.         putchar(GS);
  334.         LoYold = HiYold = HiXold = -1;  /* Force output of all bytes */
  335.         out_bytes(vdevice.cpVx, vdevice.cpVy);
  336.     }
  337.  
  338.     putchar(US);
  339.     putchar(c);
  340.  
  341.     tlstx = tlsty = -1;
  342.  
  343.     fflush(stdout);
  344. }
  345.  
  346. /*
  347.  * TEK_string
  348.  *
  349.  *    outputs a string
  350.  */
  351. int TEK_string(char *s)
  352. {
  353.     if (tlstx != vdevice.cpVx || tlsty != vdevice.cpVy) {    /* move to start */
  354.         putchar(GS);
  355.         LoYold = HiYold = HiXold = -1;  /* Force output of all bytes */
  356.         out_bytes(vdevice.cpVx, vdevice.cpVy);
  357.     }
  358.  
  359.     putchar(US);
  360.     fputs(s, stdout);
  361.  
  362.     tlstx = tlsty = -1;
  363.  
  364.     fflush(stdout);
  365. }
  366.  
  367. /*
  368.  * TEK_fill
  369.  *
  370.  *      "fill" a polygon
  371.  */
  372. int TEK_fill(
  373.   int n,
  374.   int x[],
  375.   int y[])
  376. {
  377.     int     i;
  378.  
  379.     if (tlstx != x[0] || tlsty != y[0]) {
  380.         putchar(GS);
  381.         LoYold = HiYold = HiXold = -1;  /* Force output of all bytes */
  382.         out_bytes(x[0], y[0]);
  383.     }
  384.  
  385.     for (i = 1; i < n; i++)
  386.         out_bytes(x[i], y[i]);
  387.  
  388.     out_bytes(x[0], y[0]);
  389.  
  390.     fflush(stdout);
  391.  
  392.     tlstx = vdevice.cpVx = x[n - 1];
  393.     tlsty = vdevice.cpVy = y[n - 1];
  394. }
  395.  
  396. /*
  397.  * the device entry
  398.  */
  399. static DevEntry    tekdev = {
  400.     "tek",
  401.     "large",
  402.     "small",
  403.     noop,
  404.     TEK_char,
  405.     noop,
  406.     TEK_clear,
  407.     noop,
  408.     TEK_draw,
  409.     TEK_exit,
  410.     TEK_fill,
  411.     TEK_font,
  412.     noop,
  413.     TEK_getkey,
  414.     TEK_init,
  415.     TEK_locator,
  416.     noop,
  417.     noop,
  418.     noop,
  419.     TEK_string,
  420.     noop,
  421.     noop
  422. };
  423.  
  424. /*
  425.  * _TEK_devcpy
  426.  *
  427.  *      copy the tektronix device into vdevice.dev.
  428.  */
  429. int _TEK_devcpy(void)
  430. {
  431.         vdevice.dev = tekdev;
  432. }
  433.  
  434.