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