[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.11

version 1.8, 2005/03/19 18:54:58 version 1.11, 2007/12/28 20:36:40
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "strres.h"  #include        "strres.h"
 #include        "np2.h"  #include        "np2.h"
   #include        "oemtext.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "sstp.h"  #include        "sstp.h"
Line 186  static const UINT8 prs2[] = {0xaa,0xac,0 Line 187  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 227  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 240  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';
                                   buf += oemtext_sjistooem(buf, 4, sjis, 1);
   #else
                                 *buf++ = c2;                                  *buf++ = c2;
   #endif
                         }                          }
                         else {                          else {
                                 break;                                  break;
Line 261  static char *sstpsolve(char *buf, const  Line 271  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';
                           buf += oemtext_sjistooem(buf, 4, sjis, 2);
   #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';
                                   buf += oemtext_sjistooem(buf, 4, sjis, 2);
   #else
                                   buf[0] = c;
                                   buf[1] = c2;
                                   buf += 2;
   #endif
                         }                          }
                         else {                          else {
                                 break;                                  break;
Line 283  static char *sstpsolve(char *buf, const  Line 309  static char *sstpsolve(char *buf, const 
   
 // -------------------------------  // -------------------------------
   
   static const UINT8 *prcs[4] = {k_keropi, k_winx68k, k_t98next, k_anex86};
   
 static int check_keropi(void) {  static int check_keropi(void) {
   
         char    buf[64];          UINT    i;
   
         sstpsolve(buf, k_keropi);          for (i=0; i<NELEMENTS(prcs); i++) {
         if (FindWindow(buf, NULL)) {                  OEMCHAR buf[64];
                 return(1);                  sstpsolve(buf, prcs[i]);
         }  #if defined(OSLANG_UTF8)
         sstpsolve(buf, k_winx68k);                  TCHAR tchr[64];
         if (FindWindow(buf, NULL)) {                  oemtotchar(tchr, NELEMENTS(tchr), buf, -1);
                 return(2);  #else
         }                  const TCHAR *tchr = buf;
         sstpsolve(buf, k_t98next);  #endif
         if (FindWindow(NULL, buf)) {                  if (FindWindow(tchr, NULL)) {
                 return(3);                          return(i + 1);
         }                  }
         sstpsolve(buf, k_anex86);  
         if (FindWindow(NULL, buf)) {  
                 return(4);  
         }          }
         return(0);          return(0);
 }  }
Line 311  static int check_keropi(void) { Line 336  static int check_keropi(void) {
   
 void sstpmsg_welcome(void) {  void sstpmsg_welcome(void) {
   
         int             kero;          UINT    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 359  void sstpmsg_welcome(void) { Line 383  void sstpmsg_welcome(void) {
                                         case 0:                                          case 0:
                                                 p = sstpsolve(p, s_keropi1);                                                  p = sstpsolve(p, s_keropi1);
                                                 break;                                                  break;
   
                                         case 1:                                          case 1:
                                                 p = sstpsolve(p, s_keropi2);                                                  p = sstpsolve(p, s_keropi2);
                                                 break;                                                  break;
   
                                         default:                                          default:
                                                 p = sstpsolve(p, s_keropi3);                                                  p = sstpsolve(p, s_keropi3);
                                                 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 416  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 497  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 510  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 587  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 608  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 619  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 646  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.11

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