home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.6 / ffcollection-1-6-1993-02.iso / ff_disks / 211-240 / ff_228 / glib / glib.c < prev    next >
C/C++ Source or Header  |  1989-06-26  |  29KB  |  1,473 lines
  1. /*
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  */
  4.  
  5. #include "glib.h"
  6. #include <ctype.h>
  7.  
  8. char *Reason = "";
  9.  
  10. int Currrow = 0;    /* at top of screen, for messages */
  11. int Libbank = 0;    /* from 0 to LIBBANKS-1, is the current library bank*/
  12. int Nsynths = 0;
  13.  
  14. char *Currdata;
  15. char *Yankdata;        /* current 'yank' buffer (middle of screen) */
  16.  
  17. struct peredinfo *PE;    /* array of per-editor miscellany */
  18.  
  19. char Buff[BUFSIZ];
  20. int Redraw = 0;        /* if non-0, edit screen is completely redrawn. */
  21.             /* parameter functions can make use of this. */
  22. int Changed = 0;
  23.  
  24. /* All the global values below are set as appropriate for the */
  25. /* synthesizer currently being dealt with. */
  26.  
  27. int Nvoices = 0;
  28. int Voicesize =0;
  29. int Namesize = 0;
  30. int Libindex;        /* from 0 to Nvoices-1 */
  31. int Synindex;        /* from 0 to Nvoices-1 */
  32. int Channel;
  33. int Editrow;        /* from 0 to NUMONSCREEN-1 */
  34. int Editcol;        /* 0==synth, 1==library */
  35. char *Libdata;        /* current library data (includes all LIBBANKS) */
  36.             /* ie. the stuff on the right side of the screen */
  37. char *Syndata;        /* current synth data (1 bank), ie. the left side */
  38. struct paraminfo *P;    /* list of parameter info */
  39. struct labelinfo *L;    /* arbitrary screen labels for edit screen */
  40. char *Synthname;
  41.  
  42. int (*Sendedit)();    /* function to send parameters to synth's edit buffer*/
  43. int (*Datain)();    /* convert data from file-storage format to the */
  44.             /* format stored in the P[] parameter array (p_val) */
  45. int (*Dataout)();    /* reverse of Datain */
  46. int (*Sendone)();    /* function to send one (permanent) voice to synth */
  47. int (*Sendbulk)();    /* function to send bulk dump to synth */
  48. int (*Getbulk)();    /* reverse of Sendbulk */
  49. char *(*Nameof)();    /* pulls voice name out of file-storage data */
  50. int (*Setnameof)();    /* reverse of Nameof */
  51. char *(*Numof)();    /* convert voice number to on-screen text */
  52. int (*Cvtnum)();    /* convert visible voice number to std. format */
  53. int (*Cvtanum)();    /* convert alphanumeric voice number to std. format */
  54.             /* should never define both Cvtnum and Cvtanum */
  55. main()
  56. {
  57.     int n;
  58.  
  59.     hello();
  60.     windinit();
  61.     initstuff();
  62.  
  63.     if ( Nsynths == 0 )
  64.         windstr("Hey, the E array is empty?");
  65.     else if ( Nsynths == 1 ) {
  66.         /* If there's only 1 synth, don't bother asking */
  67.         setedit(0);
  68.         libinteract();
  69.     }
  70.     else {
  71.         while ( (n=choosesynth()) >= 0 ) {
  72.             setedit(n);
  73.             libinteract();
  74.             unsetedit(n);
  75.         }
  76.     }
  77.     bye();
  78. }
  79.  
  80. /* choose a synth, returning its position in the E array */
  81. choosesynth()
  82. {
  83.     int n, pick;
  84.  
  85.     retry:
  86.     flushconsole();
  87.     windclear();
  88.     windgoto(2,18);
  89.     windstr("GLIB - A Generic Librarian/Editor");
  90.  
  91.     for ( n=1; n<=Nsynths; n++ )
  92.         libchoice(n);
  93.  
  94.     windgoto(10+n,16);
  95.     windstr("Choose your synth (or 'q' to quit) --> ");
  96.     windrefresh();
  97.     pick = mouseorkey();
  98.     if ( pick == 'q' || pick == EOF )
  99.         return(-1);
  100.     if ( pick != MOUSE )
  101.         pick = pick - '0';
  102.     else {
  103.         int row, col;
  104.         getmouse(&row,&col);
  105.         /* wait until mouse goes down */
  106.         while ( statmouse() > 0 )
  107.             ;
  108.         pick = row - 6; 
  109.     }
  110.     if ( pick < 1 || pick > Nsynths )
  111.         goto retry;
  112.     return(pick-1);
  113. }
  114.  
  115. libchoice(n)
  116. {
  117.     windgoto(6+n,27);
  118.     sprintf(Buff,"%d  -  %s",n,E[n-1].ed_name);
  119.     windstr(Buff);
  120. }
  121.  
  122. initstuff()
  123. {
  124.     int n, banksize, maxvsize = 0;
  125.     char *p;
  126.     
  127.     for ( n=0; E[n].ed_name != NULL; n++ ) {
  128.         if ( maxvsize < E[n].ed_vsize )
  129.             maxvsize = E[n].ed_vsize;
  130.     }
  131.     Nsynths = n;
  132.     Currdata = alloc( maxvsize );
  133.  
  134.     /* allocate an array of peredinfo structs */
  135.     PE =(struct peredinfo *)alloc((int)(Nsynths*sizeof(struct peredinfo)));
  136.     for ( n=0; n<Nsynths; n++ ) {
  137.         banksize =  E[n].ed_nvoices * E[n].ed_vsize;
  138.         p = PE[n].ed_libdata = alloc( LIBBANKS * banksize );
  139.         clrdata(p,LIBBANKS*banksize);
  140.         p = PE[n].ed_syndata = alloc( banksize );
  141.         clrdata(p,banksize);
  142.         p = PE[n].ed_yankdata = alloc( E[n].ed_vsize );
  143.         clrdata(p,E[n].ed_vsize);
  144.         PE[n].ed_libindex = 0;
  145.         PE[n].ed_synindex = 0;
  146.         PE[n].ed_channel = 1;
  147.         PE[n].ed_erow = 0;
  148.         PE[n].ed_ecol = 0;
  149.     }
  150. }
  151.  
  152. clrdata(data,size)
  153. char *data;
  154. {
  155.     register char *p = data, *endp = data+size;
  156.  
  157.     while ( p<endp )
  158.         *p++ = 0;
  159. }
  160.  
  161. setedit(n)
  162. {
  163.     Synthname = E[n].ed_name;
  164.     Datain = E[n].ed_din;
  165.     Dataout = E[n].ed_dout;
  166.     Nvoices = E[n].ed_nvoices;
  167.     Sendedit = E[n].ed_sedit;
  168.     Sendone = E[n].ed_sone;
  169.     Sendbulk = E[n].ed_sbulk;
  170.     Getbulk = E[n].ed_gbulk;
  171.     Nameof = E[n].ed_nof;
  172.     Numof = E[n].ed_numof;
  173.     Cvtnum = E[n].ed_cvtnum;
  174.     Cvtanum = E[n].ed_cvtanum;
  175.     Setnameof = E[n].ed_snof;
  176.     Voicesize = E[n].ed_vsize;
  177.     Namesize = E[n].ed_nsize;
  178.     Libdata = PE[n].ed_libdata;
  179.     Syndata = PE[n].ed_syndata;
  180.     Yankdata = PE[n].ed_yankdata;
  181.     Libindex = PE[n].ed_libindex;
  182.     Synindex = PE[n].ed_synindex;
  183.     Channel = PE[n].ed_channel;
  184.     Editrow = PE[n].ed_erow;
  185.     Editcol = PE[n].ed_ecol;
  186.     clrdata(Currdata,Voicesize);
  187.     P = E[n].ed_params;
  188.     L = E[n].ed_labels;
  189. }
  190.  
  191. unsetedit(n)
  192. {
  193.     int k;
  194.  
  195.     PE[n].ed_libindex = Libindex;
  196.     PE[n].ed_synindex = Synindex;
  197.     PE[n].ed_channel = Channel;
  198.     PE[n].ed_erow = Editrow;
  199.     PE[n].ed_ecol = Editcol;
  200.     for ( k=0; k<Voicesize; k++ )
  201.         PE[n].ed_yankdata[k] = Yankdata[k];
  202. }
  203.  
  204. /* template - show the boxes and such on the main library screen */
  205. template()
  206. {
  207.     int n, k, r;
  208.  
  209.     r = FIRSTROW-1;
  210.     sprintf(Buff,"%s Voices",Synthname);
  211.     n = 13 - strlen(Buff)/2;    /* center it */
  212.     windgoto(r,n<0?0:n);
  213.     windstr(Buff);
  214.     r++;
  215.     windgoto(r,0);
  216.     for ( n=0; n<26; n++ )
  217.         windputc('=');
  218.     windgoto(r,52);
  219.     for ( n=0; n<26; n++ )
  220.         windputc('=');
  221.     for ( n=r+1; n<(r+13); n++ ) {
  222.         windgoto(n,0);
  223.         windputc('|');
  224.         windgoto(n,6);
  225.         windputc('|');
  226.         windgoto(n,25);
  227.         windputc('|');
  228.  
  229.         k=52;
  230.         windgoto(n,k);
  231.         windputc('|');
  232.         windgoto(n,k+6);
  233.         windputc('|');
  234.         windgoto(n,k+25);
  235.         windputc('|');
  236.     }
  237.     windgoto(r+13,0);
  238.     for ( n=0; n<26; n++ )
  239.         windputc('=');
  240.     windgoto(r+13,52);
  241.     for ( n=0; n<26; n++ )
  242.         windputc('=');
  243.  
  244.     windgoto(YANKROW-2,YANKCOL);
  245.     windstr("  Yank Buffer");
  246.     windgoto(YANKROW-1,YANKCOL);
  247.     windstr(" ------------- ");
  248.     windgoto(YANKROW,YANKCOL);
  249.     windstr("               ");
  250.     windgoto(YANKROW+1,YANKCOL);
  251.     windstr(" ------------- ");
  252.     windrefresh();
  253. }
  254.  
  255. /* clear the message area */
  256. clearmess()
  257. {
  258.     int n;
  259.     for(n=1;n<(FIRSTROW-1);n++)
  260.         winderaserow(n);
  261.     Currrow = 0;
  262. }
  263.  
  264. /* set the current voice (ie. the synth's edit buffer) to the indicated */
  265. /* voice.  c==0 is the synth (left) side, c==1 is the library (right) side. */
  266. editto(r,c)
  267. {
  268.     int voicenum;
  269.  
  270.     /* Clear the existing '*' */
  271.     editchar(' ',Editrow,Editcol);
  272.     editchar('*',Editrow=r,Editcol=c);
  273.     if ( Editcol==0 ) {
  274.         /* we're on the synth side */
  275.         voicenum = Editrow+Synindex;
  276.         tocurrent(Syndata,voicenum);
  277.     }
  278.     else {
  279.         /* we're on the lib side */
  280.         voicenum = Editrow+Libindex;
  281.         tocurrent(bankvoice(0),voicenum);
  282.     }
  283. }
  284.  
  285. editchar(ec,r,c)
  286. {
  287.     r = r + FIRSTROW + 1;
  288.     if ( c == 0 )
  289.         c = LEFTSIDE-1;
  290.     else
  291.         c = RIGHTSIDE-1;
  292.     windgoto(r,c);
  293.     windputc(ec);
  294.     windrefresh();
  295. }
  296.  
  297. /* control interaction on the main library bank screen */
  298. libinteract()
  299. {
  300.     int c, n, swap, voicenum, maxindex;
  301.     char *p, *data;
  302.  
  303.     flushmidi();
  304.     drawall();
  305.     for ( ;; ) {
  306.         Currrow = 0;
  307.         winderaserow(Currrow);
  308.         windgoto(Currrow,0);
  309.         windstr("Command --> ");
  310.         windrefresh();
  311.         
  312.         c = mouseorkey();
  313.         if ( c == MOUSE ) {
  314.             libmouse();
  315.             continue;
  316.         }
  317.  
  318.         if ( isprint(c) )
  319.             windputc(c);
  320.         clearmess();
  321.         switch ( c ) {
  322.         case ' ':
  323.             playnote(1);
  324.             break;
  325.         case '\n':
  326. #ifndef macintosh
  327.         case '\r':
  328. #endif
  329.             /* ignore */
  330.             break;
  331.         case EOF:
  332.         case 'q':
  333.             return;
  334.         case CH_REDRAW:
  335.             drawall();
  336.             break;
  337.         case 's':
  338.         case 'p':
  339.             swap = (c=='s')?1:0;
  340.             if ( Editcol==0 )
  341.                 tosyn(Synindex+Editrow,Yankdata,swap);
  342.             else
  343.                 tolib(Libindex+Editrow,Yankdata,swap);
  344.             updatedisplay();
  345.             pryankname();
  346.             break;
  347.         case 'y':
  348.             for(n=0;n<Voicesize;n++)
  349.                 Yankdata[n] = Currdata[n];
  350.             pryankname();
  351.             break;
  352.         case '?':
  353.             helpmessage();
  354.             break;
  355.         case SCR_DOWN:
  356.             maxindex = Nvoices - NUMONSCREEN;
  357.             if ( Editcol==0 ) {
  358.                 /* we're on the synth side */
  359.                 if ( (Synindex+=NUMONSCREEN/2) > maxindex )
  360.                     Synindex = maxindex;
  361.             }
  362.             else {
  363.                 /* we're on the lib side */
  364.                 if ( (Libindex+=NUMONSCREEN/2) > maxindex )
  365.                     Libindex = maxindex;
  366.             }
  367.             updatedisplay();
  368.             break;
  369.         case SCR_UP:
  370.             if ( Editcol==0 ) {
  371.                 /* we're on the synth side */
  372.                 if ( (Synindex-=NUMONSCREEN/2) < 0 )
  373.                     Synindex = 0;
  374.             }
  375.             else {
  376.                 /* we're on the lib side */
  377.                 if ( (Libindex-=NUMONSCREEN/2) < 0 )
  378.                     Libindex = 0;
  379.             }
  380.             updatedisplay();
  381.             break;
  382.         case '\033':
  383.         case '`':
  384.             allnotesoff();
  385.             break;
  386.         case 't':
  387.             transcmd();
  388.             break;
  389.         case 'd':    /* download from synth to display */
  390.             clrdata(Syndata,Nvoices*Voicesize);
  391.             if ( readsynth(Syndata) == 0 )
  392.                 syntodisplay(Synindex=0);
  393.             break;
  394.         case 'u':    /* upload TO synth */
  395.             if ( Editcol==0 ) {
  396.                 voicenum = Editrow+Synindex;
  397.                 data = &(VOICEBYTE(Syndata,voicenum,0));
  398.             }
  399.             else
  400.                 data = bankvoice(Editrow+Libindex);
  401.             upload(data);
  402.             break;
  403.         case 'r':
  404.             readall();
  405.             break;
  406.         case 'w':
  407.             writeall();
  408.             break;
  409.         case 'c':
  410.             setchan();
  411.             break;
  412.         case 'b':
  413.             /* cycle through banks, from 0 to LIBBANKS-1 */
  414.             if ( ++Libbank >= LIBBANKS )
  415.                 Libbank = 0;
  416.             libtodisplay(Libindex);
  417.             updatedisplay();
  418.             break;
  419.         case 'e':
  420.             p = (*Nameof)(Currdata);
  421.             if ( Editcol==0 ) {
  422.                 voicenum = Editrow+Synindex;
  423.                 data = &(VOICEBYTE(Syndata,voicenum,0));
  424.                 editdata(p,data);
  425.                 windclear();
  426.                 /* Update Currdata */
  427.                 for ( n=0; n<Voicesize; n++ )
  428.                     Currdata[n] = VOICEBYTE(Syndata,voicenum,n);
  429.             }
  430.             else {
  431.                 data = bankvoice(Editrow+Libindex);
  432.                 editdata(p,data);
  433.             }
  434.             drawall();
  435.             break;
  436.         case 'g': /* goto a specific voice */
  437.             do_goto();
  438.             break;
  439.         case CH_LEFT:
  440.             if ( Editcol==1 )
  441.                 editto(Editrow,0);
  442.             break;
  443.         case CH_DOWN:
  444.             if ( Editrow < (NUMONSCREEN-1) )
  445.                 editto(Editrow+1,Editcol);
  446.             else {
  447.                 /* we're at the bottom, so try to scroll */
  448.                 if ( Editcol==0 ) {
  449.                     /* we're on the synth side */
  450.                     if (Synindex<(Nvoices-NUMONSCREEN))
  451.                         Synindex++;
  452.                 }
  453.                 else {
  454.                     /* we're on the lib side */
  455.                     if (Libindex<(Nvoices-NUMONSCREEN))
  456.                         Libindex++;
  457.                 }
  458.                 updatedisplay();
  459.             }
  460.             break;
  461.         case CH_UP:
  462.             if ( Editrow>0 )
  463.                 editto(Editrow-1,Editcol);
  464.             else {
  465.                 /* we're at the top, so try to scroll */
  466.                 if ( Editcol==0 ) {
  467.                     /* we're on the synth side */
  468.                     if (Synindex>0)
  469.                         Synindex--;
  470.                 }
  471.                 else {
  472.                     /* we're on the lib side */
  473.                     if (Libindex>0)
  474.                         Libindex--;
  475.                 }
  476.                 updatedisplay();
  477.             }    
  478.             break;
  479.         case CH_RIGHT:
  480.             if ( Editcol==0 )
  481.                 editto(Editrow,1);
  482.             break;
  483.         case 'f':
  484.             filelist();
  485.             break;
  486.         default:
  487.             message("Unrecognized command!  Press '?' for help.");
  488.             break;
  489.         }
  490.     }
  491. }
  492.  
  493. filelist()
  494. {
  495.     char *p, *q, buff[BUFSIZ];
  496.     int n, ninline = 0, nprinted = 0;
  497.  
  498.     clearmess();
  499.     Currrow = -1;    /* To start message on top line */
  500.     openls();
  501.     message("Files in current directory:");
  502.     strcpy(buff,"  ");
  503.     while ( (p=nextls()) != NULL ) {
  504.         /* add the next file to the line being constructed */
  505.         q = &buff[strlen(buff)];
  506.         strcpy(q,p);
  507.         q += (n=strlen(p));
  508.         while ( n++ < 15 )
  509.             *q++ = ' ';
  510.         *q = '\0';
  511.         if ( ninline++ > 3 ) {
  512.             message(buff);
  513.             if ( nprinted++ > 4 ) {
  514.                 message("Press any key to continue ...");
  515.                 getconsole();
  516.                 clearmess();
  517.                 nprinted = 0;
  518.             }
  519.             strcpy(buff,"  ");
  520.             ninline = 0;
  521.         }
  522.     }
  523.     if ( ninline > 0 )
  524.         message(buff);
  525.     closels();
  526. }
  527.  
  528. libmouse()
  529. {
  530.     int row, col;
  531.  
  532.     getmouse(&row,&col);
  533.     if ( row <= FIRSTROW || row > FIRSTROW+NUMONSCREEN+1 )
  534.         goto getout;
  535.     if ( col < Cols/2 )
  536.         col = 0;
  537.     else
  538.         col = 1;
  539.     row = row - FIRSTROW - 1;
  540.     editto(row,col);
  541. getout:
  542.     /* wait until mouse button is released */
  543.     while ( statmouse() > 0 )
  544.         ;
  545. }
  546.  
  547. do_goto()
  548. {
  549.     int n, r, maxindex, new_ecol;
  550.     char sbuf[100], *sp;
  551.     
  552.     message("");
  553.     message("Where to? ");
  554.     windgets(sbuf);
  555.     
  556.     sp = sbuf;
  557.     switch(*sp++) {
  558.       case 's': /* synth side */
  559.         new_ecol = 0;
  560.         break;
  561.       case 'l': /* library side */
  562.         new_ecol = 1;
  563.         break;
  564.       default: /* no change in side */
  565.           new_ecol = Editcol;
  566.         sp--;    /* but don't trash the first character */
  567.         break;
  568.     }
  569.     
  570.     clearmess();
  571.     r = sscanf(sp, "%d", &n); /* this may fail - we handle it later */
  572.     if(Cvtnum != NULL) { /* convert to internal format if needed */
  573.         n = (*Cvtnum)(n) + 1; /* we are 1-based for user input */
  574.     }
  575.     if (Cvtanum != NULL) { /* convert using alphanumeric voice number */
  576.         n = (*Cvtanum)(sp) + 1;
  577.     }
  578.     if(r != 1) {
  579.         message("type one of: sn, ln, or n");
  580.         message("  s = synth side (literal character 's')");
  581.         message("  l = library side (literal character 'l')");
  582.         message("  n = voice number to select (an integer)");
  583.         return;
  584.     }
  585.     if(n <= 0 || n > Nvoices) { /* 1-based */
  586.         message("Bad voice number!");
  587.         return;
  588.     }
  589.     
  590.     /* it can be done.  nuke the old '*' and change columes (if needed) */
  591.     editchar(' ', Editrow, Editcol);
  592.     Editcol = new_ecol;
  593.     
  594.     /* try to center it */
  595.     maxindex = Nvoices - NUMONSCREEN;
  596.     if(Editcol == 0) {
  597.         Synindex = (n - 1) - NUMONSCREEN/2; /* 0-based */
  598.         if(Synindex < 0) { /* impossible to center */
  599.             Synindex = 0; /* so do your best */
  600.         } else if(Synindex > maxindex) {
  601.             Synindex = maxindex;
  602.         }
  603.         Editrow = (n - 1) - Synindex; /* and put a '*' on it */
  604.     } else {
  605.         Libindex = (n - 1) - NUMONSCREEN/2; /* 0-based */
  606.         if(Libindex < 0) {
  607.             Libindex = 0;
  608.         } else if(Libindex > maxindex) {
  609.             Libindex = maxindex;
  610.         }
  611.         Editrow = (n - 1) - Libindex;
  612.     }
  613.     
  614.     updatedisplay(); /* do the real work */
  615.     return;
  616. }
  617.  
  618. upload(data)
  619. char *data;
  620. {
  621.     int c, n;
  622.     char num[16];
  623.  
  624.     message("");
  625.     message("Upload TO synth:");
  626.     message("                 c - current voice");
  627.     message("                 a - ALL voices");
  628.     message("Choose --> ");
  629.     c = getconsole();
  630.     if ( c == 'c' ) {
  631.         clearmess();
  632.         if ( Sendone == NULL ) {
  633.             message("Single voices can't be sent to that synth!");
  634.             return;
  635.         }
  636.         message("What voice number to you want to send it TO? --> ");
  637.         windgets(num);
  638.         clearmess();
  639.         n = atoi(num);
  640.         if(Cvtnum != NULL) { /* convert to internal format if needed */
  641.             n = (*Cvtnum)(n) + 1; /* we are 1-based for user input */
  642.         }
  643.         if (Cvtanum != NULL) { /* howzabout alphanumeric format? */
  644.             n = (*Cvtanum)(num) + 1;
  645.         }
  646.         if ( n > 0 && n <= Nvoices ) {
  647.             if ( (*Sendone)(n-1,data) != 0 ) { /* 0-based on calls -SAF */
  648.                 message("Unable to write data to synth!");
  649.                 sprintf(Buff,"Reason: %s",Reason);
  650.                 message(Buff);
  651.             }
  652.         } else {
  653.             message("Bad voice number!");
  654.         }
  655.     }
  656.     else if ( c == 'a' ) {
  657.         clearmess();
  658.         if ( Sendbulk != NULL )
  659.             (*Sendbulk)(Syndata);
  660.         else {
  661.             for ( n=0; n<Nvoices; n++ ) {
  662.                 if ( (*Sendone)(n, &(VOICEBYTE(Syndata,n,0)) ) != 0 ) {
  663.                     message("Unable to write data to synth!");
  664.                     sprintf(Buff,"Reason: %s",Reason);
  665.                     message(Buff);
  666.                     break;
  667.                 }
  668.             }
  669.         }
  670.         /* clearmess(); */
  671.     }
  672.     else {
  673.         clearmess();
  674.         message("Bad choice!");
  675.     }
  676. }
  677.  
  678. helpmessage()
  679. {
  680. clearmess();
  681. sprintf(Buff,"%s,%s,%s,%s - move around              e - edit current voice",
  682.     STR_LEFT,STR_DOWN,STR_UP,STR_RIGHT);
  683. message(Buff);
  684. message("r - read voices from a file        y - yank into buffer");
  685. message("w - write voices to a file         p - put from buffer");
  686. message("b - cycle through library banks    s - swap current voice with yank buffer");
  687. message("t - transfer all voices            f - list files in current directory");
  688. message("d - download voices from synth     c - set MIDI channel");
  689. message("u - upload voices to synth         g - 'goto' form of moving around");
  690. message("q - quit                           <space> - play a note");
  691. }
  692.  
  693. updatedisplay()
  694. {
  695.     if ( Editcol==0 ) {
  696.         /* we're on the synth side */
  697.         syntodisplay(Synindex);
  698.         editto(Editrow,Editcol);
  699.     }
  700.     else {
  701.         /* we're on the lib side */
  702.         libtodisplay(Libindex);
  703.         editto(Editrow,Editcol);
  704.     }
  705. }
  706.  
  707. pryankname()
  708. {
  709.     char ybuff[33];
  710.     char *p;
  711.  
  712.     windgoto(YANKROW,YANKCOL-4);
  713.     windstr("                    ");
  714.     strcpy(ybuff,(*Nameof)(Yankdata));
  715.     /* take off trailing blanks */
  716.     p = ybuff + strlen(ybuff) - 1;
  717.     while ( p>ybuff && *p == ' ' )
  718.         *p-- = '\0';
  719.     windgoto(YANKROW,YANKCOL+7-strlen(ybuff)/2);
  720.     windstr(ybuff);
  721.     windrefresh();
  722. }
  723.  
  724. transcmd()
  725. {
  726.     int fromc;
  727.  
  728.     message("");
  729.     message("Transfer ALL voices:");
  730.     message("                       1:   <<-----   from library bank to synth bank");
  731.     message("                       2:   ----->>   from synth bank to library bank");
  732.     message("1 or 2 --> ");
  733.     fromc = getconsole();
  734.     windputc(fromc);
  735.     if ( fromc!='1' && fromc!='2' ) {
  736.         clearmess();
  737.         return;
  738.     }
  739.     switch ( fromc ) {
  740.     case '1':
  741.         copyall(bankvoice(0),Syndata);
  742.         syntodisplay(Synindex);
  743.         clearmess();
  744.         message("Use the 'u'pload command to actually send the synth bank voices to the synth.");
  745.         break;
  746.     case '2':
  747.         copyall(Syndata,bankvoice(0));
  748.         libtodisplay(Libindex);
  749.         clearmess();
  750.         break;
  751.     }
  752. }
  753.  
  754. copyall(fromdata,todata)
  755. char *fromdata;
  756. char *todata;
  757. {
  758.     int n, v;
  759.  
  760.     for ( v=0; v<Nvoices; v++ )
  761.         for ( n=0; n<Voicesize; n++ )
  762.             VOICEBYTE(todata,v,n) = VOICEBYTE(fromdata,v,n);
  763. }
  764.  
  765. message(s)
  766. char *s;
  767. {
  768.     windgoto(++Currrow,0);
  769.     windstr(s);
  770.     windrefresh();
  771. }
  772.  
  773. setchan()
  774. {
  775.     int c;
  776.  
  777.     message("New MIDI channel --> ");
  778.     windgets(Buff);
  779.     if ( (c=atoi(Buff)) <= 0 || c > 16 ) {
  780.         clearmess();
  781.         message("Invalid channel!");
  782.     }
  783.     else {
  784.         clearmess();
  785.         Channel = c;
  786.         showchan();
  787.     }
  788. }
  789.  
  790. showchan()
  791. {
  792.     windgoto(20,31);
  793.     windstr("MIDI Channel: ");
  794.     sprintf(Buff,"%d ",Channel);
  795.     windstr(Buff);
  796.     windrefresh();
  797. }
  798.  
  799. /* read data from a file, filling the current library bank. */
  800. readall()
  801. {
  802.     char fname[100];
  803.     FILE *f;
  804.     int v, n, r;
  805.  
  806.     message("File name --> ");
  807.     windgets(fname);
  808.     OPENBINFILE(f,fname,"r");
  809.     if (f == NULL ) {
  810.         sprintf(Buff,"Can't open '%s'!",fname);
  811.         message(Buff);
  812.         return;
  813.     }
  814.     /* Check the first byte.  If it's 0xdd, then the format is mine. */
  815.     /* If the first byte is 0-31, it's also mine. */
  816.     n = (getc(f) & 0xff);
  817.     if ( n == 0xdd || n<=31 ) {
  818.         if ( n <= 31 )
  819.             ungetc(n,f);
  820.         /* This is my format, just raw data. */
  821.         for ( v=0; v<Nvoices; v++ ) {
  822.             char *p = bankvoice(v);
  823.             for ( n=0; n<Voicesize; n++ )
  824.                 *p++ = getc(f);
  825.         }
  826.         r = 0;
  827.     }
  828.     /* code for other formats would go here */
  829.     else {
  830.         message("Unknown file format");
  831.         r = 1;
  832.     }
  833.     fclose(f);
  834.     if ( r==0 ) {
  835.         libtodisplay(Libindex=0);
  836.         clearmess();
  837.     }
  838. }
  839.  
  840. /* write current library bank to a file */
  841. writeall()
  842. {
  843.     char fname[100];
  844.     FILE *f;
  845.     int v, n;
  846.  
  847.     message("File name --> ");
  848.     windgets(fname);
  849.     OPENBINFILE(f,fname,"w");
  850.     if ( f == NULL ) {
  851.         sprintf(Buff,"Can't open '%s'!",fname);
  852.         message(Buff);
  853.         return;
  854.     }
  855.     putc(0xdd,f);    /* magic byte to identify my format */
  856.     for ( v=0; v<Nvoices; v++ ) {
  857.         char *p = bankvoice(v);
  858.         for ( n=0; n<Voicesize; n++ )
  859.             putc(*p++,f);
  860.     }
  861.     fclose(f);
  862.     clearmess();
  863. }
  864.  
  865. /* draw main library/synth voice bank screen */
  866. drawall()
  867. {
  868.     windclear();
  869.     template();
  870.     libtodisplay(Libindex);
  871.     syntodisplay(Synindex);
  872.     editto(Editrow,Editcol);
  873.     pryankname();
  874.     showchan();
  875. }
  876.  
  877. /*
  878.  * tosyn
  879.  *
  880.  * Store the given 'data' in in voice 'voicenum' (both in Syndata
  881.  * AND on the synth itself).  If swap is non-zero, the voice is swapped
  882.  * with the current voice in Syndata.
  883.  */
  884.  
  885. tosyn(voicenum,data,swap)
  886. char *data;
  887. {
  888.     int n, t;
  889.  
  890.     for ( n=0; n<Voicesize; n++ ) {
  891.         if ( swap ) {
  892.             t = VOICEBYTE(Syndata,voicenum,n);
  893.             VOICEBYTE(Syndata,voicenum,n) = data[n];
  894.             data[n] = t;
  895.         }
  896.         else
  897.             VOICEBYTE(Syndata,voicenum,n) = data[n];
  898.     }
  899. }
  900.  
  901. tolib(voicenum,data,swap)
  902. char *data;
  903. {
  904.     int n, t;
  905.     char *p = bankvoice(voicenum);
  906.  
  907.     for ( n=0; n<Voicesize; n++ ) {
  908.         if ( swap ) {
  909.             t = *p;
  910.             *p = data[n];
  911.             data[n] = t;
  912.         }
  913.         else
  914.             *p = data[n];
  915.         p++;
  916.     }
  917. }
  918.  
  919. tocurrent(data,voicenum)
  920. char *data;
  921. int voicenum;
  922. {
  923.     int n;
  924.  
  925.     for ( n=0; n<Voicesize; n++ )
  926.         Currdata[n] = VOICEBYTE(data,voicenum,n);
  927.     (*Sendedit)(Currdata);
  928. }
  929.  
  930. /*
  931.  * readsynth
  932.  *
  933.  * Read a bulk dump from the synth, with some tolerance for errors.
  934.  */
  935. readsynth(data)
  936. char *data;
  937. {
  938.     if ( Getbulk == NULL ) {
  939.         message("That synth is unable to dump anything!!");
  940.         return(1);
  941.     }
  942.     message("Trying to download data from synth...");
  943.     if ( (*Getbulk)(data) == 0 ) {
  944.         clearmess();
  945.         return(0);
  946.     }
  947.     message("Unable to read data from synth!");
  948.     sprintf(Buff,"Reason: %s",Reason);
  949.     message(Buff);
  950.     message("Perhaps connections are amiss?");
  951.     return(1);
  952. }
  953.  
  954. char *
  955. vnumtext(n)
  956. {
  957.     static char vnbuff[6];
  958.  
  959.     if ( Numof == NULL ) {
  960.         sprintf(vnbuff,"%2d",n);
  961.         return(vnbuff);
  962.     }
  963.     else
  964.         return((*Numof)(n - 1)); /* keep this 0-based */
  965. }
  966.  
  967. /*
  968.  * syntodisplay(n)
  969.  *
  970.  * Tranfer Syndata names to dialog boxes (Dxvoices) starting at n.
  971.  */
  972. syntodisplay(n)
  973. {
  974.     int k, r;
  975.  
  976.     /* for the NUMONSCREEN dialog boxes */
  977.     for ( k=0; k<NUMONSCREEN; k++ ) {
  978.         r = FIRSTROW+1+k;
  979.         windgoto(r,LEFTSIDE);
  980.         sprintf(Buff,"%-3s",vnumtext(n+k+1));
  981.         windstr(Buff);
  982.         windgoto(r,LEFTSIDE+6);
  983.         windstr("                 ");
  984.  
  985.         /* pull the name out of the Syndata */
  986.         windgoto(r,LEFTSIDE+6);
  987.         windstr((*Nameof)( & (VOICEBYTE(Syndata,n+k,0) )) );
  988.     }
  989.     windrefresh();
  990. }
  991.  
  992. /*
  993.  * libtodisplay
  994.  *
  995.  * Tranfer Libdata names to the screen, starting at voice 'firstv'.
  996.  */
  997.  
  998. libtodisplay(firstv)
  999. {
  1000.     int k, r;
  1001.  
  1002.     windgoto(FIRSTROW-1,RIGHTSIDE-1);
  1003.     sprintf(Buff,"Library Voices (Bank %d)",Libbank+1);
  1004.     windstr(Buff);
  1005.  
  1006.     /* for the NUMONSCREEN dialog boxes */
  1007.     for ( k=0; k<NUMONSCREEN; k++ ) {
  1008.         r = FIRSTROW+1+k;
  1009.         windgoto(r,RIGHTSIDE);
  1010.         sprintf(Buff,"%-3s",vnumtext(firstv+k+1));
  1011.         windstr(Buff);
  1012.         windgoto(r,RIGHTSIDE+6);
  1013.         windstr("                 ");
  1014.  
  1015.         /* pull the name out of the Libdata */
  1016.         windgoto(r,RIGHTSIDE+6);
  1017.         windstr((*Nameof)(bankvoice(firstv+k)));
  1018.     }
  1019.     windrefresh();
  1020. }
  1021.  
  1022. allnotesoff()
  1023. {
  1024.     int n;
  1025.  
  1026.     /* Go through all channels. */
  1027.     for ( n=0; n<15; n++ ) {
  1028.         sendmidi(n | 0xb0);
  1029.         sendmidi(0x7b);
  1030.         sendmidi(0x00);
  1031.     }
  1032. }
  1033.  
  1034. /*
  1035.  * Below are generic edit routines, which manage a screen display
  1036.  * showing parameter values, and let you roam around and make changes.
  1037.  * The display is managed by the contents of the P array, which
  1038.  * contains the name, screen location, min/max values, etc. of
  1039.  * each parameter.
  1040.  */
  1041.  
  1042. int Prow = 0;
  1043. int Pcol = 0;
  1044. int Parm = 0;
  1045.  
  1046. /* redraw the parameter screen */
  1047. showallparms(name)
  1048. char *name;
  1049. {
  1050.     int n;
  1051.     char *s;
  1052.  
  1053.     windclear();
  1054.  
  1055.     showname(name);
  1056.     windgoto(1,0);
  1057.     for(n=strlen(name)+6;n>0;n--)
  1058.         windputc('=');
  1059.  
  1060.     /* The L array contains arbitrary screen labels */
  1061.     for ( n=0; L[n].l_text != NULL; n++ ) {
  1062.         windgoto(L[n].l_row,L[n].l_col);
  1063.         windstr(L[n].l_text);
  1064.     }
  1065.     /* Display each parameter value, and a label if there is one. */
  1066.     for ( n=0; P[n].p_name != NULL; n++ ) {
  1067.         if ( P[n].p_flags != 0 )
  1068.             continue;
  1069.         if ( (s=P[n].p_label) != NULL )
  1070.             showstr(s,P[n].p_lrow,P[n].p_lcol,0);
  1071.         showparam(n,0);
  1072.     }
  1073.     windrefresh();
  1074. }
  1075.  
  1076. showname(name)
  1077. char *name;
  1078. {
  1079.     windgoto(0,0);
  1080.     windstr("Name:                 ");
  1081.     windgoto(0,6);
  1082.     windstr(name);
  1083. }
  1084.  
  1085. showparam(n,eras)
  1086. {
  1087.     char *p;
  1088.  
  1089.     /* The p_tovis element of the P array is a function which, given */
  1090.     /* the parameter value as an argument, returns a string which is */
  1091.     /* what should be displayed on the screen. */
  1092.     p = (*(P[n].p_tovis))(P[n].p_val);
  1093.     showstr(p,P[n].p_vrow,P[n].p_vcol,eras);
  1094. }
  1095.  
  1096. showstr(p,row,col,eras)
  1097. register char *p;
  1098. register int col;
  1099. {
  1100.     register int c;
  1101.  
  1102.     windgoto(row,col);
  1103.     while ( (c=(*p++)) != '\0' ) {
  1104.         switch(c){
  1105.         case '~':
  1106.             switch( (c=(*p++)) ) {
  1107.             case 'u': row--; goto wgoto;
  1108.             case 'd': row++; goto wgoto;
  1109.             case 'l': col--; goto wgoto;
  1110.             case 'r': col++;
  1111.                 wgoto:
  1112.                 windgoto(row,col);
  1113.                 break;
  1114.             default:
  1115.                 windputc(eras?' ':c);
  1116.                 col++;
  1117.                 break;
  1118.             }
  1119.             break;
  1120.         default:
  1121.             windputc(eras?' ':c);
  1122.             col++;
  1123.             break;
  1124.         }
  1125.     }
  1126. }
  1127.  
  1128. /* Allow roaming around and changing of parameter values. */
  1129. editdata(name,data)
  1130. char *name;
  1131. char *data;    /* vmem format */
  1132. {
  1133.     int c, n;
  1134.  
  1135.     windclear();
  1136.     windrefresh();
  1137.     /* enable all the parameters */
  1138.     for ( n=0; P[n].p_name != NULL; n++ )
  1139.         enableparm(n);
  1140.  
  1141.     /* Take the voice data and put it into P */
  1142.     (*Datain)(data);
  1143.  
  1144.     Prow = Pcol = 0;
  1145.     Changed = 0;
  1146.     Redraw = 1;
  1147.     gotoparm(CH_RIGHT);    /* Get to the first parameter */
  1148.     for ( ;; ) {
  1149.         if ( Redraw ) {
  1150.             showallparms(name);
  1151.             Redraw = 0;
  1152.         }
  1153.         windgoto(Prow,Pcol);
  1154.         windrefresh();
  1155.         c = mouseorkey();
  1156.         if ( c == MOUSE ) {
  1157.             editmouse();
  1158.             continue;
  1159.         }
  1160.         switch(c){
  1161.         case CH_RIGHT:
  1162.         case CH_UP:
  1163.         case CH_DOWN:
  1164.         case CH_LEFT:
  1165.             gotoparm(c);
  1166.             break;
  1167.         case CH_REDRAW:
  1168.             showallparms(name);
  1169.             break;
  1170.         case 'N':
  1171.             /* Allow changing of voice name */
  1172.             windgoto(0,5);
  1173.             windstr("                ");
  1174.             windgoto(0,6);
  1175.             windrefresh();
  1176.             windgets(Buff);
  1177.             if ( Buff[0]!='\0' && Buff[0]!='\n' )
  1178.                 (*Setnameof)(data,Buff);
  1179.             showname(name=(*Nameof)(data));
  1180.             Changed = 1;
  1181.             break;
  1182.  
  1183.         case CH_INC:
  1184.             adjuparm(1);
  1185.             break;
  1186.         case CH_INC2:
  1187.             adjuparm(4);
  1188.             break;
  1189.         case CH_INC3:
  1190.             adjuparm(P[Parm].p_max - P[Parm].p_min);
  1191.             break;
  1192.         case CH_DEC:
  1193.             adjuparm(-1);
  1194.             break;
  1195.         case CH_DEC2:
  1196.             adjuparm(-4);
  1197.             break;
  1198.         case CH_DEC3:
  1199.             adjuparm(P[Parm].p_min - P[Parm].p_max);
  1200.             break;
  1201. #ifdef OLDSTUFF
  1202.         case 'a':
  1203.             sendaced(data);
  1204.             playnote(0);
  1205.             break;
  1206. #endif
  1207.         case ' ':
  1208.         case '\n':
  1209. #ifndef macintosh
  1210.         case '\r':
  1211. #endif
  1212.             if ( Changed ) {
  1213.                 (*Dataout)(data);
  1214.                 (*Sendedit)(data);
  1215.             }
  1216.             playnote(0);
  1217.             break;
  1218.         case '\033':
  1219.         case '`':
  1220.             allnotesoff();
  1221.             break;
  1222.         case 'q':
  1223.         case EOF:
  1224.             if ( Changed ) {
  1225.                 (*Dataout)(data);
  1226.                 (*Sendedit)(data);
  1227.             }
  1228.             return;
  1229.         default:
  1230.             break;
  1231.         }
  1232.     }
  1233. }
  1234.  
  1235. adjuparm(incdec)
  1236. {
  1237.     int v, n;
  1238.  
  1239.     v = P[Parm].p_val + incdec;
  1240.     if ( v < (n=P[Parm].p_min) )
  1241.         v = n;
  1242.     if ( v > (n=P[Parm].p_max) )
  1243.         v = n;
  1244.     Changed = 1;
  1245.     showparam(Parm,1);    /* erase the old val */
  1246.     P[Parm].p_val = v;
  1247.     showparam(Parm,0);    /* show the new val */
  1248. }
  1249.  
  1250. editmouse()
  1251. {
  1252.     int row, col, thisparm;
  1253.  
  1254.     getmouse(&row,&col);
  1255.     thisparm = closeparm(row,col);
  1256.     if ( thisparm == Parm ) {
  1257.         if ( statmouse() > 1 )
  1258.             adjuparm(-1);    /* right button */
  1259.         else if ( statmouse() == 1 ) /* added by mab - bug fix */
  1260.             adjuparm(1);    /* left button */
  1261.     }
  1262.     else {
  1263.         Parm = thisparm;
  1264.         Prow = P[Parm].p_vrow;
  1265.         Pcol = P[Parm].p_vcol;
  1266.     }
  1267. }
  1268.  
  1269. /* closeparm - Find the closest parameter */
  1270. closeparm(row,col)
  1271. {
  1272.     register struct paraminfo *pp;
  1273.     register int n;
  1274.     int dist, mindist, minparm, dr, dc;
  1275.  
  1276.     minparm = 0;
  1277.     mindist = Rows + Cols;
  1278.     for ( n=0,pp=P; pp->p_name != NULL; n++,pp++ ) {
  1279.         if ( pp->p_flags != 0 )
  1280.             continue;
  1281.         if ( (dr=row-(pp->p_vrow)) < 0 )
  1282.             dr = -dr;
  1283.         if ( (dc=col-(pp->p_vcol)) < 0 )
  1284.             dc = -dc;
  1285.         if ( (dist=dr*dr+dc*dc) < mindist ) {
  1286.             minparm = n;
  1287.             mindist = dist;
  1288.         }
  1289.     }
  1290.     return(minparm);
  1291. }
  1292.  
  1293. /* playnote - play the 'auto' note */
  1294. playnote(i)
  1295. {
  1296.     int pitch, vol, dur, chan;
  1297.     long endtime;
  1298.  
  1299.     pitch = getval("autopitch");
  1300.     if(i == 0) { /* called from inside edit-mode */
  1301.         chan = getval("autochan");
  1302.     } else { /* called from the top level */
  1303.         chan = Channel;
  1304.     }
  1305.     vol = getval("autovol");
  1306.     dur = getval("autodur");
  1307.     endtime = milliclock() + dur * 100;
  1308.     midinote(1,chan,pitch,vol);
  1309.     while ( milliclock() < endtime )
  1310.         ;
  1311.     midinote(0,chan,pitch,vol);
  1312. }
  1313.  
  1314. /* gotoparm - search for the next parameter in the specified direction */
  1315. gotoparm(dir)
  1316. {
  1317.     int n, k, inc, pm, orig, r = Prow, c = Pcol;
  1318.  
  1319.     if ( dir==CH_LEFT || dir==CH_RIGHT ) {
  1320.         if ( dir==CH_LEFT )
  1321.             c--;
  1322.         else
  1323.             c++;
  1324.         orig = c;
  1325.         inc = 0;
  1326.         pm = -1;
  1327.         /* look up and down, alternately */
  1328.         for ( n=2*Rows; n>0; n-- ) {
  1329.             r += (pm * inc++);
  1330.             pm = -pm;
  1331.             if ( r < 0 || r >= Rows )
  1332.                 continue;
  1333.             if ( dir == CH_LEFT ) {
  1334.                 for ( c=orig; c>=0; c-- ) {
  1335.                     if ( parmat(r,c) )
  1336.                         return;
  1337.                 }
  1338.             }
  1339.             else {
  1340.                 for ( c=orig; c<Cols; c++ ) {
  1341.                     if ( parmat(r,c) )
  1342.                         return;
  1343.                 }
  1344.             }
  1345.         }
  1346.         return;
  1347.     }
  1348.     if ( dir==CH_DOWN || dir==CH_UP ) {
  1349.         if ( dir==CH_DOWN )
  1350.             r++;
  1351.         else
  1352.             r--;
  1353.         orig = c;
  1354.         while ( r >= 0 && r < Rows ) {
  1355.             /* look toward both sides at the same time */
  1356.             inc = 0;
  1357.             pm = -1;
  1358.             for ( k=2*Cols; k>0; k-- ) {
  1359.                 c += (pm * inc++);
  1360.                 pm = -pm;
  1361.                 if ( c < 0 || c >= Cols )
  1362.                     continue;
  1363.                 if ( parmat(r,c) )
  1364.                     return;
  1365.             }
  1366.             if ( dir==CH_DOWN )
  1367.                 r++;
  1368.             else
  1369.                 r--;
  1370.             c = orig;
  1371.         }
  1372.         return;
  1373.     }
  1374. }
  1375.  
  1376. /* paramat - return non-zero if a parameter value is at position r,c */
  1377. parmat(r,c)
  1378. register int r, c;
  1379. {
  1380.     register int n;
  1381.     register struct paraminfo *pp;
  1382.  
  1383.     for ( n=0,pp=P; pp->p_name != NULL; n++,pp++ ) {
  1384.         if ( pp->p_flags != 0 )
  1385.             continue;
  1386.         if ( pp->p_vrow==r && pp->p_vcol==c ) {
  1387.             Prow = r;
  1388.             Pcol = c;
  1389.             Parm = n;
  1390.             return(1);
  1391.         }
  1392.     }
  1393.     return(0);
  1394. }
  1395.  
  1396. /* parmindex - return index (in P) of a given parameter name. */
  1397. parmindex(name)
  1398. char *name;
  1399. {
  1400.     int n;
  1401.     char *s;
  1402.  
  1403.     for ( n=0; (s=P[n].p_name) != NULL; n++ ) {
  1404.         if ( strcmp(s,name) == 0 )
  1405.             return(n);
  1406.     }
  1407.     sprintf(Buff,"HEY, PARMINDEX(%s) NOT FOUND!",name);
  1408.     windstr(Buff);
  1409.     windrefresh();
  1410.     return(-1);
  1411. }
  1412.  
  1413. setval(name,v)
  1414. char *name;
  1415. {
  1416.     int n;
  1417.  
  1418.     if ( (n=parmindex(name)) < 0 )
  1419.         return;
  1420.     P[n].p_val = v;
  1421. }
  1422.  
  1423. getval(name)
  1424. char *name;
  1425. {
  1426.     int n;
  1427.  
  1428.     if ( (n=parmindex(name)) < 0 )
  1429.         return(0);
  1430.     return(P[n].p_val);
  1431. }
  1432.  
  1433. enableparm(n)
  1434. {
  1435.     if ( P[n].p_flags != 0 )
  1436.         P[n].p_flags = 0;
  1437. }
  1438.  
  1439. disableparm(n)
  1440. {
  1441.     if ( P[n].p_flags == 0 )
  1442.         P[n].p_flags = 1;
  1443. }
  1444.  
  1445. midinote(onoff,chan,pitch,vol)
  1446. {
  1447.     sendmidi( ((onoff==1)?(0x90):(0x80)) | ((chan-1)&0xf) );
  1448.     sendmidi( pitch & 0x7f );
  1449.     sendmidi( vol & 0x7f );
  1450. }
  1451.  
  1452. static char Nbuff[16];
  1453.  
  1454. char *visnum(v)
  1455. {
  1456.     sprintf(Nbuff,"%d",v);
  1457.     return(Nbuff);
  1458. }
  1459. char *visonoff(v)
  1460. {
  1461.     if ( v==0 )
  1462.         return("off");
  1463.     else
  1464.         return("on");
  1465. }
  1466.  
  1467. char *
  1468. bankvoice(voice)
  1469. {
  1470.     int offset = Libbank * Nvoices * Voicesize + voice * Voicesize;
  1471.     return(Libdata + offset);
  1472. }
  1473.