/* MED - by Teijo Kinnunen 1989, 1990 V2.00 */
/* med-scr.c: screen handling routines */
#include <graphics/gfxmacros.h>
#include <graphics/sprite.h>
#include <hardware/custom.h>
#include <math.h> /* abs() */
#include "med.h"
#define SUURINSOITIN 31
extern void __asm Korosta(register __a0 struct Gadget *,register __d0 BOOL);
extern void __asm PaivitaNaytto(register __d0 BOOL);
extern void __asm SetTempo(register __d0 UWORD);
extern struct Kappale far tamakappale;
extern struct Gadget far gadget3[],far gadget4[],far gadget1[],far gadgetA[];
extern struct Gadget far gadget6[],far gadget9[],far gadget5[],far gadget7[];
extern struct Gadget far gadget2[];
extern struct Soitin *soitin[];
extern char toistostr[],tpitstr[];
extern struct CIA far ciaa;
extern struct StringInfo strinfo[];
extern UWORD volatile soittimennum,lohkoja,kursorix,soittorivi;
extern UWORD volatile soittolohko,soittolohkonnum,tempo;
extern UWORD chip eq1[],chip eq2[],chip eq3[],chip eq4[];
extern BOOL ilmoitusnakyy,aanipaalla[];
extern struct Custom far custom;
extern struct RastPort *wrp;
extern struct Window *window;
extern struct Screen *screen;
extern struct ViewPort *vp;
extern struct BitMap nayttobm;
extern struct Image far oktimg[];
extern struct PropInfo propinfo[];
extern UWORD nykyinenosio,far nappokt,currtrk;
extern struct Lohko far *lohko[];
extern UBYTE firstdisptrk;
BOOL AlustaKappale();
void TulostaSoittoLohkot(),Ilmoita(),DrawColorGadgets(),UpdateJumpGadgets();
void TulostaLohkoJaSoitin(),AsetaSuodatin(),PaivitaSoittimennimi();
void NollaaVarit(),DispVolGadget(),DelBlockHere(),DispPresetGadget();
UBYTE near heksaluku[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C',
			  'D','E','F','G','H','I','J','K','L','M','N','O',
			  'P','Q','R','S','T','U','V' },specialupd,thiscol;
UBYTE equalizerok = 0;
UWORD chip tmpA[20];
static UWORD undocolors[8] = {
	0x0000,0x0ccc,0x0556,0x099a,0x0f00,0x0f66,0x0f99,0x0fcc };
static UBYTE allocsprmsk = 0,coplist = 0,sname[50];

BOOL AlustaKappale(BOOL nollaasoittimet)
{
	UCOUNT lsk;
	FreeAllBlocks();
	tamakappale.id = ((long)('M')<<24L|(long)('E')<<16L|('D')<<8|3);
	if(nollaasoittimet) {
		VapautaSoittimet();
		for(lsk = 0; lsk <= SUURINSOITIN; lsk++) {
			tamakappale.soitin[lsk][0] = '\0';
			tamakappale.soittimenvoimakkuus[lsk] = 64;
			tamakappale.stoisto[lsk] = tamakappale.stoistonpit[lsk] = 0;
			tamakappale.midikanava[lsk] = tamakappale.midipreset[lsk] = 0;
		}
	}
	tamakappale.soittojarjestys[0]=soittorivi=soittolohko=soittolohkonnum = 0;
	tamakappale.kappaleen_pituus = lohkoja = soittimennum = 1;
	tamakappale.vaihtoja = 6;
	tamakappale.playtransp = 0;
	tamakappale.liput = LIPPU_HYPPELYPAALLA;
	tamakappale.hyppysoitin = NULL;
	AsetaSuodatin();
	if(AllocBlock(0,4)) return(TRUE);
	tamakappale.tempo = 33;
	SetTempo(34);
	PaivitaSoittimennimi();
	NollaaVarit();
	UpdateJumpGadgets();
	return(0);
}

