home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / music / stsynth / soundkey.c next >
C/C++ Source or Header  |  1987-05-18  |  29KB  |  699 lines
  1. /*        SoundKey.c
  2.           David T. Jarvis
  3.           Atari ST -- Lattice C -- Version 052686
  4. */
  5.  
  6. #define SPACE_K           32            /* space key                    */
  7. #define ESC_K             27            /* ESC key                      */
  8. #define RETURN_K          13            /* return key                   */
  9. #define DURA            1000            /* note duration                */
  10. #define TUNE_INC           6            /* adjust tuning by this much   */
  11. #define MAX_OCT            6            /* maximum octave               */
  12. #define MAX_VOL           15            /* maximum volume               */
  13. #define MAX_WAV           15            /* maximum waveform             */
  14. #define N_P_OCT           15            /* notes per octave             */
  15. #define MOUS_OFF         256            /* disable mouse                */
  16. #define MOUS_ON          257            /* enable mouse                 */
  17. #define T_OUTLINE       0x10            /* text style--outline          */
  18. #define T_NORMAL         0x0            /* text style--normal           */
  19. #define T_SKEWED      0x0004            /* text style--skewed           */
  20. #define T_THICK       0X0001            /* text style--thick            */
  21. #define CH_ENA_R           7            /* voice channel enable(read)   */
  22. #define CH_ALO_W         128            /* channel,voice a lo,write     */
  23. #define CH_AHI_W         129            /* channel,voice a hi,write     */
  24. #define CH_BLO_W         130            /*    "   ,  "   b lo,  "       */
  25. #define CH_BHI_W         131            /*    "   ,  "   b hi,  "       */
  26. #define CH_CLO_W         132            /*    "   ,  "   c lo,  "       */
  27. #define CH_CHI_W         133            /*    "   ,  "   c hi,  "       */
  28. #define CH_ENA_W         135            /* voice channel enable(write)  */
  29. #define CH_AVL_W         136            /* channel a volume, write      */
  30. #define CH_BVL_W         137            /*    "    b   "   ,   "        */
  31. #define CH_CVL_W         138            /*    "    c   "   ,   "        */
  32. #define RG_ENV_W         140            /* envelope register, write     */
  33. #define RG_WAV_W         141            /* waveform register, write     */
  34. #define CONTERM        0X484            /* attributes of console        */
  35.  
  36. #include <stdio.h>                      /* standard io library          */
  37. #include <osbind.h>                     /* GEMDOS,BIOS,XBIOS macros     */
  38. #include <ctype.h>                      /* character type macros        */
  39.  
  40. #define Supexec(a)      xbios(38,a)     /* Exec routine,supervisor mode */
  41.  
  42. /* play contains the numbers to plug into the ST sound chip */
  43. short int play[ MAX_OCT ][ N_P_OCT ] =
  44. {
  45.  { 3906,3689,3472,3189,3048,2906,2728,2551,2411,2272,2160,2049,1923,1817,1712 },
  46.  { 1923,1817,1712,1633,1524,1436,1350,1275,1205,1136,1076,1016,954,902,850 },
  47.  { 954,902,850,807,757,714,675,637,602,568,537,506,477,451,425 },
  48.  { 477,451,425,401,378,358,338,318,301,284,268,253,239,225,212 },
  49.  { 239,225,212,200,189,179,169,159,150,142,134,126,119,112,106 },
  50.  { 119,112,106,100, 94, 89, 84, 79, 75, 71, 67, 63, 59, 54, 51 }
  51. };
  52.  
  53. short int contrl[12],
  54.           intin[256], intout[256],
  55.           ptsin[256], ptsout[256],
  56.           workin[20], workout[100],
  57.           handle, i, j,
  58.           dvar, port_state,
  59.           key_rate,fast_key = 1,
  60.           x_note, y_note, z_note,
  61.           old_note = 0;
  62.  
  63. char c, x_low, x_high, y_low, y_high, z_low, z_high;
  64. char *std_msg = "Press ESC to Exit                   ";
  65.  
  66. short int hold_n = 0,             /* flag-- hold notes            */
  67.           period = 10,            /* period for sound waves       */
  68.           wave = 0,               /* waveform                     */
  69.           vol_a = MAX_VOL,        /* voice a volume               */
  70.           vol_b = MAX_VOL,        /* voice b volume               */
  71.           vol_c = MAX_VOL,        /* voice c volume               */
  72.           oct_a = 2,              /* voice a octave               */
  73.           oct_b = 2,              /* voice b octave               */
  74.           oct_c = 2,              /* voice c octave               */
  75.           tune  = 6,              /* tuning (added to pitch)      */
  76.           tn_a=2,tn_b=2,tn_c=2,   /* tuning for individual voices */
  77.           diss = 3;               /* dissonance level             */
  78.  
  79. int nonoise();                    /* routine to disable noise     */
  80.  
  81. main()
  82. {
  83. /* Check for correct resolution */
  84.      if (Getrez() != 1)
  85.          {
  86.          printf("Sorry, this program must be run in medium resolution.\n");
  87.          exit(0);
  88.          }
  89.  
  90. /* Initialize application */
  91.      appl_init();
  92.      handle=graf_handle( &dvar, &dvar, &dvar, &dvar );
  93.      for ( i = 0;  i < 10;  workin[ i++ ]=1 );  workin[ 10 ] = 2;
  94.      v_opnvwk( workin, &handle, workout );
  95.  
  96. /* Hide mouse, disable keyclick,bell, speed up keyboard repeat rate */
  97.      graf_mouse( MOUS_OFF, 0 );
  98.      Supexec(nonoise);
  99.      key_rate = Kbrate( 0x01,0x01 );
  100.  
  101. /* Initialize sound chip, enable channels a and b */
  102.      sound_off();
  103.      port_state = Giaccess( i, CH_ENA_R  );
  104.      Giaccess( (port_state & 0xc0) | 56, CH_ENA_W );
  105.  
  106. /* Make music */
  107.      play_keys();
  108.  
  109. /* turn off the sound chip, restore initial state */
  110.      Giaccess( port_state, CH_ENA_W );
  111.  
  112. /* restore keyboard repeat rate, close application and exit */
  113.      Kbrate( (key_rate >> 8) & 0x00ff, key_rate & 0x00ff );
  114.      v_clsvwk( handle );
  115.      appl_exit();
  116. }
  117.  
  118. play_keys()
  119. {
  120.      register char c=' ', c2=' ';
  121.  
  122.      keys_screen();
  123.      while (c != ESC_K)
  124.           {
  125.           if (Bconstat(2))
  126.                {
  127.                vol_c = 0;
  128.                c = Bconin(2);    c = tolower(c);
  129.                switch(c)
  130.                     {
  131.                     case '1':
  132.                          locate(22,1);
  133.                          put_msg( "H=>Higher, L=>Lower, RETURN=>Done    ");
  134.                          x_note = play[ oct_a ][ 0 ] + tn_a;
  135.                          y_note = play[ oct_b ][ 0 ] + tn_b;
  136.                          sound_on();
  137.                          do
  138.                               {
  139.                               c2 = Bconin(2);      c2 = tolower(c2);
  140.                               switch(c2)
  141.                                  {
  142.                                  case 'h':
  143.                                    if (tune)
  144.                                        {
  145.                                        tune -= TUNE_INC;
  146.                                        tn_a = tune/(oct_a+1);
  147.                                        tn_b = tune/(oct_b+1);
  148.                                        tn_c = tune/(oct_c+1);
  149.                                        x_note = play[ oct_a ][ 0 ] + tn_a;
  150.                                        y_note = play[ oct_b ][ 0 ] + tn_b;
  151.                                        sound_on();
  152.                                        dsp_vals();
  153.                                        }
  154.                                     break;
  155.                                  case 'l':
  156.                                     if (tune < TUNE_INC*5)
  157.                                         {
  158.                                         tune += TUNE_INC;
  159.                                         tn_a = tune/(oct_a+1);
  160.                                         tn_b = tune/(oct_b+1);
  161.                                         tn_c = tune/(oct_c+1);
  162.                                         y_note = play[ oct_b ][ 0 ] + tn_b;
  163.                                         x_note = play[ oct_a ][ 0 ] + tn_a;
  164.                                         sound_on();
  165.                                         dsp_vals();
  166.                                         }
  167.                                      break;
  168.                                   default:
  169.                                      break;
  170.                                   }
  171.                               } while (c2 != RETURN_K );
  172.                               sound_off();
  173.                               put_msg( std_msg );
  174.                               x_note = old_note;
  175.                               break;
  176.                     case '2':
  177.                               locate(22,1);
  178.                               put_msg(
  179.                               "M => More, L=>Less, RETURN=>Done     ");
  180.                               x_note = play[ oct_a ][ 0 ] + tn_a;
  181.                               y_note = play[ oct_b ][ 0 ] + tn_b + diss;
  182.                               sound_on();
  183.                               do
  184.                                     {
  185.                                     c2 = Bconin(2);   c2 = tolower(c2);
  186.                                     switch(c2)
  187.                                        {
  188.                                        case 'l':
  189.                                           if (diss)
  190.                                              {
  191.                                              diss--;
  192.                                              x_note = play[ oct_a ][ 0 ]
  193.                                                       + tn_a;
  194.                                              y_note = play[ oct_b ][ 0 ]
  195.                                                       + tn_b + diss;
  196.                                              sound_on();
  197.                                              dsp_vals();
  198.                                              }
  199.                                           break;
  200.                                       case 'm':
  201.                                           if (diss < 7)
  202.                                              {
  203.                                              diss++;
  204.                                              x_note = play[ oct_a ][ 0 ]
  205.                                                       + tn_a;
  206.                                              y_note = play[ oct_b ][ 0 ]
  207.                                                       + tn_b + diss;
  208.                                              sound_on();
  209.                                              dsp_vals();
  210.                                              }
  211.                                           break;
  212.                                        default:
  213.                                           break;
  214.                                        }
  215.                               } while (c2 != RETURN_K );
  216.                               sound_off();
  217.                               put_msg( std_msg );
  218.                               x_note = old_note;
  219.                               break;
  220.                          case '3':
  221.                               wave++;
  222.                               if (wave == 1) wave = 4;
  223.                               if (wave == 5) wave = 8;
  224.                               if (wave > MAX_WAV)
  225.                                    wave = 0;
  226.                               Giaccess( wave, RG_WAV_W );
  227.                               dsp_vals();
  228.                               x_note = old_note;
  229.                               break;
  230.                          case '4':
  231.                               Kbrate((key_rate>>8)&0x00ff,key_rate&0x00ff);
  232.                               fast_key = 0;
  233.                               dsp_vals();
  234.                               x_note = old_note;
  235.                               break;
  236.                          case '5':
  237.                               fast_key = 1;
  238.                               Kbrate( 0x01,0x01 );
  239.                               dsp_vals();
  240.                               x_note = old_note;
  241.                               break;
  242.                          case 'a':
  243.                               x_note = play[ oct_a ][ 0 ] + tn_a;
  244.                               y_note = play[ oct_b ][ 0 ] + tn_b + diss;
  245.                               break;
  246.                          case 'w':
  247.                               x_note = play[ oct_a ][ 1 ] + tn_a;
  248.                               y_note = play[ oct_b ][ 1 ] + tn_b + diss;
  249.                               break;
  250.                          case 's':
  251.                               x_note = play[ oct_a ][ 2 ] + tn_a;
  252.                               y_note = play[ oct_b ][ 2 ] + tn_b + diss;
  253.                               break;
  254.                          case 'e':
  255.                               x_note = play[ oct_a ][ 3 ] + tn_a;
  256.                               y_note = play[ oct_b ][ 3 ] + tn_b + diss;
  257.                               break;
  258.                          case 'd':
  259.                               x_note = play[ oct_a ][ 4 ] + tn_a;
  260.                               y_note = play[ oct_b ][ 4 ] + tn_b + diss;
  261.                               break;
  262.                          case 'f':
  263.                               x_note = play[ oct_a ][ 5 ] + tn_a;
  264.                               y_note = play[ oct_b ][ 5 ] + tn_b + diss;
  265.                               break;
  266.                          case 't':
  267.                               x_note = play[ oct_a ][ 6 ] + tn_a;
  268.                               y_note = play[ oct_b ][ 6 ] + tn_b + diss;
  269.                               break;
  270.                          case 'g':
  271.                               x_note = play[ oct_a ][ 7 ] + tn_a;
  272.                               y_note = play[ oct_b ][ 7 ] + tn_b + diss;
  273.                               break;
  274.                          case 'u':
  275.                               x_note = play[ oct_a ][ 8 ] + tn_a;
  276.                               y_note = play[ oct_b ][ 8 ] + tn_b + diss;
  277.                               break;
  278.                          case 'j':
  279.                               x_note = play[ oct_a ][ 9 ] + tn_a;
  280.                               y_note = play[ oct_b ][ 9 ] + tn_b + diss;
  281.                               break;
  282.                          case 'i':
  283.                               x_note = play[ oct_a ][ 10 ] + tn_a;
  284.                               y_note = play[ oct_b ][ 10 ] + tn_b + diss;
  285.                               break;
  286.                          case 'k':
  287.                               x_note = play[ oct_a ][ 11 ] + tn_a;
  288.                               y_note = play[ oct_b ][ 11 ] + tn_b + diss;
  289.                               break;
  290.                          case 'o':
  291.                               x_note = play[ oct_a ][ 12 ] + tn_a;
  292.                               y_note = play[ oct_b ][ 12 ] + tn_b + diss;
  293.                               break;
  294.                          case 'l':
  295.                               x_note = play[ oct_a ][ 13 ] + tn_a;
  296.                               y_note = play[ oct_b ][ 13 ] + tn_b + diss;
  297.                               break;
  298.                          case 'p':
  299.                               x_note = play[ oct_a ][ 14 ] + tn_a;
  300.                               y_note = play[ oct_b ][ 14 ] + tn_b + diss;
  301.                               break;
  302.                          case 'z':
  303.                               x_note = play[ oct_a ][ 0 ] + tn_a;
  304.                               y_note = play[ oct_b ][ 4 ] + tn_b;
  305.                               z_note = play[ oct_c ][ 7 ] + tn_c;
  306.                               vol_c = vol_a;
  307.                               break;
  308.                          case 'x':
  309.                               x_note = play[ oct_a ][ 2 ] + tn_a;
  310.                               y_note = play[ oct_b ][ 5 ] + tn_b;
  311.                               z_note = play[ oct_c ][ 9 ] + tn_c;
  312.                               vol_c = vol_a;
  313.                               break;
  314.                          case 'c':
  315.                               x_note = play[ oct_a ][ 4 ] + tn_a;
  316.                               y_note = play[ oct_b ][ 7 ] + tn_b;
  317.                               z_note = play[ oct_c ][ 11 ] + tn_c;
  318.                               vol_c = vol_a;
  319.                               break;
  320.                          case 'v':
  321.                               x_note = play[ oct_a ][ 5 ] + tn_a;
  322.                               y_note = play[ oct_b ][ 9 ] + tn_b;
  323.                               z_note = play[ oct_c ][ 12 ] + tn_c;
  324.                               vol_c = vol_a;
  325.                               break;
  326.                          case 'b':
  327.                               x_note = play[ oct_a ][ 2 ] + tn_a;
  328.                               y_note = play[ oct_b ][ 7 ] + tn_b;
  329.                               z_note = play[ oct_c ][ 11 ] + tn_c;
  330.                               vol_c = vol_a;
  331.                               break;
  332.                          case 'n':
  333.                               x_note = play[ oct_a ][ 4 ] + tn_a;
  334.                               y_note = play[ oct_b ][ 9 ] + tn_b;
  335.                               z_note = play[ oct_c ][ 12 ] + tn_c;
  336.                               vol_c = vol_a;
  337.                               break;
  338.                          case 'm':
  339.                               x_note = play[ oct_a ][ 2 ] + tn_a;
  340.                               y_note = play[ oct_b ][ 5 ] + tn_b;
  341.                               z_note = play[ oct_c ][ 11 ] + tn_c;
  342.                               vol_c = vol_a;
  343.                               break;
  344.                          case ',':
  345.                          case '<':
  346.                               x_note = play[ oct_a ][ 4 ] + tn_a;
  347.                               y_note = play[ oct_b ][ 7 ] + tn_b;
  348.                               z_note = play[ oct_c ][ 12 ] + tn_c;
  349.                               vol_c = vol_a;
  350.                               break;        
  351.                          case ']':
  352.                               oct_a++;    oct_b++;    oct_c++;
  353.                               if (oct_a > MAX_OCT) oct_a = 0;
  354.                               if (oct_b > MAX_OCT) oct_b = 0;
  355.                               if (oct_c > MAX_OCT) oct_c = 0;
  356.                               x_note = old_note;
  357.                               tn_a = tune/(oct_a+1);
  358.                               tn_b = tune/(oct_b+1);
  359.                               tn_c = tune/(oct_c+1);
  360.                               dsp_vals();
  361.                               break;
  362.                          case '[':
  363.                               oct_a--;    oct_b--;    oct_c--;
  364.                               if (oct_a < 0) oct_a = MAX_OCT;
  365.                               if (oct_b < 0) oct_b = MAX_OCT;
  366.                               if (oct_c < 0) oct_c = MAX_OCT;
  367.                               x_note = old_note;
  368.                               tn_a = tune/(oct_a+1);
  369.                               tn_b = tune/(oct_b+1);
  370.                               tn_c = tune/(oct_c+1);
  371.                               dsp_vals();
  372.                               break;
  373.                          case '}':
  374.                               oct_a++;
  375.                               if (oct_a > MAX_OCT) oct_a = 0;
  376.                               x_note = old_note;
  377.                               tn_a = tune/(oct_a+1);
  378.                               dsp_vals();
  379.                               break;
  380.                          case '{':
  381.                               oct_a--;
  382.                               if (oct_a < 0) oct_a = MAX_OCT;
  383.                               x_note = old_note;
  384.                               tn_a = tune/(oct_a+1);
  385.                               dsp_vals();
  386.                               break;
  387.                          case SPACE_K:
  388.                               x_note = old_note;
  389.                               hold_n = !hold_n;
  390.                               dsp_vals();
  391.                               if (!hold_n)
  392.                                  sound_off();
  393.                               break;
  394.                          default:
  395.                               x_note = old_note;
  396.                               break;
  397.                          }
  398.                     if (x_note != old_note)
  399.                          { 
  400.                          x_low = (char)(x_note);
  401.                          y_low = (char)(y_note);
  402.                          z_low = (char)(z_note);
  403.                          x_high = (char)(x_note >> 8);
  404.                          y_high = (char)(y_note >> 8);
  405.                          z_high = (char)(z_note >> 8);
  406.                          Giaccess( x_low, CH_ALO_W  );
  407.                          Giaccess( x_high, CH_AHI_W  );
  408.                          Giaccess( y_low, CH_BLO_W  );
  409.                          Giaccess( y_high, CH_BHI_W  );
  410.                          Giaccess( z_low, CH_CLO_W  );
  411.                          Giaccess( z_high, CH_CHI_W  );
  412.                          Giaccess( vol_a, CH_AVL_W  );
  413.                          Giaccess( vol_b, CH_BVL_W  );
  414.                          Giaccess( vol_c, CH_CVL_W  );
  415.                          j = 1;
  416.                          }
  417.                     }
  418.                else
  419.                     {
  420.                     j++;
  421.                     if ((j == DURA) && (!hold_n))
  422.                          {
  423.                          Giaccess( 0, CH_AVL_W  );
  424.                          Giaccess( 0, CH_BVL_W  );
  425.                          Giaccess( 0, CH_CVL_W  );
  426.                          }
  427.                     }
  428.                }
  429.         sound_off();
  430. }
  431.  
  432. keys_screen()
  433. {
  434.          keys_menu();      /* Display control keys menu     */
  435.          dsp_prms();       /* Display parameter names       */
  436.          dsp_vals();       /* Display parameter values      */
  437.          draw_kbd();       /* Draw a keyboard map           */
  438.          author();
  439. }
  440.  
  441. keys_menu()
  442. {
  443.         v_clrwk( handle );
  444.         empt_box(4,6,636,198,1);
  445.         empt_box(8,18,312,102,3);
  446.         vst_effects( handle, T_SKEWED );
  447.         vst_color( handle,2 );
  448.         v_gtext( handle, 264, 6, "ST SYNTHESIZER" );
  449.         vst_effects( handle, T_OUTLINE );
  450.         vst_color( handle,3 );
  451.         v_gtext( handle, 80, 16, "PARAMETER CONTROL" );
  452.         vst_effects( handle, T_NORMAL );
  453.         vst_color( handle,1 );
  454.         v_gtext( handle,16,30, "1     -- Tune Keyboard (on C)" );
  455.         v_gtext( handle,16,38, "2     -- Dissonance" );
  456.         v_gtext( handle,16,46, "3     -- Next Waveform" );
  457.         v_gtext( handle,16,54, "4,5   -- Slow/Fast Key Speed" );
  458.         v_gtext( handle,16,62, "[     -- Lower Octave, Both Voices");
  459.         v_gtext( handle,16,70, "]     -- Higher Octave, Both Voices");
  460.         v_gtext( handle,16,78, "{     -- Lower Octave, Voice A");
  461.         v_gtext( handle,16,86, "}     -- Higher Octave, Voice A");
  462.         v_gtext( handle,16,94, "SPACE -- Toggle Sustain Mode");
  463.         empt_box( 8,182,324,194,3 );
  464.         vst_color( handle,2 );
  465.         vst_effects( handle, T_THICK );
  466. }
  467.  
  468. dsp_prms()
  469. {
  470.         empt_box( 320,18,632,102,3 );
  471.         vst_effects( handle, T_OUTLINE );
  472.         vst_color( handle,3 );
  473.         v_gtext( handle,400,16,"PARAMETER VALUES" );
  474.         vst_effects( handle, T_NORMAL );
  475.         vst_color( handle,1 );
  476.         v_gtext( handle,328,30, "Tuning     :  ");
  477.         v_gtext( handle,328,38, "Dissonance :  ");
  478.         v_gtext( handle,328,46, "Waveform   :  ");
  479.         v_gtext( handle,328,54, "Key Speed  :  ");
  480.         v_gtext( handle,328,62, "Octave A   :  ");
  481.         v_gtext( handle,328,70, "Octave B   :  ");
  482.         v_gtext( handle,328,78, "Octave C   :  ");
  483.         v_gtext( handle,328,86, "Octave Mix :  ");
  484.         v_gtext( handle,328,94, "Sustain    :  ");
  485. }
  486.  
  487. dsp_vals()
  488. {
  489. char buffer[ 36 ];
  490.  
  491. vst_color( handle,1 );
  492. vst_effects( handle,T_NORMAL );
  493. sprintf(buffer,"%d%s",tune,"    ");    v_gtext( handle,448,30,buffer );
  494. sprintf(buffer,"%d%s",diss,"    ");    v_gtext( handle,448,38,buffer );
  495. sprintf(buffer,"%d%s",wave,"    ");    v_gtext( handle,448,46,buffer );
  496. if (fast_key)
  497.    sprintf(buffer,"%s","Fast    ");
  498. else
  499.    sprintf(buffer,"%s","Normal  ");
  500. v_gtext( handle,448,54,buffer );
  501. sprintf(buffer,"%d%s",oct_a,"    ");   v_gtext( handle,448,62,buffer );
  502. sprintf(buffer,"%d%s",oct_b,"    ");   v_gtext( handle,448,70,buffer );
  503. sprintf(buffer,"%d%s",oct_c,"    ");   v_gtext( handle,448,78,buffer );
  504. if (oct_a == oct_b)
  505.    sprintf(buffer,"%s","Same  ");
  506. else
  507.    sprintf(buffer,"%s","Split ");
  508. v_gtext( handle,448,86,buffer );
  509. if (hold_n)
  510.    sprintf(buffer,"%s","On  ");
  511. else
  512.    sprintf(buffer,"%s","Off ");
  513. v_gtext( handle,448,94,buffer );
  514. }
  515.  
  516. draw_kbd()
  517. {
  518. int row, key, kl, kt, kr, kb, offset=0, rowsize = 15;
  519. int ledge = 120;
  520. int tedge = 114;
  521. int keynum = 0;
  522. short int ret_key[ 14 ];
  523.  
  524. empt_box( ledge-8,tedge-4,ledge+4+306,tedge+8+45,2 );
  525. vst_color( handle,1 );
  526. vst_effects( handle,T_SKEWED );
  527. v_gtext( handle,500,tedge+6,"Control");
  528. vst_color( handle,2 );
  529. v_gtext( handle,500,tedge+18,"Notes");
  530. vst_color( handle,3 );
  531. v_gtext( handle,500,tedge+30,"Chords");
  532. v_gtext( handle,500,tedge+42,"Not Used");
  533. empt_box( 460,tedge,475,tedge+7,1 );
  534. empt_box( 460,tedge+12,475,tedge+19,2 );
  535. full_box( 460,tedge+24,475,tedge+31,3,6 );
  536. empt_box( 460,tedge+36,475,tedge+43,3 );
  537.  
  538. for (row = 0, kl = 10; row < 4; row++)
  539.    {
  540.    kl = ledge;
  541.    kt = tedge + (row*10);
  542.    kr = kl + 15 + offset;
  543.    kb = kt + 7;
  544.    empt_box( kl,kt,kr,kb,3 );
  545.    kl += offset;
  546.    keynum++;
  547.    for (key = 1; key < rowsize; key++)
  548.       {
  549.       kl += 20;
  550.       kr += 20;
  551.       if ((row == 0)&&(key == 14))
  552.          kr += 7;
  553.       switch(keynum)
  554.          {
  555.          case 1:  case 2:  case 3: case 4: case 5:
  556.          case 26: case 27:
  557.             empt_box( kl,kt,kr,kb,1 );
  558.             break;
  559.          case 17: case 18: case 20: case 22:
  560.          case 23: case 24: case 25: case 30:
  561.          case 31: case 32: case 33: case 34:
  562.          case 36: case 37: case 38:
  563.             empt_box( kl,kt,kr,kb,2 );
  564.             break;
  565.          case 28:
  566.             ret_key[ 0 ] = ret_key[ 10 ] = ret_key[ 12 ] = kl;
  567.             ret_key[ 1 ] = ret_key[ 3 ] = ret_key[ 13 ] = kt;
  568.             ret_key[ 2 ] = ret_key[ 4 ] = kr;
  569.             ret_key[ 5 ] = ret_key[ 7 ] = kt + 17;
  570.             ret_key[ 6 ] = ret_key[ 8 ] = kl - 11;
  571.             ret_key[ 9 ] = ret_key[ 11 ] = kt + 10;
  572.             vsl_color( handle,3 );
  573.             v_pline( handle,7,ret_key );
  574.             empt_box( kl+20,kt,kr+17,kb,3 );
  575.             empt_box( kl+20,kt+10,kr+17,kb+10,3 );
  576.             break;
  577.          case 41:
  578.             break;
  579.          case 43: case 44: case 45: case 46:
  580.          case 47: case 48: case 49: case 50:
  581.             full_box( kl,kt,kr,kb,3,6 );
  582.             break;
  583.          case 53:
  584.             empt_box( kl,kt,kr + 5,kb,3 );
  585.             break;
  586.          default:
  587.             empt_box( kl,kt,kr,kb,3 );
  588.             break;
  589.          }
  590.       keynum++;
  591.       }
  592.    rowsize--;
  593.    offset += 10;
  594.    }
  595.    tedge += (row*10);
  596.    empt_box( ledge+20,tedge,ledge+40,tedge+7,3 );
  597.    vsl_color( handle,1 );
  598.    empt_box( ledge+45,tedge,ledge+240,tedge+7,1 );
  599.    vsl_color( handle,3 );
  600.    empt_box( ledge+245,tedge,ledge+265,tedge+7,3 );
  601. }
  602.  
  603. author()
  604. {
  605.      long time = 150000L;
  606.      vst_color( handle,2 );
  607.      vst_effects( handle,T_SKEWED );
  608.      v_gtext( handle,14,192,"        by David T. Jarvis          ");
  609.      while (time--)
  610.          ;
  611.      put_msg( std_msg );
  612. }
  613.  
  614. put_msg( s )
  615. char *s;
  616. {
  617.         vst_color( handle,2 );
  618.         vst_effects( handle,T_THICK );
  619.         v_gtext( handle,14,192,s );
  620. }
  621.  
  622. locate( row, col )
  623. short int row, col;
  624. {
  625.         Cconout( ESC_K );
  626.         Cconout('Y');
  627.         Cconout( row + 32 );
  628.         Cconout( col + 32 );
  629. }
  630.  
  631. sound_off()
  632. {
  633.         Giaccess( 0, CH_AVL_W  );
  634.         Giaccess( 0, CH_BVL_W  );
  635.         Giaccess( 0, CH_CVL_W  );
  636. }
  637.  
  638. sound_on()
  639. {
  640.          x_low = (char)(x_note);
  641.          y_low = (char)(y_note);
  642.          z_low = (char)(z_note);
  643.          x_high = (char)(x_note >> 8);
  644.          y_high = (char)(y_note >> 8);
  645.          z_high = (char)(z_note >> 8);
  646.          Giaccess( period, RG_ENV_W  );
  647.          Giaccess( wave, RG_WAV_W  );
  648.          Giaccess( x_low, CH_ALO_W  );
  649.          Giaccess( x_high, CH_AHI_W  );
  650.          Giaccess( y_low, CH_BLO_W  );
  651.          Giaccess( y_high, CH_BHI_W  );
  652.          Giaccess( z_low, CH_CLO_W  );
  653.          Giaccess( z_high, CH_CHI_W  );
  654.          Giaccess( vol_a, CH_AVL_W  );
  655.          Giaccess( vol_b, CH_BVL_W  );
  656.          Giaccess( vol_c, CH_CVL_W  );
  657. }
  658.  
  659. empt_box( left, top, right, bottom, color )
  660. short int left, top, right, bottom, color;
  661. {
  662.    short int pxy[ 10 ];
  663.  
  664.    pxy[ 0 ] = left;     pxy[ 1 ] = top;
  665.    pxy[ 2 ] = right;    pxy[ 3 ] = top;
  666.    pxy[ 4 ] = right;    pxy[ 5 ] = bottom;
  667.    pxy[ 6 ] = left;     pxy[ 7 ] = bottom;
  668.    pxy[ 8 ] = left;     pxy[ 9 ] = top;
  669.  
  670.    vsl_color( handle,color );
  671.    v_pline( handle, 5, pxy );
  672. }
  673.  
  674. full_box( left,top,right,bottom,color,style )
  675. short int left,top,right,bottom,color,style;
  676. {
  677.    short int pxy[ 4 ];
  678.  
  679.    vsl_color( handle,color );
  680.    vsf_interior( handle,2 );
  681.    vsf_color( handle,color );
  682.    vswr_mode( handle,1 );
  683.    vsf_style( handle,style );
  684.    vsf_perimeter( handle,1 );
  685.    empt_box( left,top,right,bottom,color );
  686.    pxy[ 0 ] = left;     pxy[ 1 ] = top;
  687.    pxy[ 2 ] = right;    pxy[ 3 ] = bottom;
  688.    vr_recfl( handle,pxy );
  689. }
  690.  
  691. nonoise()
  692. {
  693. char *con_ptr;
  694.  
  695. con_ptr = CONTERM;
  696. *con_ptr = *con_ptr & (char)0xfa;
  697. }
  698.  
  699.