Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttpcmn/ttcmn.c

Diff of /trunk/teraterm/ttpcmn/ttcmn.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3221 by maya, Tue Mar 24 09:37:20 2009 UTC revision 3227 by maya, Tue Mar 24 15:10:33 2009 UTC
# Line 1  Line 1 
1  /* Tera Term  /* Tera Term
2   Copyright(C) 1994-1998 T. Teranishi   Copyright(C) 1994-1998 T. Teranishi
3   All rights reserved. */   All rights reserved. */
4    
5  /* TTCMN.DLL, main */  /* TTCMN.DLL, main */
6  #include "teraterm.h"  #include "teraterm.h"
7  #include "tttypes.h"  #include "tttypes.h"
8  #include <direct.h>  #include <direct.h>
9  #include <string.h>  #include <string.h>
10  #include "ttftypes.h"  #include "ttftypes.h"
11  #include "ttlib.h"  #include "ttlib.h"
12  #include "language.h"  #include "language.h"
13  #include <stdio.h>  #include <stdio.h>
14  #include <windows.h>  #include <windows.h>
15  #include <tchar.h>  #include <tchar.h>
16  #include <setupapi.h>  #include <setupapi.h>
17    
18  #include "compat_w95.h"  #include "compat_w95.h"
19    
20  /* first instance flag */  /* first instance flag */
21  static BOOL FirstInstance = TRUE;  static BOOL FirstInstance = TRUE;
22    
23  static HINSTANCE hInst;  static HINSTANCE hInst;
24    
25  static PMap pm;  static PMap pm;
26    
27  static HANDLE HMap = NULL;  static HANDLE HMap = NULL;
28  #define VTCLASSNAME "VTWin32"  #define VTCLASSNAME "VTWin32"
29  #define TEKCLASSNAME "TEKWin32"  #define TEKCLASSNAME "TEKWin32"
30    
31    
32  void PASCAL CopyShmemToTTSet(PTTSet ts)  void PASCAL CopyShmemToTTSet(PTTSet ts)
33  {  {
34          // 現在の設定を共有メモリからコピーする          // 現在の設定を共有メモリからコピーする
35          memcpy(ts, &pm->ts, sizeof(TTTSet));          memcpy(ts, &pm->ts, sizeof(TTTSet));
36  }  }
37    
38  void PASCAL CopyTTSetToShmem(PTTSet ts)  void PASCAL CopyTTSetToShmem(PTTSet ts)
39  {  {
40          // 現在の設定を共有メモリへコピーする          // 現在の設定を共有メモリへコピーする
41          memcpy(&pm->ts, ts, sizeof(TTTSet));          memcpy(&pm->ts, ts, sizeof(TTTSet));
42  }  }
43    
44    
45  BOOL PASCAL FAR StartTeraTerm(PTTSet ts)  BOOL PASCAL FAR StartTeraTerm(PTTSet ts)
46  {  {
47          char Temp[MAXPATHLEN];          char Temp[MAXPATHLEN];
48    
49          if (FirstInstance) {          if (FirstInstance) {
50                  // init window list                  // init window list
51                  pm->NWin = 0;                  pm->NWin = 0;
52          }          }
53          else {          else {
54                  /* only the first instance uses saved position */                  /* only the first instance uses saved position */
55                  pm->ts.VTPos.x = CW_USEDEFAULT;                  pm->ts.VTPos.x = CW_USEDEFAULT;
56                  pm->ts.VTPos.y = CW_USEDEFAULT;                  pm->ts.VTPos.y = CW_USEDEFAULT;
57                  pm->ts.TEKPos.x = CW_USEDEFAULT;                  pm->ts.TEKPos.x = CW_USEDEFAULT;
58                  pm->ts.TEKPos.y = CW_USEDEFAULT;                  pm->ts.TEKPos.y = CW_USEDEFAULT;
59          }          }
60    
61          memcpy(ts,&(pm->ts),sizeof(TTTSet));          memcpy(ts,&(pm->ts),sizeof(TTTSet));
62    
63          // if (FirstInstance) { の部分から移動 (2008.3.13 maya)          // if (FirstInstance) { の部分から移動 (2008.3.13 maya)
64          // 起動時には、共有メモリの HomeDir と SetupFName は空になる          // 起動時には、共有メモリの HomeDir と SetupFName は空になる
65          /* Get home directory */          /* Get home directory */
66          GetModuleFileName(hInst,Temp,sizeof(Temp));          GetModuleFileName(hInst,Temp,sizeof(Temp));
67          ExtractDirName(Temp, ts->HomeDir);          ExtractDirName(Temp, ts->HomeDir);
68          _chdir(ts->HomeDir);          _chdir(ts->HomeDir);
69          GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));          GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));
70    
71          if (FirstInstance) {          if (FirstInstance) {
72                  FirstInstance = FALSE;                  FirstInstance = FALSE;
73                  return TRUE;                  return TRUE;
74          }          }
75          else          else
76                  return FALSE;                  return FALSE;
77  }  }
78    
79  void PASCAL FAR ChangeDefaultSet(PTTSet ts, PKeyMap km)  void PASCAL FAR ChangeDefaultSet(PTTSet ts, PKeyMap km)
80  {  {
81          if ((ts!=NULL) &&          if ((ts!=NULL) &&
82              (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0))              (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0))
83                  memcpy(&(pm->ts),ts,sizeof(TTTSet));                  memcpy(&(pm->ts),ts,sizeof(TTTSet));
84          if (km!=NULL)          if (km!=NULL)
85                  memcpy(&(pm->km),km,sizeof(TKeyMap));                  memcpy(&(pm->km),km,sizeof(TKeyMap));
86  }  }
87    
88  void PASCAL FAR GetDefaultSet(PTTSet ts)  void PASCAL FAR GetDefaultSet(PTTSet ts)
89  {  {
90          memcpy(ts,&(pm->ts),sizeof(TTTSet));          memcpy(ts,&(pm->ts),sizeof(TTTSet));
91  }  }
92    
93    
94  /* Key scan code -> Tera Term key code */  /* Key scan code -> Tera Term key code */
95  WORD PASCAL FAR GetKeyCode(PKeyMap KeyMap, WORD Scan)  WORD PASCAL FAR GetKeyCode(PKeyMap KeyMap, WORD Scan)
96  {  {
97          WORD Key;          WORD Key;
98    
99          if (KeyMap==NULL)          if (KeyMap==NULL)
100                  KeyMap = &(pm->km);                  KeyMap = &(pm->km);
101          Key = IdKeyMax;          Key = IdKeyMax;
102          while ((Key>0) && (KeyMap->Map[Key-1] != Scan))          while ((Key>0) && (KeyMap->Map[Key-1] != Scan))
103                  Key--;                  Key--;
104          return Key;          return Key;
105  }  }
106    
107  void PASCAL FAR GetKeyStr(HWND HWin, PKeyMap KeyMap, WORD KeyCode,  void PASCAL FAR GetKeyStr(HWND HWin, PKeyMap KeyMap, WORD KeyCode,
108                            BOOL AppliKeyMode, BOOL AppliCursorMode,                            BOOL AppliKeyMode, BOOL AppliCursorMode,
109                            BOOL Send8BitMode, PCHAR KeyStr, int destlen,                            BOOL Send8BitMode, PCHAR KeyStr, int destlen,
110                            LPINT Len, LPWORD Type)                            LPINT Len, LPWORD Type)
111  {  {
112          MSG Msg;          MSG Msg;
113          char Temp[201];          char Temp[201];
114    
115          if (KeyMap==NULL)          if (KeyMap==NULL)
116                  KeyMap = &(pm->km);                  KeyMap = &(pm->km);
117    
118          *Type = IdBinary;  // key type          *Type = IdBinary;  // key type
119          *Len = 0;          *Len = 0;
120          switch (KeyCode) {          switch (KeyCode) {
121                  case IdUp:                  case IdUp:
122                          if (Send8BitMode) {                          if (Send8BitMode) {
123                                  *Len = 2;                                  *Len = 2;
124                                  if (AppliCursorMode)                                  if (AppliCursorMode)
125                                          strncpy_s(KeyStr,destlen,"\217A",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217A",_TRUNCATE);
126                                  else                                  else
127                                          strncpy_s(KeyStr,destlen,"\233A",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\233A",_TRUNCATE);
128                          } else {                          } else {
129                                  *Len = 3;                                  *Len = 3;
130                                  if (AppliCursorMode)                                  if (AppliCursorMode)
131                                          strncpy_s(KeyStr,destlen,"\033OA",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033OA",_TRUNCATE);
132                                  else                                  else
133                                          strncpy_s(KeyStr,destlen,"\033[A",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033[A",_TRUNCATE);
134                          }                          }
135                          break;                          break;
136                  case IdDown:                  case IdDown:
137                          if (Send8BitMode) {                          if (Send8BitMode) {
138                                  *Len = 2;                                  *Len = 2;
139                                  if (AppliCursorMode)                                  if (AppliCursorMode)
140                                          strncpy_s(KeyStr,destlen,"\217B",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217B",_TRUNCATE);
141                                  else                                  else
142                                          strncpy_s(KeyStr,destlen,"\233B",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\233B",_TRUNCATE);
143                          } else {                          } else {
144                                  *Len = 3;                                  *Len = 3;
145                                  if (AppliCursorMode)                                  if (AppliCursorMode)
146                                          strncpy_s(KeyStr,destlen,"\033OB",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033OB",_TRUNCATE);
147                                  else                                  else
148                                          strncpy_s(KeyStr,destlen,"\033[B",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033[B",_TRUNCATE);
149                          }                          }
150                          break;                          break;
151                  case IdRight:                  case IdRight:
152                          if (Send8BitMode) {                          if (Send8BitMode) {
153                                  *Len = 2;                                  *Len = 2;
154                                  if (AppliCursorMode)                                  if (AppliCursorMode)
155                                          strncpy_s(KeyStr,destlen,"\217C",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217C",_TRUNCATE);
156                                  else                                  else
157                                          strncpy_s(KeyStr,destlen,"\233C",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\233C",_TRUNCATE);
158                          } else {                          } else {
159                                  *Len = 3;                                  *Len = 3;
160                                  if (AppliCursorMode)                                  if (AppliCursorMode)
161                                          strncpy_s(KeyStr,destlen,"\033OC",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033OC",_TRUNCATE);
162                                  else                                  else
163                                          strncpy_s(KeyStr,destlen,"\033[C",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033[C",_TRUNCATE);
164                          }                          }
165                          break;                          break;
166                  case IdLeft:                  case IdLeft:
167                          if (Send8BitMode) {                          if (Send8BitMode) {
168                                  *Len = 2;                                  *Len = 2;
169                                  if (AppliCursorMode)                                  if (AppliCursorMode)
170                                          strncpy_s(KeyStr,destlen,"\217D",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217D",_TRUNCATE);
171                                  else                                  else
172                                          strncpy_s(KeyStr,destlen,"\233D",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\233D",_TRUNCATE);
173                          } else {                          } else {
174                                  *Len = 3;                                  *Len = 3;
175                                  if (AppliCursorMode)                                  if (AppliCursorMode)
176                                          strncpy_s(KeyStr,destlen,"\033OD",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033OD",_TRUNCATE);
177                                  else                                  else
178                                          strncpy_s(KeyStr,destlen,"\033[D",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033[D",_TRUNCATE);
179                          }                          }
180                          break;                          break;
181                  case Id0:                  case Id0:
182                          if (AppliKeyMode) {                          if (AppliKeyMode) {
183                                  if (Send8BitMode) {                                  if (Send8BitMode) {
184                                          *Len = 2;                                          *Len = 2;
185                                          strncpy_s(KeyStr,destlen,"\217p",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217p",_TRUNCATE);
186                                  } else {                                  } else {
187                                          *Len = 3;                                          *Len = 3;
188                                          strncpy_s(KeyStr,destlen,"\033Op",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Op",_TRUNCATE);
189                                  }                                  }
190                          }                          }
191                          else {                          else {
192                                  *Len = 1;                                  *Len = 1;
193                                  KeyStr[0] = '0';                                  KeyStr[0] = '0';
194                          }                          }
195                          break;                          break;
196                  case Id1:                  case Id1:
197                          if (AppliKeyMode) {                          if (AppliKeyMode) {
198                                  if (Send8BitMode) {                                  if (Send8BitMode) {
199                                          *Len = 2;                                          *Len = 2;
200                                          strncpy_s(KeyStr,destlen,"\217q",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217q",_TRUNCATE);
201                                  } else {                                  } else {
202                                          *Len = 3;                                          *Len = 3;
203                                          strncpy_s(KeyStr,destlen,"\033Oq",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Oq",_TRUNCATE);
204                                  }                                  }
205                          }                          }
206                          else {                          else {
207                                  *Len = 1;                                  *Len = 1;
208                                  KeyStr[0] = '1';                                  KeyStr[0] = '1';
209                          }                          }
210                          break;                          break;
211                  case Id2:                  case Id2:
212                          if (AppliKeyMode) {                          if (AppliKeyMode) {
213                                  if (Send8BitMode) {                                  if (Send8BitMode) {
214                                          *Len = 2;                                          *Len = 2;
215                                          strncpy_s(KeyStr,destlen,"\217r",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217r",_TRUNCATE);
216                                  } else {                                  } else {
217                                          *Len = 3;                                          *Len = 3;
218                                          strncpy_s(KeyStr,destlen,"\033Or",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Or",_TRUNCATE);
219                                  }                                  }
220                          }                          }
221                          else {                          else {
222                                  *Len = 1;                                  *Len = 1;
223                                  KeyStr[0] = '2';                                  KeyStr[0] = '2';
224                          }                          }
225                          break;                          break;
226                  case Id3:                  case Id3:
227                          if (AppliKeyMode) {                          if (AppliKeyMode) {
228                                  if (Send8BitMode) {                                  if (Send8BitMode) {
229                                          *Len = 2;                                          *Len = 2;
230                                          strncpy_s(KeyStr,destlen,"\217s",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217s",_TRUNCATE);
231                                  } else {                                  } else {
232                                          *Len = 3;                                          *Len = 3;
233                                          strncpy_s(KeyStr,destlen,"\033Os",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Os",_TRUNCATE);
234                                  }                                  }
235                          }                          }
236                          else {                          else {
237                                  *Len = 1;                                  *Len = 1;
238                                  KeyStr[0] = '3';                                  KeyStr[0] = '3';
239                          }                          }
240                          break;                          break;
241                  case Id4:                  case Id4:
242                          if (AppliKeyMode) {                          if (AppliKeyMode) {
243                                  if (Send8BitMode) {                                  if (Send8BitMode) {
244                                          *Len = 2;                                          *Len = 2;
245                                          strncpy_s(KeyStr,destlen,"\217t",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217t",_TRUNCATE);
246                                  } else {                                  } else {
247                                          *Len = 3;                                          *Len = 3;
248                                          strncpy_s(KeyStr,destlen,"\033Ot",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Ot",_TRUNCATE);
249                                  }                                  }
250                          }                          }
251                          else {                          else {
252                                  *Len = 1;                                  *Len = 1;
253                                  KeyStr[0] = '4';                                  KeyStr[0] = '4';
254                          }                          }
255                          break;                          break;
256                  case Id5:                  case Id5:
257                          if (AppliKeyMode) {                          if (AppliKeyMode) {
258                                  if (Send8BitMode) {                                  if (Send8BitMode) {
259                                          *Len = 2;                                          *Len = 2;
260                                          strncpy_s(KeyStr,destlen,"\217u",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217u",_TRUNCATE);
261                                  } else {                                  } else {
262                                          *Len = 3;                                          *Len = 3;
263                                          strncpy_s(KeyStr,destlen,"\033Ou",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Ou",_TRUNCATE);
264                                  }                                  }
265                          }                          }
266                          else {                          else {
267                                  *Len = 1;                                  *Len = 1;
268                                  KeyStr[0] = '5';                                  KeyStr[0] = '5';
269                          }                          }
270                          break;                          break;
271                  case Id6:                  case Id6:
272                          if (AppliKeyMode) {                          if (AppliKeyMode) {
273                                  if (Send8BitMode) {                                  if (Send8BitMode) {
274                                          *Len = 2;                                          *Len = 2;
275                                          strncpy_s(KeyStr,destlen,"\217v",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217v",_TRUNCATE);
276                                  } else {                                  } else {
277                                          *Len = 3;                                          *Len = 3;
278                                          strncpy_s(KeyStr,destlen,"\033Ov",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Ov",_TRUNCATE);
279                                  }                                  }
280                          }                          }
281                          else {                          else {
282                                  *Len = 1;                                  *Len = 1;
283                                  KeyStr[0] = '6';                                  KeyStr[0] = '6';
284                          }                          }
285                          break;                          break;
286                  case Id7:                  case Id7:
287                          if (AppliKeyMode) {                          if (AppliKeyMode) {
288                                  if (Send8BitMode) {                                  if (Send8BitMode) {
289                                          *Len = 2;                                          *Len = 2;
290                                          strncpy_s(KeyStr,destlen,"\217w",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217w",_TRUNCATE);
291                                  } else {                                  } else {
292                                          *Len = 3;                                          *Len = 3;
293                                          strncpy_s(KeyStr,destlen,"\033Ow",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Ow",_TRUNCATE);
294                                  }                                  }
295                          }                          }
296                          else {                          else {
297                                  *Len = 1;                                  *Len = 1;
298                                  KeyStr[0] = '7';                                  KeyStr[0] = '7';
299                          }                          }
300                          break;                          break;
301                  case Id8:                  case Id8:
302                          if (AppliKeyMode) {                          if (AppliKeyMode) {
303                                  if (Send8BitMode) {                                  if (Send8BitMode) {
304                                          *Len = 2;                                          *Len = 2;
305                                          strncpy_s(KeyStr,destlen,"\217x",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217x",_TRUNCATE);
306                                  } else {                                  } else {
307                                          *Len = 3;                                          *Len = 3;
308                                          strncpy_s(KeyStr,destlen,"\033Ox",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Ox",_TRUNCATE);
309                                  }                                  }
310                          }                          }
311                          else {                          else {
312                                  *Len = 1;                                  *Len = 1;
313                                  KeyStr[0] = '8';                                  KeyStr[0] = '8';
314                          }                          }
315                          break;                          break;
316                  case Id9:                  case Id9:
317                          if (AppliKeyMode) {                          if (AppliKeyMode) {
318                                  if (Send8BitMode) {                                  if (Send8BitMode) {
319                                          *Len = 2;                                          *Len = 2;
320                                          strncpy_s(KeyStr,destlen,"\217y",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217y",_TRUNCATE);
321                                  } else {                                  } else {
322                                          *Len = 3;                                          *Len = 3;
323                                          strncpy_s(KeyStr,destlen,"\033Oy",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Oy",_TRUNCATE);
324                                  }                                  }
325                          }                          }
326                          else {                          else {
327                                  *Len = 1;                                  *Len = 1;
328                                  KeyStr[0] = '9';                                  KeyStr[0] = '9';
329                          }                          }
330                          break;                          break;
331                  case IdMinus: /* numeric pad - key (DEC) */                  case IdMinus: /* numeric pad - key (DEC) */
332                          if (AppliKeyMode) {                          if (AppliKeyMode) {
333                                  if (Send8BitMode) {                                  if (Send8BitMode) {
334                                          *Len = 2;                                          *Len = 2;
335                                          strncpy_s(KeyStr,destlen,"\217m",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217m",_TRUNCATE);
336                                  } else {                                  } else {
337                                          *Len = 3;                                          *Len = 3;
338                                          strncpy_s(KeyStr,destlen,"\033Om",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Om",_TRUNCATE);
339                                  }                                  }
340                          }                          }
341                          else {                          else {
342                                  *Len = 1;                                  *Len = 1;
343                                  KeyStr[0] = '-';                                  KeyStr[0] = '-';
344                          }                          }
345                          break;                          break;
346                  case IdComma: /* numeric pad , key (DEC) */                  case IdComma: /* numeric pad , key (DEC) */
347                          if (AppliKeyMode) {                          if (AppliKeyMode) {
348                                  if (Send8BitMode) {                                  if (Send8BitMode) {
349                                          *Len = 2;                                          *Len = 2;
350                                          strncpy_s(KeyStr,destlen,"\217l",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217l",_TRUNCATE);
351                                  } else {                                  } else {
352                                          *Len = 3;                                          *Len = 3;
353                                          strncpy_s(KeyStr,destlen,"\033Ol",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Ol",_TRUNCATE);
354                                  }                                  }
355                          }                          }
356                          else {                          else {
357                                  *Len = 1;                                  *Len = 1;
358                                  KeyStr[0] = ',';                                  KeyStr[0] = ',';
359                          }                          }
360                          break;                          break;
361                  case IdPeriod: /* numeric pad . key */                  case IdPeriod: /* numeric pad . key */
362                          if (AppliKeyMode) {                          if (AppliKeyMode) {
363                                  if (Send8BitMode) {                                  if (Send8BitMode) {
364                                          *Len = 2;                                          *Len = 2;
365                                          strncpy_s(KeyStr,destlen,"\217n",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217n",_TRUNCATE);
366                                  } else {                                  } else {
367                                          *Len = 3;                                          *Len = 3;
368                                          strncpy_s(KeyStr,destlen,"\033On",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033On",_TRUNCATE);
369                                  }                                  }
370                          }                          }
371                          else {                          else {
372                                  *Len = 1;                                  *Len = 1;
373                                  KeyStr[0] = '.';                                  KeyStr[0] = '.';
374                          }                          }
375                          break;                          break;
376                  case IdEnter: /* numeric pad enter key */                  case IdEnter: /* numeric pad enter key */
377                          if (AppliKeyMode) {                          if (AppliKeyMode) {
378                                  if (Send8BitMode) {                                  if (Send8BitMode) {
379                                          *Len = 2;                                          *Len = 2;
380                                          strncpy_s(KeyStr,destlen,"\217M",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217M",_TRUNCATE);
381                                  } else {                                  } else {
382                                          *Len = 3;                                          *Len = 3;
383                                          strncpy_s(KeyStr,destlen,"\033OM",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033OM",_TRUNCATE);
384                                  }                                  }
385                          }                          }
386                          else {                          else {
387                                  *Len = 1;                                  *Len = 1;
388                                  KeyStr[0] = 0x0D;                                  KeyStr[0] = 0x0D;
389                          }                          }
390                          break;                          break;
391                  case IdSlash: /* numeric pad slash key */                  case IdSlash: /* numeric pad slash key */
392                          if (AppliKeyMode) {                          if (AppliKeyMode) {
393                                  if (Send8BitMode) {                                  if (Send8BitMode) {
394                                          *Len = 2;                                          *Len = 2;
395                                          strncpy_s(KeyStr,destlen,"\217o",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217o",_TRUNCATE);
396                                  } else {                                  } else {
397                                          *Len = 3;                                          *Len = 3;
398                                          strncpy_s(KeyStr,destlen,"\033Oo",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Oo",_TRUNCATE);
399                                  }                                  }
400                          }                          }
401                          else {                          else {
402                                  *Len = 1;                                  *Len = 1;
403                                  KeyStr[0] = '/';                                  KeyStr[0] = '/';
404                          }                          }
405                          break;                          break;
406                  case IdAsterisk: /* numeric pad asterisk key */                  case IdAsterisk: /* numeric pad asterisk key */
407                          if (AppliKeyMode) {                          if (AppliKeyMode) {
408                                  if (Send8BitMode) {                                  if (Send8BitMode) {
409                                          *Len = 2;                                          *Len = 2;
410                                          strncpy_s(KeyStr,destlen,"\217j",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217j",_TRUNCATE);
411                                  } else {                                  } else {
412                                          *Len = 3;                                          *Len = 3;
413                                          strncpy_s(KeyStr,destlen,"\033Oj",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Oj",_TRUNCATE);
414                                  }                                  }
415                          }                          }
416                          else {                          else {
417                                  *Len = 1;                                  *Len = 1;
418                                  KeyStr[0] = '*';                                  KeyStr[0] = '*';
419                          }                          }
420                          break;                          break;
421                  case IdPlus: /* numeric pad plus key */                  case IdPlus: /* numeric pad plus key */
422                          if (AppliKeyMode) {                          if (AppliKeyMode) {
423                                  if (Send8BitMode) {                                  if (Send8BitMode) {
424                                          *Len = 2;                                          *Len = 2;
425                                          strncpy_s(KeyStr,destlen,"\217k",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\217k",_TRUNCATE);
426                                  } else {                                  } else {
427                                          *Len = 3;                                          *Len = 3;
428                                          strncpy_s(KeyStr,destlen,"\033Ok",_TRUNCATE);                                          strncpy_s(KeyStr,destlen,"\033Ok",_TRUNCATE);
429                                  }                                  }
430                          }                          }
431                          else {                          else {
432                                  *Len = 1;                                  *Len = 1;
433                                  KeyStr[0] = '+';                                  KeyStr[0] = '+';
434                          }                          }
435                          break;                          break;
436                  case IdPF1: /* DEC Key: PF1 */                  case IdPF1: /* DEC Key: PF1 */
437                          if (Send8BitMode) {                          if (Send8BitMode) {
438                                  *Len = 2;                                  *Len = 2;
439                                  strncpy_s(KeyStr,destlen,"\217P",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\217P",_TRUNCATE);
440                          } else {                          } else {
441                                  *Len = 3;                                  *Len = 3;
442                                  strncpy_s(KeyStr,destlen,"\033OP",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033OP",_TRUNCATE);
443                          }                          }
444                          break;                          break;
445                  case IdPF2: /* DEC Key: PF2 */                  case IdPF2: /* DEC Key: PF2 */
446                          if (Send8BitMode) {                          if (Send8BitMode) {
447                                  *Len = 2;                                  *Len = 2;
448                                  strncpy_s(KeyStr,destlen,"\217Q",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\217Q",_TRUNCATE);
449                          } else {                          } else {
450                                  *Len = 3;                                  *Len = 3;
451                                  strncpy_s(KeyStr,destlen,"\033OQ",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033OQ",_TRUNCATE);
452                          }                          }
453                          break;                          break;
454                  case IdPF3: /* DEC Key: PF3 */                  case IdPF3: /* DEC Key: PF3 */
455                          if (Send8BitMode) {                          if (Send8BitMode) {
456                                  *Len = 2;                                  *Len = 2;
457                                  strncpy_s(KeyStr,destlen,"\217R",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\217R",_TRUNCATE);
458                          } else {                          } else {
459                                  *Len = 3;                                  *Len = 3;
460                                  strncpy_s(KeyStr,destlen,"\033OR",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033OR",_TRUNCATE);
461                          }                          }
462                          break;                          break;
463                  case IdPF4: /* DEC Key: PF4 */                  case IdPF4: /* DEC Key: PF4 */
464                          if (Send8BitMode) {                          if (Send8BitMode) {
465                                  *Len = 2;                                  *Len = 2;
466                                  strncpy_s(KeyStr,destlen,"\217S",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\217S",_TRUNCATE);
467                          } else {                          } else {
468                                  *Len = 3;                                  *Len = 3;
469                                  strncpy_s(KeyStr,destlen,"\033OS",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033OS",_TRUNCATE);
470                          }                          }
471                          break;                          break;
472                  case IdFind: /* DEC Key: Find */                  case IdFind: /* DEC Key: Find */
473                          if (Send8BitMode) {                          if (Send8BitMode) {
474                                  *Len = 3;                                  *Len = 3;
475                                  strncpy_s(KeyStr,destlen,"\2331~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\2331~",_TRUNCATE);
476                          } else {                          } else {
477                                  *Len = 4;                                  *Len = 4;
478                                  strncpy_s(KeyStr,destlen,"\033[1~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[1~",_TRUNCATE);
479                          }                          }
480                          break;                          break;
481                  case IdInsert: /* DEC Key: Insert Here */                  case IdInsert: /* DEC Key: Insert Here */
482                          if (Send8BitMode) {                          if (Send8BitMode) {
483                                  *Len = 3;                                  *Len = 3;
484                                  strncpy_s(KeyStr,destlen,"\2332~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\2332~",_TRUNCATE);
485                          } else {                          } else {
486                                  *Len = 4;                                  *Len = 4;
487                                  strncpy_s(KeyStr,destlen,"\033[2~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[2~",_TRUNCATE);
488                          }                          }
489                          break;                          break;
490                  case IdRemove: /* DEC Key: Remove */                  case IdRemove: /* DEC Key: Remove */
491                          if (Send8BitMode) {                          if (Send8BitMode) {
492                                  *Len = 3;                                  *Len = 3;
493                                  strncpy_s(KeyStr,destlen,"\2333~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\2333~",_TRUNCATE);
494                          } else {                          } else {
495                                  *Len = 4;                                  *Len = 4;
496                                  strncpy_s(KeyStr,destlen,"\033[3~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[3~",_TRUNCATE);
497                          }                          }
498                          break;                          break;
499                  case IdSelect: /* DEC Key: Select */                  case IdSelect: /* DEC Key: Select */
500                          if (Send8BitMode) {                          if (Send8BitMode) {
501                                  *Len = 3;                                  *Len = 3;
502                                  strncpy_s(KeyStr,destlen,"\2334~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\2334~",_TRUNCATE);
503                          } else {                          } else {
504                                  *Len = 4;                                  *Len = 4;
505                                  strncpy_s(KeyStr,destlen,"\033[4~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[4~",_TRUNCATE);
506                          }                          }
507                          break;                          break;
508                  case IdPrev: /* DEC Key: Prev */                  case IdPrev: /* DEC Key: Prev */
509                          if (Send8BitMode) {                          if (Send8BitMode) {
510                                  *Len = 3;                                  *Len = 3;
511                                  strncpy_s(KeyStr,destlen,"\2335~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\2335~",_TRUNCATE);
512                          } else {                          } else {
513                                  *Len = 4;                                  *Len = 4;
514                                  strncpy_s(KeyStr,destlen,"\033[5~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[5~",_TRUNCATE);
515                          }                          }
516                          break;                          break;
517                  case IdNext: /* DEC Key: Next */                  case IdNext: /* DEC Key: Next */
518                          if (Send8BitMode) {                          if (Send8BitMode) {
519                                  *Len = 3;                                  *Len = 3;
520                                  strncpy_s(KeyStr,destlen,"\2336~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\2336~",_TRUNCATE);
521                          } else {                          } else {
522                                  *Len = 4;                                  *Len = 4;
523                                  strncpy_s(KeyStr,destlen,"\033[6~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[6~",_TRUNCATE);
524                          }                          }
525                          break;                          break;
526                  case IdF6: /* DEC Key: F6 */                  case IdF6: /* DEC Key: F6 */
527                          if (Send8BitMode) {                          if (Send8BitMode) {
528                                  *Len = 4;                                  *Len = 4;
529                                  strncpy_s(KeyStr,destlen,"\23317~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23317~",_TRUNCATE);
530                          } else {                          } else {
531                                  *Len = 5;                                  *Len = 5;
532                                  strncpy_s(KeyStr,destlen,"\033[17~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[17~",_TRUNCATE);
533                          }                          }
534                          break;                          break;
535                  case IdF7: /* DEC Key: F7 */                  case IdF7: /* DEC Key: F7 */
536                          if (Send8BitMode) {                          if (Send8BitMode) {
537                                  *Len = 4;                                  *Len = 4;
538                                  strncpy_s(KeyStr,destlen,"\23318~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23318~",_TRUNCATE);
539                          } else {                          } else {
540                                  *Len = 5;                                  *Len = 5;
541                                  strncpy_s(KeyStr,destlen,"\033[18~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[18~",_TRUNCATE);
542                          }                          }
543                          break;                          break;
544                  case IdF8: /* DEC Key: F8 */                  case IdF8: /* DEC Key: F8 */
545                          if (Send8BitMode) {                          if (Send8BitMode) {
546                                  *Len = 4;                                  *Len = 4;
547                                  strncpy_s(KeyStr,destlen,"\23319~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23319~",_TRUNCATE);
548                          } else {                          } else {
549                                  *Len = 5;                                  *Len = 5;
550                                  strncpy_s(KeyStr,destlen,"\033[19~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[19~",_TRUNCATE);
551                          }                          }
552                          break;                          break;
553                  case IdF9: /* DEC Key: F9 */                  case IdF9: /* DEC Key: F9 */
554                          if (Send8BitMode) {                          if (Send8BitMode) {
555                                  *Len = 4;                                  *Len = 4;
556                                  strncpy_s(KeyStr,destlen,"\23320~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23320~",_TRUNCATE);
557                          } else {                          } else {
558                                  *Len = 5;                                  *Len = 5;
559                                  strncpy_s(KeyStr,destlen,"\033[20~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[20~",_TRUNCATE);
560                          }                          }
561                          break;                          break;
562                  case IdF10: /* DEC Key: F10 */                  case IdF10: /* DEC Key: F10 */
563                          if (Send8BitMode) {                          if (Send8BitMode) {
564                                  *Len = 4;                                  *Len = 4;
565                                  strncpy_s(KeyStr,destlen,"\23321~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23321~",_TRUNCATE);
566                          } else {                          } else {
567                                  *Len = 5;                                  *Len = 5;
568                                  strncpy_s(KeyStr,destlen,"\033[21~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[21~",_TRUNCATE);
569                          }                          }
570                          break;                          break;
571                  case IdF11: /* DEC Key: F11 */                  case IdF11: /* DEC Key: F11 */
572                          if (Send8BitMode) {                          if (Send8BitMode) {
573                                  *Len = 4;                                  *Len = 4;
574                                  strncpy_s(KeyStr,destlen,"\23323~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23323~",_TRUNCATE);
575                          } else {                          } else {
576                                  *Len = 5;                                  *Len = 5;
577                                  strncpy_s(KeyStr,destlen,"\033[23~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[23~",_TRUNCATE);
578                          }                          }
579                          break;                          break;
580                  case IdF12: /* DEC Key: F12 */                  case IdF12: /* DEC Key: F12 */
581                          if (Send8BitMode) {                          if (Send8BitMode) {
582                                  *Len = 4;                                  *Len = 4;
583                                  strncpy_s(KeyStr,destlen,"\23324~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23324~",_TRUNCATE);
584                          } else {                          } else {
585                                  *Len = 5;                                  *Len = 5;
586                                  strncpy_s(KeyStr,destlen,"\033[24~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[24~",_TRUNCATE);
587                          }                          }
588                          break;                          break;
589                  case IdF13: /* DEC Key: F13 */                  case IdF13: /* DEC Key: F13 */
590                          if (Send8BitMode) {                          if (Send8BitMode) {
591                                  *Len = 4;                                  *Len = 4;
592                                  strncpy_s(KeyStr,destlen,"\23325~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23325~",_TRUNCATE);
593                          } else {                          } else {
594                                  *Len = 5;                                  *Len = 5;
595                                  strncpy_s(KeyStr,destlen,"\033[25~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[25~",_TRUNCATE);
596                          }                          }
597                          break;                          break;
598                  case IdF14: /* DEC Key: F14 */                  case IdF14: /* DEC Key: F14 */
599                          if (Send8BitMode) {                          if (Send8BitMode) {
600                                  *Len = 4;                                  *Len = 4;
601                                  strncpy_s(KeyStr,destlen,"\23326~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23326~",_TRUNCATE);
602                          } else {                          } else {
603                                  *Len = 5;                                  *Len = 5;
604                                  strncpy_s(KeyStr,destlen,"\033[26~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[26~",_TRUNCATE);
605                          }                          }
606                          break;                          break;
607                  case IdHelp: /* DEC Key: Help */                  case IdHelp: /* DEC Key: Help */
608                          if (Send8BitMode) {                          if (Send8BitMode) {
609                                  *Len = 4;                                  *Len = 4;
610                                  strncpy_s(KeyStr,destlen,"\23328~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23328~",_TRUNCATE);
611                          } else {                          } else {
612                                  *Len = 5;                                  *Len = 5;
613                                  strncpy_s(KeyStr,destlen,"\033[28~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[28~",_TRUNCATE);
614                          }                          }
615                          break;                          break;
616                  case IdDo: /* DEC Key: Do */                  case IdDo: /* DEC Key: Do */
617                          if (Send8BitMode) {                          if (Send8BitMode) {
618                                  *Len = 4;                                  *Len = 4;
619                                  strncpy_s(KeyStr,destlen,"\23329~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23329~",_TRUNCATE);
620                          } else {                          } else {
621                                  *Len = 5;                                  *Len = 5;
622                                  strncpy_s(KeyStr,destlen,"\033[29~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[29~",_TRUNCATE);
623                          }                          }
624                          break;                          break;
625                  case IdF17: /* DEC Key: F17 */                  case IdF17: /* DEC Key: F17 */
626                          if (Send8BitMode) {                          if (Send8BitMode) {
627                                  *Len = 4;                                  *Len = 4;
628                                  strncpy_s(KeyStr,destlen,"\23331~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23331~",_TRUNCATE);
629                          } else {                          } else {
630                                  *Len = 5;                                  *Len = 5;
631                                  strncpy_s(KeyStr,destlen,"\033[31~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[31~",_TRUNCATE);
632                          }                          }
633                          break;                          break;
634                  case IdF18: /* DEC Key: F18 */                  case IdF18: /* DEC Key: F18 */
635                          if (Send8BitMode) {                          if (Send8BitMode) {
636                                  *Len = 4;                                  *Len = 4;
637                                  strncpy_s(KeyStr,destlen,"\23332~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23332~",_TRUNCATE);
638                          } else {                          } else {
639                                  *Len = 5;                                  *Len = 5;
640                                  strncpy_s(KeyStr,destlen,"\033[32~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[32~",_TRUNCATE);
641                          }                          }
642                          break;                          break;
643                  case IdF19: /* DEC Key: F19 */                  case IdF19: /* DEC Key: F19 */
644                          if (Send8BitMode) {                          if (Send8BitMode) {
645                                  *Len = 4;                                  *Len = 4;
646                                  strncpy_s(KeyStr,destlen,"\23333~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23333~",_TRUNCATE);
647                          } else {                          } else {
648                                  *Len = 5;                                  *Len = 5;
649                                  strncpy_s(KeyStr,destlen,"\033[33~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[33~",_TRUNCATE);
650                          }                          }
651                          break;                          break;
652                  case IdF20: /* DEC Key: F20 */                  case IdF20: /* DEC Key: F20 */
653                          if (Send8BitMode) {                          if (Send8BitMode) {
654                                  *Len = 4;                                  *Len = 4;
655                                  strncpy_s(KeyStr,destlen,"\23334~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23334~",_TRUNCATE);
656                          } else {                          } else {
657                                  *Len = 5;                                  *Len = 5;
658                                  strncpy_s(KeyStr,destlen,"\033[34~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[34~",_TRUNCATE);
659                          }                          }
660                          break;                          break;
661                  case IdXF1: /* XTERM F1 */                  case IdXF1: /* XTERM F1 */
662                          if (Send8BitMode) {                          if (Send8BitMode) {
663                                  *Len = 4;                                  *Len = 4;
664                                  strncpy_s(KeyStr,destlen,"\23311~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23311~",_TRUNCATE);
665                          } else {                          } else {
666                                  *Len = 5;                                  *Len = 5;
667                                  strncpy_s(KeyStr,destlen,"\033[11~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[11~",_TRUNCATE);
668                          }                          }
669                          break;                          break;
670                  case IdXF2: /* XTERM F2 */                  case IdXF2: /* XTERM F2 */
671                          if (Send8BitMode) {                          if (Send8BitMode) {
672                                  *Len = 4;                                  *Len = 4;
673                                  strncpy_s(KeyStr,destlen,"\23312~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23312~",_TRUNCATE);
674                          } else {                          } else {
675                                  *Len = 5;                                  *Len = 5;
676                                  strncpy_s(KeyStr,destlen,"\033[12~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[12~",_TRUNCATE);
677                          }                          }
678                          break;                          break;
679                  case IdXF3: /* XTERM F3 */                  case IdXF3: /* XTERM F3 */
680                          if (Send8BitMode) {                          if (Send8BitMode) {
681                                  *Len = 4;                                  *Len = 4;
682                                  strncpy_s(KeyStr,destlen,"\23313~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23313~",_TRUNCATE);
683                          } else {                          } else {
684                                  *Len = 5;                                  *Len = 5;
685                                  strncpy_s(KeyStr,destlen,"\033[13~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[13~",_TRUNCATE);
686                          }                          }
687                          break;                          break;
688                  case IdXF4: /* XTERM F4 */                  case IdXF4: /* XTERM F4 */
689                          if (Send8BitMode) {                          if (Send8BitMode) {
690                                  *Len = 4;                                  *Len = 4;
691                                  strncpy_s(KeyStr,destlen,"\23314~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23314~",_TRUNCATE);
692                          } else {                          } else {
693                                  *Len = 5;                                  *Len = 5;
694                                  strncpy_s(KeyStr,destlen,"\033[14~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[14~",_TRUNCATE);
695                          }                          }
696                          break;                          break;
697                  case IdXF5: /* XTERM F5 */                  case IdXF5: /* XTERM F5 */
698                          if (Send8BitMode) {                          if (Send8BitMode) {
699                                  *Len = 4;                                  *Len = 4;
700                                  strncpy_s(KeyStr,destlen,"\23315~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\23315~",_TRUNCATE);
701                          } else {                          } else {
702                                  *Len = 5;                                  *Len = 5;
703                                  strncpy_s(KeyStr,destlen,"\033[15~",_TRUNCATE);                                  strncpy_s(KeyStr,destlen,"\033[15~",_TRUNCATE);
704                          }                          }
705                          break;                          break;
706                  case IdHold:                  case IdHold:
707                  case IdPrint:                  case IdPrint:
708                  case IdBreak:                  case IdBreak:
709                  case IdCmdEditCopy:                  case IdCmdEditCopy:
710                  case IdCmdEditPaste:                  case IdCmdEditPaste:
711                  case IdCmdEditPasteCR:                  case IdCmdEditPasteCR:
712                  case IdCmdEditCLS:                  case IdCmdEditCLS:
713                  case IdCmdEditCLB:                  case IdCmdEditCLB:
714                  case IdCmdCtrlOpenTEK:                  case IdCmdCtrlOpenTEK:
715                  case IdCmdCtrlCloseTEK:                  case IdCmdCtrlCloseTEK:
716                  case IdCmdLineUp:                  case IdCmdLineUp:
717                  case IdCmdLineDown:                  case IdCmdLineDown:
718                  case IdCmdPageUp:                  case IdCmdPageUp:
719                  case IdCmdPageDown:                  case IdCmdPageDown:
720                  case IdCmdBuffTop:                  case IdCmdBuffTop:
721                  case IdCmdBuffBottom:                  case IdCmdBuffBottom:
722                  case IdCmdNextWin:                  case IdCmdNextWin:
723                  case IdCmdPrevWin:                  case IdCmdPrevWin:
724                  case IdCmdLocalEcho:                  case IdCmdLocalEcho:
725                  case IdScrollLock:                  case IdScrollLock:
726                          PostMessage(HWin,WM_USER_ACCELCOMMAND,KeyCode,0);                          PostMessage(HWin,WM_USER_ACCELCOMMAND,KeyCode,0);
727                          break;                          break;
728                  default:                  default:
729                          if ((KeyCode >= IdUser1) && (KeyCode <= IdKeyMax)) {                          if ((KeyCode >= IdUser1) && (KeyCode <= IdKeyMax)) {
730                                  *Type = (WORD)(*KeyMap).UserKeyType[KeyCode-IdUser1]; // key type                                  *Type = (WORD)(*KeyMap).UserKeyType[KeyCode-IdUser1]; // key type
731                                  *Len = KeyMap->UserKeyLen[KeyCode-IdUser1];                                  *Len = KeyMap->UserKeyLen[KeyCode-IdUser1];
732                                  memcpy(Temp,                                  memcpy(Temp,
733                                             &KeyMap->UserKeyStr[KeyMap->UserKeyPtr[KeyCode-IdUser1]],                                             &KeyMap->UserKeyStr[KeyMap->UserKeyPtr[KeyCode-IdUser1]],
734                                             *Len);                                             *Len);
735                                  Temp[*Len] = 0;                                  Temp[*Len] = 0;
736                                  if ((*Type==IdBinary) || (*Type==IdText))                                  if ((*Type==IdBinary) || (*Type==IdText))
737                                          *Len = Hex2Str(Temp,KeyStr,destlen);                                          *Len = Hex2Str(Temp,KeyStr,destlen);
738                                  else                                  else
739                                          strncpy_s(KeyStr,destlen,Temp,_TRUNCATE);                                          strncpy_s(KeyStr,destlen,Temp,_TRUNCATE);
740                          }                          }
741                          else                          else
742                                  return;                                  return;
743          }          }
744          /* remove WM_CHAR message for used keycode */          /* remove WM_CHAR message for used keycode */
745          PeekMessage(&Msg,HWin, WM_CHAR, WM_CHAR,PM_REMOVE);          PeekMessage(&Msg,HWin, WM_CHAR, WM_CHAR,PM_REMOVE);
746  }  }
747    
748  void FAR PASCAL SetCOMFlag(int Com)  void FAR PASCAL SetCOMFlag(int Com)
749  {  {
750          pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);          pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);
751  }  }
752    
753  void FAR PASCAL ClearCOMFlag(int Com)  void FAR PASCAL ClearCOMFlag(int Com)
754  {  {
755          pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));          pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));
756  }  }
757    
758  int FAR PASCAL CheckCOMFlag(int Com)  int FAR PASCAL CheckCOMFlag(int Com)
759  {  {
760          return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);          return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);
761  }  }
762    
763  int FAR PASCAL RegWin(HWND HWinVT, HWND HWinTEK)  int FAR PASCAL RegWin(HWND HWinVT, HWND HWinTEK)
764  {  {
765          int i, j;          int i, j;
766    
767          if (pm->NWin>=MAXNWIN)          if (pm->NWin>=MAXNWIN)
768                  return 0;                  return 0;
769          if (HWinVT==NULL)          if (HWinVT==NULL)
770                  return 0;                  return 0;
771          if (HWinTEK!=NULL) {          if (HWinTEK!=NULL) {
772                  i = 0;                  i = 0;
773                  while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))                  while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))
774                          i++;                          i++;
775                  if (i>=pm->NWin)                  if (i>=pm->NWin)
776                          return 0;                          return 0;
777                  for (j=pm->NWin-1 ; j>i ; j--)                  for (j=pm->NWin-1 ; j>i ; j--)
778                          pm->WinList[j+1] = pm->WinList[j];                          pm->WinList[j+1] = pm->WinList[j];
779                  pm->WinList[i+1] = HWinTEK;                  pm->WinList[i+1] = HWinTEK;
780                  pm->NWin++;                  pm->NWin++;
781                  return 0;                  return 0;
782          }          }
783          pm->WinList[pm->NWin++] = HWinVT;          pm->WinList[pm->NWin++] = HWinVT;
784          if (pm->NWin==1)          if (pm->NWin==1)
785                  return 1;                  return 1;
786          else          else
787                  return (int)(SendMessage(pm->WinList[pm->NWin-2],                  return (int)(SendMessage(pm->WinList[pm->NWin-2],
788                               WM_USER_GETSERIALNO,0,0)+1);                               WM_USER_GETSERIALNO,0,0)+1);
789  }  }
790    
791  void FAR PASCAL UnregWin(HWND HWin)  void FAR PASCAL UnregWin(HWND HWin)
792  {  {
793          int i, j;          int i, j;
794    
795          i = 0;          i = 0;
796          while ((i<pm->NWin) && (pm->WinList[i]!=HWin))          while ((i<pm->NWin) && (pm->WinList[i]!=HWin))
797                  i++;                  i++;
798          if (pm->WinList[i]!=HWin)          if (pm->WinList[i]!=HWin)
799                  return;                  return;
800          for (j=i ; j<pm->NWin-1 ; j++)          for (j=i ; j<pm->NWin-1 ; j++)
801                  pm->WinList[j] = pm->WinList[j+1];                  pm->WinList[j] = pm->WinList[j+1];
802          if (pm->NWin>0)          if (pm->NWin>0)
803                  pm->NWin--;                  pm->NWin--;
804  }  }
805    
806  void FAR PASCAL SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)  void FAR PASCAL SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)
807  {  {
808          int i;          int i;
809          char Temp[MAXPATHLEN];          char Temp[MAXPATHLEN];
810          HWND Hw;          HWND Hw;
811    
812          // delete all items in Window menu          // delete all items in Window menu
813          i = GetMenuItemCount(menu);          i = GetMenuItemCount(menu);
814          if (i>0)          if (i>0)
815                  do {                  do {
816                          i--;                          i--;
817                          RemoveMenu(menu,i,MF_BYPOSITION);                          RemoveMenu(menu,i,MF_BYPOSITION);
818                  } while (i>0);                  } while (i>0);
819    
820          i = 0;          i = 0;
821          while (i<pm->NWin) {          while (i<pm->NWin) {
822                  Hw = pm->WinList[i]; // get window handle                  Hw = pm->WinList[i]; // get window handle
823                  if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&                  if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
824                      ((strcmp(Temp,VTCLASSNAME)==0) ||                      ((strcmp(Temp,VTCLASSNAME)==0) ||
825                       (strcmp(Temp,TEKCLASSNAME)==0))) {                       (strcmp(Temp,TEKCLASSNAME)==0))) {
826                          Temp[0] = '&';                          Temp[0] = '&';
827                          Temp[1] = (char)(0x31 + i);                          Temp[1] = (char)(0x31 + i);
828                          Temp[2] = ' ';                          Temp[2] = ' ';
829                          GetWindowText(Hw,&Temp[3],sizeof(Temp)-4);                          GetWindowText(Hw,&Temp[3],sizeof(Temp)-4);
830                          AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);                          AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);
831                          i++;                          i++;
832                          if (i>8)                          if (i>8)
833                                  i = pm->NWin;                                  i = pm->NWin;
834                  }                  }
835                  else                  else
836                          UnregWin(Hw);                          UnregWin(Hw);
837          }          }
838          get_lang_msg("MENU_WINDOW_WINDOW", buf, buflen, "&Window", langFile);          get_lang_msg("MENU_WINDOW_WINDOW", buf, buflen, "&Window", langFile);
839          if (VTFlag == 1) {          if (VTFlag == 1) {
840                  AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_WINDOW, buf);                  AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_WINDOW, buf);
841          }          }
842          else {          else {
843                  AppendMenu(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, buf);                  AppendMenu(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, buf);
844          }          }
845  }  }
846    
847  void FAR PASCAL SetWinList(HWND HWin, HWND HDlg, int IList)  void FAR PASCAL SetWinList(HWND HWin, HWND HDlg, int IList)
848  {  {
849          int i;          int i;
850          char Temp[MAXPATHLEN];          char Temp[MAXPATHLEN];
851          HWND Hw;          HWND Hw;
852    
853          for (i=0; i<pm->NWin; i++) {          for (i=0; i<pm->NWin; i++) {
854                  Hw = pm->WinList[i]; // get window handle                  Hw = pm->WinList[i]; // get window handle
855                  if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&                  if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
856                      ((strcmp(Temp,VTCLASSNAME)==0) ||                      ((strcmp(Temp,VTCLASSNAME)==0) ||
857                       (strcmp(Temp,TEKCLASSNAME)==0))) {                       (strcmp(Temp,TEKCLASSNAME)==0))) {
858                          GetWindowText(Hw,Temp,sizeof(Temp)-1);                          GetWindowText(Hw,Temp,sizeof(Temp)-1);
859                          SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,                          SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,
860                                             0, (LONG)Temp);                                             0, (LONG)Temp);
861                          if (Hw==HWin)                          if (Hw==HWin)
862                                  SendDlgItemMessage(HDlg, IList, LB_SETCURSEL,                                  SendDlgItemMessage(HDlg, IList, LB_SETCURSEL,
863                                                    i,0);                                                    i,0);
864                  }                  }
865                  else                  else
866                          UnregWin(Hw);                          UnregWin(Hw);
867          }          }
868  }  }
869    
870  void FAR PASCAL SelectWin(int WinId)  void FAR PASCAL SelectWin(int WinId)
871  {  {
872          if ((WinId>=0) && (WinId<pm->NWin)) {          if ((WinId>=0) && (WinId<pm->NWin)) {
873                  ShowWindow(pm->WinList[WinId],SW_SHOWNORMAL);                  ShowWindow(pm->WinList[WinId],SW_SHOWNORMAL);
874                  SetForegroundWindow(pm->WinList[WinId]);                  SetForegroundWindow(pm->WinList[WinId]);
875          }          }
876  }  }
877    
878  void FAR PASCAL SelectNextWin(HWND HWin, int Next)  void FAR PASCAL SelectNextWin(HWND HWin, int Next)
879  {  {
880          int i;          int i;
881    
882          i = 0;          i = 0;
883          while ((i<pm->NWin) && (pm->WinList[i]!=HWin))          while ((i<pm->NWin) && (pm->WinList[i]!=HWin))
884                  i++;                  i++;
885          if (pm->WinList[i]!=HWin)          if (pm->WinList[i]!=HWin)
886                  return;                  return;
887          i = i + Next;          i = i + Next;
888          if (i >= pm->NWin)          if (i >= pm->NWin)
889                  i = 0;                  i = 0;
890          else if (i<0)          else if (i<0)
891                  i = pm->NWin-1;                  i = pm->NWin-1;
892          SelectWin(i);          SelectWin(i);
893  }  }
894    
895  HWND FAR PASCAL GetNthWin(int n)  HWND FAR PASCAL GetNthWin(int n)
896  {  {
897          if (n<pm->NWin)          if (n<pm->NWin)
898                  return pm->WinList[n];                  return pm->WinList[n];
899          else          else
900                  return NULL;                  return NULL;
901  }  }
902    
903  int FAR PASCAL CommReadRawByte(PComVar cv, LPBYTE b)  int FAR PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
904  {  {
905          if ( ! cv->Ready )          if ( ! cv->Ready )
906                  return 0;                  return 0;
907    
908          if ( cv->InBuffCount>0 ) {          if ( cv->InBuffCount>0 ) {
909                  *b = cv->InBuff[cv->InPtr];                  *b = cv->InBuff[cv->InPtr];
910                  cv->InPtr++;                  cv->InPtr++;
911                  cv->InBuffCount--;                  cv->InBuffCount--;
912                  if ( cv->InBuffCount==0 )                  if ( cv->InBuffCount==0 )
913                          cv->InPtr = 0;                          cv->InPtr = 0;
914                  return 1;                  return 1;
915          }          }
916          else {          else {
917                  cv->InPtr = 0;                  cv->InPtr = 0;
918                  return 0;                  return 0;
919          }          }
920  }  }
921    
922  void PASCAL FAR CommInsert1Byte(PComVar cv, BYTE b)  void PASCAL FAR CommInsert1Byte(PComVar cv, BYTE b)
923  {  {
924          if ( ! cv->Ready )          if ( ! cv->Ready )
925                  return;                  return;
926    
927          if (cv->InPtr == 0)          if (cv->InPtr == 0)
928                  memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);                  memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
929          else          else
930                  cv->InPtr--;                  cv->InPtr--;
931          cv->InBuff[cv->InPtr] = b;          cv->InBuff[cv->InPtr] = b;
932          cv->InBuffCount++;          cv->InBuffCount++;
933    
934          if (cv->HBinBuf!=0 )          if (cv->HBinBuf!=0 )
935                  cv->BinSkip++;                  cv->BinSkip++;
936  }  }
937    
938  void Log1Bin(PComVar cv, BYTE b)  void Log1Bin(PComVar cv, BYTE b)
939  {  {
940          if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag)          if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag)
941                  return;                  return;
942          if (cv->BinSkip > 0) {          if (cv->BinSkip > 0) {
943                  cv->BinSkip--;                  cv->BinSkip--;
944                  return;                  return;
945          }          }
946          cv->BinBuf[cv->BinPtr] = b;          cv->BinBuf[cv->BinPtr] = b;
947          cv->BinPtr++;          cv->BinPtr++;
948          if (cv->BinPtr>=InBuffSize)          if (cv->BinPtr>=InBuffSize)
949                  cv->BinPtr = cv->BinPtr-InBuffSize;                  cv->BinPtr = cv->BinPtr-InBuffSize;
950          if (cv->BCount>=InBuffSize) {          if (cv->BCount>=InBuffSize) {
951                  cv->BCount = InBuffSize;                  cv->BCount = InBuffSize;
952                  cv->BStart = cv->BinPtr;                  cv->BStart = cv->BinPtr;
953          }          }
954          else          else
955                  cv->BCount++;                  cv->BCount++;
956  }  }
957    
958  int FAR PASCAL CommRead1Byte(PComVar cv, LPBYTE b)  int FAR PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
959  {  {
960          int c;          int c;
961    
962          if ( ! cv->Ready )          if ( ! cv->Ready )
963                  return 0;                  return 0;
964    
965          if ((cv->HLogBuf!=NULL) &&          if ((cv->HLogBuf!=NULL) &&
966              ((cv->LCount>=InBuffSize-10) ||              ((cv->LCount>=InBuffSize-10) ||
967               (cv->DCount>=InBuffSize-10))) {               (cv->DCount>=InBuffSize-10))) {
968                  // 自分のバッファに余裕がない場合は、CPUスケジューリングを他に回し、                  // 自分のバッファに余裕がない場合は、CPUスケジューリングを他に回し、
969                  // CPUがストールするの防ぐ。                  // CPUがストールするの防ぐ。
970                  // (2006.10.13 yutaka)                  // (2006.10.13 yutaka)
971                  Sleep(1);                  Sleep(1);
972                  return 0;                  return 0;
973          }          }
974    
975          if ((cv->HBinBuf!=NULL) &&          if ((cv->HBinBuf!=NULL) &&
976              (cv->BCount>=InBuffSize-10))              (cv->BCount>=InBuffSize-10))
977                  return 0;                  return 0;
978    
979          if ( cv->TelMode )          if ( cv->TelMode )
980                  c = 0;                  c = 0;
981          else          else
982                  c = CommReadRawByte(cv,b);                  c = CommReadRawByte(cv,b);
983    
984          if ((c==1) && cv->TelCRFlag) {          if ((c==1) && cv->TelCRFlag) {
985                  cv->TelCRFlag = FALSE;                  cv->TelCRFlag = FALSE;
986                  if (*b==0) c = 0;                  if (*b==0) c = 0;
987          }          }
988    
989          if ( c==1 ) {          if ( c==1 ) {
990                  if ( cv->IACFlag ) {                  if ( cv->IACFlag ) {
991                          cv->IACFlag = FALSE;                          cv->IACFlag = FALSE;
992                          if ( *b != 0xFF ) {                          if ( *b != 0xFF ) {
993                                  cv->TelMode = TRUE;                                  cv->TelMode = TRUE;
994                                  CommInsert1Byte(cv,*b);                                  CommInsert1Byte(cv,*b);
995                                  if ( cv->HBinBuf!=0 )                                  if ( cv->HBinBuf!=0 )
996                                          cv->BinSkip--;                                          cv->BinSkip--;
997                                  c = 0;                                  c = 0;
998                          }                          }
999                  }                  }
1000                  else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {                  else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1001                          if (!cv->TelFlag && cv->TelAutoDetect)  /* TTPLUG */                          if (!cv->TelFlag && cv->TelAutoDetect)  /* TTPLUG */
1002                                  cv->TelFlag = TRUE;                                  cv->TelFlag = TRUE;
1003                          if (cv->TelFlag) {                          if (cv->TelFlag) {
1004                                  cv->IACFlag = TRUE;                                  cv->IACFlag = TRUE;
1005                                  c = 0;                                  c = 0;
1006                          }                          }
1007                  }                  }
1008                  else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D))                  else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D))
1009                          cv->TelCRFlag = TRUE;                          cv->TelCRFlag = TRUE;
1010          }          }
1011    
1012          if ( (c==1) && (cv->HBinBuf!=0) )          if ( (c==1) && (cv->HBinBuf!=0) )
1013                  Log1Bin(cv, *b);                  Log1Bin(cv, *b);
1014    
1015          return c;          return c;
1016  }  }
1017    
1018  int FAR PASCAL CommRawOut(PComVar cv, PCHAR B, int C)  int FAR PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1019  {  {
1020          int a;          int a;
1021    
1022          if ( ! cv->Ready )          if ( ! cv->Ready )
1023                  return C;                  return C;
1024    
1025          if (C > OutBuffSize - cv->OutBuffCount)          if (C > OutBuffSize - cv->OutBuffCount)
1026                  a = OutBuffSize - cv->OutBuffCount;                  a = OutBuffSize - cv->OutBuffCount;
1027          else          else
1028                  a = C;                  a = C;
1029          if ( cv->OutPtr > 0 ) {          if ( cv->OutPtr > 0 ) {
1030                  memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);                  memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1031                  cv->OutPtr = 0;                  cv->OutPtr = 0;
1032          }          }
1033          memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);          memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1034          cv->OutBuffCount = cv->OutBuffCount + a;          cv->OutBuffCount = cv->OutBuffCount + a;
1035          return a;          return a;
1036  }  }
1037    
1038  int FAR PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)  int FAR PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)
1039  {  {
1040          int a, i, Len;          int a, i, Len;
1041          char d[3];          char d[3];
1042    
1043          if ( ! cv->Ready )          if ( ! cv->Ready )
1044                  return C;                  return C;
1045    
1046          i = 0;          i = 0;
1047          a = 1;          a = 1;
1048          while ((a>0) && (i<C)) {          while ((a>0) && (i<C)) {
1049                  Len = 0;                  Len = 0;
1050    
1051                  d[Len] = B[i];                  d[Len] = B[i];
1052                  Len++;                  Len++;
1053    
1054                  if ( cv->TelFlag && (B[i]=='\x0d') &&                  if ( cv->TelFlag && (B[i]=='\x0d') &&
1055                       ! cv->TelBinSend ) {                       ! cv->TelBinSend ) {
1056                          d[Len] = '\x00';                          d[Len] = '\x00';
1057                          Len++;                          Len++;
1058                  };                  };
1059    
1060                  if ( cv->TelFlag && (B[i]=='\xff') ) {                  if ( cv->TelFlag && (B[i]=='\xff') ) {
1061                          d[Len] = '\xff';                          d[Len] = '\xff';
1062                          Len++;                          Len++;
1063                  }                  }
1064    
1065                  if ( OutBuffSize-cv->OutBuffCount-Len >=0 ) {                  if ( OutBuffSize-cv->OutBuffCount-Len >=0 ) {
1066                          CommRawOut(cv,d,Len);                          CommRawOut(cv,d,Len);
1067                          a = 1;                          a = 1;
1068                  }                  }
1069                  else                  else
1070                          a = 0;                          a = 0;
1071    
1072                  i = i + a;                  i = i + a;
1073          }          }
1074          return i;          return i;
1075  }  }
1076    
1077  static void OutputTextUTF8(WORD K, char *TempStr, int *TempLenSrc, PComVar cv)  static void OutputTextUTF8(WORD K, char *TempStr, int *TempLenSrc, PComVar cv)
1078  {  {
1079          unsigned int code;          unsigned int code;
1080          int byte;          int byte;
1081          int TempLen = *TempLenSrc;          int TempLen = *TempLenSrc;
1082    
1083          code = SJIS2UTF8(K, &byte, cv->Locale);          code = SJIS2UTF8(K, &byte, cv->Locale);
1084          if (byte == 1) {          if (byte == 1) {
1085                  TempStr[TempLen++] = code;                  TempStr[TempLen++] = code;
1086          }          }
1087          else if (byte == 2) {          else if (byte == 2) {
1088                  TempStr[TempLen++] = (code >> 8) & 0xff;                  TempStr[TempLen++] = (code >> 8) & 0xff;
1089                  TempStr[TempLen++] = code & 0xff;                  TempStr[TempLen++] = code & 0xff;
1090    
1091          }          }
1092          else if (byte == 3) {          else if (byte == 3) {
1093                  TempStr[TempLen++] = (code >> 16) & 0xff;                  TempStr[TempLen++] = (code >> 16) & 0xff;
1094                  TempStr[TempLen++] = (code >> 8) & 0xff;                  TempStr[TempLen++] = (code >> 8) & 0xff;
1095                  TempStr[TempLen++] = code & 0xff;                  TempStr[TempLen++] = code & 0xff;
1096    
1097          }          }
1098    
1099          *TempLenSrc = TempLen;          *TempLenSrc = TempLen;
1100  }  }
1101    
1102    
1103  //  //
1104  // SJISから各種漢字コードへ変換して出力する。  // SJISから各種漢字コードへ変換して出力する。
1105  //  //
1106  int TextOutJP(PComVar cv, PCHAR B, int C)  int TextOutJP(PComVar cv, PCHAR B, int C)
1107  {  {
1108          int i, TempLen;          int i, TempLen;
1109          WORD K;          WORD K;
1110          char TempStr[11];          char TempStr[11];
1111          int SendCodeNew;          int SendCodeNew;
1112          BYTE d;          BYTE d;
1113          BOOL Full, KanjiFlagNew;          BOOL Full, KanjiFlagNew;
1114    
1115          Full = FALSE;          Full = FALSE;
1116          i = 0;          i = 0;
1117          while (! Full && (i < C)) {          while (! Full && (i < C)) {
1118                  TempLen = 0;                  TempLen = 0;
1119                  d = (BYTE)B[i];                  d = (BYTE)B[i];
1120                  SendCodeNew = cv->SendCode;                  SendCodeNew = cv->SendCode;
1121    
1122                  if (cv->SendKanjiFlag) {                  if (cv->SendKanjiFlag) {
1123                          KanjiFlagNew = FALSE;                          KanjiFlagNew = FALSE;
1124                          SendCodeNew = IdKanji;                          SendCodeNew = IdKanji;
1125    
1126                          K = (cv->SendKanjiFirst << 8) + d;                          K = (cv->SendKanjiFirst << 8) + d;
1127    
1128                          // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。                          // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1129                          if (cv->KanjiCodeSend == IdUTF8) {                          if (cv->KanjiCodeSend == IdUTF8) {
1130                                  OutputTextUTF8(K, TempStr, &TempLen, cv);                                  OutputTextUTF8(K, TempStr, &TempLen, cv);
1131    
1132                          } else {                          } else {
1133    
1134                                  if (cv->KanjiCodeSend == IdEUC)                                  if (cv->KanjiCodeSend == IdEUC)
1135                                          K = SJIS2EUC(K);                                          K = SJIS2EUC(K);
1136                                  else if (cv->KanjiCodeSend != IdSJIS)                                  else if (cv->KanjiCodeSend != IdSJIS)
1137                                          K = SJIS2JIS(K);                                          K = SJIS2JIS(K);
1138    
1139                                  if ((cv->SendCode==IdKatakana) &&                                  if ((cv->SendCode==IdKatakana) &&
1140                                      (cv->KanjiCodeSend==IdJIS) &&                                      (cv->KanjiCodeSend==IdJIS) &&
1141                                      (cv->JIS7KatakanaSend==1)) {                                      (cv->JIS7KatakanaSend==1)) {
1142                                          TempStr[TempLen] = SI;                                          TempStr[TempLen] = SI;
1143                                          TempLen++;                                          TempLen++;
1144                                  }                                  }
1145    
1146                                  TempStr[TempLen] = HIBYTE(K);                                  TempStr[TempLen] = HIBYTE(K);
1147                                  TempStr[TempLen+1] = LOBYTE(K);                                  TempStr[TempLen+1] = LOBYTE(K);
1148                                  TempLen = TempLen + 2;                                  TempLen = TempLen + 2;
1149                          }                          }
1150                  }                  }
1151                  else if (IsDBCSLeadByteEx(*cv->CodePage, d))                  else if (IsDBCSLeadByteEx(*cv->CodePage, d))
1152                  {                  {
1153                          KanjiFlagNew = TRUE;                          KanjiFlagNew = TRUE;
1154                          cv->SendKanjiFirst = d;                          cv->SendKanjiFirst = d;
1155                          SendCodeNew = IdKanji;                          SendCodeNew = IdKanji;
1156    
1157                          if ((cv->SendCode!=IdKanji) &&                          if ((cv->SendCode!=IdKanji) &&
1158                              (cv->KanjiCodeSend==IdJIS)) {                              (cv->KanjiCodeSend==IdJIS)) {
1159                                  TempStr[0] = 0x1B;                                  TempStr[0] = 0x1B;
1160                                  TempStr[1] = '$';                                  TempStr[1] = '$';
1161                                  if (cv->KanjiIn == IdKanjiInB)                                  if (cv->KanjiIn == IdKanjiInB)
1162                                          TempStr[2] = 'B';                                          TempStr[2] = 'B';
1163                                  else                                  else
1164                                          TempStr[2] = '@';                                          TempStr[2] = '@';
1165                                  TempLen = 3;                                  TempLen = 3;
1166                          }                          }
1167                          else TempLen = 0;                          else TempLen = 0;
1168                  }                  }
1169                  else {                  else {
1170                          KanjiFlagNew = FALSE;                          KanjiFlagNew = FALSE;
1171    
1172                          if ((cv->SendCode==IdKanji) &&                          if ((cv->SendCode==IdKanji) &&
1173                                  (cv->KanjiCodeSend==IdJIS))                                  (cv->KanjiCodeSend==IdJIS))
1174                          {                          {
1175                                  TempStr[0] = 0x1B;                                  TempStr[0] = 0x1B;
1176                                  TempStr[1] = '(';                                  TempStr[1] = '(';
1177                                  switch (cv->KanjiOut) {                                  switch (cv->KanjiOut) {
1178                                  case IdKanjiOutJ:                                  case IdKanjiOutJ:
1179                                          TempStr[2] = 'J';                                          TempStr[2] = 'J';
1180                                          break;                                          break;
1181                                  case IdKanjiOutH:                                  case IdKanjiOutH:
1182                                          TempStr[2] = 'H';                                          TempStr[2] = 'H';
1183                                          break;                                          break;
1184                                  default:                                  default:
1185                                          TempStr[2] = 'B';                                          TempStr[2] = 'B';
1186                                  }                                  }
1187                                  TempLen = 3;                                  TempLen = 3;
1188                          }                          }
1189                          else TempLen = 0;                          else TempLen = 0;
1190    
1191                          if ((0xa0<d) && (d<0xe0)) {                          if ((0xa0<d) && (d<0xe0)) {
1192                                  SendCodeNew = IdKatakana;                                  SendCodeNew = IdKatakana;
1193                                  if ((cv->SendCode!=IdKatakana) &&                                  if ((cv->SendCode!=IdKatakana) &&
1194                                      (cv->KanjiCodeSend==IdJIS) &&                                      (cv->KanjiCodeSend==IdJIS) &&
1195                                      (cv->JIS7KatakanaSend==1)) {                                      (cv->JIS7KatakanaSend==1)) {
1196                                          TempStr[TempLen] = SO;                                          TempStr[TempLen] = SO;
1197                                          TempLen++;                                          TempLen++;
1198                                  }                                  }
1199                          }                          }
1200                          else {                          else {
1201                                  SendCodeNew = IdASCII;                                  SendCodeNew = IdASCII;
1202                                  if ((cv->SendCode==IdKatakana) &&                                  if ((cv->SendCode==IdKatakana) &&
1203                                      (cv->KanjiCodeSend==IdJIS) &&                                      (cv->KanjiCodeSend==IdJIS) &&
1204                                      (cv->JIS7KatakanaSend==1)) {                                      (cv->JIS7KatakanaSend==1)) {
1205                                          TempStr[TempLen] = SI;                                          TempStr[TempLen] = SI;
1206                                          TempLen++;                                          TempLen++;
1207                                  }                                  }
1208                          }                          }
1209    
1210                          if (d==0x0d) {                          if (d==0x0d) {
1211                                  TempStr[TempLen] = 0x0d;                                  TempStr[TempLen] = 0x0d;
1212                                  TempLen++;                                  TempLen++;
1213                                  if (cv->CRSend==IdCRLF) {                                  if (cv->CRSend==IdCRLF) {
1214                                          TempStr[TempLen] = 0x0a;                                          TempStr[TempLen] = 0x0a;
1215                                          TempLen++;                                          TempLen++;
1216                                  }                                  }
1217                                  else if ((cv->CRSend==IdCR) &&                                  else if ((cv->CRSend==IdCR) &&
1218                                           cv->TelFlag && ! cv->TelBinSend) {                                           cv->TelFlag && ! cv->TelBinSend) {
1219                                          TempStr[TempLen] = 0;                                          TempStr[TempLen] = 0;
1220                                          TempLen++;                                          TempLen++;
1221                                  }                                  }
1222                          }                          }
1223                          else if ((d>=0xa1) && (d<=0xe0)) {                          else if ((d>=0xa1) && (d<=0xe0)) {
1224                                  /* Katakana */                                  /* Katakana */
1225                                  if (cv->KanjiCodeSend==IdEUC) {                                  if (cv->KanjiCodeSend==IdEUC) {
1226                                          TempStr[TempLen] = (char)0x8E;                                          TempStr[TempLen] = (char)0x8E;
1227                                          TempLen++;                                          TempLen++;
1228                                  }                                  }
1229                                  if ((cv->KanjiCodeSend==IdJIS) &&                                  if ((cv->KanjiCodeSend==IdJIS) &&
1230                                      (cv->JIS7KatakanaSend==1))                                      (cv->JIS7KatakanaSend==1))
1231                                          TempStr[TempLen] = d & 0x7f;                                          TempStr[TempLen] = d & 0x7f;
1232                                  else                                  else
1233                                          TempStr[TempLen] = d;                                          TempStr[TempLen] = d;
1234                                  TempLen++;                                  TempLen++;
1235    
1236                                  // 半角カナはUnicodeでは2バイトになる (2004.10.4 yutaka)                                  // 半角カナはUnicodeでは2バイトになる (2004.10.4 yutaka)
1237                                  if (cv->KanjiCodeSend==IdUTF8) {                                  if (cv->KanjiCodeSend==IdUTF8) {
1238                                          TempLen = 0;                                          TempLen = 0;
1239                                          K = d;                                          K = d;
1240                                          OutputTextUTF8(K, TempStr, &TempLen, cv);                                          OutputTextUTF8(K, TempStr, &TempLen, cv);
1241                                  }                                  }
1242                          }                          }
1243                          else {                          else {
1244                                  TempStr[TempLen] = d;                                  TempStr[TempLen] = d;
1245                                  TempLen++;                                  TempLen++;
1246                                  if (cv->TelFlag && (d==0xff)) {                                  if (cv->TelFlag && (d==0xff)) {
1247                                          TempStr[TempLen] = (char)0xff;                                          TempStr[TempLen] = (char)0xff;
1248                                          TempLen++;                                          TempLen++;
1249                                  }                                  }
1250                          }                          }
1251                  } // if (cv->SendKanjiFlag) else if ... else ... end                  } // if (cv->SendKanjiFlag) else if ... else ... end
1252    
1253                  if (TempLen == 0) {                  if (TempLen == 0) {
1254                          i++;                          i++;
1255                          cv->SendCode = SendCodeNew;                          cv->SendCode = SendCodeNew;
1256                          cv->SendKanjiFlag = KanjiFlagNew;                          cv->SendKanjiFlag = KanjiFlagNew;
1257                  }                  }
1258                  else {                  else {
1259                          Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;                          Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1260                          if (! Full) {                          if (! Full) {
1261                                  i++;                                  i++;
1262                                  cv->SendCode = SendCodeNew;                                  cv->SendCode = SendCodeNew;
1263                                  cv->SendKanjiFlag = KanjiFlagNew;                                  cv->SendKanjiFlag = KanjiFlagNew;
1264                                  CommRawOut(cv,TempStr,TempLen);                                  CommRawOut(cv,TempStr,TempLen);
1265                          }                          }
1266                  }                  }
1267    
1268          } // end of "while {}"          } // end of "while {}"
1269    
1270          return i;          return i;
1271  }  }
1272    
1273  int TextOutKR(PComVar cv, PCHAR B, int C) //HKS  int TextOutKR(PComVar cv, PCHAR B, int C) //HKS
1274  {  {
1275          int i, TempLen;          int i, TempLen;
1276          WORD K;          WORD K;
1277          char TempStr[11];          char TempStr[11];
1278          int SendCodeNew;          int SendCodeNew;
1279          BYTE d;          BYTE d;
1280          BOOL Full, KanjiFlagNew;          BOOL Full, KanjiFlagNew;
1281    
1282          Full = FALSE;          Full = FALSE;
1283          i = 0;          i = 0;
1284          while (! Full && (i < C))          while (! Full && (i < C))
1285          {          {
1286                  TempLen = 0;                  TempLen = 0;
1287                  d = (BYTE)B[i];                  d = (BYTE)B[i];
1288                  SendCodeNew = cv->SendCode;                  SendCodeNew = cv->SendCode;
1289    
1290                  if (cv->SendKanjiFlag)                  if (cv->SendKanjiFlag)
1291                  {                  {
1292                          KanjiFlagNew = FALSE;                          KanjiFlagNew = FALSE;
1293                          SendCodeNew = IdKanji;                          SendCodeNew = IdKanji;
1294    
1295                          K = (cv->SendKanjiFirst << 8) + d;                          K = (cv->SendKanjiFirst << 8) + d;
1296    
1297                          // UTF-8への変換を行う。1?3バイトまでの対応なので注意。                          // UTF-8への変換を行う。1?3バイトまでの対応なので注意。
1298                          if (cv->KanjiCodeSend == IdUTF8) {                          if (cv->KanjiCodeSend == IdUTF8) {
1299                                  OutputTextUTF8(K, TempStr, &TempLen, cv);                                  OutputTextUTF8(K, TempStr, &TempLen, cv);
1300    
1301                          } else {                          } else {
1302    
1303                                  if (cv->KanjiCodeSend == IdEUC) K = K;                                  if (cv->KanjiCodeSend == IdEUC) K = K;
1304                                  else if (cv->KanjiCodeSend != IdSJIS) K = K;                                  else if (cv->KanjiCodeSend != IdSJIS) K = K;
1305    
1306                                  if ((cv->SendCode==IdKatakana) &&                                  if ((cv->SendCode==IdKatakana) &&
1307                                          (cv->KanjiCodeSend==IdJIS) &&                                          (cv->KanjiCodeSend==IdJIS) &&
1308                                          (cv->JIS7KatakanaSend==1))                                          (cv->JIS7KatakanaSend==1))
1309                                  {                                  {
1310                                          TempStr[TempLen] = SI;                                          TempStr[TempLen] = SI;
1311                                          TempLen++;                                          TempLen++;
1312                                  }                                  }
1313    
1314                                  TempStr[TempLen] = HIBYTE(K);                                  TempStr[TempLen] = HIBYTE(K);
1315                                  TempStr[TempLen+1] = LOBYTE(K);                                  TempStr[TempLen+1] = LOBYTE(K);
1316                                  TempLen = TempLen + 2;                                  TempLen = TempLen + 2;
1317                          }                          }
1318                  }                  }
1319                  else if (IsDBCSLeadByteEx(*cv->CodePage, d))                  else if (IsDBCSLeadByteEx(*cv->CodePage, d))
1320                  {                  {
1321                          KanjiFlagNew = TRUE;                          KanjiFlagNew = TRUE;
1322                          cv->SendKanjiFirst = d;                          cv->SendKanjiFirst = d;
1323                          SendCodeNew = IdKanji;                          SendCodeNew = IdKanji;
1324    
1325                          if ((cv->SendCode!=IdKanji) &&                          if ((cv->SendCode!=IdKanji) &&
1326                                  (cv->KanjiCodeSend==IdJIS))                                  (cv->KanjiCodeSend==IdJIS))
1327                          {                          {
1328                                  TempStr[0] = 0x1B;                                  TempStr[0] = 0x1B;
1329                                  TempStr[1] = '$';                                  TempStr[1] = '$';
1330                                  if (cv->KanjiIn == IdKanjiInB)                                  if (cv->KanjiIn == IdKanjiInB)
1331                                          TempStr[2] = 'B';                                          TempStr[2] = 'B';
1332                                  else                                  else
1333                                          TempStr[2] = '@';                                          TempStr[2] = '@';
1334                                  TempLen = 3;                                  TempLen = 3;
1335                          }                          }
1336                          else TempLen = 0;                          else TempLen = 0;
1337                  }                  }
1338                  else {                  else {
1339                          KanjiFlagNew = FALSE;                          KanjiFlagNew = FALSE;
1340    
1341                          if ((cv->SendCode==IdKanji) &&                          if ((cv->SendCode==IdKanji) &&
1342                                  (cv->KanjiCodeSend==IdJIS))                                  (cv->KanjiCodeSend==IdJIS))
1343                          {                          {
1344                                  TempStr[0] = 0x1B;                                  TempStr[0] = 0x1B;
1345                                  TempStr[1] = '(';                                  TempStr[1] = '(';
1346                                  switch (cv->KanjiOut) {                                  switch (cv->KanjiOut) {
1347                                  case IdKanjiOutJ: TempStr[2] = 'J'; break;                                  case IdKanjiOutJ: TempStr[2] = 'J'; break;
1348                                  case IdKanjiOutH: TempStr[2] = 'H'; break;                                  case IdKanjiOutH: TempStr[2] = 'H'; break;
1349                                  default:                                  default:
1350                                          TempStr[2] = 'B';                                          TempStr[2] = 'B';
1351                                  }                                  }
1352                                  TempLen = 3;                                  TempLen = 3;
1353                          }                          }
1354                          else TempLen = 0;                          else TempLen = 0;
1355    
1356                          if ((0xa0<d) && (d<0xe0))                          if ((0xa0<d) && (d<0xe0))
1357                          {                          {
1358                                  SendCodeNew = IdKatakana;                                  SendCodeNew = IdKatakana;
1359                                  if ((cv->SendCode!=IdKatakana) &&                                  if ((cv->SendCode!=IdKatakana) &&
1360                                          (cv->KanjiCodeSend==IdJIS) &&                                          (cv->KanjiCodeSend==IdJIS) &&
1361                                          (cv->JIS7KatakanaSend==1))                                          (cv->JIS7KatakanaSend==1))
1362                                  {                                  {
1363                                          TempStr[TempLen] = SO;                                          TempStr[TempLen] = SO;
1364                                          TempLen++;                                          TempLen++;
1365                                  }                                  }
1366                          }                          }
1367                          else {                          else {
1368                                  SendCodeNew = IdASCII;                                  SendCodeNew = IdASCII;
1369                                  if ((cv->SendCode==IdKatakana) &&                                  if ((cv->SendCode==IdKatakana) &&
1370                                          (cv->KanjiCodeSend==IdJIS) &&                                          (cv->KanjiCodeSend==IdJIS) &&
1371                                          (cv->JIS7KatakanaSend==1))                                          (cv->JIS7KatakanaSend==1))
1372                                  {                                  {
1373                                          TempStr[TempLen] = SI;                                          TempStr[TempLen] = SI;
1374                                          TempLen++;                                          TempLen++;
1375                                  }                                  }
1376                          }                          }
1377    
1378                          if (d==0x0d)                          if (d==0x0d)
1379                          {                          {
1380                                  TempStr[TempLen] = 0x0d;                                  TempStr[TempLen] = 0x0d;
1381                                  TempLen++;                                  TempLen++;
1382                                  if (cv->CRSend==IdCRLF)                                  if (cv->CRSend==IdCRLF)
1383                                  {                                  {
1384                                          TempStr[TempLen] = 0x0a;                                          TempStr[TempLen] = 0x0a;
1385                                          TempLen++;                                          TempLen++;
1386                                  }                                  }
1387                                  else if ((cv->CRSend==IdCR) &&                                  else if ((cv->CRSend==IdCR) &&
1388                                          cv->TelFlag && ! cv->TelBinSend)                                          cv->TelFlag && ! cv->TelBinSend)
1389                                  {                                  {
1390                                          TempStr[TempLen] = 0;                                          TempStr[TempLen] = 0;
1391                                          TempLen++;                                          TempLen++;
1392                                  }                                  }
1393                          }                          }
1394                          else if ((d>=0xa1) && (d<=0xe0))                          else if ((d>=0xa1) && (d<=0xe0))
1395                          {                          {
1396                                  /* Katakana */                                  /* Katakana */
1397                                  if (cv->KanjiCodeSend==IdEUC)                                  if (cv->KanjiCodeSend==IdEUC)
1398                                  {                                  {
1399                                          TempStr[TempLen] = (char)0x8E;                                          TempStr[TempLen] = (char)0x8E;
1400                                          TempLen++;                                          TempLen++;
1401                                  }                                  }
1402                                  if ((cv->KanjiCodeSend==IdJIS) &&                                  if ((cv->KanjiCodeSend==IdJIS) &&
1403                                          (cv->JIS7KatakanaSend==1))                                          (cv->JIS7KatakanaSend==1))
1404                                          TempStr[TempLen] = d & 0x7f;                                          TempStr[TempLen] = d & 0x7f;
1405                                  else                                  else
1406                                          TempStr[TempLen] = d;                                          TempStr[TempLen] = d;
1407                                  TempLen++;                                  TempLen++;
1408    
1409                                  // 半角カナはUnicodeでは2バイトになる (2004.10.4 yutaka)                                  // 半角カナはUnicodeでは2バイトになる (2004.10.4 yutaka)
1410                                  if (cv->KanjiCodeSend==IdUTF8) {                                  if (cv->KanjiCodeSend==IdUTF8) {
1411                                          TempLen = 0;                                          TempLen = 0;
1412                                          K = d;                                          K = d;
1413                                          OutputTextUTF8(K, TempStr, &TempLen, cv);                                          OutputTextUTF8(K, TempStr, &TempLen, cv);
1414                                  }                                  }
1415                          }                          }
1416                          else {                          else {
1417                                  TempStr[TempLen] = d;                                  TempStr[TempLen] = d;
1418                                  TempLen++;                                  TempLen++;
1419                                  if (cv->TelFlag && (d==0xff))                                  if (cv->TelFlag && (d==0xff))
1420                                  {                                  {
1421                                          TempStr[TempLen] = (char)0xff;                                          TempStr[TempLen] = (char)0xff;
1422                                          TempLen++;                                          TempLen++;
1423                                  }                                  }
1424                          }                          }
1425                  } // if (cv->SendKanjiFlag) else if ... else ... end                  } // if (cv->SendKanjiFlag) else if ... else ... end
1426    
1427                  if (TempLen == 0)                  if (TempLen == 0)
1428                  {                  {
1429                          i++;                          i++;
1430                          cv->SendCode = SendCodeNew;                          cv->SendCode = SendCodeNew;
1431                          cv->SendKanjiFlag = KanjiFlagNew;                          cv->SendKanjiFlag = KanjiFlagNew;
1432                  }                  }
1433                  else {                  else {
1434                          Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;                          Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1435                          if (! Full)                          if (! Full)
1436                          {                          {
1437                                  i++;                                  i++;
1438                                  cv->SendCode = SendCodeNew;                                  cv->SendCode = SendCodeNew;
1439                                  cv->SendKanjiFlag = KanjiFlagNew;                                  cv->SendKanjiFlag = KanjiFlagNew;
1440                                  CommRawOut(cv,TempStr,TempLen);                                  CommRawOut(cv,TempStr,TempLen);
1441                          }                          }
1442                  }                  }
1443    
1444          } // end of "while {}"          } // end of "while {}"
1445    
1446          return i;          return i;
1447  }  }
1448    
1449  int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)  int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1450  {  {
1451          int i, TempLen;          int i, TempLen;
1452          char TempStr[11];          char TempStr[11];
1453          BYTE d;          BYTE d;
1454          BOOL Full;          BOOL Full;
1455    
1456          if (! cv->Ready )          if (! cv->Ready )
1457                  return C;                  return C;
1458    
1459          if (cv->Language==IdJapanese)          if (cv->Language==IdJapanese)
1460                  return TextOutJP(cv,B,C);                  return TextOutJP(cv,B,C);
1461      if (cv->Language==IdKorean)         // HKS      if (cv->Language==IdKorean)         // HKS
1462         return TextOutKR(cv,B,C);         return TextOutKR(cv,B,C);
1463    
1464    
1465          Full = FALSE;          Full = FALSE;
1466          i = 0;          i = 0;
1467          while (! Full && (i < C)) {          while (! Full && (i < C)) {
1468                  TempLen = 0;                  TempLen = 0;
1469                  d = (BYTE)B[i];                  d = (BYTE)B[i];
1470                    
1471                  if (d==0x0d) {                  if (d==0x0d) {
1472                          TempStr[TempLen] = 0x0d;                          TempStr[TempLen] = 0x0d;
1473                          TempLen++;                          TempLen++;
1474                          if (cv->CRSend==IdCRLF) {                          if (cv->CRSend==IdCRLF) {
1475                                  TempStr[TempLen] = 0x0a;                                  TempStr[TempLen] = 0x0a;
1476                                  TempLen++;                                  TempLen++;
1477                          }                          }
1478                          else if ((cv->CRSend==IdCR) &&                          else if ((cv->CRSend==IdCR) &&
1479                                           cv->TelFlag && ! cv->TelBinSend) {                                           cv->TelFlag && ! cv->TelBinSend) {
1480                                  TempStr[TempLen] = 0;                                  TempStr[TempLen] = 0;
1481                                  TempLen++;                                  TempLen++;
1482                          }                          }
1483                  }                  }
1484                  else {                  else {
1485                          if ((cv->Language==IdRussian) &&                          if ((cv->Language==IdRussian) &&
1486                              (d>=128))                              (d>=128))
1487                                  d = RussConv(cv->RussClient,cv->RussHost,d);                                  d = RussConv(cv->RussClient,cv->RussHost,d);
1488                          TempStr[TempLen] = d;                          TempStr[TempLen] = d;
1489                          TempLen++;                          TempLen++;
1490                          if (cv->TelFlag && (d==0xff)) {                          if (cv->TelFlag && (d==0xff)) {
1491                                  TempStr[TempLen] = (char)0xff;                                  TempStr[TempLen] = (char)0xff;
1492                                  TempLen++;                                  TempLen++;
1493                          }                          }
1494                  }                  }
1495    
1496                  Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;                  Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1497                  if (! Full) {                  if (! Full) {
1498                          i++;                          i++;
1499                          CommRawOut(cv,TempStr,TempLen);                          CommRawOut(cv,TempStr,TempLen);
1500                  }                  }
1501          } // end of while {}          } // end of while {}
1502    
1503          return i;          return i;
1504  }  }
1505    
1506  int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)  int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1507  {  {
1508          int a, i, Len;          int a, i, Len;
1509          char d[3];          char d[3];
1510    
1511          if ( ! cv->Ready )          if ( ! cv->Ready )
1512                  return C;                  return C;
1513    
1514          if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {          if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1515                  memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);                  memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1516                  cv->InPtr = 0;                  cv->InPtr = 0;
1517          }          }
1518    
1519          i = 0;          i = 0;
1520          a = 1;          a = 1;
1521          while ((a>0) && (i<C)) {          while ((a>0) && (i<C)) {
1522                  Len = 0;                  Len = 0;
1523    
1524                  d[Len] = B[i];                  d[Len] = B[i];
1525                  Len++;                  Len++;
1526    
1527                  if ( cv->TelFlag && (B[i]=='\x0d') &&                  if ( cv->TelFlag && (B[i]=='\x0d') &&
1528                       ! cv->TelBinSend ) {                       ! cv->TelBinSend ) {
1529                          d[Len] = 0x00;                          d[Len] = 0x00;
1530                          Len++;                          Len++;
1531                  }                  }
1532    
1533                  if ( cv->TelFlag && (B[i]=='\xff') ) {                  if ( cv->TelFlag && (B[i]=='\xff') ) {
1534                          d[Len] = '\xff';                          d[Len] = '\xff';
1535                          Len++;                          Len++;
1536                  }                  }
1537    
1538                  if ( InBuffSize-cv->InBuffCount-Len >=0 ) {                  if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1539                          memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);                          memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1540                          cv->InBuffCount = cv->InBuffCount + Len;                          cv->InBuffCount = cv->InBuffCount + Len;
1541                          a = 1;                          a = 1;
1542                  }                  }
1543                  else                  else
1544                          a = 0;                          a = 0;
1545                  i = i + a;                  i = i + a;
1546          }          }
1547          return i;          return i;
1548  }  }
1549    
1550  int FAR PASCAL TextEchoJP(PComVar cv, PCHAR B, int C)  int FAR PASCAL TextEchoJP(PComVar cv, PCHAR B, int C)
1551  {  {
1552          int i, TempLen;          int i, TempLen;
1553          WORD K;          WORD K;
1554          char TempStr[11];          char TempStr[11];
1555          int EchoCodeNew;          int EchoCodeNew;
1556          BYTE d;          BYTE d;
1557          BOOL Full, KanjiFlagNew;          BOOL Full, KanjiFlagNew;
1558    
1559          Full = FALSE;          Full = FALSE;
1560          i = 0;          i = 0;
1561          while (! Full && (i < C)) {          while (! Full && (i < C)) {
1562                  TempLen = 0;                  TempLen = 0;
1563                  d = (BYTE)B[i];                  d = (BYTE)B[i];
1564                  EchoCodeNew = cv->EchoCode;                  EchoCodeNew = cv->EchoCode;
1565    
1566                  if (cv->EchoKanjiFlag) {                  if (cv->EchoKanjiFlag) {
1567                          KanjiFlagNew = FALSE;                          KanjiFlagNew = FALSE;
1568                          EchoCodeNew = IdKanji;                          EchoCodeNew = IdKanji;
1569    
1570                          K = (cv->EchoKanjiFirst << 8) + d;                          K = (cv->EchoKanjiFirst << 8) + d;
1571                          // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。                          // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1572                          if (cv->KanjiCodeSend == IdUTF8) {                          if (cv->KanjiCodeSend == IdUTF8) {
1573                                  OutputTextUTF8(K, TempStr, &TempLen, cv);                                  OutputTextUTF8(K, TempStr, &TempLen, cv);
1574                          }                          }
1575                          else {                          else {
1576                                  if (cv->KanjiCodeEcho == IdEUC)                                  if (cv->KanjiCodeEcho == IdEUC)
1577                                          K = SJIS2EUC(K);                                          K = SJIS2EUC(K);
1578                                  else if (cv->KanjiCodeEcho != IdSJIS)                                  else if (cv->KanjiCodeEcho != IdSJIS)
1579                                          K = SJIS2JIS(K);                                          K = SJIS2JIS(K);
1580    
1581                                  if ((cv->EchoCode==IdKatakana) &&                                  if ((cv->EchoCode==IdKatakana) &&
1582                                      (cv->KanjiCodeEcho==IdJIS) &&                                      (cv->KanjiCodeEcho==IdJIS) &&
1583                                      (cv->JIS7KatakanaEcho==1)) {                                      (cv->JIS7KatakanaEcho==1)) {
1584                                          TempStr[TempLen] = SI;                                          TempStr[TempLen] = SI;
1585                                          TempLen++;                                          TempLen++;
1586                                  }                                  }
1587    
1588                                  TempStr[TempLen] = HIBYTE(K);                                  TempStr[TempLen] = HIBYTE(K);
1589                                  TempStr[TempLen+1] = LOBYTE(K);                                  TempStr[TempLen+1] = LOBYTE(K);
1590                                  TempLen = TempLen + 2;                                  TempLen = TempLen + 2;
1591                          }                          }
1592                  }                  }
1593                  else if (IsDBCSLeadByteEx(*cv->CodePage, d)) {                  else if (IsDBCSLeadByteEx(*cv->CodePage, d)) {
1594                          KanjiFlagNew = TRUE;                          KanjiFlagNew = TRUE;
1595                          cv->EchoKanjiFirst = d;                          cv->EchoKanjiFirst = d;
1596                          EchoCodeNew = IdKanji;                          EchoCodeNew = IdKanji;
1597    
1598                          if ((cv->EchoCode!=IdKanji) &&                          if ((cv->EchoCode!=IdKanji) &&
1599                              (cv->KanjiCodeEcho==IdJIS)) {                              (cv->KanjiCodeEcho==IdJIS)) {
1600                                  TempStr[0] = 0x1B;                                  TempStr[0] = 0x1B;
1601                                  TempStr[1] = '$';                                  TempStr[1] = '$';
1602                                  if (cv->KanjiIn == IdKanjiInB)                                  if (cv->KanjiIn == IdKanjiInB)
1603                                          TempStr[2] = 'B';                                          TempStr[2] = 'B';
1604                                  else                                  else
1605                                          TempStr[2] = '@';                                          TempStr[2] = '@';
1606                                  TempLen = 3;                                  TempLen = 3;
1607                          }                          }
1608                          else                          else
1609                                  TempLen = 0;                                  TempLen = 0;
1610                  }                  }
1611                  else {                  else {
1612                          KanjiFlagNew = FALSE;                          KanjiFlagNew = FALSE;
1613    
1614                          if ((cv->EchoCode==IdKanji) &&                          if ((cv->EchoCode==IdKanji) &&
1615                              (cv->KanjiCodeEcho==IdJIS)) {                              (cv->KanjiCodeEcho==IdJIS)) {
1616                                  TempStr[0] = 0x1B;                                  TempStr[0] = 0x1B;
1617                                  TempStr[1] = '(';                                  TempStr[1] = '(';
1618                                  switch (cv->KanjiOut) {                                  switch (cv->KanjiOut) {
1619                                          case IdKanjiOutJ:                                          case IdKanjiOutJ:
1620                                                  TempStr[2] = 'J';                                                  TempStr[2] = 'J';
1621                                                  break;                                                  break;
1622                                          case IdKanjiOutH:                                          case IdKanjiOutH:
1623                                                  TempStr[2] = 'H';                                                  TempStr[2] = 'H';
1624                                                  break;                                                  break;
1625                                          default:                                          default:
1626                                                  TempStr[2] = 'B';                                                  TempStr[2] = 'B';
1627                                  }                                  }
1628                                  TempLen = 3;                                  TempLen = 3;
1629                          }                          }
1630                          else                          else
1631                                  TempLen = 0;                                  TempLen = 0;
1632    
1633                          if ((0xa0<d) && (d<0xe0)) {                          if ((0xa0<d) && (d<0xe0)) {
1634                                  EchoCodeNew = IdKatakana;                                  EchoCodeNew = IdKatakana;
1635                                  if ((cv->EchoCode!=IdKatakana) &&                                  if ((cv->EchoCode!=IdKatakana) &&
1636                                      (cv->KanjiCodeEcho==IdJIS) &&                                      (cv->KanjiCodeEcho==IdJIS) &&
1637                                      (cv->JIS7KatakanaEcho==1)) {                                      (cv->JIS7KatakanaEcho==1)) {
1638                                          TempStr[TempLen] = SO;                                          TempStr[TempLen] = SO;
1639                                          TempLen++;                                          TempLen++;
1640                                  }                                  }
1641                          }                          }
1642                          else {                          else {
1643                                  EchoCodeNew = IdASCII;                                  EchoCodeNew = IdASCII;
1644                                  if ((cv->EchoCode==IdKatakana) &&                                  if ((cv->EchoCode==IdKatakana) &&
1645                                      (cv->KanjiCodeEcho==IdJIS) &&                                      (cv->KanjiCodeEcho==IdJIS) &&
1646                                      (cv->JIS7KatakanaEcho==1)) {                                      (cv->JIS7KatakanaEcho==1)) {
1647                                          TempStr[TempLen] = SI;                                          TempStr[TempLen] = SI;
1648                                          TempLen++;                                          TempLen++;
1649                                  }                                  }
1650                          }                          }
1651    
1652                          if (d==0x0d) {                          if (d==0x0d) {
1653                                  TempStr[TempLen] = 0x0d;                                  TempStr[TempLen] = 0x0d;
1654                                  TempLen++;                                  TempLen++;
1655                                  if (cv->CRSend==IdCRLF) {                                  if (cv->CRSend==IdCRLF) {
1656                                          TempStr[TempLen] = 0x0a;                                          TempStr[TempLen] = 0x0a;
1657                                          TempLen++;                                          TempLen++;
1658                                  }                                  }
1659                                  else if ((cv->CRSend==IdCR) &&                                  else if ((cv->CRSend==IdCR) &&
1660                                                   cv->TelFlag && ! cv->TelBinSend) {                                                   cv->TelFlag && ! cv->TelBinSend) {
1661                                          TempStr[TempLen] = 0;                                          TempStr[TempLen] = 0;
1662                                          TempLen++;                                          TempLen++;
1663                                  }                                  }
1664                          }                          }
1665                          else if ((d>=0xa1) && (d<=0xe0)) {                          else if ((d>=0xa1) && (d<=0xe0)) {
1666                                  /* Katakana */                                  /* Katakana */
1667                                  if (cv->KanjiCodeEcho==IdEUC) {                                  if (cv->KanjiCodeEcho==IdEUC) {
1668                                          TempStr[TempLen] = (char)0x8E;                                          TempStr[TempLen] = (char)0x8E;
1669                                          TempLen++;                                          TempLen++;
1670                                  }                                  }
1671                                  if ((cv->KanjiCodeEcho==IdJIS) &&                                  if ((cv->KanjiCodeEcho==IdJIS) &&
1672                                      (cv->JIS7KatakanaEcho==1))                                      (cv->JIS7KatakanaEcho==1))
1673                                          TempStr[TempLen] = d & 0x7f;                                          TempStr[TempLen] = d & 0x7f;
1674                                  else                                  else
1675                                          TempStr[TempLen] = d;                                          TempStr[TempLen] = d;
1676                                  TempLen++;                                  TempLen++;
1677                          }                          }
1678                          else {                          else {
1679                                  TempStr[TempLen] = d;                                  TempStr[TempLen] = d;
1680                                  TempLen++;                                  TempLen++;
1681                                  if (cv->TelFlag && (d==0xff)) {                                  if (cv->TelFlag && (d==0xff)) {
1682                                          TempStr[TempLen] = (char)0xff;                                          TempStr[TempLen] = (char)0xff;
1683                                          TempLen++;                                          TempLen++;
1684                                  }                                  }
1685                          }                          }
1686                  } // if (cv->SendKanjiFlag) else if ... else ... end                  } // if (cv->SendKanjiFlag) else if ... else ... end
1687    
1688                  if (TempLen == 0) {                  if (TempLen == 0) {
1689                          i++;                          i++;
1690                          cv->EchoCode = EchoCodeNew;                          cv->EchoCode = EchoCodeNew;
1691                          cv->EchoKanjiFlag = KanjiFlagNew;                          cv->EchoKanjiFlag = KanjiFlagNew;
1692                  }                  }
1693                  else {                  else {
1694                          Full = InBuffSize-cv->InBuffCount-TempLen < 0;                          Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1695                          if (! Full) {                          if (! Full) {
1696                                  i++;                                  i++;
1697                                  cv->EchoCode = EchoCodeNew;                                  cv->EchoCode = EchoCodeNew;
1698                                  cv->EchoKanjiFlag = KanjiFlagNew;                                  cv->EchoKanjiFlag = KanjiFlagNew;
1699                                  memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);                                  memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1700                                  cv->InBuffCount = cv->InBuffCount + TempLen;                                  cv->InBuffCount = cv->InBuffCount + TempLen;
1701                          }                          }
1702                  }                  }
1703    
1704          } // end of "while {}"          } // end of "while {}"
1705    
1706          return i;          return i;
1707  }  }
1708    
1709  int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)  int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
1710  {  {
1711          int i, TempLen;          int i, TempLen;
1712          char TempStr[11];          char TempStr[11];
1713          BYTE d;          BYTE d;
1714          BOOL Full;          BOOL Full;
1715    
1716          if ( ! cv->Ready )          if ( ! cv->Ready )
1717                  return C;                  return C;
1718    
1719          if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {          if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1720                  memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);                  memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1721                  cv->InPtr = 0;                  cv->InPtr = 0;
1722          }          }
1723    
1724          if (cv->Language==IdJapanese)          if (cv->Language==IdJapanese)
1725                  return TextEchoJP(cv,B,C);                  return TextEchoJP(cv,B,C);
1726    
1727          Full = FALSE;          Full = FALSE;
1728          i = 0;          i = 0;
1729          while (! Full && (i < C)) {          while (! Full && (i < C)) {
1730                  TempLen = 0;                  TempLen = 0;
1731                  d = (BYTE)B[i];                  d = (BYTE)B[i];
1732    
1733                  if (d==0x0d) {                  if (d==0x0d) {
1734                          TempStr[TempLen] = 0x0d;                          TempStr[TempLen] = 0x0d;
1735                          TempLen++;                          TempLen++;
1736                          if (cv->CRSend==IdCRLF) {                          if (cv->CRSend==IdCRLF) {
1737                                  TempStr[TempLen] = 0x0a;                                  TempStr[TempLen] = 0x0a;
1738                                  TempLen++;                                  TempLen++;
1739                          }                          }
1740                          else if ((cv->CRSend==IdCR) &&                          else if ((cv->CRSend==IdCR) &&
1741                                   cv->TelFlag && ! cv->TelBinSend) {                                   cv->TelFlag && ! cv->TelBinSend) {
1742                                  TempStr[TempLen] = 0;                                  TempStr[TempLen] = 0;
1743                                  TempLen++;                                  TempLen++;
1744                          }                          }
1745                  }                  }
1746                  else {                  else {
1747                          if ((cv->Language==IdRussian) &&                          if ((cv->Language==IdRussian) &&
1748                              (d>=128))                              (d>=128))
1749                                  d = RussConv(cv->RussClient,cv->RussHost,d);                                  d = RussConv(cv->RussClient,cv->RussHost,d);
1750                          TempStr[TempLen] = d;                          TempStr[TempLen] = d;
1751                          TempLen++;                          TempLen++;
1752                          if (cv->TelFlag && (d==0xff)) {                          if (cv->TelFlag && (d==0xff)) {
1753                                  TempStr[TempLen] = (char)0xff;                                  TempStr[TempLen] = (char)0xff;
1754                                  TempLen++;                                  TempLen++;
1755                          }                          }
1756                  }                  }
1757    
1758                  Full = InBuffSize-cv->InBuffCount-TempLen < 0;                  Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1759                  if (! Full) {                  if (! Full) {
1760                          i++;                          i++;
1761                          memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);                          memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1762                          cv->InBuffCount = cv->InBuffCount + TempLen;                          cv->InBuffCount = cv->InBuffCount + TempLen;
1763                  }                  }
1764          } // end of while {}          } // end of while {}
1765    
1766          return i;          return i;
1767  }  }
1768    
1769  // listup serial port driver  // listup serial port driver
1770  // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661  // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
1771  // (2007.8.17 yutaka)  // (2007.8.17 yutaka)
1772  static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)  static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
1773  {  {
1774          GUID ClassGuid[1];          GUID ClassGuid[1];
1775          DWORD dwRequiredSize;          DWORD dwRequiredSize;
1776          BOOL bRet;          BOOL bRet;
1777          HDEVINFO DeviceInfoSet = NULL;          HDEVINFO DeviceInfoSet = NULL;
1778          SP_DEVINFO_DATA DeviceInfoData;          SP_DEVINFO_DATA DeviceInfoData;
1779          DWORD dwMemberIndex = 0;          DWORD dwMemberIndex = 0;
1780          int i;          int i;
1781    
1782          DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);          DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
1783    
1784          // 以前のメモリをフリーしておく          // 以前のメモリをフリーしておく
1785          for (i = 0 ; i < ComPortMax ; i++) {          for (i = 0 ; i < ComPortMax ; i++) {
1786                  free(ComPortDesc[i]);                  free(ComPortDesc[i]);
1787                  ComPortDesc[i] = NULL;                  ComPortDesc[i] = NULL;
1788          }          }
1789    
1790  // Get ClassGuid from ClassName for PORTS class  // Get ClassGuid from ClassName for PORTS class
1791          bRet =          bRet =
1792                  SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,                  SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
1793                                            &dwRequiredSize);                                            &dwRequiredSize);
1794          if (!bRet)          if (!bRet)
1795                  goto cleanup;                  goto cleanup;
1796    
1797  // Get class devices  // Get class devices
1798          // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている          // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている
1799          // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)          // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)
1800          DeviceInfoSet =          DeviceInfoSet =
1801                  SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);                  SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
1802    
1803          if (DeviceInfoSet) {          if (DeviceInfoSet) {
1804  // Enumerate devices  // Enumerate devices
1805                  dwMemberIndex = 0;                  dwMemberIndex = 0;
1806                  while (SetupDiEnumDeviceInfo                  while (SetupDiEnumDeviceInfo
1807                             (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {                             (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
1808                          TCHAR szFriendlyName[MAX_PATH];                          TCHAR szFriendlyName[MAX_PATH];
1809                          TCHAR szPortName[MAX_PATH];                          TCHAR szPortName[MAX_PATH];
1810                          //TCHAR szMessage[MAX_PATH];                          //TCHAR szMessage[MAX_PATH];
1811                          DWORD dwReqSize = 0;                          DWORD dwReqSize = 0;
1812                          DWORD dwPropType;                          DWORD dwPropType;
1813                          DWORD dwType = REG_SZ;                          DWORD dwType = REG_SZ;
1814                          HKEY hKey = NULL;                          HKEY hKey = NULL;
1815    
1816  // Get friendlyname  // Get friendlyname
1817                          bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,                          bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
1818                                                                  &DeviceInfoData,                                                                  &DeviceInfoData,
1819                                                                  SPDRP_FRIENDLYNAME,                                                                  SPDRP_FRIENDLYNAME,
1820                                                                  &dwPropType,                                                                  &dwPropType,
1821                                                                  (LPBYTE)                                                                  (LPBYTE)
1822                                                                  szFriendlyName,                                                                  szFriendlyName,
1823                                                                  sizeof(szFriendlyName),                                                                  sizeof(szFriendlyName),
1824                                                                  &dwReqSize);                                                                  &dwReqSize);
1825    
1826  // Open device parameters reg key  // Open device parameters reg key
1827                          hKey = SetupDiOpenDevRegKey(DeviceInfoSet,                          hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
1828                                                      &DeviceInfoData,                                                      &DeviceInfoData,
1829                                                      DICS_FLAG_GLOBAL,                                                      DICS_FLAG_GLOBAL,
1830                                                      0, DIREG_DEV, KEY_READ);                                                      0, DIREG_DEV, KEY_READ);
1831                          if (hKey) {                          if (hKey) {
1832  // Qurey for portname  // Qurey for portname
1833                                  long lRet;                                  long lRet;
1834                                  dwReqSize = sizeof(szPortName);                                  dwReqSize = sizeof(szPortName);
1835                                  lRet = RegQueryValueEx(hKey,                                  lRet = RegQueryValueEx(hKey,
1836                                                         _T("PortName"),                                                         _T("PortName"),
1837                                                         0,                                                         0,
1838                                                         &dwType,                                                         &dwType,
1839                                                         (LPBYTE) & szPortName,                                                         (LPBYTE) & szPortName,
1840                                                         &dwReqSize);                                                         &dwReqSize);
1841    
1842  // Close reg key  // Close reg key
1843                                  RegCloseKey(hKey);                                  RegCloseKey(hKey);
1844                          }                          }
1845    
1846  #if 0  #if 0
1847                          sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,                          sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
1848                                  szPortName);                                  szPortName);
1849                          printf("%s\n", szMessage);                          printf("%s\n", szMessage);
1850  #endif  #endif
1851    
1852                          if (_strnicmp(szPortName, "COM", 3) == 0) {  // COMポートドライバを発見                          if (_strnicmp(szPortName, "COM", 3) == 0) {  // COMポートドライバを発見
1853                                  int port = atoi(&szPortName[3]);                                  int port = atoi(&szPortName[3]);
1854                                  int i;                                  int i;
1855    
1856                                  for (i = 0 ; i < comports ; i++) {                                  for (i = 0 ; i < comports ; i++) {
1857                                          if (ComPortTable[i] == port) {  // 接続を確認                                          if (ComPortTable[i] == port) {  // 接続を確認
1858                                                  ComPortDesc[i] = _strdup(szFriendlyName);                                                  ComPortDesc[i] = _strdup(szFriendlyName);
1859                                                  break;                                                  break;
1860                                          }                                          }
1861                                  }                                  }
1862                          }                          }
1863    
1864                  }                  }
1865          }          }
1866    
1867    cleanup:    cleanup:
1868  // Destroy device info list  // Destroy device info list
1869          SetupDiDestroyDeviceInfoList(DeviceInfoSet);          SetupDiDestroyDeviceInfoList(DeviceInfoSet);
1870  }  }
1871    
1872    
1873  int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)  int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
1874  {  {
1875          HMODULE h;          HMODULE h;
1876          TCHAR   devicesBuff[65535];          TCHAR   devicesBuff[65535];
1877          TCHAR   *p;          TCHAR   *p;
1878          int     comports = 0;          int     comports = 0;
1879          int     i, j, min;          int     i, j, min;
1880          WORD    s;          WORD    s;
1881    
1882          if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&          if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
1883              (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&              (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
1884              (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {              (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
1885                  p = devicesBuff;                  p = devicesBuff;
1886                  while (*p != '\0') {                  while (*p != '\0') {
1887                          if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {                          if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
1888                                  ComPortTable[comports++] = atoi(p+3);                                  ComPortTable[comports++] = atoi(p+3);
1889                                  if (comports >= ComPortMax)                                  if (comports >= ComPortMax)
1890                                          break;                                          break;
1891                          }                          }
1892                          p += (strlen(p)+1);                          p += (strlen(p)+1);
1893                  }                  }
1894    
1895                  for (i=0; i<comports-1; i++) {                  for (i=0; i<comports-1; i++) {
1896                          min = i;                          min = i;
1897                          for (j=i+1; j<comports; j++)                          for (j=i+1; j<comports; j++)
1898                                  if (ComPortTable[min] > ComPortTable[j])                                  if (ComPortTable[min] > ComPortTable[j])
1899                                          min = j;                                          min = j;
1900                          if (min != i) {                          if (min != i) {
1901                                  s = ComPortTable[i];                                  s = ComPortTable[i];
1902                                  ComPortTable[i] = ComPortTable[min];                                  ComPortTable[i] = ComPortTable[min];
1903                                  ComPortTable[min] = s;                                  ComPortTable[min] = s;
1904                          }                          }
1905                  }                  }
1906          }          }
1907          else {          else {
1908  #if 1  #if 1
1909                  for (i=1; i<=ComPortMax; i++) {                  for (i=1; i<=ComPortMax; i++) {
1910                          FILE *fp;                          FILE *fp;
1911                          char buf[11]; // \\.\COMxxx + NULL                          char buf[11]; // \\.\COMxxx + NULL
1912                          _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);                          _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
1913                          if ((fp = fopen(buf, "r")) != NULL) {                          if ((fp = fopen(buf, "r")) != NULL) {
1914                                  fclose(fp);                                  fclose(fp);
1915                                  ComPortTable[comports++] = i;                                  ComPortTable[comports++] = i;
1916                          }                          }
1917                  }                  }
1918  #else  #else
1919                  comports = -1;                  comports = -1;
1920  #endif  #endif
1921          }          }
1922    
1923          ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);          ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
1924    
1925          return comports;          return comports;
1926  }  }
1927    
1928  BOOL WINAPI DllMain(HANDLE hInstance,  BOOL WINAPI DllMain(HANDLE hInstance,
1929                      ULONG ul_reason_for_call,                      ULONG ul_reason_for_call,
1930                      LPVOID lpReserved)                      LPVOID lpReserved)
1931  {  {
1932          switch( ul_reason_for_call ) {          switch( ul_reason_for_call ) {
1933                  case DLL_THREAD_ATTACH:                  case DLL_THREAD_ATTACH:
1934                          /* do thread initialization */                          /* do thread initialization */
1935                          break;                          break;
1936                  case DLL_THREAD_DETACH:                  case DLL_THREAD_DETACH:
1937                          /* do thread cleanup */                          /* do thread cleanup */
1938                          break;                          break;
1939                  case DLL_PROCESS_ATTACH:                  case DLL_PROCESS_ATTACH:
1940                          /* do process initialization */                          /* do process initialization */
1941                          DoCover_IsDebuggerPresent();                          DoCover_IsDebuggerPresent();
1942                          hInst = hInstance;                          hInst = hInstance;
1943                          HMap = CreateFileMapping(                          HMap = CreateFileMapping(
1944                                  (HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,                                  (HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,
1945                                  0, sizeof(TMap), TT_FILEMAPNAME);                                  0, sizeof(TMap), TT_FILEMAPNAME);
1946                          if (HMap == NULL)                          if (HMap == NULL)
1947                                  return FALSE;                                  return FALSE;
1948                          FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);                          FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);
1949    
1950                          pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);                          pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);
1951                          if (pm == NULL)                          if (pm == NULL)
1952                                  return FALSE;                                  return FALSE;
1953                          break;                          break;
1954                  case DLL_PROCESS_DETACH:                  case DLL_PROCESS_DETACH:
1955                          /* do process cleanup */                          /* do process cleanup */
1956                          UnmapViewOfFile(pm);                          UnmapViewOfFile(pm);
1957                          CloseHandle(HMap);                          CloseHandle(HMap);
1958                          break;                          break;
1959          }          }
1960          return TRUE;          return TRUE;
1961  }  }
Legend:
Removed from v.3221  
changed lines
  Added in v.3227
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help