void PaivitaSoittimennimi()
{
	static UWORD prevmch = 0;
	UWORD remnum;
	if(nykyinenosio == 4) remnum = RemoveGadget(window,&gadget4[0]);
	strinfo[2].Buffer = tamakappale.soitin[soittimennum];
	strinfo[2].DispPos = 0;
	if(nykyinenosio == 4) {
		char num[12],npit;
		AddGadget(window,&gadget4[0],remnum);
		RefreshGList(&gadget4[0],window,NULL,1);
		SetAPen(wrp,0); SetBPen(wrp,3);
		Move(wrp,136,26);
		num[0] = heksaluku[soittimennum]; /* Tulosta numero */
		Text(wrp,num,1);
		if(soitin[soittimennum])
			npit = stcul_d(num,soitin[soittimennum]->length);
		else { num[0] = '-'; npit = 1; }
		Move(wrp,179,26);
		Text(wrp,"       ",6 - npit); /* pyyhitään vas. reuna */
		Text(wrp,num,npit); /* Tulostetaan soittimen pituus */
		remnum = RemoveGList(window,&gadget4[8],2);
		strinfo[3].LongInt = tamakappale.stoisto[soittimennum];
		strinfo[4].LongInt = tamakappale.stoistonpit[soittimennum];
		strinfo[3].DispPos = strinfo[4].DispPos = 0;
		(void)stcu_d(toistostr,tamakappale.stoisto[soittimennum]);
		(void)stcu_d(tpitstr,tamakappale.stoistonpit[soittimennum]);
		AddGList(window,&gadget4[8],remnum,2,NULL);
		RefreshGList(&gadget4[8],window,NULL,2); /* stringit */
		DispVolGadget();
	} else if(nykyinenosio == 9) {
		if(tamakappale.midikanava[soittimennum]) {
			Korosta(&gadget9[1],TRUE);
			Korosta(&gadget9[2],FALSE);
			if(prevmch && prevmch != tamakappale.midikanava[
				soittimennum]) Korosta(&gadget9[prevmch+2],FALSE);
			prevmch = tamakappale.midikanava[soittimennum];
			Korosta(&gadget9[prevmch+2],TRUE);
		} else {
			Korosta(&gadget9[1],FALSE);
			Korosta(&gadget9[2],TRUE);
			if(prevmch) Korosta(&gadget9[prevmch+2],FALSE);
			prevmch = 0;
		}
		DispPresetGadget();
	}
	if(tamakappale.hyppysoitin & (1 << soittimennum))
		Korosta(&gadget4[6],TRUE);
	else	Korosta(&gadget4[6],FALSE);
	TulostaLohkoJaSoitin();
}

void TulostaSoittoLohkot()
{
	register UBYTE sjarj,sjarjkymm = 0;
	UCOUNT rivilaskin;
	char lohkoteksti[2];
	if(nykyinenosio != 3) return;
	SetAPen(wrp,1);
	for(rivilaskin = 0; rivilaskin < 3; rivilaskin++) {
		sjarj = tamakappale.soittojarjestys[soittolohkonnum - 1 + rivilaskin];
		lohkoteksti[0] = 0;
		while(sjarj >= 10) { sjarj -= 10; sjarjkymm++; lohkoteksti[0]++; }
		if(lohkoteksti[0]) lohkoteksti[0] += '0';
		else lohkoteksti[0] = ' ';
		lohkoteksti[1] = '0' + sjarj;
		Move(wrp,175,26 + 8 * rivilaskin);
		if(soittolohkonnum + rivilaskin == 0 ||
			soittolohkonnum + rivilaskin > tamakappale.kappaleen_pituus) {
			lohkoteksti[0] = lohkoteksti[1] = ' '; }
			if(rivilaskin == 1) SetBPen(wrp,2); else SetBPen(wrp,3);
			Text(wrp,lohkoteksti,2);
		}
		SetAPen(wrp,0);
}

void Ilmoita(teksti)
char *teksti;
{
	static char edellinenteksti[40] = "";
	extern char title[];
	if(!teksti) {
		BltBitMapRastPort(&nayttobm,0,0,wrp,0,0,275,13,0xc0);
		ilmoitusnakyy = FALSE;
	}
	else {
		if(ilmoitusnakyy && !strcmp(edellinenteksti,teksti)) return;
		strcpy(edellinenteksti,teksti);
		SetAPen(wrp,0);
		RectFill(wrp,1,1,274,12);
		Move(wrp,5,10);
		SetAPen(wrp,1);
		SetDrMd(wrp,JAM1);
		Text(wrp,teksti,strlen(teksti));
		SetDrMd(wrp,JAM2);
		SetAPen(wrp,0);
		ilmoitusnakyy = TRUE;
	}
}

static void kymmenjarj(ptr,luku)
UBYTE *ptr;
UBYTE luku;
{
	*ptr = '0';
	while(luku >= 10) { luku -= 10; (*ptr)++; }
	*(ptr+1) = '0'+luku;
}

