np2/generic/keydisp.c - diff

Return to keydisp.c CVS log

Up to [RetroPC.NET] / np2 / generic

Diff for /np2/generic/keydisp.c between versions 1.3 and 1.9

version 1.3, 2003/11/28 15:28:19	version 1.9, 2005/02/07 14:46:10
Line 11	Line 11
typedef struct {	typedef struct {
UINT16 posx;	UINT16 posx;
UINT16 pals;	UINT16 pals;
const BYTE *data;	const UINT8 *data;
} KDKEYPOS;	} KDKEYPOS;

typedef struct {	typedef struct {
BYTE k[KEYDISP_NOTEMAX];	UINT8 k[KEYDISP_NOTEMAX];
BYTE r[KEYDISP_NOTEMAX];	UINT8 r[KEYDISP_NOTEMAX];
UINT remain;	UINT remain;
BYTE flag;	UINT8 flag;
BYTE padding[3];	UINT8 padding[3];
} KDCHANNEL;	} KDCHANNEL;

typedef struct {	typedef struct {
BYTE ch;	UINT8 ch;
BYTE key;	UINT8 key;
} KDDELAYE;	} KDDELAYE;

typedef struct {	typedef struct {
UINT pos;	UINT pos;
UINT rem;	UINT rem;
BYTE warm;	UINT8 warm;
BYTE warmbase;	UINT8 warmbase;
} KDDELAY;	} KDDELAY;

typedef struct {	typedef struct {
UINT16 fnum[4];	UINT16 fnum[4];
BYTE lastnote[4];	UINT8 lastnote[4];
BYTE flag;	UINT8 flag;
BYTE extflag;	UINT8 extflag;
} KDFMCTRL;	} KDFMCTRL;

typedef struct {	typedef struct {
UINT16 fto[4];	UINT16 fto[4];
BYTE lastnote[4];	UINT8 lastnote[4];
BYTE flag;	UINT8 flag;
BYTE mix;	UINT8 mix;
BYTE padding[2];	UINT8 padding[2];
} KDPSGCTRL;	} KDPSGCTRL;

