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

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

version 1.8, 2005/03/19 18:54:58 version 1.9, 2005/03/19 20:46:07
Line 10 Line 10
 #include        "sound.h"  #include        "sound.h"
 #include        "fmboard.h"  #include        "fmboard.h"
 #include        "np2info.h"  #include        "np2info.h"
   #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
   #include        "oemtext.h"
   #endif
   
   
 static const OEMCHAR cr[] = OEMTEXT("\\n");  static const OEMCHAR cr[] = OEMTEXT("\\n");
Line 186  static const UINT8 prs2[] = {0xaa,0xac,0 Line 189  static const UINT8 prs2[] = {0xaa,0xac,0
                                 (a) = ((a) << 2) | ((a) >> 6);                  \                                  (a) = ((a) << 2) | ((a) >> 6);                  \
                 }                  }
   
 static char *sstpsolve(char *buf, const unsigned char *dat) {  static OEMCHAR *sstpsolve(OEMCHAR *buf, const UINT8 *dat) {
   
         UINT8   c;          UINT8   c;
         UINT8   last;          UINT8   last;
   #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
           char    sjis[4];
   #endif
   
         last = 0x80;          last = 0x80;
         while(1) {          while(1) {
Line 223  static char *sstpsolve(char *buf, const  Line 229  static char *sstpsolve(char *buf, const 
                                 break;                                  break;
                         }                          }
                         while(ms > 10) {                          while(ms > 10) {
                                 CopyMemory(buf, "\\w9", 3);                                  CopyMemory(buf, OEMTEXT("\\w9"), 3 * sizeof(OEMCHAR));
                                 buf += 3;                                  buf += 3;
                                 ms -= 10;                                  ms -= 10;
                         }                          }
                         if (ms) {                          if (ms) {
                                 SPRINTF(buf, "\\w%1u", ms);                                  OEMSPRINTF(buf, OEMTEXT("\\w%1u"), ms);
                                 buf += 3;                                  buf += 3;
                         }                          }
                 }                  }
Line 236  static char *sstpsolve(char *buf, const  Line 242  static char *sstpsolve(char *buf, const 
                         UINT8 c2;                          UINT8 c2;
                         GETSSTPDAT1(c2);                          GETSSTPDAT1(c2);
                         if (c2) {                          if (c2) {
   #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
                                   sjis[0] = c2;
                                   sjis[1] = '\0';
                                   oemtext_sjistooem(buf, 4, sjis, 1);
                                   buf += OEMSTRLEN(buf);
   #else
                                 *buf++ = c2;                                  *buf++ = c2;
   #endif
                         }                          }
                         else {                          else {
                                 break;                                  break;
Line 261  static char *sstpsolve(char *buf, const  Line 274  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++ = (UINT8)0x82;  #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
                         *buf++ = prs2[c-0xa0];                          sjis[0] = (UINT8)0x82;
                           sjis[1] = prs2[c-0xa0];
                           sjis[2] = '\0';
                           oemtext_sjistooem(buf, 4, sjis, 2);
                           buf += OEMSTRLEN(buf);
   #else
                           buf[0] = (UINT8)0x82;
                           buf[1] = prs2[c-0xa0];
                           buf += 2;
   #endif
                 }                  }
                 else {                  else {
                         UINT8 c2;                          UINT8 c2;
                         GETSSTPDAT1(c2);                          GETSSTPDAT1(c2);
                         if (c2) {                          if (c2) {
                                 *buf++ = c;  #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
                                 *buf++ = c2;                                  sjis[0] = c;
                                   sjis[1] = c2;
                                   sjis[2] = '\0';
                                   oemtext_sjistooem(buf, 4, sjis, 2);
                                   buf += OEMSTRLEN(buf);
   #else
                                   buf[0] = c;
                                   buf[1] = c2;
                                   buf += 2;
   #endif
                         }                          }
                         else {                          else {
                                 break;                                  break;
Line 285  static char *sstpsolve(char *buf, const  Line 316  static char *sstpsolve(char *buf, const 
   
 static int check_keropi(void) {  static int check_keropi(void) {
   
         char    buf[64];          OEMCHAR buf[64];
   
         sstpsolve(buf, k_keropi);          sstpsolve(buf, k_keropi);
         if (FindWindow(buf, NULL)) {          if (FindWindow(buf, NULL)) {
Line 312  static int check_keropi(void) { Line 343  static int check_keropi(void) {
 void sstpmsg_welcome(void) {  void sstpmsg_welcome(void) {
   
         int             kero;          int             kero;
         char    *p;          OEMCHAR *p;
         char    buf[512];          OEMCHAR buf[512];
   
         p = buf;          p = buf;
   
         kero = check_keropi();          kero = check_keropi();
         if (!kero) {          if (!kero) {
                 switch(rand() & 15) {                  switch(rand() & 15) {
Line 367  void sstpmsg_welcome(void) { Line 397  void sstpmsg_welcome(void) {
                                                 break;                                                  break;
                                 }                                  }
                                 break;                                  break;
   
                         case 2:                          case 2:
                                 p = sstpsolve(p, s_winx68k);                                  p = sstpsolve(p, s_winx68k);
                                 break;                                  break;
   
                         case 3:                          case 3:
                                 p = sstpsolve(p, s_t98next);                                  p = sstpsolve(p, s_t98next);
                                 break;                                  break;
   
                         case 4:                          case 4:
                                 p = sstpsolve(p, s_anex86);                                  p = sstpsolve(p, s_anex86);
                                 break;                                  break;
   
                         default:                          default:
                                 p = sstpsolve(p, s_error);                                  p = sstpsolve(p, s_error);
                                 break;                                  break;
Line 386  void sstpmsg_welcome(void) { Line 420  void sstpmsg_welcome(void) {
   
 void sstpmsg_reset(void) {  void sstpmsg_reset(void) {
   
         char    str[1024];          OEMCHAR str[1024];
         UINT    update;          UINT    update;
   
         str[0] = '\0';          str[0] = '\0';
   
         update = sys_updates;          update = sys_updates;
         if (update & SYS_UPDATECLOCK) {          if (update & SYS_UPDATECLOCK) {
                 strcat(str, "ＣＰＵクロックを %CLOCK%に");                  milstr_ncat(str, OEMTEXT("ＣＰＵクロックを %CLOCK%に"), NELEMENTS(str));
         }          }
         if (update & SYS_UPDATEMEMORY) {          if (update & SYS_UPDATEMEMORY) {
                 if (str[0]) {                  if (str[0]) {
                         strcat(str, cr);                          milstr_ncat(str, cr, NELEMENTS(str));
                 }                  }
                 strcat(str, "メモリを %MEM3%に");                  milstr_ncat(str, OEMTEXT("メモリを %MEM3%に"), NELEMENTS(str));
         }          }
         if (update & SYS_UPDATESBOARD) {          if (update & SYS_UPDATESBOARD) {
                 if (str[0]) {                  if (str[0]) {
                         strcat(str, cr);                          milstr_ncat(str, cr, NELEMENTS(str));
                 }                  }
                 strcat(str, "音源を %JSND%に");                  milstr_ncat(str, OEMTEXT("音源を %JSND%に"), NELEMENTS(str));
         }          }
         if (update & (SYS_UPDATERATE | SYS_UPDATESBUF | SYS_UPDATEMIDI |          if (update & (SYS_UPDATERATE | SYS_UPDATESBUF | SYS_UPDATEMIDI |
                                         SYS_UPDATEHDD | SYS_UPDATESERIAL1)) {                                          SYS_UPDATEHDD | SYS_UPDATESERIAL1)) {
                 BOOL hit = FALSE;                  BOOL hit = FALSE;
                 if (str[0]) {                  if (str[0]) {
                         strcat(str, "\\nあと…\\w5");                          milstr_ncat(str, OEMTEXT("\\nあと…\\w5"), NELEMENTS(str));
                 }                  }
                 if (update & SYS_UPDATEMIDI) {                  if (update & SYS_UPDATEMIDI) {
                         hit = TRUE;                          hit = TRUE;
                         strcat(str, "MIDI");                          milstr_ncat(str, OEMTEXT("MIDI"), NELEMENTS(str));
                 }                  }
                 if (update & (SYS_UPDATERATE | SYS_UPDATESBUF)) {                  if (update & (SYS_UPDATERATE | SYS_UPDATESBUF)) {
                         if (hit) {                          if (hit) {
                                 strcat(str, " ");                                  milstr_ncat(str, str_space, NELEMENTS(str));
                         }                          }
                         hit = TRUE;                          hit = TRUE;
                         strcat(str, "サウンド設定");                          milstr_ncat(str, OEMTEXT("サウンド設定"), NELEMENTS(str));
                 }                  }
                 if (update & SYS_UPDATEHDD) {                  if (update & SYS_UPDATEHDD) {
                         if (hit) {                          if (hit) {
                                 strcat(str, " ");                                  milstr_ncat(str, str_space, NELEMENTS(str));
                         }                          }
                         hit = TRUE;                          hit = TRUE;
                         strcat(str, "ハードディスク");                          milstr_ncat(str, OEMTEXT("ハードディスク"), NELEMENTS(str));
                 }                  }
                 if (update & SYS_UPDATESERIAL1) {                  if (update & SYS_UPDATESERIAL1) {
                         if (hit) {                          if (hit) {
                                 strcat(str, " ");                                  milstr_ncat(str, str_space, NELEMENTS(str));
                         }                          }
                         hit = TRUE;                          hit = TRUE;
                         strcat(str, "シリアル");                          milstr_ncat(str, OEMTEXT("シリアル"), NELEMENTS(str));
                 }                  }
                 strcat(str, "の設定を");                  milstr_ncat(str, OEMTEXT("の設定を"), NELEMENTS(str));
         }          }
         if (str[0]) {          if (str[0]) {
                 char out[1024];                  OEMCHAR out[1024];
                 strcat(str, "変更しました。");                  milstr_ncat(str, OEMTEXT("変更しました。"), NELEMENTS(str));
                 np2info(out, str, sizeof(out), &sstpex);                  np2info(out, str, NELEMENTS(out), &sstpex);
                 sstp_send(out, NULL);                  sstp_send(out, NULL);
         }          }
 }  }
   
   
 void sstpmsg_about(void) {  void sstpmsg_about(void) {
   
         char    str[1024];          OEMCHAR str[1024];
         char    out[1024];          OEMCHAR out[1024];
         char    *p;          OEMCHAR *p;
         int             nostat = FALSE;          int             nostat = FALSE;
   
         p = str;          p = str;
Line 469  void sstpmsg_about(void) { Line 501  void sstpmsg_about(void) {
                 case 5:                  case 5:
                         p = sstpsolve(p, s_ver1);                          p = sstpsolve(p, s_ver1);
                         break;                          break;
   
                 case 6:                  case 6:
                         p = sstpsolve(p, s_ver2);                          p = sstpsolve(p, s_ver2);
                         break;                          break;
Line 481  void sstpmsg_about(void) { Line 514  void sstpmsg_about(void) {
         if (!nostat) {          if (!nostat) {
                 p = sstpsolve(p, s_info);                  p = sstpsolve(p, s_info);
         }          }
         np2info(out, str, sizeof(out), &sstpex);          np2info(out, str, NELEMENTS(out), &sstpex);
         sstp_send(out, NULL);          sstp_send(out, NULL);
 }  }
   
   
 void sstpmsg_config(void) {  void sstpmsg_config(void) {
   
         char    str[1024];          OEMCHAR str[1024];
         char    *p;          OEMCHAR *p;
   
         p = sstpsolve(str, s_config0);          p = sstpsolve(str, s_config0);
         switch(rand() & 7) {          switch(rand() & 7) {
                 case 0:                  case 0:
                         p = sstpsolve(p, s_config1);                          p = sstpsolve(p, s_config1);
                         break;                          break;
   
                 case 1:                  case 1:
                         p = sstpsolve(p, s_config2);                          p = sstpsolve(p, s_config2);
                         break;                          break;
   
                 case 2:                  case 2:
                 case 3:                  case 3:
                         p = sstpsolve(p, s_config3);                          p = sstpsolve(p, s_config3);
                         break;                          break;
   
                 default:                  default:
                         p = sstpsolve(p, s_config4);                          p = sstpsolve(p, s_config4);
                         break;                          break;
Line 555  static void e_sstpreset(HWND hWnd, char  Line 591  static void e_sstpreset(HWND hWnd, char 
   
 BOOL sstpconfirm_reset(void) {  BOOL sstpconfirm_reset(void) {
   
         char    str[256];          OEMCHAR str[256];
   
         sstpsolve(str, s_reset);          sstpsolve(str, s_reset);
         return(sstp_send(str, e_sstpreset));          return(sstp_send(str, e_sstpreset));
Line 576  static void e_sstpexit(HWND hWnd, char * Line 612  static void e_sstpexit(HWND hWnd, char *
   
 BOOL sstpconfirm_exit(void) {  BOOL sstpconfirm_exit(void) {
   
         char    str[512];          OEMCHAR str[512];
   
         sstpsolve(str, s_exit);          sstpsolve(str, s_exit);
         return(sstp_send(str, e_sstpexit));          return(sstp_send(str, e_sstpexit));
Line 587  BOOL sstpconfirm_exit(void) { Line 623  BOOL sstpconfirm_exit(void) {
   
 BOOL sstpmsg_running(void) {  BOOL sstpmsg_running(void) {
   
         char    buf[256];          OEMCHAR buf[256];
         char    *p;          OEMCHAR *p;
   
         p = buf;          p = buf;
         switch(rand() & 7) {          switch(rand() & 7) {
                 case 0:                  case 0:
                         p = sstpsolve(p, s_running1);                          p = sstpsolve(p, s_running1);
                         break;                          break;
   
                 case 1:                  case 1:
                         p = sstpsolve(p, s_running2);                          p = sstpsolve(p, s_running2);
                         break;                          break;
   
                 case 2:                  case 2:
                         p = sstpsolve(p, s_running3);                          p = sstpsolve(p, s_running3);
                         break;                          break;
   
                 default:                  default:
                         p = sstpsolve(p, s_running4);                          p = sstpsolve(p, s_running4);
                         break;                          break;
Line 611  BOOL sstpmsg_running(void) { Line 650  BOOL sstpmsg_running(void) {
   
 BOOL sstpmsg_dxerror(void) {  BOOL sstpmsg_dxerror(void) {
   
         char    buf[256];          OEMCHAR buf[256];
   
         sstpsolve(buf, s_dxerror);          sstpsolve(buf, s_dxerror);
         return(sstp_sendonly(buf));          return(sstp_sendonly(buf));
Removed from v.1.8  
changed lines
  Added in v.1.9

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