home *** CD-ROM | disk | FTP | other *** search
/ Transactor / Transactor_26_1988_Transactor_Publishing.d64 / menus.c < prev    next >
Text File  |  2023-02-26  |  4KB  |  235 lines
  1. /* menus.c - menu routines */
  2. /* W Mat Waites - Sept 1988 */
  3.  
  4. #include <stdio.h>
  5.  
  6. /* globals */
  7. extern int done;
  8. extern int echo;
  9. extern int baud;
  10. extern int bpchar;
  11. extern int stopbits;
  12. extern int parity;
  13. extern int ddrive;
  14.  
  15. char *parval();
  16. char *dupval();
  17.  
  18. /* menu() - main menu */
  19. menu()
  20. {SHIFT-+}
  21.   int mdone = 0;
  22.   int kbchar;
  23.   char fname[21];
  24.  
  25.   /* draw menu */
  26.   erase();
  27.   while(!mdone)
  28.     {SHIFT-+}
  29.     center(1, "Cmaster Menu");
  30.  
  31.     move(4, 5);
  32.     printf("(Q)uit");
  33.     move(5, 5);
  34.     printf("(B)aud                %4d",
  35.       baud);
  36.     move(6, 5);
  37.     printf("Bits per (C)har          %1d",
  38.       bpchar);
  39.     move(7, 5);
  40.     printf("(P)arity        %10s",
  41.       parval(parity));
  42.     move(8, 5);
  43.     printf("(S)top bits              %1d",
  44.       stopbits);
  45.     move(9, 5);
  46.     printf("(T)og Duplex    %10s",
  47.       dupval(echo));
  48.  
  49.     move(11, 5);
  50.     printf("(U)pload");
  51.     move(12, 5);
  52.     printf("(D)ownload");
  53.     move(13, 5);
  54.     printf("(N)umber of drive        %1d",
  55.       ddrive);
  56.  
  57.     move(15, 5);
  58.     printf("(R)eturn");
  59.  
  60.     /* wait for keypress */
  61.     while(charsinq() == 0)
  62.       {SHIFT-+}
  63.       {SHIFT--}
  64.     kbchar = getkb();
  65.  
  66.     /* switch on key */
  67.     switch(kbchar)
  68.       {SHIFT-+}
  69.       case 'q': /* quit */
  70.       case 'Q':
  71.         done = 1;
  72.         mdone = 1;
  73.         break;
  74.       case 'u': /* upload */
  75.       case 'U':
  76.         erase();
  77.         move(12, 5);
  78.         printf("Filename:");
  79.         if(getstring(fname, 15))
  80.           {SHIFT-+}
  81.           erase();
  82.           setserial(baud, 8, 1, 0);
  83.           sendfile(fname, ddrive);
  84.           setserial(baud, bpchar,
  85.             stopbits, parity);
  86.           printf("Press key:");
  87.           while(charsinq() == 0)
  88.             {SHIFT-+}
  89.             {SHIFT--}
  90.           kbchar = getkb();
  91.           mdone = 1;
  92.           {SHIFT--}
  93.         erase();
  94.         break;
  95.       case 'd': /* download */
  96.       case 'D':
  97.         erase();
  98.         move(12, 5);
  99.         printf("Filename:");
  100.         if(getstring(fname, 15))
  101.           {SHIFT-+}
  102.           erase();
  103.           setserial(baud, 8, 1, 0);
  104.           recvfile(fname, ddrive);
  105.           setserial(baud, bpchar,
  106.             stopbits, parity);
  107.           printf("Press key:");
  108.           while(charsinq() == 0)
  109.             {SHIFT-+}
  110.             {SHIFT--}
  111.           kbchar = getkb();
  112.           mdone = 1;
  113.           {SHIFT--}
  114.         erase();
  115.         break;
  116.       case 'n':  /* change active drive */
  117.       case 'N':
  118.         if(ddrive == 8)
  119.           {SHIFT-+}
  120.           ddrive = 9;
  121.           {SHIFT--}
  122.         else
  123.           {SHIFT-+}
  124.           ddrive = 8;
  125.           {SHIFT--}
  126.         break;
  127.       case 'b': /* cycle baud */
  128.       case 'B':
  129.         switch(baud)
  130.           {SHIFT-+}
  131.           case 300:
  132.             baud = 450;
  133.             break;
  134.           case 450:
  135.             baud = 1200;
  136.             break;
  137.           case 1200:
  138.             baud = 300;
  139.             break;
  140.           default:
  141.             baud = 300;
  142.             break;
  143.           {SHIFT--}
  144.         setserial(baud, bpchar,
  145.                   stopbits, parity);
  146.         break;
  147.       case 'c': /* bits per char */
  148.       case 'C':
  149.         bpchar++;
  150.         if(bpchar > 8)
  151.           {SHIFT-+}
  152.           bpchar = 7;
  153.           {SHIFT--}
  154.         setserial(baud, bpchar,
  155.                   stopbits, parity);
  156.         break;
  157.       case 'p': /* parity */
  158.       case 'P':
  159.         if(parity == 0)
  160.           {SHIFT-+}
  161.           parity = 1;
  162.           {SHIFT--}
  163.         else
  164.           {SHIFT-+}
  165.           parity += 2;
  166.           if(parity > 7)
  167.             {SHIFT-+}
  168.             parity = 0;
  169.             {SHIFT--}
  170.           {SHIFT--}
  171.         setserial(baud, bpchar,
  172.                   stopbits, parity);
  173.         break;
  174.       case 's': /* stopbits (1 or 2) */
  175.       case 'S':
  176.         stopbits++;
  177.         if(stopbits > 2)
  178.           {SHIFT-+}
  179.           stopbits = 1;
  180.           {SHIFT--}
  181.         setserial(baud, bpchar,
  182.                   stopbits, parity);
  183.         break;
  184.       case 't': /* toggle local echo */
  185.       case 'T':
  186.         echo = !echo;
  187.         break;
  188.       case 'r': /* return to terminal */
  189.       case 'R':
  190.         mdone = 1;
  191.         break;
  192.       default:
  193.         break;
  194.       {SHIFT--}
  195.     {SHIFT--}
  196.   erase();
  197. {SHIFT--}
  198.  
  199. /* parval() - return parity string */
  200. char *parval(par)
  201. int par;
  202. {SHIFT-+}
  203.   switch(par)
  204.     {SHIFT-+}
  205.     case 0:
  206.       return("Disabled");
  207.     case 1:
  208.       return("Odd");
  209.     case 3:
  210.       return("Even");
  211.     case 5:
  212.       return("Mark");
  213.     case 7:
  214.       return("Space");
  215.     default:
  216.       return("Invalid");
  217.     {SHIFT--}
  218. {SHIFT--}
  219.  
  220. /* dupval() - return duplex string */
  221. char *dupval(ech)
  222. int ech;
  223. {SHIFT-+}
  224.   if(ech)
  225.     {SHIFT-+}
  226.     return("Half");
  227.     {SHIFT--}
  228.   else
  229.     {SHIFT-+}
  230.     return("Full");
  231.     {SHIFT--}
  232. {SHIFT--}
  233.  
  234. /* end of file */
  235.