void TulostaLohkoJaSoitin()
{
	static UWORD prevtrknum = 4;
	static char tulteksti[] = "  /  ";
	char snimitxt[11],cnt,mrkjalj = strlen(tamakappale.soitin[soittimennum]);
	kymmenjarj(&tulteksti[0],(UBYTE)(soittolohkonnum + 1));
	kymmenjarj(&tulteksti[3],tamakappale.kappaleen_pituus);
	Move(wrp,13,72);
	SetAPen(wrp,0); SetBPen(wrp,3);
	Text(wrp,tulteksti,5);
	kymmenjarj(&tulteksti[0],soittolohko);
	kymmenjarj(&tulteksti[3],(lohkoja - 1));
	Move(wrp,64,72);
	Text(wrp,tulteksti,5);
	tulteksti[0] = heksaluku[soittimennum];
	Move(wrp,116,72);
	Text(wrp,tulteksti,1);
	tulteksti[1] = firstdisptrk / 4 + '1';
	tulteksti[3] = lohko[soittolohko]->numtracks / 4 + '0';
	Move(wrp,136,72);
	Text(wrp,tulteksti+1,3);
	for(cnt = 0; cnt < 10; cnt++) {
		if(mrkjalj-- > 0) snimitxt[cnt] = tamakappale.soitin[soittimennum][cnt];
		else snimitxt[cnt] = ' ';
	}
	Move(wrp,234,72);
	Text(wrp,snimitxt,10);
	if(nykyinenosio == 9) {
		Move(wrp,32,25);
		Text(wrp,snimitxt,10);
	}
	else if(nykyinenosio == 5) {
		UWORD plblock = soittolohko;
		if(lohko[plblock]->numtracks != prevtrknum) {
			Korosta(&gadget5[15 + prevtrknum / 4],FALSE);
			prevtrknum = lohko[plblock]->numtracks;
			Korosta(&gadget5[15 + prevtrknum / 4],TRUE);
		}
	}
}

void AsetaSuodatin()
{
	if(tamakappale.liput & LIPPU_SUODATINPAALLA) {
		ciaa.ciapra &= ~CIAF_LED;
		Korosta(&gadget3[5],TRUE);
	} else {
		ciaa.ciapra |= CIAF_LED;
		Korosta(&gadget3[5],FALSE);
	}
}

void NollaaVarit()
{
	SetRGB4(vp,0,0x0,0x0,0x0);
	SetRGB4(vp,1,0xc,0xc,0xc);
	SetRGB4(vp,2,0x5,0x5,0x6);
	SetRGB4(vp,3,0x9,0x9,0xa);
	SetRGB4(vp,4,0xf,0x0,0x0);
	SetRGB4(vp,5,0xf,0x6,0x6);
	SetRGB4(vp,6,0xf,0x9,0x9);
	SetRGB4(vp,7,0xf,0xc,0xc);
	DrawColorGadgets(thiscol);
}

void DispVolGadget()
{
	char num[2];
	if(nykyinenosio == 4) {
		if(tamakappale.soittimenvoimakkuus[soittimennum])
			ModifyProp(&gadget4[11],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
			tamakappale.soittimenvoimakkuus[soittimennum] * 1024 - 1,0,0x400,0);
		else	ModifyProp(&gadget4[11],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
			0,0,0x400,0);
		kymmenjarj(num,tamakappale.soittimenvoimakkuus[soittimennum]);
		Move(wrp,56,58);
		Text(wrp,num,2); /* Lopuksi soittimen voimakkuus */
	}
}

void DispPresetGadget()
{
	extern char presetstr[];
	UWORD rempos;
	if(nykyinenosio != 9) return;
	if(tamakappale.midipreset[soittimennum])
		ModifyProp(&gadget9[21],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
		tamakappale.midipreset[soittimennum] * 512 - 1,0,508,0);
	else	ModifyProp(&gadget9[21],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
		0,0,508,0);
	rempos = RemoveGadget(window,&gadget9[19]);
	stci_d(presetstr,tamakappale.midipreset[soittimennum]);
	strinfo[5].LongInt = tamakappale.midipreset[soittimennum];
	AddGadget(window,&gadget9[19],rempos);
	RefreshGList(&gadget9[19],window,NULL,1);
}
	
