[BACK]Return to sstpmsg.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / win9x

Diff for /np2/win9x/sstpmsg.cpp between versions 1.1 and 1.8

version 1.1, 2003/10/16 17:58:50 version 1.8, 2005/03/19 18:54:58
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "strres.h"
 #include        "np2.h"  #include        "np2.h"
   #include        "scrnmng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "pccore.h"  
 #include        "sstp.h"  #include        "sstp.h"
 #include        "sstpres.h"  #include        "sstpres.h"
   #include        "pccore.h"
   #include        "iocore.h"
   #include        "sound.h"
   #include        "fmboard.h"
 #include        "np2info.h"  #include        "np2info.h"
   
   
 static char cr[] = "\\n";  static const OEMCHAR cr[] = OEMTEXT("\\n");
   
   
   // ---- np2info extend
   
   static const OEMCHAR str_jwinclr[] =
                                           OEMTEXT("256色\0ハイカラー\0フルカラー\0トゥルーカラー");
   static const OEMCHAR str_jwinmode[] =
                                           OEMTEXT(" (窓モード)\0 (フルスクリーン)");
   
   
   static void info_progtitle(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
           milstr_ncpy(str, np2oscfg.titles, maxlen);
   }
   
   static void info_jsound(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
   const OEMCHAR   *p;
   
           switch(usesound) {
                   case 0x01:
                           p = OEMTEXT("14ボード");
                           break;
   
                   case 0x02:
                           p = OEMTEXT("26音源");
                           break;
   
                   case 0x04:
                           p = OEMTEXT("86音源");
                           break;
   
                   case 0x06:
                           p = OEMTEXT("２枚刺し");
                           break;
   
                   case 0x08:
                           p = OEMTEXT("118音源");
                           break;
   
                   case 0x14:
                           p = OEMTEXT("86音源(ちびおと付)");
                           break;
   
                   case 0x20:
                           p = OEMTEXT("スピークボード");
                           break;
   
                   case 0x40:
                           p = OEMTEXT("スパークボード");
                           break;
   
                   case 0x80:
                           p = OEMTEXT("AMD-98");
                           break;
   
                   default:
                           p = OEMTEXT("なし");
                           break;
           }
           milstr_ncpy(str, p, maxlen);
   }
   
   static void info_jdisp(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
           UINT    bpp;
   
           bpp = scrnmng_getbpp();
           milstr_ncpy(str, milstr_list(str_jwinclr, ((bpp >> 3) - 1) & 3), maxlen);
           milstr_ncat(str, milstr_list(str_jwinmode, (scrnmng_isfullscreen())?1:0),
                                                                                                                                           maxlen);
           (void)ex;
   }
   
   static void info_jbios(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
           str[0] = '\0';
           if (pccore.rom & PCROM_BIOS) {
                   milstr_ncat(str, str_biosrom, maxlen);
           }
           if (soundrom.name[0]) {
                   if (str[0]) {
                           milstr_ncat(str, OEMTEXT("と"), maxlen);
                   }
                   milstr_ncat(str, soundrom.name, maxlen);
           }
           if (str[0] == '\0') {
                   milstr_ncat(str, OEMTEXT("なし"), maxlen);
           }
   }
   
   static void info_jrhythm(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
   const OEMCHAR   *p;
           OEMCHAR         jrhythmstr[16];
           UINT            exist;
           UINT            i;
   
           if (!(usesound & 0x6c)) {
                   p = OEMTEXT("不要やで");
           }
           else {
                   exist = rhythm_getcaps();
                   if (exist == 0) {
                           p = OEMTEXT("用意されてないんか…");
                   }
                   else if (exist == 0x3f) {
                           p = OEMTEXT("全部あるで");
                   }
                   else {
                           milstr_ncpy(jrhythmstr, OEMTEXT("BSCHTRや"), NELEMENTS(jrhythmstr));
                           for (i=0; i<6; i++) {
                                   if (!(exist & (1 << i))) {
                                           jrhythmstr[i] = '_';
                                   }
                           }
                           p = jrhythmstr;
                   }
           }
           milstr_ncpy(str, p, maxlen);
   }
   
   typedef struct {
           OEMCHAR key[8];
           void    (*proc)(OEMCHAR *str, int maxlen, const NP2INFOEX *ex);
   } INFOPROC;
   
   static const INFOPROC infoproc[] = {
                           {OEMTEXT("PROG"),               info_progtitle},
                           {OEMTEXT("JSND"),               info_jsound},
                           {OEMTEXT("JBIOS"),              info_jbios},
                           {OEMTEXT("JDISP"),              info_jdisp},
                           {OEMTEXT("JRHYTHM"),    info_jrhythm}};
   
 static const BYTE prs2[] = {0xaa,0xac,0xae,0xb0,0xb2,0xbe,0xf0,0x9f,  static BOOL sstpext(OEMCHAR *dst, const OEMCHAR *key, int maxlen,
                                                         0xa1,0xa3,0xa5,0xa7,0xe1,0xe3,0xe5,0xc1,                                                                                                                  const NP2INFOEX *ex) {
                                                         0xb8,0xa0,0xa2,0xa4,0xa6,0xa8,0xa9,0xab,  
                                                         0xad,0xaf,0xb1,0xb3,0xb5,0xb7,0xb9,0xbb,  
                                                         0xbd,0xbf,0xc2,0xc4,0xc6,0xc8,0xc9,0xca,  
                                                         0xcb,0xcc,0xcd,0xd0,0xd3,0xd6,0xd9,0xdc,  
                                                         0xdd,0xde,0xdf,0xe0,0xe2,0xe4,0xe6,0xe7,  
                                                         0xe8,0xe9,0xea,0xeb,0xed,0xf1,0xb4,0xb8};  
   
   const INFOPROC  *inf;
   const INFOPROC  *infterm;
   
           inf = infoproc;
           infterm = infoproc + NELEMENTS(infoproc);
           while(inf < infterm) {
                   if (!milstr_cmp(key, inf->key)) {
                           inf->proc(dst, maxlen, ex);
                           return(TRUE);
                   }
                   inf++;
           }
           return(FALSE);
   }
   
   static const NP2INFOEX sstpex = {OEMTEXT("\\n"), sstpext};
   
   
   // ----
   
   static const UINT8 prs2[] = {0xaa,0xac,0xae,0xb0,0xb2,0xbe,0xf0,0x9f,
                                                            0xa1,0xa3,0xa5,0xa7,0xe1,0xe3,0xe5,0xc1,
                                                            0xb8,0xa0,0xa2,0xa4,0xa6,0xa8,0xa9,0xab,
                                                            0xad,0xaf,0xb1,0xb3,0xb5,0xb7,0xb9,0xbb,
                                                            0xbd,0xbf,0xc2,0xc4,0xc6,0xc8,0xc9,0xca,
                                                            0xcb,0xcc,0xcd,0xd0,0xd3,0xd6,0xd9,0xdc,
                                                            0xdd,0xde,0xdf,0xe0,0xe2,0xe4,0xe6,0xe7,
                                                            0xe8,0xe9,0xea,0xeb,0xed,0xf1,0xb4,0xb8};
   
 #define GETSSTPDAT1(a) {                                                                \  #define GETSSTPDAT1(a) {                                                                \
                                 (a) = last;                                                             \                                  (a) = last;                                                             \
