Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
minitel.c
Package: win2ksrc.rar　[view]
Upload User: caisha3
Upload Date: 2013-09-21
Package Size: 208739k
Code Size: 49k
Category:

Windows Develop

Development Platform:

Visual C++

minitel.c：Code Content
  1. /* File: D:wackeremuminitel.c (Created: 05-Mar-1994)
  2.  *
  3.  * Copyright 1994, 1998 by Hilgraeve Inc. -- Monroe, MI
  4.  * All rights reserved
  5.  *
  6.  * $Revision: 2 $
  7.  * $Date: 2/05/99 3:20p $
  8.  */
  10. #include <windows.h>
  11. #pragma hdrstop
  13. #include <time.h>
  15. #include <tdllstdtyp.h>
  16. #include <tdlltdll.h>
  17. #include <tdllsession.h>
  18. #include <tdllcloop.h>
  19. #include <tdllprint.h>
  20. #include <tdllcapture.h>
  21. #include <tdllassert.h>
  22. #include <tdllmc.h>
  23. #include <tdllupdate.h>
  24. #include <tdllchars.h>
  25. #include <tdllcnct.h>
  26. #include <tdllterm.h>
  27. #include <tdllbackscrl.h>
  28. #include <tdlltchar.h>
  29. #include <termres.h>
  31. #include "emu.h"
  32. #include "emu.hh"
  33. #include "emuid.h"
  34. #include "minitel.hh"
  35. #include "keytbls.h"
  38. #if defined(INCL_MINITEL)
  40. static void emuMinitelRedisplayLine(const HHEMU hhEmu,
  41. const int row,
  42. const int col);
  44. static int minitel_kbdin(const HHEMU hhEmu, int key, const int fTest);
  45. static ECHAR minitelMapMosaics(const HHEMU hhEmu, ECHAR ch);
  46. static void minitelFullScrnReveal(const HHEMU hhEmu);
  47. static void minitelFullScrnConceal(const HHEMU hhEmu);
  48. static void minitelSS2(const HHEMU hhEmu);
  49. static void minitelSS2Part2(const HHEMU hhEmu);
  50. static void minitelInsMode(const HHEMU hhEmu);
  51. static void minitelPRO1(const HHEMU hhEmu);
  52. static void minitelPRO2Part1(const HHEMU hhEmu);
  53. static void minitelPRO2Part2(const HHEMU hhEmu);
  54. static void minitelStatusReply(const HHEMU hhEmu);
  56. /*
  57. Here begins the famed and fabled Minitel emulator. Abandon all hope
  58. all ye who..., well you get the idea.  The Minitel emulator uses a
  59. combination of character attributes and field attributes.  See the
  60. book "minitel 1B" for description of field attributes. Page numbers
  61. referenced in this code refer to the before mentioned book. - mrw
  62. */
  64. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  65.  * FUNCTION:
  66.  * emuMinitelInit
  67.  *
  68.  * DESCRIPTION:
  69.  * Startup routine for the minitel emulator.
  70.  *
  71.  * ARGUMENTS:
  72.  * hhEmu - private emulator handle.
  73.  *
  74.  * RETURNS:
  75.  * void
  76.  *
  77.  */
  78. void emuMinitelInit(const HHEMU hhEmu)
  79. {
  80. int i;
  81. LOGFONT lf;
  82. HWND hwndTerm;
  83. PSTMTPRIVATE pstPRI;
  85. static struct trans_entry const minitel_tbl[] =
  86. {
  87. {NEW_STATE, 0, 0, 0}, // 0
  88. {0, ETEXT('x00'), ETEXT('x01'), nothing},
  89. {0, ETEXT('x20'), ETEXT('x7F'), minitelGraphic},
  90. {1, ETEXT('x1B'), ETEXT('x1B'), nothing},
  91. {0, ETEXT('x07'), ETEXT('x07'), emu_bell},
  93. {0, ETEXT('b'),   ETEXT('b'), minitelBackspace},
  94. {0, ETEXT('t'),   ETEXT('t'), minitelHorzTab},
  95. {0, ETEXT('n'),   ETEXT('n'), minitelLinefeed},
  96. {0, ETEXT('x0B'), ETEXT('x0B'), minitelVerticalTab},
  97. {0, ETEXT('x0C'), ETEXT('x0C'), minitelFormFeed},
  98. {0, ETEXT('r'),   ETEXT('r'), carriagereturn},
  99. {0, ETEXT('x0E'), ETEXT('x0F'), minitelCharSet},  // change char set
  100. {0, ETEXT('x11'), ETEXT('x11'), minitelCursorOn}, // cursor on
  101. {5, ETEXT('x12'), ETEXT('x12'), nothing},   // repeat
  102. {12,ETEXT('x13'), ETEXT('x13'), nothing},   // SEP
  103. {0, ETEXT('x14'), ETEXT('x14'), minitelCursorOff},// cursor off
  104. {20,ETEXT('x16'), ETEXT('x16'), nothing},   // SS2 (undocumented)
  105. {0, ETEXT('x18'), ETEXT('x18'), minitelCancel},   // cancel
  106. {20,ETEXT('x19'), ETEXT('x19'), nothing},    // SS2
  107. {0, ETEXT('x1C'), ETEXT('x1C'), nothing}, // really is nothing.
  108. {13,ETEXT('x1D'), ETEXT('x1D'), nothing}, // SS3,X ingnored, p99, 1.2.7
  109. {0, ETEXT('x1E'), ETEXT('x1E'), minitelRecordSeparator},
  110. {3, ETEXT('x1F'), ETEXT('x1F'), nothing}, // Unit Seperator
  111. //{0, ETEXT('x7F'), ETEXT('x7F'), minitelDel},
  113. {NEW_STATE, 0, 0, 0}, // 1 - seen ESC
  114. {1, ETEXT('x00'), ETEXT('x00'), nothing},
  115. {0, ETEXT('x01'), ETEXT('x1F'), minitelResync},
  116. {18,ETEXT('x23'), ETEXT('x23'), nothing},
  117. {14,ETEXT('x25'), ETEXT('x25'), nothing},
  118. {13,ETEXT('x35'), ETEXT('x37'), nothing}, // eat ESC,35-37,X sequences
  119. {6, ETEXT('x39'), ETEXT('x39'), nothing}, // PROT1, p134
  120. {7, ETEXT('x3A'), ETEXT('x3A'), nothing}, // PROT2, p134
  121. {8, ETEXT('x3B'), ETEXT('x3B'), nothing}, // PROT3, p134
  122. {2, ETEXT('x5B'), ETEXT('x5B'), ANSI_Pn_Clr},
  123. {0, ETEXT('x40'), ETEXT('x49'), emuMinitelCharAttr}, // forground color, flashing
  124. {0, ETEXT('x4C'), ETEXT('x4F'), emuMinitelCharAttr}, // char width & height
  125. {0, ETEXT('x50'), ETEXT('x5A'), emuMinitelFieldAttr},// background, underlining
  126. {0, ETEXT('x5F'), ETEXT('x5F'), emuMinitelFieldAttr},// reveal display
  127. {0, ETEXT('x5C'), ETEXT('x5D'), emuMinitelCharAttr}, // inverse
  128. {0, ETEXT('x61'), ETEXT('x61'), minitelCursorReport},
  129. {22,ETEXT('x20'), ETEXT('x2F'), nothing}, // p.99 ISO 2022
  131. {NEW_STATE, 0, 0, 0}, // 2 - seen ESC [
  132. {2, ETEXT('x00'), ETEXT('x00'), nothing},
  133. {2, ETEXT('x30'), ETEXT('x39'), ANSI_Pn},
  134. {2, ETEXT('x3B'), ETEXT('x3B'), ANSI_Pn_End},
  135. {2, ETEXT('x3A'), ETEXT('x3F'), ANSI_Pn},
  136. {0, ETEXT('x40'), ETEXT('x40'), minitelInsChars},
  137. {0, ETEXT('x41'), ETEXT('x41'), minitelCursorUp},
  138. {0, ETEXT('x42'), ETEXT('x42'), ANSI_CUD},
  139. {0, ETEXT('x43'), ETEXT('x43'), ANSI_CUF},
  140. {0, ETEXT('x44'), ETEXT('x44'), ANSI_CUB},
  141. {0, ETEXT('x48'), ETEXT('x48'), minitelCursorDirect},
  142. {0, ETEXT('x4A'), ETEXT('x4A'), minitelClrScrn},
  143. {0, ETEXT('x4B'), ETEXT('x4B'), minitelClrLn},
  144. {0, ETEXT('x4C'), ETEXT('x4C'), minitelInsRows},
  145. {0, ETEXT('x4D'), ETEXT('x4D'), minitelDelRows},
  146. {0, ETEXT('x50'), ETEXT('x50'), minitelDelChars},
  147. {0, ETEXT('x68'), ETEXT('x69'), minitelInsMode},
  148. {0, ETEXT('x7A'), ETEXT('x7B'), nothing}, //* p144 12.2
  149. {0, ETEXT('x7D'), ETEXT('x7D'), nothing}, //* p144 12.2
  150. {0, ETEXT('x7F'), ETEXT('x7F'), minitelResetTerminal}, //* p145, 13.2
  152. {NEW_STATE, 0, 0, 0}, // 3 - unit separtor character position
  153. {3, ETEXT('x00'), ETEXT('x00'), nothing},
  154. {4, ETEXT('x01'), ETEXT('xFF'), minitelUSRow},
  156. {NEW_STATE, 0, 0, 0}, // 4 - end of unit separtor character position
  157. {4, ETEXT('x00'), ETEXT('x00'), nothing},
  158. {0, ETEXT('x01'), ETEXT('xFF'), minitelUSCol},
  160. {NEW_STATE, 0, 0, 0}, // 5 - number of repeats
  161. {5, ETEXT('x00'), ETEXT('x00'), nothing},
  162. {0, ETEXT('x40'), ETEXT('x7F'), minitelRepeat},
  163. {0, ETEXT('x00'), ETEXT('xFF'), minitelResync},
  165. {NEW_STATE, 0, 0, 0}, // 6 - Protocol 1 sequence (PRO1,X)
  166. {6, ETEXT('x00'), ETEXT('x00'), nothing},
  167. {0, ETEXT('x01'), ETEXT('xFF'), minitelPRO1},
  169. {NEW_STATE, 0, 0, 0}, // 7 - Protocol 2 sequence (PRO2,X,Y)
  170. {7, ETEXT('x00'), ETEXT('x00'), nothing},
  171. {8, ETEXT('x01'), ETEXT('xFF'), minitelPRO2Part1},
  173. {NEW_STATE, 0, 0, 0}, // 8 - Protocol 2 sequence (PRO2,X,Y)
  174. {8, ETEXT('x00'), ETEXT('x00'), nothing},
  175. {0, ETEXT('x01'), ETEXT('xFF'), minitelPRO2Part2},
  177. {NEW_STATE, 0, 0, 0}, // 9 - Protocol 3 sequence (PRO3,X,Y,Z)
  178. {9, ETEXT('x00'), ETEXT('x00'), nothing},
  179. {10,ETEXT('x01'), ETEXT('xFF'), nothing},
  181. {NEW_STATE, 0, 0, 0}, // 10 - Protocol 3 sequence (PRO3,X,Y,Z)
  182. {10,ETEXT('x00'), ETEXT('x00'), nothing},
  183. {11,ETEXT('x01'), ETEXT('xFF'), nothing},
  185. {NEW_STATE, 0, 0, 0}, // 11 - Protocol 3 sequence (PRO3,X,Y,Z)
  186. {11,ETEXT('x00'), ETEXT('x00'), nothing},
  187. {0, ETEXT('x01'), ETEXT('xFF'), nothing},
  189. {NEW_STATE, 0, 0, 0}, // 12 - SEP
  190. {12,ETEXT('x00'), ETEXT('x00'), nothing},
  191. {0, ETEXT('x01'), ETEXT('xFF'), nothing},
  193. {NEW_STATE, 0, 0, 0}, // 13 - ESC,35-39,X sequences eaten, p99, 1.2.7
  194. {13,ETEXT('x00'), ETEXT('x00'), nothing},
  195. {0, ETEXT('x01'), ETEXT('xFF'), nothing},
  197. {NEW_STATE, 0, 0, 0}, // 14 - screen transparency mode
  198. {15,ETEXT('x1B'), ETEXT('x1B'), nothing},
  199. {14,ETEXT('x00'), ETEXT('xFF'), nothing},
  200. {23,ETEXT('x20'), ETEXT('x2F'), nothing}, // could be ISO 2022
  202. {NEW_STATE, 0, 0, 0}, // 15 - screen transparency mode continued, seen ESC
  203. {16,ETEXT('x25'), ETEXT('x25'), nothing},
  204. {17,ETEXT('x2F'), ETEXT('x2F'), nothing},
  205. {15,ETEXT('x00'), ETEXT('x00'), nothing},
  206. {14,ETEXT('x00'), ETEXT('xFF'), nothing},
  208. {NEW_STATE, 0, 0, 0}, // 16 - screen transparency mode continued, seen ESC x25
  209. {0, ETEXT('x40'), ETEXT('x40'), nothing},
  210. {16,ETEXT('x00'), ETEXT('x00'), nothing},
  211. {14,ETEXT('x00'), ETEXT('xFF'), nothing},
  213. {NEW_STATE, 0, 0, 0}, // 17 - screen transparency mode continued, seen ESC x2F
  214. {0, ETEXT('x3F'), ETEXT('x3F'), nothing},
  215. {17,ETEXT('x00'), ETEXT('x00'), nothing},
  216. {14,ETEXT('x00'), ETEXT('xFF'), nothing},
  218. {NEW_STATE, 0, 0, 0}, // 18 - Full screen reveal/hide, seen ESC x23
  219. {18,ETEXT('x00'), ETEXT('x00'), nothing},
  220. {19,ETEXT('x20'), ETEXT('x20'), nothing},
  221. {23,ETEXT('x20'), ETEXT('x2F'), nothing}, // could be ISO 2022
  223. {NEW_STATE, 0, 0, 0}, // 19 - Full screen reveal/hide, seen ESC x23 x20
  224. {19,ETEXT('x00'), ETEXT('x00'), nothing},
  225. {0, ETEXT('x58'), ETEXT('x58'), minitelFullScrnConceal},
  226. {0, ETEXT('x5F'), ETEXT('x5F'), minitelFullScrnReveal},
  228. {NEW_STATE, 0, 0, 0}, // 20 - SS2
  229. {20,ETEXT('x00'), ETEXT('x00'), nothing},
  230. {0, ETEXT('x00'), ETEXT('x1F'), minitelResync},
  231. {21,ETEXT('x20'), ETEXT('x7F'), minitelSS2}, // valid SS2
  233. {NEW_STATE, 0, 0, 0}, // 21 - SS2 part 2
  234. {21,ETEXT('x00'), ETEXT('x00'), nothing},
  235. {0, ETEXT('x20'), ETEXT('x7F'), minitelSS2Part2}, // valid SS2
  237. {NEW_STATE, 0, 0, 0}, // 22 - p.99 ISO 2022
  238. {23,ETEXT('x20'), ETEXT('x2F'), nothing},
  239. {0, ETEXT('x00'), ETEXT('x1F'), minitelResync},
  241. {NEW_STATE, 0, 0, 0}, // 23 - p.99 ISO 2022
  242. {24,ETEXT('x20'), ETEXT('x2F'), nothing},
  243. {0, ETEXT('x00'), ETEXT('x1F'), minitelResync},
  245. {NEW_STATE, 0, 0, 0}, // 24 - p.99 ISO 2022
  246. {25, ETEXT('x30'), ETEXT('x3F'), nothing}, // page 107.
  247. {0,  ETEXT('x30'), ETEXT('x7E'), nothing}, // final character
  248. {0,  ETEXT('x00'), ETEXT('x1F'), minitelResync},
  250. {NEW_STATE, 0, 0, 0}, // 25 - p.99 ISO 2022
  251. {0,  ETEXT('x0D'), ETEXT('x0D'), nothing}, // page 107. eat CR
  252. {0,  ETEXT('x00'), ETEXT('x7F'), minitelResync},
  253. };
  255. if (hhEmu == 0)
  256. {
  257. assert(0);
  258. return;
  259. }
  261. emuInstallStateTable(hhEmu, minitel_tbl, DIM(minitel_tbl));
  263. // Allocate and initialize private data for Minitel emulator.
  264. //
  265. if (hhEmu->pvPrivate != 0)
  266. {
  267. free(hhEmu->pvPrivate);
  268. hhEmu->pvPrivate = 0;
  269. }
  271. hhEmu->pvPrivate = malloc(sizeof(MTPRIVATE));
  273. if (hhEmu->pvPrivate == 0)
  274. {
  275. assert(FALSE);
  276. return;
  277. }
  279. pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  280. memset(pstPRI, 0, sizeof(MTPRIVATE));
  282. pstPRI->minitel_last_char = ETEXT(' ');
  284. /* load key array */
  286. emuKeyTableLoad(hhEmu, Minitel_KeyTable,
  287.  sizeof(Minitel_KeyTable)/sizeof(KEYTBLSTORAGE),
  288.  &hhEmu->stEmuKeyTbl);
  290. /* --- Allocate attribute buffer for Minitel junk --- */
  292. pstPRI->apstMT = malloc(MAX_EMUROWS * sizeof(PSTMINITEL));
  294. if (pstPRI->apstMT == 0)
  295. {
  296. assert(FALSE);
  297. return;
  298. }
  300. memset(pstPRI->apstMT, 0, MAX_EMUROWS * sizeof(PSTMINITEL));
  302. for (i = 0 ; i < MAX_EMUROWS ; ++i)
  303. {
  304. pstPRI->apstMT[i] = malloc(MAX_EMUCOLS * sizeof(STMINITEL));
  306. if (pstPRI->apstMT[i] == 0)
  307. {
  308. assert(FALSE);
  309. return;
  310. }
  312. memset(pstPRI->apstMT[i], 0, MAX_EMUCOLS * sizeof(STMINITEL));
  313. }
  315. /* --- Setup defaults --- */
  317. hhEmu->emu_maxrow = 24;     // 25 line emulator
  318. hhEmu->emu_maxcol = 39;     // start in 40 column mode
  319. hhEmu->top_margin = 1;    // access to row 0 is restricted.
  320. hhEmu->bottom_margin = hhEmu->emu_maxrow; // this has to equal emu_maxrow which changed
  322. hhEmu->emu_kbdin = minitel_kbdin;
  323. hhEmu->emu_graphic = minitelGraphic;
  324. hhEmu->emu_deinstall = emuMinitelDeinstall;
  325. hhEmu->emu_ntfy = minitelNtfy;
  326. hhEmu->emuHomeHostCursor = minitelHomeHostCursor;
  327. #ifdef INCL_TERMINAL_SIZE_AND_COLORS
  328.     hhEmu->emu_setscrsize = emuMinitelSetScrSize;
  329. #endif
  330. hhEmu->emu_highchar = (TCHAR)0xFF;
  332. if (hhEmu->emu_currow == 0)
  333. (*hhEmu->emu_setcurpos)(hhEmu, 1, hhEmu->emu_curcol - 1);
  335. // Also, set font to Arial Alternative
  336. //
  337. memset(&lf, 0, sizeof(LOGFONT));
  338. hwndTerm = sessQueryHwndTerminal(hhEmu->hSession);
  339. termGetLogFont(hwndTerm, &lf);
  341. if (StrCharCmpi(lf.lfFaceName, "Arial Alternative") != 0)
  342. {
  343. StrCharCopy(lf.lfFaceName, "Arial Alternative");
  344. lf.lfCharSet = DEFAULT_CHARSET;
  345. lf.lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
  346. termSetLogFont(hwndTerm, &lf);
  347. }
  349. // Backscrol not supported in minitel
  350. //
  351. backscrlSetUNumLines(sessQueryBackscrlHdl(hhEmu->hSession), 0);
  353. // Initialize colors for the Minitel.
  354. //
  355. std_setcolors(hhEmu, VC_BRT_WHITE, VC_BLACK);
  357. // Set terminal to power-up state
  358. //
  359. minitelResetTerminal(hhEmu);
  361. // Turn backscroll off for minitels
  362. //
  363. backscrlSetShowFlag(sessQueryBackscrlHdl(hhEmu->hSession), FALSE);
  365. // Enable Minitel toolbar buttons
  366. //
  367. PostMessage(sessQueryHwnd(hhEmu->hSession), WM_SESS_SHOW_SIDEBAR, 0, 0);
  368. return;
  369. }
  371. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  372.  * FUNCTION:
  373.  * emuMinitelDeinstall
  374.  *
  375.  * DESCRIPTION:
  376.  * Frees the extra attribute buffer needed to manage serial attributes.
  377.  *
  378.  * ARGUMENTS:
  379.  * hhEmu - private emulator handle.
  380.  *
  381.  * RETURNS:
  382.  * void
  383.  *
  384.  */
  385. void emuMinitelDeinstall(const HHEMU hhEmu)
  386. {
  387. int i;
  388. PSTMTPRIVATE pstPRI;
  390. assert(hhEmu);
  391. pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  393. if (pstPRI)
  394. {
  395. if (pstPRI->apstMT)
  396. {
  397. for (i = 0 ; i < MAX_EMUROWS ; ++i)
  398. {
  399. if (pstPRI->apstMT[i])
  400. {
  401. free(pstPRI->apstMT[i]);
  402. pstPRI->apstMT[i] = NULL;
  403. }
  404. }
  406. free(pstPRI->apstMT);
  407. pstPRI->apstMT = 0;
  408. }
  410. free(hhEmu->pvPrivate);
  411. hhEmu->pvPrivate = 0;
  412. }
  414. // Hide Minitel toolbar buttons
  415. //
  416. ShowWindow(sessQuerySidebarHwnd(hhEmu->hSession), SW_HIDE);
  417. return;
  418. }
  420. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  421.  * FUNCTION:
  422.  * minitelReset
  423.  *
  424.  * DESCRIPTION:
  425.  * Sets emulator to an initial state. Used for record and unit
  426.  * separators.
  427.  *
  428.  * ARGUMENTS:
  429.  * hhEmu - private emulator handle.
  430.  *
  431.  * RETURNS:
  432.  * void
  433.  *
  434.  */
  435. void minitelReset(const HHEMU hhEmu)
  436. {
  437. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  439. pstPRI->minitelG1Active = FALSE;
  441. memset(&hhEmu->emu_charattr, 0, sizeof(hhEmu->emu_charattr));
  442. hhEmu->emu_charattr.txtclr = VC_BRT_WHITE;
  443. hhEmu->emu_charattr.bkclr = VC_BLACK;
  445. pstPRI->apstMT[hhEmu->emu_imgrow][hhEmu->emu_curcol].isattr = 0;
  447. memset(&pstPRI->stLatentAttr, 0, sizeof(pstPRI->stLatentAttr));
  448. pstPRI->stLatentAttr.fBkClr = TRUE;
  450. hhEmu->attrState[CS_STATE] =
  451. hhEmu->attrState[CSCLEAR_STATE] = hhEmu->emu_charattr;
  453. hhEmu->emu_clearattr = hhEmu->emu_charattr;
  454. minitelNtfy(hhEmu, 0);
  455. return;
  456. }
  458. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  459.  * FUNCTION:
  460.  * minitelGraphic
  461.  *
  462.  * DESCRIPTION:
  463.  * Handles displayable characters.
  464.  *
  465.  * ARGUMENTS:
  466.  * hhEmu - private emulator handle.
  467.  *
  468.  * RETURNS:
  469.  * void
  470.  *
  471.  */
  472. void minitelGraphic(const HHEMU hhEmu)
  473. {
  474. ECHAR ccode;
  475. ECHAR aechBuf[10];
  476. int r;
  477. int row = hhEmu->emu_currow;
  478. int col = hhEmu->emu_curcol;
  479. BOOL fRedisplay = FALSE;
  480.     BOOL fDblHi;
  481. STATTR stAttr;
  483. ECHAR *tp = hhEmu->emu_apText[hhEmu->emu_imgrow];
  484. const PSTATTR ap = hhEmu->emu_apAttr[hhEmu->emu_imgrow];
  485. const HUPDATE hUpdate = sessQueryUpdateHdl(hhEmu->hSession);
  486. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  488. ccode = hhEmu->emu_code;
  490. if (ccode == 0)
  491. return;
  493. pstPRI->minitel_last_char = ccode;
  495. if (hhEmu->mode_IRM == SET)
  496. {
  497. if (col < hhEmu->emu_maxcol)
  498. {
  499. memmove(&tp[col+1], &tp[col],
  500. (unsigned)(hhEmu->emu_maxcol-col) * sizeof(ECHAR));
  502. memmove(&ap[col+1], &ap[col],
  503. (unsigned)(hhEmu->emu_maxcol-col) * sizeof(STATTR));
  505. memmove(&pstPRI->apstMT[hhEmu->emu_imgrow][col+1],
  506. &pstPRI->apstMT[hhEmu->emu_imgrow][col],
  507. (unsigned)(hhEmu->emu_maxcol-col) * sizeof(STMINITEL));
  508. }
  509. }
  511. /* --- check if we are overwriting an attribute space --- */
  513. if (pstPRI->apstMT[hhEmu->emu_imgrow][col].isattr)
  514. {
  515. pstPRI->apstMT[hhEmu->emu_imgrow][col].isattr = FALSE;
  516. fRedisplay = TRUE;
  517. }
  519. /* --- If we receive a space and have latent attributes, validate --- */
  521. if (ccode == ETEXT('x20') && pstPRI->stLatentAttr.fModified
  522. && pstPRI->minitelG1Active == FALSE)
  523. {
  524. r = hhEmu->emu_imgrow;
  526. // Color
  527. //
  528. pstPRI->apstMT[r][col].fbkclr = pstPRI->stLatentAttr.fBkClr;
  529. pstPRI->apstMT[r][col].bkclr = pstPRI->stLatentAttr.bkclr;
  531. // Conceal
  532. //
  533. pstPRI->apstMT[r][col].conceal = pstPRI->stLatentAttr.conceal;
  535. // Underline
  536. //
  537. pstPRI->apstMT[r][col].undrln = pstPRI->stLatentAttr.undrln;
  539. pstPRI->apstMT[hhEmu->emu_imgrow][col].isattr  = TRUE;
  541. // This is truely wierd.  We don't reset the fBkclr, fConceal, or
  542. // fUndrln fields, only the fModified flag.  Thus if any serial
  543. // attributes are set, all latent values get updated.  The only
  544. // guy who appears to be able to turn off an attribute is the
  545. // mosaic character which validates the background color and sets
  546. // the fBkClr flag to false.  I can't think of a reason why it
  547. // should work this way.  Pretty damn confusing if you ask me. - mrw
  548. //
  549. pstPRI->stLatentAttr.fModified = FALSE;
  550.     fRedisplay = TRUE;
  551. }
  553. /* --- If we switched to G1, map char to location in new font --- */
  555. if (pstPRI->minitelG1Active)
  556. ccode = minitelMapMosaics(hhEmu, ccode);
  558. pstPRI->apstMT[hhEmu->emu_imgrow][col].ismosaic =
  559. (unsigned)pstPRI->minitelG1Active;
  561. /* --- If we switched to semigraphic mode, validate the background --- */
  563. if (pstPRI->minitelG1Active)
  564. {
  565. // Guess what? Latent background color is always adopted for mosaics.
  566. // This is a major undocumented find.  Basicly, mosaics
  567. // (semigraphics) always use the latent background color regardless
  568. // of the validation state.
  569. //
  570. ap[col].bkclr = pstPRI->stLatentAttr.bkclr;
  571. fRedisplay = TRUE;
  573. // Something tricky here.  Reception of a mosaic validates the
  574. // background color.  Validate means adopt the color.  It also
  575. // means that if we shift back to the alpha (G0 char set) and
  576. // recieve a space, we DON'T validate the background color a
  577. // second time.  So we keep a seperate flag for the background
  578. // color validation. - mrw
  579. //
  580. pstPRI->stLatentAttr.fBkClr = FALSE;
  581. }
  583. /* --- Normal character processing --- */
  585. tp[col] = ccode;
  587. // Update the end of row index if necessary.
  588. //
  589. if (col > hhEmu->emu_aiEnd[hhEmu->emu_imgrow])
  590. hhEmu->emu_aiEnd[hhEmu->emu_imgrow] = col;
  592. /* --- Find out this characters current attributes and adjust --- */
  594. stAttr = GetAttr(hhEmu, row, col);
  595. ap[col] = hhEmu->emu_charattr;
  596. ap[col].bkclr = stAttr.bkclr;
  597. ap[col].blank = stAttr.blank;
  598. ap[col].undrln = stAttr.undrln;
  600. if (pstPRI->minitelG1Active)
  601. ap[col].symbol = 1;
  603. // Documented: 0x7F (mosaic or alpha) always maps to 0x5F in the G1
  604. // character set (solid block).
  605. //
  606. if (tp[col] == ETEXT('x7F'))
  607. {
  608. tp[col] = ETEXT('x5F');
  609. ap[col].symbol = 1;
  610. }
  612. /* --- Double high stuff --- */
  614. if (hhEmu->emu_charattr.dblhilo)
  615. {
  616. if (row >= 2)
  617. {
  618. r = row_index(hhEmu, row-1);
  620. hhEmu->emu_apText[r][col] = ccode;
  621. hhEmu->emu_apAttr[r][col] = ap[col];
  622. hhEmu->emu_apAttr[r][col].dblhilo = 0;
  623. hhEmu->emu_apAttr[r][col].dblhihi = 1;
  624. pstPRI->apstMT[r][col] = pstPRI->apstMT[hhEmu->emu_imgrow][col];
  625. updateChar(hUpdate, row-1, col, col);
  626. }
  627. }
  629. /* --- Double wide stuff --- */
  631. if (hhEmu->emu_charattr.dblwilf)
  632. {
  633. if (row > 0 && col < hhEmu->emu_maxcol)
  634. {
  635. tp[col+1] = ccode;
  636. ap[col+1] = ap[col];
  637. ap[col+1].dblwilf = 0;
  638. ap[col+1].dblwirt = 1;
  640. // Major league bug.
  641. //
  642. pstPRI->apstMT[hhEmu->emu_imgrow][col+1] =
  643. pstPRI->apstMT[hhEmu->emu_imgrow][col];
  644. }
  646. if (hhEmu->emu_charattr.dblhilo)
  647. {
  648. r = row_index(hhEmu, row-1);
  650. hhEmu->emu_apText[r][col+1] = ccode;
  651. hhEmu->emu_apAttr[r][col+1] = ap[col];
  652. hhEmu->emu_apAttr[r][col+1].dblwilf = 0;
  653. hhEmu->emu_apAttr[r][col+1].dblwirt = 1;
  654. hhEmu->emu_apAttr[r][col+1].dblhilo = 0;
  655. hhEmu->emu_apAttr[r][col+1].dblhihi = 1;
  656. pstPRI->apstMT[r][col+1] = pstPRI->apstMT[hhEmu->emu_imgrow][col];
  657. }
  658. }
  660. /* --- Need to use old row and column --- */
  662. if (fRedisplay)
  663. emuMinitelRedisplayLine(hhEmu, row, col);
  665. /* --- Need to bump the column guy an extra notch if double wide --- */
  667. if (hhEmu->emu_charattr.dblwilf)
  668. {
  669. col += 1;
  670. hhEmu->emu_aiEnd[hhEmu->emu_imgrow] = col;
  671. }
  673. updateChar(hUpdate, row, hhEmu->emu_curcol, col);
  675. /* --- bump column position, check for wrap, etc. --- */
  677. if (++col > hhEmu->emu_maxcol)
  678. {
  679. // Escape code 0x18 is referred to as cancel in the minitel doco.
  680. // It fills from the cursor pos to the end of the row with blanks.
  681. // Note: Also, it does not force wrap in anyway since
  682. // the cursor position is not updated. That's why we have to
  683. // check here. - mrw:5/3/95
  684. //
  685. if (pstPRI->fInCancel || row == 0)
  686. {
  687. col = hhEmu->emu_maxcol;
  688. return;
  689. }
  691. printEchoString(hhEmu->hPrintEcho, tp,
  692. emuRowLen(hhEmu, hhEmu->emu_imgrow));
  694. CnvrtMBCStoECHAR(aechBuf, sizeof(aechBuf), TEXT("rn"),
  695. StrCharGetByteCount(TEXT("rn")));
  697. printEchoString(hhEmu->hPrintEcho, aechBuf, sizeof(ECHAR) * 2);
  699. CaptureLine(sessQueryCaptureFileHdl(hhEmu->hSession), CF_CAP_LINES,
  700. tp, emuRowLen(hhEmu, hhEmu->emu_imgrow));
  702.         // Wrap around accounts for double high
  703. //
  704. fDblHi = (BOOL)hhEmu->emu_charattr.dblhilo;
  706. if (row == hhEmu->bottom_margin)
  707. {
  708. if (pstPRI->fScrollMode)
  709. minitel_scrollup(hhEmu, fDblHi ? 2 : 1);
  711. else
  712. row = fDblHi ? 2 : 1;
  713. }
  715. else if (row != 0)
  716. {
  717. row += fDblHi ? 2 : 1;
  719. if (row > hhEmu->emu_maxrow)
  720.                 row = 2;
  721. }
  723. col = 0;
  724. }
  726. // Finally, set the cursor position.  This will reset emu_currow
  727. // and emu_curcol.
  728. //
  729. (*hhEmu->emu_setcurpos)(hhEmu, row, col);
  730. return;
  731. }
  733. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  734.  * FUNCTION:
  735.  * emuMinitelRedisplayLine
  736.  *
  737.  * DESCRIPTION:
  738.  * The trick to field attributes is when you encounter one, you need to
  739.  * update the rest of the line that follows since changing or overwriting
  740.  * an attribute space affects stuff to the right.
  741.  *
  742.  * ARGUMENTS:
  743.  * hhEmu - private emulator handle.
  744.  * int row - row to redisplay
  745.  * int col - start column
  746.  *
  747.  * RETURNS:
  748.  * void
  749.  *
  750.  */
  751. static void emuMinitelRedisplayLine(const HHEMU hhEmu,
  752. const int row,
  753. const int col)
  754. {
  755. int i = row_index(hhEmu, row);
  756.     int fDblHi = FALSE;
  757. const ECHAR *tp = hhEmu->emu_apText[i];
  758. const PSTATTR ap = hhEmu->emu_apAttr[i];
  759. const PSTATTR apl = hhEmu->emu_apAttr[row_index(hhEmu, row-1)];
  760. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  761. const PSTMINITEL pstMT = pstPRI->apstMT[i];
  763. for (i = col ; i <= hhEmu->emu_maxcol ; ++i)
  764. {
  765. ap[i] = GetAttr(hhEmu, row, i);
  767. // Here's a wierd one.  Attribute spaces (as opposed to plain spaces)
  768. // validate but do not display the underline attribute.  I suspect
  769. // something similar with seperated mosaics. - mrw
  771. if (tp[i] == ETEXT('x20') && pstMT[i].isattr)
  772. ap[i].undrln = 0;
  774.         // If we're redisplaying a row that has a double hi character,
  775.         // then we have to redisplay the upper-half as well.
  777.         if (ap[i].dblhilo)
  778.             {
  779.             fDblHi = TRUE;
  780. apl[i] = GetAttr(hhEmu, row-1, i);
  781.             }
  782. }
  784. if (fDblHi)
  785. {
  786. updateChar(sessQueryUpdateHdl(hhEmu->hSession),
  787. row-1, col, hhEmu->emu_maxcol);
  788. }
  790. updateChar(sessQueryUpdateHdl(hhEmu->hSession),
  791. row, col, hhEmu->emu_maxcol);
  793. return;
  794. }
  796. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  797.  * FUNCTION:
  798.  * GetAttr
  799.  *
  800.  * DESCRIPTION:
  801.  * Walks the current row and builds a composite attribute based on
  802.  * the encountered attribute spaces.
  803.  *
  804.  * ARGUMENTS:
  805.  * hhEmu - private emulator handle.
  806.  * iRow - logical row
  807.  * iCol - logical col
  808.  *
  809.  * RETURNS:
  810.  * composite attribute.
  811.  *
  812.  */
  813. STATTR GetAttr(const HHEMU hhEmu, const int iRow, const int iCol)
  814. {
  815. int i;
  816. STATTR stAttr;
  817. const int r = row_index(hhEmu, iRow);
  818. const PSTATTR ap = hhEmu->emu_apAttr[r];
  819. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  820. const PSTMINITEL pstMT = pstPRI->apstMT[r];
  822. stAttr = hhEmu->emu_apAttr[r][iCol];
  823. stAttr.bkclr = 0;
  824. stAttr.undrln = 0;
  825. stAttr.blank = 0;
  827. for (i = 0 ; i <= iCol ; ++i)
  828. {
  829.         // Mosaics validate the background color.  Do it first however,
  830.         // because an attribute space can change it to something else.
  832. if (pstMT[i].ismosaic)
  833. stAttr.bkclr = ap[i].bkclr;
  835. if (pstMT[i].isattr)
  836. {
  837. if (pstMT[i].fbkclr)
  838. stAttr.bkclr = pstMT[i].bkclr;
  840. stAttr.undrln = pstMT[i].undrln;
  841. stAttr.blank = pstMT[i].conceal;
  842. }
  844. // Mosaics always cancel underlining.
  845. //
  846. if (pstMT[i].ismosaic)
  847. stAttr.undrln = 0;
  848. }
  850. return stAttr;
  851. }
  853. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  854.  * FUNCTION:
  855.  * emuMinitelCharAttr
  856.  *
  857.  * DESCRIPTION:
  858.  * Modifies the current character attribute.  Does not affect field
  859.  * attributes.
  860.  *
  861.  * mrw - 11/1/94: Went to high intensity colors to more closely match
  862.  * the minitel colors.
  863.  *
  864.  * ARGUMENTS:
  865.  * hhEmu - private emulator handle.
  866.  *
  867.  * RETURNS:
  868.  * void
  869.  *
  870.  */
  871. void emuMinitelCharAttr(const HHEMU hhEmu)
  872. {
  873. STATTR stAttr = hhEmu->attrState[CS_STATE];
  874. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  876. switch (hhEmu->emu_code)
  877. {
  878. case ETEXT('x40'):  stAttr.txtclr = 0;  break;
  879. case ETEXT('x41'):  stAttr.txtclr = 12; /*4*/ break;
  880. case ETEXT('x42'):  stAttr.txtclr = 10; /*2*/ break;
  881. case ETEXT('x43'):  stAttr.txtclr = 14; /*6*/ break;
  882. case ETEXT('x44'):  stAttr.txtclr = 9;  /*1*/ break;
  883. case ETEXT('x45'):  stAttr.txtclr = 13; /*5*/ break;
  884. case ETEXT('x46'):  stAttr.txtclr = 11; /*3*/ break;
  885. case ETEXT('x47'):  stAttr.txtclr = 15; break;
  887. case ETEXT('x48'):  stAttr.blink  = 1;  break;
  888. case ETEXT('x49'):  stAttr.blink  = 0;  break;
  890. case ETEXT('x4C'): // normal size
  891. if (pstPRI->minitelG1Active)
  892. return;
  894. stAttr.dblhilo = 0;
  895. stAttr.dblwilf = 0;
  896. break;
  898. case ETEXT('x4D'): // double height
  899. if (pstPRI->minitelG1Active || hhEmu->emu_currow <= 1)
  900. return;
  902. stAttr.dblhilo= 1;
  903. stAttr.dblwilf = 0;
  904. break;
  906. case ETEXT('x4E'): // double width
  907. if (pstPRI->minitelG1Active || hhEmu->emu_currow < 1)
  908. return;
  910. stAttr.dblhilo = 0;
  911. stAttr.dblwilf = 1;
  912. break;
  914. case ETEXT('x4F'): // double size
  915. if (pstPRI->minitelG1Active || hhEmu->emu_currow <= 1)
  916. return;
  918. stAttr.dblhilo = 1;
  919. stAttr.dblwilf = 1;
  920. break;
  922. case ETEXT(ETEXT('x5C')):    // normal polarity
  923. if (pstPRI->minitelG1Active)
  924. return;
  926. stAttr.revvid = 0;
  927. break;
  929. case ETEXT(ETEXT('x5D')):    // reverse polarity
  930. if (pstPRI->minitelG1Active)
  931. return;
  933. stAttr.revvid = 1;
  934. break;
  936. default:
  937. break;
  938. }
  940. /* --- commit changes --- */
  942. hhEmu->emu_charattr =
  943. hhEmu->attrState[CS_STATE] =
  944. hhEmu->attrState[CSCLEAR_STATE] = stAttr;
  946. hhEmu->attrState[CSCLEAR_STATE].revvid = 0;
  947. hhEmu->attrState[CSCLEAR_STATE].undrln = 0;
  949. hhEmu->emu_clearattr = hhEmu->attrState[CSCLEAR_STATE];
  950. return;
  951. }
  953. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  954.  * FUNCTION:
  955.  * emuMinitelFieldAttr
  956.  *
  957.  * DESCRIPTION:
  958.  * Dreaded field attributes.  Actually, this routine updates what is
  959.  * called a Latent Attribute. The attributes only become effective
  960.  * when a space is recieved.  Who invents this stupid stuff anyways?
  961.  *
  962.  * mrw - 11/1/94: Went to high intensity colors to more closely match
  963.  * the minitel colors.
  964.  *
  965.  * ARGUMENTS:
  966.  * hhEmu - private emulator handle.
  967.  *
  968.  * RETURNS:
  969.  * void
  970.  *
  971.  */
  972. void emuMinitelFieldAttr(const HHEMU hhEmu)
  973. {
  974. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  975. LATENTATTR * const pstLA = &pstPRI->stLatentAttr;
  977. switch (hhEmu->emu_code)
  978. {
  979. case ETEXT('x50'):  pstLA->bkclr = 0;  break;
  980. case ETEXT('x51'):  pstLA->bkclr = 12;  break;
  981. case ETEXT('x52'):  pstLA->bkclr = 10;  break;
  982. case ETEXT('x53'):  pstLA->bkclr = 14;  break;
  983. case ETEXT('x54'):  pstLA->bkclr = 9;  break;
  984. case ETEXT('x55'):  pstLA->bkclr = 13;  break;
  985. case ETEXT('x56'):  pstLA->bkclr = 11;  break;
  986. case ETEXT('x57'):  pstLA->bkclr = 15;  break;
  988. case ETEXT('x58'):  pstLA->conceal=1;  break;
  989. case ETEXT('x5F'):  pstLA->conceal=0;  break;
  991. case ETEXT('x59'): // separated mosaics off
  992. if (pstPRI->minitelG1Active)
  993. {
  994. pstPRI->minitelUseSeparatedMosaics = 0;
  995. return;
  996. }
  998. else
  999. {
  1000. pstPRI->stLatentAttr.undrln = 0;
  1001. }
  1002. break;
  1004. case ETEXT('x5A'): // separated mosaics on
  1005. if (pstPRI->minitelG1Active)
  1006. {
  1007. pstPRI->minitelUseSeparatedMosaics = 1;
  1008. return;
  1009. }
  1011. else
  1012. {
  1013. pstPRI->stLatentAttr.undrln = 1;
  1014. }
  1015. break;
  1017. default:
  1018.     return;
  1019. }
  1021. // Undocumented: setting any field attribute invalidates the
  1022. // latent color context.
  1023. //
  1024. pstPRI->stLatentAttr.fBkClr = TRUE;
  1026. pstPRI->stLatentAttr.fModified = TRUE;
  1027. return;
  1028. }
  1030. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  1031.  * minitel_kbdin
  1032.  *
  1033.  * DESCRIPTION:
  1034.  *  Processes keys for the minitel emulator.
  1035.  *
  1036.  * ARGUMENTS:
  1037.  * hhEmu - private emulator handle.
  1038.  * key  - key to process
  1039.  *
  1040.  * RETURNS:
  1041.  *  nothing
  1042.  */
  1043. static int minitel_kbdin(const HHEMU hhEmu, int key, const int fTest)
  1044. {
  1045. int index;
  1046. TCHAR c;
  1047. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1049. if ((index = emuKbdKeyLookup(hhEmu, key, &hhEmu->stEmuKeyTbl)) != -1)
  1050. {
  1051. if (!fTest)
  1052. {
  1053. emuSendKeyString(hhEmu, index, &hhEmu->stEmuKeyTbl);
  1055. // This completes the code sent by emuSendKeyString(), page 124
  1056. //
  1057. if (key == (VK_RIGHT | VIRTUAL_KEY | SHIFT_KEY) ||
  1058. key == (VK_RIGHT | VIRTUAL_KEY | SHIFT_KEY | EXTENDED_KEY))
  1059. {
  1060. c = (pstPRI->minitelSecondDep) ? TEXT('x6c') : TEXT('x68');
  1062. CLoopCharOut(sessQueryCLoopHdl(hhEmu->hSession), c);
  1063. }
  1065. // Check for disconnect key.  If hit twice consecutively,
  1066. // it posts a disconnect to the modem guy.
  1067. //
  1068. if (key == (VK_F9 | VIRTUAL_KEY))
  1069. {
  1070. pstPRI->F9 += 1;
  1073. if (pstPRI->F9 == 2)
  1074. {
  1075. PostMessage(sessQueryHwnd(hhEmu->hSession),
  1076. WM_DISCONNECT, 0, 0);
  1077. }
  1078. }
  1079. }
  1080. }
  1082. else
  1083. {
  1084. // reset F9 counter, must have two consecutive to disconnect
  1085. //
  1086. pstPRI->F9 = 0;
  1087. index = std_kbdin(hhEmu, key, fTest);
  1088. }
  1090. return index;
  1091. }
  1093. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1094.  * FUNCTION:
  1095.  * minitelCharSet
  1096.  *
  1097.  * DESCRIPTION:
  1098.  * We don't really switch character sets here.  Since minitel uses
  1099.  * 7 bit ASCII, we can user the half of the ASCII table for the
  1100.  * contigous and seperated mosaics that comprise the G1 char set.
  1101.  * Other rule here is that switching the the G1 character set
  1102.  * validates the background color on reception of the first mosaic.
  1103.  * One thing I haven't figured out yet is when a field attribute is
  1104.  * validated, does the latent attribute get reset or retain the last color?
  1105.  *
  1106.  * ARGUMENTS:
  1107.  * hhEmu - private emulator handle.
  1108.  *
  1109.  * RETURNS:
  1110.  * void
  1111.  *
  1112.  */
  1113. void minitelCharSet(const HHEMU hhEmu)
  1114. {
  1115. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1117. pstPRI->stLatentAttr.undrln = 0;
  1119. if (hhEmu->emu_code == ETEXT(0x0E)) // switch to G1
  1120. {
  1121. pstPRI->minitelG1Active = TRUE;
  1122. pstPRI->minitelUseSeparatedMosaics = FALSE;
  1123. }
  1125. else
  1126. {
  1127. pstPRI->minitelG1Active = FALSE;
  1128. }
  1130. // underline, size and polarity attributes permanently canceled.
  1131. //
  1132. hhEmu->emu_charattr.undrln = 0;
  1133. hhEmu->emu_charattr.dblhihi = 0;
  1134. hhEmu->emu_charattr.dblhilo = 0;
  1135. hhEmu->emu_charattr.dblwilf = 0;
  1136. hhEmu->emu_charattr.dblwirt = 0;
  1137. hhEmu->emu_charattr.revvid = 0;
  1138. hhEmu->emu_charattr.symbol = 0;
  1140. hhEmu->attrState[CS_STATE] =
  1141. hhEmu->attrState[CSCLEAR_STATE] = hhEmu->emu_charattr;
  1143. hhEmu->emu_clearattr = hhEmu->emu_charattr;
  1145. return;
  1146. }
  1148. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1149.  * FUNCTION:
  1150.  * minitelResetTerminal
  1151.  *
  1152.  * DESCRIPTION:
  1153.  * Response to a 1B 39 7F sequence.  Puts terminal in power-up state.
  1154.  *
  1155.  * ARGUMENTS:
  1156.  * hhEmu - private emulator handle.
  1157.  *
  1158.  * RETURNS:
  1159.  * void
  1160.  *
  1161.  */
  1162. void minitelResetTerminal(const HHEMU hhEmu)
  1163. {
  1164. minitelClearScreen(hhEmu, 0);  // clear screen
  1165. (*hhEmu->emu_setcurpos)(hhEmu, 0, 0);
  1167. minitelClearLine(hhEmu, 0);    // clear line 0
  1168. (*hhEmu->emu_setcurpos)(hhEmu, 1, 0);
  1170. minitelReset(hhEmu);  // reset attributes
  1172. ((PSTMTPRIVATE)hhEmu->pvPrivate)->fScrollMode = 0;
  1173. EmuStdSetCursorType(hhEmu, EMU_CURSOR_NONE);
  1174. minitelNtfy(hhEmu, 0);
  1175. return;
  1176. }
  1178. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1179.  * FUNCTION:
  1180.  * minitelCursorOn
  1181.  *
  1182.  * DESCRIPTION:
  1183.  * Turns minitel cursor on.
  1184.  *
  1185.  * ARGUMENTS:
  1186.  * hhEmu - private emulator handle.
  1187.  *
  1188.  * RETURNS:
  1189.  * void
  1190.  *
  1191.  */
  1192. void minitelCursorOn(const HHEMU hhEmu)
  1193. {
  1194. EmuStdSetCursorType(hhEmu, EMU_CURSOR_BLOCK);
  1195. return;
  1196. }
  1198. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1199.  * FUNCTION:
  1200.  * minitelCursorOff
  1201.  *
  1202.  * DESCRIPTION:
  1203.  * Turns minitel cursor off
  1204.  *
  1205.  * ARGUMENTS:
  1206.  * hhEmu - private emulator handle.
  1207.  *
  1208.  * RETURNS:
  1209.  * void
  1210.  *
  1211.  */
  1212. void minitelCursorOff(const HHEMU hhEmu)
  1213. {
  1214. #if defined(NDEBUG)
  1215. EmuStdSetCursorType(hhEmu, EMU_CURSOR_NONE);
  1216. #else
  1217. EmuStdSetCursorType(hhEmu, EMU_CURSOR_BLOCK);
  1218. #endif
  1220. return;
  1221. }
  1223. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1224.  * FUNCTION:
  1225.  * mintelMapMosaics
  1226.  *
  1227.  * DESCRIPTION:
  1228.  * Maps regular character to a mosaic char for our font only.
  1229.  *
  1230.  * ARGUMENTS:
  1231.  * hhEmu - private emulator handle.
  1232.  * ch - character to convert
  1233.  *
  1234.  * RETURNS:
  1235.  * converted or original character.
  1236.  *
  1237.  */
  1238. static ECHAR minitelMapMosaics(const HHEMU hhEmu, ECHAR ch)
  1239. {
  1240. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1242. if (ch >= ETEXT('x21') && ch <= ETEXT('x3F'))
  1243. ch += ETEXT('x1F');
  1245. // Another weird undocumented affect.  Columns 4 and 5 (except 5F)
  1246. // map to columns 6 and 7 (page 101)
  1247.     //
  1248. else if (ch >= ETEXT('x40') && ch <= ETEXT('x5E'))
  1249. ch += ETEXT('x20');
  1251. else if (ch >= ETEXT('x60') && ch <= ETEXT('x7E'))
  1252. ch += 0;
  1254. if (pstPRI->minitelUseSeparatedMosaics && ch >= ETEXT('x21') &&
  1255. ch <= ETEXT('x7F'))
  1256. {
  1257. ch += ETEXT('x40');
  1258. }
  1260. return ch;
  1261. }
  1263. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1264.  * FUNCTION:
  1265.  * minitelCursorReport
  1266.  *
  1267.  * DESCRIPTION:
  1268.  * Return the current cursor location as US row col.
  1269.  *
  1270.  * ARGUMENTS:
  1271.  * hhEmu - private emulator handle.
  1272.  *
  1273.  * RETURNS:
  1274.  * void
  1275.  *
  1276.  */
  1277. void minitelCursorReport(const HHEMU hhEmu)
  1278. {
  1279. TCHAR ach[40];
  1280. ECHAR aech[40];
  1282. wsprintf(ach, TEXT("US%c%c"), hhEmu->emu_currow, hhEmu->emu_curcol);
  1284. CnvrtMBCStoECHAR(aech, sizeof(aech), ach,
  1285.         StrCharGetByteCount(ach) + sizeof(TCHAR));
  1287. emuSendString(hhEmu, aech, StrCharGetEcharByteCount(aech));
  1288. return;
  1289. }
  1291. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1292.  * FUNCTION:
  1293.  * minitelFullScrnConceal
  1294.  *
  1295.  * DESCRIPTION:
  1296.  * Just sets the blank bits on all the attributes.
  1297.  *
  1298.  * ARGUMENTS:
  1299.  * hhEmu - private emulator handle.
  1300.  *
  1301.  * RETURNS:
  1302.  * void
  1303.  *
  1304.  */
  1305. static void minitelFullScrnConceal(const HHEMU hhEmu)
  1306. {
  1307. int i, j;
  1308. PSTATTR ap;
  1310. for (i = 1 ; i <= hhEmu->emu_maxrow ; ++i)
  1311. {
  1312. ap = hhEmu->emu_apAttr[row_index(hhEmu, i)];
  1314. for (j = 0 ; j <= hhEmu->emu_maxcol ; ++j, ++ap)
  1315. ap->blank = 1;
  1317. updateLine(sessQueryUpdateHdl(hhEmu->hSession),
  1318. 1, hhEmu->emu_maxrow);
  1319. }
  1321. return;
  1322. }
  1324. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1325.  * FUNCTION:
  1326.  * minitelFullScrnReveal
  1327.  *
  1328.  * DESCRIPTION:
  1329.  * Just sets the blank bits on all the attributes.
  1330.  *
  1331.  * ARGUMENTS:
  1332.  * hhEmu - private emulator handle.
  1333.  *
  1334.  * RETURNS:
  1335.  * void
  1336.  *
  1337.  */
  1338. static void minitelFullScrnReveal(const HHEMU hhEmu)
  1339. {
  1340. int i, j;
  1341. PSTATTR ap;
  1343. for (i = 1 ; i <= hhEmu->emu_maxrow ; ++i)
  1344. {
  1345. ap = hhEmu->emu_apAttr[row_index(hhEmu, i)];
  1347. for (j = 0 ; j <= hhEmu->emu_maxcol ; ++j, ++ap)
  1348. ap->blank = 0;
  1349. }
  1351. updateLine(sessQueryUpdateHdl(hhEmu->hSession), 1, hhEmu->emu_maxrow);
  1353. return;
  1354. }
  1356. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1357.  * FUNCTION:
  1358.  * minitelResync
  1359.  *
  1360.  * DESCRIPTION:
  1361.  * Certain codes will cause the emulator to resynchronize, (goto state
  1362.  * zero) and play the character thru.
  1363.  *
  1364.  * ARGUMENTS:
  1365.  * hhEmu - private emulator handle.
  1366.  *
  1367.  * RETURNS:
  1368.  * void
  1369.  *
  1370.  */
  1371. void minitelResync(const HHEMU hhEmu)
  1372. {
  1373. hhEmu->state = 0;
  1374. #if defined(EXTENDED_FEATURES)
  1375. (void)(*hhEmu->emu_datain)(hhEmu, hhEmu->emu_code);
  1376. #else
  1377. (void)(*hhEmu->emu_datain)((HEMU)hhEmu, hhEmu->emu_code);
  1378. #endif
  1379. return;
  1380. }
  1382. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1383.  * FUNCTION:
  1384.  * minitelSS2
  1385.  *
  1386.  * DESCRIPTION:
  1387.  * SS2 is an alternate character set. It only has about 15 symbols so
  1388.  * we just map them here to ones in our current minitel font.
  1389.  *
  1390.  * ARGUMENTS:
  1391.  * hhEmu - private emulator handle.
  1392.  *
  1393.  * RETURNS:
  1394.  * void
  1395.  *
  1396.  */
  1397. static void minitelSS2(const HHEMU hhEmu)
  1398. {
  1399. const int row = hhEmu->emu_currow;
  1400. const int col = hhEmu->emu_curcol;
  1401. BOOL  fNoAdvance = FALSE;
  1402. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1404. /* --- SS2 codes are ignored in semigraphic mode --- */
  1406. if (pstPRI->minitelG1Active)
  1407. {
  1408. hhEmu->state = 0;
  1409. return;
  1410. }
  1412. /* --- Map the character --- */
  1414. switch (hhEmu->emu_code)
  1415. {
  1416. case ETEXT('x23'): hhEmu->emu_code = ETEXT('xA3');  break; // british pound
  1417. case ETEXT('x24'): hhEmu->emu_code = ETEXT('x24');  break; // Dollar sign
  1418. case ETEXT('x26'): hhEmu->emu_code = ETEXT('x23');  break; // pound sign
  1419. case ETEXT('x27'): hhEmu->emu_code = ETEXT('xA7');  break; // integral
  1420. case ETEXT('x2C'): hhEmu->emu_code = ETEXT('xC3');  break; // left arrow
  1421. case ETEXT('x2D'): hhEmu->emu_code = ETEXT('xC0');  break; // up arrow
  1422. case ETEXT('x2E'): hhEmu->emu_code = ETEXT('xC4');  break; // right arrow
  1423. case ETEXT('x2F'): hhEmu->emu_code = ETEXT('xC5');  break; // down arrow
  1424. case ETEXT('x30'): hhEmu->emu_code = ETEXT('xB0');  break; // degree
  1425. case ETEXT('x31'): hhEmu->emu_code = ETEXT('xB1');  break; // plus-minus
  1426. case ETEXT('x38'): hhEmu->emu_code = ETEXT('xF7');  break; // divide
  1427. case ETEXT('x3C'): hhEmu->emu_code = ETEXT('xBC');  break; // 1/4
  1428. case ETEXT('x3D'): hhEmu->emu_code = ETEXT('xBD');  break; // 1/2
  1429. case ETEXT('x3E'): hhEmu->emu_code = ETEXT('xBE');  break; // 3/4
  1430. case ETEXT('x41'): hhEmu->emu_code = ETEXT('x60');  fNoAdvance = TRUE;  break;
  1431. case ETEXT('x42'): hhEmu->emu_code = ETEXT('xB4');  fNoAdvance = TRUE;  break;
  1432. case ETEXT('x43'): hhEmu->emu_code = ETEXT('x5E');  fNoAdvance = TRUE;  break;
  1433. case ETEXT('x48'): hhEmu->emu_code = ETEXT('xA8');  fNoAdvance = TRUE;  break;
  1434. case ETEXT('x4A'): hhEmu->emu_code = ETEXT('xB8');  fNoAdvance = TRUE;  break;
  1435. case ETEXT('x4B'): hhEmu->emu_code = ETEXT('xB8');  fNoAdvance = TRUE;  break;
  1436. case ETEXT('x6A'): hhEmu->emu_code = ETEXT('x8C');  break;
  1437. case ETEXT('x7A'): hhEmu->emu_code = ETEXT('x9C');  break;
  1438. case ETEXT('x7B'): hhEmu->emu_code = ETEXT('xDF');  break;
  1439. default: hhEmu->emu_code = ETEXT('x5F');  break;
  1440. }
  1442. minitelGraphic(hhEmu);
  1444. if (fNoAdvance)
  1445. {
  1446. (*hhEmu->emu_setcurpos)(hhEmu, row, col); // don't advance cursor
  1447. }
  1449. else
  1450. {
  1451. // If we don't advance the cursor, we're done with this SS2
  1452. // sequence and reset the state to 0 - mrw, 2/3/95
  1453. //
  1454. hhEmu->state = 0;
  1455. }
  1457. return;
  1458. }
  1460. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1461.  * FUNCTION:
  1462.  * minitelSS2Part2
  1463.  *
  1464.  * DESCRIPTION:
  1465.  * The second half a an SS2 code is the vowel portion for the accents
  1466.  * page 90.
  1467.  *
  1468.  * ARGUMENTS:
  1469.  * hhEmu - private emulator handle.
  1470.  *
  1471.  * RETURNS:
  1472.  * void
  1473.  *
  1474.  */
  1475. static void minitelSS2Part2(const HHEMU hhEmu)
  1476. {
  1477. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1479. switch (hhEmu->emu_code)
  1480. {
  1481. case ETEXT('a'):
  1482. switch (pstPRI->minitel_last_char)
  1483. {
  1484. case ETEXT('x60'): hhEmu->emu_code = ETEXT('xE0');    break;
  1485. case ETEXT('x5E'): hhEmu->emu_code = ETEXT('xE2');    break;
  1486. case ETEXT('xA8'): hhEmu->emu_code = ETEXT('xE4');    break;
  1487. default: break;
  1488. }
  1489. break;
  1491. case ETEXT('e'):
  1492. switch (pstPRI->minitel_last_char)
  1493. {
  1494. case ETEXT('x60'): hhEmu->emu_code = ETEXT('xE8');    break;
  1495. case ETEXT('xB4'): hhEmu->emu_code = ETEXT('xE9');    break;
  1496. case ETEXT('x5E'): hhEmu->emu_code = ETEXT('xEA');    break;
  1497. case ETEXT('xA8'): hhEmu->emu_code = ETEXT('xEB');    break;
  1498. default: break;
  1499. }
  1500. break;
  1502. case ETEXT('i'):
  1503. switch (pstPRI->minitel_last_char)
  1504. {
  1505. case ETEXT('x5E'): hhEmu->emu_code = ETEXT('xEE');    break;
  1506. case ETEXT('xA8'): hhEmu->emu_code = ETEXT('xEF');    break;
  1507. default: break;
  1508. }
  1509. break;
  1511. case ETEXT('o'):
  1512. switch (pstPRI->minitel_last_char)
  1513. {
  1514. case ETEXT('x5E'): hhEmu->emu_code = ETEXT('xF4');    break;
  1515. case ETEXT('xA8'): hhEmu->emu_code = ETEXT('xF6');    break;
  1516. default: break;
  1517. }
  1518. break;
  1520. case ETEXT('u'):
  1521. switch (pstPRI->minitel_last_char)
  1522. {
  1523. case ETEXT('x60'): hhEmu->emu_code = ETEXT('xF9');    break;
  1524. case ETEXT('x5E'): hhEmu->emu_code = ETEXT('xFB');    break;
  1525. case ETEXT('xA8'): hhEmu->emu_code = ETEXT('xFC');    break;
  1526. default: break;
  1527. }
  1528. break;
  1530. case ETEXT('c'):
  1531. switch (pstPRI->minitel_last_char)
  1532. {
  1533. case ETEXT('xB8'): hhEmu->emu_code = ETEXT('xE7'); break;
  1534. default: break;
  1535. }
  1536. break;
  1538. default:
  1539. // Docs say if we're not one of the above chars, then overwrite
  1540. // position with current char.
  1541. break;
  1542. }
  1544. minitelGraphic(hhEmu);
  1545. return;
  1546. }
  1548. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1549.  * FUNCTION:
  1550.  * minitelInsMode
  1551.  *
  1552.  * DESCRIPTION:
  1553.  * Sets or Resets the insert mode depending on received code.
  1554.  *
  1555.  * ARGUMENTS:
  1556.  * hhEmu - private emulator handle.
  1557.  *
  1558.  * RETURNS:
  1559.  * void
  1560.  *
  1561.  */
  1562. static void minitelInsMode(const HHEMU hhEmu)
  1563. {
  1564. hhEmu->mode_IRM = (hhEmu->emu_code == ETEXT('x68')) ? SET : RESET;
  1565. return;
  1566. }
  1568. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1569.  * FUNCTION:
  1570.  * minitelNtfy
  1571.  *
  1572.  * DESCRIPTION:
  1573.  * Paints an inverted F or C when connection/disconnection notifications
  1574.  * come in.
  1575.  *
  1576.  * ARGUMENTS:
  1577.  * hhEmuPass - change this to hhEmu when reentrancy done.
  1578.  * nNtfyCode - why it was called, (we don't use)
  1579.  *
  1580.  * RETURNS:
  1581.  * void
  1582.  *
  1583.  */
  1584. void minitelNtfy(const HHEMU hhEmu, const int nNtfyCode)
  1585. {
  1586. const int r = row_index(hhEmu, 0);
  1587. const int c = hhEmu->emu_maxcol - 1;
  1588. ECHAR chr;
  1589. BOOL  fFlash = FALSE;
  1591. switch (cnctQueryStatus(sessQueryCnctHdl(hhEmu->hSession)))
  1592. {
  1593. case CNCT_STATUS_FALSE:
  1594. default:
  1595. chr = ETEXT('F');
  1596. break;
  1598. case CNCT_STATUS_TRUE:
  1599. chr = ETEXT('C');
  1600. break;
  1602. case CNCT_STATUS_CONNECTING:
  1603. chr = ETEXT('C');
  1604. fFlash = TRUE;
  1605. break;
  1606. }
  1608. hhEmu->emu_apText[r][c] = chr;
  1609. hhEmu->emu_apAttr[r][c].revvid = 1;
  1610. hhEmu->emu_apAttr[r][c].blink = (unsigned)fFlash;
  1611. hhEmu->emu_apAttr[r][c].symbol = 0; // mrw-5/5/95
  1613. hhEmu->emu_aiEnd[r] = c;
  1615. updateChar(sessQueryUpdateHdl(hhEmu->hSession), 0, c, c);
  1616. NotifyClient(hhEmu->hSession, EVENT_TERM_UPDATE, 0);
  1618. return;
  1619. }
  1621. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1622.  * FUNCTION:
  1623.  * minitelPRO1
  1624.  *
  1625.  * DESCRIPTION:
  1626.  * Handles PRO1 sequences (ESC,39,X).
  1627.  *
  1628.  * ARGUMENTS:
  1629.  * hhEmu - private emulator handle
  1630.  *
  1631.  * RETURNS:
  1632.  * void
  1633.  *
  1634.  */
  1635. static void minitelPRO1(const HHEMU hhEmu)
  1636. {
  1637. ECHAR aechBuf[35];
  1638. static const TCHAR achID[] = "x01x43r0x04";
  1640. switch (hhEmu->emu_code)
  1641. {
  1642. case ETEXT('x7B'): // ENQROM (page 139)
  1643. // See pages 21 & 22.  Basicly we send back an indentification
  1644. // sequence delimited by SOH and EOT
  1645. //
  1646. CnvrtMBCStoECHAR(aechBuf, sizeof(aechBuf), achID,
  1647.             StrCharGetByteCount(achID));
  1649. CLoopSend(sessQueryCLoopHdl(hhEmu->hSession), aechBuf, 5, 0);
  1650. break;
  1652. case ETEXT('x67'): // Disconnect (page 139)
  1653. PostMessage(sessQueryHwnd(hhEmu->hSession), WM_DISCONNECT, 0, 0);
  1654. break;
  1656. case ETEXT('x72'):
  1657. minitelStatusReply(hhEmu);
  1658. break;
  1660. default:
  1661. break;
  1662. }
  1664. return;
  1665. }
  1667. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1668.  * FUNCTION:
  1669.  * minitelPRO2Part1
  1670.  *
  1671.  * DESCRIPTION:
  1672.  * Handles first half of a PRO2 sequence.
  1673.  *
  1674.  * ARGUMENTS:
  1675.  * hhEmu - private emulator handle.
  1676.  *
  1677.  * RETURNS:
  1678.  * void
  1679.  *
  1680.  */
  1681. static void minitelPRO2Part1(const HHEMU hhEmu)
  1682. {
  1683. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1685. pstPRI->minitel_PRO1 = hhEmu->emu_code;
  1686. return;
  1687. }
  1689. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1690.  * FUNCTION:
  1691.  * minitelPRO2Part2
  1692.  *
  1693.  * DESCRIPTION:
  1694.  * Handles the second half of a PRO2 sequence.
  1695.  *
  1696.  * ARGUMENTS:
  1697.  * hhEmu - private emulator handle
  1698.  *
  1699.  * RETURNS:
  1700.  * void
  1701.  *
  1702.  */
  1703. static void minitelPRO2Part2(const HHEMU hhEmu)
  1704. {
  1705. int fUpperCase;
  1706. BYTE abKey[256];
  1707. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1709. switch (hhEmu->emu_code)
  1710. {
  1711. case ETEXT('x43'):   // scrolling
  1712. if (pstPRI->minitel_PRO1 == ETEXT('x69'))
  1713. pstPRI->fScrollMode = TRUE;
  1715. if (pstPRI->minitel_PRO1 == ETEXT('x6A'))
  1716. pstPRI->fScrollMode = FALSE;
  1718. minitelStatusReply(hhEmu);
  1719. break;
  1721. case ETEXT('x44'):   // error correction procedure (not implemented)
  1722. break;
  1724. case ETEXT('x45'):   // keyboard upper/lower case
  1725. if (pstPRI->minitel_PRO1 == ETEXT('x69'))
  1726. fUpperCase = FALSE;
  1728. else if (pstPRI->minitel_PRO1 == ETEXT('x6A'))
  1729. fUpperCase = TRUE;
  1731. else
  1732. break;
  1734. GetKeyboardState(abKey);
  1736. if (fUpperCase)
  1737. abKey[VK_CAPITAL] |= 0x01;
  1739. else
  1740. abKey[VK_CAPITAL] &= 0xfe;
  1743. SetKeyboardState(abKey);
  1745. minitelStatusReply(hhEmu);
  1746. break;
  1748. default:
  1749. return;
  1750. }
  1752. return;
  1753. }
  1755. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1756.  * FUNCTION:
  1757.  * minitelStatusReply
  1758.  *
  1759.  * DESCRIPTION:
  1760.  * Acknowledgement sequence for some PRO2 sequences and status requests.
  1761.  *
  1762.  * ARGUMENTS:
  1763.  * hhEmu - private emulator handle.
  1764.  *
  1765.  * RETURNS:
  1766.  * void
  1767.  *
  1768.  * AUTHOR: Mike Ward, 08-May-1995
  1769.  */
  1770. static void minitelStatusReply(const HHEMU hhEmu)
  1771. {
  1772. ECHAR ach[10];
  1773. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1775. // The PRO2 sequences x43 and x45 all return and acknowledgement
  1776. // of the form PRO2,x73,status byte.  The format of the status byte
  1777. // is defined in page 143, section 11.2.
  1778. //
  1779. // strcpy(ach, "x1bx3Ax73");
  1780. CnvrtMBCStoECHAR(ach, sizeof(ach), "x1bx3Ax73",
  1781. (unsigned long)StrCharGetByteCount("x1bx3Ax73"));
  1783. ach[3] = ETEXT('x40');  // bit 7 is always 1.
  1784. ach[3] |= pstPRI->fScrollMode ? ETEXT('x02') : ETEXT('x00');
  1785. ach[3] |=(GetKeyState(VK_CAPITAL) > 0) ? ETEXT('x00') : ETEXT('x08');
  1786. ach[4] = ETEXT('');
  1787. CLoopSend(sessQueryCLoopHdl(hhEmu->hSession), ach, 4, 0);
  1789. return;
  1790. }
  1792. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1793.  * FUNCTION:
  1794.  * emuMinitelSendKey
  1795.  *
  1796.  * DESCRIPTION:
  1797.  * Used by the toolbar to emit the correct minitel sequence for the
  1798.  * specified button.
  1799.  *
  1800.  * ARGUMENTS:
  1801.  * hEmu - public emulator handle.
  1802.  * iCmd - command string to send.
  1803.  *
  1804.  * RETURNS:
  1805.  * void
  1806.  *
  1807.  * AUTHOR: Mike Ward, 10-Mar-1995
  1808.  */
  1809. void emuMinitelSendKey(const HEMU hEmu, const int iCmd)
  1810. {
  1811. TCHAR *pach;
  1812. ECHAR aechBuf[20];
  1813. const HHEMU hhEmu = (HHEMU)hEmu;
  1814. const PSTMTPRIVATE pstPRI = (PSTMTPRIVATE)hhEmu->pvPrivate;
  1816. switch (iCmd)
  1817. {
  1818. case IDM_MINITEL_INDEX:  pach = TEXT("x13") TEXT("F");    break;
  1819. case IDM_MINITEL_CANCEL: pach = TEXT("x13") TEXT("E");    break;
  1820. case IDM_MINITEL_PREVIOUS: pach = TEXT("x13") TEXT("B");    break;
  1821. case IDM_MINITEL_REPEAT: pach = TEXT("x13") TEXT("C");    break;
  1822. case IDM_MINITEL_GUIDE:  pach = TEXT("x13") TEXT("D");    break;
  1823. case IDM_MINITEL_CORRECT: pach = TEXT("x13") TEXT("G");    break;
  1824. case IDM_MINITEL_NEXT: pach = TEXT("x13") TEXT("H");    break;
  1825. case IDM_MINITEL_SEND: pach = TEXT("x13") TEXT("A");    break;
  1826. case IDM_MINITEL_CONFIN:
  1827. pach = TEXT("x13") TEXT("I");
  1828. pstPRI->F9 += 1;
  1830. if (pstPRI->F9 == 2)
  1831. PostMessage(sessQueryHwnd(hhEmu->hSession), WM_DISCONNECT, 0, 0);
  1833. break;
  1835. default:
  1836. assert(0);
  1837. return;
  1838. }
  1840. CnvrtMBCStoECHAR(aechBuf, sizeof(aechBuf), pach,
  1841. StrCharGetByteCount(pach) + sizeof(TCHAR));
  1843. emuSendString((HHEMU)hEmu, aechBuf, StrCharGetEcharByteCount(aechBuf));
  1844. return;
  1845. }
  1847. #ifdef INCL_TERMINAL_SIZE_AND_COLORS
  1848. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  1849.  * FUNCTION:
  1850.  *  emuMinitelSetScrSize
  1851.  *
  1852.  * DESCRIPTION:
  1853.  *  Replaces std_setscrsize which was added to allow user settable screen
  1854.  * sizes. However, the Minitel doesn't allow this.
  1855.  *
  1856.  * ARGUMENTS:
  1857.  *  hhEmu - The internal emulator handle.
  1858.  *
  1859.  * RETURNS:
  1860.  *  void
  1861.  *
  1862.  * AUTHOR: Bob Everett - 1 Sep 1998
  1863.  */
  1864. void emuMinitelSetScrSize(const HHEMU hhEmu)
  1865.     {
  1866.     }
  1867. #endif
  1869. #endif // INCL_MINITEL