void NewBlockHere(UWORD hblock,UWORD tracks)
{
	UWORD blockcnt;
	if(lohkoja < 100) {
		blockcnt = lohkoja++;
		for(; blockcnt > hblock; blockcnt--)
			lohko[blockcnt] = lohko[blockcnt-1];
		lohko[hblock] = 0L;
		if(AllocBlock(hblock,tracks)) DelBlockHere(hblock);
		else for(blockcnt = 0; blockcnt <
		     tamakappale.kappaleen_pituus; blockcnt++)
			if(tamakappale.soittojarjestys[blockcnt] >= hblock)
				tamakappale.soittojarjestys[blockcnt]++;
	} else Ilmoita("No more than 100 blocks!!");
	TulostaLohkoJaSoitin();
	PaivitaNaytto(TRUE);
}

void DelBlockHere(UWORD hblock)
{
	UWORD blockcnt = hblock;
	if(lohkoja > 1) {
		if(soittolohko >= lohkoja-1) soittolohko--;
		FreeBlock(blockcnt);
		for(;blockcnt < lohkoja; blockcnt++)
			lohko[blockcnt] = lohko[blockcnt+1];
		lohko[lohkoja--] = 0L;
		for(blockcnt = 0; blockcnt < tamakappale.kappaleen_pituus; blockcnt++)
			if(tamakappale.soittojarjestys[blockcnt] >= hblock
			   && tamakappale.soittojarjestys[blockcnt])
				tamakappale.soittojarjestys[blockcnt]--;
	}
	TulostaLohkoJaSoitin();
	PaivitaNaytto(TRUE);
}

void DispInfoGadgets()
{
	UWORD choncnt;
	for(choncnt = 0; choncnt < 16; choncnt++) {
		register UWORD starty = choncnt > 7 ? 71 : 67;
		register UWORD startx = 3 * (choncnt & 0x7) + 205;
		if(aanipaalla[choncnt]) {
			SetAPen(wrp,4);
			WritePixel(wrp,startx,starty);
			WritePixel(wrp,startx,starty + 1);
			WritePixel(wrp,startx + 1,starty + 1);
			SetAPen(wrp,6);
			WritePixel(wrp,startx + 1,starty);
		}
		else {
			SetAPen(wrp,1);
			WritePixel(wrp,startx,starty);
			WritePixel(wrp,startx,starty + 1);
			WritePixel(wrp,startx + 1,starty);
			WritePixel(wrp,startx + 1,starty + 1);
		}
	}
	SetAPen(wrp,0);
	choncnt = nykyinenosio;
	nykyinenosio = 0xF;
	Korosta(&gadget1[8],(BOOL)(gadget6[0].GadgetID & 0x1000));
	Korosta(&gadget1[9],(BOOL)(gadget6[1].GadgetID & 0x1000));
	nykyinenosio = choncnt;
	DrawImage(wrp,&oktimg[nappokt],164,66);
}

void ShowTempo()
{
	UWORD remnum,new = tempo; /* <- because tempo is volatile */
	UBYTE tempostr[4] = "000";
	if(nykyinenosio == 3)	remnum = RemoveGadget(window,&gadget3[9]);
	propinfo[1].HorizPot = 274 * tempo - 225;
	if(nykyinenosio == 3) {
		AddGadget(window,&gadget3[9],remnum);
		RefreshGList(&gadget3[9],window,NULL,1);
		Move(wrp,104,45);
		while(new >= 100) { new -= 100;	tempostr[0]++; }
		while(new >= 10)  { new -= 10;	tempostr[1]++; }
		while(new)	  { new--;	tempostr[2]++; }
		Text(wrp,tempostr,3);
	}
}

void SpecialUpdate()
{
	extern UWORD chip mouse1[];
	if(specialupd & 0x1) {	/* bit #0 = filter */
		if(ciaa.ciapra & CIAF_LED) Korosta(&gadget3[5],FALSE);
		else Korosta(&gadget3[5],TRUE);
		specialupd &= ~0x1;
	}
	if(specialupd & 0x2) {	/* bit #1 = stop playing */
		Korosta(&gadget3[0],FALSE);
		Korosta(&gadget3[1],FALSE);
		SetPointer(window,&mouse1[0],23,16,-1,0);
		specialupd &= ~0x2;
	}
	if(specialupd & 0x4) {	/* change tempo */
		ShowTempo();
		specialupd &= ~0x4;
	}
}