Line 29  static const BYTE prs2[] = {0xaa,0xac,0x Line 188  static const BYTE prs2[] = {0xaa,0xac,0x
   
 static char *sstpsolve(char *buf, const unsigned char *dat) {  static char *sstpsolve(char *buf, const unsigned char *dat) {
   
         BYTE    c;          UINT8   c;
         BYTE    last;          UINT8   last;
   
         last = 0x80;          last = 0x80;
         while(1) {          while(1) {
Line 58  static char *sstpsolve(char *buf, const  Line 217  static char *sstpsolve(char *buf, const 
                         *buf++ = c;                          *buf++ = c;
                 }                  }
                 else if (c == 0x7f) {                  else if (c == 0x7f) {
                         BYTE ms;                          UINT8 ms;
                         GETSSTPDAT1(ms);                          GETSSTPDAT1(ms);
                         if (!ms) {                          if (!ms) {
                                 break;                                  break;
Line 69  static char *sstpsolve(char *buf, const  Line 228  static char *sstpsolve(char *buf, const 
                                 ms -= 10;                                  ms -= 10;
                         }                          }
                         if (ms) {                          if (ms) {
                                 wsprintf(buf, "\\w%u", ms);                                  SPRINTF(buf, "\\w%1u", ms);
                                 buf += 3;                                  buf += 3;
                         }                          }
                 }                  }
                 else if (c == 0x80) {                  else if (c == 0x80) {
                         BYTE c2;                          UINT8 c2;
                         GETSSTPDAT1(c2);                          GETSSTPDAT1(c2);
                         if (c2) {                          if (c2) {
                                 *buf++ = c2;                                  *buf++ = c2;
Line 85  static char *sstpsolve(char *buf, const  Line 244  static char *sstpsolve(char *buf, const 
                 }                  }
                 else if (c >= 0xf0) {                  else if (c >= 0xf0) {
                         int i;                          int i;
                         const BYTE *p;                          const UINT8 *p;
                         i = c - 0xf0;                          i = c - 0xf0;
                         if (c == 0xff) {                          if (c == 0xff) {
                                 BYTE c2;                                  UINT8 c2;
                                 GETSSTPDAT1(c2);                                  GETSSTPDAT1(c2);
                                 if (!c2) {                                  if (!c2) {
                                         break;                                          break;
Line 102  static char *sstpsolve(char *buf, const  Line 261  static char *sstpsolve(char *buf, const 
                         buf = sstpsolve(buf, p);                          buf = sstpsolve(buf, p);
                 }                  }
                 else if ((c >= 0xa0) && (c < 0xe0)) {                  else if ((c >= 0xa0) && (c < 0xe0)) {
                         *buf++ = (BYTE)0x82;                          *buf++ = (UINT8)0x82;
                         *buf++ = prs2[c-0xa0];                          *buf++ = prs2[c-0xa0];
                 }                  }
                 else {                  else {
                         BYTE c2;                          UINT8 c2;
                         GETSSTPDAT1(c2);                          GETSSTPDAT1(c2);
                         if (c2) {                          if (c2) {
                                 *buf++ = c;                                  *buf++ = c;
Line 121  static char *sstpsolve(char *buf, const  Line 280  static char *sstpsolve(char *buf, const 
         return(buf);          return(buf);
 }  }
   
   
 // -------------------------------  // -------------------------------
   
 static int check_keropi(void) {  static int check_keropi(void) {
Line 233  void sstpmsg_reset(void) { Line 393  void sstpmsg_reset(void) {
   
         update = sys_updates;          update = sys_updates;
         if (update & SYS_UPDATECLOCK) {          if (update & SYS_UPDATECLOCK) {
                 strcat(str, "ＣＰＵクロックを !CLOCKに");                  strcat(str, "ＣＰＵクロックを %CLOCK%に");
         }          }
         if (update & SYS_UPDATEMEMORY) {          if (update & SYS_UPDATEMEMORY) {
                 if (str[0]) {                  if (str[0]) {
                         strcat(str, cr);                          strcat(str, cr);
                 }                  }
                 strcat(str, "メモリを !MEM3に");                  strcat(str, "メモリを %MEM3%に");
         }          }
         if (update & SYS_UPDATESBOARD) {          if (update & SYS_UPDATESBOARD) {
                 if (str[0]) {                  if (str[0]) {
                         strcat(str, cr);                          strcat(str, cr);
                 }                  }
                 strcat(str, "音源を !JSNDに");                  strcat(str, "音源を %JSND%に");
         }          }
         if (update & (SYS_UPDATERATE | SYS_UPDATESBUF | SYS_UPDATEMIDI |          if (update & (SYS_UPDATERATE | SYS_UPDATESBUF | SYS_UPDATEMIDI |
                                         SYS_UPDATEHDD | SYS_UPDATESERIAL1)) {                                          SYS_UPDATEHDD | SYS_UPDATESERIAL1)) {
Line 283  void sstpmsg_reset(void) { Line 443  void sstpmsg_reset(void) {
         if (str[0]) {          if (str[0]) {
                 char out[1024];                  char out[1024];
                 strcat(str, "変更しました。");                  strcat(str, "変更しました。");
                 np2info(out, str, sizeof(out));                  np2info(out, str, sizeof(out), &sstpex);
                 sstp_send(out, NULL);                  sstp_send(out, NULL);
         }          }
 }  }
Line 291  void sstpmsg_reset(void) { Line 451  void sstpmsg_reset(void) {
   
 void sstpmsg_about(void) {  void sstpmsg_about(void) {
   
         char    str[2048];          char    str[1024];
         char    out[2048];          char    out[1024];
         char    *p;          char    *p;
         int             nostat = FALSE;          int             nostat = FALSE;
   
Line 321  void sstpmsg_about(void) { Line 481  void sstpmsg_about(void) {
         if (!nostat) {          if (!nostat) {
                 p = sstpsolve(p, s_info);                  p = sstpsolve(p, s_info);
         }          }
         np2info(out, str, sizeof(out));          np2info(out, str, sizeof(out), &sstpex);
         sstp_send(out, NULL);          sstp_send(out, NULL);
 }  }
   
Line 350  void sstpmsg_config(void) { Line 510  void sstpmsg_config(void) {
         sstp_send(str, NULL);          sstp_send(str, NULL);
 }  }
   
 // -----------------------------------------------------------  
   // ----
   
 static char *get_code(char *buf, int *ret) {  static char *get_code(char *buf, int *ret) {
   
         int     stat;          int             stat;
   
         stat = 0;          stat = 0;
         if (!memcmp(buf, "SSTP", 4)) {          if (!memcmp(buf, "SSTP", 4)) {
Line 413  static void e_sstpexit(HWND hWnd, char * Line 574  static void e_sstpexit(HWND hWnd, char *
         }          }
 }  }
   
 static void e_sstpexit2(HWND hWnd, char *buf) {  
   
         char    *p;  
         int             ret;  
   
         p = get_code(buf, &ret);  
         if (ret == 200) {  
                 if (!memcmp(p, "いい", 4)) {  
                         SendMessage(hWnd, WM_NP2CMD, 0, NP2CMD_EXIT2);  
                 }  
         }  
 }  
   
 BOOL sstpconfirm_exit(void) {  BOOL sstpconfirm_exit(void) {
   
         char    str[512];          char    str[512];
   
 #if 1  
         sstpsolve(str, s_exit);          sstpsolve(str, s_exit);
         return(sstp_send(str, e_sstpexit));          return(sstp_send(str, e_sstpexit));
 #else  
         if (rand() & 3) {  
                 sstpsolve(str, s_exit);  
                 return(sstp_send(str, e_sstpexit));  
         }  
         else {  
                 sstpsolve(str, s_exit2);  
                 return(sstp_send(str, e_sstpexit2));  
         }  
 #endif  
 }  }
   
   
Removed from v.1.1  
changed lines
  Added in v.1.8

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