home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume6 / glib / part05 / vis.c < prev   
Encoding:
C/C++ Source or Header  |  1989-05-14  |  10.0 KB  |  561 lines
  1. /* $Id: vis.c,v 1.6 89/05/06 17:13:46 lee Exp $
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * Data Display Routines
  5.  *
  6.  * Code started 16 JAN 89 --  Michael R. Kesti mrk@gvgspd.GVG.TEK.COM
  7.  * $Log:    vis.c,v $
  8.  * Revision 1.6  89/05/06  17:13:46  lee
  9.  * rel. to comp.sources.misc
  10.  * 
  11.  */
  12.  
  13. #include <stdio.h>
  14.  
  15.  
  16. char *
  17. vispan(v)
  18. {
  19.     switch (v) {
  20.     case 0: return("7>");
  21.     case 1: return("6>");
  22.     case 2: return("5>");
  23.     case 3: return("4>");
  24.     case 4: return("3>");
  25.     case 5: return("2>");
  26.     case 6: return("1>");
  27.     case 7: return("><");
  28.     case 8: return("<1");
  29.     case 9: return("<2");
  30.     case 10: return("<3");
  31.     case 11: return("<4");
  32.     case 12: return("<5");
  33.     case 13: return("<6");
  34.     case 14: return("<7");
  35.     }
  36.     return("*");
  37. }
  38.  
  39. char *
  40. visreverbtype(v)
  41. {
  42.     switch (v) {
  43.     case 0: return("ROOM 1");
  44.     case 1: return("ROOM 2");
  45.     case 2: return("HALL 1");
  46.     case 3: return("HALL 2");
  47.     case 4: return("PLATE");
  48.     case 5: return("DELAY 1");
  49.     case 6: return("DELAY 2");
  50.     case 7: return("DELAY 3");
  51.     case 8: return("OFF");
  52.     }
  53.     return("*");
  54. }
  55.  
  56. char *visreverbtime(v)
  57. {
  58. static char visreverbtimebuf[2];
  59.  
  60.     if((v >= 0) && (v <= 7)) {
  61.         sprintf(visreverbtimebuf,"%d",v + 1);
  62.         return(visreverbtimebuf);
  63.     } else {
  64.         return("*");
  65.     }
  66. }
  67.  
  68. char *visreverblevel(v)
  69. {
  70. static char visreverblevelbuf[2];
  71.  
  72.     if((v >= 0) && (v <= 7)) {
  73.         sprintf(visreverblevelbuf,"%d",v);
  74.         return(visreverblevelbuf);
  75.     } else {
  76.         return("*");
  77.     }
  78. }
  79.  
  80. char *vispatchlevel(v)
  81. {
  82. static char vispatchlevelbuf[4];
  83.  
  84.     if((v >= 0) && (v <= 100)) {
  85.         sprintf(vispatchlevelbuf,"%d",v);
  86.         return(vispatchlevelbuf);
  87.     } else {
  88.         return("*");
  89.     }
  90. }
  91.  
  92. char *
  93. viskeymode(v)
  94. {
  95.     switch (v) {
  96.     case 0: return("WHOLE");
  97.     case 1: return("DUAL");
  98.     case 2: return("SPLIT");
  99.     }
  100.     return("*");
  101. }
  102.  
  103. static    char *split_table[] = {
  104.     "C",
  105.     "C#",
  106.     "D",
  107.     "D#",
  108.     "E",
  109.     "F",
  110.     "F#",
  111.     "G",
  112.     "G#",
  113.     "A",
  114.     "A#",
  115.     "B"
  116. };
  117.  
  118. char *
  119. vissplit(v)
  120. {
  121. static    char    vissplitbuf[4];
  122.  
  123.     if((v >= 0) && (v <= 61)) {
  124.         strcpy(vissplitbuf, split_table[v % 12]);
  125.         if(strlen(vissplitbuf) == 1) {
  126.             vissplitbuf[1] = (((v / 12) + 2) + '0');
  127.             vissplitbuf[2] = 0;
  128.         } else {
  129.             vissplitbuf[2] = (((v / 12) + 2) + '0');
  130.             vissplitbuf[3] = 0;
  131.         }
  132.         return(vissplitbuf);
  133.     } else {
  134.     return("*");
  135.     }
  136. }
  137.  
  138. char *
  139. vistonegroup(v)
  140. {
  141.     switch (v) {
  142.     case 0: return("A");
  143.     case 1: return("B");
  144.     case 2: return("I");
  145.     case 3: return("R");
  146.     }
  147.     return("*");
  148. }
  149.  
  150. char *
  151. visrtone(v)
  152. {
  153. static char visrtonebuf[4];
  154.     if(v >= 0 && v <= 127) {
  155.         if(v < 64) {
  156.             sprintf(visrtonebuf,"% 02d",v + 1);
  157.             visrtonebuf[0] = 'I';
  158.         } else {
  159.             if(v == 127) {
  160.                 strcpy(visrtonebuf, "OFF");
  161.             } else {
  162.                 v -= 64;
  163.                 sprintf(visrtonebuf," %02d",v + 1);
  164.                 visrtonebuf[0] = 'R';
  165.             }
  166.         }
  167.         return(visrtonebuf);
  168.     }
  169.     return("*");
  170. }
  171.  
  172. char *vistonenum(v)
  173. {
  174. static char vistonenumbuf[3];
  175.  
  176.     if((v >= 0) && (v <= 63)) {
  177.         sprintf(vistonenumbuf,"%02d",v + 1);
  178.         return(vistonenumbuf);
  179.     } else {
  180.         return("*");
  181.     }
  182. }
  183.  
  184. char *viskeyshift(v)
  185. {
  186. static char viskeyshiftbuf[4];
  187.  
  188.     if((v >= 0) && (v <= 23)) {
  189.         sprintf(viskeyshiftbuf,"-%d",abs(v - 24));
  190.         return(viskeyshiftbuf);
  191.     } else if(v == 24) {
  192.         sprintf(viskeyshiftbuf,"0");
  193.         return(viskeyshiftbuf);
  194.     } else if((v >= 25) && (v <= 48)) {
  195.         sprintf(viskeyshiftbuf,"+%d", (v - 24));
  196.         return(viskeyshiftbuf);
  197.     } else {
  198.         return("*");
  199.     }
  200. }
  201.  
  202. char *visfinetune(v)
  203. {
  204. static char visfinetunebuf[4];
  205.  
  206.     if((v >= 0) && (v <= 49)) {
  207.         sprintf(visfinetunebuf,"-%d",abs(v - 50));
  208.         return(visfinetunebuf);
  209.     } else if(v == 50) {
  210.         sprintf(visfinetunebuf,"0");
  211.         return(visfinetunebuf);
  212.     } else if((v >= 51) && (v <= 100)) {
  213.         sprintf(visfinetunebuf,"+%d",(v - 50));
  214.         return(visfinetunebuf);
  215.     } else {
  216.         return("*");
  217.     }
  218. }
  219.  
  220. char *visbendrange(v)
  221. {
  222. static char visbendrangebuf[3];
  223.  
  224.     if((v >= 0) && (v <= 24)) {
  225.         sprintf(visbendrangebuf,"%d",v);
  226.         return(visbendrangebuf);
  227.     } else {
  228.         return("*");
  229.     }
  230. }
  231.  
  232. char *visassignmode(v)
  233. {
  234. static char visassignmodebuf[2];
  235.  
  236.     if((v >= 0) && (v <= 3)) {
  237.         sprintf(visassignmodebuf,"%d",v);
  238.         return(visassignmodebuf);
  239.     } else {
  240.         return("*");
  241.     }
  242. }
  243.  
  244. char *vistonebal(v)
  245. {
  246. static char vistonebalbuf[30];
  247. static char vistonebalbuf1[30];
  248. int n;
  249.  
  250.     if((v >= 0) && (v <= 100)) {
  251.         sprintf(vistonebalbuf,"%d", v);
  252.         for(n = 0 ; n < (30 - strlen(vistonebalbuf)) ; n++)
  253.             strcat(vistonebalbuf, " ");
  254.         sprintf(vistonebalbuf1,"%d", abs(v - 100));
  255.         strcat(vistonebalbuf, vistonebalbuf1);
  256.         return(vistonebalbuf);
  257.     } else {
  258.         return("*");
  259.     }
  260. }
  261.  
  262. char *
  263. visstruct(v)
  264. {
  265.     if((v >= 0) && (v <= 12)) {
  266.         switch(v) {
  267.             case 0:
  268.                 return("~l~l~u~u~u __|_ ~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lS 1  S");
  269.                 break;
  270.             case 1:
  271.                 return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lS 2  S");
  272.                 break;
  273.             case 2:
  274.                 return("~l~l~u~u~u __|_ ~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lP 3  S");
  275.                 break;
  276.             case 3:
  277.                 return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lP 4  S");
  278.                 break;
  279.             case 4:
  280.                 return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lS 5  P");
  281.                 break;
  282.             case 5:
  283.                 return("~l~l~u~u~u __|_ ~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lP 6  P");
  284.                 break;
  285.             case 6:
  286.                 return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lP 7  P");
  287.                 break;
  288.             case 7:
  289.                 return("~l~l~u~u~u|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lS 8  S");
  290.                 break;
  291.             case 8:
  292.                 return("~l~l~u~u~u|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lP 9  P");
  293.                 break;
  294.             case 9:
  295.                 return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lS 10 S");
  296.                 break;
  297.             case 10:
  298.                 return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lP 11 S");
  299.                 break;
  300.             case 11:
  301.                 return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lS 12 P");
  302.                 break;
  303.             case 12:
  304.                 return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lP 13 P");
  305.                 break;
  306.         }
  307.     } else {
  308.         return("*");
  309.     }
  310. }
  311.  
  312. char *
  313. vispmute(v)
  314. {
  315.     switch (v) {
  316.     case 0: return("_    _    _    _");
  317.     case 1: return("1    _    _    _");
  318.     case 2: return("_    2    _    _");
  319.     case 3: return("1    2    _    _");
  320.     case 4: return("_    _    3    _");
  321.     case 5: return("1    _    3    _");
  322.     case 6: return("_    2    3    _");
  323.     case 7: return("1    2    3    _");
  324.     case 8: return("_    _    _    4");
  325.     case 9: return("1     _   _    4");
  326.     case 10: return("_    2    _    4");
  327.     case 11: return("1    2    _    4");
  328.     case 12: return("_    _    3    4");
  329.     case 13: return("1    _    3    4");
  330.     case 14: return("_    2    3    4");
  331.     case 15: return("1    2    3    4");
  332.     }
  333.     return("*");
  334. }
  335.  
  336. char *
  337. visenvmode(v)
  338. {
  339.     switch (v) {
  340.     case 0: return("NORMAL");
  341.     case 1: return("NO SUSTAIN");
  342.     }
  343.     return("*");
  344. }
  345.  
  346. static    char *cpitch_table[] = {
  347.     "C",
  348.     "C#",
  349.     "D",
  350.     "D#",
  351.     "E",
  352.     "F",
  353.     "F#",
  354.     "G",
  355.     "G#",
  356.     "A",
  357.     "A#",
  358.     "B"
  359. };
  360.  
  361. char *
  362. viscpitch(v)
  363. {
  364. static    char    viscpitchbuf[4];
  365.  
  366.     if((v >= 0) && (v <= 96)) {
  367.         strcpy(viscpitchbuf, cpitch_table[v % 12]);
  368.         if(strlen(viscpitchbuf) == 1) {
  369.             viscpitchbuf[1] = (((v / 12) + 1) + '0');
  370.             viscpitchbuf[2] = 0;
  371.         } else {
  372.             viscpitchbuf[2] = (((v / 12) + 1) + '0');
  373.             viscpitchbuf[3] = 0;
  374.         }
  375.         return(viscpitchbuf);
  376.     } else {
  377.     return("*");
  378.     }
  379. }
  380.  
  381. char *
  382. vispkeyfol(v)
  383. {
  384.     switch (v) {
  385.     case 0: return("-1");
  386.     case 1: return("-1/2");
  387.     case 2: return("-1/4");
  388.     case 3: return("0");
  389.     case 4: return("1/8");
  390.     case 5: return("1/4");
  391.     case 6: return("3/8");
  392.     case 7: return("1/2");
  393.     case 8: return("5/8");
  394.     case 9: return("3/4");
  395.     case 10: return("7/8");
  396.     case 11: return("1");
  397.     case 12: return("5/4");
  398.     case 13: return("3/2");
  399.     case 14: return("2");
  400.     case 15: return("s1");
  401.     case 16: return("s2");
  402.     }
  403.     return("*");
  404. }
  405.  
  406. char *
  407. vistkeyfol(v)
  408. {
  409.     switch (v) {
  410.     case 0: return("-1");
  411.     case 1: return("-1/2");
  412.     case 2: return("-1/4");
  413.     case 3: return("0");
  414.     case 4: return("1/8");
  415.     case 5: return("1/4");
  416.     case 6: return("3/8");
  417.     case 7: return("1/2");
  418.     case 8: return("5/8");
  419.     case 9: return("3/4");
  420.     case 10: return("7/8");
  421.     case 11: return("1");
  422.     case 12: return("5/4");
  423.     case 13: return("3/2");
  424.     case 14: return("2");
  425.     }
  426.     return("*");
  427. }
  428.  
  429. char *viswavebank(v)
  430. {
  431.     switch (v) {
  432.     case 0: return("SQU1");
  433.     case 1: return("SAW1");
  434.     case 2: return("SQU2");
  435.     case 3: return("SAW2");
  436.     }
  437.     return("*");
  438. }
  439.  
  440. char *vispcmnum(v)
  441. {
  442. static char vispcmnumbuf[3];
  443.  
  444.     if((v >= 0) && (v <= 127)) {
  445.         sprintf(vispcmnumbuf,"%d",v + 1);
  446.         return(vispcmnumbuf);
  447.     } else {
  448.         return("*");
  449.     }
  450. }
  451.  
  452. char *visvelsens(v)
  453. {
  454. static char visvelsensbuf[3];
  455.  
  456.     if((v >= 0) && (v <= 6)) {
  457.         sprintf(visvelsensbuf,"-%d",abs(v - 7));
  458.         return(visvelsensbuf);
  459.     } else if(v == 7) {
  460.         sprintf(visvelsensbuf,"0");
  461.         return(visvelsensbuf);
  462.     } else if((v >= 8) && (v <= 14)) {
  463.         sprintf(visvelsensbuf,"+%d",abs(v - 7));
  464.         return(visvelsensbuf);
  465.     } else {
  466.         return("*");
  467.     }
  468. }
  469.  
  470. char *visenvlev(v)
  471. {
  472. static char visenvlevbuf[4];
  473.  
  474.     if((v >= 0) && (v <= 49)) {
  475.         sprintf(visenvlevbuf,"-%d",abs(v - 50));
  476.         return(visenvlevbuf);
  477.     } else if(v == 50) {
  478.         sprintf(visenvlevbuf,"0");
  479.         return(visenvlevbuf);
  480.     } else if((v >= 51) && (v <= 100)) {
  481.         sprintf(visenvlevbuf,"+%d",abs(v - 50));
  482.         return(visenvlevbuf);
  483.     } else {
  484.         return("*");
  485.     }
  486. }
  487.  
  488. char *visbiaslev(v)
  489. {
  490. static char visbiaslevbuf[3];
  491.  
  492.     if((v >= 0) && (v <= 6)) {
  493.         sprintf(visbiaslevbuf,"-%d",abs(v - 7));
  494.         return(visbiaslevbuf);
  495.     } else if(v == 7) {
  496.         sprintf(visbiaslevbuf,"0");
  497.         return(visbiaslevbuf);
  498.     } else if((v >= 8) && (v <= 14)) {
  499.         sprintf(visbiaslevbuf,"+%d",abs(v - 7));
  500.         return(visbiaslevbuf);
  501.     } else {
  502.         return("*");
  503.     }
  504. }
  505.  
  506. static    char *bpitch_table[] = {
  507.     "A",
  508.     "A#",
  509.     "B",
  510.     "C",
  511.     "C#",
  512.     "D",
  513.     "D#",
  514.     "E",
  515.     "F",
  516.     "F#",
  517.     "G",
  518.     "G#"
  519. };
  520.  
  521. char *
  522. visbiaspd(v)
  523. {
  524. static    char    visbiaspdbuf[5];
  525. static    char    visbiaspdbuf1[2];
  526.  
  527.     if((v >= 0) && (v <= 127)) {
  528.         if(v >= 64) {
  529.             strcpy(visbiaspdbuf, ">");
  530.             v -= 64;
  531.         } else {
  532.             strcpy(visbiaspdbuf, "<");
  533.         }
  534.         strcat(visbiaspdbuf, bpitch_table[v % 12]);
  535.         v += 9;
  536.         sprintf(visbiaspdbuf1, "%d", (v / 12) + 1);
  537.         strcat(visbiaspdbuf, visbiaspdbuf1);
  538.         return(visbiaspdbuf);
  539.     } else {
  540.         return("*");
  541.     }
  542. }
  543.  
  544. char *vistvablev(v)
  545. {
  546. static char vistvablevbuf[4];
  547.  
  548.     if((v >= 0) && (v <= 12)) {
  549.         if(v == 12) {
  550.             return("0");
  551.         } else {
  552.             sprintf(vistvablevbuf,"-%d",abs(v - 12));
  553.             return(vistvablevbuf);
  554.         }
  555.     } else {
  556.         return("*");
  557.     }
  558. }
  559.  
  560. /* end */
  561.