erabo/spiegel-keyman
1
0
Fork 0
mirror of https://github.com/keymanapp/keyman.git synced 2026-09-19 14:17:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

feat(linux): mcompile-dk naming of Var,Function (KeyVal,KeyCode,VK)

Browse source
This commit is contained in:
Sabine 2024-02-20 10:09:17 +01:00
parent fb1ad0cad7
commit 76adcd07ca
4 changed files with 84 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

129
linux/mcompile/keymap/keymap.cpp
View file

@ -327,8 +327,8 @@ int append_underlying_ToVector(v_dw_3D &All_Vector,GdkKeymap *keymap) {
All_Vector[1][i][0] = All_Vector[0][i][0];
// get Keyvals of this key and copy to unshifted/shifted in "underlying"-block[1][i][1] / block[1][i][2]
All_Vector[1][i][0+1] = KMX_get_KeyvalUnderlying_From_KeyCodeUnderlying_GDK(keymap,All_Vector[0][i][0],0); //shift state: unshifted:0
All_Vector[1][i][1+1] = KMX_get_KeyvalUnderlying_From_KeyCodeUnderlying_GDK(keymap,All_Vector[0][i][0],1); //shift state: shifted:1
All_Vector[1][i][0+1] = KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(keymap,All_Vector[0][i][0],0); //shift state: unshifted:0
All_Vector[1][i][1+1] = KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(keymap,All_Vector[0][i][0],1); //shift state: shifted:1
}
return 0;
@ -407,7 +407,7 @@ std::u16string convert_DeadkeyValues_To_U16str(int in) {
return u"\0";
}
int KMX_get_keyval_From_Keycode(GdkKeymap *keymap, guint keycode, ShiftState ss, int caps) {
int KMX_get_KeyVal_From_KeyCode(GdkKeymap *keymap, guint keycode, ShiftState ss, int caps) {
GdkModifierType consumed;
GdkKeymapKey *maps;
@ -494,11 +494,11 @@ int KMX_get_keyval_From_Keycode(GdkKeymap *keymap, guint keycode, ShiftState ss,
return (int) *keyvals;
}
KMX_DWORD KMX_get_KeyvalUnderlying_From_KeyCodeUnderlying_GDK(GdkKeymap *keymap, guint keycode, int shift_state_pos) {
KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap *keymap, guint keycode, int shift_state_pos) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
KMX_DWORD out;
KMX_DWORD KVal;
if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count))
return 0;
@ -509,15 +509,29 @@ KMX_DWORD KMX_get_KeyvalUnderlying_From_KeyCodeUnderlying_GDK(GdkKeymap *keymap,
if (!(keycode <= keycode_max))
return 0;
out = (KMX_DWORD) KMX_get_keyval_From_Keycode(keymap, keycode, (ShiftState) shift_state_pos, 0);
KVal = (KMX_DWORD) KMX_get_KeyVal_From_KeyCode(keymap, keycode, (ShiftState) shift_state_pos, 0);
g_free(keyvals);
g_free(maps);
return out;
return KVal;
}
KMX_DWORD KMX_get_KeyvalUnderlying_DK_From_KeyCodeUnderlying_GDK(GdkKeymap *keymap, guint keycode, int shift_state_pos, PKMX_WCHAR &dky) {
KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap *keymap, UINT VKShiftState, UINT KC_underlying, PKMX_WCHAR DeadKey) {
PKMX_WCHAR dky;
KMX_DWORD KeyVal = KMX_get_KeyValUnderlying_DK_From_KeyCodeUnderlying(keymap, KC_underlying, map_VKShiftState_to_LinModifier(VKShiftState), dky);
if(KeyVal >= deadkey_min) { // deadkey
*DeadKey = *dky;
return 0xFFFF;
}
else if((KeyVal > deadkey_max) || ((KeyVal < deadkey_min) && ( KeyVal > 0xFF))) // out of range
return 0xFFFE;
else // usable char
return KeyVal;
}
KMX_DWORD KMX_get_KeyValUnderlying_DK_From_KeyCodeUnderlying(GdkKeymap *keymap, guint keycode, int shift_state_pos, PKMX_WCHAR &dky) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
@ -536,79 +550,25 @@ KMX_DWORD KMX_get_KeyvalUnderlying_DK_From_KeyCodeUnderlying_GDK(GdkKeymap *keym
if (!(keycode <= keycode_max))
return 0;
KMX_DWORD All_Keyvals = KMX_get_keyval_From_Keycode(keymap, keycode, ShiftState(shift_state_pos), 0);
KMX_DWORD KeyV = KMX_get_KeyVal_From_KeyCode(keymap, keycode, ShiftState(shift_state_pos), 0);
if(( (All_Keyvals >= deadkey_min) && (All_Keyvals <= deadkey_max)))
deadkey = All_Keyvals;
if(( (KeyV >= deadkey_min) && (KeyV <= deadkey_max)))
deadkey = KeyV;
dky = (PKMX_WCHAR) (convert_DeadkeyValues_To_U16str((int) deadkey)).c_str();
g_free(keyvals);
g_free(maps);
if((All_Keyvals >= deadkey_min) && (All_Keyvals <= deadkey_max)) // deadkeys
if((KeyV >= deadkey_min) && (KeyV <= deadkey_max)) // deadkeys
return 0xFFFF;
else if((All_Keyvals > deadkey_max) || ((All_Keyvals < deadkey_min) && ( All_Keyvals > 0xFF))) // out of range
else if((KeyV > deadkey_max) || ((KeyV < deadkey_min) && ( KeyV > 0xFF))) // out of range
return 0xFFFE;
else // usable char
return All_Keyvals;
return KeyV;
}
KMX_DWORD KMX_get_CharUnderlying_From_KeyCodeUnderlying_GDK(GdkKeymap *keymap, UINT VKShiftState, UINT KC_underlying, PKMX_WCHAR DeadKey) {
PKMX_WCHAR dky;
KMX_DWORD keyvals_dw = KMX_get_KeyvalUnderlying_DK_From_KeyCodeUnderlying_GDK(keymap, KC_underlying, map_VKShiftState_to_LinModifier(VKShiftState), dky);
if(keyvals_dw >= deadkey_min) { // deadkey
*DeadKey = *dky;
return 0xFFFF;
}
else if((keyvals_dw > deadkey_max) || ((keyvals_dw < deadkey_min) && ( keyvals_dw > 0xFF))) // out of range
return 0xFFFE;
else // usable char
return keyvals_dw;
/*if( keyvals_dw == 0xFFFF)
*DeadKey = *dky;
return keyvals_dw;*/
}
KMX_DWORD KMX_get_VKUS_From_KeyCodeUnderlying_GDK( GdkKeymap *keymap, KMX_DWORD keycode) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count))
return 0;
if ( keycode >7)
return (KMX_DWORD) ScanCodeToUSVirtualKey[keycode-8];
return 0;
}
KMX_DWORD KMX_get_KeyCodeUnderlying_From_KeycodeUS_GDK(GdkKeymap *keymap, v_dw_3D &All_Vector, KMX_DWORD KC_US, ShiftState ss, int caps) {
KMX_DWORD Character;
std::wstring ws = convert_DeadkeyValues_ToWstr(KMX_get_keyval_From_Keycode(keymap, KC_US, ss, caps));
Character = *ws.c_str();
//Find underlying KC of character
for( int i=0; i< (int)All_Vector[1].size()-1 ;i++) {
for( int j=1; j< (int)All_Vector[1][0].size();j++) {
if ( ( All_Vector[1][i][j] == Character ) ) {
KC_US = All_Vector[1][i][j];
return All_Vector[1][i][0];
}
}
}
return KC_US;
}
KMX_WCHAR KMX_get_KValUnderlying_From_KValUS_VEC(v_dw_3D & All_Vector, KMX_DWORD VK_US) {
KMX_WCHAR KMX_get_KeyValUnderlying_From_KeyValUS(v_dw_3D & All_Vector, KMX_DWORD VK_US) {
KMX_DWORD VK_underlying;
for( int i=0; i< (int)All_Vector[0].size()-1 ;i++) {
for( int j=1; j< (int)All_Vector[0][0].size();j++) {
@ -621,11 +581,42 @@ KMX_WCHAR KMX_get_KValUnderlying_From_KValUS_VEC(v_dw_3D & All_Vector, KMX_DWORD
return VK_US;
}
KMX_DWORD KMX_get_KeyCodeUnderlying_From_KeyCodeUS(GdkKeymap *keymap, v_dw_3D &All_Vector, KMX_DWORD KC_US, ShiftState ss, int caps) {
KMX_DWORD KC_underlying;
KMX_DWORD Character;
std::wstring ws = convert_DeadkeyValues_ToWstr(KMX_get_KeyVal_From_KeyCode(keymap, KC_US, ss, caps));
Character = *ws.c_str();
//Find underlying KC of character
for( int i=0; i< (int)All_Vector[1].size()-1 ;i++) {
for( int j=1; j< (int)All_Vector[1][0].size();j++) {
if ( ( All_Vector[1][i][j] == Character ) ) {
KC_underlying = All_Vector[1][i][0];
return KC_underlying;
}
}
}
return KC_US;
}
UINT KMX_get_KeyCodeUnderlying_From_VKUS(KMX_DWORD VirtualKeyUS) {
return (8 + USVirtualKeyToScanCode[VirtualKeyUS]);
}
KMX_DWORD KMX_get_VKUS_From_KeyCodeUnderlying( GdkKeymap *keymap, KMX_DWORD keycode) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count))
return 0;
if ( keycode >7)
return (KMX_DWORD) ScanCodeToUSVirtualKey[keycode-8];
return 0;
}
std::wstring CodePointToWString(unsigned int codepoint) {
std::wstring str;

26
linux/mcompile/keymap/keymap.h
View file

@ -508,29 +508,29 @@ std::wstring convert_DeadkeyValues_ToWstr(int in);
std::u16string convert_DeadkeyValues_To_U16str(int in);
// use gdk_keymap_translate_keyboard_state to get keyval - base function to get keyvals
int KMX_get_keyval_From_Keycode(GdkKeymap *keymap, guint keycode, ShiftState ss, int caps);
int KMX_get_KeyVal_From_KeyCode(GdkKeymap *keymap, guint keycode, ShiftState ss, int caps);
// use KMX_get_keyval_From_Keycode and forbids use of certain keycodes
KMX_DWORD KMX_get_KeyvalUnderlying_From_KeyCodeUnderlying_GDK(GdkKeymap *keymap, guint keycode, int shift_state_pos);
// use KMX_get_keyval_From_Keycode and return CATEGORY off keyval and prevent use of certain keycodes
KMX_DWORD KMX_get_KeyvalUnderlying_DK_From_KeyCodeUnderlying_GDK(GdkKeymap *keymap, guint keycode, int shift_state_pos, PKMX_WCHAR &dky);
// use KMX_get_KeyVal_From_KeyCode and prevent use of certain keycodes
KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap *keymap, guint keycode, int shift_state_pos);
// fill Deadkey with dk and return CATEGORY
KMX_DWORD KMX_get_CharUnderlying_From_KeyCodeUnderlying_GDK(GdkKeymap *keymap, UINT VKShiftState, UINT KC_underlying, PKMX_WCHAR DeadKey);
KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap *keymap, UINT VKShiftState, UINT KC_underlying, PKMX_WCHAR DeadKey);
// return the VirtualKey of the underlying Keyboard for a given Keyode using GDK
KMX_DWORD KMX_get_VKUS_From_KeyCodeUnderlying_GDK( GdkKeymap *keymap, KMX_DWORD keycode);
// use Vector to return the Keycode of the underlying Keyboard for given VK_US using GDK
KMX_DWORD KMX_get_KeyCodeUnderlying_From_KeycodeUS_GDK(GdkKeymap *keymap, v_dw_3D &All_Vector,KMX_DWORD KC_US, ShiftState ss, int caps);
// use KMX_get_KeyVal_From_KeyCode and return CATEGORY off keyval and prevent use of certain keycodes
KMX_DWORD KMX_get_KeyValUnderlying_DK_From_KeyCodeUnderlying(GdkKeymap *keymap, guint keycode, int shift_state_pos, PKMX_WCHAR &dky);
// use Vector to return the Keyval of underlying Keyboard
KMX_WCHAR KMX_get_KValUnderlying_From_KValUS_VEC(v_dw_3D &All_Vector,KMX_DWORD VK_underlying);
KMX_WCHAR KMX_get_KeyValUnderlying_From_KeyValUS(v_dw_3D &All_Vector,KMX_DWORD VK_underlying);
// use Vector to return the Keycode of the underlying Keyboard for given VK_US using GDK
KMX_DWORD KMX_get_KeyCodeUnderlying_From_KeyCodeUS(GdkKeymap *keymap, v_dw_3D &All_Vector,KMX_DWORD KC_US, ShiftState ss, int caps);
// return the Keycode of the underlying Keyboard for given VK_US
UINT KMX_get_KeyCodeUnderlying_From_VKUS(KMX_DWORD VirtualKeyUS);
// return the VirtualKey of the US Keyboard for a given Keyode using GDK
KMX_DWORD KMX_get_VKUS_From_KeyCodeUnderlying( GdkKeymap *keymap, KMX_DWORD keycode);
// convert codePoint to wstring
std::wstring CodePointToWString(unsigned int codepoint);
std::u16string CodePointToString_16(unsigned int codepoint);