typedef struct {	typedef struct {
BYTE mode;	UINT8 mode;
BYTE dispflag;	UINT8 dispflag;
BYTE framepast;	UINT8 framepast;
BYTE keymax;	UINT8 keymax;
BYTE fmmax;	UINT8 fmmax;
BYTE psgmax;	UINT8 psgmax;
BYTE fmpos[KEYDISP_FMMAX];	UINT8 fmpos[KEYDISP_FMMAX];
BYTE psgpos[KEYDISP_PSGMAX];	UINT8 psgpos[KEYDISP_PSGMAX];
UINT fmreg[KEYDISP_FMMAX];	UINT fmreg[KEYDISP_FMMAX];
KDDELAY delay;	KDDELAY delay;
KDCHANNEL ch[KEYDISP_CHMAX];	KDCHANNEL ch[KEYDISP_CHMAX];
KDFMCTRL fmctl[KEYDISP_FMMAX];	KDFMCTRL fmctl[KEYDISP_FMMAX];
KDPSGCTRL psgctl[KEYDISP_PSGMAX];	KDPSGCTRL psgctl[KEYDISP_PSGMAX];
BYTE pal8[KEYDISP_PALS];	UINT8 pal8[KEYDISP_PALS];
UINT16 pal16[KEYDISP_LEVEL*2];	UINT16 pal16[KEYDISP_LEVEL*2];
RGB32 pal32[KEYDISP_LEVEL*2];	RGB32 pal32[KEYDISP_LEVEL*2];
KDKEYPOS keypos[128];	KDKEYPOS keypos[128];
Line 77 static KEYDISP keydisp;	Line 77 static KEYDISP keydisp;

// ---- event	// ---- event

static void keyon(UINT ch, BYTE note) {	static void keyon(UINT ch, UINT8 note) {

UINT i;	UINT i;
KDCHANNEL *kdch;	KDCHANNEL *kdch;
Line 104 static void keyon(UINT ch, BYTE note) {	Line 104 static void keyon(UINT ch, BYTE note) {
}	}
}	}

static void keyoff(UINT ch, BYTE note) {	static void keyoff(UINT ch, UINT8 note) {

UINT i;	UINT i;
KDCHANNEL *kdch;	KDCHANNEL *kdch;
Line 136 static void chkeyoff(UINT ch) {	Line 136 static void chkeyoff(UINT ch) {

static void keyalloff(void) {	static void keyalloff(void) {

BYTE i;	UINT8 i;

for (i=0; i<KEYDISP_CHMAX; i++) {	for (i=0; i<KEYDISP_CHMAX; i++) {
chkeyoff(i);	chkeyoff(i);
Line 170 static void delayreset(void) {	Line 170 static void delayreset(void) {
keyalloff();	keyalloff();
}	}

static void delayexecevent(BYTE framepast) {	static void delayexecevent(UINT8 framepast) {

KDDELAYE *ebase;	KDDELAYE *ebase;
UINT pos;	UINT pos;
Line 225 static void delayexecevent(BYTE framepas	Line 225 static void delayexecevent(BYTE framepas
keydisp.delay.rem = rem;	keydisp.delay.rem = rem;
}	}

static void delaysetevent(BYTE ch, BYTE key) {	static void delaysetevent(UINT8 ch, UINT8 key) {

KDDELAYE *e;	KDDELAYE *e;

Line 258 static void delaysetevent(BYTE ch, BYTE	Line 258 static void delaysetevent(BYTE ch, BYTE

// ---- FM	// ---- FM

static BYTE getfmnote(UINT16 fnum) {	static UINT8 getfmnote(UINT16 fnum) {

BYTE ret;	UINT8 ret;
int i;	int i;

ret = (fnum >> 11) & 7;	ret = (fnum >> 11) & 7;
Line 288 static BYTE getfmnote(UINT16 fnum) {	Line 288 static BYTE getfmnote(UINT16 fnum) {
return(ret);	return(ret);
}	}

static void fmkeyoff(BYTE ch, KDFMCTRL *k) {	static void fmkeyoff(UINT8 ch, KDFMCTRL *k) {

delaysetevent(keydisp.fmpos[ch], k->lastnote[0]);	delaysetevent(keydisp.fmpos[ch], k->lastnote[0]);
}	}

static void fmkeyon(BYTE ch, KDFMCTRL *k) {	static void fmkeyon(UINT8 ch, KDFMCTRL *k) {

UINT reg;	UINT reg;

Line 301 static void fmkeyon(BYTE ch, KDFMCTRL *k	Line 301 static void fmkeyon(BYTE ch, KDFMCTRL *k
reg = keydisp.fmreg[ch] + 0xa0;	reg = keydisp.fmreg[ch] + 0xa0;
k->fnum[0] = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];	k->fnum[0] = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];
k->lastnote[0] = getfmnote(k->fnum[0]);	k->lastnote[0] = getfmnote(k->fnum[0]);
delaysetevent(keydisp.fmpos[ch], (BYTE)(k->lastnote[0] \| 0x80));	delaysetevent(keydisp.fmpos[ch], (UINT8)(k->lastnote[0] \| 0x80));
}	}

static void fmkeyreset(void) {	static void fmkeyreset(void) {
Line 309 static void fmkeyreset(void) {	Line 309 static void fmkeyreset(void) {
ZeroMemory(keydisp.fmctl, sizeof(keydisp.fmctl));	ZeroMemory(keydisp.fmctl, sizeof(keydisp.fmctl));
}	}

void keydisp_fmkeyon(BYTE ch, BYTE value) {	void keydisp_fmkeyon(UINT8 ch, UINT8 value) {

KDFMCTRL *k;	KDFMCTRL *k;

Line 333 void keydisp_fmkeyon(BYTE ch, BYTE value	Line 333 void keydisp_fmkeyon(BYTE ch, BYTE value

static void fmkeysync(void) {	static void fmkeysync(void) {

BYTE ch;	UINT8 ch;
KDFMCTRL *k;	KDFMCTRL *k;
UINT16 reg;	UINT16 reg;
UINT16 fnum;	UINT16 fnum;
Line 343 static void fmkeysync(void) {	Line 343 static void fmkeysync(void) {
reg = keydisp.fmreg[ch] + 0xa0;	reg = keydisp.fmreg[ch] + 0xa0;
fnum = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];	fnum = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];
if (k->fnum[0] != fnum) {	if (k->fnum[0] != fnum) {
BYTE n;	UINT8 n;
k->fnum[0] = fnum;	k->fnum[0] = fnum;
n = getfmnote(fnum);	n = getfmnote(fnum);
if (k->lastnote[0] != n) {	if (k->lastnote[0] != n) {
Line 351 static void fmkeysync(void) {	Line 351 static void fmkeysync(void) {
}	}
k->lastnote[0] = n;	k->lastnote[0] = n;
delaysetevent(keydisp.fmpos[ch],	delaysetevent(keydisp.fmpos[ch],
(BYTE)(k->lastnote[0] \| 0x80));	(UINT8)(k->lastnote[0] \| 0x80));
}	}
}	}
}	}
Line 362 static void fmkeysync(void) {	Line 362 static void fmkeysync(void) {

static const void *psgtbl[3] = {&psg1, &psg2, &psg3};	static const void *psgtbl[3] = {&psg1, &psg2, &psg3};

static BYTE getpsgnote(UINT16 tone) {	static UINT8 getpsgnote(UINT16 tone) {

BYTE ret;	UINT8 ret;
int i;	int i;

ret = 60;	ret = 60;
Line 393 static BYTE getpsgnote(UINT16 tone) {	Line 393 static BYTE getpsgnote(UINT16 tone) {
return(ret);	return(ret);
}	}

static void psgmix(BYTE ch, PSGGEN psg) {	static void psgmix(UINT8 ch, PSGGEN psg) {

KDPSGCTRL *k;	KDPSGCTRL *k;

k = keydisp.psgctl + ch;	k = keydisp.psgctl + ch;
if ((k->mix ^ psg->reg.mixer) & 7) {	if ((k->mix ^ psg->reg.mixer) & 7) {
BYTE i, bit, pos;	UINT8 i, bit, pos;
k->mix = psg->reg.mixer;	k->mix = psg->reg.mixer;
pos = keydisp.psgpos[ch];	pos = keydisp.psgpos[ch];
for (i=0, bit=1; i<3; i++, pos++, bit<<=1) {	for (i=0, bit=1; i<3; i++, pos++, bit<<=1) {
Line 409 static void psgmix(BYTE ch, PSGGEN psg)	Line 409 static void psgmix(BYTE ch, PSGGEN psg)
}	}
else if ((!(k->mix & bit)) && (psg->reg.vol[i] & 0x1f)) {	else if ((!(k->mix & bit)) && (psg->reg.vol[i] & 0x1f)) {
k->flag \|= bit;	k->flag \|= bit;
k->fto[i] = ((UINT16 )(psg->reg.tune[i])) & 0xfff;	k->fto[i] = LOADINTELWORD(psg->reg.tune[i]) & 0xfff;
k->lastnote[i] = getpsgnote(k->fto[i]);	k->lastnote[i] = getpsgnote(k->fto[i]);
delaysetevent(pos, (BYTE)(k->lastnote[i] \| 0x80));	delaysetevent(pos, (UINT8)(k->lastnote[i] \| 0x80));
}	}
}	}
}	}
}	}

static void psgvol(BYTE ch, PSGGEN psg, BYTE i) {	static void psgvol(UINT8 ch, PSGGEN psg, UINT8 i) {

KDPSGCTRL *k;	KDPSGCTRL *k;
BYTE bit;	UINT8 bit;
BYTE pos;	UINT8 pos;
UINT16 tune;	UINT16 tune;

k = keydisp.psgctl + ch;	k = keydisp.psgctl + ch;
Line 434 static void psgvol(BYTE ch, PSGGEN psg,	Line 434 static void psgvol(BYTE ch, PSGGEN psg,
tune &= 0xfff;	tune &= 0xfff;
k->fto[i] = tune;	k->fto[i] = tune;
k->lastnote[i] = getpsgnote(tune);	k->lastnote[i] = getpsgnote(tune);
delaysetevent(pos, (BYTE)(k->lastnote[i] \| 0x80));	delaysetevent(pos, (UINT8)(k->lastnote[i] \| 0x80));
}	}
}	}
else if (k->flag & bit) {	else if (k->flag & bit) {
Line 450 static void psgkeyreset(void) {	Line 450 static void psgkeyreset(void) {

void keydisp_psgmix(void *psg) {	void keydisp_psgmix(void *psg) {

BYTE c;	UINT8 c;

if (keydisp.mode != KEYDISP_MODEFM) {	if (keydisp.mode != KEYDISP_MODEFM) {
return;	return;
Line 463 void keydisp_psgmix(void *psg) {	Line 463 void keydisp_psgmix(void *psg) {
}	}
}	}

void keydisp_psgvol(void *psg, BYTE ch) {	void keydisp_psgvol(void *psg, UINT8 ch) {

BYTE c;	UINT8 c;

if (keydisp.mode != KEYDISP_MODEFM) {	if (keydisp.mode != KEYDISP_MODEFM) {
return;	return;
Line 480 void keydisp_psgvol(void *psg, BYTE ch)	Line 480 void keydisp_psgvol(void *psg, BYTE ch)

static void psgkeysync(void) {	static void psgkeysync(void) {

BYTE ch;	UINT8 ch;
KDPSGCTRL *k;	KDPSGCTRL *k;
BYTE bit;	UINT8 bit;
BYTE i;	UINT8 i;
BYTE pos;	UINT8 pos;
PSGGEN psg;	PSGGEN psg;
UINT16 tune;	UINT16 tune;
BYTE n;	UINT8 n;

for (ch=0, k=keydisp.psgctl; ch<keydisp.psgmax; ch++, k++) {	for (ch=0, k=keydisp.psgctl; ch<keydisp.psgmax; ch++, k++) {
psg = (PSGGEN)psgtbl[ch];	psg = (PSGGEN)psgtbl[ch];
Line 502 static void psgkeysync(void) {	Line 502 static void psgkeysync(void) {
if (k->lastnote[i] != n) {	if (k->lastnote[i] != n) {
delaysetevent(pos, k->lastnote[i]);	delaysetevent(pos, k->lastnote[i]);
k->lastnote[i] = n;	k->lastnote[i] = n;
delaysetevent(pos, (BYTE)(n \| 0x80));	delaysetevent(pos, (UINT8)(n \| 0x80));
}	}
}	}
}	}
Line 513 static void psgkeysync(void) {	Line 513 static void psgkeysync(void) {

// ---- BOARD change...	// ---- BOARD change...

static void setfmhdl(BYTE items, UINT base) {	static void setfmhdl(UINT8 items, UINT base) {

while(items--) {	while(items--) {
if ((keydisp.keymax < KEYDISP_CHMAX) &&	if ((keydisp.keymax < KEYDISP_CHMAX) &&
Line 529 static void setfmhdl(BYTE items, UINT ba	Line 529 static void setfmhdl(BYTE items, UINT ba
}	}
}	}

static void setpsghdl(BYTE items) {	static void setpsghdl(UINT8 items) {

while(items--) {	while(items--) {
if ((keydisp.keymax <= (KEYDISP_CHMAX - 3)) &&	if ((keydisp.keymax <= (KEYDISP_CHMAX - 3)) &&
Line 540 static void setpsghdl(BYTE items) {	Line 540 static void setpsghdl(BYTE items) {
}	}
}	}

void keydisp_setfmboard(BYTE b) {	void keydisp_setfmboard(UINT b) {

keydisp.keymax = 0;	keydisp.keymax = 0;
keydisp.fmmax = 0;	keydisp.fmmax = 0;
Line 586 void keydisp_setfmboard(BYTE b) {	Line 586 void keydisp_setfmboard(BYTE b) {

// ---- MIDI	// ---- MIDI

void keydisp_midi(const BYTE *cmd) {	void keydisp_midi(const UINT8 *cmd) {

if (keydisp.mode != KEYDISP_MODEMIDI) {	if (keydisp.mode != KEYDISP_MODEMIDI) {
return;	return;
Line 645 static int getdispkeys(void) {	Line 645 static int getdispkeys(void) {

static void clearrect(CMNVRAM *vram, int x, int y, int cx, int cy) {	static void clearrect(CMNVRAM *vram, int x, int y, int cx, int cy) {

	CMNPAL col;

switch(vram->bpp) {	switch(vram->bpp) {
#if defined(SUPPORT_8BPP)	#if defined(SUPPORT_8BPP)
case 8:	case 8:
cmndraw8_fill(vram, x, y, cx, cy, keydisp.pal8[KEYDISP_PALBG]);	col.pal8 = keydisp.pal8[KEYDISP_PALBG];
break;	break;
#endif	#endif
#if defined(SUPPORT_16BPP)	#if defined(SUPPORT_16BPP)
case 16:	case 16:
cmndraw16_fill(vram, x, y, cx, cy, keydisp.pal16[KEYDISP_LEVEL]);	col.pal16 = keydisp.pal16[KEYDISP_LEVEL];
break;	break;
#endif	#endif
#if defined(SUPPORT_24BPP)	#if defined(SUPPORT_24BPP)
case 24:	case 24:
cmndraw24_fill(vram, x, y, cx, cy, keydisp.pal32[KEYDISP_LEVEL]);
break;
#endif	#endif
#if defined(SUPPORT_32BPP)	#if defined(SUPPORT_32BPP)
case 32:	case 32:
cmndraw32_fill(vram, x, y, cx, cy, keydisp.pal32[KEYDISP_LEVEL]);	#endif
	#if defined(SUPPORT_24BPP) \|\| defined(SUPPORT_32BPP)
	col.pal32 = keydisp.pal32[KEYDISP_LEVEL];
break;	break;
#endif	#endif
	default:
	return;
}	}
	cmndraw_fill(vram, x, y, cx, cy, col);
}	}

static void drawkeybg(CMNVRAM *vram) {	static void drawkeybg(CMNVRAM *vram) {

	CMNPAL bg;
	CMNPAL fg;
int i;	int i;

switch(vram->bpp) {	switch(vram->bpp) {
#if defined(SUPPORT_8BPP)	#if defined(SUPPORT_8BPP)
case 8:	case 8:
for (i=0; i<10; i++) {	bg.pal8 = keydisp.pal8[KEYDISP_PALBG];
cmndraw8_setpat(vram, keybrd1, i * KEYDISP_KEYCX, 0,	fg.pal8 = keydisp.pal8[KEYDISP_PALFG];
keydisp.pal8[KEYDISP_PALBG], keydisp.pal8[KEYDISP_PALFG]);
}
cmndraw8_setpat(vram, keybrd2, 10 * KEYDISP_KEYCX, 0,
keydisp.pal8[KEYDISP_PALBG], keydisp.pal8[KEYDISP_PALFG]);
break;	break;
#endif	#endif
#if defined(SUPPORT_16BPP)	#if defined(SUPPORT_16BPP)
case 16:	case 16:
for (i=0; i<10; i++) {	bg.pal16 = keydisp.pal16[KEYDISP_LEVEL];
cmndraw16_setpat(vram, keybrd1, i * KEYDISP_KEYCX, 0,	fg.pal16 = keydisp.pal16[0];
keydisp.pal16[KEYDISP_LEVEL], keydisp.pal16[0]);
}
cmndraw16_setpat(vram, keybrd2, 10 * KEYDISP_KEYCX, 0,
keydisp.pal16[KEYDISP_LEVEL], keydisp.pal16[0]);
break;	break;
#endif	#endif
#if defined(SUPPORT_24BPP)	#if defined(SUPPORT_24BPP)
case 24:	case 24:
for (i=0; i<10; i++) {	bg.pal32 = keydisp.pal32[KEYDISP_LEVEL];
cmndraw24_setpat(vram, keybrd1, i * KEYDISP_KEYCX, 0,	fg.pal32 = keydisp.pal32[0];
keydisp.pal32[KEYDISP_LEVEL], keydisp.pal32[0]);
}
cmndraw24_setpat(vram, keybrd2, 10 * KEYDISP_KEYCX, 0,
keydisp.pal32[KEYDISP_LEVEL], keydisp.pal32[0]);
break;	break;
#endif	#endif
#if defined(SUPPORT_32BPP)	#if defined(SUPPORT_32BPP)
case 32:	case 32:
for (i=0; i<10; i++) {	bg.pal32 = keydisp.pal32[KEYDISP_LEVEL];
cmndraw32_setpat(vram, keybrd1, i * KEYDISP_KEYCX, 0,	fg.pal32 = keydisp.pal32[0];
keydisp.pal32[KEYDISP_LEVEL], keydisp.pal32[0]);
}
cmndraw32_setpat(vram, keybrd2, 10 * KEYDISP_KEYCX, 0,
keydisp.pal32[KEYDISP_LEVEL], keydisp.pal32[0]);
break;	break;
#endif	#endif
	default:
	return;
}	}
	for (i=0; i<10; i++) {
	cmndraw_setpat(vram, keybrd1, i * KEYDISP_KEYCX, 0, bg, fg);
	}
	cmndraw_setpat(vram, keybrd2, 10 * KEYDISP_KEYCX, 0, bg, fg);
}	}

static BOOL draw1key(CMNVRAM vram, KDCHANNEL kdch, UINT n) {	static BOOL draw1key(CMNVRAM vram, KDCHANNEL kdch, UINT n) {

KDKEYPOS *pos;	KDKEYPOS *pos;
UINT pal;	UINT pal;
BYTE pal8;	CMNPAL fg;

pos = keydisp.keypos + (kdch->k[n] & 0x7f);	pos = keydisp.keypos + (kdch->k[n] & 0x7f);
pal = kdch->r[n] & 0x7f;	pal = kdch->r[n] & 0x7f;
Line 729 static BOOL draw1key(CMNVRAM *vram, KDCH	Line 726 static BOOL draw1key(CMNVRAM *vram, KDCH
#if defined(SUPPORT_8BPP)	#if defined(SUPPORT_8BPP)
case 8:	case 8:
if (pal != (KEYDISP_LEVEL - 1)) {	if (pal != (KEYDISP_LEVEL - 1)) {
pal8 = keydisp.pal8[(pos->pals)?KEYDISP_PALBG:KEYDISP_PALFG];	fg.pal8 = keydisp.pal8[
cmndraw8_setfg(vram, pos->data, pos->posx, 0, pal8);	(pos->pals)?KEYDISP_PALBG:KEYDISP_PALFG];
	cmndraw_setfg(vram, pos->data, pos->posx, 0, fg);
kdch->r[n] = 0;	kdch->r[n] = 0;
return(TRUE);	return(TRUE);
}	}
cmndraw8_setfg(vram, pos->data, pos->posx, 0,	fg.pal8 = keydisp.pal8[KEYDISP_PALHIT];
keydisp.pal8[KEYDISP_PALHIT]);
break;	break;
#endif	#endif
#if defined(SUPPORT_16BPP)	#if defined(SUPPORT_16BPP)
case 16:	case 16:
cmndraw16_setfg(vram, pos->data, pos->posx, 0,	fg.pal16 = keydisp.pal16[pal + pos->pals];
keydisp.pal16[pal + pos->pals]);
break;	break;
#endif	#endif
#if defined(SUPPORT_24BPP)	#if defined(SUPPORT_24BPP)
case 24:	case 24:
cmndraw24_setfg(vram, pos->data, pos->posx, 0,	fg.pal32 = keydisp.pal32[pal + pos->pals];
keydisp.pal32[pal + pos->pals]);
break;	break;
#endif	#endif
#if defined(SUPPORT_32BPP)	#if defined(SUPPORT_32BPP)
case 32:	case 32:
cmndraw32_setfg(vram, pos->data, pos->posx, 0,	fg.pal32 = keydisp.pal32[pal + pos->pals];
keydisp.pal32[pal + pos->pals]);
break;	break;
#endif	#endif
	default:
	return(FALSE);
}	}
	cmndraw_setfg(vram, pos->data, pos->posx, 0, fg);
return(FALSE);	return(FALSE);
}	}

static BOOL draw1ch(CMNVRAM vram, BYTE framepast, KDCHANNEL kdch) {	static BOOL draw1ch(CMNVRAM vram, UINT8 framepast, KDCHANNEL kdch) {

BOOL draw;	BOOL draw;
UINT i;	UINT i;
BOOL coll;	BOOL coll;
BYTE nextf;	UINT8 nextf;
UINT j;	UINT j;

draw = FALSE;	draw = FALSE;
Line 866 void keydisp_setpal(CMNPALFN *palfn) {	Line 863 void keydisp_setpal(CMNPALFN *palfn) {
keydisp.dispflag \|= KEYDISP_FLAGREDRAW;	keydisp.dispflag \|= KEYDISP_FLAGREDRAW;
}	}

void keydisp_setmode(BYTE mode) {	void keydisp_setmode(UINT8 mode) {

if (keydisp.mode != mode) {	if (keydisp.mode != mode) {
keydisp.mode = mode;	keydisp.mode = mode;
Line 883 void keydisp_setmode(BYTE mode) {	Line 880 void keydisp_setmode(BYTE mode) {
}	}
}	}

void keydisp_setdelay(BYTE frames) {	void keydisp_setdelay(UINT8 frames) {

keydisp.delay.warmbase = frames;	keydisp.delay.warmbase = frames;
delayreset();	delayreset();
}	}

BYTE keydisp_process(BYTE framepast) {	UINT8 keydisp_process(UINT8 framepast) {

int keys;	int keys;
int i;	int i;
Line 957 BOOL keydisp_paint(CMNVRAM *vram, BOOL r	Line 954 BOOL keydisp_paint(CMNVRAM *vram, BOOL r
kdpnt_exit:	kdpnt_exit:
return(draw);	return(draw);
}	}

#endif	#endif

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.3
changed lines
	Added in v.1.9