void ChgTempo(UWORD new)
{
	tamakappale.tempo = new;
	SetTempo(new);
	SpecialUpdate(); /* SetTempo() will set specialupd flag */
}

static void DispColVals(UWORD r,UWORD g,UWORD b)
{
	Move(wrp,107,27);
	Text(wrp,&heksaluku[r],1);
	Move(wrp,107,37);
	Text(wrp,&heksaluku[g],1);
	Move(wrp,107,47);
	Text(wrp,&heksaluku[b],1);
}

void DrawColorGadgets(UBYTE newcolor)
{
	static BYTE currcol = 0;
	UWORD newrgb,r,g,b;
	static WORD far boxdata[] = { -1,-1,8,-1,8,8,-1,8,-1,0 };
	static struct Border far box = { 0,0,7,0,COMPLEMENT,5,boxdata,NULL };
	if(nykyinenosio != 7) return;
	if(newcolor != -1) {
		DrawBorder(wrp,&box,10 * currcol + 15,52);
		currcol = newcolor;
	}
	DrawBorder(wrp,&box,10 * currcol + 15,52);
	newrgb = GetRGB4(vp->ColorMap,currcol);
	r = (newrgb & 0x0f00) >> 8;
	g = (newrgb & 0x00f0) >> 4;
	b = newrgb & 0x000f;
	ModifyProp(&gadget7[0],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
		r * (MAXPOT / 15),0,MAXBODY / 16,0);
	ModifyProp(&gadget7[1],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
		g * (MAXPOT / 15),0,MAXBODY / 16,0);
	ModifyProp(&gadget7[2],window,NULL,AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
		b * (MAXPOT / 15),0,MAXBODY / 16,0);
	DispColVals(r,g,b);
}

void GetUndoColors()
{
	UCOUNT counter = 0;
	for(;counter < 8; counter++) undocolors[counter] =
		GetRGB4(vp->ColorMap,counter);
}

static void UndoColors()
{
	UCOUNT counter = 0;
	for(;counter < 8; counter++) SetRGB4(vp,counter,
		(undocolors[counter] & 0x0f00) >> 8,(undocolors[counter] &
		0x00f0) >> 4,undocolors[counter] & 0x000f);
	DrawColorGadgets(thiscol);
}

void ColorHandler(UWORD gid)
{
	if(gid >= 0x703 && gid <= 0x70A)
		DrawColorGadgets(thiscol = (UBYTE)(gid - 0x703));
	else if(gid >= 0x700 && gid <= 0x702) {
		UWORD rgb[3];
		rgb[0] = propinfo[5].HorizPot / 4096;
		rgb[1] = propinfo[6].HorizPot / 4096;
		rgb[2] = propinfo[7].HorizPot / 4096;
		SetRGB4(vp,thiscol,rgb[0],rgb[1],rgb[2]);
		DispColVals(rgb[0],rgb[1],rgb[2]);
		ModifyProp(&gadget7[gid - 0x700],window,NULL,
			AUTOKNOB|FREEHORIZ|PROPBORDERLESS,
			rgb[gid - 0x700] * (MAXPOT / 15),0,MAXBODY/16,0);
	}
	else if(gid == 0x70B) NollaaVarit();
	else if(gid == 0x70C) UndoColors();
}

void RemoveInstrument()
{
	if(soitin[soittimennum]) {
		FreeMem((void *)soitin[soittimennum],soitin[soittimennum]->
			length + sizeof(struct Soitin));
		soitin[soittimennum] = NULL;
		tamakappale.soitin[soittimennum][0] = '\0';
		tamakappale.soittimenvoimakkuus[soittimennum] = 64;
		tamakappale.stoisto[soittimennum] = tamakappale.
			stoistonpit[soittimennum] = 0;
		tamakappale.midikanava[soittimennum] =
			tamakappale.midipreset[soittimennum] = 0;
		tamakappale.hyppysoitin &= ~(1<<soittimennum);
		PaivitaSoittimennimi();
	}
}

void GetRepeat()
{
	LONG newrep = strinfo[3].LongInt;
	if(newrep < 0) tamakappale.stoisto[soittimennum] = 0;
	else tamakappale.stoisto[soittimennum] = (UWORD)newrep;
	PaivitaSoittimennimi();
	if(nykyinenosio == 4) ActivateGadget(&gadget4[9],window,NULL);
}

