mirror of
https://github.com/keymanapp/keyman.git
synced 2026-08-05 08:25:32 +00:00
927154cebb
# This is the 1st commit message: feat(mac): remove unused func # This is the commit message #2: feat(mac): edit, remove unused code # This is the commit message #3: feat(mac): more edit # This is the commit message #4: feat(mac): comments keymap # This is the commit message #5: feat(mac): comments importRules # This is the commit message #6: feat(mac): comments # This is the commit message #7: feat(mac): more comments # This is the commit message #8: feat(mac): adapt data types return para
338 lines
15 KiB
C++
338 lines
15 KiB
C++
/*
|
|
* Keyman is copyright (C) SIL International. MIT License.
|
|
*
|
|
* Mnemonic layout support for mac
|
|
*
|
|
* Throughout mcompile we use the following naming conventions:
|
|
* KEYCODE: The physical position of a key on a keyboard e.g. Keycode for 'Z' on US: 6 on Mac | 52 on Linux/x11 | 44 on Windows
|
|
* SCANCODE (naming on windows): The physical position of a key on a keyboard e.g. Keycode for 'Z' on US: 44 on Windows
|
|
* VIRTUAL KEY: The value of a character on a key e.g. 'A' = 65; 'a' = 97 - not neccessarily the same as ACSII- exists on a Windows keyboard only
|
|
* KEYVAL(UE): The value of a character on a key e.g. 'A' = 65; 'a' = 97 - not neccessarily the same as ACSII
|
|
*/
|
|
|
|
#include "keymap.h"
|
|
#include "kmx_file.h"
|
|
|
|
/** @brief map a shiftstate used on windows to a shiftstate suitable for UCKeyTranslate() on the mac */
|
|
int mac_convert_Shiftstate_to_MacShiftstate(int shiftState) {
|
|
if (shiftState == 0) return MAC_BASE; // Win ss 0 -> mac ss 0
|
|
else if (shiftState == K_SHIFTFLAG) return MAC_SHIFT; // Win ss 16 -> mac ss 2
|
|
else if (shiftState == (LCTRLFLAG | RALTFLAG)) return MAC_OPT; // Win ss 9 -> mac ss 8
|
|
else if (shiftState == (K_SHIFTFLAG | LCTRLFLAG | RALTFLAG)) return MAC_SHIFT_OPT; // Win ss 25 -> mac ss 10
|
|
else return shiftState; // Win ss x -> mac ss x
|
|
}
|
|
|
|
/** @brief map a shiftstate used in rgkey (a vector of VirtualKey*) to a shiftstate suitable for UCKeyTranslate() on the mac */
|
|
int mac_convert_rgkey_Shiftstate_to_MacShiftstate(int rgkey_ShiftState) {
|
|
if (rgkey_ShiftState == 0) return MAC_BASE;
|
|
else if (rgkey_ShiftState == 1) return MAC_SHIFT;
|
|
else if (rgkey_ShiftState == 6) return MAC_OPT;
|
|
else if (rgkey_ShiftState == 7) return MAC_SHIFT_OPT;
|
|
else return rgkey_ShiftState;
|
|
}
|
|
|
|
// _S2 todo missing code
|
|
/** @brief check for correct input parameter that will later be used in UCKeyTranslate() */
|
|
bool ensureValidInputForKeyboardTranslation(int shiftstate, int keycode) {
|
|
if ((shiftstate > max_shiftstate))
|
|
return false;
|
|
|
|
if (keycode > keycode_max)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/** @brief create a 3D-Vector containing data of the US keyboard and the currently used (underlying) keyboard */
|
|
int mac_createOneVectorFromBothKeyboards(vec_dword_3D& all_vector, const UCKeyboardLayout* keyboard_layout) {
|
|
// store contents of the English (US) keyboard in all_vector
|
|
if (mac_write_US_ToVector(all_vector)) {
|
|
printf("ERROR: can't write full US to Vector \n");
|
|
return 1;
|
|
}
|
|
|
|
// add contents of underlying keyboard to all_vector
|
|
if (mac_append_underlying_ToVector(all_vector, keyboard_layout)) {
|
|
printf("ERROR: can't append underlying ToVector \n");
|
|
return 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/** @brief write data of the US keyboard into a 3D-Vector */
|
|
int mac_write_US_ToVector(vec_dword_3D& vec_us) {
|
|
// Values for US : A, S, D, F, H, G, Z, X, C, V, §, B, Q, W, E, R, Y, T, 1, 2, 3, 4, 6, 5, =, 9, 7, -, 8, 0, ], O, U, [, I, P,CR, L, J, ', K, ;, \, ,, /, N, M, .
|
|
std::vector<int> us_Base = {97,115,100,102,104,103,122,120,99,118,167,98,113,119,101,114,121,116,49,50,51,52,54,53,61,57,55,45,56,48, 93,111,117, 91,105,112,13,108,106,39,107,59, 92,44,47,110,109,46};
|
|
std::vector<int> us_Shift = {65, 83, 68, 70, 72, 71, 90, 88,67, 86,177,66, 81, 87, 69, 82, 89, 84,33,64,35,36,94,37,43,40,38,95,42,41,125, 79, 85,123, 73, 80,13, 76, 74,34, 75,58,124,60,63, 78, 77,62};
|
|
|
|
vec_dword_1D values;
|
|
vec_dword_2D key;
|
|
|
|
for (int i = 0; i < us_Base.size(); i++) {
|
|
values.push_back(i);
|
|
values.push_back(us_Base[i]);
|
|
values.push_back(us_Shift[i]);
|
|
key.push_back(values);
|
|
values.clear();
|
|
}
|
|
vec_us.push_back(key);
|
|
|
|
if (key.size() == 0) {
|
|
printf("ERROR: can't Create Vector for US keyboard\n");
|
|
return 1;
|
|
} else if (key.size() < 48) {
|
|
printf("ERROR: keyboard not created completely\n");
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
/** @brief create an 2D-Vector with all fields initialized to INVALID_NAME */
|
|
vec_dword_2D mac_create_empty_2D_Vector(int dim_rows, int dim_ss) {
|
|
vec_dword_1D shifts;
|
|
vec_dword_2D vector_2D;
|
|
|
|
for (int j = 0; j < dim_ss; j++) {
|
|
shifts.push_back(INVALID_NAME);
|
|
}
|
|
|
|
for (int i = 0; i < dim_rows; i++) {
|
|
vector_2D.push_back(shifts);
|
|
}
|
|
return vector_2D;
|
|
}
|
|
|
|
/** @brief append a 2D-vector containing data of the currently used (underlying) keyboard to the 3D-vector */
|
|
int mac_append_underlying_ToVector(vec_dword_3D& all_vector, const UCKeyboardLayout* keyboard_layout) {
|
|
if (all_vector.size() != 1) {
|
|
printf("ERROR: data for US keyboard not correct\n");
|
|
return 1;
|
|
}
|
|
|
|
// create a 2D vector all filled with " " and push to 3D-Vector
|
|
vec_dword_2D underlying_Vector2D = mac_create_empty_2D_Vector(all_vector[0].size(), all_vector[0][0].size());
|
|
|
|
if (underlying_Vector2D.size() == 0) {
|
|
printf("ERROR: can't create empty 2D-Vector\n");
|
|
return 1;
|
|
}
|
|
|
|
all_vector.push_back(underlying_Vector2D);
|
|
if (all_vector.size() < 2) {
|
|
printf("ERROR: creation of 3D-Vector failed\n");
|
|
return 2;
|
|
}
|
|
|
|
for (int i = 0; i < (int)all_vector[1].size(); i++) {
|
|
// get key name US stored in [0][i][0] and copy to name in "underlying"-block[1][i][0]
|
|
all_vector[1][i][0] = all_vector[0][i][0];
|
|
|
|
for (int k = 0; k < 2; k++) { // use BASE and SHIFT only
|
|
all_vector[1][i][k + 1] = mac_KMX_get_KeyVal_From_KeyCode(keyboard_layout, all_vector[0][i][0], mac_convert_rgkey_Shiftstate_to_MacShiftstate(k), 0);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/** @brief create a pointer to pointer of the current keymap for later use */
|
|
bool mac_InitializeUCHR(const UCKeyboardLayout** keyboard_layout) {
|
|
TISInputSourceRef source = TISCopyCurrentKeyboardInputSource();
|
|
if (!source) {
|
|
printf("ERROR: can't get source\n");
|
|
return 1;
|
|
}
|
|
|
|
CFDataRef layout_data = static_cast<CFDataRef>((TISGetInputSourceProperty(source, kTISPropertyUnicodeKeyLayoutData)));
|
|
*keyboard_layout = reinterpret_cast<const UCKeyboardLayout*>(CFDataGetBytePtr(layout_data));
|
|
if (!keyboard_layout) {
|
|
printf("ERROR: Can't get keyboard_layout\n");
|
|
return 2;
|
|
}
|
|
// intentionally leaking `source` in order to still be able to access `keymap`
|
|
return 0;
|
|
}
|
|
|
|
/** @brief return the keyvalue for a given Keycode, shiftstate and caps */
|
|
KMX_DWORD mac_KMX_get_KeyVal_From_KeyCode(const UCKeyboardLayout* keyboard_layout, int keycode, int shiftstate_mac, int caps) {
|
|
UInt32 deadkeystate;
|
|
UniCharCount maxStringlength = 5;
|
|
UniCharCount actualStringlength = 0;
|
|
OptionBits keyTranslateOptions = 0;
|
|
UniChar unicodeString[maxStringlength];
|
|
OSStatus status;
|
|
unicodeString[0] = 0;
|
|
|
|
if (!ensureValidInputForKeyboardTranslation(shiftstate_mac, keycode))
|
|
return 0;
|
|
|
|
/*
|
|
UCKeyTranslate != 0 if a dk was found; then run UCKeyTranslate again with a SPACE (keycode_spacebar) to get the plain dk e.g.'^'
|
|
if CAPS is used: always add 4 e.g. SHIFT = 2; SHIFT+CAPS = 6
|
|
*/
|
|
|
|
status = UCKeyTranslate(keyboard_layout, keycode, kUCKeyActionDown, (shiftstate_mac + 4 * caps), LMGetKbdType(), keyTranslateOptions, &deadkeystate, maxStringlength, &actualStringlength, unicodeString);
|
|
// If this was a deadkey (deadkeystate != 0), append a space
|
|
if (deadkeystate != 0)
|
|
status = UCKeyTranslate(keyboard_layout, keycode_spacebar, kUCKeyActionDown, (shiftstate_mac + 4 * caps), LMGetKbdType(), keyTranslateOptions, &deadkeystate, maxStringlength, &actualStringlength, unicodeString);
|
|
|
|
// if there is no character assigned to the Key+Shift+CAPS UCKeyTranslate writes 0x01 into unicodeString[0]
|
|
if (unicodeString[0] == 1) // impossible character
|
|
return 0;
|
|
else {
|
|
return unicodeString[0]; // combined char e.g. â
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/** @brief return the keyvalue for a given Keycode, shiftstate and caps */
|
|
KMX_DWORD mac_KMX_get_KeyVal_From_KeyCode_dk(const UCKeyboardLayout* keyboard_layout, int keycode, int shiftstate_mac, int caps, UInt32& deadkeystate) {
|
|
UniCharCount maxStringlength = 5;
|
|
UniCharCount actualStringlength = 0;
|
|
OptionBits keyTranslateOptions = 0;
|
|
UniChar unicodeString[maxStringlength];
|
|
unicodeString[0] = 0;
|
|
OSStatus status;
|
|
|
|
if (!ensureValidInputForKeyboardTranslation(shiftstate_mac, keycode))
|
|
return 0;
|
|
|
|
/*
|
|
UCKeyTranslate != 0 if a dk was found; then run UCKeyTranslate again with a SPACE (keycode_spacebar) to get the plain dk e.g.'^'
|
|
if CAPS is used: always add 4 e.g. SHIFT = 2; SHIFT+CAPS = 6
|
|
*/
|
|
|
|
status = UCKeyTranslate(keyboard_layout, keycode, kUCKeyActionDown, (shiftstate_mac + 4 * caps), LMGetKbdType(), keyTranslateOptions, &deadkeystate, maxStringlength, &actualStringlength, unicodeString);
|
|
|
|
// If this was a deadkey,append a space
|
|
if (deadkeystate != 0)
|
|
status = UCKeyTranslate(keyboard_layout, keycode_spacebar, kUCKeyActionDown,(shiftstate_mac + 4 * caps), LMGetKbdType(), keyTranslateOptions, &deadkeystate, maxStringlength, &actualStringlength, unicodeString);
|
|
|
|
// if there is no character assigned to the Key+Shift+CAPS UCKeyTranslate writes 0x01 into unicodeString[0]
|
|
if (unicodeString[0] == 1) // impossible character
|
|
return 0;
|
|
else
|
|
return unicodeString[0]; // combined char e.g. â
|
|
}
|
|
|
|
/** @brief return the keyvalue for a given Keycode and shiftstate of the currently used (underlying) keyboard layout. */
|
|
KMX_DWORD mac_KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(const UCKeyboardLayout* keyboard_layout, UINT kc_underlying, UINT vk_ShiftState, PKMX_WCHAR deadKey) {
|
|
PKMX_WCHAR dky = NULL;
|
|
UInt32 isdk = 0;
|
|
KMX_DWORD keyV;
|
|
int caps = 0;
|
|
|
|
if (!ensureValidInputForKeyboardTranslation(mac_convert_Shiftstate_to_MacShiftstate(vk_ShiftState), kc_underlying))
|
|
return 0;
|
|
|
|
keyV = mac_KMX_get_KeyVal_From_KeyCode_dk(keyboard_layout, kc_underlying, (mac_convert_Shiftstate_to_MacShiftstate(vk_ShiftState)), caps, isdk);
|
|
|
|
// if there was a deadkey return 0xFFFF and copy deadkey into dky; else return the keyvalue
|
|
if (isdk != 0) {
|
|
dky = (PKMX_WCHAR)(std::u16string(1, keyV)).c_str();
|
|
*deadKey = *dky;
|
|
return 0xFFFF;
|
|
}
|
|
*deadKey = 0;
|
|
return keyV;
|
|
}
|
|
|
|
/** @brief return the keyvalue of a key of the the currently used (underlying) keyboard for a given keyvalue of the US keyboard */
|
|
KMX_DWORD mac_KMX_get_KeyValUnderlying_From_KeyValUS(vec_dword_3D& all_vector, KMX_DWORD kv_us) {
|
|
// look for kv_us for any shiftstate of US keyboard
|
|
for (int i = 0; i < (int)all_vector[0].size() - 1; i++) {
|
|
for (int j = 1; j < (int)all_vector[0][0].size(); j++) {
|
|
if (all_vector[0][i][j] == kv_us)
|
|
return all_vector[1][i][j];
|
|
}
|
|
}
|
|
return kv_us;
|
|
}
|
|
|
|
/** @brief return the keycode of the currently used (underlying) keyboard for a given keyvalue of the underlying keyboard */
|
|
KMX_DWORD mac_KMX_get_KeyCodeUnderlying_From_KeyValUnderlying(vec_dword_3D& all_vector, KMX_DWORD kv_underlying) {
|
|
// look for kv_us for any shiftstate of US keyboard
|
|
for (int i = 0; i < all_vector[1].size() - 1; i++) {
|
|
for (int j = 1; j < all_vector[1][0].size(); j++) {
|
|
if (all_vector[1][i][j] == kv_underlying) {
|
|
return all_vector[1][i][0];
|
|
}
|
|
}
|
|
}
|
|
return kv_underlying;
|
|
}
|
|
|
|
/** @brief return the keycode of the currently used (underlying) keyboard for a given keycode of the US keyboard */
|
|
KMX_DWORD mac_KMX_get_KeyCodeUnderlying_From_KeyCodeUS(const UCKeyboardLayout* keyboard_layout, vec_dword_3D& all_vector, KMX_DWORD kc_us, ShiftState ss_win, int caps) {
|
|
// first get the keyvalue of the key on the US keyboard (kc_us)
|
|
std::u16string u16str = std::u16string(1, mac_KMX_get_KeyVal_From_KeyCode(keyboard_layout, kc_us, mac_convert_rgkey_Shiftstate_to_MacShiftstate(ss_win), caps));
|
|
KMX_DWORD kv = mac_KMX_get_KeyVal_From_KeyCode(keyboard_layout, kc_us, mac_convert_rgkey_Shiftstate_to_MacShiftstate(ss_win), caps);
|
|
//_S2
|
|
// then find the same keyvalue on the underlying keyboard and return the keycode of that key on the underlying keyboard
|
|
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] == (KMX_DWORD)*u16str.c_str())
|
|
if (all_vector[1][i][j] == kv)
|
|
return all_vector[1][i][0];
|
|
}
|
|
}
|
|
return kc_us;
|
|
}
|
|
|
|
/** @brief return the keycode of the currently used (underlying) keyboard for a given virtual key of the US keyboard */
|
|
KMX_DWORD mac_KMX_get_KeyCodeUnderlying_From_VKUS(KMX_DWORD vk_us) {
|
|
// on the mac virtual keys do not exist. Nevertheless we can use this mapping to obtain an 'artificial' us virtual key
|
|
return (mac_USVirtualKeyToScanCode[vk_us]);
|
|
}
|
|
|
|
/** @brief return a virtual key of the US keyboard for a given keycode of the currently used (underlying) keyboard */
|
|
KMX_DWORD mac_KMX_get_VKUS_From_KeyCodeUnderlying(KMX_DWORD keycode) {
|
|
// on the mac virtual keys do not exist. Nevertheless we can use this mapping to obtain an keycode from an 'artificial' us virtual key
|
|
return mac_ScanCodeToUSVirtualKey[keycode];
|
|
}
|
|
|
|
/** @brief return the keyvalue of a combination of deadkey + character if there is a combination available */
|
|
KMX_DWORD mac_get_CombinedChar_From_DK(const UCKeyboardLayout* keyboard_layout, int vk_dk, KMX_DWORD ss_dk, KMX_DWORD vk_us, KMX_DWORD shiftstate_mac, int caps) {
|
|
UInt32 deadkeystate;
|
|
UniCharCount maxStringlength = 5;
|
|
UniCharCount actualStringlength = 0;
|
|
OptionBits keyTranslateOptions = 0;
|
|
UniChar unicodeString[maxStringlength];
|
|
unicodeString[0] = 0;
|
|
OSStatus status;
|
|
|
|
/*
|
|
UCKeyTranslate != 0 if a dk was found; then run UCKeyTranslate again with a base character (vk_us) to get the combined dk e.g.'Â'
|
|
if CAPS is used: always add 4 e.g. SHIFT = 2; SHIFT+CAPS = 6
|
|
*/
|
|
|
|
status = UCKeyTranslate(keyboard_layout, vk_dk, kUCKeyActionDown, ss_dk, LMGetKbdType(), keyTranslateOptions, &deadkeystate, maxStringlength, &actualStringlength, unicodeString);
|
|
|
|
// If this was a deadkey, append a character
|
|
if (deadkeystate != 0) {
|
|
status = UCKeyTranslate(keyboard_layout, vk_us, kUCKeyActionDown, shiftstate_mac + 4 * caps, LMGetKbdType(), keyTranslateOptions, &deadkeystate, maxStringlength, &actualStringlength, unicodeString);
|
|
|
|
if (unicodeString[0] == 1) // impossible character
|
|
return 0;
|
|
else
|
|
return unicodeString[0]; // combined char e.g. â
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
|
|
//################################################################################################################################################
|
|
//################################################################################################################################################
|
|
|
|
|
|
void test_printoutKeyboards_S2(vec_dword_3D& all_vector) {
|
|
printf(" values of US - Values of underlying");
|
|
for ( int i=0; i< all_vector[0].size(); i++) {
|
|
printf("-----------------------------\n");
|
|
for ( int j=0; j< all_vector[0][0].size(); j++) {
|
|
printf("i:%i\tUS: %i(%c)\t Underlying: %i(%c)\t \t\t\t%c \n", i,all_vector[0][i][j] , all_vector[0][i][j] , all_vector[1][i][j],all_vector[1][i][j],(all_vector[0][i][j] == all_vector[1][i][j]) ? '.' : '*');
|
|
}
|
|
}
|
|
}
|
|
|