1007 lines
26 KiB
C++
1007 lines
26 KiB
C++
/*****************************************************************************/
|
|
/*
|
|
Vcc Copyright 2015 by Joseph Forgione.
|
|
This file is part of VCC (Virtual Color Computer)
|
|
|
|
VCC (Virtual Color Computer) is free software: you can redistribute
|
|
it and/or modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation, either version 3 of the
|
|
License, or (at your option) any later version.
|
|
|
|
VCC (Virtual Color Computer) is distributed in the hope that it will
|
|
be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with VCC (Virtual Color Computer). If not, see
|
|
<http://www.gnu.org/licenses/>.
|
|
|
|
Keyboard Edit author: E J Jaquay 2021
|
|
*/
|
|
|
|
/*-------------------------------------------------------
|
|
// Functions defined here that are called by config.c:
|
|
KeyMapProc
|
|
SaveCustomKeyMap
|
|
LoadCustomKeyMap
|
|
CloneStandardKeymap
|
|
*/
|
|
|
|
#include <Windows.h>
|
|
#include <windowsx.h>
|
|
#include <stdio.h>
|
|
#include <intrin.h>
|
|
|
|
#include "defines.h"
|
|
#include "config.h"
|
|
|
|
#include <vcc/util/logger.h>
|
|
#include "keyboard.h"
|
|
#include "keyboardLayout.h"
|
|
#include "keyboardEdit.h"
|
|
#include "keynames.h"
|
|
|
|
// Modifier Button id's
|
|
static int ModBtnCode[4] = {0,IDC_KEYBTN_LSHIFT,IDC_KEYBTN_CTRL,IDC_KEYBTN_ALT};
|
|
|
|
// Modifier ScanCodes
|
|
static int ModScanCode[4] = {0,DIK_LSHIFT,DIK_LCONTROL,DIK_LMENU};
|
|
|
|
// Modifier Names
|
|
static const char *ModName[4] = {"","Shift","Ctrl","Alt"};
|
|
|
|
// Windows handles
|
|
HWND hKeyMapDlg = nullptr; // Key map dialog
|
|
HWND hText_PC = nullptr; // Control to display PC Key.
|
|
HWND hText_CC = nullptr; // Control to display selected CoCo Keys
|
|
|
|
// Subclass Text_PC control processing to capture all PC keystrokes
|
|
LRESULT CALLBACK SubText_PCproc(HWND,UINT,WPARAM,LPARAM);
|
|
WNDPROC Text_PCproc;
|
|
|
|
// CoCo and Host PC buttons and keys that are currently selected
|
|
// Note Left and Right modifiers are tied together
|
|
int CC_KeySelected; // BtnId
|
|
int CC_ModSelected; // 0,1,2,3
|
|
int PC_KeySelected; // ScanCode
|
|
int PC_ModSelected; // 0,1,2,3
|
|
|
|
// Current CoCo key button states (up/down)
|
|
// Used to raise currently down buttons
|
|
BOOL CoCoKeySet; // BtnId
|
|
BOOL CoCoModSet; // 0,1,2,3
|
|
|
|
// Pointer for selected translation entry
|
|
keytranslationentry_t * pKeyTran = nullptr;
|
|
|
|
// Counter to limit the number of popup error messages
|
|
int UserWarned = 0;
|
|
|
|
// Background and Font for dynamic text boxes
|
|
HBRUSH hbrTextBox = nullptr;
|
|
HFONT hfTextBox = nullptr;
|
|
|
|
// Keymap data changed flag
|
|
BOOL KeyMapChanged = FALSE;
|
|
|
|
// Forward references
|
|
BOOL InitKeymapDialog(HWND);
|
|
BOOL Process_CoCoKey(int);
|
|
BOOL SetCustomKeymap();
|
|
BOOL SetControlFont(WPARAM,LPARAM);
|
|
void CoCoModifier(int);
|
|
void ShowCoCoKey();
|
|
void SetPCmod(int);
|
|
void ShowPCkey();
|
|
void SetCoCokey();
|
|
void DoKeyDown(WPARAM,LPARAM);
|
|
void ShowMapError(int, const char *);
|
|
void SetDialogFocus(HWND);
|
|
int GetKeymapLine (char*, keytranslationentry_t *, int);
|
|
const char *GenKeymapLine(const keytranslationentry_t *);
|
|
|
|
// Lookup functions for keyname tables
|
|
static struct CoCoKey * cctable_rowcol_lookup(unsigned char, unsigned char);
|
|
static struct CoCoKey * cctable_keyid_lookup();
|
|
static struct CoCoKey * cocotable_keyname_lookup(const char *);
|
|
static struct PCScanCode * scantable_scancode_lookup(int);
|
|
static struct PCScanCode * scantable_keyname_lookup(const char *);
|
|
|
|
/**************************************************/
|
|
/* Load custom keymap from file */
|
|
/**************************************************/
|
|
|
|
int LoadCustomKeyMap(const char* keymapfile)
|
|
{
|
|
FILE *keymap;
|
|
char buf[256];
|
|
int ndx = 0;
|
|
int lnum = 0;
|
|
|
|
// Do nothing if keymap file path is empty
|
|
if (*keymapfile == '\0') return 1;
|
|
|
|
// Open the keymap file. Create default if open fails.
|
|
if ((keymap = fopen(keymapfile,"r")) == nullptr) {
|
|
if (! UserWarned) {
|
|
UserWarned = 1;
|
|
MessageBox(GetActiveWindow(),
|
|
"Custom keymap read failed. Using defaults","Warning",0);
|
|
}
|
|
SaveCustomKeyMap(keymapfile);
|
|
return 1;
|
|
}
|
|
UserWarned = 0;
|
|
|
|
// clear the custom keymap.
|
|
memset ( keyTranslationsCustom, 0,
|
|
sizeof(keytranslationentry_t)*MAX_CTRANSTBLSIZ);
|
|
|
|
// load keymap from file.
|
|
while (fgets(buf,250,keymap)) {
|
|
lnum++;
|
|
// Get line from file, save valid entries in table
|
|
if (GetKeymapLine(buf, &keyTranslationsCustom[ndx],lnum)==0) {
|
|
ndx++;
|
|
if (ndx > MAX_CTRANSTBLSIZ-1) {
|
|
// Translation table overflow! (Can this actually happen?)
|
|
// TODO: If it does correct condition and warn user
|
|
// ShowMapError(lnum,"Translation table full!");
|
|
fclose(keymap);
|
|
return 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose(keymap);
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Parse a line from keymap file into trans table entry
|
|
//-----------------------------------------------------
|
|
int GetKeymapLine ( char* line, keytranslationentry_t * trans, int lnum)
|
|
{
|
|
const char *pStr;
|
|
static struct PCScanCode * pPCScanCode; // FIXME: Why is this static?
|
|
static struct CoCoKey * pCoCoKey; // FIXME: Why is this static?
|
|
|
|
// pc scancode -> ScanCode1
|
|
pStr = strtok(line, " \t\n\r");
|
|
if ((pStr == nullptr) || (*pStr == '#')) return 1; // A comment, skip it
|
|
|
|
pPCScanCode = scantable_keyname_lookup(pStr);
|
|
if (pPCScanCode == nullptr) {
|
|
ShowMapError(lnum,"PC Scancode not recognized");
|
|
return 2;
|
|
}
|
|
trans->ScanCode1 = pPCScanCode->ScanCode;
|
|
|
|
// pc modifier -> ScanCode2
|
|
pStr = strtok(nullptr, " \t\n\r");
|
|
if (pStr == nullptr) {
|
|
ShowMapError(lnum,"PC Scancode modifier missing");
|
|
return 2;
|
|
}
|
|
|
|
// Generate scancode for modifier 1=shift,2=ctrl,3=alt
|
|
switch(*pStr) {
|
|
case '0':
|
|
trans->ScanCode2 = 0;
|
|
break;
|
|
case '1':
|
|
trans->ScanCode2 = DIK_LSHIFT;
|
|
break;
|
|
case '2':
|
|
trans->ScanCode2 = DIK_LCONTROL;
|
|
break;
|
|
case '3':
|
|
trans->ScanCode2 = DIK_LMENU;
|
|
break;
|
|
default:
|
|
ShowMapError(lnum,"PC key modifier not recognized");
|
|
return 2;
|
|
}
|
|
|
|
// CoCo Key -> Row1, Col1
|
|
pStr = strtok(nullptr, " \t\n\r");
|
|
if (pStr == nullptr) {
|
|
ShowMapError(lnum,"CoCo keyname missing");
|
|
return 2;
|
|
}
|
|
pCoCoKey = cocotable_keyname_lookup(pStr);
|
|
if (pCoCoKey == nullptr) {
|
|
ShowMapError(lnum,"CoCo keyname not recognized");
|
|
return 2;
|
|
}
|
|
trans->Row1 = 1 << pCoCoKey->row;
|
|
trans->Col1 = pCoCoKey->col;
|
|
|
|
// CoCo Key modifer -> Row2, Col2
|
|
pStr = strtok(nullptr, " \t\n\r");
|
|
|
|
// If modifier missing accept input anyway
|
|
if (pStr == nullptr) {
|
|
trans->Row2 = 0;
|
|
trans->Col2 = 0;
|
|
return 0;
|
|
}
|
|
|
|
// Generate row and col for modifier 1=shift,2=ctrl,3=alt
|
|
switch(*pStr) {
|
|
case '0':
|
|
trans->Row2 = 0;
|
|
trans->Col2 = 0;
|
|
break;
|
|
case '1':
|
|
trans->Row2 = 64;
|
|
trans->Col2 = 7;
|
|
break;
|
|
case '2':
|
|
trans->Row2 = 64;
|
|
trans->Col2 = 4;
|
|
break;
|
|
case '3':
|
|
trans->Row2 = 64;
|
|
trans->Col2 = 3;
|
|
break;
|
|
default:
|
|
ShowMapError(lnum,"CoCo key modifier not recognized");
|
|
return 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------
|
|
// Clone custom keymap from current standard keymap
|
|
//------------------------------------------------------
|
|
int CloneStandardKeymap(int keymap)
|
|
{
|
|
int i = 0;
|
|
keytranslationentry_t * dst = keyTranslationsCustom;
|
|
const keytranslationentry_t * src;
|
|
switch (keymap) {
|
|
case kKBLayoutCoCo:
|
|
src = keyTranslationsCoCo;
|
|
break;
|
|
case kKBLayoutNatural:
|
|
src = keyTranslationsNatural;
|
|
break;
|
|
case kKBLayoutCompact:
|
|
src = keyTranslationsCompact;
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
while (src->ScanCode1 != 0) {
|
|
*dst++ = *src++;
|
|
if (i++ == MAX_CTRANSTBLSIZ) break;
|
|
}
|
|
dst->ScanCode1 = 0;
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Save custom keymap to file
|
|
//-----------------------------------------------------
|
|
int SaveCustomKeyMap(const char* keymapfile)
|
|
{
|
|
const keytranslationentry_t * pTran;
|
|
pTran = keyTranslationsCustom;
|
|
|
|
FILE *omap;
|
|
FILE *kmap;
|
|
char tmpfile[MAX_PATH];
|
|
char tmppath[MAX_PATH];
|
|
|
|
char buf[256];
|
|
DWORD attr;
|
|
|
|
// Create a temporary file to hold the keymap
|
|
GetTempPath(MAX_PATH,tmppath);
|
|
GetTempFileName(tmppath,"KM_",0,tmpfile);
|
|
|
|
// Open it for write
|
|
kmap = fopen(tmpfile,"w");
|
|
if (kmap == nullptr) {
|
|
MessageBox(hKeyMapDlg,tmpfile,"open error",0);
|
|
return 1;
|
|
}
|
|
|
|
// If there was already a file by name specified
|
|
attr=GetFileAttributesA(keymapfile);
|
|
if ( (attr != INVALID_FILE_ATTRIBUTES) &&
|
|
!(attr & FILE_ATTRIBUTE_DIRECTORY) ) {
|
|
// Open the existing file
|
|
omap = fopen(keymapfile,"r");
|
|
if (omap == nullptr) {
|
|
MessageBox(hKeyMapDlg,keymapfile,"open error",0);
|
|
return 1;
|
|
}
|
|
// Copy comments to temporary file
|
|
while (fgets(buf,256,omap)) {
|
|
if (*buf != '#') break;
|
|
if( fputs(buf,kmap) < 0) {
|
|
MessageBox(hKeyMapDlg,keymapfile,"read error",0);
|
|
fclose(kmap);
|
|
return 2;
|
|
}
|
|
}
|
|
// Close and delete it
|
|
fclose(omap);
|
|
DeleteFile(keymapfile);
|
|
}
|
|
|
|
// Copy in contents of custom key translation table
|
|
while (pTran->ScanCode1 != 0) {
|
|
if( fputs(GenKeymapLine(pTran),kmap) < 0) {
|
|
MessageBox(hKeyMapDlg,tmpfile,"write error",0);
|
|
fclose(kmap);
|
|
return 3;
|
|
}
|
|
pTran++;
|
|
}
|
|
fclose(kmap);
|
|
|
|
// Rename temp file to keymapfile
|
|
if (!MoveFile(tmpfile,keymapfile)) {
|
|
MessageBox(hKeyMapDlg,tmpfile,"Rename error",0);
|
|
return 4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------
|
|
// Convert translation record for keymap file
|
|
//-----------------------------------------------------
|
|
const char * GenKeymapLine( const keytranslationentry_t * pTran )
|
|
{
|
|
static char txt[64];
|
|
static struct PCScanCode * pSC; // FIXME: Why is this static?
|
|
static struct CoCoKey * pCC; // FIXME: Why is this static?
|
|
int CCmod = 0;
|
|
int PCmod = 0;
|
|
|
|
// Determine PC key and modifier
|
|
if (pTran->ScanCode1 == 0) return nullptr;
|
|
if (pTran->Row1 == 0) return nullptr;
|
|
|
|
if (pTran->ScanCode2 != 0) {
|
|
switch (pTran->ScanCode1) {
|
|
case DIK_LSHIFT:
|
|
PCmod = 1;
|
|
break;
|
|
case DIK_LCONTROL:
|
|
PCmod = 2;
|
|
break;
|
|
case DIK_LMENU:
|
|
PCmod = 3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((pTran->ScanCode2 != 0) & (PCmod != 0)) {
|
|
pSC = scantable_scancode_lookup(pTran->ScanCode2);
|
|
} else {
|
|
pSC = scantable_scancode_lookup(pTran->ScanCode1);
|
|
switch (pTran->ScanCode2) {
|
|
case DIK_LSHIFT:
|
|
PCmod = 1;
|
|
break;
|
|
case DIK_LCONTROL:
|
|
PCmod = 2;
|
|
break;
|
|
case DIK_LMENU:
|
|
PCmod = 3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if (pSC == nullptr) return nullptr;
|
|
|
|
// Determine CoCo key and modifier
|
|
if (pTran->Row2 != 0) {
|
|
if (pTran->Row1 == 64) {
|
|
if (pTran->Col1 == 7) { // shift
|
|
CCmod = 1;
|
|
} else if (pTran->Col1 == 4) { // ctrl
|
|
CCmod = 2;
|
|
} else if (pTran->Col1 == 3) { // alt
|
|
CCmod = 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((pTran->Row2 != 0) & (CCmod != 0)) {
|
|
pCC = cctable_rowcol_lookup(pTran->Row2, pTran->Col2);
|
|
} else {
|
|
pCC = cctable_rowcol_lookup(pTran->Row1, pTran->Col1);
|
|
if (pTran->Row2 == 64) {
|
|
if (pTran->Col2 == 7) {
|
|
CCmod = 1;
|
|
} else if (pTran->Col2 == 4) {
|
|
CCmod = 2;
|
|
} else if (pTran->Col2 == 3) {
|
|
CCmod = 3;
|
|
}
|
|
}
|
|
}
|
|
if (pCC == nullptr) return nullptr;
|
|
|
|
sprintf(txt," DIK_%-12s %d COCO_%-10s %d\n",
|
|
pSC->keyname, PCmod, pCC->keyname, CCmod);
|
|
|
|
return txt;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Show message box for custom keymap load errors
|
|
//-----------------------------------------------------
|
|
|
|
void ShowMapError(int lnum, const char *msg)
|
|
{
|
|
if (UserWarned < 8) {
|
|
char fullmsg[128];
|
|
sprintf(fullmsg,"Line %d %s", lnum,msg);
|
|
MessageBox(hKeyMapDlg,fullmsg,"Error", 0);
|
|
} else if (UserWarned == 8) {
|
|
MessageBox(hKeyMapDlg,"Too many errors to show", "Error", 0);
|
|
}
|
|
UserWarned++;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Lookup sctable by scan code name. Binary search.
|
|
//-----------------------------------------------------
|
|
static struct
|
|
PCScanCode * scantable_keyname_lookup(const char * keyname)
|
|
{
|
|
int first = 0;
|
|
int last = (sizeof(sctable)/sizeof(sctable[0]))-1;
|
|
int mid = last / 2;
|
|
|
|
int cmp = strncmp(keyname,"DIK_", 4);
|
|
if (cmp != 0) return nullptr;
|
|
|
|
while (first < last) {
|
|
cmp = strcmp(keyname+4,sctable[mid].keyname);
|
|
if (cmp == 0) return &sctable[mid];
|
|
if (cmp > 0) {
|
|
first = mid + 1;
|
|
} else {
|
|
last = mid;
|
|
}
|
|
mid = (first+last)/2;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Lookup sctable by numeric scancode.
|
|
//-----------------------------------------------------
|
|
static struct
|
|
PCScanCode * scantable_scancode_lookup(int ScanCode)
|
|
{
|
|
int ndx;
|
|
|
|
// Build sctable_ndx on first call
|
|
if (*sctable_ndx == 0) {
|
|
// Init sctable_ndx with unsupported entries
|
|
for (int sc=0; sc<256; sc++) sctable_ndx[sc] = -1;
|
|
// Populate valid sctable_ndx entries
|
|
ndx = 0;
|
|
while (sctable[ndx].ScanCode > 0) {
|
|
sctable_ndx[sctable[ndx].ScanCode] = ndx;
|
|
ndx++;
|
|
}
|
|
}
|
|
|
|
// Lookup using sctable_ndx
|
|
ScanCode = ScanCode & 0XFF; // impose good scan code range
|
|
ndx = sctable_ndx[ScanCode]; // get index
|
|
if (ndx < 0) return nullptr; // return NULL if unsupported
|
|
return &sctable[ndx]; // else return pointer to selected entry
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Lookup CoCo key by keyname. Binary search.
|
|
//-----------------------------------------------------
|
|
static struct
|
|
CoCoKey * cocotable_keyname_lookup(const char * keyname)
|
|
{
|
|
int first = 0;
|
|
|
|
int last = (sizeof(cctable)/sizeof(cctable[0]))-1; // 56
|
|
int mid = last / 2;
|
|
|
|
int cmp = strncmp(keyname,"COCO_", 5);
|
|
if (cmp != 0) return nullptr;
|
|
|
|
while (first < last) {
|
|
cmp = strcmp(keyname+5,cctable[mid].keyname);
|
|
if (cmp == 0) return &cctable[mid];
|
|
if (cmp > 0) {
|
|
first = mid + 1;
|
|
} else {
|
|
last = mid;
|
|
}
|
|
mid = (first+last)/2;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Lookup CoCo key by button id. Sequential search.
|
|
//-----------------------------------------------------
|
|
static struct CoCoKey * cctable_keyid_lookup()
|
|
{
|
|
struct CoCoKey *p;
|
|
if (CC_KeySelected) {
|
|
p = cctable;
|
|
while (p->id > 0) {
|
|
if (p->id == CC_KeySelected) {
|
|
return p;
|
|
break;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Lookup CoCo key by row mask and col.
|
|
//-----------------------------------------------------
|
|
static struct
|
|
CoCoKey * cctable_rowcol_lookup(unsigned char RowMask, unsigned char Col)
|
|
{
|
|
unsigned long Row = 0;
|
|
unsigned long Mask = RowMask;
|
|
int ndx;
|
|
|
|
// Convert RowMask, Col to index cctable_ndx
|
|
_BitScanForward(&Row,Mask);
|
|
ndx = Col + (Row<<3);
|
|
if (ndx > 55) return nullptr;
|
|
return &cctable[cctable_ndx[ndx]];
|
|
}
|
|
|
|
/**************************************************/
|
|
/* Keymap Edit Dialog */
|
|
/**************************************************/
|
|
|
|
BOOL CALLBACK KeyMapProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (msg) {
|
|
case WM_INITDIALOG:
|
|
return InitKeymapDialog(hWnd);
|
|
case WM_CTLCOLORSTATIC:
|
|
return SetControlFont(wParam,lParam);
|
|
case WM_COMMAND:
|
|
switch(LOWORD(wParam)) {
|
|
case IDC_SET_CUST_KEYMAP:
|
|
return SetCustomKeymap();
|
|
case IDC_KEYMAP_OK:
|
|
SetCustomKeymap();
|
|
if (KeyMapChanged) SaveCustomKeyMap(GetKeyMapFilePath());
|
|
return EndDialog(hWnd,wParam);
|
|
case IDCANCEL:
|
|
if (KeyMapChanged) {
|
|
LoadCustomKeyMap(GetKeyMapFilePath());
|
|
vccKeyboardBuildRuntimeTable(kKBLayoutCustom);
|
|
}
|
|
return EndDialog(hWnd,wParam);
|
|
default:
|
|
return Process_CoCoKey(LOWORD(wParam));
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Initialize key map dialog
|
|
//-----------------------------------------------------
|
|
BOOL InitKeymapDialog(HWND hWnd)
|
|
{
|
|
// Save dialog window handle as global
|
|
hKeyMapDlg = hWnd;
|
|
|
|
// Save handles for data display controls as globals
|
|
hText_CC = GetDlgItem(hWnd,IDC_CCKEY_TXT);
|
|
hText_PC = GetDlgItem(hWnd,IDC_PCKEY_TXT);
|
|
|
|
if (hfTextBox == nullptr)
|
|
hfTextBox = CreateFont (14, 0, 0, 0, FW_MEDIUM, FALSE,
|
|
FALSE, FALSE, ANSI_CHARSET, OUT_TT_PRECIS,
|
|
CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
|
|
DEFAULT_PITCH | FF_DONTCARE, TEXT("Tahoma"));
|
|
|
|
if (hbrTextBox == nullptr)
|
|
hbrTextBox = CreateSolidBrush(RGB(255,255,255));
|
|
|
|
// Initialize selected keys information
|
|
CC_KeySelected = 0;
|
|
CC_ModSelected = 0;
|
|
PC_KeySelected = 0;
|
|
PC_ModSelected = 0;
|
|
CoCoKeySet = 0;
|
|
CoCoModSet = 0;
|
|
|
|
KeyMapChanged = FALSE;
|
|
|
|
EnableWindow(GetDlgItem(hKeyMapDlg,IDC_SET_CUST_KEYMAP),FALSE);
|
|
|
|
// Subclass hText_PC to handle PC keyboard
|
|
Text_PCproc = (WNDPROC)GetWindowLongPtr(hText_PC, GWLP_WNDPROC);
|
|
SetWindowLongPtr(hText_PC, GWLP_WNDPROC, (LONG_PTR)SubText_PCproc);
|
|
|
|
SetDialogFocus(hText_PC);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Set font for text boxes
|
|
//-----------------------------------------------------
|
|
BOOL SetControlFont(WPARAM wParam, LPARAM lParam) {
|
|
if (((HWND) lParam == hText_PC) |
|
|
((HWND) lParam == hText_CC)) {
|
|
SelectObject((HDC)wParam,hfTextBox);
|
|
return (INT_PTR)hbrTextBox;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Set mapping for selected key
|
|
//-----------------------------------------------------
|
|
BOOL SetCustomKeymap() {
|
|
|
|
int ModCol;
|
|
int ModRow;
|
|
static struct CoCoKey *p; // FIXME: Why is this static?
|
|
|
|
if (pKeyTran == nullptr) {
|
|
|
|
// If no entry and no coco key to map do nothing
|
|
if ( (CC_KeySelected + CC_ModSelected) == 0 ) return TRUE;
|
|
|
|
p = cctable_keyid_lookup();
|
|
int len = 0;
|
|
pKeyTran = keyTranslationsCustom;
|
|
|
|
while (pKeyTran->ScanCode1 > 0) {
|
|
len++;
|
|
pKeyTran++;
|
|
}
|
|
if (len >= MAX_CTRANSTBLSIZ) {
|
|
// table overflow!!
|
|
// TODO: Warn user
|
|
return TRUE;
|
|
}
|
|
pKeyTran->ScanCode1 = PC_KeySelected;
|
|
pKeyTran->ScanCode2 = ModScanCode[PC_ModSelected];
|
|
}
|
|
|
|
// Generate row and col for modifier
|
|
switch(CC_ModSelected) {
|
|
case 1:
|
|
ModCol = 7;
|
|
ModRow = 64;
|
|
break;
|
|
case 2:
|
|
ModCol = 4;
|
|
ModRow = 64;
|
|
break;
|
|
case 3:
|
|
ModCol = 3;
|
|
ModRow = 64;
|
|
break;
|
|
default:
|
|
ModCol = 0;
|
|
ModRow = 0;
|
|
break;
|
|
}
|
|
|
|
// Update custom translation table
|
|
if (CC_KeySelected != 0) { // BtnId
|
|
p = cctable_keyid_lookup();
|
|
if (p) {
|
|
pKeyTran->Row1 = 1<<(p->row);
|
|
pKeyTran->Col1 = p->col;
|
|
} else {
|
|
// Internal error, invalid Map!
|
|
// TODO: Warn user
|
|
return TRUE;
|
|
}
|
|
pKeyTran->Row2 = ModRow;
|
|
pKeyTran->Col2 = ModCol;
|
|
|
|
} else if (CC_ModSelected != 0) {
|
|
pKeyTran->Row1 = ModRow;
|
|
pKeyTran->Col1 = ModCol;
|
|
|
|
} else {
|
|
// Remove PC key from translation table
|
|
//TODO: Warn user key is being unmapped?
|
|
while (pKeyTran->ScanCode1 > 0) {
|
|
memcpy(pKeyTran,pKeyTran+1,sizeof(keytranslationentry_t));
|
|
pKeyTran++;
|
|
}
|
|
}
|
|
|
|
// Update runtime table
|
|
if (GetKeyboardLayout() == kKBLayoutCustom)
|
|
vccKeyboardBuildRuntimeTable(kKBLayoutCustom);
|
|
|
|
// Disable set button
|
|
EnableWindow(GetDlgItem(hKeyMapDlg,IDC_SET_CUST_KEYMAP),FALSE);
|
|
|
|
// Set map changed flag
|
|
KeyMapChanged = TRUE;
|
|
|
|
// Reset focus
|
|
SetDialogFocus(hText_PC);
|
|
return TRUE;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Select or toggle coco shift, ctrl, or alt (1, 2, or 3)
|
|
//-----------------------------------------------------
|
|
void CoCoModifier(int Modifier)
|
|
{
|
|
if (CC_ModSelected != Modifier) {
|
|
CC_ModSelected = Modifier;
|
|
} else {
|
|
CC_ModSelected = 0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// SetFocus for key map dialog
|
|
//-----------------------------------------------------
|
|
void SetDialogFocus(HWND hCtrl) {
|
|
SendMessage(hKeyMapDlg,WM_NEXTDLGCTL,(WPARAM)hCtrl,TRUE);
|
|
}
|
|
|
|
// Select coco key(s) as per button id
|
|
void CoCoSelect(int BtnId)
|
|
{
|
|
switch (BtnId) {
|
|
case IDC_KEYBTN_RSHIFT:
|
|
case IDC_KEYBTN_LSHIFT:
|
|
CoCoModifier(1);
|
|
break;
|
|
case IDC_KEYBTN_CTRL:
|
|
CoCoModifier(2);
|
|
break;
|
|
case IDC_KEYBTN_ALT:
|
|
CoCoModifier(3);
|
|
break;
|
|
default:
|
|
if (CC_KeySelected != BtnId) {
|
|
CC_KeySelected = BtnId;
|
|
} else {
|
|
CC_KeySelected = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Handle CoCo key button press
|
|
//-----------------------------------------------------
|
|
BOOL Process_CoCoKey(int BtnId)
|
|
{
|
|
|
|
// Return FALSE if not a CoCo key button
|
|
if (BtnId < IDC_KEYBTN_FIRST) return FALSE;
|
|
if (BtnId > IDC_KEYBTN_LAST) return FALSE;
|
|
SetDialogFocus(hText_PC);
|
|
if ( (PC_KeySelected != 0 ) | ( PC_ModSelected !=0 ) ) {
|
|
CoCoSelect(BtnId);
|
|
ShowCoCoKey();
|
|
EnableWindow(GetDlgItem(hKeyMapDlg,IDC_SET_CUST_KEYMAP),TRUE);
|
|
} else {
|
|
MessageBox(hKeyMapDlg,"Press PC key to map first","Error",0);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Set up/down state of modifier key button(s)
|
|
//-----------------------------------------------------
|
|
void SetModKeyState (int mod, int state)
|
|
{
|
|
switch (mod) {
|
|
case 1:
|
|
Button_SetState(GetDlgItem(hKeyMapDlg,IDC_KEYBTN_LSHIFT),state);
|
|
Button_SetState(GetDlgItem(hKeyMapDlg,IDC_KEYBTN_RSHIFT),state);
|
|
break;
|
|
case 2:
|
|
Button_SetState(GetDlgItem(hKeyMapDlg,IDC_KEYBTN_CTRL),state);
|
|
break;
|
|
case 3:
|
|
Button_SetState(GetDlgItem(hKeyMapDlg,IDC_KEYBTN_ALT),state);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Display CoCo keys
|
|
//-----------------------------------------------------
|
|
void ShowCoCoKey()
|
|
{
|
|
char str[64];
|
|
const char * keytxt = "";
|
|
const struct CoCoKey *p;
|
|
|
|
// set coco keyboard buttons
|
|
if (CC_KeySelected != CoCoKeySet) {
|
|
if (CoCoKeySet) {
|
|
Button_SetState(GetDlgItem(hKeyMapDlg,CoCoKeySet),0);
|
|
}
|
|
if (CC_KeySelected) {
|
|
Button_SetState(GetDlgItem(hKeyMapDlg,CC_KeySelected),1);
|
|
}
|
|
CoCoKeySet = CC_KeySelected;
|
|
}
|
|
|
|
if (CC_ModSelected != CoCoModSet ) {
|
|
SetModKeyState (CoCoModSet, 0);
|
|
SetModKeyState (CC_ModSelected, 1);
|
|
CoCoModSet = CC_ModSelected;
|
|
}
|
|
|
|
// Show coco keys names in editbox
|
|
if (CC_KeySelected) {
|
|
p = cctable_keyid_lookup();
|
|
if (p != nullptr) {
|
|
if (p->label != nullptr) {
|
|
keytxt = p->label;
|
|
} else {
|
|
keytxt = p->keyname;
|
|
}
|
|
}
|
|
}
|
|
|
|
sprintf(str,"%s %s",ModName[CC_ModSelected],keytxt);
|
|
SendMessage(hText_CC, WM_SETTEXT, 0, (LPARAM)str);
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Handle messages for PC key name text box. This will
|
|
// get all Keyboard events while dialog is running.
|
|
//-----------------------------------------------------
|
|
|
|
LRESULT CALLBACK
|
|
SubText_PCproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int ScanCode;
|
|
int Extended;
|
|
switch (msg) {
|
|
case WM_GETDLGCODE:
|
|
return DLGC_WANTALLKEYS;
|
|
case WM_SYSKEYUP:
|
|
case WM_KEYUP:
|
|
case WM_CHAR:
|
|
return 0;
|
|
case WM_SYSKEYDOWN:
|
|
case WM_KEYDOWN:
|
|
ScanCode=(lParam >> 16) & 0xFF;
|
|
Extended=(lParam >> 24) & 1;
|
|
if (Extended && (ScanCode!=DIK_NUMLOCK))
|
|
{
|
|
ScanCode += 0x80;
|
|
}
|
|
switch (ScanCode) {
|
|
case DIK_LWIN:
|
|
return 0;
|
|
case DIK_LSHIFT:
|
|
case DIK_RSHIFT:
|
|
SetPCmod(1);
|
|
break;
|
|
case DIK_LCONTROL:
|
|
case DIK_RCONTROL:
|
|
SetPCmod(2);
|
|
break;
|
|
case DIK_LMENU:
|
|
case DIK_RMENU:
|
|
SetPCmod(3);
|
|
break;
|
|
default:
|
|
if (PC_KeySelected == ScanCode) {
|
|
PC_KeySelected = 0;
|
|
} else {
|
|
PC_KeySelected = ScanCode;
|
|
}
|
|
break;
|
|
}
|
|
ShowPCkey();
|
|
SetCoCokey();
|
|
return 0;
|
|
}
|
|
// Stock text control does everything else
|
|
return (CallWindowProc(Text_PCproc,hWnd,msg,wParam,lParam));
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Select or toggle PC shift, ctrl, or alt
|
|
//-----------------------------------------------------
|
|
void SetPCmod(int ModNum)
|
|
{
|
|
if (ModNum == PC_ModSelected) {
|
|
PC_ModSelected = 0;
|
|
} else {
|
|
PC_ModSelected = ModNum;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Display PC keys names that are selected
|
|
//-----------------------------------------------------
|
|
void ShowPCkey()
|
|
{
|
|
char str[64];
|
|
const char * keytxt = "";
|
|
const struct PCScanCode * entry;
|
|
if (PC_KeySelected>0) {
|
|
entry = scantable_scancode_lookup(PC_KeySelected);
|
|
if (entry == nullptr) {
|
|
keytxt = "";
|
|
PC_KeySelected=0;
|
|
} else {
|
|
keytxt = entry->label;
|
|
if (keytxt == nullptr) keytxt = entry->keyname;
|
|
}
|
|
}
|
|
sprintf(str,"%s %s",ModName[PC_ModSelected],keytxt);
|
|
SendMessage(hText_PC, WM_SETTEXT, 0, (LPARAM)str);
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Set CoCo key as per current map
|
|
//-----------------------------------------------------
|
|
void SetCoCokey()
|
|
{
|
|
static struct CoCoKey * pCoCoKey; // FIXME: Why is this static?
|
|
|
|
// Clear selected coco keys
|
|
CC_KeySelected = 0;
|
|
CC_ModSelected = 0;
|
|
|
|
// Scan Custom translation table for match on PC key(s) selected
|
|
int mod = ModScanCode[PC_ModSelected];
|
|
int s1 = PC_KeySelected + ( mod << 8 );
|
|
int s2 = ( PC_KeySelected << 8 ) + mod;
|
|
|
|
pKeyTran = keyTranslationsCustom;
|
|
while (pKeyTran->ScanCode1 != 0) {
|
|
int m = pKeyTran->ScanCode1 + (pKeyTran->ScanCode2 << 8);
|
|
if ( (m == s1) | (m == s2) ) break;
|
|
pKeyTran++;
|
|
}
|
|
|
|
// If match found select mapped coco keys (if any)
|
|
if (pKeyTran->ScanCode1 != 0) {
|
|
if (pKeyTran->Row1 != 0) {
|
|
pCoCoKey = cctable_rowcol_lookup(pKeyTran->Row1, pKeyTran->Col1);
|
|
if (pCoCoKey) CoCoSelect(pCoCoKey->id);
|
|
}
|
|
if (pKeyTran->Row2 != 0) {
|
|
pCoCoKey = cctable_rowcol_lookup(pKeyTran->Row2, pKeyTran->Col2);
|
|
if (pCoCoKey) CoCoSelect(pCoCoKey->id);
|
|
}
|
|
} else {
|
|
pKeyTran = nullptr;
|
|
}
|
|
|
|
// Disable set button
|
|
EnableWindow(GetDlgItem(hKeyMapDlg,IDC_SET_CUST_KEYMAP),FALSE);
|
|
|
|
// Show results
|
|
ShowCoCoKey();
|
|
}
|
|
|