archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/shell/osshell/accesory/hypertrm/emu/emuhdl.c

2771 lines
82 KiB
Raw Permalink Blame History

/* File: D:\WACKER\emu\emuhdl.c (Created: 10-Dec-1993)
*
* Copyright 1994-2001 by Hilgraeve Inc. -- Monroe, MI
* All rights reserved
*
* $Revision: 22 $
* $Date: 7/08/02 6:33p $
*/
#include <windows.h>
#pragma hdrstop
// #define DEBUGSTR
#include <time.h>
#include <tapi.h>
#include <tdll\stdtyp.h>
#include <tdll\mc.h>
#include <tdll\assert.h>
#include <tdll\sf.h>
#include <tdll\sess_ids.h>
#include <tdll\session.h>
#include <tdll\capture.h>
#include <tdll\cloop.h>
#include <tdll\term.h>
#include <tdll\print.h>
#include <tdll\update.h>
#include <tdll\load_res.h>
#include <tdll\globals.h>
#include <tdll\statusbr.h>
#include <tdll\cnct.h>
#include <tdll\cnct.hh>
#include <tdll\htchar.h>
#include <tdll\com.h>
#include <tdll\errorbox.h> // TimedMessageBox()
#include <cncttapi\cncttapi.hh> // cncttapiSetLineConfig()
#include <term\res.h>
#include "emu.h"
#include "emu.hh"
#include "emuid.h"
#include "viewdata.hh"
#include "minitel.hh"
#include "emudec.hh"
#include "keytbls.h"
// Function prototypes...
//
STATIC_FUNC int emuLoadSettings(const HHEMU hhEmu,
const unsigned int uiId,
unsigned long ulDataSize,
void *pvData);
STATIC_FUNC void emuCheckSettings(struct stEmuBaseSFSettings *pstBaseSettings);
// Keytable declarations
//
const KEYTBLSTORAGE AnsiKeyTable[MAX_ANSI_KEYS] =
{
{VK_UP | VIRTUAL_KEY, {"\x1B[A\xff"}},
{VK_DOWN | VIRTUAL_KEY, {"\x1B[B\xff"}},
{VK_RIGHT | VIRTUAL_KEY, {"\x1B[C\xff"}},
{VK_LEFT | VIRTUAL_KEY, {"\x1B[D\xff"}},
// Added 27 Aug 98 rde
{VK_HOME | VIRTUAL_KEY, {"\x1B[H\xff"}},
{VK_END | VIRTUAL_KEY, {"\x1B[K\xff"}},
//VK_UP | VIRTUAL_KEY | CTRL_KEY, "\x1BOx\xff",
//VK_DOWN | VIRTUAL_KEY | CTRL_KEY, "\x1BOr\xff",
//VK_RIGHT | VIRTUAL_KEY | CTRL_KEY, "\x1BOv\xff",
//VK_LEFT | VIRTUAL_KEY | CTRL_KEY, "\x1BOt\xff",
//VK_HOME | VIRTUAL_KEY, "\x1B[H\xff",
//VK_END | VIRTUAL_KEY, "\x1B[K\xff",
//VK_HOME | VIRTUAL_KEY | CTRL_KEY, "\x1BOw\xff",
//VK_END | VIRTUAL_KEY | CTRL_KEY, "\x1BOq\xff",
//VK_PRIOR | VIRTUAL_KEY, "\x1B[M\xff",
//VK_NEXT | VIRTUAL_KEY, "\x1B[H\x1B[2J\xff",
//VK_PRIOR | VIRTUAL_KEY | CTRL_KEY, "\x1BOy\xff",
//VK_NEXT | VIRTUAL_KEY | CTRL_KEY, "\x1BOs\xff",
//VK_RETURN | VIRTUAL_KEY, "\x0D\xff",
//VK_RETURN | VIRTUAL_KEY | CTRL_KEY, "\x1BOM\xff",
//VK_INSERT | VIRTUAL_KEY | CTRL_KEY, "\x1BOp\xff",
/* -------------- Function keys ------------- */
{VK_F1 | VIRTUAL_KEY, {"\x1BOP\xff"}},
{VK_F2 | VIRTUAL_KEY, {"\x1BOQ\xff"}},
{VK_F3 | VIRTUAL_KEY, {"\x1BOR\xff"}},
{VK_F4 | VIRTUAL_KEY, {"\x1BOS\xff"}},
/* -------------- Gray keys, (extended edit pad) ------------- */
{VK_UP | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[A\xff"}},
{VK_DOWN | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[B\xff"}},
{VK_RIGHT | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[C\xff"}},
{VK_LEFT | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[D\xff"}},
// Added 27 Aug 98 rde
{VK_HOME | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[H\xff"}},
{VK_END | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[K\xff"}},
//VK_HOME | VIRTUAL_KEY | EXTENDED_KEY, "\x1B[H\xff",
//VK_END | VIRTUAL_KEY | EXTENDED_KEY, "\x1B[K\xff",
//VK_PRIOR | VIRTUAL_KEY | EXTENDED_KEY, "\x1B[M\xff",
//VK_NEXT | VIRTUAL_KEY | EXTENDED_KEY, "\x1B[H\x1B[2J\xff",
{VK_TAB | VIRTUAL_KEY | SHIFT_KEY,{"\x1B\x5B\x5A\xff"}}, /* KT_SHIFT + KN_TAB */
};
/* Also for ANSI emulator */
const KEYTBLSTORAGE IBMPCKeyTable[MAX_IBMPC_KEYS] =
{
{VK_BACK, {"\x08\xff"}}, /* KN_BS */
{VK_DELETE | VIRTUAL_KEY, {"\x00\x53\xff"}}, /* KN_DEL */
{VK_DOWN | VIRTUAL_KEY, {"\x00\x50\xff"}}, /* KN_DOWN */
{VK_END | VIRTUAL_KEY, {"\x00\x4F\xff"}}, /* KN_END */
{VK_RETURN, {"\x0D\xff"}}, /* KN_ENTER */
{VK_ESCAPE, {"\x1B\xff"}}, /* KN_ESC */
{VK_F1 | VIRTUAL_KEY, {"\x00\x3B\xff"}}, /* KN_F1 */
{VK_F2 | VIRTUAL_KEY, {"\x00\x3C\xff"}}, /* KN_F2 */
{VK_F3 | VIRTUAL_KEY, {"\x00\x3D\xff"}}, /* KN_F3 */
{VK_F4 | VIRTUAL_KEY, {"\x00\x3E\xff"}}, /* KN_F4 */
{VK_F5 | VIRTUAL_KEY, {"\x00\x3F\xff"}}, /* KN_F5 */
{VK_F6 | VIRTUAL_KEY, {"\x00\x40\xff"}}, /* KN_F6 */
{VK_F7 | VIRTUAL_KEY, {"\x00\x41\xff"}}, /* KN_F7 */
{VK_F8 | VIRTUAL_KEY, {"\x00\x42\xff"}}, /* KN_F8 */
{VK_F9 | VIRTUAL_KEY, {"\x00\x43\xff"}}, /* KN_F9 */
{VK_F10 | VIRTUAL_KEY, {"\x00\x44\xff"}}, /* KN_F10 */
{VK_F11 | VIRTUAL_KEY, {"\x00\x85\xff"}}, /* KN_F11 */
{VK_F12 | VIRTUAL_KEY, {"\x00\x86\xff"}}, /* KN_F12 */
{VK_HOME | VIRTUAL_KEY, {"\x00\x47\xff"}}, /* KN_HOME */
{VK_INSERT | VIRTUAL_KEY, {"\x00\x52\xff"}}, /* KN_INS */
{VK_LEFT | VIRTUAL_KEY, {"\x00\x4B\xff"}}, /* KN_LEFT */
{VK_NEXT | VIRTUAL_KEY, {"\x00\x51\xff"}}, /* KN_PGDN */
{VK_PRIOR | VIRTUAL_KEY, {"\x00\x49\xff"}}, /* KN_PGUP */
{VK_RIGHT | VIRTUAL_KEY, {"\x00\x4D\xff"}}, /* KN_RIGHT */
{VK_TAB, {"\x09\xff"}}, /* KN_TAB */
{VK_UP | VIRTUAL_KEY, {"\x00\x48\xff"}}, /* KN_UP */
{VK_BACK | VIRTUAL_KEY | CTRL_KEY, {"\x7F\xff"}}, /* KT_CTRL + KN_BS */
{VK_DELETE | VIRTUAL_KEY | CTRL_KEY, {"\x00\x93\xff"}}, /* KT_CTRL + KN_DEL */
{VK_DOWN | VIRTUAL_KEY | CTRL_KEY, {"\x00\x91\xff"}}, /* KT_CTRL + KN_DOWN */
{VK_END | VIRTUAL_KEY | CTRL_KEY, {"\x00\x75\xff"}}, /* KT_CTRL + KN_END */
{VK_RETURN | VIRTUAL_KEY | CTRL_KEY, {"\x0A\xff"}}, /* KT_CTRL + KN_ENTER */
{VK_F1 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x5E\xff"}}, /* KT_CTRL + KN_F1 */
{VK_F10 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x67\xff"}}, /* KT_CTRL + KN_F10 */
{VK_F11 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x89\xff"}}, /* KT_CTRL + KN_F11 */
{VK_F12 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x8A\xff"}}, /* KT_CTRL + KN_F12 */
{VK_F2 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x5F\xff"}}, /* KT_CTRL + KN_F2 */
{VK_F3 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x60\xff"}}, /* KT_CTRL + KN_F3 */
{VK_F4 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x61\xff"}}, /* KT_CTRL + KN_F4 */
{VK_F5 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x62\xff"}}, /* KT_CTRL + KN_F5 */
{VK_F6 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x63\xff"}}, /* KT_CTRL + KN_F6 */
{VK_F7 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x64\xff"}}, /* KT_CTRL + KN_F7 */
{VK_F8 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x65\xff"}}, /* KT_CTRL + KN_F8 */
{VK_F9 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x66\xff"}}, /* KT_CTRL + KN_F9 */
{VK_HOME | VIRTUAL_KEY | CTRL_KEY, {"\x00\x77\xff"}}, /* KT_CTRL + KN_HOME */
{VK_INSERT | VIRTUAL_KEY | CTRL_KEY, {"\x00\x92\xff"}}, /* KT_CTRL + KN_INS */
{VK_LEFT | VIRTUAL_KEY | CTRL_KEY, {"\x00\x73\xff"}}, /* KT_CTRL + KN_LEFT */
{VK_F1 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x8F\xff"}}, /* KT_CTRL + KN_MID */
{VK_PRIOR | VIRTUAL_KEY | CTRL_KEY, {"\x00\x76\xff"}}, /* KT_CTRL + KN_PGDN */
{VK_NEXT | VIRTUAL_KEY | CTRL_KEY, {"\x00\x84\xff"}}, /* KT_CTRL + KN_PGUP */
{VK_PRINT | VIRTUAL_KEY | CTRL_KEY, {"\x00\x72\xff"}}, /* KT_CTRL + KN_PRTSC */
{VK_RIGHT | VIRTUAL_KEY | CTRL_KEY, {"\x00\x74\xff"}}, /* KT_CTRL + KN_RIGHT */
{VK_TAB | VIRTUAL_KEY | CTRL_KEY, {"\x00\x94\xff"}}, /* KT_CTRL + KN_TAB */
{VK_UP | VIRTUAL_KEY | CTRL_KEY, {"\x00\x8D\xff"}}, /* KT_CTRL + KN_UP */
{VK_F1 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x54\xff"}}, /* KT_SHIFT + KN_F1 */
{VK_F10 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x5D\xff"}}, /* KT_SHIFT + KN_F10 */
{VK_F11 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x87\xff"}}, /* KT_SHIFT + KN_F11 */
{VK_F12 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x88\xff"}}, /* KT_SHIFT + KN_F12 */
{VK_F2 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x55\xff"}}, /* KT_SHIFT + KN_F2 */
{VK_F3 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x56\xff"}}, /* KT_SHIFT + KN_F3 */
{VK_F4 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x57\xff"}}, /* KT_SHIFT + KN_F4 */
{VK_F5 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x58\xff"}}, /* KT_SHIFT + KN_F5 */
{VK_F6 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x59\xff"}}, /* KT_SHIFT + KN_F6 */
{VK_F7 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x5A\xff"}}, /* KT_SHIFT + KN_F7 */
{VK_F8 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x5B\xff"}}, /* KT_SHIFT + KN_F8 */
{VK_F9 | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x5C\xff"}}, /* KT_SHIFT + KN_F9 */
{VK_TAB | VIRTUAL_KEY | SHIFT_KEY,{"\x00\x0F\xff"}}, /* KT_SHIFT + KN_TAB */
{0x5C | ALT_KEY | VIRTUAL_KEY, {"\x00\x28\xff"}}, /* KT_ALT + '\'' */
{0x2C | ALT_KEY | VIRTUAL_KEY, {"\x00\x33\xff"}}, /* KT_ALT + ',' */
{0x2D | ALT_KEY | VIRTUAL_KEY, {"\x00\x82\xff"}}, /* KT_ALT + '-' */
{0x2E | ALT_KEY | VIRTUAL_KEY, {"\x00\x34\xff"}}, /* KT_ALT + '.' */
{0x2F | ALT_KEY | VIRTUAL_KEY, {"\x00\x35\xff"}}, /* KT_ALT + '/' */
{0x30 | ALT_KEY | VIRTUAL_KEY, {"\x00\x81\xff"}}, /* KT_ALT + '0' */
{0x31 | ALT_KEY | VIRTUAL_KEY, {"\x00\x78\xff"}}, /* KT_ALT + '1' */
{0x32 | ALT_KEY | VIRTUAL_KEY, {"\x00\x79\xff"}}, /* KT_ALT + '2' */
{0x33 | ALT_KEY | VIRTUAL_KEY, {"\x00\x7A\xff"}}, /* KT_ALT + '3' */
{0x34 | ALT_KEY | VIRTUAL_KEY, {"\x00\x7B\xff"}}, /* KT_ALT + '4' */
{0x35 | ALT_KEY | VIRTUAL_KEY, {"\x00\x7C\xff"}}, /* KT_ALT + '5' */
{0x36 | ALT_KEY | VIRTUAL_KEY, {"\x00\x7D\xff"}}, /* KT_ALT + '6' */
{0x37 | ALT_KEY | VIRTUAL_KEY, {"\x00\x7E\xff"}}, /* KT_ALT + '7' */
{0x38 | ALT_KEY | VIRTUAL_KEY, {"\x00\x7F\xff"}}, /* KT_ALT + '8' */
{0x39 | ALT_KEY | VIRTUAL_KEY, {"\x00\x80\xff"}}, /* KT_ALT + '9' */
{0x3B | ALT_KEY | VIRTUAL_KEY, {"\x00\x27\xff"}}, /* KT_ALT + ';' */
{0x3D | ALT_KEY | VIRTUAL_KEY, {"\x00\x83\xff"}}, /* KT_ALT + '=' */
{0x41 | ALT_KEY | VIRTUAL_KEY, {"\x00\x1E\xff"}}, /* KT_ALT + 'A' */
{0x42 | ALT_KEY | VIRTUAL_KEY, {"\x00\x30\xff"}}, /* KT_ALT + 'B' */
{0x43 | ALT_KEY | VIRTUAL_KEY, {"\x00\x2E\xff"}}, /* KT_ALT + 'C' */
{0x44 | ALT_KEY | VIRTUAL_KEY, {"\x00\x20\xff"}}, /* KT_ALT + 'D' */
{0x45 | ALT_KEY | VIRTUAL_KEY, {"\x00\x12\xff"}}, /* KT_ALT + 'E' */
{0x46 | ALT_KEY | VIRTUAL_KEY, {"\x00\x21\xff"}}, /* KT_ALT + 'F' */
{0x47 | ALT_KEY | VIRTUAL_KEY, {"\x00\x22\xff"}}, /* KT_ALT + 'G' */
{0x48 | ALT_KEY | VIRTUAL_KEY, {"\x00\x23\xff"}}, /* KT_ALT + 'H' */
{0x49 | ALT_KEY | VIRTUAL_KEY, {"\x00\x17\xff"}}, /* KT_ALT + 'I' */
{0x4A | ALT_KEY | VIRTUAL_KEY, {"\x00\x24\xff"}}, /* KT_ALT + 'J' */
{0x4B | ALT_KEY | VIRTUAL_KEY, {"\x00\x25\xff"}}, /* KT_ALT + 'K' */
{0x4C | ALT_KEY | VIRTUAL_KEY, {"\x00\x26\xff"}}, /* KT_ALT + 'L' */
{0x4D | ALT_KEY | VIRTUAL_KEY, {"\x00\x32\xff"}}, /* KT_ALT + 'M' */
{0x4E | ALT_KEY | VIRTUAL_KEY, {"\x00\x31\xff"}}, /* KT_ALT + 'N' */
{0x4F | ALT_KEY | VIRTUAL_KEY, {"\x00\x18\xff"}}, /* KT_ALT + 'O' */
{0x50 | ALT_KEY | VIRTUAL_KEY, {"\x00\x19\xff"}}, /* KT_ALT + 'P' */
{0x51 | ALT_KEY | VIRTUAL_KEY, {"\x00\x10\xff"}}, /* KT_ALT + 'Q' */
{0x52 | ALT_KEY | VIRTUAL_KEY, {"\x00\x13\xff"}}, /* KT_ALT + 'R' */
{0x53 | ALT_KEY | VIRTUAL_KEY, {"\x00\x1F\xff"}}, /* KT_ALT + 'S' */
{0x54 | ALT_KEY | VIRTUAL_KEY, {"\x00\x14\xff"}}, /* KT_ALT + 'T' */
{0x55 | ALT_KEY | VIRTUAL_KEY, {"\x00\x16\xff"}}, /* KT_ALT + 'U' */
{0x56 | ALT_KEY | VIRTUAL_KEY, {"\x00\x2F\xff"}}, /* KT_ALT + 'V' */
{0x57 | ALT_KEY | VIRTUAL_KEY, {"\x00\x11\xff"}}, /* KT_ALT + 'W' */
{0x58 | ALT_KEY | VIRTUAL_KEY, {"\x00\x2D\xff"}}, /* KT_ALT + 'X' */
{0x59 | ALT_KEY | VIRTUAL_KEY, {"\x00\x15\xff"}}, /* KT_ALT + 'Y' */
{0x5A | ALT_KEY | VIRTUAL_KEY, {"\x00\x2C\xff"}}, /* KT_ALT + 'Z' */
{0x5B | ALT_KEY | VIRTUAL_KEY, {"\x00\x1A\xff"}}, /* KT_ALT + '[' */
{0x5D | ALT_KEY | VIRTUAL_KEY, {"\x00\x1B\xff"}}, /* KT_ALT + ']' */
{0x60 | ALT_KEY | VIRTUAL_KEY, {"\x00\x29\xff"}}, /* KT_ALT + '`' */
{VK_BACK | VIRTUAL_KEY | ALT_KEY, {"\x00\x0E\xff"}}, /* KT_ALT + KN_BS */
{VK_RETURN | VIRTUAL_KEY | ALT_KEY, {"\x00\x1C\xff"}}, /* KT_ALT + KN_ENTER */
{VK_ESCAPE | VIRTUAL_KEY | ALT_KEY, {"\x00\x01\xff"}}, /* KT_ALT + KN_ESC */
{VK_F1 | VIRTUAL_KEY | ALT_KEY, {"\x00\x68\xff"}}, /* KT_ALT + KN_F1 */
{VK_F10 | VIRTUAL_KEY | ALT_KEY, {"\x00\x71\xff"}}, /* KT_ALT + KN_F10 */
{VK_F11 | VIRTUAL_KEY | ALT_KEY, {"\x00\x8B\xff"}}, /* KT_ALT + KN_F11 */
{VK_F12 | VIRTUAL_KEY | ALT_KEY, {"\x00\x8C\xff"}}, /* KT_ALT + KN_F12 */
{VK_F2 | VIRTUAL_KEY | ALT_KEY, {"\x00\x69\xff"}}, /* KT_ALT + KN_F2 */
{VK_F3 | VIRTUAL_KEY | ALT_KEY, {"\x00\x6A\xff"}}, /* KT_ALT + KN_F3 */
{VK_F4 | VIRTUAL_KEY | ALT_KEY, {"\x00\x6B\xff"}}, /* KT_ALT + KN_F4 */
{VK_F5 | VIRTUAL_KEY | ALT_KEY, {"\x00\x6C\xff"}}, /* KT_ALT + KN_F5 */
{VK_F6 | VIRTUAL_KEY | ALT_KEY, {"\x00\x6D\xff"}}, /* KT_ALT + KN_F6 */
{VK_F7 | VIRTUAL_KEY | ALT_KEY, {"\x00\x6E\xff"}}, /* KT_ALT + KN_F7 */
{VK_F8 | VIRTUAL_KEY | ALT_KEY, {"\x00\x6F\xff"}}, /* KT_ALT + KN_F8 */
{VK_F9 | VIRTUAL_KEY | ALT_KEY, {"\x00\x70\xff"}}, /* KT_ALT + KN_F9 */
{VK_TAB | VIRTUAL_KEY | ALT_KEY, {"\x00\xA5\xff"}}, /* KT_ALT + KN_TAB */
{VK_RETURN | EXTENDED_KEY, {"\x00\xE0\x0D\xff"}}, /* KT_KP + KN_ENTER */
{0x2F | EXTENDED_KEY, {"\x00\xE0\x2F\xff"}}, /* KT_KP + '/' */
{VK_MULTIPLY | VIRTUAL_KEY, {"\x2A\xff"}}, /* KT_KP + '*' */
{VK_ADD | VIRTUAL_KEY, {"\x2B\xff"}}, /* KT_KP + '+' */
{VK_SUBTRACT | VIRTUAL_KEY, {"\x2D\xff"}}, /* KT_KP + '-' */
{VK_DECIMAL | VIRTUAL_KEY, {"\x2E\xff"}}, /* KT_KP + '.' */
{VK_NUMPAD0 | VIRTUAL_KEY, {"\x30\xff"}}, /* KT_KP + '0' */
{VK_NUMPAD1 | VIRTUAL_KEY, {"\x31\xff"}}, /* KT_KP + '1' */
{VK_NUMPAD2 | VIRTUAL_KEY, {"\x32\xff"}}, /* KT_KP + '2' */
{VK_NUMPAD3 | VIRTUAL_KEY, {"\x33\xff"}}, /* KT_KP + '3' */
{VK_NUMPAD4 | VIRTUAL_KEY, {"\x34\xff"}}, /* KT_KP + '4' */
{VK_NUMPAD5 | VIRTUAL_KEY, {"\x35\xff"}}, /* KT_KP + '5' */
{VK_NUMPAD6 | VIRTUAL_KEY, {"\x36\xff"}}, /* KT_KP + '6' */
{VK_NUMPAD7 | VIRTUAL_KEY, {"\x37\xff"}}, /* KT_KP + '7' */
{VK_NUMPAD8 | VIRTUAL_KEY, {"\x38\xff"}}, /* KT_KP + '8' */
{VK_NUMPAD9 | VIRTUAL_KEY, {"\x39\xff"}}, /* KT_KP + '9' */
{VK_MULTIPLY | VIRTUAL_KEY | CTRL_KEY, {"\x00\x96\xff"}}, /* KT_CTRL + KT_KP + '*' */
{VK_ADD | VIRTUAL_KEY | CTRL_KEY, {"\x00\x90\xff"}}, /* KT_CTRL + KT_KP + '+' */
{VK_SUBTRACT | VIRTUAL_KEY | CTRL_KEY, {"\x00\x8E\xff"}}, /* KT_CTRL + KT_KP + '-' */
{VK_DIVIDE | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\x95\xff"}}, /* KT_CTRL + KT_KP + '/' */
{0x0a | EXTENDED_KEY | CTRL_KEY, {"\x0A\xff"}}, /* KT_CTRL+KT_KP+KN_ENTER */
{VK_MULTIPLY | VIRTUAL_KEY | ALT_KEY, {"\x00\x37\xff"}}, /* KT_ALT + KT_KP + '*' */
{VK_ADD | VIRTUAL_KEY | ALT_KEY, {"\x00\x4E\xff"}}, /* KT_ALT + KT_KP + '+' */
{VK_SUBTRACT | VIRTUAL_KEY | ALT_KEY, {"\x00\x4A\xff"}}, /* KT_ALT + KT_KP + '-' */
{VK_DIVIDE | VIRTUAL_KEY | ALT_KEY, {"\x00\xA4\xff"}}, /* KT_ALT + KT_KP + '/' */
{0x0d | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\xA6\xff"}}, /* KT_ALT + KT_KP +KN_ENTER */
{VK_DELETE | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x53\xff"}}, /* KT_EP +KN_DEL */
{VK_DOWN | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x50\xff"}}, /* KT_EP +KN_DOWN */
{VK_END | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x4F\xff"}}, /* KT_EP +KN_END */
{VK_HOME | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x47\xff"}}, /* KT_EP +KN_HOME */
{VK_INSERT | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x52\xff"}}, /* KT_EP +KN_INS */
{VK_LEFT | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x4B\xff"}}, /* KT_EP +KN_LEFT */
{VK_NEXT | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x51\xff"}}, /* KT_EP +KN_PGDN */
{VK_PRIOR | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x49\xff"}}, /* KT_EP +KN_PGUP */
{VK_RIGHT | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x4D\xff"}}, /* KT_EP +KN_RIGHT */
{VK_UP | VIRTUAL_KEY | EXTENDED_KEY, {"\x00\xE0\x48\xff"}}, /* KT_EP +KN_UP */
{VK_DELETE | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x93\xff"}}, /* KT_CTRL + KT_EP +KN_DEL */
{VK_DOWN | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x91\xff"}}, /* KT_CTRL + KT_EP +KN_DOWN */
{VK_END | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x75\xff"}}, /* KT_CTRL + KT_EP +KN_END */
{VK_HOME | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x77\xff"}}, /* KT_CTRL + KT_EP +KN_HOME */
{VK_INSERT | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x92\xff"}}, /* KT_CTRL + KT_EP +KN_INS */
{VK_LEFT | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x73\xff"}}, /* KT_CTRL + KT_EP +KN_LEFT */
{VK_NEXT | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x76\xff"}}, /* KT_CTRL + KT_EP +KN_PGDN */
{VK_PRIOR | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x84\xff"}}, /* KT_CTRL + KT_EP +KN_PGUP */
{VK_RIGHT | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x74\xff"}}, /* KT_CTRL + KT_EP +KN_RIGHT */
{VK_UP | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x00\xE0\x8D\xff"}}, /* KT_CTRL + KT_EP +KN_UP */
{VK_DELETE | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\xA3\xff"}}, /* KT_ALT + KT_EP +KN_DEL */
{VK_DOWN | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\xA0\xff"}}, /* KT_ALT + KT_EP +KN_DOWN */
{VK_END | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\x9F\xff"}}, /* KT_ALT + KT_EP +KN_END */
{VK_HOME | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\x97\xff"}}, /* KT_ALT + KT_EP +KN_HOME */
{VK_INSERT | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\xA2\xff"}}, /* KT_ALT + KT_EP +KN_INS */
{VK_LEFT | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\x9B\xff"}}, /* KT_ALT + KT_EP +KN_LEFT */
{VK_NEXT | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\xA1\xff"}}, /* KT_ALT + KT_EP +KN_PGDN */
{VK_PRIOR | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\x99\xff"}}, /* KT_ALT + KT_EP +KN_PGUP */
{VK_RIGHT | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\x9D\xff"}}, /* KT_ALT + KT_EP +KN_RIGHT */
{VK_UP | VIRTUAL_KEY | EXTENDED_KEY | ALT_KEY, {"\x00\x98\xff"}}, /* KT_ALT + KT_EP +KN_UP */
{0x32 | VIRTUAL_KEY | CTRL_KEY, {"\x00\x03\xff"}}, /* KT_CTRL + '@' (NUL) */
};
/* for VT52 emulator */
const KEYTBLSTORAGE VT52KeyTable[MAX_VT52_KEYS] =
{
{VK_UP | EXTENDED_KEY | VIRTUAL_KEY,{"\x1B\x41\xff"}}, /* KN_UP */
{VK_DOWN | EXTENDED_KEY | VIRTUAL_KEY,{"\x1B\x42\xff"}}, /* KN_DOWN */
{VK_RIGHT| EXTENDED_KEY | VIRTUAL_KEY,{"\x1B\x43\xff"}}, /* KN_RIGHT */
{VK_LEFT | EXTENDED_KEY | VIRTUAL_KEY,{"\x1B\x44\xff"}}, /* KN_LEFT */
{VK_UP | VIRTUAL_KEY, {"\x1B\x41\xff"}}, /* KN_UP */
{VK_DOWN | VIRTUAL_KEY, {"\x1B\x42\xff"}}, /* KN_DOWN */
{VK_RIGHT| VIRTUAL_KEY, {"\x1B\x43\xff"}}, /* KN_RIGHT */
{VK_LEFT | VIRTUAL_KEY, {"\x1B\x44\xff"}}, /* KN_LEFT */
{VK_F1 | VIRTUAL_KEY, {"\x1BP\xff"}}, /* KN_F1 */
{VK_F2 | VIRTUAL_KEY, {"\x1BQ\xff"}}, /* KN_F2 */
{VK_F3 | VIRTUAL_KEY, {"\x1BR\xff"}}, /* KN_F3 */
{VK_F4 | VIRTUAL_KEY, {"\x1BS\xff"}}, /* KN_F4 */
{VK_F1 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BP\xff"}}, /* KN_F1 */
{VK_F2 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BQ\xff"}}, /* KN_F2 */
{VK_F3 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BR\xff"}}, /* KN_F3 */
{VK_F4 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BS\xff"}}, /* KN_F4 */
{VK_DELETE | VIRTUAL_KEY, {"\x7F\xff"}}, /* KN_DEL */
{VK_DELETE | VIRTUAL_KEY | EXTENDED_KEY,{"\x7F\xff"}}, /* KN_DEL */
{VK_ADD | VIRTUAL_KEY, {",\xff"}},
};
const KEYTBLSTORAGE VT52_Keypad_KeyTable[MAX_VT52_KEYPAD_KEYS] =
{
{VK_NUMPAD0 | VIRTUAL_KEY, {"\x1B?p\xff"}}, /* KT_KP + '0' (alternate mode) */
{VK_NUMPAD1 | VIRTUAL_KEY, {"\x1B?q\xff"}}, /* KT_KP + '1' (alternate mode) */
{VK_NUMPAD2 | VIRTUAL_KEY, {"\x1B?r\xff"}}, /* KT_KP + '2' (alternate mode) */
{VK_NUMPAD3 | VIRTUAL_KEY, {"\x1B?s\xff"}}, /* KT_KP + '3' (alternate mode) */
{VK_NUMPAD4 | VIRTUAL_KEY, {"\x1B?t\xff"}}, /* KT_KP + '4' (alternate mode) */
{VK_NUMPAD5 | VIRTUAL_KEY, {"\x1B?u\xff"}}, /* KT_KP + '5' (alternate mode) */
{VK_NUMPAD6 | VIRTUAL_KEY, {"\x1B?v\xff"}}, /* KT_KP + '6' (alternate mode) */
{VK_NUMPAD7 | VIRTUAL_KEY, {"\x1B?w\xff"}}, /* KT_KP + '7' (alternate mode) */
{VK_NUMPAD8 | VIRTUAL_KEY, {"\x1B?x\xff"}}, /* KT_KP + '8' (alternate mode) */
{VK_NUMPAD9 | VIRTUAL_KEY, {"\x1B?y\xff"}}, /* KT_KP + '9' (alternate mode) */
{VK_DECIMAL | VIRTUAL_KEY, {"\x1B?n\xff"}}, /* KT_KP + '.' (alternate mode) */
{VK_ADD | VIRTUAL_KEY, {"\x1B?l\xff"}}, /* KT_KP + '+' (alternate mode) */
{VK_RETURN | EXTENDED_KEY, {"\x1B?M\xff"}}, /* KT_KP + enter (alternate mode) */
{VK_SUBTRACT | VIRTUAL_KEY, {"\x1B?m\xff"}}, /* KT_KP + '-' (alternate mode) */
};
const KEYTBLSTORAGE VT_PF_KeyTable[MAX_VT_PF_KEYS] =
{
{VK_NUMLOCK | VIRTUAL_KEY | EXTENDED_KEY, {"\x1BP\xff"}}, /* KT_KP + NUMLOCK */
{0x2F | EXTENDED_KEY, {"\x1BQ\xff"}}, /* KT_KP + '/' */
{VK_MULTIPLY | VIRTUAL_KEY, {"\x1BR\xff"}}, /* KT_KP + '*' */
{VK_SUBTRACT | VIRTUAL_KEY, {"\x1BS\xff"}}, /* KT_KP + '-' */
};
/* for VT100 emulator */
const KEYTBLSTORAGE VT100KeyTable[MAX_VT100_KEYS] =
{
{VK_UP | VIRTUAL_KEY, {"\x1B[A\xff"}}, /* KN_UP */
{VK_DOWN | VIRTUAL_KEY, {"\x1B[B\xff"}}, /* KN_DOWN */
{VK_RIGHT| VIRTUAL_KEY, {"\x1B[C\xff"}}, /* KN_RIGHT */
{VK_LEFT | VIRTUAL_KEY, {"\x1B[D\xff"}}, /* KN_LEFT */
{VK_UP | EXTENDED_KEY | VIRTUAL_KEY, {"\x1B[A\xff"}}, /* KN_UP */
{VK_DOWN | EXTENDED_KEY | VIRTUAL_KEY,{"\x1B[B\xff"}}, /* KN_DOWN */
{VK_RIGHT| EXTENDED_KEY | VIRTUAL_KEY,{"\x1B[C\xff"}}, /* KN_RIGHT */
{VK_LEFT | EXTENDED_KEY | VIRTUAL_KEY,{"\x1B[D\xff"}}, /* KN_LEFT */
{VK_F1 | VIRTUAL_KEY, {"\x1BOP\xff"}}, /* KN_F1 */
{VK_F2 | VIRTUAL_KEY, {"\x1BOQ\xff"}}, /* KN_F2 */
{VK_F3 | VIRTUAL_KEY, {"\x1BOR\xff"}}, /* KN_F3 */
{VK_F4 | VIRTUAL_KEY, {"\x1BOS\xff"}}, /* KN_F4 */
{VK_F1 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BOP\xff"}}, /* KN_F1 */
{VK_F2 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BOQ\xff"}}, /* KN_F2 */
{VK_F3 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BOR\xff"}}, /* KN_F3 */
{VK_F4 | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BOS\xff"}}, /* KN_F4 */
{VK_DELETE | VIRTUAL_KEY, {"\x7F\xff"}}, /* KN_DEL */
{VK_DELETE | VIRTUAL_KEY | EXTENDED_KEY,{"\x7F\xff"}}, /* KN_DEL */
{VK_ADD | VIRTUAL_KEY, {",\xff"}},
{VK_SPACE | VIRTUAL_KEY | CTRL_KEY, {"\x00\xff"}}, /* CTRL + SPACE */
{0x32 | VIRTUAL_KEY | SHIFT_KEY | CTRL_KEY, {"\x00\xff"}}, /* CTRL + @ */
{0x32 | VIRTUAL_KEY | CTRL_KEY, {"\x00\xff"}}, /* CTRL + 2 */
{0x36 | VIRTUAL_KEY | CTRL_KEY, {"\x1e\xff"}}, /* CTRL + 6 */
{0xbd | VIRTUAL_KEY | CTRL_KEY, {"\x1f\xff"}}, /* CTRL + - */
};
const KEYTBLSTORAGE VT100_Cursor_KeyTable[MAX_VT100_CURSOR_KEYS] =
{
{VK_UP | EXTENDED_KEY | VIRTUAL_KEY, {"\x1BOA\xff"}}, /* KN_UP */
{VK_DOWN | EXTENDED_KEY | VIRTUAL_KEY,{"\x1BOB\xff"}}, /* KN_DOWN */
{VK_RIGHT| EXTENDED_KEY | VIRTUAL_KEY,{"\x1BOC\xff"}}, /* KN_RIGHT */
{VK_LEFT | EXTENDED_KEY | VIRTUAL_KEY,{"\x1BOD\xff"}}, /* KN_LEFT */
{VK_UP | VIRTUAL_KEY, {"\x1BOA\xff"}}, /* KN_UP */
{VK_DOWN | VIRTUAL_KEY, {"\x1BOB\xff"}}, /* KN_DOWN */
{VK_RIGHT| VIRTUAL_KEY, {"\x1BOC\xff"}}, /* KN_RIGHT */
{VK_LEFT | VIRTUAL_KEY, {"\x1BOD\xff"}}, /* KN_LEFT */
};
const KEYTBLSTORAGE VT100_Keypad_KeyTable[MAX_VT100_KEYPAD_KEYS] =
{
{VK_NUMPAD0 | VIRTUAL_KEY, {"\x1BOp\xff"}}, /* KT_KP + '0' (alternate mode) */
{VK_NUMPAD1 | VIRTUAL_KEY, {"\x1BOq\xff"}}, /* KT_KP + '1' (alternate mode) */
{VK_NUMPAD2 | VIRTUAL_KEY, {"\x1BOr\xff"}}, /* KT_KP + '2' (alternate mode) */
{VK_NUMPAD3 | VIRTUAL_KEY, {"\x1BOs\xff"}}, /* KT_KP + '3' (alternate mode) */
{VK_NUMPAD4 | VIRTUAL_KEY, {"\x1BOt\xff"}}, /* KT_KP + '4' (alternate mode) */
{VK_NUMPAD5 | VIRTUAL_KEY, {"\x1BOu\xff"}}, /* KT_KP + '5' (alternate mode) */
{VK_NUMPAD6 | VIRTUAL_KEY, {"\x1BOv\xff"}}, /* KT_KP + '6' (alternate mode) */
{VK_NUMPAD7 | VIRTUAL_KEY, {"\x1BOw\xff"}}, /* KT_KP + '7' (alternate mode) */
{VK_NUMPAD8 | VIRTUAL_KEY, {"\x1BOx\xff"}}, /* KT_KP + '8' (alternate mode) */
{VK_NUMPAD9 | VIRTUAL_KEY, {"\x1BOy\xff"}}, /* KT_KP + '9' (alternate mode) */
{VK_DECIMAL | VIRTUAL_KEY, {"\x1BOn\xff"}}, /* KT_KP + '.' (alternate mode) */
{VK_ADD | VIRTUAL_KEY, {"\x1BOl\xff"}}, /* KT_KP + '*' (alternate mode) */
{VK_RETURN | EXTENDED_KEY, {"\x1BOM\xff"}}, /* KT_KP + '+' (alternate mode) */
{VK_SUBTRACT | VIRTUAL_KEY, {"\x1BOm\xff"}}, /* KT_KP + '-' (alternate mode) */
};
#if defined(INCL_MINITEL)
const KEYTBLSTORAGE Minitel_KeyTable[MAX_MINITEL_KEYS] =
{
{0x4D | VIRTUAL_KEY | CTRL_KEY, {"\x0D\xff"}}, /* ctrl-m */
{VK_RETURN | VIRTUAL_KEY, {"\x13\x41\xff"}}, /* Envoi CNTRL-MA*/
{VK_RETURN | EXTENDED_KEY, {"\x13\x41\xff"}}, /* Send CNTRL-MA*/
{VK_TAB | VIRTUAL_KEY, {"\x13\x41\xff"}}, /* Send CNTRL-MA*/
{VK_F8 | VIRTUAL_KEY, {"\x13\x41\xff"}}, /* Send CNTRL-MA*/
{VK_HOME | VIRTUAL_KEY, {"\x13\x46"}}, /* Sommaire CNTRL-MF*/
{VK_HOME | VIRTUAL_KEY | EXTENDED_KEY, {"\x13\x46\xff"}}, /* Index CNTRL-MF*/
{VK_F1 | VIRTUAL_KEY, {"\x13\x46\xff"}}, /* Index CNTRL-MF*/
{VK_DELETE | VIRTUAL_KEY, {"\x13\x45\xff"}}, /* Annulation CNTRL-ME*/
{VK_DELETE | VIRTUAL_KEY | EXTENDED_KEY, {"\x13\x45\xff"}}, /* Cancel CNTRL-ME*/
{VK_F2 | VIRTUAL_KEY, {"\x13\x45\xff"}}, /* Cancel CNTRL-ME*/
{VK_PRIOR | VIRTUAL_KEY, {"\x13\x42\xff"}}, /* Retour CNTRL-MB*/
{VK_PRIOR | VIRTUAL_KEY | EXTENDED_KEY, {"\x13\x42\xff"}}, /* Previous CNTRL-MB*/
{VK_F3 | VIRTUAL_KEY, {"\x13\x42\xff"}}, /* Previous CNTRL-MB*/
{VK_INSERT | VIRTUAL_KEY, {"\x13\x43\xff"}}, /* Repeat CNTRL-MC*/
{VK_INSERT | VIRTUAL_KEY | EXTENDED_KEY, {"\x13\x43\xff"}}, /* Repeat CNTRL-MC*/
{VK_F4 | VIRTUAL_KEY, {"\x13\x43\xff"}}, /* Repeat CNTRL-MC*/
{VK_BACK | VIRTUAL_KEY, {"\x13\x47\xff"}}, /* Correct CNTRL-MG*/
{VK_F6 | VIRTUAL_KEY, {"\x13\x47\xff"}}, /* Correct CNTRL-MG*/
{VK_INSERT | VIRTUAL_KEY, {"\x13\x44\xff"}}, /* Guide CNTRL-MD*/
{VK_INSERT | VIRTUAL_KEY | EXTENDED_KEY, {"\x13\x44\xff"}}, /* Guide CNTRL-MD*/
{VK_F5 | VIRTUAL_KEY, {"\x13\x44\xff"}}, /* Guide CNTRL-MD*/
{VK_NEXT | VIRTUAL_KEY, {"\x13\x48\xff"}}, /* Suite CNTRL-MH*/
{VK_NEXT | VIRTUAL_KEY | EXTENDED_KEY, {"\x13\x48\xff"}}, /* Next CNTRL-MH*/
{VK_F7 | VIRTUAL_KEY, {"\x13\x48\xff"}}, /* Next CNTRL-MH*/
{VK_F9 | VIRTUAL_KEY, {"\x13\x49\xff"}}, /* Connect (page 123) */
// Page 124
{VK_UP | VIRTUAL_KEY, {"\x1B[A\xff"}},
{VK_UP | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[A\xff"}},
{VK_UP | VIRTUAL_KEY | SHIFT_KEY, {"\x1B[M\xff"}},
{VK_UP | VIRTUAL_KEY | EXTENDED_KEY | SHIFT_KEY, {"\x1B[M\xff"}},
{VK_DOWN | VIRTUAL_KEY, {"\x1B[B\xff"}},
{VK_DOWN | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[B\xff"}},
{VK_DOWN | VIRTUAL_KEY | SHIFT_KEY, {"\x1B[L\xff"}},
{VK_DOWN | VIRTUAL_KEY | SHIFT_KEY | EXTENDED_KEY, {"\x1B[L\xff"}},
{VK_RIGHT | VIRTUAL_KEY, {"\x1B[C\xff"}},
{VK_RIGHT | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[C\xff"}},
/* See minitel kbdin routine on this one - mrw */
{VK_RIGHT | VIRTUAL_KEY | SHIFT_KEY, {"\x1B[4\xff"}},
{VK_RIGHT | VIRTUAL_KEY | SHIFT_KEY | EXTENDED_KEY, {"\x1B[4\xff"}},
{VK_LEFT | VIRTUAL_KEY, {"\x1B[D\xff"}},
{VK_LEFT | VIRTUAL_KEY | EXTENDED_KEY, {"\x1B[D\xff"}},
{VK_LEFT | VIRTUAL_KEY | SHIFT_KEY, {"\x1B[P\xff"}},
{VK_LEFT | VIRTUAL_KEY | SHIFT_KEY | EXTENDED_KEY, {"\x1B[P\xff"}},
{VK_LEFT | VIRTUAL_KEY | CTRL_KEY, {"\x7F\xff"}},
{VK_LEFT | VIRTUAL_KEY | CTRL_KEY | EXTENDED_KEY, {"\x7F\xff"}},
/* numpad enter */
{VK_RETURN | VIRTUAL_KEY | EXTENDED_KEY, {"\x13\x41\xff"}},
{VK_RETURN | VIRTUAL_KEY | EXTENDED_KEY | SHIFT_KEY, {"\x1B[H\xff"}},
{VK_RETURN | VIRTUAL_KEY | EXTENDED_KEY | CTRL_KEY, {"\x1B[2J\xff"}},
// page 118
{0xA3, {"\x19\x23\xff"}}, // British pound symbol.
{0xA7, {"\x19\x27\xff"}}, // Paragraph symbol.
{0xA8, {"\x19\x48\xff"}}, // umluot
{0xB0, {"\x19\x30\xff"}}, // degree symbol
{0xB1, {"\x19\x31\xff"}}, // plus over minus symbol
{0xB4, {"\x19\x42\xff"}}, // accute accent
{0xBC, {"\x19\x3C\xff"}}, // 1/4
{0xBD, {"\x19\x3D\xff"}}, // 1/2
{0xBE, {"\x19\x3E\xff"}}, // 3/4
{0xB8, {"\x19\x4B\xff"}}, // beard
{0xC0, {"\x19\x2D\xff"}}, // up arrow symbol
{0xC3, {"\x19\x2C\xff"}}, // left arrow symbol
{0xC4, {"\x19\x2E\xff"}}, // right arrow symbol
{0xC5, {"\x19\x2F\xff"}}, // down arrow symbol
{0xDF, {"\x19\x7B\xff"}}, // Beta
{0xE0, {"\x19\x41\x61\xff"}}, // a grave accent
{0xE2, {"\x19\x43\x61\xff"}}, // a circumflex
{0xE4, {"\x19\x48\x61\xff"}}, // a umluot
{0xE7, {"\x19\x4B\x63\xff"}}, // c with a beard
{0xE8, {"\x19\x41\x65\xff"}}, // e grave accent
{0xE9, {"\x19\x42\x65\xff"}}, // e accute accent
{0xEA, {"\x19\x43\x65\xff"}}, // e circumflex
{0xEB, {"\x19\x48\x65\xff"}}, // e umluot
{0xEE, {"\x19\x43\x69\xff"}}, // i circumflex
{0xEF, {"\x19\x48\x69\xff"}}, // i umluot
{0xF4, {"\x19\x43\x6f\xff"}}, // o circumflex
{0xF5, {"\x19\x48\x6f\xff"}}, // o umluot
{0xF7, {"\x19\x38\xff"}}, // divide-by symbol
{0xF9, {"\x19\x41\x75\xff"}}, // u grave accent
{0xFB, {"\x19\x43\x75\xff"}}, // u circumflex
{0xFC, {"\x19\x48\x75\xff"}}, // u circumflex
{0x5E, {"\x19\x43\xff"}}, // circumflex accent (^)
{0x60, {"\x19\x41\xff"}}, // grave accent(`)
{0x8C, {"\x19\x6A\xff"}}, // big OE
{0x9C, {"\x19\x7A\xff"}}, // little oe
};
#endif
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuCreateHdl
*
* DESCRIPTION:
* Creates an emulator handle. The creation of an Emulator handle
* includes setting default user settings and loading the ANSI
* emulator.
*
* ARGUMENTS:
* hSession - session handle.
*
* RETURNS:
* HEMU or zero on error.
*
*/
HEMU emuCreateHdl(const HSESSION hSession)
{
HHEMU hhEmu;
hhEmu = malloc(sizeof(*hhEmu));
if (hhEmu == 0)
{
assert(FALSE);
return 0;
}
memset(hhEmu, 0, sizeof(*hhEmu));
InitializeCriticalSection(&hhEmu->csEmu);
hhEmu->hSession = hSession;
// Create and load the Emulator Name & Id table.
//
if (!emuCreateNameTable(hhEmu))
{
assert(FALSE);
emuDestroyHdl((HEMU)hhEmu);
hhEmu = NULL;
return 0;
}
// Create the text and attribute buffers.
//
if (!emuCreateTextAttrBufs((HEMU)hhEmu, MAX_EMUROWS, MAX_EMUCOLS))
{
assert(FALSE);
emuDestroyHdl((HEMU)hhEmu);
hhEmu = NULL;
return 0;
}
// Create the Print handle used for Printer Echo.
//
hhEmu->hPrintEcho = printCreateHdl(hSession);
if(hhEmu->hPrintEcho == 0)
{
assert(FALSE);
emuDestroyHdl((HEMU)hhEmu);
hhEmu = NULL;
return 0;
}
// Create the Print handle used for Host directed printing.
//
hhEmu->hPrintHost = printCreateHdl(hSession);
if (hhEmu->hPrintHost == 0)
{
assert(FALSE);
emuDestroyHdl((HEMU)hhEmu);
hhEmu = NULL;
return 0;
}
// Initialize the user settings for the emulation handle.
//
if (emuInitializeHdl((HEMU)hhEmu) != 0)
{
assert(FALSE);
emuDestroyHdl((HEMU)hhEmu);
hhEmu = NULL;
return 0;
}
return (HEMU)hhEmu;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuDestroyHdl
*
* DESCRIPTION:
* Death and destruction of the once noble emulator handle.
*
* ARGUMENTS:
* hEmu - external emulator handle.
*
* RETURNS:
* 0=OK, else error
*
*/
int emuDestroyHdl(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(0);
return -1;
}
if (hhEmu->pstNameTable)
{
free(hhEmu->pstNameTable);
hhEmu->pstNameTable = NULL;
}
if (hhEmu->emu_deinstall)
{
(*hhEmu->emu_deinstall)(hhEmu);
}
printDestroyHdl(hhEmu->hPrintEcho);
hhEmu->hPrintEcho = NULL;
printDestroyHdl(hhEmu->hPrintHost);
hhEmu->hPrintHost = NULL;
emuDestroyTextAttrBufs(hEmu);
DeleteCriticalSection(&hhEmu->csEmu);
if(hhEmu)
free(hhEmu);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuInitializeHdl
*
* DESCRIPTION:
* This function initializes the stUserSettings structure of the internal
* emulator handle with the values stored in the session file.
*
* ARGUMENTS:
* HEMU - The External Emulator Handle.
*
* RETURNS:
* 0 if successful, otherwise -1
*
*/
int emuInitializeHdl(const HEMU hEmu)
{
int nRet, nReturn;
struct stEmuBaseSFSettings stBaseSFSettings;
const HHEMU hhEmu = (HHEMU)hEmu;
nReturn = -1;
if (hhEmu == 0)
{
assert(FALSE);
return nReturn;
}
emuLock(hEmu);
hhEmu->emu_maxcol = EMU_DEFAULT_MAXCOL;
hhEmu->emu_maxrow = EMU_DEFAULT_MAXROW;
hhEmu->bottom_margin = EMU_DEFAULT_MAXROW;
hhEmu->mode_vt220 = FALSE;
hhEmu->mode_vt320 = FALSE;
// Added for the VT220/320 rde 16 Feb 1998
hhEmu->fUse8BitCodes = FALSE;
hhEmu->fAllowUserKeys = FALSE;
#if defined(INCL_PRINT_PASSTHROUGH)
// Added for VT100/220/320 mpt: 5-19-00
// hhEmu->fPrintRaw = FALSE;
#endif // INCL_PRINT_PASSTHROUGH
hhEmu->attrState[0].txtclr =
hhEmu->attrState[1].txtclr = VC_WHITE;
hhEmu->attrState[0].bkclr =
hhEmu->attrState[1].bkclr = VC_BLACK;
hhEmu->iCurAttrState = CS_STATE;
std_setcolors(hhEmu, GetNearestColorIndex(GetSysColor(COLOR_WINDOWTEXT)),
GetNearestColorIndex(GetSysColor(COLOR_WINDOW)));
// Initialize the user setting default values.
//
memset(&stBaseSFSettings, 0, sizeof(stBaseSFSettings));
stBaseSFSettings.nTermKeys = EMU_KEYS_TERM;
stBaseSFSettings.nCursorType = EMU_CURSOR_LINE;
stBaseSFSettings.fCursorBlink = TRUE;
stBaseSFSettings.nCharacterSet = EMU_CHARSET_ASCII;
stBaseSFSettings.fMapPFkeys = FALSE;
stBaseSFSettings.fAltKeypadMode = FALSE;
stBaseSFSettings.fKeypadAppMode = FALSE;
stBaseSFSettings.fCursorKeypadMode = FALSE;
stBaseSFSettings.fReverseDelBk = FALSE;
stBaseSFSettings.f132Columns = FALSE;
stBaseSFSettings.fWrapLines = TRUE;
stBaseSFSettings.fDestructiveBk = TRUE;
stBaseSFSettings.fLbSymbolOnEnter = FALSE;
stBaseSFSettings.fUse8BitCodes = FALSE;
stBaseSFSettings.fAllowUserKeys = FALSE;
stBaseSFSettings.nEmuId = EMU_AUTO;
#if defined(INCL_ULTC_VERSION)
stBaseSFSettings.nEmuId = EMU_VT220;
stBaseSFSettings.nCharacterSet = EMU_CHARSET_MULTINATIONAL;
#endif
stBaseSFSettings.nAutoAttempts = 0;
#ifdef INCL_USER_DEFINED_BACKSPACE_AND_TELNET_TERMINAL_ID
// Initialize new user settings. - cab:11/14/96
//
stBaseSFSettings.nBackspaceKeys = EMU_BKSPKEYS_CTRLH;
// Zero the telnet id string. I am doing this because if there
// isn't one in the session file, I want to load the default.
//
stBaseSFSettings.acTelnetId[0] = TEXT('\0');
emuQueryDefaultTelnetId(stBaseSFSettings.nEmuId,
stBaseSFSettings.acTelnetId, EMU_MAX_TELNETID);
#endif
// Load the settings if they exist.
if ((nRet = emuLoadSettings(hhEmu,
SFID_EMU_SETTINGS,
sizeof(stBaseSFSettings),
&stBaseSFSettings)) == -1)
{
nReturn = -1;
goto InitExit;
}
if (nRet > 0)
{
// The data was present.
// Check to see if there is a telnet id. If not, use the default.
//
emuCheckSettings(&stBaseSFSettings);
#ifdef INCL_USER_DEFINED_BACKSPACE_AND_TELNET_TERMINAL_ID
if ( stBaseSFSettings.acTelnetId[0] == TEXT('\0') )
{
emuQueryDefaultTelnetId(stBaseSFSettings.nEmuId,
stBaseSFSettings.acTelnetId, EMU_MAX_TELNETID);
}
#endif
}
// Initialize the emu's user settings structure from the data stored
// in the session file.
hhEmu->stUserSettings.nEmuId = stBaseSFSettings.nEmuId;
hhEmu->stUserSettings.nTermKeys = stBaseSFSettings.nTermKeys;
hhEmu->stUserSettings.nCursorType = stBaseSFSettings.nCursorType;
hhEmu->stUserSettings.nCharacterSet = stBaseSFSettings.nCharacterSet;
hhEmu->stUserSettings.nAutoAttempts = stBaseSFSettings.nAutoAttempts;
hhEmu->stUserSettings.fCursorBlink = stBaseSFSettings.fCursorBlink;
hhEmu->stUserSettings.fMapPFkeys = stBaseSFSettings.fMapPFkeys;
hhEmu->stUserSettings.fAltKeypadMode = stBaseSFSettings.fAltKeypadMode;
hhEmu->stUserSettings.fKeypadAppMode = stBaseSFSettings.fKeypadAppMode;
hhEmu->stUserSettings.fCursorKeypadMode = stBaseSFSettings.fCursorKeypadMode;
hhEmu->stUserSettings.fReverseDelBk = stBaseSFSettings.fReverseDelBk;
hhEmu->stUserSettings.f132Columns = stBaseSFSettings.f132Columns;
#if defined(INCL_PRINT_PASSTHROUGH)
//hhEmu->stUserSettings.fPrintRaw = stBaseSFSettings.fPrintRaw;
#endif // INCL_PRINT_PASSTHROUGH
hhEmu->stUserSettings.fDestructiveBk = stBaseSFSettings.fDestructiveBk;
hhEmu->stUserSettings.fWrapLines = stBaseSFSettings.fWrapLines;
hhEmu->stUserSettings.fLbSymbolOnEnter = stBaseSFSettings.fLbSymbolOnEnter;
hhEmu->stUserSettings.fUse8BitCodes = stBaseSFSettings.fUse8BitCodes;
hhEmu->stUserSettings.fAllowUserKeys = stBaseSFSettings.fAllowUserKeys;
hhEmu->stUserSettings.nBackspaceKeys = stBaseSFSettings.nBackspaceKeys;
StrCharCopyN(hhEmu->stUserSettings.acTelnetId, stBaseSFSettings.acTelnetId, EMU_MAX_TELNETID);
#ifdef INCL_TERMINAL_SIZE_AND_COLORS
// Set up the default colors in case the user settings don't exist.
#if TRUE
hhEmu->stUserSettings.nTextColor =
GetNearestColorIndex(GetSysColor(COLOR_WINDOWTEXT));
hhEmu->stUserSettings.nBackgroundColor =
GetNearestColorIndex(GetSysColor(COLOR_WINDOW));
#else
// We've decided not to do this. rde 14 Jul 98
// Use white (non-bold) on black. rde 8 Jul 98
hhEmu->stUserSettings.nBackgroundColor = VC_BLACK;
hhEmu->stUserSettings.nTextColor = VC_WHITE;
#endif
// Load the settings if they exist.
if ((nRet = emuLoadSettings(hhEmu,
SFID_EMU_TEXTCOLOR_SETTING,
sizeof(hhEmu->stUserSettings.nTextColor),
&hhEmu->stUserSettings.nTextColor)) == -1)
{
nReturn = -1;
goto InitExit;
}
if (nRet > 0)
{
// The data was present, so use it.
std_setcolors(hhEmu,
hhEmu->stUserSettings.nTextColor,
hhEmu->stUserSettings.nBackgroundColor);
}
if ((nRet = emuLoadSettings(hhEmu,
SFID_EMU_BKGRNDCOLOR_SETTING,
sizeof(hhEmu->stUserSettings.nBackgroundColor),
&hhEmu->stUserSettings.nBackgroundColor)) == -1)
{
nReturn = -1;
goto InitExit;
}
if (nRet > 0)
{
// The data was present, so use it.
std_setcolors(hhEmu,
hhEmu->stUserSettings.nTextColor,
hhEmu->stUserSettings.nBackgroundColor);
}
// Set up the default screen size in case the user settings don't exist.
hhEmu->stUserSettings.nUserDefRows = EMU_DEFAULT_ROWS;
hhEmu->stUserSettings.nUserDefCols =
hhEmu->stUserSettings.f132Columns ? MAX_EMUCOLS : EMU_DEFAULT_COLS;
#if defined(INCL_PRINT_PASSTHROUGH)
// default host-controlled print mode with regard to windows drivers
hhEmu->stUserSettings.fPrintRaw = FALSE;
#endif // INCL_PRINT_PASSTHROUGH
// Load the settings if they exist.
if ((nRet = emuLoadSettings(hhEmu,
SFID_EMU_SCRNROWS_SETTING,
sizeof(hhEmu->stUserSettings.nUserDefRows),
&hhEmu->stUserSettings.nUserDefRows)) == -1)
{
nReturn = -1;
goto InitExit;
}
if ((nRet = emuLoadSettings(hhEmu,
SFID_EMU_SCRNCOLS_SETTING,
sizeof(hhEmu->stUserSettings.nUserDefCols),
&hhEmu->stUserSettings.nUserDefCols)) == -1)
{
nReturn = -1;
goto InitExit;
}
#if defined(INCL_PRINT_PASSTHROUGH)
if ((nRet = emuLoadSettings(hhEmu,
SFID_EMU_PRINT_RAW,
sizeof(hhEmu->stUserSettings.fPrintRaw),
&hhEmu->stUserSettings.fPrintRaw)) == -1)
{
nReturn = -1;
goto InitExit;
}
#endif // INCL_PRINT_PASSTHROUGH
if (nRet > 0)
{
// The data was present, so use it.
hhEmu->stUserSettings.f132Columns =
(hhEmu->stUserSettings.nUserDefCols == 132) ? TRUE : FALSE;
#if FALSE // TODO:rde Is this needed?
hhEmu->emu_setscrsize = std_setscrsize;
#endif
}
#endif
// Load the emulator.
//
nReturn = emuLoad((HEMU)hhEmu, hhEmu->stUserSettings.nEmuId);
//JMH 01-09-97 emuSetSettings() was being called before emuLoad(), but
// emuLoad() initialized some values that got set by emuSetSettings().
// (e.g. 132-column mode).
//
// Tell the emulator about the user's settings.
//
emuSetSettings((HEMU)hhEmu, &hhEmu->stUserSettings);
// Clear the emulator image.
//
//*for (nRow = 0 ; nRow < MAX_EMUROWS ; ++nRow)
//* clear_imgrow(hhEmu, nRow);
//* This breaks the MINITEL bad - mrw
//*(hhEmu->emu_setcurpos)(hhEmu, 0, 0);
InitExit:
emuUnlock(hEmu);
NotifyClient(hhEmu->hSession, EVENT_EMU_SETTINGS, 0);
NotifyClient(hhEmu->hSession, EVENT_TERM_UPDATE, 0);
if (nReturn < 0)
nRet = 0;
return nReturn;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuSaveHdl
*
* DESCRIPTION:
* This function stores the emulator user settings in the session file.
*
*
* ARGUMENTS:
* HEMU - The External Emulator Handle.
*
* RETURNS:
* 0=OK, else error
*
*/
int emuSaveHdl(const HEMU hEmu)
{
struct stEmuBaseSFSettings stBaseSFSettings;
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(FALSE);
return -1;
}
// Initialize the base structure that gets saved in the session file.
stBaseSFSettings.nEmuId = hhEmu->stUserSettings.nEmuId;
stBaseSFSettings.nTermKeys = hhEmu->stUserSettings.nTermKeys;
stBaseSFSettings.nCursorType = hhEmu->stUserSettings.nCursorType;
stBaseSFSettings.nCharacterSet = hhEmu->stUserSettings.nCharacterSet;
stBaseSFSettings.nAutoAttempts = hhEmu->stUserSettings.nAutoAttempts;
stBaseSFSettings.fCursorBlink = hhEmu->stUserSettings.fCursorBlink;
stBaseSFSettings.fMapPFkeys = hhEmu->stUserSettings.fMapPFkeys;
stBaseSFSettings.fAltKeypadMode = hhEmu->stUserSettings.fAltKeypadMode;
stBaseSFSettings.fKeypadAppMode = hhEmu->stUserSettings.fKeypadAppMode;
stBaseSFSettings.fCursorKeypadMode = hhEmu->stUserSettings.fCursorKeypadMode;
stBaseSFSettings.fReverseDelBk = hhEmu->stUserSettings.fReverseDelBk;
stBaseSFSettings.f132Columns = hhEmu->stUserSettings.f132Columns;
stBaseSFSettings.fDestructiveBk = hhEmu->stUserSettings.fDestructiveBk;
stBaseSFSettings.fWrapLines = hhEmu->stUserSettings.fWrapLines;
stBaseSFSettings.fLbSymbolOnEnter = hhEmu->stUserSettings.fLbSymbolOnEnter;
stBaseSFSettings.fUse8BitCodes = hhEmu->stUserSettings.fUse8BitCodes;
stBaseSFSettings.fAllowUserKeys = hhEmu->stUserSettings.fAllowUserKeys;
stBaseSFSettings.nBackspaceKeys = hhEmu->stUserSettings.nBackspaceKeys;
StrCharCopyN(stBaseSFSettings.acTelnetId, hhEmu->stUserSettings.acTelnetId, EMU_MAX_TELNETID);
emuLock(hEmu);
sfPutSessionItem(sessQuerySysFileHdl(hhEmu->hSession),
SFID_EMU_SETTINGS,
sizeof(stBaseSFSettings),
&stBaseSFSettings);
#ifdef INCL_TERMINAL_SIZE_AND_COLORS
sfPutSessionItem(sessQuerySysFileHdl(hhEmu->hSession),
SFID_EMU_TEXTCOLOR_SETTING,
sizeof(hhEmu->stUserSettings.nTextColor),
&hhEmu->stUserSettings.nTextColor);
sfPutSessionItem(sessQuerySysFileHdl(hhEmu->hSession),
SFID_EMU_BKGRNDCOLOR_SETTING,
sizeof(hhEmu->stUserSettings.nBackgroundColor),
&hhEmu->stUserSettings.nBackgroundColor);
sfPutSessionItem(sessQuerySysFileHdl(hhEmu->hSession),
SFID_EMU_SCRNROWS_SETTING,
sizeof(hhEmu->stUserSettings.nUserDefRows),
&hhEmu->stUserSettings.nUserDefRows);
sfPutSessionItem(sessQuerySysFileHdl(hhEmu->hSession),
SFID_EMU_SCRNCOLS_SETTING,
sizeof(hhEmu->stUserSettings.nUserDefCols),
&hhEmu->stUserSettings.nUserDefCols);
#endif
#if defined(INCL_PRINT_PASSTHROUGH)
sfPutSessionItem(sessQuerySysFileHdl(hhEmu->hSession),
SFID_EMU_PRINT_RAW,
sizeof(hhEmu->stUserSettings.fPrintRaw),
&hhEmu->stUserSettings.fPrintRaw);
#endif // INCL_PRINT_PASSTHROUGH
emuUnlock(hEmu);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuLock
*
* DESCRIPTION:
* Grabs the emulator's critical section semaphore. Access functions
* to the emulator should also call this so we can call emulator
* functions from anywhere.
*
* ARGUMENTS:
* hEmu - external emulator handle.
*
* RETURNS:
* void
*
*/
void emuLock(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
EnterCriticalSection(&hhEmu->csEmu);
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuUnlock
*
* DESCRIPTION:
* Releases the emulator's critical section semaphore.
*
* ARGUMENTS:
* hEmu - external emulator handle.
*
* RETURNS:
* void
*
*/
void emuUnlock(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
LeaveCriticalSection(&hhEmu->csEmu);
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuGetTxtBuf
*
* DESCRIPTION:
* Obviously we don't need the handle here but when we do go reentrant,
* we only change the guts of this function. Also, I don't call
* emuLock(), emuUnlock() since only termGetUpdate() calls these functions
* and at that point the emulator is already locked down.
*
* ARGUMENTS:
* hEmu - external emulator handle
*
* RETURNS:
* pointer to text buf array
*
*/
ECHAR **emuGetTxtBuf(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hEmu == 0)
{
assert(0);
return 0;
}
return hhEmu->emu_apText;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuGetAttrBuf
*
* DESCRIPTION:
* Obviously we don't need the handle here but when we do go reentrant,
* we only change the guts of this function. Also, I don't call
* emuLock(), emuUnlock() since only termGetUpdate() calls these functions
* and at that point the emulator is already locked down.
*
* ARGUMENTS:
* hEmu - external emulator handle
*
* RETURNS:
* pointer to attribute buf array
*
*/
PSTATTR *emuGetAttrBuf(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hEmu == 0)
{
assert(0);
return 0;
}
return hhEmu->emu_apAttr;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuKbdIn
*
* DESCRIPTION:
*
*
* ARGUMENTS:
*
*
* RETURNS:
* 0=termkey, -1=not termkey, -2=error
*
*/
int emuKbdIn(const HEMU hEmu, KEY_T key, const int fTest)
{
const HHEMU hhEmu = (HHEMU)hEmu;
int iRet;
if (hEmu == 0)
{
assert(0);
return -2;
}
emuLock(hEmu);
iRet = (*hhEmu->emu_kbdin)(hhEmu, (int)key, fTest);
emuUnlock(hEmu);
return iRet;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuIsEmuKey
*
* DESCRIPTION:
* Checks to see if the the given key maps to any defined terminal keys.
*
* ARGUMENTS:
* HEMU hEmu - External emulator handle.
* int key - Key to test.
*
* RETURNS:
* TRUE=termkey, FALSE=not termkey
*
*/
int emuIsEmuKey(const HEMU hEmu, KEY_T key)
{
const HHEMU hhEmu = (HHEMU)hEmu;
int iRet;
if (hEmu == 0)
{
assert(0);
return FALSE;
}
if (cnctQueryStatus(sessQueryCnctHdl(hhEmu->hSession)) !=
CNCT_STATUS_TRUE || IsSessionSuspended(hhEmu->hSession) ||
hhEmu->stUserSettings.nTermKeys == EMU_KEYS_ACCEL)
{
return FALSE;
}
emuLock(hEmu);
iRet = (*hhEmu->emu_kbdin)(hhEmu, (int)key, TRUE);
emuUnlock(hEmu);
return (iRet == -1) ? FALSE : TRUE;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* emuComDone
*
* DESCRIPTION:
*
* ARGUMENTS:
*
* RETURNS:
* 0=OK, else error
*
*/
int emuComDone(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hEmu == 0)
{
assert(0);
return -1;
}
NotifyClient(hhEmu->hSession, EVENT_TERM_UPDATE, 0L);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryCurPos
*
* DESCRIPTION: Returns the row and column position of the current
* cursor position.
*
* ARGUMENTS: hEmu - The External emulator handle.
* *row - A pointer to an integer.
* *col - A pointer to an integer.
*
* RETURNS:
* 0=OK, else error
*
*/
int emuQueryCurPos(const HEMU hEmu, int *row, int *col)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hEmu == 0)
{
assert(0);
return -1;
}
emuLock(hEmu);
*row = hhEmu->emu_currow;
*col = hhEmu->emu_curcol;
emuUnlock(hEmu);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryCursorType
*
* DESCRIPTION:
* Returns the current cursor type.
*
* ARGUMENTS:
* hEmu - public emulator handle.
*
* RETURNS:
* The cursor type.
*
*/
int emuQueryCursorType(const HEMU hEmu)
{
int iCurType;
const HHEMU hhEmu = (HHEMU)hEmu;
if (hEmu == 0)
{
assert(0);
return -1;
}
emuLock(hEmu);
iCurType = hhEmu->iCurType;
emuUnlock(hEmu);
return iCurType;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuTrackingNotify
*
* DESCRIPTION:
* Cloop calls this function when it detects a pause in the data flow.
* This allows the client side to track to the cursor position if that
* option is enabled.
*
* ARGUMENTS:
* HEMU hEmu - External emulator handle.
*
* RETURNS:
* 0
*
*/
int emuTrackingNotify(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(FALSE);
return 0;
}
NotifyClient(hhEmu->hSession, EVENT_TERM_TRACK, 0);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryClearAttr
*
* DESCRIPTION:
*
* ARGUMENTS:
*
* RETURNS:
* 0=OK, else error
*
*/
int emuQueryClearAttr(const HEMU hEmu, PSTATTR pstClearAttr)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(0);
return -1;
}
emuLock(hEmu);
*pstClearAttr = hhEmu->emu_clearattr_sav;
emuUnlock(hEmu);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryRowsCols
*
* DESCRIPTION:
* Returns the current number of rows and columns set in the emulator.
*
* ARGUMENTS:
* hEmu - public emulator handle
* piRows - pointer to row variable
* piCols - pointer to col variable
*
* RETURNS:
* 0=OK, else error
*
*/
int emuQueryRowsCols(const HEMU hEmu, int *piRows, int *piCols)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hEmu == 0)
{
assert(0);
return -1;
}
emuLock(hEmu);
*piRows = hhEmu->emu_maxrow + 1;
*piCols = hhEmu->emu_maxcol + 1;
emuUnlock(hEmu);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryPrintEchoHdl
*
* DESCRIPTION: This routine returns the Print handle used for
* Printer Echo for the given emulator handle.
*
* ARGUMENTS: hEmu - The external emulator handle.
*
* RETURNS: HPRINT - The External print handle for Printer Echo.
*
*/
HPRINT emuQueryPrintEchoHdl(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
HPRINT hPrint;
if (hhEmu == 0)
{
assert(FALSE);
return 0;
}
emuLock(hEmu);
hPrint = hhEmu->hPrintEcho;
emuUnlock(hEmu);
return hPrint;
}
#if 0
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryEmuName
*
* DESCRIPTION:
* Returns the name of the emulator.
*
* ARGUMENTS:
* hEmu - The External Emulator Handle.
* *acBuffer - The address of a buffer to receive the information.
* nSize - The size of the buffer.
*
* RETURNS:
* 0=OK else error
*
*/
int emuQueryName(const HEMU hEmu, TCHAR *achBuffer, int nSize)
{
const HHEMU hhEmu = (HHEMU)hEmu;
BYTE *pv;
BYTE *temp;
DWORD nLen;
int indx;
int nEmuCount;
int nEmuId;
if (hhEmu == 0)
{
*achBuffer = 0;
assert(FALSE);
return -1 ;
}
emuLock(hEmu);
nEmuId = hhEmu->stUserSettings.nEmuId;
emuUnlock(hEmu);
if (resLoadDataBlock(glblQueryDllHinst(),
IDT_EMU_NAMES,
(LPVOID *)&pv, &nLen))
{
assert(FALSE);
return -2;
}
nEmuCount = *(RCDATA_TYPE *)pv;
pv += sizeof(RCDATA_TYPE);
for (indx = 0 ; indx < nEmuCount ; indx++)
{
nLen = (DWORD)StrCharGetByteCount((LPTSTR)pv) + (DWORD)sizeof(BYTE);
if (nLen == 0)
{
assert(FALSE);
return -3;
}
temp = pv + nLen;
if (*(RCDATA_TYPE *)temp == nEmuId)
{
if (StrCharGetByteCount(pv) < nSize)
{
StrCharCopyN(achBuffer, pv, nSize);
break;
}
else
{
*achBuffer = 0;
return -4;
}
}
pv += (nLen + (DWORD)sizeof(RCDATA_TYPE));
}
return 0;
}
#endif
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryEmuName
*
* DESCRIPTION:
* Returns the name of the emulator.
*
* ARGUMENTS:
* hEmu - The External Emulator Handle.
* *acBuffer - The address of a buffer to receive the information.
* nSize - The size of the buffer.
*
* RETURNS:
* 0=OK else error
*
*/
int emuQueryName(const HEMU hEmu, TCHAR *achBuffer, int nSize)
{
const HHEMU hhEmu = (HHEMU)hEmu;
TCHAR achText[256];
int nEmuId,
nResourceId,
nLen;
emuLock(hEmu);
nEmuId = hhEmu->stUserSettings.nEmuId;
emuUnlock(hEmu);
switch(nEmuId)
{
case EMU_AUTO:
nResourceId = IDS_EMUNAME_AUTO;
break;
case EMU_ANSI:
nResourceId = IDS_EMUNAME_ANSI;
break;
case EMU_ANSIW:
nResourceId = IDS_EMUNAME_ANSIW;
break;
case EMU_MINI:
nResourceId = IDS_EMUNAME_MINI;
break;
case EMU_VIEW:
nResourceId = IDS_EMUNAME_VIEW;
break;
case EMU_TTY:
nResourceId = IDS_EMUNAME_TTY;
break;
case EMU_VT100:
nResourceId = IDS_EMUNAME_VT100;
break;
case EMU_VT52:
nResourceId = IDS_EMUNAME_VT52;
break;
case EMU_VT100J:
nResourceId = IDS_EMUNAME_VT100J;
break;
#if defined(INCL_VT220)
case EMU_VT220:
nResourceId = IDS_EMUNAME_VT220;
break;
#endif
#if defined(INCL_VT320)
case EMU_VT320:
nResourceId = IDS_EMUNAME_VT320;
break;
#endif
#if defined(INCL_VT100PLUS)
case EMU_VT100PLUS:
nResourceId = IDS_EMUNAME_VT100PLUS;
break;
#endif
#if defined(INCL_VTUTF8)
case EMU_VTUTF8:
nResourceId = IDS_EMUNAME_VTUTF8;
break;
#endif
default:
assert(FALSE);
return(-1);
}
nLen = LoadString(glblQueryDllHinst(), (unsigned)nResourceId, achText,
sizeof(achText) / sizeof(TCHAR));
// Has the caller supplied a large enough buffer.
//
if (nSize <= nLen)
return(-1);
StrCharCopyN(achBuffer, achText, nSize);
return(0);
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuGetIdFromName
*
* DESCRIPTION:
* Returns the Id for the supplied emulator name.
*
* ARGUMENTS:
* hEmu - The External Emulator Handle.
* *acBuffer - The address of a buffer to receive the information.
* nSize - The size of the buffer.
*
* RETURNS:
* An emulator ID otherwise (-1) if the function fails.
*
*/
int emuGetIdFromName(const HEMU hEmu, TCHAR *achEmuName)
{
const HHEMU hhEmu = (HHEMU)hEmu;
int iRet, idx;
for(idx = 0; idx < NBR_EMULATORS; idx++)
{
iRet = StrCharCmp(achEmuName, hhEmu->pstNameTable[idx].acName);
if (iRet == 0)
{
return(hhEmu->pstNameTable[idx].nEmuId);
}
}
return(-1);
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryEmulatorId
*
* DESCRIPTION:
* Returns the oridinal value for the current emulator. This can be
* used through-out the program to write conditional code for emulators.
*
* ARGUMENTS:
* HEMU hEmulator - external emulator handle.
*
* RETURNS:
* ordinal value (>0).
*
*/
int emuQueryEmulatorId(const HEMU hEmulator)
{
const HHEMU hhEmu = (HHEMU)hEmulator;
int nEmuId;
if (hhEmu == 0)
{
assert(0);
return -1;
}
emuLock(hEmulator);
nEmuId = hhEmu->stUserSettings.nEmuId;
emuUnlock(hEmulator);
return (nEmuId);
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
* emuLoad
*
* DESCRIPTION:
* Loads all pertinent tables into memory for the specified emulator.
*
* ARGUMENTS: hEmu External Emulator Handle.
* nEmuId ID that identifies a specific emulator.
* fForceLoad -
*
*
* RETURNS: 0 if successful. -1 if nEmuId is invalid.
*
*/
int emuLoad(const HEMU hEmu, const int nEmuId)
{
const HHEMU hhEmu = (HHEMU)hEmu;
int col;
void (*emuInitFunction)(const HHEMU hhEmu);
if (hEmu == 0)
{
assert(0);
return -2;
}
emuLock(hEmu);
// If the requested emulator is already loaded, return.
//
if (hhEmu->nEmuLoaded == nEmuId)
{
emuUnlock(hEmu);
return 0;
}
// Validate nEmuId and set set initialization function.
switch(nEmuId)
{
#if defined(INCL_MINITEL)
case EMU_MINI:
if (hhEmu->nEmuLoaded == EMU_AUTO && hhEmu->hSession)
{
HCOM hCom = sessQueryComHdl(hhEmu->hSession);
HCLOOP hCLoop = sessQueryCLoopHdl(hhEmu->hSession);
HCNCT hCnct = sessQueryCnctHdl(hhEmu->hSession);
if (hCom && ComValidHandle(hCom))
{
int iDataBits = 8;
int iParity = NOPARITY;
int iStopBits = ONESTOPBIT;
ComGetDataBits(hCom, &iDataBits);
ComGetParity(hCom, &iParity);
ComGetStopBits(hCom, &iStopBits);
//
// Force the incoming ASCII data to 7 bit.
//
CLoopSetASCII7(hCLoop, TRUE);
if (iDataBits != 7 || iParity != EVENPARITY || iStopBits != ONESTOPBIT)
{
const HHCNCT hhCnct = (HHCNCT)hCnct;
ComSetDataBits(hCom, 7);
ComSetParity(hCom, EVENPARITY);
ComSetStopBits(hCom, ONESTOPBIT);
ComSetAutoDetect(hCom, FALSE);
if (hCnct)
{
HHDRIVER hhDriver = (HHDRIVER)hhCnct->hDriver;
if (hhDriver && cncttapiSetLineConfig(hhDriver->dwLine, hCom) == -16)
{
cnctDisconnect(hCnct, CNCT_DIALNOW | CNCT_XFERABORTCONFIRM);
}
}
}
}
}
emuInitFunction = emuMinitelInit;
break;
#endif
case EMU_AUTO:
emuInitFunction = emuAutoInit;
break;
case EMU_ANSIW:
case EMU_ANSI:
emuInitFunction = emuAnsiInit;
break;
case EMU_TTY:
emuInitFunction = emuAnsiInit;
break;
case EMU_VT100J:
case EMU_VT100:
emuInitFunction = vt100_init;
break;
case EMU_VT52:
emuInitFunction = vt52_init;
break;
#if defined(INCL_VT220)
case EMU_VT220:
emuInitFunction = vt220_init;
break;
#endif
#if defined(INCL_VT320)
case EMU_VT320:
emuInitFunction = vt220_init; // The VT320 is the same as the VT220.
break;
#endif
#if defined(INCL_VT100PLUS)
case EMU_VT100PLUS:
emuInitFunction = vt100_init; // The VT100+ is the same as the VT100.
break;
#endif
#if defined(INCL_VTUTF8)
case EMU_VTUTF8:
emuInitFunction = vtutf8_init;
break;
#endif
#if defined(INCL_VIEWDATA)
case EMU_VIEW:
emuInitFunction = EmuViewdataInit;
break;
#endif
default:
emuUnlock(hEmu);
return(-1);
}
// Remove the current emulator, if one is loaded.
//
if (hhEmu->emu_deinstall)
(*hhEmu->emu_deinstall)(hhEmu);
// Save the new emulator Id.
//
hhEmu->stUserSettings.nEmuId = nEmuId;
hhEmu->nEmuLoaded = nEmuId;
// setup function pointers to standard routines.
hhEmu->EmuSetCursorType = EmuStdSetCursorType;
hhEmu->emuResetTerminal = stdResetTerminal;
hhEmu->emu_graphic = emuStdGraphic;
#if defined(EXTENDED_FEATURES)
hhEmu->emu_datain = emuStdDataIn;
#else
hhEmu->emu_datain = emuDataIn;
#endif
hhEmu->emu_kbdin = std_kbdin;
hhEmu->emu_getscrsize = std_getscrsize;
#ifdef INCL_TERMINAL_SIZE_AND_COLORS
hhEmu->emu_setscrsize = std_setscrsize;
#endif
hhEmu->emu_getscrollcnt = std_getscrollcnt;
hhEmu->emu_getcurpos = std_getcurpos;
hhEmu->emu_setcurpos = std_setcurpos;
hhEmu->emu_getattr = std_getattr;
hhEmu->emu_setattr = std_setattr;
hhEmu->emu_setcolors = std_setcolors;
hhEmu->emu_getcolors = std_getcolors;
hhEmu->emu_initcolors = std_initcolors;
hhEmu->emu_clearscreen = std_clearscreen;
hhEmu->emu_clearline = std_clearline;
hhEmu->emu_clearrgn = std_clearrgn;
hhEmu->emu_scroll = std_scroll;
hhEmu->emu_deinstall = std_deinstall;
hhEmu->emu_ntfy = std_emu_ntfy;
hhEmu->emuHomeHostCursor= std_HomeHostCursor;
hhEmu->emu_maxrow = EMU_DEFAULT_MAXROW;
hhEmu->emu_maxcol = EMU_DEFAULT_MAXCOL;
hhEmu->bottom_margin = hhEmu->emu_maxrow; // mrw:2/21/96
hhEmu->top_margin = 0; // mrw:2/21/96
hhEmu->emu_charattr = hhEmu->attrState[CS_STATE];
hhEmu->emu_clearattr =
hhEmu->emu_clearattr_sav = hhEmu->attrState[CSCLEAR_STATE];
// Initialize mode variables.
//
hhEmu->mode_KAM = RESET; /* Enable Keyboard */
hhEmu->mode_IRM = RESET; /* Replace chars rather than insert */
hhEmu->mode_VEM = RESET; /* Inserting lines scrolls down, not up */
hhEmu->mode_HEM = RESET; /* Inserting chars scrolls right, not left */
hhEmu->mode_SRM = SET; /* Send-Receive. No local character echo */
hhEmu->mode_LNM = RESET; /* LF moves vertically only */
hhEmu->mode_DECOM = RESET; /* Absolute cursor positioning */
hhEmu->mode_DECPFF = RESET; /* No form feed after screen prINT */
hhEmu->mode_DECPEX = RESET; /* PrINT only scroll rgn. on screen prINT */
hhEmu->mode_DECSCNM = RESET; /* Screen mode. RESET=normal vid, SET=reverse vid */
hhEmu->mode_DECTCEM = SET; /* Cursor enable. RESET=hidden, SET=visible */
hhEmu->mode_25enab = RESET; /* When true (SET), emulator can use 25th line */
hhEmu->mode_protect = RESET; /* When true (SET), protected mode is on */
hhEmu->mode_block = RESET; /* When true (SET), block mode is on */
hhEmu->mode_local = RESET; /* When true (SET), block mode is on */
hhEmu->print_echo = FALSE;
// Initialize state table.
//
hhEmu->emu_highchar = 0x7F;
// Set default tab stops to 8.
//
//for (col = 0; col <= EMU_DEFAULT_MAXCOL; ++col)
// Need to define tab stops for the whole screen so received tabs
// with cursor at column 72 or more will go to the next tab rather
// than the right edge of the screen. 22 Apr 99 rde
for (col = 0; col < MAX_EMUCOLS; ++col)
{
if (!(col % 8))
hhEmu->tab_stop[col] = TRUE;
}
// Call initialization function for emulator.
//
(*emuInitFunction)(hhEmu);
// Paints every cell with the new attributes...
//
std_initcolors(hhEmu);
#ifdef INCL_TERMINAL_SIZE_AND_COLORS
// Update the screen size.
//
hhEmu->emu_setscrsize(hhEmu);
#endif
// We want the terminal to read the emulator image after loading
// but we don't want a scroll operation so update each line
// individually - mrw
updateLine(sessQueryUpdateHdl(hhEmu->hSession), 0, hhEmu->emu_maxrow);
NotifyClient(hhEmu->hSession, EVENT_EMU_CLRATTR, 0);
NotifyClient(hhEmu->hSession, EVENT_EMU_SETTINGS, 0);
NotifyClient(hhEmu->hSession, EVENT_TERM_UPDATE, 0);
emuUnlock(hEmu);
PostMessage(sessQueryHwndStatusbar(hhEmu->hSession),
SBR_NTFY_REFRESH, (WPARAM)SBR_EMU_PART_NO, 0);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQuerySettings
*
* DESCRIPTION:
* This function returns a copy of the of the User Settings structure
* found in the internal emulator handle.
*
* ARGUMENTS:
* HEMU - The External emulator handle.
* PSTEMUSET - A pointer to a structure of type STEMUSET
*
* RETURNS:
* 0=OK, else error
*
*/
int emuQuerySettings(const HEMU hEmu, PSTEMUSET pstSettings)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(0);
return -1;
}
emuLock(hEmu);
MemCopy(pstSettings, &hhEmu->stUserSettings, sizeof(STEMUSET));
emuUnlock(hEmu);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuSetSettings
*
* DESCRIPTION:
* This function stores the Emulator Settings in the internal Emualtor
* handle. This function DOES NOT save the information in the session
* file. The values to be set are validated. If any values passed
* into this routine are invalid, default values will be set.
*
* ARGUMENTS:
*
* RETURNS:
* 0 if the values passed in are validated. A number less than 0 will
* be returned if any one of the values are invalid. Note that in the
* case of several invalid settings, the return value will point only
* to the last one that was invalid.
*
*/
int emuSetSettings(const HEMU hEmu, const PSTEMUSET pstSettings)
{
const HHEMU hhEmu = (HHEMU)hEmu;
int iReturn;
if (hhEmu == 0)
{
assert(0);
return -1;
}
iReturn = 0;
switch(pstSettings->nEmuId)
{
case EMU_AUTO:
case EMU_ANSI:
case EMU_ANSIW:
case EMU_MINI:
case EMU_VIEW:
case EMU_TTY:
case EMU_VT100:
case EMU_VT100J:
case EMU_VT52:
case EMU_VT220:
case EMU_VT320:
case EMU_VT100PLUS:
case EMU_VTUTF8:
break;
default:
pstSettings->nEmuId = EMU_AUTO;
iReturn = -1;
assert(FALSE);
break;
}
switch(pstSettings->nTermKeys)
{
case EMU_KEYS_ACCEL:
case EMU_KEYS_TERM:
case EMU_KEYS_SCAN:
break;
default:
pstSettings->nTermKeys = EMU_KEYS_TERM;
iReturn = -2;
assert(FALSE);
break;
}
switch(pstSettings->nCursorType)
{
case EMU_CURSOR_BLOCK:
case EMU_CURSOR_LINE:
case EMU_CURSOR_NONE:
break;
default:
pstSettings->nCursorType = EMU_CURSOR_LINE;
iReturn = -3;
assert(FALSE);
break;
}
switch(pstSettings->nCharacterSet)
{
case EMU_CHARSET_ASCII:
case EMU_CHARSET_UK:
case EMU_CHARSET_SPECIAL:
#if defined(INCL_VT220)
case EMU_CHARSET_MULTINATIONAL:
case EMU_CHARSET_FRENCH:
case EMU_CHARSET_FRENCHCANADIAN:
case EMU_CHARSET_GERMAN:
#endif
break;
default:
pstSettings->nCharacterSet = EMU_CHARSET_ASCII;
iReturn = -4;
assert(FALSE);
break;
}
// The values to be set have been validated. Set the emulator handle
// values, and the internal emualtor variables that correspond.
//
emuLock(hEmu);
#ifdef INCL_TERMINAL_SIZE_AND_COLORS
if (pstSettings->nTextColor != hhEmu->stUserSettings.nTextColor ||
pstSettings->nBackgroundColor != hhEmu->stUserSettings.nBackgroundColor)
{
// The user defined colors have changed--implement them.
std_setcolors(hhEmu,
pstSettings->nTextColor,
pstSettings->nBackgroundColor);
}
#endif
// When called from emuInitializeHdl, the source and dest pointers
// for the following call are the same, so there's no need to
// to do the copy.
//
if(&hhEmu->stUserSettings != pstSettings)
MemCopy(&hhEmu->stUserSettings, pstSettings, sizeof(STEMUSET));
hhEmu->iCurType = hhEmu->stUserSettings.nCursorType;
hhEmu->mode_AWM = hhEmu->stUserSettings.fWrapLines;
hhEmu->mode_DECKPAM = hhEmu->stUserSettings.fKeypadAppMode;
hhEmu->mode_DECCKM = hhEmu->stUserSettings.fCursorKeypadMode;
hhEmu->fUse8BitCodes = hhEmu->stUserSettings.fUse8BitCodes;
hhEmu->fAllowUserKeys = hhEmu->stUserSettings.fAllowUserKeys;
// Call emuSetDecColumns only if the emulator is a VT100, and
// there has been change in the user setting of 132 column mode.
//
emuSetDecColumns(hhEmu,
hhEmu->stUserSettings.f132Columns ?
VT_MAXCOL_132MODE :
VT_MAXCOL_80MODE,
FALSE);
#ifdef INCL_TERMINAL_SIZE_AND_COLORS
// Set the possible new row and column values if
// the emulator is not about to change.
//
hhEmu->emu_setscrsize(hhEmu);
#endif
emuUnlock(hEmu);
NotifyClient(hhEmu->hSession, EVENT_EMU_SETTINGS, 0);
//JMH 01-09-97 These two events also need to be sent, says JCM.
//
NotifyClient(hhEmu->hSession, EVENT_TERM_UPDATE, 0);
NotifyClient(hhEmu->hSession, EVENT_EMU_CLRATTR, 0);
return(iReturn);
}
#if defined(EXTENDED_FEATURES) //TODO:rde 23 mar 98
// When we're comfortable enough with changing to using a function
// pointer here, do it for all builds.
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuDataIn
*
* DESCRIPTION:
* External entry point for incoming data.
*
* ARGUMENTS:
* hEmu - public emulator handle
* ccode - character code
*
* RETURNS:
* TRUE if displayable
*
*/
int emuDataIn(const HEMU hEmu, const ECHAR ccode)
{
int iRetVal = TRUE;
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(FALSE);
}
else
{
emuLock(hEmu);
CaptureChar(sessQueryCaptureFileHdl(hhEmu->hSession),
CPF_MODE_RAW,
ccode); //moved from emuStdDataIn 05AUG98 mpt
emuUnlock(hEmu);
iRetVal = (*hhEmu->emu_datain)(hhEmu, ccode);
}
return iRetVal;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
* emuStdDataIn
*
* DESCRIPTION:
* Processes passed in codes through the emulation state tables.
*
* ARGUMENTS:
* hhEmu - The internal emulator handle.
* ccode - The character to process.
*
* RETURNS:
* TRUE if displayable character
*/
int emuStdDataIn(const HHEMU hhEmu, const ECHAR ccode)
{
//ECHAR echCode;
int ntrans;
struct trans_entry *tptr;
emuLock((HEMU)hhEmu);
hhEmu->emu_code = ETEXT(ccode);
// Capture raw data.
//
#if 0 //moved to emuDataIn to prevent characters being captures
//multiple times due to the re-entrant nature of this function. - mpt 5aug98
CaptureChar(sessQueryCaptureFileHdl(hhEmu->hSession),
CPF_MODE_RAW,
ccode);
#endif
// Seek next state by finding character range.
//
tptr = hhEmu->state_tbl[hhEmu->state].first_trans;
ntrans = hhEmu->state_tbl[hhEmu->state].number_trans;
for (; ntrans > 0; ntrans--, ++tptr)
if (ccode >= tptr->lochar && ccode <= tptr->hichar)
break;
if (ntrans <= 0)
{
// Added to handle the case of 2 successive ESC chars--just
// the 1st ESC should be thrown away
hhEmu->state = 0;
tptr = hhEmu->state_tbl[hhEmu->state].first_trans;
ntrans = hhEmu->state_tbl[hhEmu->state].number_trans;
for (; ntrans > 0; ntrans--, ++tptr)
{
if (ccode >= tptr->lochar && ccode <= tptr->hichar)
break;
}
// 6-14-83
// second condition (below) added to allow emulator to toss invalid
// escpae sequences (i.e.ESC [ 0v).
if (ntrans <= 0 || tptr->next_state == 0)
{
commanderror(hhEmu);
goto DataInExit;
}
else
{
CaptureChar(sessQueryCaptureFileHdl(hhEmu->hSession),
CF_CAP_CHARS, ccode);
printEchoChar(hhEmu->hPrintEcho, ccode);
}
}
hhEmu->state = tptr->next_state;
(*tptr->funct_ptr)(hhEmu);
// The code has been process through the emulator. Check for
// capturing and printing, and reset other emulator values.
//
if (hhEmu->state == 0)
{
if (IN_RANGE(ccode, ETEXT(' '), hhEmu->emu_highchar) ||
ccode == ETEXT('\r') ||
ccode == ETEXT('\n'))
{
CaptureChar(sessQueryCaptureFileHdl(hhEmu->hSession),
CF_CAP_CHARS, ccode);
printEchoChar(hhEmu->hPrintEcho, ccode);
}
hhEmu->num_param_cnt = hhEmu->selector_cnt =
hhEmu->selector[0] = hhEmu->num_param[0] = 0;
hhEmu->DEC_private = FALSE;
}
DataInExit:
emuUnlock((HEMU)hhEmu);
return(TRUE);
}
//#if FALSE
#else
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
* emuDataIn
*
* DESCRIPTION:
* Processes passed in codes through the emulation state tables.
*
* ARGUMENTS:
* hhEmu - The internal emulator handle.
* ccode - The character to process.
*
* RETURNS:
* TRUE if displayable character
*/
int emuDataIn(const HEMU hEmu, const ECHAR ccode)
{
//ECHAR echCode;
int ntrans;
struct trans_entry *tptr;
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(FALSE);
goto DataInExit;
}
emuLock(hEmu);
hhEmu->emu_code = ETEXT(ccode);
// Capture raw data.
//
CaptureChar(sessQueryCaptureFileHdl(hhEmu->hSession),
CPF_MODE_RAW,
ccode);
// Seek next state by finding character range.
//
tptr = hhEmu->state_tbl[hhEmu->state].first_trans;
ntrans = hhEmu->state_tbl[hhEmu->state].number_trans;
for (; ntrans > 0; ntrans--, ++tptr)
if (ccode >= tptr->lochar && ccode <= tptr->hichar)
break;
if (ntrans <= 0)
{
// Added to handle the case of 2 successive ESC chars--just
// the 1st ESC should be thrown away
hhEmu->state = 0;
tptr = hhEmu->state_tbl[hhEmu->state].first_trans;
ntrans = hhEmu->state_tbl[hhEmu->state].number_trans;
for (; ntrans > 0; ntrans--, ++tptr)
{
if (ccode >= tptr->lochar && ccode <= tptr->hichar)
break;
}
// 6-14-83
// second condition (below) added to allow emulator to toss invalid
// escpae sequences (i.e.ESC [ 0v).
if (ntrans <= 0 || tptr->next_state == 0)
{
commanderror(hhEmu);
goto DataInExit;
}
else
{
CaptureChar(sessQueryCaptureFileHdl(hhEmu->hSession),
CF_CAP_CHARS, ccode);
printEchoChar(hhEmu->hPrintEcho, ccode);
}
}
hhEmu->state = tptr->next_state;
(*tptr->funct_ptr)(hhEmu);
// The code has been process through the emulator. Check for
// capturing and printing, and reset other emulator values.
//
if (hhEmu->state == 0)
{
if (IN_RANGE(ccode, ETEXT(' '), hhEmu->emu_highchar) ||
ccode == ETEXT('\r') ||
ccode == ETEXT('\n'))
{
CaptureChar(sessQueryCaptureFileHdl(hhEmu->hSession),
CF_CAP_CHARS, ccode);
printEchoChar(hhEmu->hPrintEcho, ccode);
}
hhEmu->num_param_cnt = hhEmu->selector_cnt =
hhEmu->selector[0] = hhEmu->num_param[0] = 0;
hhEmu->DEC_private = FALSE;
}
DataInExit:
emuUnlock(hEmu);
return(TRUE);
}
#endif
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuNotify
*
* DESCRIPTION:
* A function that can be called to notify the emulators of an event.
* As events are identified, they can be added to this function.
*
* ARGUMENTS:
* hEmu - The external emulator handle.
* nEvent - The event ID.
*
* RETURNS:
* 0=OK, else error
*
*/
int emuNotify(const HEMU hEmu, const int nEvent)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(FALSE);
return -1;
}
emuLock(hEmu);
switch(nEvent)
{
case EMU_EVENT_CONNECTED:
hhEmu->fWasConnected = TRUE;
break;
case EMU_EVENT_DISCONNECTED:
if (hhEmu->stUserSettings.nEmuId == EMU_AUTO)
{
if (hhEmu->fWasConnected)
hhEmu->stUserSettings.nAutoAttempts++;
if (hhEmu->stUserSettings.nAutoAttempts ==
EMU_MAX_AUTODETECT_ATTEMPTS)
#if !defined(FAR_EAST)
emuAutoDetectLoad(hhEmu, EMU_ANSI);
#else
emuAutoDetectLoad(hhEmu, EMU_ANSIW);
#endif
}
hhEmu->fWasConnected = FALSE;
break;
default:
break;
}
(*hhEmu->emu_ntfy)(hhEmu, nEvent);
emuUnlock(hEmu);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuHomeHostCursor
*
* DESCRIPTION:
* Homes the cursor. Needed when we first load a session. Incidently,
* homing the cursor for a minitel places the cursor at 1,0, not 0,0
* which is why this function exists.
*
* ARGUMENTS:
* hEmu - public emulator handle.
*
* RETURNS:
* 0=OK,else error
*
*/
int emuHomeHostCursor(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
if (hhEmu == 0)
{
assert(0);
return -1;
}
return (*hhEmu->emuHomeHostCursor)(hhEmu);
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuEraseTerminalScreen
*
* DESCRIPTION:
* Erases emulator image, doesn't put stuff in the backscroll.
*
* ARGUMENTS:
* hEmu - public emulator handle.
*
* RETURNS:
* 0=OK,else error
*
*/
int emuEraseTerminalScreen(const HEMU hEmu)
{
const HHEMU hhEmu = (HHEMU)hEmu;
int i;
if (hhEmu == 0)
{
assert(0);
return -1;
}
for (i = 0 ; i <= hhEmu->emu_maxrow ; ++i)
clear_imgrow(hhEmu, i);
updateLine(sessQueryUpdateHdl(hhEmu->hSession), 0, hhEmu->emu_maxrow);
// The notify function is used to in minitel to set the state
// of the screen based on connection status (F or C in upper corner).
//
hhEmu->emu_ntfy(hhEmu, 0);
return 0;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuQueryDefaultTelnetId
*
* DESCRIPTION:
* Gets the default telnet terminal id string for the given emulator.
*
* ARGUMENTS:
* nEmuId - id of the emulator (e.g. EMU_ANSI).
* achTelnetId - pointer to the buffer for the string.
* nSize - size of the buffer (in characters).
*
* RETURNS:
* 0=OK, else error
*
* AUTHOR: C. Baumgartner, 11/15/96
*/
int emuQueryDefaultTelnetId(const int nEmuId, TCHAR *achTelnetId, int nSize)
{
int iRet = 0;
TCHAR * pszDefaultId;
// Note : Since these strings are a part of the telnet
// protocol, it is okay if they are hard-coded.
//
switch(nEmuId)
{
case EMU_AUTO:
case EMU_ANSI:
pszDefaultId = TEXT("ANSI");
break;
case EMU_TTY:
pszDefaultId = TEXT("TELETYPE-33");
break;
case EMU_VT52:
pszDefaultId = TEXT("VT52");
break;
#if defined(INCL_VT220)
case EMU_VT220:
pszDefaultId = TEXT("VT220");
break;
#endif
#if defined(INCL_VT320)
case EMU_VT320:
pszDefaultId = TEXT("VT320");
break;
#endif
#if defined(INCL_VT100PLUS)
case EMU_VT100PLUS:
pszDefaultId = TEXT("VT100+");
break;
#endif
#if defined(INCL_VTUTF8)
case EMU_VTUTF8:
pszDefaultId = TEXT("VT-UTF8");
break;
#endif
case EMU_VT100:
default:
pszDefaultId = TEXT("VT100");
break;
}
if ( StrCharGetStrLength(pszDefaultId) < nSize )
{
StrCharCopyN(achTelnetId, pszDefaultId, nSize);
iRet = 0;
}
else
{
iRet = -1;
}
return iRet;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuLoadDefaultTelnetId
*
* DESCRIPTION:
* Loads the given emulator handle with the default telnet terminal id
* string for the current emulator type.
*
* ARGUMENTS:
* hEmu - A public emulator handle
*
* RETURNS:
* 0=OK, else error
*
* AUTHOR: C. Baumgartner, 11/18/96
*/
int emuLoadDefaultTelnetId(const HEMU hEmu)
{
HHEMU hhEmu = (HHEMU)hEmu;
return emuQueryDefaultTelnetId(hhEmu->stUserSettings.nEmuId,
hhEmu->stUserSettings.acTelnetId, EMU_MAX_TELNETID);
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuLoadSettings
*
* DESCRIPTION:
* Loads the given emulator user settings.
*
* ARGUMENTS:
* hhEmu - an internal emulator handle
* uiId - the SFID of the data to load
* ulDataSize - the size of the data to load (in bytes)
* pvData - address at which to put the data
*
* RETURNS:
* The size (in bytes) of the data loaded, -1 if an error occured
*
* AUTHOR: Bob Everett - 6 Jun 1998
*/
STATIC_FUNC int emuLoadSettings(const HHEMU hhEmu,
const unsigned int uiId,
unsigned long ulDataSize,
void *pvData)
{
int iResult = 0;
int iRetVal = 0;
unsigned long ulSize = 0;
// Do the screen color settings exist?
sfGetSessionItem(sessQuerySysFileHdl(hhEmu->hSession), uiId, &ulSize, 0);
if (ulSize > 0)
{
// The settings exist. Go get them.
iResult = sfGetSessionItem(sessQuerySysFileHdl(hhEmu->hSession),
uiId, &ulDataSize, pvData);
if (iResult != 0)
iRetVal = -1;
else
iRetVal = (int)ulSize;
}
return iRetVal;
}
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
* FUNCTION:
* emuCheckSettings
*
* DESCRIPTION:
* This ugly piece of code checks for a mismatch in settings between versions.
* The settings affected are fUse8BitCodes, fAllowUserKeys, nBackspaceKeys,
* and acTelnetId. The mismatch occurs when moving an HTPE3 session file to
* any newer version. This includes HT98 and HTPE4.
*
* ARGUMENTS:
* hhEmu - an internal emulator handle
*
* RETURNS:
* Nada, zip, not a thing.
*
* AUTHOR: Bob Everett - 8 Jun 1998
*/
STATIC_FUNC void emuCheckSettings(struct stEmuBaseSFSettings *pstBaseSFSettings)
{
TCHAR *psz = 0;
TCHAR sz[EMU_MAX_TELNETID];
if ((pstBaseSFSettings->nBackspaceKeys != EMU_BKSPKEYS_CTRLH) &&
(pstBaseSFSettings->nBackspaceKeys != EMU_BKSPKEYS_DEL) &&
(pstBaseSFSettings->nBackspaceKeys != EMU_BKSPKEYS_CTRLHSPACE))
{
// This is the best test for this scenario. Move the data.
psz = (TCHAR *)&pstBaseSFSettings->fAllowUserKeys;
if (StrCharGetStrLength(psz) < EMU_MAX_TELNETID)
{
StrCharCopyN(sz, psz, sizeof(sz) / sizeof(TCHAR));
StrCharCopyN(pstBaseSFSettings->acTelnetId, sz, EMU_MAX_TELNETID );
}
pstBaseSFSettings->nBackspaceKeys =
pstBaseSFSettings->fUse8BitCodes;
// Use the defaults.
pstBaseSFSettings->fUse8BitCodes = FALSE;
pstBaseSFSettings->fAllowUserKeys = FALSE;
}
// Check the data.
if ((pstBaseSFSettings->fUse8BitCodes != TRUE) &&
(pstBaseSFSettings->fUse8BitCodes != FALSE))
pstBaseSFSettings->fUse8BitCodes = FALSE;
if ((pstBaseSFSettings->fAllowUserKeys != TRUE) &&
(pstBaseSFSettings->fAllowUserKeys != FALSE))
pstBaseSFSettings->fAllowUserKeys = FALSE;
if ((pstBaseSFSettings->nBackspaceKeys != EMU_BKSPKEYS_CTRLH) &&
(pstBaseSFSettings->nBackspaceKeys != EMU_BKSPKEYS_DEL) &&
(pstBaseSFSettings->nBackspaceKeys != EMU_BKSPKEYS_CTRLHSPACE))
{
pstBaseSFSettings->nBackspaceKeys = EMU_BKSPKEYS_CTRLH;
// Assume that if nBackspaceKeys is messed up, so is acTelnetId.
pstBaseSFSettings->acTelnetId[0] = TEXT('\0');
}
}