[BACK]Return to keydisp.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / generic

Diff for /np2/generic/keydisp.c between versions 1.1 and 1.10

version 1.1, 2003/11/21 06:51:11 version 1.10, 2006/12/17 02:31:22
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] = (*(WORD *)(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 606  void keydisp_midi(const BYTE *cmd) { Line 606  void keydisp_midi(const BYTE *cmd) {
                         break;                          break;
   
                 case 0xb0:                  case 0xb0:
                         if ((cmd[1] == 0x7b) || (cmd[1] == 0x78)) {                          if ((cmd[1] == 0x78) || (cmd[1] == 0x79) || (cmd[1] == 0x7b)) {
                                 chkeyoff(cmd[0] & 0x0f);                                  chkeyoff(cmd[0] & 0x0f);
                         }                          }
                         break;                          break;
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 917  void keydisp_getsize(int *width, int *he Line 914  void keydisp_getsize(int *width, int *he
         if (width) {          if (width) {
                 *width = KEYDISP_WIDTH;                  *width = KEYDISP_WIDTH;
         }          }
         if (*height) {          if (height) {
                 *height = (getdispkeys() * KEYDISP_KEYCY) + 1;                  *height = (getdispkeys() * KEYDISP_KEYCY) + 1;
         }          }
         keydisp.dispflag &= ~KEYDISP_FLAGSIZING;          keydisp.dispflag &= ~KEYDISP_FLAGSIZING;
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
   
Removed from v.1.1  
changed lines
  Added in v.1.10

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