home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 340.lha / ftek / tek.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-26  |  20.7 KB  |  863 lines
  1. /* This module is a minimum extenal hooks tek 4010 emulation, the
  2.  
  3.  * function OpenTek {InitTek()} must be called before any of the others, it
  4.  * assumes that gfx, intuition are open. Tek() returns true if it
  5.  * uses the input stream else false. It must be called before any
  6.  * character parsing or you could get into trouble. CloseTek() Frees
  7.  * up all resources used by this module */
  8.  
  9. /* I had to invent a few commands for area fill reset screen, and
  10.  * color setting. Any one who knows the correct commands please let me
  11.  * know  the line drawing and color index selection are standard commands.
  12.  * I have vax software to drive the 640x400 mode, and it works really well.
  13.  * the 1024x780 mode is not quite as clear, but works ok.
  14.  * The author of this software can be contacted as:
  15.  * T.Whelan
  16.  * Dept. of Physics & Astronomy
  17.  * University of Iowa
  18.  * Iowa City
  19.  * IA 52244
  20.  * and on span at IOWA::WHELAN
  21.  
  22.  * on the "to do" list, are graphic input mode and run time selection
  23.  * of the screen resolution. */
  24.  
  25. /******************************************************************/
  26. /*        More Mods added by NG    4-88 - Now built on top of vt100 v2.8
  27. /*        Mods added by NG    4-87 - Now built on top of vt100 v2.6
  28. /******************************************************************/
  29.  
  30. /*  compiler directives to fetch the necessary header files */
  31.  
  32. #include <stdio.h>
  33. #include <ctype.h>
  34. #include <typedefs.h>
  35. #include "tek.h"
  36.  
  37. /* externs from ftek.c */
  38. extern MENU Menu[];
  39. extern WIN *Win;
  40.  
  41. /*********************** tek defaults *******************************/
  42.  
  43. int    t_scale = 0; /* 0->1024x780    1->640x400 resolution    */
  44. int    t_on    = 0; /* 0 = no    1 = yes  come up with tek screen on */
  45. int    t_depth = 1; /* depth of tek screen                    */
  46. int    t_interlace = 1; /* interlace tek screen  0=no    1=yes    */
  47.  
  48. /*    new for v2.85    */
  49.  
  50. int t_font_size = 8; /* use topaz in this font size for tek window    */
  51.  
  52. /********************************************************************/
  53.  
  54. int TekMode = FALSE;
  55.  
  56. /* global pointers, used only in this code module */
  57.  
  58. MENU tekmenu[2];
  59. struct Screen       *TekScreen;
  60. struct Window       *TekWindow;
  61. void *TekFillRas;    /* was an int * in 1.1    */
  62. int Tek_screen_open = 0;    /* new variable added by NG    */
  63. extern void * AllocRaster();    /* was an int * in 1.1  */
  64. int dx = 8;
  65. int dy = 10;
  66.  
  67. /* macros... */
  68. #define mrp TekWindow->RPort
  69. #define COLOR(i, j, k, l) SetRGB4(&TekScreen->ViewPort, i, j, k, l)
  70.  
  71.  
  72. /* this macro puts the tek screen at the back
  73.  * and sets things so that the user gets the
  74.  * non-tek mode of operation, there are some problems here
  75.  * as we do not use intuition to control window positions */
  76.  
  77. #define TekOFF() {TekMode = FALSE; \
  78.         ScreenToBack(TekScreen); }
  79.  
  80. #define clear() SetRast(mrp, 0L); /* set the screen to color Zero */
  81.  
  82. /* the screen size */
  83. #define TXMIN 0
  84. #define TYMIN 0
  85. #define TXMAX 640        /* changed from old tek version     */
  86. #define TYMAX 400
  87.  
  88. int real_txmax = TXMAX;
  89. int real_tymax = TYMAX;
  90.  
  91. struct DiskfontBase *DiskfontBase;
  92. struct TextAttr tek_Attr = { (STRPTR)"topaz.font",8,0,0 };
  93. struct TextFont *tekf;
  94.  
  95. struct NewScreen TekNewScreen = {
  96.    TXMIN, TYMIN,
  97.    TXMAX, TYMAX, 1,            /* 1 bit plane is now the default */
  98.    0, 1,
  99.    HIRES|INTERLACE,        /* now the default    */
  100.    CUSTOMSCREEN,
  101.    NULL,
  102.    NULL,
  103.    NULL,
  104.    NULL
  105.    };
  106.  
  107. struct NewWindow TekNewWindow = {
  108.    TXMIN, TYMIN + 1,    /* allow one pixel space at top for screen access */
  109.    TXMAX, TYMAX - 1,
  110.    1, 0,
  111.    RAWKEY,    /* No IDCMP flags */
  112.    BORDERLESS|NOCAREREFRESH|SMART_REFRESH,
  113.    NULL,
  114.    NULL,
  115.    NULL,
  116.    NULL,
  117.    NULL,
  118.    0, 0,
  119.    0, 0,
  120.    CUSTOMSCREEN
  121.    };
  122.  
  123. /********  tek menu stuff  *******/
  124. struct MenuItem TekItem[TekParamsMax];
  125. struct IntuiText TekText[TekParamsMax];
  126. struct MenuItem TekScaleItem[TekScaleMax];
  127. struct IntuiText TekScaleText[TekScaleMax];
  128. struct MenuItem TekDepthItem[TekDepthMax];
  129. struct IntuiText TekDepthText[TekDepthMax];
  130. struct MenuItem TekInterlaceItem[TekInterlaceMax];
  131. struct IntuiText TekInterlaceText[TekInterlaceMax];
  132. struct MenuItem TekScreenItem[TekScreenMax];
  133. struct IntuiText TekScreenText[TekScreenMax];
  134. struct MenuItem TekSelectItem[TekSelectMax];
  135. struct IntuiText TekSelectText[TekSelectMax];
  136.  
  137.  
  138. /* initalize the window and screen needed for this mode
  139.  * inituition and gfx are assumed open */
  140. /* was called InitTek in old version - now this function just opens
  141. the tek screen so rename it    */
  142.  
  143. OpenTek(HisPort)
  144. struct MsgPort *HisPort;
  145. {
  146. static struct AreaInfo ai;
  147. static WORD buffer[250];
  148. static struct TmpRas tr;
  149.  
  150. if(Tek_screen_open == 1)
  151.     return(FALSE);
  152.  
  153. /* for morerows compatibility    */
  154. real_txmax = TekNewScreen.Width = GfxBase->NormalDisplayColumns;
  155. real_tymax = TekNewScreen.Height = 2 * GfxBase->NormalDisplayRows;
  156.  
  157. TekScreen = (struct Screen *)OpenScreen(&TekNewScreen);
  158. if (TekScreen == NULL) {
  159.     puts("Cannot open Tek screen\n");
  160.     return TRUE;
  161. }
  162.  
  163. TekNewWindow.Screen = TekScreen;
  164.  
  165. /* for morerows compatibility    */
  166. TekNewWindow.Width = real_txmax;
  167. TekNewWindow.Height = real_tymax - 1;
  168.  
  169. TekWindow = (struct Window *)OpenWindow(&TekNewWindow);
  170. if (TekWindow == NULL){
  171.     puts("Cannot open Tek window\n");
  172.     return TRUE;
  173. }
  174.  
  175. DiskfontBase = (struct DiskfontBase *) OpenLibrary("diskfont.library",0L);
  176. if(DiskfontBase != NULL) {
  177.     /* set up desired font    */
  178.     tek_Attr.ta_YSize = t_font_size;
  179.     tekf = (struct TextFont *) OpenDiskFont(&tek_Attr);
  180.     if(tekf  != NULL) {
  181.         SetFont(mrp,tekf);
  182.         dx = tekf->tf_XSize;
  183.         dy = tekf->tf_YSize;
  184.     }
  185. }
  186.  
  187. /* make HisPort the User Port for this window, so that his
  188.  * read routines will work when my screen is active
  189.  */
  190. TekWindow->UserPort = HisPort;
  191. ModifyIDCMP(TekWindow, RAWKEY|MENUPICK);
  192.  
  193.  
  194. /* allow for area fill */
  195. InitArea (&ai, buffer, 100L);
  196. mrp->AreaInfo = &ai;
  197. TekFillRas = AllocRaster((long)real_txmax, (long)real_tymax);
  198.  
  199. InitTmpRas(&tr, TekFillRas, RASSIZE((long)real_txmax, (long)real_tymax));
  200.  
  201. reset();
  202.  
  203. TekOFF();
  204. Tek_screen_open = 1;    /* added by NG    */
  205. return FALSE; /* no errors detected */
  206. }
  207.  
  208.  
  209. InitTekDev(HisWin)
  210. WIN *HisWin;
  211. {
  212. if(t_on == 1)
  213.     OpenTek(HisWin->UserPort);
  214. }
  215.  
  216. CloseTek()
  217. {
  218.  if(Tek_screen_open == 0)
  219.     return;
  220.  TekMode = FALSE;
  221.  FreeRaster(TekFillRas,(long)real_txmax,(long)real_tymax);
  222.  TekWindow->UserPort = NULL; /* I will not close his port */
  223.  CloseWindow(TekWindow);
  224.  CloseScreen(TekScreen);
  225.  if(DiskfontBase != NULL) {
  226.     CloseLibrary(DiskfontBase);
  227.  }
  228.  if(tekf != NULL) {
  229.     CloseFont(tekf);
  230.  }
  231.  Tek_screen_open = 0;
  232. }
  233.  
  234.  
  235. /*************************************************
  236. * Function to do tek 4010 graphics and mode
  237. * switching, the function returns false if it
  238. * uses the character else the
  239. * character can be used for something else
  240. *************************************************/
  241.  
  242.  
  243. int Tek(c)
  244. char c;
  245. {
  246.     static int x = TXMIN, xl;
  247.     static int y = TYMIN, yl;
  248.     static int last, escmode = FALSE, boxmode = FALSE;
  249.     static int loy, hix, hiy;
  250.  
  251.     static int        mode;
  252.  
  253.     static colormode = NULL, index, red, green;
  254.     static int tk4100 = NULL;
  255.     static int ic = 1;
  256.     static int lastc = 1;
  257.  
  258.     if (TekMode) goto top;
  259.     if (c == GS) {
  260.     TekMode = TRUE;
  261.     if(Tek_screen_open == 0)
  262.         return TRUE;
  263.     ScreenToFront(TekScreen);
  264.     mode = MOVE;
  265.     }
  266.     return TekMode; /* i.e. if c == GS we used it and can leave */
  267. top:
  268. /* first handle case if graph is sent without having the tek screen
  269.  * turned on; just eat the graphics commands until the graph is
  270.  * finished - then turn back to text mode
  271.  * also make this selanar compatible
  272.   */
  273.     if(Tek_screen_open == 0) {
  274.     if((c == CAN) || ((lastc == ESC) && (c == '2')))
  275.         TekMode = FALSE;         /* turn tek mode off   */
  276.     lastc = c;
  277.     return TRUE;
  278.     }
  279. /*
  280.     if(mode == ALPHA) {
  281.     emit(c);
  282.     emit(CR);
  283.     emit(LF);
  284.     }
  285. */
  286.  
  287.     if(escmode){
  288.     if(colormode != (int)NULL){
  289.        c = c - '0';
  290.        colormode++;
  291.        if(colormode == 2)
  292.            index = c;
  293.        else if(colormode == 3)
  294.            red = c;
  295.        else if(colormode == 4)
  296.            green = c;
  297.        else if(colormode == 5){
  298.            COLOR((long)index, (long)red, (long)green, (long)c);
  299.            colormode = NULL;
  300.            escmode = FALSE;
  301.        }
  302.        return TekMode;
  303.     }
  304.     switch (c) {
  305.         case '2':    /* Selanar Compatable graphics terminator */
  306.         TekOFF();
  307.         boxmode = FALSE;
  308.         break;
  309. /* I do not know what the tek 4100 area fill commands are so I made-up
  310.    my own, this will not harm the line drawing mode. */
  311.         case 'A':
  312.         boxmode = TRUE;
  313.         break;
  314.         case 'B':
  315.         boxmode = FALSE;
  316.         break;
  317.         case 'Q':
  318.         colormode = 1;
  319.         return TekMode;
  320. /* another one of my own commands */
  321.         case 'R':   /* reset to default then clear screen */
  322.         reset();
  323.         ic = 1;
  324.         case 12:     /* clear page */
  325.         x = TXMIN;
  326.         y = TYMIN + dy;
  327.         mode = ALPHA;
  328.         tk4100 = NULL;
  329.         clear();
  330.         break;
  331.         case 'M':  /* looks like a 4100 command */
  332.         tk4100 = 'M';
  333.         break;
  334.     }
  335.     escmode = FALSE;
  336.     } else if (tk4100 != (int)NULL){
  337.     if(tk4100 == COLORSET){
  338.         ic = c - '0';
  339.         SetAPen(mrp, (long)ic);
  340.     }
  341.     if(tk4100 == 'M' && c == 'L')
  342.         tk4100 = COLORSET;
  343.     else
  344.         tk4100 = NULL;
  345.     } else if (c >= ' ')
  346.     if (mode == ALPHA){
  347.         if(xl > real_txmax-dx) xl = real_txmax-dx;
  348.         if(xl < TXMIN) xl = TXMIN;
  349.         if(yl < TYMIN+dy) yl = TYMIN+dy;
  350.         if(yl > real_tymax) yl = real_tymax;
  351.         SetAPen(mrp, 1L);
  352.         Move(mrp,(long)xl,(long)yl);
  353.         Text(mrp,&c,1L);
  354.         SetAPen(mrp, (long)ic);
  355.         xl += dx;
  356.         if (xl > real_txmax) xl = real_txmax;
  357.     } else if(mode & INCREMENTAL)
  358.         switch(c){
  359.         case ' ':
  360.             mode |= MOVE;
  361.             mode &= ~LINE;
  362.             break;
  363.         case 'P':
  364.             mode |= LINE;
  365.             mode &= ~MOVE;
  366.             break;
  367.         case 'D':
  368.             yl += 1;
  369.             goto doit;
  370.         case 'E':
  371.             xl += 1;
  372.             yl += 1;
  373.             goto doit;
  374.         case 'A':
  375.             xl += 1;
  376.             goto doit;
  377.         case 'I':
  378.             xl += 1;
  379.             yl -= 1;
  380.             goto doit;
  381.         case 'H':
  382.             yl -= 1;
  383.             goto doit;
  384.         case 'J':
  385.             xl -= 1;
  386.             yl -= 1;
  387.             goto doit;
  388.         case 'B':
  389.             xl -= 1;
  390.             goto doit;
  391.         case 'F':
  392.             xl -= 1;
  393.             yl += 1;
  394.             goto doit;
  395.         default:
  396.             printf("Bad incremental command: %c\n",c);
  397.             break;
  398. doit:
  399.         if(mode & LINE)
  400.             Draw(mrp,(long)xl,(long)yl);
  401.         else if(mode & MOVE)
  402.             Move(mrp,(long)xl,(long)yl);
  403.         else
  404.             printf("Bad mode: %d\n",mode);
  405.         }
  406.     else{
  407.  
  408.     /* a note here about 4014 graphics, If your graphics software
  409.        drives a Tek 4014 then this will work perfecly well, you
  410.        just will not be able to use the 4096 pixel resolution
  411.        that that big storage tube device offers */
  412.  
  413.         register int tag, data, x, y;
  414.  
  415.         tag = c/32;
  416.         data = c - tag*32;
  417.         switch (tag){
  418.         case 1:
  419.             if (last == 3)
  420.             hix = data*32;
  421.             else
  422.             hiy = data*32;
  423.             break;
  424.         case 2:
  425.             x = hix + data;   /* low x always sent so don't save it */
  426.             y = hiy + loy;
  427.             if (t_scale == 0){
  428.             x = (((float)x)*real_txmax)/1024;
  429.             y = (((float)y)*real_tymax)/780;
  430.             }
  431.             x = x/(2-t_interlace);
  432.             y = (real_tymax-1) -  (y/(2-t_interlace));
  433.             if(x > real_txmax) x = real_txmax;
  434.             if(x < TXMIN) x = TXMIN;
  435.             if(y > real_tymax) y = real_tymax;
  436.             if(y < TYMIN) y = TYMIN;
  437.             switch (mode){
  438.             case MOVE:
  439.                 mode = LINE;
  440.                 Move(mrp, (long)x, (long)y);
  441.                 break;
  442.             case LINE:
  443.                 if (boxmode)
  444.                 RectFill(mrp, (long)min((int)xl,(int)x),
  445.                 (long)min((int)yl,(int)y), (long)max((int)xl,(int)x),
  446.                 (long)max((int)yl,(int)y));
  447.                 else
  448.                 Draw(mrp, (long)x, (long)y);
  449.                 break;
  450.                case POINT:
  451.                 WritePixel(mrp, (long)x, (long)y);
  452.                 break;
  453.             }
  454.             xl = x;
  455.             yl = y;
  456.             break;
  457.         case 3:
  458.             loy = data;
  459.             break;
  460.         }
  461.         last = tag;
  462.     }
  463.     else switch(c){
  464.     case BEL:     /* bell */
  465.         DisplayBeep(NULL);
  466.         break;
  467.     case BS:   /* backspace */
  468.         x -= dx;
  469.         if (x < TXMIN) x = TXMIN;
  470.         break;
  471.     case HT:  /* cursor right */
  472.         x += dx;
  473.         if (x > real_txmax) x = real_txmax;
  474.         break;
  475.     case LF: /* NL */
  476.         y += dy;
  477.         if (y > real_tymax) y = real_tymax;
  478.         break;
  479.     case VT: /* cursor up */
  480.         y -= dy;
  481.         if (y < TYMIN+dy) y = TYMIN+dy;
  482.         break;
  483.     case CR:  /* CR */
  484.         x = TXMIN;
  485.         break;
  486.     case CAN:  /* CAN */
  487.         TekOFF();
  488.         boxmode = FALSE;
  489.         break;
  490.     case ESC:  /* ESC */
  491.         escmode = TRUE;
  492.         break;
  493.     case FS:  /* FS (point-plot) */
  494.         mode = POINT;
  495.         break;
  496.     case GS:  /* GS vector */
  497.         mode = MOVE;
  498.         break;
  499.     case US: /* US alpha mode */
  500.         mode = ALPHA;
  501.         break;
  502.     case RS:  /* GS vector */
  503.         mode |= INCREMENTAL;
  504.         break;
  505.     default:
  506.        /*   TekOFF();
  507.         return FALSE; */
  508.         break;
  509.       } /* end of switch */
  510.       return TRUE;
  511. }
  512.  
  513. reset()
  514. {
  515. /* mess up the colors */
  516. COLOR(0L, 0L, 0L, 0L);
  517. COLOR(1L, 15L, 15L, 15L);
  518. COLOR(2L, 15L, 0L, 0L);
  519. COLOR(3L, 0L, 15L, 0L);
  520. COLOR(4L, 0L, 0L, 15L);
  521. COLOR(5L, 0L, 15L, 15L);
  522. COLOR(6L, 15L, 0L, 15L);
  523. COLOR(7L, 15L, 15L, 0L);
  524. COLOR(8L, 15L, 8L, 0L);
  525. COLOR(9L, 8L, 15L, 0L);
  526. COLOR(10L,0L, 15L, 8L);
  527. COLOR(11L,0L, 8L, 15L);
  528. COLOR(12L,8L, 0L, 15L);
  529. COLOR(13L,15L, 0L, 8L);
  530. COLOR(14L,5L, 5L, 5L);
  531. COLOR(15L,10L, 10L, 10L);
  532.  
  533. clear();
  534. SetAPen(mrp, 1L);
  535. }
  536.  
  537. max(a,b)
  538. int a,b;
  539. {
  540. if(a >= b) return(a);
  541. return(b);
  542. }
  543.  
  544. min(a,b)
  545. int a,b;
  546. {
  547. if(a <= b) return(a);
  548. return(b);
  549. }
  550.  
  551. /*****************************************************************/
  552. /*    Intialize the structure arrays needed for
  553. /*        the Tek menu items
  554. /*****************************************************************/
  555. char keycommands[] = " TVEQ";
  556. char otherkeys[] = "NY";
  557.  
  558. void
  559. InitTekItems()
  560. {
  561.     int n;
  562.  
  563.     for(n=0; n<TekParamsMax; n++) {
  564.         TekItem[n].NextItem = &TekItem[n+1];
  565.         TekItem[n].LeftEdge = 0;
  566.         TekItem[n].TopEdge = 10 * n;
  567.         TekItem[n].Width = 100;
  568.         TekItem[n].Height = 10;
  569.         TekItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
  570.         TekItem[n].MutualExclude = 0;
  571.         TekItem[n].ItemFill = (APTR)&TekText[n];
  572.         TekItem[n].SelectFill = NULL;
  573.         TekItem[n].Command = 0;
  574.  
  575.         TekText[n].FrontPen = 0;
  576.         TekText[n].BackPen = 1;
  577.         TekText[n].DrawMode = JAM2;
  578.         TekText[n].LeftEdge = 0;
  579.         TekText[n].TopEdge = 1;
  580.         TekText[n].ITextFont = NULL;
  581.         TekText[n].NextText = NULL;
  582.     }
  583.     TekItem[TekParamsMax - 1].NextItem = NULL;
  584.  
  585.     TekText[0].IText = (UBYTE *)"Scale";
  586.     TekText[1].IText = (UBYTE *)"Screen Depth";
  587.     TekText[2].IText = (UBYTE *)"Interlace";
  588.     TekItem[0].SubItem = TekScaleItem;
  589.     TekItem[1].SubItem = TekDepthItem;
  590.     TekItem[2].SubItem = TekInterlaceItem;
  591.  
  592.     for(n=0; n<TekScaleMax; n++) {
  593.         TekScaleItem[n].NextItem = &TekScaleItem[n+1];
  594.         TekScaleItem[n].LeftEdge = 60;
  595.         TekScaleItem[n].TopEdge = 10 * n;
  596.         TekScaleItem[n].Width = 100;
  597.         TekScaleItem[n].Height = 10;
  598.         TekScaleItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  599.         TekScaleItem[n].MutualExclude = (~(1 << n));
  600.         TekScaleItem[n].ItemFill = (APTR)&TekScaleText[n];
  601.         TekScaleItem[n].SelectFill = NULL;
  602.         TekScaleItem[n].Command = 0;
  603.  
  604.         TekScaleText[n].FrontPen = 0;
  605.         TekScaleText[n].BackPen = 1;
  606.         TekScaleText[n].DrawMode = JAM2;
  607.         TekScaleText[n].LeftEdge = 0;
  608.         TekScaleText[n].TopEdge = 1;
  609.         TekScaleText[n].ITextFont = NULL;
  610.         TekScaleText[n].NextText = NULL;
  611.     }
  612.     TekScaleItem[TekScaleMax - 1].NextItem = NULL;
  613.  
  614.     switch(t_scale) {
  615.         case 0:
  616.             TekScaleItem[0].Flags |= CHECKED;
  617.             break;
  618.         case 1:
  619.             TekScaleItem[1].Flags |= CHECKED;
  620.             break;
  621.     }
  622.  
  623.     TekScaleText[0].IText = (UBYTE *)"   1028x780";
  624.     TekScaleText[1].IText = (UBYTE *)"   640x400";
  625.  
  626.     for(n=0; n<TekDepthMax; n++) {
  627.         TekDepthItem[n].NextItem = &TekDepthItem[n+1];
  628.         TekDepthItem[n].LeftEdge = 60;
  629.         TekDepthItem[n].TopEdge = 10 * n;
  630.         TekDepthItem[n].Width = 60;
  631.         TekDepthItem[n].Height = 10;
  632.         TekDepthItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  633.         TekDepthItem[n].MutualExclude = (~(1 << n));
  634.         TekDepthItem[n].ItemFill = (APTR)&TekDepthText[n];
  635.         TekDepthItem[n].SelectFill = NULL;
  636.         TekDepthItem[n].Command = 0;
  637.  
  638.         TekDepthText[n].FrontPen = 0;
  639.         TekDepthText[n].BackPen = 1;
  640.         TekDepthText[n].DrawMode = JAM2;
  641.         TekDepthText[n].LeftEdge = 0;
  642.         TekDepthText[n].TopEdge = 1;
  643.         TekDepthText[n].ITextFont = NULL;
  644.         TekDepthText[n].NextText = NULL;
  645.     }
  646.     TekDepthItem[TekDepthMax - 1].NextItem = NULL;
  647.  
  648.     TekDepthText[0].IText = (UBYTE *)"    1";
  649.     TekDepthText[1].IText = (UBYTE *)"    2";
  650.     TekDepthText[2].IText = (UBYTE *)"    3";
  651.     TekDepthText[3].IText = (UBYTE *)"    4";
  652.  
  653.     switch(t_depth) {
  654.         case 1:
  655.             TekDepthItem[0].Flags |= CHECKED;
  656.             break;
  657.         case 2:
  658.             TekDepthItem[1].Flags |= CHECKED;
  659.             break;
  660.         case 3:
  661.             TekDepthItem[2].Flags |= CHECKED;
  662.             break;
  663.         case 4:
  664.             TekDepthItem[3].Flags |= CHECKED;
  665.             break;
  666.     }
  667.  
  668.     for(n=0; n<TekInterlaceMax; n++) {
  669.         TekInterlaceItem[n].NextItem = &TekInterlaceItem[n+1];
  670.         TekInterlaceItem[n].LeftEdge = 60;
  671.         TekInterlaceItem[n].TopEdge = 10 * n;
  672.         TekInterlaceItem[n].Width = 60;
  673.         TekInterlaceItem[n].Height = 10;
  674.         TekInterlaceItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  675.         TekInterlaceItem[n].MutualExclude = (~(1 << n));
  676.         TekInterlaceItem[n].ItemFill = (APTR)&TekInterlaceText[n];
  677.         TekInterlaceItem[n].SelectFill = NULL;
  678.         TekInterlaceItem[n].Command = 0;
  679.  
  680.         TekInterlaceText[n].FrontPen = 0;
  681.         TekInterlaceText[n].BackPen = 1;
  682.         TekInterlaceText[n].DrawMode = JAM2;
  683.         TekInterlaceText[n].LeftEdge = 0;
  684.         TekInterlaceText[n].TopEdge = 1;
  685.         TekInterlaceText[n].ITextFont = NULL;
  686.         TekInterlaceText[n].NextText = NULL;
  687.     }
  688.     TekInterlaceItem[TekInterlaceMax - 1].NextItem = NULL;
  689.  
  690.     TekInterlaceText[0].IText = (UBYTE *)"   Off";
  691.     TekInterlaceText[1].IText = (UBYTE *)"   On";
  692.  
  693.     switch(t_interlace) {
  694.         case 0:
  695.             TekInterlaceItem[0].Flags |= CHECKED;
  696.             break;
  697.         case 1:
  698.             TekInterlaceItem[1].Flags |= CHECKED;
  699.             break;
  700.     }
  701.  
  702.  
  703.     for(n=0; n<TekScreenMax; n++) {
  704.         TekScreenItem[n].NextItem = &TekScreenItem[n+1];
  705.         TekScreenItem[n].LeftEdge = 0;
  706.         TekScreenItem[n].TopEdge = 10 * n;
  707.         TekScreenItem[n].Width = 140;
  708.         TekScreenItem[n].Height = 10;
  709.         TekScreenItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
  710.         TekScreenItem[n].MutualExclude = 0;
  711.         TekScreenItem[n].ItemFill = (APTR)&TekScreenText[n];
  712.         TekScreenItem[n].SelectFill = NULL;
  713.         if(n != 0) {
  714.             TekScreenItem[n].Command = keycommands[n];
  715.             TekScreenItem[n].Flags |= COMMSEQ;
  716.             }
  717.         else
  718.             TekScreenItem[n].Command = 0;
  719.  
  720.         TekScreenText[n].FrontPen = 0;
  721.         TekScreenText[n].BackPen = 1;
  722.         TekScreenText[n].DrawMode = JAM2;
  723.         TekScreenText[n].LeftEdge = 0;
  724.         TekScreenText[n].TopEdge = 1;
  725.         TekScreenText[n].ITextFont = NULL;
  726.         TekScreenText[n].NextText = NULL;
  727.     }
  728.     TekScreenItem[TekScreenMax - 1].NextItem = NULL;
  729.  
  730.     TekScreenText[0].IText = (UBYTE *)"  TekScreen";
  731.     TekScreenText[1].IText = (UBYTE *)"  Tek Front";
  732.     TekScreenText[2].IText = (UBYTE *)"  VT Front";
  733.     TekScreenText[3].IText = (UBYTE *)"  Erase";
  734.     TekScreenText[4].IText = (UBYTE *)"  Quit";
  735.  
  736.     TekScreenItem[0].SubItem = TekSelectItem;
  737.  
  738.     for(n=0; n<TekSelectMax; n++) {
  739.         TekSelectItem[n].NextItem = &TekSelectItem[n+1];
  740.         TekSelectItem[n].LeftEdge = 60;
  741.         TekSelectItem[n].TopEdge = 10 * n;
  742.         TekSelectItem[n].Width = 100;
  743.         TekSelectItem[n].Height = 10;
  744.         TekSelectItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT
  745.         | COMMSEQ;
  746.         TekSelectItem[n].MutualExclude = (~(1 << n));
  747.         TekSelectItem[n].ItemFill = (APTR)&TekSelectText[n];
  748.         TekSelectItem[n].SelectFill = NULL;
  749.         TekSelectItem[n].Command = otherkeys[n];
  750.  
  751.         TekSelectText[n].FrontPen = 0;
  752.         TekSelectText[n].BackPen = 1;
  753.         TekSelectText[n].DrawMode = JAM2;
  754.         TekSelectText[n].LeftEdge = 0;
  755.         TekSelectText[n].TopEdge = 1;
  756.         TekSelectText[n].ITextFont = NULL;
  757.         TekSelectText[n].NextText = NULL;
  758.     }
  759.     TekSelectItem[TekSelectMax - 1].NextItem = NULL;
  760.  
  761. /*    switch(t_on) {
  762.         case 0:
  763.             TekSelectItem[0].Flags |= CHECKED;
  764.             break;
  765.         case 1:
  766.             TekSelectItem[1].Flags |= CHECKED;
  767.             break;
  768.     }
  769. */
  770.  
  771.     TekSelectItem[t_on].Flags |= CHECKED;
  772.  
  773.     TekSelectText[0].IText = (UBYTE *)"    Off";
  774.     TekSelectText[1].IText = (UBYTE *)"    On";
  775. }
  776.  
  777. /****************************************************************/
  778. /*    The following function inits the Menu structure array with
  779. /*        the tek menu items
  780. /****************************************************************/
  781.  
  782. void
  783. InitTekMenu()
  784. {
  785. Menu[0].NextMenu = &tekmenu[0];
  786. tekmenu[0].NextMenu = &tekmenu[1];
  787. tekmenu[0].LeftEdge = 80;
  788. tekmenu[0].TopEdge = 0;
  789. tekmenu[0].Width = 85;
  790. tekmenu[0].Height = 10;
  791. tekmenu[0].Flags = MENUENABLED;
  792. tekmenu[0].MenuName = "Tek params";        /* text for menu-bar display */
  793. tekmenu[0].FirstItem = &TekItem[0]; /* pointer to first item in list */
  794.  
  795. tekmenu[1].NextMenu = NULL;
  796. tekmenu[1].LeftEdge = 180;
  797. tekmenu[1].TopEdge = 0;
  798. tekmenu[1].Width = 60;
  799. tekmenu[1].Height = 10;
  800. tekmenu[1].Flags = MENUENABLED;
  801. tekmenu[1].MenuName = "Screen";   /* text for menu-bar display */
  802. tekmenu[1].FirstItem = &TekScreenItem[0];  /* pointer to first item in list */
  803.  
  804. }
  805.  
  806. void
  807. t_cmd_scale(n)
  808. char *n;
  809. {
  810.     t_scale = atoi(n);
  811. }
  812.  
  813. void
  814. t_cmd_depth(n)
  815. char *n;
  816. {
  817.     if(t_depth != atoi(n)) {
  818.         t_depth = atoi(n);
  819.         if(Tek_screen_open == 1) {
  820.             CloseTek();
  821.             TekNewScreen.Depth = t_depth;
  822.             OpenTek(Win->UserPort);
  823.         }
  824.     }
  825. }
  826.  
  827. void
  828. t_cmd_on(n)
  829. char *n;
  830. {
  831.     if(t_on != atoi(n)) {
  832.         t_on = atoi(n);
  833.         if(t_on == 0)
  834.             CloseTek();
  835.         else
  836.             OpenTek(Win->UserPort);
  837.     }
  838. }
  839.  
  840. void
  841. t_cmd_interlace(n)
  842. char *n;
  843. {
  844.     if(t_interlace != atoi(n)) {
  845.         t_interlace = atoi(n);
  846.         if(Tek_screen_open == 1) {
  847.             CloseTek();
  848.             if(t_interlace == 0)
  849.                 TekNewScreen.ViewModes |= ~INTERLACE;
  850.             else
  851.                 TekNewScreen.ViewModes |= INTERLACE;
  852.             OpenTek(Win->UserPort);
  853.         }
  854.     }
  855. }
  856.  
  857. void
  858. t_cmd_font_size(n)
  859. char *n;
  860. {
  861.     t_font_size = atoi(n);
  862. }
  863.