void GetRepLen()
{
	LONG newrl = strinfo[4].LongInt;
	if(newrl < 0) tamakappale.stoistonpit[soittimennum] = 0;
	else tamakappale.stoistonpit[soittimennum] = (UWORD)newrl;
	PaivitaSoittimennimi();
}

void InsertSeq(UBYTE num)
{
	UWORD pbnum = soittolohkonnum,cnt;
	if(tamakappale.kappaleen_pituus >= 99) {
		Ilmoita("Max = 99 sequences!!");
		return;
	}
	for(cnt = tamakappale.kappaleen_pituus; cnt > pbnum; cnt--)
		tamakappale.soittojarjestys[cnt] = tamakappale.soittojarjestys[cnt-1];
	tamakappale.kappaleen_pituus++;
	tamakappale.soittojarjestys[pbnum] = num;
	TulostaSoittoLohkot();
	TulostaLohkoJaSoitin();
}

void DelSeq()
{
	UWORD pbnum = soittolohkonnum,cnt;
	if(tamakappale.kappaleen_pituus <= 1 || pbnum >= tamakappale.
		kappaleen_pituus) return;
	tamakappale.kappaleen_pituus--;
	for(cnt = pbnum; cnt < tamakappale.kappaleen_pituus; cnt++)
		tamakappale.soittojarjestys[cnt] = tamakappale.soittojarjestys[cnt+1];
	TulostaSoittoLohkot();
	TulostaLohkoJaSoitin();
}

void PlayTransp(BYTE transp)
{
	char num[3];
	UWORD pos;
	if(transp < -12) transp = -12;
	else if(transp > 12) transp = 12;
	tamakappale.playtransp = transp;
	if(nykyinenosio == 0xA)	pos = RemoveGadget(window,&gadgetA[13]);
	propinfo[4].HorizPot = 2622 * (transp + 13) - 15;
	if(nykyinenosio == 0xA) {
		AddGadget(window,&gadgetA[13],pos);
		RefreshGList(&gadgetA[13],window,NULL,1);
	}
	kymmenjarj(&num[1],abs(transp));
	if(transp < 0) num[0] = '-'; else num[0] = ' ';
	SetAPen(wrp,2);
	Move(wrp,203,40);
	Text(wrp,num,3);
}

static void TransposeTrack(UWORD block,UBYTE track,BYTE steps)
{
	UBYTE *endptr,*noteptr = &lohko[block]->music[0];
	BYTE newnote;
	endptr = noteptr + 3 * lohko[block]->numtracks * 64;
	if(track != 0xff) noteptr += 3*track;
	while(noteptr < endptr) {
		if(newnote = *noteptr & 0x7f) {
			if(gadgetA[17].GadgetID & 0x1000 ||
				(((*(noteptr+1) >> 4) + (*noteptr & 0x80 ?
					16 : 0)) == soittimennum)) {
				newnote += steps;
				if(newnote <= 0) newnote += 12;
				else if(newnote > 63) newnote -= 12;
				*noteptr &= 0x80;
				*noteptr |= newnote;
			}
		}
		if(track != 0xff) noteptr += 3 * lohko[block]->numtracks;
		else noteptr += 3;
	}
}

void Transpose(BYTE steps,UBYTE obj)
{
	if(obj == 0) { /* whole song */
		UWORD blockcnt;
		for(blockcnt = 0; blockcnt < lohkoja; blockcnt++)
			TransposeTrack(blockcnt,0xff,steps);
	} else if(obj==1) TransposeTrack(soittolohko,0xff,steps); /*block*/
	else if(obj == 2) TransposeTrack(soittolohko,(UBYTE)currtrk,steps);
	PaivitaNaytto(TRUE);
}

void ClrFileName()	/* Clears the file name, so the user can't  */
{			/* accidentaly load a new song. */
	register UWORD pos;
	extern char kappaleennimi[];
	if(kappaleennimi[0] == '\0') return;
	if(nykyinenosio == 2) pos = RemoveGadget(window,&gadget2[9]);
	strcpy(sname,kappaleennimi);
	kappaleennimi[0] = '\0';
	if(nykyinenosio == 2) {
		AddGadget(window,&gadget2[9],pos);
		RefreshGList(&gadget2[9],window,NULL,1);
	}
}

void RetFileName()
{
	register UWORD pos;
	if(nykyinenosio == 2) pos = RemoveGadget(window,&gadget2[9]);
	strcpy(kappaleennimi,sname);
	if(nykyinenosio == 2) {
		AddGadget(window,&gadget2[9],pos);
		RefreshGList(&gadget2[9],window,NULL,1);
	}
}
	
