home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 369b.lha / MED_v2.0 / Source / medsrc / med-scr.c < prev    next >
C/C++ Source or Header  |  1990-05-03  |  21KB  |  696 lines
  1. /* MED - by Teijo Kinnunen 1989, 1990 V2.00 */
  2. /* med-scr.c: screen handling routines */
  3. #include <graphics/gfxmacros.h>
  4. #include <graphics/sprite.h>
  5. #include <hardware/custom.h>
  6. #include <math.h> /* abs() */
  7. #include "med.h"
  8. #define SUURINSOITIN 31
  9. extern void __asm Korosta(register __a0 struct Gadget *,register __d0 BOOL);
  10. extern void __asm PaivitaNaytto(register __d0 BOOL);
  11. extern void __asm SetTempo(register __d0 UWORD);
  12. extern struct Kappale far tamakappale;
  13. extern struct Gadget far gadget3[],far gadget4[],far gadget1[],far gadgetA[];
  14. extern struct Gadget far gadget6[],far gadget9[],far gadget5[],far gadget7[];
  15. extern struct Gadget far gadget2[];
  16. extern struct Soitin *soitin[];
  17. extern char toistostr[],tpitstr[];
  18. extern struct CIA far ciaa;
  19. extern struct StringInfo strinfo[];
  20. extern UWORD volatile soittimennum,lohkoja,kursorix,soittorivi;
  21. extern UWORD volatile soittolohko,soittolohkonnum,tempo;
  22. extern UWORD chip eq1[],chip eq2[],chip eq3[],chip eq4[];
  23. extern BOOL ilmoitusnakyy,aanipaalla[];
  24. extern struct Custom far custom;
  25. extern struct RastPort *wrp;
  26. extern struct Window *window;
  27. extern struct Screen *screen;
  28. extern struct ViewPort *vp;
  29. extern struct BitMap nayttobm;
  30. extern struct Image far oktimg[];
  31. extern struct PropInfo propinfo[];
  32. extern UWORD nykyinenosio,far nappokt,currtrk;
  33. extern struct Lohko far *lohko[];
  34. extern UBYTE firstdisptrk;
  35. BOOL AlustaKappale();
  36. void TulostaSoittoLohkot(),Ilmoita(),DrawColorGadgets(),UpdateJumpGadgets();
  37. void TulostaLohkoJaSoitin(),AsetaSuodatin(),PaivitaSoittimennimi();
  38. void NollaaVarit(),DispVolGadget(),DelBlockHere(),DispPresetGadget();
  39. UBYTE near heksaluku[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C',
  40.               'D','E','F','G','H','I','J','K','L','M','N','O',
  41.               'P','Q','R','S','T','U','V' },specialupd,thiscol;
  42. UBYTE equalizerok = 0;
  43. UWORD chip tmpA[20];
  44. static UWORD undocolors[8] = {
  45.     0x0000,0x0ccc,0x0556,0x099a,0x0f00,0x0f66,0x0f99,0x0fcc };
  46. static UBYTE allocsprmsk = 0,coplist = 0,sname[50];
  47.  
  48. BOOL AlustaKappale(BOOL nollaasoittimet)
  49. {
  50.     UCOUNT lsk;
  51.     FreeAllBlocks();
  52.     tamakappale.id = ((long)('M')<<24L|(long)('E')<<16L|('D')<<8|3);
  53.     if(nollaasoittimet) {
  54.         VapautaSoittimet();
  55.         for(lsk = 0; lsk <= SUURINSOITIN; lsk++) {
  56.             tamakappale.soitin[lsk][0] = '\0';
  57.             tamakappale.soittimenvoimakkuus[lsk] = 64;
  58.             tamakappale.stoisto[lsk] = tamakappale.stoistonpit[lsk] = 0;
  59.             tamakappale.midikanava[lsk] = tamakappale.midipreset[lsk] = 0;
  60.         }
  61.     }
  62.     tamakappale.soittojarjestys[0]=soittorivi=soittolohko=soittolohkonnum = 0;
  63.     tamakappale.kappaleen_pituus = lohkoja = soittimennum = 1;
  64.     tamakappale.vaihtoja = 6;
  65.     tamakappale.playtransp = 0;
  66.     tamakappale.liput = LIPPU_HYPPELYPAALLA;
  67.     tamakappale.hyppysoitin = NULL;
  68.     AsetaSuodatin();
  69.     if(AllocBlock(0,4)) return(TRUE);
  70.     tamakappale.tempo = 33;
  71.     SetTempo(34);
  72.     PaivitaSoittimennimi();
  73.     NollaaVarit();
  74.     UpdateJumpGadgets();
  75.     return(0);
  76. }
  77.  
  78. void PaivitaSoittimennimi()
  79. {
  80.     static UWORD prevmch = 0;
  81.     UWORD remnum;
  82.     if(nykyinenosio == 4) remnum = RemoveGadget(window,&gadget4[0]);
  83.     strinfo[2].Buffer = tamakappale.soitin[soittimennum];
  84.     strinfo[2].DispPos = 0;
  85.     if(nykyinenosio == 4) {
  86.         char num[12],npit;
  87.         AddGadget(window,&gadget4[0],remnum);
  88.         RefreshGList(&gadget4[0],window,NULL,1);
  89.         SetAPen(wrp,0); SetBPen(wrp,3);
  90.         Move(wrp,136,26);
  91.         num[0] = heksaluku[soittimennum]; /* Tulosta numero */
  92.         Text(wrp,num,1);
  93.         if(soitin[soittimennum])
  94.             npit = stcul_d(num,soitin[soittimennum]->length);
  95.         else { num[0] = '-'; npit = 1; }
  96.         Move(wrp,179,26);
  97.         Text(wrp,"       ",6 - npit); /* pyyhitään vas. reuna */
  98.         Text(wrp,num,npit); /* Tulostetaan soittimen pituus */
  99.         remnum = RemoveGList(window,&gadget4[8],2);
  100.         strinfo[3].LongInt = tamakappale.stoisto[soittimennum];
  101.         strinfo[4].LongInt = tamakappale.stoistonpit[soittimennum];
  102.         strinfo[3].DispPos = strinfo[4].DispPos = 0;
  103.         (void)stcu_d(toistostr,tamakappale.stoisto[soittimennum]);
  104.         (void)stcu_d(tpitstr,tamakappale.stoistonpit[soittimennum]);
  105.         AddGList(window,&gadget4[8],remnum,2,NULL);
  106.         RefreshGList(&gadget4[8],window,NULL,2); /* stringit */
  107.         DispVolGadget();
  108.     } else if(nykyinenosio == 9) {
  109.         if(tamakappale.midikanava[soittimennum]) {
  110.             Korosta(&gadget9[1],TRUE);
  111.             Korosta(&gadget9[2],FALSE);
  112.             if(prevmch && prevmch != tamakappale.midikanava[
  113.                 soittimennum]) Korosta(&gadget9[prevmch+2],FALSE);
  114.             prevmch = tamakappale.midikanava[soittimennum];
  115.             Korosta(&gadget9[prevmch+2],TRUE);
  116.         } else {
  117.             Korosta(&gadget9[1],FALSE);
  118.             Korosta(&gadget9[2],TRUE);
  119.             if(prevmch) Korosta(&gadget9[prevmch+2],FALSE);
  120.             prevmch = 0;
  121.         }
  122.         DispPresetGadget();
  123.     }
  124.     if(tamakappale.hyppysoitin & (1 << soittimennum))
  125.         Korosta(&gadget4[6],TRUE);
  126.     else    Korosta(&gadget4[6],FALSE);
  127.     TulostaLohkoJaSoitin();
  128. }
  129.  
  130. void TulostaSoittoLohkot()
  131. {
  132.     register UBYTE sjarj,sjarjkymm = 0;
  133.     UCOUNT rivilaskin;
  134.     char lohkoteksti[2];
  135.     if(nykyinenosio != 3) return;
  136.     SetAPen(wrp,1);
  137.     for(rivilaskin = 0; rivilaskin < 3; rivilaskin++) {
  138.         sjarj = tamakappale.soittojarjestys[soittolohkonnum - 1 + rivilaskin];
  139.         lohkoteksti[0] = 0;
  140.         while(sjarj >= 10) { sjarj -= 10; sjarjkymm++; lohkoteksti[0]++; }
  141.         if(lohkoteksti[0]) lohkoteksti[0] += '0';
  142.         else lohkoteksti[0] = ' ';
  143.         lohkoteksti[1] = '0' + sjarj;
  144.         Move(wrp,175,26 + 8 * rivilaskin);
  145.         if(soittolohkonnum + rivilaskin == 0 ||
  146.             soittolohkonnum + rivilaskin > tamakappale.kappaleen_pituus) {
  147.             lohkoteksti[0] = lohkoteksti[1] = ' '; }
  148.             if(rivilaskin == 1) SetBPen(wrp,2); else SetBPen(wrp,3);
  149.             Text(wrp,lohkoteksti,2);
  150.         }
  151.         SetAPen(wrp,0);
  152. }
  153.  
  154. void Ilmoita(teksti)
  155. char *teksti;
  156. {
  157.     static char edellinenteksti[40] = "";
  158.     extern char title[];
  159.     if(!teksti) {
  160.         BltBitMapRastPort(&nayttobm,0,0,wrp,0,0,275,13,0xc0);
  161.         ilmoitusnakyy = FALSE;
  162.     }
  163.     else {
  164.         if(ilmoitusnakyy && !strcmp(edellinenteksti,teksti)) return;
  165.         strcpy(edellinenteksti,teksti);
  166.         SetAPen(wrp,0);
  167.         RectFill(wrp,1,1,274,12);
  168.         Move(wrp,5,10);
  169.         SetAPen(wrp,1);
  170.         SetDrMd(wrp,JAM1);
  171.         Text(wrp,teksti,strlen(teksti));
  172.         SetDrMd(wrp,JAM2);
  173.         SetAPen(wrp,0);
  174.         ilmoitusnakyy = TRUE;
  175.     }
  176. }
  177.  
  178. static void kymmenjarj(ptr,luku)
  179. UBYTE *ptr;
  180. UBYTE luku;
  181. {
  182.     *ptr = '0';
  183.     while(luku >= 10) { luku -= 10; (*ptr)++; }
  184.     *(ptr+1) = '0'+luku;
  185. }
  186.  
  187. void TulostaLohkoJaSoitin()
  188. {
  189.     static UWORD prevtrknum = 4;
  190.     static char tulteksti[] = "  /  ";
  191.     char snimitxt[11],cnt,mrkjalj = strlen(tamakappale.soitin[soittimennum]);
  192.     kymmenjarj(&tulteksti[0],(UBYTE)(soittolohkonnum + 1));
  193.     kymmenjarj(&tulteksti[3],tamakappale.kappaleen_pituus);
  194.     Move(wrp,13,72);
  195.     SetAPen(wrp,0); SetBPen(wrp,3);
  196.     Text(wrp,tulteksti,5);
  197.     kymmenjarj(&tulteksti[0],soittolohko);
  198.     kymmenjarj(&tulteksti[3],(lohkoja - 1));
  199.     Move(wrp,64,72);
  200.     Text(wrp,tulteksti,5);
  201.     tulteksti[0] = heksaluku[soittimennum];
  202.     Move(wrp,116,72);
  203.     Text(wrp,tulteksti,1);
  204.     tulteksti[1] = firstdisptrk / 4 + '1';
  205.     tulteksti[3] = lohko[soittolohko]->numtracks / 4 + '0';
  206.     Move(wrp,136,72);
  207.     Text(wrp,tulteksti+1,3);
  208.     for(cnt = 0; cnt < 10; cnt++) {
  209.         if(mrkjalj-- > 0) snimitxt[cnt] = tamakappale.soitin[soittimennum][cnt];
  210.         else snimitxt[cnt] = ' ';
  211.     }
  212.     Move(wrp,234,72);
  213.     Text(wrp,snimitxt,10);
  214.     if(nykyinenosio == 9) {
  215.         Move(wrp,32,25);
  216.         Text(wrp,snimitxt,10);
  217.     }
  218.     else if(nykyinenosio == 5) {
  219.         UWORD plblock = soittolohko;
  220.         if(lohko[plblock]->numtracks != prevtrknum) {
  221.             Korosta(&gadget5[15 + prevtrknum / 4],FALSE);
  222.             prevtrknum = lohko[plblock]->numtracks;
  223.             Korosta(&gadget5[15 + prevtrknum / 4],TRUE);
  224.         }
  225.     }
  226. }
  227.  
  228. void AsetaSuodatin()
  229. {
  230.     if(tamakappale.liput & LIPPU_SUODATINPAALLA) {
  231.         ciaa.ciapra &= ~CIAF_LED;
  232.         Korosta(&gadget3[5],TRUE);
  233.     } else {
  234.         ciaa.ciapra |= CIAF_LED;
  235.         Korosta(&gadget3[5],FALSE);
  236.     }
  237. }
  238.  
  239. void NollaaVarit()
  240. {
  241.     SetRGB4(vp,0,0x0,0x0,0x0);
  242.     SetRGB4(vp,1,0xc,0xc,0xc);
  243.     SetRGB4(vp,2,0x5,0x5,0x6);
  244.     SetRGB4(vp,3,0x9,0x9,0xa);
  245.     SetRGB4(vp,4,0xf,0x0,0x0);
  246.     SetRGB4(vp,5,0xf,0x6,0x6);
  247.     SetRGB4(vp,6,0xf,0x9,0x9);
  248.     SetRGB4(vp,7,0xf,0xc,0xc);
  249.     DrawColorGadgets(thiscol);
  250. }
  251.  
  252. void DispVolGadget()
  253. {
  254.     char num[2];
  255.     if(nykyinenosio == 4) {
  256.         if(tamakappale.soittimenvoimakkuus[soittimennum])
  257.             ModifyProp(&gadget4[11],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  258.             tamakappale.soittimenvoimakkuus[soittimennum] * 1024 - 1,0,0x400,0);
  259.         else    ModifyProp(&gadget4[11],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  260.             0,0,0x400,0);
  261.         kymmenjarj(num,tamakappale.soittimenvoimakkuus[soittimennum]);
  262.         Move(wrp,56,58);
  263.         Text(wrp,num,2); /* Lopuksi soittimen voimakkuus */
  264.     }
  265. }
  266.  
  267. void DispPresetGadget()
  268. {
  269.     extern char presetstr[];
  270.     UWORD rempos;
  271.     if(nykyinenosio != 9) return;
  272.     if(tamakappale.midipreset[soittimennum])
  273.         ModifyProp(&gadget9[21],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  274.         tamakappale.midipreset[soittimennum] * 512 - 1,0,508,0);
  275.     else    ModifyProp(&gadget9[21],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  276.         0,0,508,0);
  277.     rempos = RemoveGadget(window,&gadget9[19]);
  278.     stci_d(presetstr,tamakappale.midipreset[soittimennum]);
  279.     strinfo[5].LongInt = tamakappale.midipreset[soittimennum];
  280.     AddGadget(window,&gadget9[19],rempos);
  281.     RefreshGList(&gadget9[19],window,NULL,1);
  282. }
  283.     
  284. void NewBlockHere(UWORD hblock,UWORD tracks)
  285. {
  286.     UWORD blockcnt;
  287.     if(lohkoja < 100) {
  288.         blockcnt = lohkoja++;
  289.         for(; blockcnt > hblock; blockcnt--)
  290.             lohko[blockcnt] = lohko[blockcnt-1];
  291.         lohko[hblock] = 0L;
  292.         if(AllocBlock(hblock,tracks)) DelBlockHere(hblock);
  293.         else for(blockcnt = 0; blockcnt <
  294.              tamakappale.kappaleen_pituus; blockcnt++)
  295.             if(tamakappale.soittojarjestys[blockcnt] >= hblock)
  296.                 tamakappale.soittojarjestys[blockcnt]++;
  297.     } else Ilmoita("No more than 100 blocks!!");
  298.     TulostaLohkoJaSoitin();
  299.     PaivitaNaytto(TRUE);
  300. }
  301.  
  302. void DelBlockHere(UWORD hblock)
  303. {
  304.     UWORD blockcnt = hblock;
  305.     if(lohkoja > 1) {
  306.         if(soittolohko >= lohkoja-1) soittolohko--;
  307.         FreeBlock(blockcnt);
  308.         for(;blockcnt < lohkoja; blockcnt++)
  309.             lohko[blockcnt] = lohko[blockcnt+1];
  310.         lohko[lohkoja--] = 0L;
  311.         for(blockcnt = 0; blockcnt < tamakappale.kappaleen_pituus; blockcnt++)
  312.             if(tamakappale.soittojarjestys[blockcnt] >= hblock
  313.                && tamakappale.soittojarjestys[blockcnt])
  314.                 tamakappale.soittojarjestys[blockcnt]--;
  315.     }
  316.     TulostaLohkoJaSoitin();
  317.     PaivitaNaytto(TRUE);
  318. }
  319.  
  320. void DispInfoGadgets()
  321. {
  322.     UWORD choncnt;
  323.     for(choncnt = 0; choncnt < 16; choncnt++) {
  324.         register UWORD starty = choncnt > 7 ? 71 : 67;
  325.         register UWORD startx = 3 * (choncnt & 0x7) + 205;
  326.         if(aanipaalla[choncnt]) {
  327.             SetAPen(wrp,4);
  328.             WritePixel(wrp,startx,starty);
  329.             WritePixel(wrp,startx,starty + 1);
  330.             WritePixel(wrp,startx + 1,starty + 1);
  331.             SetAPen(wrp,6);
  332.             WritePixel(wrp,startx + 1,starty);
  333.         }
  334.         else {
  335.             SetAPen(wrp,1);
  336.             WritePixel(wrp,startx,starty);
  337.             WritePixel(wrp,startx,starty + 1);
  338.             WritePixel(wrp,startx + 1,starty);
  339.             WritePixel(wrp,startx + 1,starty + 1);
  340.         }
  341.     }
  342.     SetAPen(wrp,0);
  343.     choncnt = nykyinenosio;
  344.     nykyinenosio = 0xF;
  345.     Korosta(&gadget1[8],(BOOL)(gadget6[0].GadgetID & 0x1000));
  346.     Korosta(&gadget1[9],(BOOL)(gadget6[1].GadgetID & 0x1000));
  347.     nykyinenosio = choncnt;
  348.     DrawImage(wrp,&oktimg[nappokt],164,66);
  349. }
  350.  
  351. void ShowTempo()
  352. {
  353.     UWORD remnum,new = tempo; /* <- because tempo is volatile */
  354.     UBYTE tempostr[4] = "000";
  355.     if(nykyinenosio == 3)    remnum = RemoveGadget(window,&gadget3[9]);
  356.     propinfo[1].HorizPot = 274 * tempo - 225;
  357.     if(nykyinenosio == 3) {
  358.         AddGadget(window,&gadget3[9],remnum);
  359.         RefreshGList(&gadget3[9],window,NULL,1);
  360.         Move(wrp,104,45);
  361.         while(new >= 100) { new -= 100;    tempostr[0]++; }
  362.         while(new >= 10)  { new -= 10;    tempostr[1]++; }
  363.         while(new)      { new--;    tempostr[2]++; }
  364.         Text(wrp,tempostr,3);
  365.     }
  366. }
  367.  
  368. void SpecialUpdate()
  369. {
  370.     extern UWORD chip mouse1[];
  371.     if(specialupd & 0x1) {    /* bit #0 = filter */
  372.         if(ciaa.ciapra & CIAF_LED) Korosta(&gadget3[5],FALSE);
  373.         else Korosta(&gadget3[5],TRUE);
  374.         specialupd &= ~0x1;
  375.     }
  376.     if(specialupd & 0x2) {    /* bit #1 = stop playing */
  377.         Korosta(&gadget3[0],FALSE);
  378.         Korosta(&gadget3[1],FALSE);
  379.         SetPointer(window,&mouse1[0],23,16,-1,0);
  380.         specialupd &= ~0x2;
  381.     }
  382.     if(specialupd & 0x4) {    /* change tempo */
  383.         ShowTempo();
  384.         specialupd &= ~0x4;
  385.     }
  386. }
  387.  
  388. void ChgTempo(UWORD new)
  389. {
  390.     tamakappale.tempo = new;
  391.     SetTempo(new);
  392.     SpecialUpdate(); /* SetTempo() will set specialupd flag */
  393. }
  394.  
  395. static void DispColVals(UWORD r,UWORD g,UWORD b)
  396. {
  397.     Move(wrp,107,27);
  398.     Text(wrp,&heksaluku[r],1);
  399.     Move(wrp,107,37);
  400.     Text(wrp,&heksaluku[g],1);
  401.     Move(wrp,107,47);
  402.     Text(wrp,&heksaluku[b],1);
  403. }
  404.  
  405. void DrawColorGadgets(UBYTE newcolor)
  406. {
  407.     static BYTE currcol = 0;
  408.     UWORD newrgb,r,g,b;
  409.     static WORD far boxdata[] = { -1,-1,8,-1,8,8,-1,8,-1,0 };
  410.     static struct Border far box = { 0,0,7,0,COMPLEMENT,5,boxdata,NULL };
  411.     if(nykyinenosio != 7) return;
  412.     if(newcolor != -1) {
  413.         DrawBorder(wrp,&box,10 * currcol + 15,52);
  414.         currcol = newcolor;
  415.     }
  416.     DrawBorder(wrp,&box,10 * currcol + 15,52);
  417.     newrgb = GetRGB4(vp->ColorMap,currcol);
  418.     r = (newrgb & 0x0f00) >> 8;
  419.     g = (newrgb & 0x00f0) >> 4;
  420.     b = newrgb & 0x000f;
  421.     ModifyProp(&gadget7[0],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  422.         r * (MAXPOT / 15),0,MAXBODY / 16,0);
  423.     ModifyProp(&gadget7[1],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  424.         g * (MAXPOT / 15),0,MAXBODY / 16,0);
  425.     ModifyProp(&gadget7[2],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  426.         b * (MAXPOT / 15),0,MAXBODY / 16,0);
  427.     DispColVals(r,g,b);
  428. }
  429.  
  430. void GetUndoColors()
  431. {
  432.     UCOUNT counter = 0;
  433.     for(;counter < 8; counter++) undocolors[counter] =
  434.         GetRGB4(vp->ColorMap,counter);
  435. }
  436.  
  437. static void UndoColors()
  438. {
  439.     UCOUNT counter = 0;
  440.     for(;counter < 8; counter++) SetRGB4(vp,counter,
  441.         (undocolors[counter] & 0x0f00) >> 8,(undocolors[counter] &
  442.         0x00f0) >> 4,undocolors[counter] & 0x000f);
  443.     DrawColorGadgets(thiscol);
  444. }
  445.  
  446. void ColorHandler(UWORD gid)
  447. {
  448.     if(gid >= 0x703 && gid <= 0x70A)
  449.         DrawColorGadgets(thiscol = (UBYTE)(gid - 0x703));
  450.     else if(gid >= 0x700 && gid <= 0x702) {
  451.         UWORD rgb[3];
  452.         rgb[0] = propinfo[5].HorizPot / 4096;
  453.         rgb[1] = propinfo[6].HorizPot / 4096;
  454.         rgb[2] = propinfo[7].HorizPot / 4096;
  455.         SetRGB4(vp,thiscol,rgb[0],rgb[1],rgb[2]);
  456.         DispColVals(rgb[0],rgb[1],rgb[2]);
  457.         ModifyProp(&gadget7[gid - 0x700],window,NULL,
  458.             AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
  459.             rgb[gid - 0x700] * (MAXPOT / 15),0,MAXBODY/16,0);
  460.     }
  461.     else if(gid == 0x70B) NollaaVarit();
  462.     else if(gid == 0x70C) UndoColors();
  463. }
  464.  
  465. void RemoveInstrument()
  466. {
  467.     if(soitin[soittimennum]) {
  468.         FreeMem((void *)soitin[soittimennum],soitin[soittimennum]->
  469.             length + sizeof(struct Soitin));
  470.         soitin[soittimennum] = NULL;
  471.         tamakappale.soitin[soittimennum][0] = '\0';
  472.         tamakappale.soittimenvoimakkuus[soittimennum] = 64;
  473.         tamakappale.stoisto[soittimennum] = tamakappale.
  474.             stoistonpit[soittimennum] = 0;
  475.         tamakappale.midikanava[soittimennum] =
  476.             tamakappale.midipreset[soittimennum] = 0;
  477.         tamakappale.hyppysoitin &= ~(1<<soittimennum);
  478.         PaivitaSoittimennimi();
  479.     }
  480. }
  481.  
  482. void GetRepeat()
  483. {
  484.     LONG newrep = strinfo[3].LongInt;
  485.     if(newrep < 0) tamakappale.stoisto[soittimennum] = 0;
  486.     else tamakappale.stoisto[soittimennum] = (UWORD)newrep;
  487.     PaivitaSoittimennimi();
  488.     if(nykyinenosio == 4) ActivateGadget(&gadget4[9],window,NULL);
  489. }
  490.  
  491. void GetRepLen()
  492. {
  493.     LONG newrl = strinfo[4].LongInt;
  494.     if(newrl < 0) tamakappale.stoistonpit[soittimennum] = 0;
  495.     else tamakappale.stoistonpit[soittimennum] = (UWORD)newrl;
  496.     PaivitaSoittimennimi();
  497. }
  498.  
  499. void InsertSeq(UBYTE num)
  500. {
  501.     UWORD pbnum = soittolohkonnum,cnt;
  502.     if(tamakappale.kappaleen_pituus >= 99) {
  503.         Ilmoita("Max = 99 sequences!!");
  504.         return;
  505.     }
  506.     for(cnt = tamakappale.kappaleen_pituus; cnt > pbnum; cnt--)
  507.         tamakappale.soittojarjestys[cnt] = tamakappale.soittojarjestys[cnt-1];
  508.     tamakappale.kappaleen_pituus++;
  509.     tamakappale.soittojarjestys[pbnum] = num;
  510.     TulostaSoittoLohkot();
  511.     TulostaLohkoJaSoitin();
  512. }
  513.  
  514. void DelSeq()
  515. {
  516.     UWORD pbnum = soittolohkonnum,cnt;
  517.     if(tamakappale.kappaleen_pituus <= 1 || pbnum >= tamakappale.
  518.         kappaleen_pituus) return;
  519.     tamakappale.kappaleen_pituus--;
  520.     for(cnt = pbnum; cnt < tamakappale.kappaleen_pituus; cnt++)
  521.         tamakappale.soittojarjestys[cnt] = tamakappale.soittojarjestys[cnt+1];
  522.     TulostaSoittoLohkot();
  523.     TulostaLohkoJaSoitin();
  524. }
  525.  
  526. void PlayTransp(BYTE transp)
  527. {
  528.     char num[3];
  529.     UWORD pos;
  530.     if(transp < -12) transp = -12;
  531.     else if(transp > 12) transp = 12;
  532.     tamakappale.playtransp = transp;
  533.     if(nykyinenosio == 0xA)    pos = RemoveGadget(window,&gadgetA[13]);
  534.     propinfo[4].HorizPot = 2622 * (transp + 13) - 15;
  535.     if(nykyinenosio == 0xA) {
  536.         AddGadget(window,&gadgetA[13],pos);
  537.         RefreshGList(&gadgetA[13],window,NULL,1);
  538.     }
  539.     kymmenjarj(&num[1],abs(transp));
  540.     if(transp < 0) num[0] = '-'; else num[0] = ' ';
  541.     SetAPen(wrp,2);
  542.     Move(wrp,203,40);
  543.     Text(wrp,num,3);
  544. }
  545.  
  546. static void TransposeTrack(UWORD block,UBYTE track,BYTE steps)
  547. {
  548.     UBYTE *endptr,*noteptr = &lohko[block]->music[0];
  549.     BYTE newnote;
  550.     endptr = noteptr + 3 * lohko[block]->numtracks * 64;
  551.     if(track != 0xff) noteptr += 3*track;
  552.     while(noteptr < endptr) {
  553.         if(newnote = *noteptr & 0x7f) {
  554.             if(gadgetA[17].GadgetID & 0x1000 ||
  555.                 (((*(noteptr+1) >> 4) + (*noteptr & 0x80 ?
  556.                     16 : 0)) == soittimennum)) {
  557.                 newnote += steps;
  558.                 if(newnote <= 0) newnote += 12;
  559.                 else if(newnote > 63) newnote -= 12;
  560.                 *noteptr &= 0x80;
  561.                 *noteptr |= newnote;
  562.             }
  563.         }
  564.         if(track != 0xff) noteptr += 3 * lohko[block]->numtracks;
  565.         else noteptr += 3;
  566.     }
  567. }
  568.  
  569. void Transpose(BYTE steps,UBYTE obj)
  570. {
  571.     if(obj == 0) { /* whole song */
  572.         UWORD blockcnt;
  573.         for(blockcnt = 0; blockcnt < lohkoja; blockcnt++)
  574.             TransposeTrack(blockcnt,0xff,steps);
  575.     } else if(obj==1) TransposeTrack(soittolohko,0xff,steps); /*block*/
  576.     else if(obj == 2) TransposeTrack(soittolohko,(UBYTE)currtrk,steps);
  577.     PaivitaNaytto(TRUE);
  578. }
  579.  
  580. void ClrFileName()    /* Clears the file name, so the user can't  */
  581. {            /* accidentaly load a new song. */
  582.     register UWORD pos;
  583.     extern char kappaleennimi[];
  584.     if(kappaleennimi[0] == '\0') return;
  585.     if(nykyinenosio == 2) pos = RemoveGadget(window,&gadget2[9]);
  586.     strcpy(sname,kappaleennimi);
  587.     kappaleennimi[0] = '\0';
  588.     if(nykyinenosio == 2) {
  589.         AddGadget(window,&gadget2[9],pos);
  590.         RefreshGList(&gadget2[9],window,NULL,1);
  591.     }
  592. }
  593.  
  594. void RetFileName()
  595. {
  596.     register UWORD pos;
  597.     if(nykyinenosio == 2) pos = RemoveGadget(window,&gadget2[9]);
  598.     strcpy(kappaleennimi,sname);
  599.     if(nykyinenosio == 2) {
  600.         AddGadget(window,&gadget2[9],pos);
  601.         RefreshGList(&gadget2[9],window,NULL,1);
  602.     }
  603. }
  604.     
  605. static void CreateCopperList()
  606. {
  607.     static UWORD cols[] = { 0xf21,0xf31,0xf41,0xf51,0xf62,0xf72,0xf82,
  608.         0xf92,0xfa2,0xfb2,0xfc2,0xfd3,0xfe3,0xff3,0xef3,0xcf2,
  609.         0xbf2,0x9f2,0x8f1,0x6f1,0x4f1,0x2f0,0x0f0,0x0e0,0x0d0,
  610.         0x0c0,0x0b0,0x0a0,0x090,0x080 };
  611.     UWORD colcnt,ycount = 137;
  612.     struct UCopList *cl;
  613.     if(coplist) return;
  614.     cl = (struct UCopList *)AllocMem(sizeof(struct UCopList),
  615.         MEMF_PUBLIC|MEMF_CHIP|MEMF_CLEAR);
  616.     if(!cl) return;
  617.     SetRGB4(vp,21,0xa,0xa,0xa);    SetRGB4(vp,22,0xa,0xa,0xa);
  618.     SetRGB4(vp,23,0xb,0xb,0xb);    SetRGB4(vp,25,0xa,0xa,0xa);
  619.     SetRGB4(vp,26,0xa,0xa,0xa);    SetRGB4(vp,27,0xb,0xb,0xb);
  620.     for(colcnt = 0; colcnt < 30; colcnt++) {
  621.         CWAIT(cl,ycount,0);
  622.         CMove(cl,(long)(&custom.color[22]),(long)cols[colcnt]);
  623.         CBump(cl);
  624.         CMove(cl,(long)(&custom.color[26]),(long)cols[colcnt]);
  625.         CBump(cl);
  626.         ycount += 2;
  627.     }
  628.     CEND(cl);
  629.     vp->UCopIns = cl;
  630.     RethinkDisplay();
  631.     coplist = 1;
  632. }
  633.  
  634. void RemCopperList() /* Remove our beautiful copper colors */
  635. {
  636.     struct UCopList *uins = vp->UCopIns,*this;
  637.     if(!coplist) return;
  638.     Forbid();
  639.     vp->UCopIns = 0;
  640.     RethinkDisplay();
  641.     while(uins) {
  642.         this = uins;
  643.         FreeCopList(uins->FirstCopList);
  644.         uins = uins->Next;
  645.         FreeMem((void *)this,sizeof(struct UCopList));
  646.     }
  647.     Permit();
  648.     coplist = 0;
  649. }
  650.  
  651. void RemEqualizer()
  652. {
  653.     if(!equalizerok) return;
  654.     equalizerok = 0;
  655.     if(allocsprmsk & 1) { FreeSprite(2); allocsprmsk &= ~1; }
  656.     if(allocsprmsk & 2) { FreeSprite(3); allocsprmsk &= ~2; }
  657.     if(allocsprmsk & 4) { FreeSprite(4); allocsprmsk &= ~4; }
  658.     if(allocsprmsk & 8) { FreeSprite(5); allocsprmsk &= ~8; }
  659. }
  660.  
  661. void InitEqualizer()
  662. {
  663.     static struct SimpleSprite ss1 = { eq1,64,75,134,0 },
  664.         ss2 = { eq2,64,147,134,0 },ss3 = { eq3,64,219,134,0 },
  665.         ss4 = { eq4,64,291,134,0 };
  666.     if(equalizerok) return;
  667.     if(GetSprite(&ss1,2) == -1) { RemEqualizer(); return; }
  668.     allocsprmsk |= 1;
  669.     if(GetSprite(&ss2,3) == -1) { RemEqualizer(); return; }
  670.     allocsprmsk |= 2;
  671.     if(GetSprite(&ss3,4) == -1) { RemEqualizer(); return; }
  672.     allocsprmsk |= 4;
  673.     if(GetSprite(&ss4,5) == -1) { RemEqualizer(); return; }
  674.     allocsprmsk |= 8;
  675.     ChangeSprite(vp,&ss1,eq1);
  676.     ChangeSprite(vp,&ss2,eq2);
  677.     ChangeSprite(vp,&ss3,eq3);
  678.     ChangeSprite(vp,&ss4,eq4);
  679.     if(!coplist) CreateCopperList();
  680.     equalizerok = 1;
  681. }
  682.  
  683. void UpdateJumpGadgets()
  684. {
  685.     Korosta(&gadget7[13],(BOOL)(!(tamakappale.liput & LIPPU_HYPPELYPAALLA)));
  686.     if(tamakappale.liput & LIPPU_HYPPELYPAALLA) {
  687.         Korosta(&gadget7[14],(BOOL)(tamakappale.liput &
  688.             LIPPU_HYPPELYTAHTIIN));
  689.         Korosta(&gadget7[15],(BOOL)(!(tamakappale.liput &
  690.             LIPPU_HYPPELYTAHTIIN)));
  691.     } else {
  692.         Korosta(&gadget7[14],FALSE);
  693.         Korosta(&gadget7[15],FALSE);
  694.     }
  695. }
  696.