16
linux/mcompile/keymap/mc_import_rules.cpp
View file

@ -76,19 +76,19 @@ int KMX_ToUnicodeEx(guint keycode, const BYTE *lpKeyState, PKMX_WCHAR pwszBuff,
if (!(keycode <= keycode_max))
return 0;
std::wstring str = convert_DeadkeyValues_ToWstr(KMX_get_keyval_From_Keycode(keymap, keycode, ShiftState(shift_state_pos), caps));
std::wstring str = convert_DeadkeyValues_ToWstr(KMX_get_KeyVal_From_KeyCode(keymap, keycode, ShiftState(shift_state_pos), caps));
pwszBuff[0]= * (PKMX_WCHAR) u16string_from_wstring(str).c_str();
KMX_DWORD keyvals_dw= (KMX_DWORD) KMX_get_keyval_From_Keycode(keymap, keycode, ShiftState(shift_state_pos), caps);
KMX_DWORD KeyVal= (KMX_DWORD) KMX_get_KeyVal_From_KeyCode(keymap, keycode, ShiftState(shift_state_pos), caps);
g_free(keyvals);
g_free(maps);
if((keyvals_dw >= deadkey_min) && (keyvals_dw <= deadkey_max)) // deadkeys
if((KeyVal >= deadkey_min) && (KeyVal <= deadkey_max)) // deadkeys
return -1;
else if(gdk_keyval_to_unicode(keyvals_dw) == 0) // NO UNICODE
else if(gdk_keyval_to_unicode(KeyVal) == 0) // NO UNICODE
return 0;
else // usable char
else /// usable char
return 1;
}
@ -125,7 +125,7 @@ public:
}
KMX_VirtualKey(UINT scanCode, KMX_HKL hkl, GdkKeymap **keymap) {
this->m_vk = KMX_get_VKUS_From_KeyCodeUnderlying_GDK(*keymap, scanCode);
this->m_vk = KMX_get_VKUS_From_KeyCodeUnderlying(*keymap, scanCode);
this->m_hkl = hkl;
this->m_sc = scanCode;
memset(this->m_rgfDeadKey,0,sizeof(this->m_rgfDeadKey));
@ -346,8 +346,8 @@ int i4 = this->KMX_IsXxxxGrCapsEqualToXxxxShift() ? 8 : 0;*/
// key->Key stores VK-US ( not underlying !!)
// key->dpOutput stores character Underlying
KMX_DWORD SC_Underlying = KMX_get_KeyCodeUnderlying_From_KeycodeUS_GDK(keymap, All_Vector, this->SC(), (ShiftState) ss, caps);
key->Key = KMX_get_VKUS_From_KeyCodeUnderlying_GDK( keymap, SC_Underlying);
KMX_DWORD SC_Underlying = KMX_get_KeyCodeUnderlying_From_KeyCodeUS(keymap, All_Vector, this->SC(), (ShiftState) ss, caps);
key->Key = KMX_get_VKUS_From_KeyCodeUnderlying( keymap, SC_Underlying);
key->Line = 0;
key->ShiftFlags = this->KMX_GetShiftStateValue(capslock, caps, (ShiftState) ss);

6
linux/mcompile/keymap/mcompile.cpp
View file

@ -370,8 +370,8 @@ void KMX_ConvertDeadkey(LPKMX_KEYBOARD kbd, KMX_WORD vk_US, UINT shift, KMX_WCHA
KMX_GetDeadkeys(dk_Table, deadkey, pdk = deadkeys, keymap); // returns array of [usvk, ch_out] pairs
while(*pdk) {
// Look up the ch
UINT vkUnderlying = KMX_get_KValUnderlying_From_KValUS_VEC(All_Vector, *pdk);
KMX_TranslateDeadkeyKeyboard(kbd, dkid, vkUnderlying, *(pdk+1), *(pdk+2));
UINT KeyValUnderlying = KMX_get_KeyValUnderlying_From_KeyValUS(All_Vector, *pdk);
KMX_TranslateDeadkeyKeyboard(kbd, dkid, KeyValUnderlying, *(pdk+1), *(pdk+2));
pdk+=3;
}
}
@ -435,7 +435,7 @@ KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint arg
// _S2 DIFFERENT TO MCOMPILE WINDOWS
// win goes via VK, Lin goes via SC/Keycode
UINT scUnderlying = KMX_get_KeyCodeUnderlying_From_VKUS(KMX_VKMap[i]);
KMX_WCHAR ch = KMX_get_CharUnderlying_From_KeyCodeUnderlying_GDK(keymap, VKShiftState[j], scUnderlying, &DeadKey);
KMX_WCHAR ch = KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(keymap, VKShiftState[j], scUnderlying, &DeadKey);
//wprintf(L"--- VK_%d -> SC_ [%c] dk=%d ( ss %i) \n", VKMap[i], ch == 0 ? 32 : ch, DeadKey, VKShiftState[j]);