static void CreateCopperList()
{
	static UWORD cols[] = { 0xf21,0xf31,0xf41,0xf51,0xf62,0xf72,0xf82,
		0xf92,0xfa2,0xfb2,0xfc2,0xfd3,0xfe3,0xff3,0xef3,0xcf2,
		0xbf2,0x9f2,0x8f1,0x6f1,0x4f1,0x2f0,0x0f0,0x0e0,0x0d0,
		0x0c0,0x0b0,0x0a0,0x090,0x080 };
	UWORD colcnt,ycount = 137;
	struct UCopList *cl;
	if(coplist) return;
	cl = (struct UCopList *)AllocMem(sizeof(struct UCopList),
		MEMF_PUBLIC|MEMF_CHIP|MEMF_CLEAR);
	if(!cl) return;
	SetRGB4(vp,21,0xa,0xa,0xa);	SetRGB4(vp,22,0xa,0xa,0xa);
	SetRGB4(vp,23,0xb,0xb,0xb);	SetRGB4(vp,25,0xa,0xa,0xa);
	SetRGB4(vp,26,0xa,0xa,0xa);	SetRGB4(vp,27,0xb,0xb,0xb);
	for(colcnt = 0; colcnt < 30; colcnt++) {
		CWAIT(cl,ycount,0);
		CMove(cl,(long)(&custom.color[22]),(long)cols[colcnt]);
		CBump(cl);
		CMove(cl,(long)(&custom.color[26]),(long)cols[colcnt]);
		CBump(cl);
		ycount += 2;
	}
	CEND(cl);
	vp->UCopIns = cl;
	RethinkDisplay();
	coplist = 1;
}

void RemCopperList() /* Remove our beautiful copper colors */
{
	struct UCopList *uins = vp->UCopIns,*this;
	if(!coplist) return;
	Forbid();
	vp->UCopIns = 0;
	RethinkDisplay();
	while(uins) {
		this = uins;
		FreeCopList(uins->FirstCopList);
		uins = uins->Next;
		FreeMem((void *)this,sizeof(struct UCopList));
	}
	Permit();
	coplist = 0;
}

void RemEqualizer()
{
	if(!equalizerok) return;
	equalizerok = 0;
	if(allocsprmsk & 1) { FreeSprite(2); allocsprmsk &= ~1; }
	if(allocsprmsk & 2) { FreeSprite(3); allocsprmsk &= ~2; }
	if(allocsprmsk & 4) { FreeSprite(4); allocsprmsk &= ~4; }
	if(allocsprmsk & 8) { FreeSprite(5); allocsprmsk &= ~8; }
}

void InitEqualizer()
{
	static struct SimpleSprite ss1 = { eq1,64,75,134,0 },
		ss2 = { eq2,64,147,134,0 },ss3 = { eq3,64,219,134,0 },
		ss4 = { eq4,64,291,134,0 };
	if(equalizerok) return;
	if(GetSprite(&ss1,2) == -1) { RemEqualizer(); return; }
	allocsprmsk |= 1;
	if(GetSprite(&ss2,3) == -1) { RemEqualizer(); return; }
	allocsprmsk |= 2;
	if(GetSprite(&ss3,4) == -1) { RemEqualizer(); return; }
	allocsprmsk |= 4;
	if(GetSprite(&ss4,5) == -1) { RemEqualizer(); return; }
	allocsprmsk |= 8;
	ChangeSprite(vp,&ss1,eq1);
	ChangeSprite(vp,&ss2,eq2);
	ChangeSprite(vp,&ss3,eq3);
	ChangeSprite(vp,&ss4,eq4);
	if(!coplist) CreateCopperList();
	equalizerok = 1;
}

void UpdateJumpGadgets()
{
	Korosta(&gadget7[13],(BOOL)(!(tamakappale.liput & LIPPU_HYPPELYPAALLA)));
	if(tamakappale.liput & LIPPU_HYPPELYPAALLA) {
		Korosta(&gadget7[14],(BOOL)(tamakappale.liput &
			LIPPU_HYPPELYTAHTIIN));
		Korosta(&gadget7[15],(BOOL)(!(tamakappale.liput &
			LIPPU_HYPPELYTAHTIIN)));
	} else {
		Korosta(&gadget7[14],FALSE);
		Korosta(&gadget7[15],FALSE);
	}
}