diff --git a/.clang-format b/.clang-format index 81ca2c82a37..50df9fee126 100644 --- a/.clang-format +++ b/.clang-format @@ -134,4 +134,3 @@ TabWidth: 8 UseCRLF: false UseTab: Never ... - diff --git a/.gitignore b/.gitignore index 92f87dbaa2d..772784fdb8c 100644 --- a/.gitignore +++ b/.gitignore @@ -183,11 +183,3 @@ lcov.info /keyman*.buildinfo /keyman*.changes /keyman*.tar.?z - -#Sabine: -# /common/test/keyboards/invalid/source/*.kmx -# /developer/src/test/auto/kmcomp/*.kmn -# /developer/src/test/auto/kmcomp/*.kvk -# /developer/src/test/auto/kmcomp/*.kvk* -# /developer/src/test/auto/kmcomp/*.txt -/linux/mcompile/keymap/X_bak diff --git a/linux/mcompile/keymap/.gitignore b/linux/mcompile/keymap/.gitignore new file mode 100644 index 00000000000..fcea0ffb39d --- /dev/null +++ b/linux/mcompile/keymap/.gitignore @@ -0,0 +1,2 @@ +resources/ +build/ diff --git a/linux/mcompile/keymap/README.md b/linux/mcompile/keymap/README.md index a40b7d4fefb..d12a0820e0b 100644 --- a/linux/mcompile/keymap/README.md +++ b/linux/mcompile/keymap/README.md @@ -1,22 +1,7 @@ -# Keymap +This is a proposal to rewrite mcompile for Linux. For this we need to query the base keyboard data from the Linux platform, then rewriting the keyboard .kmx using the same approach as is done in mcompile for Windows, but working from the data from the x11 keyboard on Linux. +Ideally, we'd rewrite mcompile to be cross-platform (Windows, Linux, macOS), so that the keyboard interrogation would be separated from the .kmx rewriting, at least to some degree. Nevertheless it would probably be easiest to start from a standalone implementation. Sample program that reads US basic keyboard and compares to key value group - -TODO check if US basic is the right Keyboard to compare with -TODO non-letter characters don't work OK yet -TODO Umlauts don't work OK yet -TODO Check for use of correct dimensions in Vector/prevent error if dims are not correct -TODO prevent crashes: handle possible Errors in CreateCompleteRow_US, Split_US_To_3D_Vector -TODO check Keycode of TLDE, BKSL, LSGT -TODO remove unnecessary printf/cout -TODO path for xkb/symbols as compile time option in meson -TODO append_other_ToVector: ensure shift states of GetKeyvalsFromKeymap are not out of range -TODO check how many/which shift states we use ( at the moment we read all shiftstate-columns of US but then use only 2 colums - (non-shift + shift) then use as many colums for Other ) - -TODO define folder to store File_US.txt" in and find better name -TODO get rid of GTK functions that are deprecated and use X11 instead -TODO retrieve name of Other keyboard and use appropriate name instead of "Other" -TODO ... +# Keymap diff --git a/linux/mcompile/keymap/build.sh b/linux/mcompile/keymap/build.sh new file mode 100755 index 00000000000..7c66e4b0b49 --- /dev/null +++ b/linux/mcompile/keymap/build.sh @@ -0,0 +1,63 @@ +#!/usr/bin/env bash + +## START STANDARD BUILD SCRIPT INCLUDE +# adjust relative paths as necessary +THIS_SCRIPT="$(readlink -f "${BASH_SOURCE[0]}")" +. "${THIS_SCRIPT%/*}/../../../resources/build/builder.inc.sh" +## END STANDARD BUILD SCRIPT INCLUDE + +#. "$KEYMAN_ROOT/resources/shellHelperFunctions.sh" + +################################ Main script ################################ + +builder_describe \ + "Mnemonic layout recompiler for Linux" \ + "@/common/include" \ + "clean" \ + "configure" \ + "build" \ + "test" + +builder_parse "$@" + +builder_describe_outputs \ + configure build/build.ninja \ + build build/mcompile + +TARGET_PATH="$THIS_SCRIPT_PATH/build" + +do_clean() { + rm -rf "$THIS_SCRIPT_PATH/resources" + rm -rf "$TARGET_PATH" +} + +do_configure() { + # Import our standard compiler defines; this is copied from + # /resources/build/meson/standard.meson.build by build.sh, because meson doesn't + # allow us to reference a file outside its root + mkdir -p "$THIS_SCRIPT_PATH/resources" + cp "$KEYMAN_ROOT/resources/build/meson/standard.meson.build" "$THIS_SCRIPT_PATH/resources/meson.build" + + pushd "$THIS_SCRIPT_PATH" > /dev/null + # Additional arguments are used by Linux build, e.g. -Dprefix=${INSTALLDIR} + meson setup build --buildtype $BUILDER_CONFIGURATION "${builder_extra_params[@]}" + popd > /dev/null + +} + +do_build() { + pushd "$TARGET_PATH" > /dev/null + ninja + popd > /dev/null +} + +do_test() { + pushd "$TARGET_PATH" > /dev/null + meson test "${builder_extra_params[@]}" + popd > /dev/null +} + +builder_run_action clean do_clean +builder_run_action configure do_configure +builder_run_action build do_build +builder_run_action test do_test diff --git a/linux/mcompile/keymap/deadkey.cpp b/linux/mcompile/keymap/deadkey.cpp new file mode 100644 index 00000000000..325082026bf --- /dev/null +++ b/linux/mcompile/keymap/deadkey.cpp @@ -0,0 +1,331 @@ +/* + * Keyman is copyright (C) 2004 - 2024 SIL International. MIT License. + * + * Mnemonic layout support for Linux + */ + +#include "keymap.h" +#include "deadkey.h" + +/** + * @brief create a Vector of DeadKey containing all combinations of deadkey + character for ALL possible Linux keyboards + * @return vector of Deadkey* that holds all combinations of deadkey + character +*/ +std::vector create_deadkeys_by_basechar() { + std::vector alDead; + vec_dword_2D dk_ComposeTable; + + create_DKTable(dk_ComposeTable); + + for (int i = 0; i < (int)dk_ComposeTable.size() - 1; i++) { + DeadKey* dk2 = new DeadKey(dk_ComposeTable[i][0]); + for (int j = i; j < (int)dk_ComposeTable.size(); j++) { + if ((dk_ComposeTable[i][0] == dk_ComposeTable[j][0]) && (IsKeymanUsedChar(dk_ComposeTable[j][1]))) + dk2->KMX_AddDeadKeyRow(dk_ComposeTable[j][1], dk_ComposeTable[j][2]); + } + alDead.push_back(dk2); + } + return alDead; +} + +/** + * @brief filter entries for the currently used Linux Keyboard out of a vector of all existing deadKey combinations + * @param dk the deadkey for which all combinations will be found + * @param[in,out] dkVec combinations of deadkey + character for the currently used Linux Keyboard + * @param r_All_Vec all existing combinations of deadkey + character for ALL possible Linux keyboards +*/ +void refine_alDead(KMX_WCHAR dk, std::vector& dkVec, std::vector& r_All_Vec) { + if (dk == 0) + return; + + for (int j = 0; j < (int)r_All_Vec.size(); j++) { + if (dk == r_All_Vec[j]->KMX_GetDeadCharacter()) { + if (!found_dk_inVector(dk, dkVec)) { + dkVec.push_back(r_All_Vec[j]); + } + return; + } + } +} + +/** + * @brief check whether a deadkey already exists in the deadkey vector + * @param dk the deadkey to be found + * @param dkVec vector containing combinations of deadkey + character + * @return true if deadkey alredy exists; + * false if not +*/ +bool found_dk_inVector(KMX_WCHAR dk, std::vector& dkVec) { + for (int i = 0; i < dkVec.size(); i++) { + if (dk == dkVec[i]->KMX_GetDeadCharacter()) + return true; + } + return false; +} + +/** + * @brief find all deadkey combinations for a certain deadkey in a vector of all deadkey combinations + * @param r_dk_ComposeTable vector containing all possible deadkey combinations + * @param dk deadkey of interest + * @param[in,out] dk_SingleTable vector containing all dk-character combinations for a specific deadkey dk + * @return true if successful; + * false if not +*/ +bool query_dk_combinations_for_specific_dk(vec_dword_2D& r_dk_ComposeTable, KMX_DWORD dk, vec_dword_2D& dk_SingleTable) { + vec_dword_1D row; + + for (int i = 0; i < (int)r_dk_ComposeTable.size(); i++) { + if (r_dk_ComposeTable[i][0] == dk && IsKeymanUsedChar(r_dk_ComposeTable[i][1])) { + row.push_back(r_dk_ComposeTable[i][0]); + row.push_back(r_dk_ComposeTable[i][1]); + row.push_back(r_dk_ComposeTable[i][2]); + dk_SingleTable.push_back(row); + row.clear(); + } + } + + if (dk_SingleTable.size() > 0) + return true; + else + return false; +} + +/** + * @brief convert a character to the upper-case equivalent and find the corresponding shiftstate + * of the entered keyval: a(97) -> A(65) + Base A(65) -> A(65) + Shift + * @param kval keyval that might be changed + * @param[in,out] shift the shiftstate of the entered keyval + * @param keymap a pointer to the currently used (underlying) keyboard layout + * @return the upper case equivalent of the keyval +*/ +KMX_DWORD KMX_change_keyname_to_capital(KMX_DWORD kVal, KMX_DWORD& shift, GdkKeymap* keymap) { + guint keyval = (guint)kVal; + GdkKeymapKey* keys; + gint n_keys; + + KMX_DWORD capitalKeyval = (KMX_DWORD)gdk_keyval_to_upper(kVal); + if (keyval != 0) { + gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &n_keys); + for (int i = 0; i < n_keys; i++) { + if (keys[i].group == 0) { + shift = keys[i].level; + return capitalKeyval; + } + } + } + return capitalKeyval; +} + +/** + * @brief append a 1D-vector containing name, base character and unicode_value to a 2D-Vector + * holding all possible combinations of deadkey + character for all Linux keyboards + * @param[in,out] dk_ComposeTable 2D-Vector holding all possible combinations of deadkey + character + * @param diacritic_name the name of a diacritic + * @param base_char base character + * @param unicode_value Unicode-value of the combined character +*/ +void add_deadkey_combination(vec_dword_2D& dk_ComposeTable, std::string diacritic_name, std::string base_char, KMX_DWORD unicode_value) { + vec_dword_1D line; + line.push_back(convertNamesTo_DWORD_Value(diacritic_name)); + line.push_back(convertNamesTo_DWORD_Value(base_char)); + line.push_back(unicode_value); + dk_ComposeTable.push_back(line); +} + +/** + * @brief create a 2D-Vector containing all possible combinations of deadkey + character for all Linux keyboards + * the values are taken from from: https://help.ubuntu.com/community/GtkDeadKeyTable#Accents + * dk_ComposeTable[i][0] : diacritic_name (e.g. dead_circumflex) + * dk_ComposeTable[i][1] : base_char (e.g. a) + * dk_ComposeTable[i][2] : unicode_value-Value (e.g. 0x00E2) + * @param[in,out] dk_ComposeTable +*/ +void create_DKTable(vec_dword_2D& dk_ComposeTable) { + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "a", 0x00E2); // small A with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "A", 0x00C2); // capital A with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "e", 0x00EA); // small E with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "E", 0x00CA); // capital E with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "i", 0x00EE); // small I with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "I", 0x00CE); // capital I with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "o", 0x00F4); // small O with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "O", 0x00D4); // capital O with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "u", 0x00FB); // small U with circumflex + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "U", 0x00DB); // capital U with circumflex + + add_deadkey_combination(dk_ComposeTable, "dead_acute", "a", 0x00E1); // small A with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "A", 0x00C1); // capital A with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "c", 0x0107); // small C with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "C", 0x0106); // capital C with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "e", 0x00E9); // small E with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "E", 0x00C9); // capital E with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "i", 0x00ED); // small I with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "I", 0x00CD); // capital I with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "l", 0x013A); // small L with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "L", 0x0139); // capital L with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "n", 0x0144); // small N with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "N", 0x0143); // capital N with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "o", 0x00F3); // small O with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "O", 0x00D3); // capital O with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "r", 0x0155); // small R with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "R", 0x0154); // capital R with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "s", 0x015B); // small S with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "S", 0x015A); // capital S with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "u", 0x00FA); // small U with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "U", 0x00DA); // capital U with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "y", 0x00FD); // small Y with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "Y", 0x00DD); // capital Y with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "z", 0x017A); // small Z with acute + add_deadkey_combination(dk_ComposeTable, "dead_acute", "Z", 0x0179); // capital Z with acute + + add_deadkey_combination(dk_ComposeTable, "dead_grave", "a", 0x00E0); // small A with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "A", 0x00C0); // capital A with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "e", 0x00E8); // small E with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "E", 0x00C8); // capital E with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "i", 0x00EC); // small I with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "I", 0x00CC); // capital I with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "o", 0x00F2); // small O with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "O", 0x00D2); // capital O with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "u", 0x00F9); // small U with grave + add_deadkey_combination(dk_ComposeTable, "dead_grave", "U", 0x00D9); // capital U with grave + + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "a", 0x00E3); // small A with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "A", 0x00C3); // capital A with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "i", 0x0129); // small I with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "I", 0x0128); // capital I with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "n", 0x00F1); // small N with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "N", 0x00D1); // capital N with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "o", 0x00F5); // small O with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "O", 0x00D5); // capital O with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "u", 0x0169); // small U with tilde + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "U", 0x0168); // capital U with tilde + + add_deadkey_combination(dk_ComposeTable, "dead_macron", "a", 0x0101); // small A with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "A", 0x0100); // capital A with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "e", 0x0113); // small E with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "E", 0x0112); // capital E with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "i", 0x012B); // small I with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "I", 0x012A); // capital I with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "o", 0x014D); // small O with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "O", 0x014C); // capital O with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "u", 0x016B); // small U with macron + add_deadkey_combination(dk_ComposeTable, "dead_macron", "U", 0x016A); // capital U with macron + + add_deadkey_combination(dk_ComposeTable, "dead_breve", "a", 0x0103); // small A with breve + add_deadkey_combination(dk_ComposeTable, "dead_breve", "A", 0x0102); // capital A with breve + add_deadkey_combination(dk_ComposeTable, "dead_breve", "g", 0x011F); // small G with breve + add_deadkey_combination(dk_ComposeTable, "dead_breve", "G", 0x011E); // capital G with breve + + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "e", 0x0117); // small E with dot above + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "E", 0x0116); // capital E with dot above + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "i", 0x0131); // small DOTLESS_I + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "I", 0x0130); // capital I with dot above + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "z", 0x017C); // small Z with dot above + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "Z", 0x017B); // capital Z with dot above + + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "a", 0x00E4); // small A with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "A", 0x00C4); // capital A with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "e", 0x00EB); // small E with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "E", 0x00CB); // capital E with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "i", 0x00EF); // small I with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "I", 0x00CF); // capital I with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "o", 0x00F6); // small O with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "O", 0x00D6); // capital O with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "u", 0x00FC); // small U with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "U", 0x00DC); // capital U with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "y", 0x00FF); // small Y with diaeresis + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "Y", 0x0178); // capital Y with diaeresis + + add_deadkey_combination(dk_ComposeTable, "dead_abovering", "a", 0x00E5); // small A with ring above + add_deadkey_combination(dk_ComposeTable, "dead_abovering", "A", 0x00C5); // capital A with ring above + add_deadkey_combination(dk_ComposeTable, "dead_abovering", "u", 0x016F); // small U with ring above + add_deadkey_combination(dk_ComposeTable, "dead_abovering", "U", 0x016E); // capital U with ring above + + add_deadkey_combination(dk_ComposeTable, "dead_doubleacute", "o", 0x0151); // small O with double acute + add_deadkey_combination(dk_ComposeTable, "dead_doubleacute", "O", 0x0150); // capital O with double acute + add_deadkey_combination(dk_ComposeTable, "dead_doubleacute", "u", 0x0171); // small U with double acute + add_deadkey_combination(dk_ComposeTable, "dead_doubleacute", "U", 0x0170); // capital U with double acute + + add_deadkey_combination(dk_ComposeTable, "dead_caron", "c", 0x010D); // small C with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "C", 0x010C); // capital C with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "d", 0x010F); // small D with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "D", 0x010E); // capital D with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "e", 0x011B); // small E with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "E", 0x011A); // capital E with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "l", 0x013E); // small L with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "L", 0x013D); // capital L with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "n", 0x0148); // small N with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "N", 0x0147); // capital N with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "r", 0x0159); // small R with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "R", 0x0158); // capital R with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "s", 0x0161); // small S with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "S", 0x0160); // capital S with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "t", 0x0165); // small T with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "T", 0x0164); // capital T with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "z", 0x017E); // small Z with caron + add_deadkey_combination(dk_ComposeTable, "dead_caron", "Z", 0x017D); // capital Z with caron + + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "c", 0x00E7); // small C with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "C", 0x00C7); // capital C with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "g", 0x0123); // small G with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "G", 0x0122); // capital G with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "k", 0x0137); // small K with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "K", 0x0136); // capital K with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "l", 0x013C); // small L with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "L", 0x013B); // capital L with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "n", 0x0146); // small N with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "N", 0x0145); // capital N with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "r", 0x0157); // small R with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "R", 0x0156); // capital R with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "s", 0x015F); // small S with cedilla + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "S", 0x015E); // capital S with cedilla + + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "a", 0x0105); // small A with ogonek + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "A", 0x0104); // capital A with ogonek + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "e", 0x0119); // small E with ogonek + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "E", 0x0118); // capital E with ogonek + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "i", 0x012F); // small I with ogonek + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "I", 0x012E); // capital I with ogonek + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "u", 0x0173); // small U with ogonek + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "U", 0x0172); // capital U with ogonek + + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "space", 0x005E); // CIRCUMFLEX_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_acute", "space", 0x0027); // APOSTROPHE + add_deadkey_combination(dk_ComposeTable, "dead_grave", "space", 0x0060); // GRAVE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_breve", "space", 0x02D8); // BREVE + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "space", 0x02D9); // DOT_ABOVE + add_deadkey_combination(dk_ComposeTable, "dead_abovering", "space", 0x02DA); // RING_ABOVE + add_deadkey_combination(dk_ComposeTable, "dead_doubleacute", "space", 0x02DD); // DOUBLE_ACUTE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_caron", "space", 0x02C7); // CARON + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "space", 0x00B8); // CEDILLA + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "space", 0x02DB); // OGONEK + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "space", 0x007E); // TILDE + + add_deadkey_combination(dk_ComposeTable, "dead_breve", "dead_breve", 0x02D8); // BREVE + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "abovedot", 0x02D9); // DOT_ABOVE + add_deadkey_combination(dk_ComposeTable, "dead_abovedot", "dead_abovedot", 0x02D9); // DOT_ABOVE + add_deadkey_combination(dk_ComposeTable, "dead_abovering", "dead_abovering", 0x02DA); // RING_ABOVE + add_deadkey_combination(dk_ComposeTable, "dead_acute", "apostrophe", 0x00B4); // ACUTE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_acute", "acute", 0x00B4); // ACUTE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_acute", "dead_acute", 0x00B4); // ACUTE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_doubleacute", "dead_doubleacute", 0x02DD); // DOUBLE_ACUTE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_caron", "caron", 0x02C7); // CARON + add_deadkey_combination(dk_ComposeTable, "dead_caron", "dead_caron", 0x02C7); // CARON + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "comma", 0x00B8); // CEDILLA + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "cedilla", 0x00B8); // CEDILLA + add_deadkey_combination(dk_ComposeTable, "dead_cedilla", "dead_cedilla", 0x00B8); // CEDILLA + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "minus", 0x00AF); // MACRON + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "asciicircum", 0x005E); // CIRCUMFLEX_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "underscore", 0x00AF); // MACRON + add_deadkey_combination(dk_ComposeTable, "dead_circumflex", "dead_circumflex", 0x005E); // CIRCUMFLEX_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "quotedbl", 0x00A8); // DIAERESIS + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "diaeresis", 0x00A8); // DIAERESIS + add_deadkey_combination(dk_ComposeTable, "dead_diaeresis", "dead_diaeresis", 0x00A8); // DIAERESIS + add_deadkey_combination(dk_ComposeTable, "dead_grave", "grave", 0x0060); // GRAVE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_grave", "dead_grave", 0x0060); // GRAVE_ACCENT + add_deadkey_combination(dk_ComposeTable, "dead_macron", "macron", 0x00AF); // MACRON + add_deadkey_combination(dk_ComposeTable, "dead_macron", "dead_macron", 0x00AF); // MACRON + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "ogonek", 0x02DB); // OGONEK + add_deadkey_combination(dk_ComposeTable, "dead_ogonek", "dead_ogonek", 0x02DB); // OGONEK + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "asciitilde", 0x007E); // TILDE + add_deadkey_combination(dk_ComposeTable, "dead_tilde", "dead_tilde", 0x007E); // TILDE +} diff --git a/linux/mcompile/keymap/deadkey.h b/linux/mcompile/keymap/deadkey.h new file mode 100644 index 00000000000..5c52768ecf1 --- /dev/null +++ b/linux/mcompile/keymap/deadkey.h @@ -0,0 +1,30 @@ + +#pragma once +#ifndef DEADKEY_H +#define DEADKEY_H + +#include "mc_import_rules.h" +#include + +/** @brief create a Vector of DeadKey containing all combinations of deadkey + character for ALL possible Linux keyboards */ +std::vector create_deadkeys_by_basechar(); + +/** @brief filter entries for the currently used Linux Keyboard out of a vector of all existing deadKey combinations */ +void refine_alDead(KMX_WCHAR dk, std::vector& dkVec, std::vector& r_All_Vec); + +/** @brief check whether a deadkey already exists in the deadkey vector */ +bool found_dk_inVector(KMX_WCHAR dk, std::vector& dkVec); + +/** @brief find all deadkey combinations for a certain deadkey in a vector of all deadkey combinations */ +bool query_dk_combinations_for_specific_dk(vec_dword_2D& r_dk_ComposeTable, KMX_DWORD dk, vec_dword_2D& dk_SingleTable); + +/** @brief convert a character to the upper-case equivalent and find the corresponding shiftstate of the entered keyval */ +KMX_DWORD KMX_change_keyname_to_capital(KMX_DWORD kVal, KMX_DWORD& shift, GdkKeymap* keymap); + +/** @brief append a 1D-vector containing name, base character and unicode_value to a 2D-Vector */ +void add_deadkey_combination(vec_dword_2D& dk_ComposeTable, std::string diacritic_name, std::string base_char, KMX_DWORD unicode_value); + +/** @brief create a 2D-Vector containing all possible combinations of deadkey + character for all Linux keyboards */ +void create_DKTable(vec_dword_2D& dk_ComposeTable); + +#endif /*DEADKEY_H*/ diff --git a/linux/mcompile/keymap/keymap.cpp b/linux/mcompile/keymap/keymap.cpp index 397be17f6c2..25d77214820 100644 --- a/linux/mcompile/keymap/keymap.cpp +++ b/linux/mcompile/keymap/keymap.cpp @@ -1,463 +1,1042 @@ +/* + * Keyman is copyright (C) 2004 - 2024 SIL International. MIT License. + * + * Mnemonic layout support for Linux + * + * Throughout mcompile we use the following naming conventions: + * KEYCODE: (name on Linux, Mac):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 (name 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" +#include "/usr/include/xcb/xproto.h" +#include + +/** + * @brief map a shiftstate used on Windows to a shiftstate suitable for gdk_keymap_translate_keyboard_state() on Linux + * Windows: (Base: 00000000 (0); Shift 00010000 (16); AltGr 00001001 (9); Shift+AltGr 00011001 (25)) + * Linux: (Base: 0; Shift 1; ALTGr 2; Shift+ALTGr 3 ) + * @param shiftState shiftstate used on Windows + * @return a shiftstate usable for gdk_keymap_translate_keyboard_state() on linux if available + * if shiftState is a windows ShiftState: convert the windows ShiftState (0,16,9,25) to a Linux ShiftState (0,1,2,3) that is then used as "Level" in gdk + * if shiftState is NOT a windows ShiftState (then in_ShiftState is already a Linux shiftstate): return the entered shiftstate + */ +int convert_Shiftstate_to_LinuxShiftstate(int shiftState) { + if (shiftState == 0) return 0; // Win ss 0 -> Lin ss 0 + else if (shiftState == K_SHIFTFLAG) return XCB_MOD_MASK_SHIFT; // Win ss 16 -> Lin ss 1 + else if (shiftState == (LCTRLFLAG | RALTFLAG)) return XCB_MOD_MASK_LOCK; // Win ss 9 -> Lin ss 2 + else if (shiftState == (K_SHIFTFLAG | LCTRLFLAG | RALTFLAG)) return (XCB_MOD_MASK_SHIFT | XCB_MOD_MASK_LOCK); // Win ss 25 -> Lin ss 3 + else return shiftState; // Lin ss x -> Lin ss x +} -/* -static void PrintKeymapForCode(GdkKeymap *keymap, guint keycode) -{ - GdkKeymapKey *maps; - guint *keyvals; - gint count; +/** + * @brief map a shiftstate used for rgkey to a shiftstate suitable for gdk_keymap_translate_keyboard_state() on Linux + * rgkey: (Base: 0; Shift1 ; AltGr 6; Shift+AltGr 7) + * Linux: (Base: 0; Shift 1; ALTGr 2; Shift+ALTGr 3 ) + * @param shiftState shiftstate used for rgkey + * @return a shiftstate usable for gdk_keymap_translate_keyboard_state() on linux if available + * if shiftState is a rgkey ShiftState: convert the rgkey ShiftState (0,1,6,7) to a Linux ShiftState (0,1,2,3) that is then used as "Level" in gdk + * if shiftState is NOT a rgkey ShiftState (then in_ShiftState is already a Linux shiftstate): return the entered shiftstate + */ +int convert_rgkey_Shiftstate_to_LinuxShiftstate(ShiftState shiftState) { + if (shiftState == Base) return 0; // rgkey ss 0 -> Lin ss 0 + else if (shiftState == Shft) return XCB_MOD_MASK_SHIFT; // rgkey ss 1 -> Lin ss 1 + else if (shiftState == MenuCtrl) return XCB_MOD_MASK_LOCK; // rgkey ss 6 -> Lin ss 2 + else if (shiftState == ShftMenuCtrl) return (XCB_MOD_MASK_SHIFT | XCB_MOD_MASK_LOCK); // rgkey ss 7 -> Lin ss 3 + else return shiftState; // Lin ss x -> Lin ss x +} - if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count)) - return; +/** + * @brief check for correct input parameter that will later be used in gdk_keymap_translate_keyboard_state() + * @param shiftstate the currently used shiftstate + * @param keycode the code of the key in question + * @return true if all parameters are OK; + * false if not + */ +bool ensureValidInputForKeyboardTranslation(int shiftstate, gint keycode) { - for (int i = 0; i < count; i++) { - if (maps[i].level > 0 || maps[i].group > 1) - continue; - printf(" i=%d, keycode=%d, keyval=%d (%c), level=%d, group=%d\n", i, maps[i].keycode, keyvals[i], keyvals[i], maps[i].level, maps[i].group); - } + // We're dealing with shiftstates 0,1,2,3 + if (shiftstate < 0 || shiftstate > 3) + return false; - g_free(keyvals); - g_free(maps); + // For K_Space (keycode = 65) only Base and Shift are allowed + if (keycode == 65 && shiftstate > 1) + return false; + + if (keycode > keycode_max) + return false; + + return true; } -*/ -void write_US_ToVector( v_str_3D &vec,std::string language, const char* text) { - // ? CHECK if ran OK-> return 0/1 - std::string FullPathName = "/usr/share/X11/xkb/symbols/" + language; +/** + * @brief convert names of keys stated in a symbol file to a keyvalue + * @param tok_str the name stated in symbol file + * @return the keyvalue + */ +KMX_DWORD convertNamesTo_DWORD_Value(std::string tok_str) { + // more on https://manpages.ubuntu.com/manpages/jammy/man3/keysyms.3tk.html + std::map key_values; + + key_values["ampersand"] = 38; + key_values["apostrophe"] = 39; + key_values["asciicircum"] = 136; + key_values["asciitilde"] = 126; + key_values["asterisk"] = 42; + key_values["at"] = 64; + key_values["backslash"] = 92; + key_values["BackSpace"] = 65288; + key_values["bar"] = 124; + key_values["braceleft"] = 123; + key_values["braceright"] = 125; + key_values["bracketleft"] = 91; + key_values["bracketright"] = 93; + key_values["colon"] = 58; + key_values["comma"] = 44; + key_values["diaeresis"] = 168; + key_values["dollar"] = 36; + key_values["equal"] = 61; + key_values["exclam"] = 33; + key_values["grave"] = 96; + key_values["greater"] = 62; + key_values["less"] = 60; + key_values["minus"] = 45; + key_values["numbersign"] = 35; + key_values["parenleft"] = 40; + key_values["parenright"] = 41; + key_values["percent"] = 37; + key_values["period"] = 46; + key_values["plus"] = 43; + key_values["question"] = 63; + key_values["quotedbl"] = 34; + key_values["semicolon"] = 59; + key_values["slash"] = 47; + key_values["space"] = 32; + key_values["ssharp"] = 223; + key_values["underscore"] = 95; + + key_values["nobreakspace"] = 160; + key_values["exclamdown"] = 161; + key_values["cent"] = 162; + key_values["sterling"] = 163; + key_values["currency"] = 164; + key_values["yen"] = 165; + key_values["brokenbar"] = 166; + key_values["section"] = 167; + key_values["copyright"] = 169; + key_values["ordfeminine"] = 170; + key_values["guillemotleft"] = 171; + key_values["notsign"] = 172; + key_values["hyphen"] = 173; + key_values["registered"] = 174; + key_values["macron"] = 175; + key_values["degree"] = 176; + key_values["plusminus"] = 177; + key_values["twosuperior"] = 178; + key_values["threesuperior"] = 179; + key_values["acute"] = 180; + key_values["mu"] = 181; + key_values["paragraph"] = 182; + key_values["periodcentered"] = 183; + key_values["cedilla"] = 184; + key_values["onesuperior"] = 185; + key_values["masculine"] = 186; + key_values["guillemotright"] = 187; + key_values["onequarter"] = 188; + key_values["onehalf"] = 189; + key_values["threequarters"] = 190; + key_values["questiondown"] = 191; + key_values["Agrave"] = 192; + key_values["Aacute"] = 193; + key_values["Acircumflex"] = 194; + key_values["Atilde"] = 195; + key_values["Adiaeresis"] = 196; + key_values["Aring"] = 197; + key_values["AE"] = 198; + key_values["Ccedilla"] = 199; + key_values["Egrave"] = 200; + key_values["Eacute"] = 201; + key_values["Ecircumflex"] = 202; + key_values["Ediaeresis"] = 203; + key_values["Igrave"] = 204; + key_values["Iacute"] = 205; + key_values["Icircumflex"] = 206; + key_values["Idiaeresis"] = 207; + key_values["ETH"] = 208; + key_values["Ntilde"] = 209; + key_values["Ograve"] = 210; + key_values["Oacute"] = 211; + key_values["Ocircumflex"] = 212; + key_values["Otilde"] = 213; + key_values["Odiaeresis"] = 214; + key_values["multiply"] = 215; + key_values["Oslash"] = 216; + key_values["Ugrave"] = 217; + key_values["Uacute"] = 218; + key_values["Ucircumflex"] = 219; + key_values["Udiaeresis"] = 220; + key_values["Yacute"] = 221; + key_values["THORN"] = 222; + key_values["agrave"] = 224; + key_values["aacute"] = 225; + key_values["acircumflex"] = 226; + key_values["atilde"] = 227; + key_values["adiaeresis"] = 228; + key_values["aring"] = 229; + key_values["ae"] = 230; + key_values["ccedilla"] = 231; + key_values["egrave"] = 232; + key_values["eacute"] = 233; + key_values["ecircumflex"] = 234; + key_values["ediaeresis"] = 235; + key_values["igrave"] = 236; + key_values["iacute"] = 237; + key_values["icircumflex"] = 238; + key_values["idiaeresis"] = 239; + key_values["eth"] = 240; + key_values["ntilde"] = 241; + key_values["ograve"] = 242; + key_values["oacute"] = 243; + key_values["ocircumflex"] = 244; + key_values["otilde"] = 245; + key_values["odiaeresis"] = 246; + key_values["division"] = 247; + key_values["oslash"] = 248; + key_values["ugrave"] = 249; + key_values["uacute"] = 250; + key_values["ucircumflex"] = 251; + key_values["udiaeresis"] = 252; + key_values["yacute"] = 253; + key_values["thorn"] = 254; + key_values["ydiaeresis"] = 255; + key_values["Aogonek"] = 417; + key_values["breve"] = 418; + key_values["Lstroke"] = 419; + key_values["Lcaron"] = 421; + key_values["Sacute"] = 422; + key_values["Scaron"] = 425; + key_values["Scedilla"] = 426; + key_values["Tcaron"] = 427; + key_values["Zacute"] = 428; + key_values["Zcaron"] = 430; + key_values["Zabovedot"] = 431; + key_values["aogonek"] = 433; + key_values["ogonek"] = 434; + key_values["lstroke"] = 435; + key_values["lcaron"] = 437; + key_values["sacute"] = 438; + key_values["caron"] = 439; + key_values["scaron"] = 441; + key_values["scedilla"] = 442; + key_values["tcaron"] = 443; + key_values["zacute"] = 444; + key_values["doubleacute"] = 445; + key_values["zcaron"] = 446; + key_values["zabovedot"] = 447; + key_values["Racute"] = 448; + key_values["Abreve"] = 451; + key_values["Lacute"] = 453; + key_values["Cacute"] = 454; + key_values["Ccaron"] = 456; + key_values["Eogonek"] = 458; + key_values["Ecaron"] = 460; + key_values["Dcaron"] = 463; + key_values["Dstroke"] = 464; + key_values["Nacute"] = 465; + key_values["Ncaron"] = 466; + key_values["Odoubleacute"] = 469; + key_values["Rcaron"] = 472; + key_values["Uring"] = 473; + key_values["Udoubleacute"] = 475; + key_values["Tcedilla"] = 478; + key_values["racute"] = 480; + key_values["abreve"] = 483; + key_values["lacute"] = 485; + key_values["cacute"] = 486; + key_values["ccaron"] = 488; + key_values["eogonek"] = 490; + key_values["ecaron"] = 492; + key_values["dcaron"] = 495; + key_values["dstroke"] = 496; + key_values["nacute"] = 497; + key_values["ncaron"] = 498; + key_values["odoubleacute"] = 501; + key_values["rcaron"] = 504; + key_values["uring"] = 505; + key_values["udoubleacute"] = 507; + key_values["tcedilla"] = 510; + key_values["abovedot"] = 511; + key_values["Hstroke"] = 673; + key_values["Hcircumflex"] = 678; + key_values["Iabovedot"] = 681; + key_values["Gbreve"] = 683; + key_values["Jcircumflex"] = 684; + key_values["hstroke"] = 689; + key_values["hcircumflex"] = 694; + key_values["idotless"] = 697; + key_values["gbreve"] = 699; + key_values["jcircumflex"] = 700; + key_values["Cabovedot"] = 709; + key_values["Ccircumflex"] = 710; + key_values["Gabovedot"] = 725; + key_values["Gcircumflex"] = 728; + key_values["Ubreve"] = 733; + key_values["Scircumflex"] = 734; + key_values["cabovedot"] = 741; + key_values["ccircumflex"] = 742; + key_values["gabovedot"] = 757; + key_values["gcircumflex"] = 760; + key_values["ubreve"] = 765; + key_values["scircumflex"] = 766; + key_values["kra"] = 930; + key_values["Rcedilla"] = 931; + key_values["Itilde"] = 933; + key_values["Lcedilla"] = 934; + key_values["Emacron"] = 938; + key_values["Gcedilla"] = 939; + key_values["Tslash"] = 940; + key_values["rcedilla"] = 947; + key_values["itilde"] = 949; + key_values["lcedilla"] = 950; + key_values["emacron"] = 954; + key_values["gcedilla"] = 955; + key_values["tslash"] = 956; + key_values["ENG"] = 957; + key_values["eng"] = 959; + key_values["Amacron"] = 960; + key_values["Iogonek"] = 967; + key_values["Eabovedot"] = 972; + key_values["Imacron"] = 975; + key_values["Ncedilla"] = 977; + key_values["Omacron"] = 978; + key_values["Kcedilla"] = 979; + key_values["Uogonek"] = 985; + key_values["Utilde"] = 989; + key_values["Umacron"] = 990; + key_values["amacron"] = 992; + key_values["iogonek"] = 999; + key_values["eabovedot"] = 1004; + key_values["imacron"] = 1007; + key_values["ncedilla"] = 1009; + key_values["omacron"] = 1010; + key_values["kcedilla"] = 1011; + key_values["uogonek"] = 1017; + key_values["utilde"] = 1021; + key_values["umacron"] = 1022; + key_values["overline"] = 1150; + + key_values["dead_abovedot"] = 729; + key_values["dead_abovering"] = 730; + key_values["dead_acute"] = 180; + key_values["dead_breve"] = 728; + key_values["dead_caron"] = 711; + key_values["dead_cedilla"] = 184; + key_values["dead_circumflex"] = 94; + key_values["dead_diaeresis"] = 168; + key_values["dead_doubleacute"] = 733; + key_values["dead_grave"] = 96; + key_values["dead_ogonek"] = 731; + key_values["dead_perispomeni"] = 126; + key_values["dead_tilde"] = 126; + + key_values["acute accent"] = 0xB4; + + if (tok_str.size() == 1) { + return (KMX_DWORD)(*tok_str.c_str()); + } else { + std::map::iterator it; + for (it = key_values.begin(); it != key_values.end(); ++it) { + if (it->first == tok_str) + return it->second; + } + } + return INVALID_NAME; +} - const char* path = FullPathName.c_str(); - FILE* fp = fopen((path), "r"); - if ( !fp) - printf("could not open file!"); +/** + * @brief create a 3D-Vector containing data of the US keyboard and the currently used (underlying) keyboard + * all_vector [ US_Keyboard ] + * [KeyCode_US ] + * [Keyval unshifted ] + * [Keyval shifted ] + * [Underlying Kbd] + * [KeyCode_underlying] + * [Keyval unshifted ] + * [Keyval shifted ] + * @param[in,out] all_vector Vector that holds the data of the US keyboard as well as the currently used (underlying) keyboard + * @param keymap pointer to currently used (underlying) keyboard layout + * @return 0 on success; + * 1 if data of US keyboard was not written; + * 2 if data of underlying keyboard was not written +*/ +int createOneVectorFromBothKeyboards(vec_dword_3D& all_vector, GdkKeymap* keymap) { + // store contents of the English (US) keyboard in all_vector + if (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 (append_underlying_ToVector(all_vector, keymap)) { + printf("ERROR: can't append underlying ToVector \n"); + return 2; + } + return 0; +} +/** + * @brief write data of the US keyboard into a 3D-Vector which later will contain + * data of the US keyboard and the currently used (underlying) keyboard + * @param[in,out] vec_us Vector that holds the data of the US keyboard + * @return 0 on success; + * 1 if data of US keyboard was not written; +*/ +int write_US_ToVector(vec_dword_3D& vec_us) { // create 1D-vector of the complete line - v_str_1D Vector_completeUS; - CreateCompleteRow_US(Vector_completeUS,fp , text, language); + vec_string_1D vector_completeUS; + if (createCompleteVector_US(vector_completeUS)) { + printf("ERROR: can't create complete row US \n"); + return 1; + } // split contents of 1D Vector to 3D vector - Split_US_To_3D_Vector( vec,Vector_completeUS); + if (split_US_To_3D_Vector(vec_us, vector_completeUS)) { + return 1; + } + + if (vector_completeUS.size() < 2) { + printf("ERROR: several keys of the US keyboard are not processed \n"); + return 1; + } - printf("+++++++ dimensions of Vector after write_US_ToVector\t\t %li..%li..%li\n", vec.size(), vec[0].size(),vec[0][0].size()); - fclose(fp); + if (vector_completeUS.size() != 48) { + printf("WARNING: the wrong keyboard input might have been chosen.\n"); + return 0; + } + + return 0; } -void CreateCompleteRow_US(v_str_1D &complete_List, FILE* fp, const char* text, std::string language) { +/** + * @brief create a 1D-Vector containing all relevant entries of the symbol file us basic + * @param[in,out] complete_List the 1D-Vector + * @return FALSE on success; + * TRUE if file could not be opened +*/ +bool createCompleteVector_US(vec_string_1D& complete_List) { // in the Configuration file we find the appopriate paragraph between "xkb_symbol " and the next xkb_symbol - // and then copy all rows starting with "key <" to a v1D-Vector + // then copy all rows starting with "key <" to a 1D-Vector - // ? CHECK if ran OK-> return 0/1 - int buffer_size = 512; - char buffer[buffer_size]; - bool print_OK = false; + bool create_row = false; const char* key = "key <"; - std::string str_txt(text); + std::string line; + std::string str_us_kbd_name("xkb_symbols \"basic\""); std::string xbk_mark = "xkb_symbol"; - // TODO define folder to store File in - std::ofstream KeyboardFile("File_" + language + ".txt"); - - printf("Keyboard %s\n", text); - KeyboardFile << "Keyboard" << text << "\n"; + std::ifstream inputFile("/usr/share/X11/xkb/symbols/us"); - if (fp) { - while (fgets(buffer, buffer_size, fp) != NULL) { - std::string str_buf(buffer); + if (!inputFile.is_open()) { + printf("ERROR: could not open file!\n"); + return TRUE; + } + else { + while (getline(inputFile, line)) { // stop when finding the mark xkb_symbol - if (std::string(str_buf).find(xbk_mark) != std::string::npos) - print_OK = false; + if (line.find(xbk_mark) != std::string::npos) + create_row = false; // start when finding the mark xkb_symbol + correct layout - if ((std::string(str_buf).find(str_txt) != std::string::npos)) - print_OK = true; + if (line.find(str_us_kbd_name) != std::string::npos) + create_row = true; // as long as we are in the same xkb_symbol layout block and find "key <" we push the whole line into a 1D-vector - if ((print_OK) && (std::string(str_buf).find(key) != std::string::npos)) { - printf("%s", buffer); - complete_List.push_back(buffer); - KeyboardFile << buffer; + else if (create_row && (line.find(key) != std::string::npos)) { + complete_List.push_back(line); } } } - printf("-°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° \n"); + complete_List.push_back(" key { [ space, space] };"); + + inputFile.close(); + return FALSE; } -void Split_US_To_3D_Vector(v_str_3D &all_US,v_str_1D completeList) { +/** + * @brief convert the key name obtained from symbol file to the matching keycode + * e.g. name of Key ) --> Keycode 15 + * @param key_name as stated in the symbol file + * @return the equivalent keycode +*/ +int get_keycode_from_keyname(std::string key_name) { + int out = INVALID_NAME; + + if (key_name == "key") + out = 49; /* VK_ BKQUOTE */ + else if (key_name == "key") + out = 10; /* VK_1 */ + else if (key_name == "key") + out = 11; /* VK_2 */ + else if (key_name == "key") + out = 12; /* VK_3 */ + else if (key_name == "key") + out = 13; /* VK_4 */ + else if (key_name == "key") + out = 14; /* VK_5 */ + else if (key_name == "key") + out = 15; /* VK_6 */ + else if (key_name == "key") + out = 16; /* VK_7 */ + else if (key_name == "key") + out = 17; /* VK_8 */ + else if (key_name == "key") + out = 18; /* VK_9 */ + else if (key_name == "key") + out = 19; /* VK_0 */ + else if (key_name == "key") + out = 20; /* VK_MINUS K_HYPHEN */ + else if (key_name == "key") + out = 21; /* VK_EQUAL */ + + else if (key_name == "key") + out = 24; /* VK_Q */ + else if (key_name == "key") + out = 25; /* VK_W */ + else if (key_name == "key") + out = 26; /* VK_E */ + else if (key_name == "key") + out = 27; /* VK_R */ + else if (key_name == "key") + out = 28; /* VK_T */ + else if (key_name == "key") + out = 29; /* VK_Y */ + else if (key_name == "key") + out = 30; /* VK_U */ + else if (key_name == "key") + out = 31; /* VK_I */ + else if (key_name == "key") + out = 32; /* VK_O */ + else if (key_name == "key") + out = 33; /* VK_P */ + else if (key_name == "key") + out = 34; /* VK_LEFTBRACE */ + else if (key_name == "key") + out = 35; /* VK_RIGHTBRACE */ + + else if (key_name == "key") + out = 38; /* VK_A */ + else if (key_name == "key") + out = 39; /* VK_S */ + else if (key_name == "key") + out = 40; /* VK_D */ + else if (key_name == "key") + out = 41; /* VK_F */ + else if (key_name == "key") + out = 42; /* VK_G */ + else if (key_name == "key") + out = 43; /* VK_H */ + else if (key_name == "key") + out = 44; /* VK_J */ + else if (key_name == "key") + out = 45; /* VK_K */ + else if (key_name == "key") + out = 46; /* VK_L */ + else if (key_name == "key") + out = 47; /* VK_SEMICOLON */ + else if (key_name == "key") + out = 48; /* VK_APOSTROPHE */ + + else if (key_name == "key") + out = 52; /* VK_Z */ + else if (key_name == "key") + out = 53; /* VK_X */ + else if (key_name == "key") + out = 54; /* VK_C */ + else if (key_name == "key") + out = 55; /* VK_V */ + else if (key_name == "key") + out = 56; /* VK_B */ + else if (key_name == "key") + out = 57; /* VK_N */ + else if (key_name == "key") + out = 58; /* VK_M */ + else if (key_name == "key") + out = 59; /* VK_ COMMA */ + else if (key_name == "key") + out = 60; /* VK_DOT */ + else if (key_name == "key") + out = 61; /* VK_SLASH */ + else if (key_name == "key") + out = 51; /* VK_BKSLASH */ + else if (key_name == "key") + out = 63; /* VK_RIGHTSHIFT */ + else if (key_name == "key") + out = 65; /* VK_SPACE */ + + return out; +} + +/** + * @brief process each element of a 1D-Vector, split and write to a 3D-Vector + * @param[in,out] all_US a 3D_Vector containing all keyvalues of the US keyboard + * @param completeList a 1D-Vector containing all relevant entries copied from the symbol file us basic + * @return 0 on success if entry can be split +*/ +int split_US_To_3D_Vector(vec_dword_3D& all_US, vec_string_1D completeList) { // 1: take the whole line of the 1D-Vector and remove unwanted characters. - // 2: seperate the name e.g. key and the shiftstates - // 3: push Names/Shiftstates to shift_states and then shiftstates to All_US, our 3D-Vector holding all Elements + // 2: seperate the name e.g. key from the shiftstates + // 3: convert to KMX_DWORD + // 4: push Names/Shiftstates to shift_states and then shift_states to All_US, our 3D-Vector holding all Elements - // ? CHECK if ran OK-> return 0/1 std::vector delim{' ', '[', ']', '}', ';', '\t', '\n'}; - char split_bracel = '{'; - char split_char_komma = ','; - std::string empty = "--"; - v_str_1D tokens; - v_str_2D shift_states; - - // go through the whole vector - for (int k = 0; k < (int)completeList.size() - 1; k++) { + int keyCode; + vec_string_1D tokens; + vec_dword_1D tokens_dw; + vec_dword_2D shift_states; + // loop through the whole vector + for (int k = 0; k < (int)completeList.size(); k++) { // remove all unwanted char - for (int i = 0; i < (int) delim.size(); i++) { + for (int i = 0; i < (int)delim.size(); i++) { completeList[k].erase(remove(completeList[k].begin(), completeList[k].end(), delim[i]), completeList[k].end()); } // only lines with ("key<.. are of interest if (completeList[k].find("key<") != std::string::npos) { + // split off the key names + std::istringstream split_Keyname(completeList[k]); + for (std::string each; std::getline(split_Keyname, each, '{'); tokens.push_back(each)) { + // empty + } - //split off the key names - std::istringstream split1(completeList[k]); - for (std::string each; std::getline(split1, each, split_bracel); tokens.push_back(each)); - - // replace keys names with number ( with 29,...) - - // ? CHECK if ran OK-> return 0/1 - int Keycde = replace_PosKey_with_Keycode(tokens[0]); - tokens[0] = std::to_string(Keycde); + // replace keys names with Keycode ( with 21,...) + keyCode = get_keycode_from_keyname(tokens[0]); + tokens[0] = std::to_string(keyCode); // seperate rest of the vector to its elements and push to 'tokens' - std::istringstream split(tokens[1]); + std::istringstream split_Characters(tokens[1]); tokens.pop_back(); - for (std::string each; std::getline(split, each, split_char_komma); tokens.push_back(each)); - //printf("### 5 Split_US_To_3D_Vector: tokens: size:%li...tokens[0]-[4]:-name:%s\tShiftstates:%s--%s--%s--%s---.\n", tokens.size(),tokens[0].c_str(),tokens[1].c_str(),tokens[2].c_str(),tokens[3].c_str(),tokens[4].c_str()); - // at the moment we only use the first 2 shiftstates (non-shift+shift) so get rid of all others - int surplus = tokens.size() - shift_state_count -1; - for( int j=0; j < surplus;j++) { - tokens.pop_back(); + for (std::string each; std::getline(split_Characters, each, ','); + tokens.push_back(each)); + + // now convert all to KMX_DWORD and fill tokens + tokens_dw.push_back((KMX_DWORD)keyCode); + + for (int i = 1; i < (int)tokens.size(); i++) { + // replace a name with a single character ( a -> a ; equal -> = ) + KMX_DWORD tokens_int = convertNamesTo_DWORD_Value(tokens[i]); + tokens_dw.push_back(tokens_int); } - // now push result to shift_states - shift_states.push_back(tokens); + shift_states.push_back(tokens_dw); + tokens_dw.clear(); tokens.clear(); } } all_US.push_back(shift_states); - // ? CHECK if ran OK, vector size is correct -> return 0/1 - //printf("### 6 Split_US_To_3D_clearVector %li..%li..%li\n", all_US.size(), all_US[0].size(),all_US[0][0].size()); + if (all_US.size() == 0) { + printf("ERROR: Can't split US to 3D-Vector\n"); + return 1; + } + return 0; } -int replace_PosKey_with_Keycode(std::string in) { - int out=0; - if ( in == "key") out = 49; //correct ??? - else if ( in == "key") out = 10; - else if ( in == "key") out = 11; - else if ( in == "key") out = 12; - else if ( in == "key") out = 13; - else if ( in == "key") out = 14; - else if ( in == "key") out = 15; - else if ( in == "key") out = 16; - else if ( in == "key") out = 17; - else if ( in == "key") out = 18; - else if ( in == "key") out = 19; - else if ( in == "key") out = 20; - else if ( in == "key") out = 21; - - else if ( in == "key") out = 24; - else if ( in == "key") out = 25; - else if ( in == "key") out = 26; - else if ( in == "key") out = 27; - else if ( in == "key") out = 28; - else if ( in == "key") out = 29; - else if ( in == "key") out = 30; - else if ( in == "key") out = 31; - else if ( in == "key") out = 32; - else if ( in == "key") out = 33; - else if ( in == "key") out = 34; - else if ( in == "key") out = 35; - - else if ( in == "key") out = 38; - else if ( in == "key") out = 39; - else if ( in == "key") out = 40; - else if ( in == "key") out = 41; - else if ( in == "key") out = 42; - else if ( in == "key") out = 43; - else if ( in == "key") out = 44; - else if ( in == "key") out = 45; - else if ( in == "key") out = 46; - else if ( in == "key") out = 47; - else if ( in == "key") out = 48; - else if ( in == "key") out = 49; - - else if ( in == "key") out = 52; - else if ( in == "key") out = 53; - else if ( in == "key") out = 54; - else if ( in == "key") out = 55; - else if ( in == "key") out = 56; - else if ( in == "key") out = 57; - else if ( in == "key") out = 58; - else if ( in == "key") out = 59; - else if ( in == "key") out = 60; - else if ( in == "key") out = 61; - else if ( in == "key") out = 62; //correct ??? - else if ( in == "key") out = 51; //correct ??? - return out; +/** + * @brief create an 2D-Vector with all fields initialized to INVALID_NAME + * @param dim_rows number of rows in vector + * @param dim_ss number of columns in vector + * @return the 2D-Vector +*/ +vec_dword_2D 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; } -void append_other_ToVector(v_str_3D &All_Vector,GdkKeymap * keymap) { +/** + * @brief append a 2D-vector containing data of the currently used (underlying) keyboard to the 3D-vector + * @param[in,out] all_vector 3D-vector that holds the data of the US keyboard and the currently used (underlying) keyboard + * @param keymap pointer to currently used (underlying) keybord layout + * @return 0 on success; + * 1 if the initialization of the underlying vector fails; + * 2 if data of less than 2 keyboards is contained in all_vector +*/ +int append_underlying_ToVector(vec_dword_3D& all_vector, GdkKeymap* keymap) { + if (all_vector.size() != 1) { + printf("ERROR: data for US keyboard not correct\n"); + return 1; + } - // create a 2D vector all fill0ed with "--" and push to 3D-Vector - // ? CHECK if ran OK-> return 0/1 - v_str_2D Other_Vector2D = create_empty_2D(All_Vector[0].size(),All_Vector[0][0].size()); - All_Vector.push_back(Other_Vector2D); + // create a 2D vector all filled with " " and push to 3D-Vector + vec_dword_2D underlying_Vector2D = create_empty_2D_Vector(all_vector[0].size(), all_vector[0][0].size()); - printf("+++++++ dimensions of Vector after append_other_ToVector\t %li..%li..%li\n", All_Vector.size(), 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 =1; i< (int) All_Vector[1].size()-1;i++) - { - // get key name US stored in [0][i][0] and copy to name in other-block[1][i][0] - All_Vector[1][i][0] = All_Vector[0][i][0]; + 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]; - // write this value to 3D- Vector - All_Vector[1][i][0+1] = GetKeyvalsFromKeymap(keymap,stoi(All_Vector[1][i][0]),0); //shift state: unshifted:0 - All_Vector[1][i][1+1] = GetKeyvalsFromKeymap(keymap,stoi(All_Vector[1][i][0]),1); //shift state: shifted:1 - //printf("Keycodes US->Other: %d(US): %s %s ---- (other):%s, %s, %s \n",stoi(All_Vector[1][i][0]),All_Vector[0][i][1].c_str(),All_Vector[0][i][2].c_str(),All_Vector[1][i][1].c_str(),All_Vector[1][i][2].c_str(),All_Vector[1][i][3].c_str()); + // 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(keymap, all_vector[0][i][0], convert_rgkey_Shiftstate_to_LinuxShiftstate(ShiftState::Base)); // shift state: unshifted:0 + all_vector[1][i][1 + 1] = KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(keymap, all_vector[0][i][0], convert_rgkey_Shiftstate_to_LinuxShiftstate(ShiftState::Shft)); // shift state: shifted:1 } - // ? CHECK if ran OK, vector size is correct -> return 0/1 + + return 0; } -v_str_2D create_empty_2D( int dim_rows,int dim_shifts) -{ - std::string empty = "--"; - v_str_1D shifts; - v_str_2D all; +/** + * @brief initializes GDK and return the current keymap for later use + * @param keymap [out] currently used (underlying) keyboard layout + * @return FALSE on success; + * TRUE if the display or keymap is not found +*/ +bool InitializeGDK(GdkKeymap** keymap, int argc, gchar* argv[]) { + // get keymap of underlying keyboard - for ( int i=0; i< dim_rows;i++) { - for ( int j=0; j< dim_shifts;j++) { - shifts.push_back(empty); - } - all.push_back(shifts); - shifts.clear(); + gdk_init(&argc, &argv); + GdkDisplay* display = gdk_display_get_default(); + if (!display) { + printf("ERROR: can't get display\n"); + return TRUE; } - //printf("+++++++ dimensions of Vector after create_empty_2D\t\t %li..%li..%li\n", all.size(), all[0].size(),all[1].size()); - return all; + + *keymap = gdk_keymap_get_for_display(display); + if (!keymap) { + printf("ERROR: Can't get keymap\n"); + gdk_display_close(display); + return TRUE; + } + // intentionally leaking `display` in order to still be able to access `keymap` + return FALSE; } -int GetKeyvalsFromKeymap(GdkKeymap *keymap, guint keycode, int shift_state_pos) { - GdkKeymapKey *maps; - guint *keyvals; - gint count; - int out; +/** + * @brief check if keyval correponds to a character we use in mcompile + * @param kv the keyval to be checked + * @return true if keyval is used in mcompile; + * false if not +*/ +bool IsKeymanUsedChar(int kv) { + // 32 A-Z a-z + if ((kv == 0x20) || (kv >= 65 && kv <= 90) || (kv >= 97 && kv <= 122)) + return true; + else + return false; +} + +/** + * @brief convert a deadkey-value to a u16string if it is in the range of deadkeys used for mcompile. + * deadkeys used for mcompile e.g. 65106 -> '^' + * @param in value to be converted + * @return on success a u16string holding the converted value; + * else u"\0" +*/ +std::u16string convert_DeadkeyValues_To_U16str(KMX_DWORD in) { + if (in == 0) + return u"\0"; + if ((int)in < (int)deadkey_min) { // no deadkey; no Unicode + return std::u16string(1, in); + } + + std::string long_name((const char*)gdk_keyval_name(in)); // e.g. "dead_circumflex", "U+017F", "t" + + if (long_name.substr(0, 2) == "U+") // U+... Unicode value + return CodePointToU16String(in - 0x1000000); // GDK's gdk_keymap_translate_keyboard_state() returns (Keyvalue | 0x01000000) + // since we never have a carry-over we can just subtract 0x01000000 + + KMX_DWORD lname = convertNamesTo_DWORD_Value(long_name); // 65106 => "dead_circumflex" => 94 => "^" + + if (lname != INVALID_NAME) { + return std::u16string(1, lname); + } else + return u"\0"; +} + +/** + * @brief return the keyvalue for a given Keycode, shiftstate and caps + * currently used (underlying) keyboard layout + * "What character will be produced for a keypress of a key and modifier?" + * @param keymap pointer to the currently used (underlying) keyboard layout + * @param keycode a key of the currently used keyboard layout + * @param ss a (windows-)shiftstate of the currently used keyboard layout + * @param caps state of the caps key of the currently used keyboard layout + * @return the keyval obtained from keycode, shiftstate and caps +*/ +KMX_DWORD KMX_get_KeyVal_From_KeyCode(GdkKeymap* keymap, guint keycode, ShiftState ss, int caps) { + GdkModifierType consumed; + GdkKeymapKey* maps; + guint* keyvals; + gint count; if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count)) return 0; - //if(!gdk_wayland_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count)) - // return 0; - if (!(shift_state_pos < count)) + if (!(ensureValidInputForKeyboardTranslation(convert_rgkey_Shiftstate_to_LinuxShiftstate(ss), keycode))) { + g_free(keyvals); + g_free(maps); return 0; + } - out = keyvals[shift_state_pos]; + // BASE (shiftstate: 0) + if ((ss == Base) && (caps == 0)) { + GdkModifierType MOD_base = (GdkModifierType)(~GDK_MODIFIER_MASK); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_base, 0, keyvals, NULL, NULL, &consumed); + } - g_free(keyvals); - g_free(maps); - return out; -} + // BASE + CAPS (shiftstate: 0) + else if ((ss == Base) && (caps == 1)) { + GdkModifierType MOD_Caps = (GdkModifierType)(GDK_LOCK_MASK); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_Caps, 0, keyvals, NULL, NULL, &consumed); + } -void extract_difference( v_str_3D &All_Vector) -{ - // ? CHECK if ran OK-> return 0/1 - // TODO define which Folder; find better name - std::ofstream Map_File("Map_US.txt"); - std::string diff =" "; - - printf("-----------------------------------------------------------------------------------------------------------------------------------------------\n"); - std::cout << "Nr of \n" ; - std::cout << "Key: " << "\t Character US (no shift) " << " Character US (shift) "<< "\t\tCharacter other (no shift)" << "\tCharacter other (shift) difference \n" ; - printf("-----------------------------------------------------------------------------------------------------------------------------------------------\n"); - - Map_File <<"--------------------------------------------------------------------------------------------------------------------------------------------\n"; - Map_File << "Nr of \n" ; - Map_File << "Key: " << "\t Character US (no shift) " << " Character US (shift) "<< "\t\tCharacter other (no shift)" << "\tCharacter other (shift) difference \n" ; - Map_File <<"--------------------------------------------------------------------------------------------------------------------------------------------\n"; - - for ( int k=0; k<(int)All_Vector[0].size()-1; k++) { - if (All_Vector[0][k][1] == All_Vector[1][k][1]) - diff =" "; - else - diff =" *** "; - // ? CHECK if index exists - std::cout << All_Vector[0][k][0] << "\t " <<+(*(All_Vector[0][k][1].c_str()))<< "\t("<< All_Vector[0][k][1] <<")"< Other: "<< std::setw(5)< Other: (" << in << ": no match)\n"; - return "-"; -} -std::string get_US_Char_FromOther(std::string in , v_str_3D &All_Vector) { - std::string diff; - // find correct row of char in other - for( int i=0; i< (int)All_Vector[1].size()-1;i++) { - for( int j=0; j< (int)All_Vector[1][0].size()-1;j++) { - if ( All_Vector[1][i][j] == in ) { - if ( All_Vector[0][i][j] != All_Vector[1][i][j]) - diff =" ** "; - // ? CHECK if Index exists - std::cout << "Other -> US: "<< std::setw(5)< US: (" << in << ": no match)\n"; - return "-"; - } - -std::string getKeyNrOf_USChar(std::string in , v_str_3D &All_Vector) { - // find correct row of char in US - for( int i=0; i< (int)All_Vector[0].size()-1;i++) { - for( int j=0; j< (int)All_Vector[0][0].size()-1;j++) { - if ( All_Vector[0][i][j] == in ) { - // ? CHECK if index exists - std::cout << "KeyNr of US char: \t"<< All_Vector[0][i][j] << " -> " << All_Vector[0][i][0] <<"\n"; - return All_Vector[0][i][0] ; - } - } + // Ctrl (shiftstate: 2) + else if ((ss == Ctrl) && (caps == 0)) { + GdkModifierType MOD_Ctrl = (GdkModifierType)(GDK_MOD5_MASK); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_Ctrl, 0, keyvals, NULL, NULL, &consumed); } - return "-"; -} -std::string getKeyNrOf_OtherChar(std::string in , v_str_3D &All_Vector) { - // find correct row of char in US - for( int i=0; i< (int)All_Vector[1].size()-1;i++) { - for( int j=0; j< (int)All_Vector[1][0].size()-1;j++) { - if ( All_Vector[1][i][j] == in ) { - // ? CHECK if index exists - std::cout << "KeyNr of Other char : \t"<< All_Vector[1][i][j] << " -> " << All_Vector[1][i][0] <<"\n"; - return All_Vector[1][i][0] ; - } - } + // Ctrl + CAPS (shiftstate: 2) + else if ((ss == Ctrl) && (caps == 1)) { + GdkModifierType MOD_CtrlCaps = (GdkModifierType)(GDK_MOD5_MASK | GDK_LOCK_MASK); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_CtrlCaps, 0, keyvals, NULL, NULL, &consumed); } - return "-"; -} -bool test(v_str_3D &V) { -// ? CHECK if index exists - printf("\n+++++++++ print some characters of US and Other +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"); + // SHIFT+Ctrl (shiftstate: 3) + else if ((ss == ShftCtrl) && (caps == 0)) { + GdkModifierType MOD_Ctrl = (GdkModifierType)(GDK_SHIFT_MASK | GDK_MOD5_MASK); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_Ctrl, 0, keyvals, NULL, NULL, &consumed); + } - for ( int k=13; k<43; k++) { - std::cout << " row 1 (US)......" << V[0][k][0]<< ".." << V[0][k][1]<< ".."<< V[0][k][2]<< ".." << V[0][k][3]<< ".." << V[0][k][4]<< "..\n" ; - if (V.size()>1) - std::cout << " row 1 (Other).."<< V[1][k][0]<< ".." << V[1][k][1]<< ".."<< V[1][k][2]<< ".." << V[1][k][3]<< ".." << V[1][k][4]<< "..\n" ; + // SHIFT+Ctrl + CAPS (shiftstate: 3) + else if ((ss == ShftCtrl) && (caps == 1)) { + GdkModifierType MOD_CtrlCaps = (GdkModifierType)(GDK_SHIFT_MASK | GDK_MOD5_MASK | GDK_LOCK_MASK); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_CtrlCaps, 0, keyvals, NULL, NULL, &consumed); } - printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"); - return true; -} -void test_in_out(v_str_3D &All_Vector) { -std::string diff; - printf("-----------------------------------------------------------------------------------------------------------------------------------------------\n"); - //checks mapping between US and other - std::string a = get_Other_Char_FromUS( "z", All_Vector); - std::string aa = get_Other_Char_FromUS( "Z", All_Vector); - std::string aaa = get_Other_Char_FromUS( "y", All_Vector); - std::string aaaa = get_Other_Char_FromUS( "Y", All_Vector); - - std::string b = get_US_Char_FromOther( "z", All_Vector); - std::string bb = get_US_Char_FromOther( "Z", All_Vector); - std::string bbb = get_US_Char_FromOther( "y", All_Vector); - std::string bbbb = get_US_Char_FromOther( "Y", All_Vector); - - std::string c = getKeyNrOf_OtherChar( "z", All_Vector); - std::string cc = getKeyNrOf_OtherChar( "Z", All_Vector); - std::string ccc = getKeyNrOf_OtherChar( "y", All_Vector); - std::string cccc = getKeyNrOf_OtherChar( "Y", All_Vector); - - std::string d = getKeyNrOf_USChar( "z", All_Vector); - std::string dd = getKeyNrOf_USChar( "Z", All_Vector); - std::string ddd = getKeyNrOf_USChar( "y", All_Vector); - std::string dddd = getKeyNrOf_USChar( "Y", All_Vector); - - std::cout << "get_Other_Char_FromUS z-Z-y-Y: " << ".." << a<< ".." < return 0/1 - printf("-----------------------------------------------------------------------------------------------------------------------------------------------\n"); - for ( int i=0; i< (int)All_Vector[0].size();i++) { - out =get_Other_Char_FromUS(All_Vector[0][i][shiftstate], All_Vector); + // ALT-GR + CAPS (shiftstate: 6) + else if ((ss == MenuCtrl) && (caps == 1)) { + GdkModifierType MOD_AltGr = (GdkModifierType)(GDK_MOD2_MASK | GDK_MOD5_MASK | GDK_LOCK_MASK); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_AltGr, 0, keyvals, NULL, NULL, &consumed); } -} -void print_simple_map_Other(v_str_3D &All_Vector, int shiftstate){ - std::string out, diff; - // ? CHECK if ran OK-> return 0/1 - printf("-----------------------------------------------------------------------------------------------------------------------------------------------\n"); - for ( int i=0; i< (int)All_Vector[0].size();i++) { - out = get_US_Char_FromOther(All_Vector[0][i][shiftstate], All_Vector); + // ALT-GR (shiftstate: 7) + else if ((ss == ShftMenuCtrl) && (caps == 0)) { + GdkModifierType MOD_AltGr = (GdkModifierType)((GDK_SHIFT_MASK | GDK_MOD2_MASK | GDK_MOD5_MASK)); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_AltGr, 0, keyvals, NULL, NULL, &consumed); } + + // ALT-GR +CAPS (shiftstate: 7) + else if ((ss == ShftMenuCtrl) && (caps == 1)) { + GdkModifierType MOD_AltGr = (GdkModifierType)((GDK_SHIFT_MASK | GDK_MOD2_MASK | GDK_MOD5_MASK | GDK_LOCK_MASK)); + gdk_keymap_translate_keyboard_state(keymap, keycode, MOD_AltGr, 0, keyvals, NULL, NULL, &consumed); + } else + return 0; + + return (int)*keyvals; } -void test_specific_Characters(v_str_3D &All_Vector){ - printf("-----------------------------------------------------------------------------------------------------------------------------------------------\n"); - v_str_1D in {"a", "b", "m", "w", "x", "y", "z"}; - std::string out; - for( int i=0; i< (int) in.size()-1; i++) { - out = get_Other_Char_FromUS(in[i], All_Vector); +/** + * @brief return the keyvalue for a given Keycode and shiftstate of the currently used (underlying) keyboard layout. + * "What character will be produced for a keypress of a key and modifiers on the underlying keyboard?" + * @param keymap a pointer to the currently used (underlying) keyboard layout + * @param keycode a key of the currently used keyboard + * @param shiftState a shiftstate of the currently used keyboard layout + * @return the keyval obtained from Keycode and shiftstate; + */ +KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap* keymap, guint keycode, int shiftState) { + GdkKeymapKey* maps; + guint* keyvals; + gint count; + KMX_DWORD kVal; + + if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count)) + return 0; + + + if (!(ensureValidInputForKeyboardTranslation(shiftState, keycode))) { + g_free(keyvals); + g_free(maps); + return 0; } + + kVal = KMX_get_KeyVal_From_KeyCode(keymap, keycode, (ShiftState)shiftState, 0); + + g_free(keyvals); + g_free(maps); + + return kVal; } +/** + * @brief return the keyvalue for a given Keycode and shiftstate of the currently used (underlying) keyboard layout. + * "What character will be produced for a keypress of a key and modifiers on the underlying keyboard?" + * If a deadkey was found return 0xFFFF and copy the deadkey into deadKey + * This function is similar to KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap* keymap, guint keycode, int shiftState) + * but processes deadkeys + * @param keymap a pointer to the currently used (underlying) keyboard layout + * @param keycode a key of the currently used keyboard + * @param shiftState a shiftstate of the currently used keyboard layout + * @param deadKey* pointer to keyvalue if a deadkey was found; if not NULL + * @return 0xFFFF in case a deadkey was found, then the deadkey is stored in deadKey + * 0xFFFE in case a deadkey is out of range + * the keyval obtained from Keycode and shiftstate and caps; +*/ +KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap* keymap, guint keycode, KMX_DWORD shiftState, PKMX_WCHAR deadkey) { + GdkKeymapKey* maps; + guint* keyvals; + gint count; + PKMX_WCHAR dky = NULL; -//-------------------------------------- -int main(gint argc, gchar *argv[]) -{ - gdk_init(&argc, &argv); - GdkDisplay *display = gdk_display_get_default(); - if (!display) { - printf("ERROR: can't get display\n"); - return 1; - } - GdkKeymap *keymap = gdk_keymap_get_for_display(display); - if (!keymap) { - printf("ERROR: Can't get keymap\n"); - gdk_display_close(display); - return 2; + if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count)) + return 0; + + if (!(ensureValidInputForKeyboardTranslation(convert_Shiftstate_to_LinuxShiftstate(shiftState), keycode))) { + g_free(keyvals); + g_free(maps); + return 0; } - // write content of xkb_symbols to 3D Vector - // I assume we use Keyboard US basic as base - std::string US_language = "us"; - const char* text_us = "xkb_symbols \"basic\""; + KMX_DWORD keyV = KMX_get_KeyVal_From_KeyCode(keymap, keycode, ShiftState(convert_Shiftstate_to_LinuxShiftstate(shiftState)), 0); - v_str_3D All_Vector; - write_US_ToVector(All_Vector,US_language, text_us); - //test(All_Vector); + g_free(keyvals); + g_free(maps); - // add contents of other keyboard to vector - append_other_ToVector(All_Vector,keymap); - //test(All_Vector); + if ((keyV >= deadkey_min) && (keyV <= deadkey_max)) { // deadkey + dky = (PKMX_WCHAR)(convert_DeadkeyValues_To_U16str(keyV)).c_str(); + *deadkey = *dky; + return 0xFFFF; + } else if ((keyV > deadkey_max) || ((keyV < deadkey_min) && (keyV > 0xFF))) // out of range + return 0xFFFE; + else // usable char + return keyV; +} - extract_difference(All_Vector); - //test_in_out(All_Vector); - //print_simple_map_US(All_Vector,1); // 1 = non-shift - //print_simple_map_Other(All_Vector,1); // 1 = non-shift - test_specific_Characters(All_Vector); - gdk_display_close(display); +/** + * @brief return the keyvalue of a key of the the currently used (underlying) keyboard for a given keyvalue of the US keyboard + * "What character is on the same position/shiftstats/caps on the currently used (underlying) keyboard as on the US keyboard?" + * @param all_vector 3D-vector that holds the data of the US keyboard and the currently used (underlying) keyboard + * @param kv_us a keyvalue on the US keyboard + * @return keyval of the underlying keyboard if available; + * else the keyval of the US keyboard +*/ +KMX_DWORD 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 keycode of the US keyboard + * "Where on an underlying keyboard do we find a character that is on a certain key on a US keyboard?" + * @param keymap the currently used (underlying) keyboard layout + * @param all_vector 3D-vector that holds the data of the US keyboard and the currently used (underlying) keyboard + * @param kc_us a key of the US keyboard + * @param ss a windows-type shiftstate + * @param caps state of the caps key + * @return the keycode of the underlying keyboard if found; + * else the keycode of the US keyboard +*/ +KMX_DWORD KMX_get_KeyCodeUnderlying_From_KeyCodeUS(GdkKeymap* keymap, vec_dword_3D& all_vector, KMX_DWORD kc_us, ShiftState ss, int caps) { + std::u16string u16str = convert_DeadkeyValues_To_U16str(KMX_get_KeyVal_From_KeyCode(keymap, kc_us, ss, caps)); + + 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())) + 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 + * "Where on an underlying keyboard do we find a character of a US keyboard?" + * @param virtualKeyUS a virtual key of the US keyboard + * @return the keycode of the currently used (underlying) keyboard +*/ +KMX_DWORD KMX_get_KeyCodeUnderlying_From_VKUS(KMX_DWORD virtualKeyUS) { + // Linux virtualKeys are always 8 different to Windows virtualKeys + return (KMX_DWORD)(8 + USVirtualKeyToScanCode[virtualKeyUS]); +} + +/** + * @brief return a virtual key of the US keyboard for a given keycode of the currently used (underlying) keyboard + * "Which key of a underlying keyboard will be mapped to a virtual key of a US keyboard?" + * @param keycode a keycode of the currently used (underlying) keyboard + * @return the virtual key of the US keyboard or + * 0 if the key is not used +*/ +KMX_DWORD KMX_get_VKUS_From_KeyCodeUnderlying(KMX_DWORD keycode) { + // Linux virtualKeys are always 8 different to Windows virtualKeys + if (keycode > 7) + return (KMX_DWORD)ScanCodeToUSVirtualKey[keycode - 8]; - printf("°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° end\n"); return 0; } + +/** + * @brief convert a codepoint to a u16string + * @param codepoint to be converted + * @return a u16string holding the converted value; +*/ +std::u16string CodePointToU16String(unsigned int codepoint) { + std::u16string str; + + if (codepoint <= 0xFFFF) { + str = static_cast(codepoint); + } else { + assert(codepoint < 0x10FFFF); + assert(isLittleEndianSystem()); + + codepoint -= 0x10000; + str.resize(2); + str[0] = static_cast(0xDC00 + (codepoint & 0x3FF)); + str[1] = static_cast(0xD800 + ((codepoint >> 10) & 0x3FF)); + } + return str; +} diff --git a/linux/mcompile/keymap/keymap.h b/linux/mcompile/keymap/keymap.h index cfbd5dc1df9..11c437378d7 100644 --- a/linux/mcompile/keymap/keymap.h +++ b/linux/mcompile/keymap/keymap.h @@ -1,67 +1,574 @@ -// In ths program we use a 3D-Vector Vector[language][Keys][Shiftstates] #pragma once +#ifndef KEYMAP_H +#define KEYMAP_H #include #include #include +#include #include #include #include #include #include #include +#include "km_u16.h" +#include -#include "mc_kmxfile.h" -#include "mc_savekeyboard.h" +enum ShiftState { + Base = 0, // 0 + Shft = 1, // 1 + Ctrl = 2, // 2 + ShftCtrl = Shft | Ctrl, // 3 + Menu = 4, // 4 -- NOT USED + ShftMenu = Shft | Menu, // 5 -- NOT USED + MenuCtrl = Menu | Ctrl, // 6 + ShftMenuCtrl = Shft | Menu | Ctrl, // 7 + Xxxx = 8, // 8 + ShftXxxx = Shft | Xxxx, // 9 +}; -typedef std::vector v_str_1D; -typedef std::vector > v_str_2D; -typedef std::vector > > v_str_3D; +#define VK_SPACE 0x20 +#define VK_COLON 0xBA +#define VK_EQUAL 0xBB +#define VK_COMMA 0xBC +#define VK_HYPHEN 0xBD +#define VK_PERIOD 0xBE +#define VK_SLASH 0xBF +#define VK_ACCENT 0xC0 +#define VK_LBRKT 0xDB +#define VK_BKSLASH 0xDC +#define VK_RBRKT 0xDD +#define VK_QUOTE 0xDE +#define VK_xDF 0xDF +#define VK_OEM_102 0xE2 // "<>" or "\|" on RT 102-key kbd. -int shift_state_count = 2; // use shiftstate : no shift, shift +#define VK_DIVIDE 0x6F +#define VK_CANCEL 3 +#define VK_DECIMAL 0x2E -// read configuration file, split and write to 3D-Vector (Data for US on [0][ ][ ] ) -void write_US_ToVector(v_str_3D &vec, std::string language, const char *text); +#define VK_OEM_CLEAR 0xFE +#define VK_LSHIFT 0xA0 +#define VK_RSHIFT 0xA1 +#define VK_LCONTROL 0xA2 +#define VK_RCONTROL 0xA3 +#define VK_LMENU 0xA4 +#define VK_RMENU 0xA5 -// 1. step: read complete Row of Configuration file US -void CreateCompleteRow_US(v_str_1D &complete_List, FILE *fpp, const char *text, std::string language); +#define VK_SHIFT 0x10 +#define VK_CONTROL 0x11 +#define VK_MENU 0x12 +#define VK_PAUSE 0x13 +#define VK_CAPITAL 0x14 -// 2nd step: write contents to 3D vector -void Split_US_To_3D_Vector(v_str_3D &all_US, v_str_1D completeList); -// replace Name of Key (e.g. ) wih Keycode ( e.g. 15 ) -int replace_PosKey_with_Keycode(std::string in); +// Map of all US English virtual key codes that we can translate +const KMX_DWORD KMX_VKMap[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', + 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', -// append characters using GDK to 3D-Vector (Data for Other Language on [1][ ][ ] ) -void append_other_ToVector(v_str_3D &All_Vector, GdkKeymap *keymap); + VK_SPACE, /* 32 */ -// create an empty 2D vector containing "--" in all fields -v_str_2D create_empty_2D(int dim_rows, int dim_shifts); + VK_ACCENT, /* 192 VK_OEM_3 K_BKQUOTE */ + VK_HYPHEN, /* - 189 VK_OEM_MINUS */ + VK_EQUAL, /* = 187 VK_OEM_PLUS */ -// find Keyvals to fill into 2D-Vector of Other Language -int GetKeyvalsFromKeymap(GdkKeymap *keymap, guint keycode, int shift_state_pos); + VK_LBRKT, /* [ 219 VK_OEM_4 */ + VK_RBRKT, /* ] 221 VK_OEM_6 */ + VK_BKSLASH, /* \ 220 VK_OEM_5 */ -// print both sets of characters (US and OtherLanguage) to console and file for comparison -void extract_difference(v_str_3D &All_Vector); + VK_COLON, /* ; 186 VK_OEM_1 */ + VK_QUOTE, /* ' 222 VK_OEM_7 */ -// get mapped key from Other (Other->US) -std::string get_Other_Char_FromUS(std::string in, v_str_3D &All_Vector); -// get mapped key from US->Other (US->Other) -std::string get_US_Char_FromOther(std::string in, v_str_3D &All_Vector); -// get KeyNr from US -std::string getKeyNrOf_USChar(std::string in, v_str_3D &All_Vector); -// get KeyNr from Other -std::string getKeyNrOf_OtherChar(std::string in, v_str_3D &All_Vector); + VK_COMMA, /* , 188 VK_OEM_COMMA */ + VK_PERIOD, /* . 190 VK_OEM_PERIOD */ + VK_SLASH, /* / 191 VK_OEM_2 */ -// for testing/debugging - may be deleted later -// prints out a 1:1 mapping US->Other -void print_simple_map_US(v_str_3D &All_Vector, int shiftstate); -// prints out a 1:1 mapping Other->US -void print_simple_map_Other(v_str_3D &All_Vector, int shiftstate); -// test of above functions (character mapping US <-> Other; KeyNr <-> CHaracter) -void test_in_out(v_str_3D &All_Vector); -// testing of Vector contents ( first row of US and Other) -bool test(v_str_3D &V); -// writing out mapping of some characters: a,b,m,w,x,y,z -void test_specific_Characters(v_str_3D &All_Vector); + VK_xDF, /* ß (?) 223*/ + VK_OEM_102, /* < > | 226 */ + 0}; + +typedef std::vector vec_string_1D; +typedef std::vector vec_dword_1D; +typedef std::vector > vec_dword_2D; +typedef std::vector > > vec_dword_3D; + +static KMX_DWORD INVALID_NAME = 0; +static gint keycode_max = 94; +static KMX_DWORD deadkey_min = 0xfe50; // X11's keysymdef.h defines deadkeys between 0xfe50-0xfe93 +static KMX_DWORD deadkey_max = 0xfe93; // https://fossies.org/linux/tk/xlib/X11/keysymdef.h + +/** @brief check if current machine uses little endian + * @return true if little endian is used; + * else false */ +inline bool isLittleEndianSystem() { + char16_t test = 0x0102; + return (reinterpret_cast(&test))[0] == 0x02; +} + +/** @brief map a shiftstate used on windows to a shiftstate suitable for gdk_keymap_translate_keyboard_state() on Linux */ +int convert_Shiftstate_to_LinuxShiftstate(int shiftState); + +/** @brief map a shiftstate used for rgkey to a shiftstate suitable for gdk_keymap_translate_keyboard_state() on Linux */ +int convert_rgkey_Shiftstate_to_LinuxShiftstate(ShiftState shiftState); + +/** @brief check for correct input parameter that will later be used in gdk_keymap_translate_keyboard_state() */ +bool ensureValidInputForKeyboardTranslation(int shiftstate, gint keycode); + +/** @brief convert names of keys stated in a symbol file to a keyvalue */ +KMX_DWORD convertNamesTo_DWORD_Value(std::string tok_str); + +/** @brief create a 3D-Vector containing data of the US keyboard and the currently used (underlying) keyboard */ +int createOneVectorFromBothKeyboards(vec_dword_3D& all_vector, GdkKeymap* keymap); + +/** @brief write data of the US keyboard into a 3D-Vector which later will contain data of the US keyboard and the currently used (underlying) keyboard */ +int write_US_ToVector(vec_dword_3D& vec_us); + +/** @brief create a 1D-Vector containing all relevant entries of the symbol file us basic */ +bool createCompleteVector_US(vec_string_1D& complete_List); + +/** @brief convert the key name obtained from symbol file to the matching keycode */ +int get_keycode_from_keyname(std::string key_name); + +/** @brief process each element of a 1D-Vector, split and write to a 3D-Vector */ +int split_US_To_3D_Vector(vec_dword_3D& all_US, vec_string_1D completeList); + +/** @brief create an 2D-Vector with all fields containing INVALID_NAME */ +vec_dword_2D create_empty_2D_Vector(int dim_rows, int dim_ss); + +/** @brief append a 2D-vector containing data of the currently used (underlying) keyboard to the 3D-vector */ +int append_underlying_ToVector(vec_dword_3D& all_vector, GdkKeymap* keymap); + +/** @brief create a pointer to pointer of the current keymap for later use */ +bool InitializeGDK(GdkKeymap** keymap, int argc, gchar* argv[]); + +const KMX_DWORD USVirtualKeyToScanCode[256] = { + 0x00, // L"K_?00", // &H0 + 0x00, // L"K_LBUTTON", // &H1 + 0x00, // L"K_RBUTTON", // &H2 + 0x46, // L"K_CANCEL", // &H3 + 0x00, // L"K_MBUTTON", // &H4 + 0x00, // L"K_?05", // &H5 + 0x00, // L"K_?06", // &H6 + 0x00, // L"K_?07", // &H7 + 0x0E, // L"K_BKSP", // &H8 + 0x0F, // L"K_TAB", // &H9 + 0x00, // L"K_?0A", // &HA + 0x00, // L"K_?0B", // &HB + 0x4C, // L"K_KP5", // &HC + 0x1C, // L"K_ENTER", // &HD + 0x00, // L"K_?0E", // &HE + 0x00, // L"K_?0F", // &HF + 0x2A, // L"K_SHIFT", // &H10 + 0x1D, // L"K_CONTROL", // &H11 + 0x38, // L"K_ALT", // &H12 + 0x00, // L"K_PAUSE", // &H13 + 0x3A, // L"K_CAPS", // &H14 + 0x00, // L"K_KANJI?15", // &H15 + 0x00, // L"K_KANJI?16", // &H16 + 0x00, // L"K_KANJI?17", // &H17 + 0x00, // L"K_KANJI?18", // &H18 + 0x00, // L"K_KANJI?19", // &H19 + 0x00, // L"K_?1A", // &H1A + 0x01, // L"K_ESC", // &H1B + 0x00, // L"K_KANJI?1C", // &H1C + 0x00, // L"K_KANJI?1D", // &H1D + 0x00, // L"K_KANJI?1E", // &H1E + 0x00, // L"K_KANJI?1F", // &H1F + 0x39, // L"K_SPACE", // &H20 + 0x49, // L"K_PGUP", // &H21 + 0x51, // L"K_PGDN", // &H22 + 0x4F, // L"K_END", // &H23 + 0x47, // L"K_HOME", // &H24 + 0x4B, // L"K_LEFT", // &H25 + 0x48, // L"K_UP", // &H26 + 0x4D, // L"K_RIGHT", // &H27 + 0x50, // L"K_DOWN", // &H28 + 0x00, // L"K_SEL", // &H29 + 0x00, // L"K_PRINT", // &H2A + 0x00, // L"K_EXEC", // &H2B + 0x54, // L"K_PRTSCN", // &H2C + 0x52, // L"K_INS", // &H2D + 0x53, // L"K_DEL", // &H2E + 0x63, // L"K_HELP", // &H2F + 0x0B, // L"K_0", // &H30 + 0x02, // L"K_1", // &H31 + 0x03, // L"K_2", // &H32 + 0x04, // L"K_3", // &H33 + 0x05, // L"K_4", // &H34 + 0x06, // L"K_5", // &H35 + 0x07, // L"K_6", // &H36 + 0x08, // L"K_7", // &H37 + 0x09, // L"K_8", // &H38 + 0x0A, // L"K_9", // &H39 + 0x00, // L"K_?3A", // &H3A + 0x00, // L"K_?3B", // &H3B + 0x00, // L"K_?3C", // &H3C + 0x00, // L"K_?3D", // &H3D + 0x00, // L"K_?3E", // &H3E + 0x00, // L"K_?3F", // &H3F + 0x00, // L"K_?40", // &H40 + 0x1E, // L"K_A", // &H41 + 0x30, // L"K_B", // &H42 + 0x2E, // L"K_C", // &H43 + 0x20, // L"K_D", // &H44 + 0x12, // L"K_E", // &H45 + 0x21, // L"K_F", // &H46 + 0x22, // L"K_G", // &H47 + 0x23, // L"K_H", // &H48 + 0x17, // L"K_I", // &H49 + 0x24, // L"K_J", // &H4A + 0x25, // L"K_K", // &H4B + 0x26, // L"K_L", // &H4C + 0x32, // L"K_M", // &H4D + 0x31, // L"K_N", // &H4E + 0x18, // L"K_O", // &H4F + 0x19, // L"K_P", // &H50 + 0x10, // L"K_Q", // &H51 + 0x13, // L"K_R", // &H52 + 0x1F, // L"K_S", // &H53 + 0x14, // L"K_T", // &H54 + 0x16, // L"K_U", // &H55 + 0x2F, // L"K_V", // &H56 + 0x11, // L"K_W", // &H57 + 0x2D, // L"K_X", // &H58 + 0x15, // L"K_Y", // &H59 + 0x2C, // L"K_Z", // &H5A + 0x5B, // L"K_?5B", // &H5B + 0x5C, // L"K_?5C", // &H5C + 0x5D, // L"K_?5D", // &H5D + 0x00, // L"K_?5E", // &H5E + 0x5F, // L"K_?5F", // &H5F + 0x52, // L"K_NP0", // &H60 + 0x4F, // L"K_NP1", // &H61 + 0x50, // L"K_NP2", // &H62 + 0x51, // L"K_NP3", // &H63 + 0x4B, // L"K_NP4", // &H64 + 0x4C, // L"K_NP5", // &H65 + 0x4D, // L"K_NP6", // &H66 + 0x47, // L"K_NP7", // &H67 + 0x48, // L"K_NP8", // &H68 + 0x49, // L"K_NP9", // &H69 + 0x37, // L"K_NPSTAR", // &H6A + 0x4E, // L"K_NPPLUS", // &H6B + 0x7E, // L"K_SEPARATOR", // &H6C // MCD 01-11-02: Brazilian Fix, 00 -> 7E + 0x4A, // L"K_NPMINUS", // &H6D + 0x53, // L"K_NPDOT", // &H6E + 0x135, // L"K_NPSLASH", // &H6F + 0x3B, // L"K_F1", // &H70 + 0x3C, // L"K_F2", // &H71 + 0x3D, // L"K_F3", // &H72 + 0x3E, // L"K_F4", // &H73 + 0x3F, // L"K_F5", // &H74 + 0x40, // L"K_F6", // &H75 + 0x41, // L"K_F7", // &H76 + 0x42, // L"K_F8", // &H77 + 0x43, // L"K_F9", // &H78 + 0x44, // L"K_F10", // &H79 + 0x57, // L"K_F11", // &H7A + 0x58, // L"K_F12", // &H7B + 0x64, // L"K_F13", // &H7C + 0x65, // L"K_F14", // &H7D + 0x66, // L"K_F15", // &H7E + 0x67, // L"K_F16", // &H7F + 0x68, // L"K_F17", // &H80 + 0x69, // L"K_F18", // &H81 + 0x6A, // L"K_F19", // &H82 + 0x6B, // L"K_F20", // &H83 + 0x6C, // L"K_F21", // &H84 + 0x6D, // L"K_F22", // &H85 + 0x6E, // L"K_F23", // &H86 + 0x76, // L"K_F24", // &H87 + + 0x00, // L"K_?88", // &H88 + 0x00, // L"K_?89", // &H89 + 0x00, // L"K_?8A", // &H8A + 0x00, // L"K_?8B", // &H8B + 0x00, // L"K_?8C", // &H8C + 0x00, // L"K_?8D", // &H8D + 0x00, // L"K_?8E", // &H8E + 0x00, // L"K_?8F", // &H8F + + 0x45, // L"K_NUMLOCK", // &H90 + 0x46, // L"K_SCROL", // &H91 + + 0x00, // L"K_?92", // &H92 + 0x00, // L"K_?93", // &H93 + 0x00, // L"K_?94", // &H94 + 0x00, // L"K_?95", // &H95 + 0x00, // L"K_?96", // &H96 + 0x00, // L"K_?97", // &H97 + 0x00, // L"K_?98", // &H98 + 0x00, // L"K_?99", // &H99 + 0x00, // L"K_?9A", // &H9A + 0x00, // L"K_?9B", // &H9B + 0x00, // L"K_?9C", // &H9C + 0x00, // L"K_?9D", // &H9D + 0x00, // L"K_?9E", // &H9E + 0x00, // L"K_?9F", // &H9F + 0x2A, // L"K_?A0", // &HA0 + 0x36, // L"K_?A1", // &HA1 + 0x1D, // L"K_?A2", // &HA2 + 0x1D, // L"K_?A3", // &HA3 + 0x38, // L"K_?A4", // &HA4 + 0x38, // L"K_?A5", // &HA5 + 0x6A, // L"K_?A6", // &HA6 + 0x69, // L"K_?A7", // &HA7 + 0x67, // L"K_?A8", // &HA8 + 0x68, // L"K_?A9", // &HA9 + 0x65, // L"K_?AA", // &HAA + 0x66, // L"K_?AB", // &HAB + 0x32, // L"K_?AC", // &HAC + 0x20, // L"K_?AD", // &HAD + 0x2E, // L"K_?AE", // &HAE + 0x30, // L"K_?AF", // &HAF + 0x19, // L"K_?B0", // &HB0 + 0x10, // L"K_?B1", // &HB1 + 0x24, // L"K_?B2", // &HB2 + 0x22, // L"K_?B3", // &HB3 + 0x6C, // L"K_?B4", // &HB4 + 0x6D, // L"K_?B5", // &HB5 + 0x6B, // L"K_?B6", // &HB6 + 0x21, // L"K_?B7", // &HB7 + 0x00, // L"K_?B8", // &HB8 + 0x00, // L"K_?B9", // &HB9 + 0x27, // L"K_COLON", // &HBA + 0x0D, // L"K_EQUAL", // &HBB + 0x33, // L"K_COMMA", // &HBC + 0x0C, // L"K_HYPHEN", // &HBD + 0x34, // L"K_PERIOD", // &HBE + 0x35, // L"K_SLASH", // &HBF + 0x29, // L"K_BKQUOTE", // &HC0 + + 0x73, // L"K_?C1", // &HC1 + 0x7E, // L"K_?C2", // &HC2 + 0x00, // L"K_?C3", // &HC3 + 0x00, // L"K_?C4", // &HC4 + 0x00, // L"K_?C5", // &HC5 + 0x00, // L"K_?C6", // &HC6 + 0x00, // L"K_?C7", // &HC7 + 0x00, // L"K_?C8", // &HC8 + 0x00, // L"K_?C9", // &HC9 + 0x00, // L"K_?CA", // &HCA + 0x00, // L"K_?CB", // &HCB + 0x00, // L"K_?CC", // &HCC + 0x00, // L"K_?CD", // &HCD + 0x00, // L"K_?CE", // &HCE + 0x00, // L"K_?CF", // &HCF + 0x00, // L"K_?D0", // &HD0 + 0x00, // L"K_?D1", // &HD1 + 0x00, // L"K_?D2", // &HD2 + 0x00, // L"K_?D3", // &HD3 + 0x00, // L"K_?D4", // &HD4 + 0x00, // L"K_?D5", // &HD5 + 0x00, // L"K_?D6", // &HD6 + 0x00, // L"K_?D7", // &HD7 + 0x00, // L"K_?D8", // &HD8 + 0x00, // L"K_?D9", // &HD9 + 0x00, // L"K_?DA", // &HDA + 0x1A, // L"K_LBRKT", // &HDB + 0x2B, // L"K_BKSLASH", // &HDC + 0x1B, // L"K_RBRKT", // &HDD + 0x28, // L"K_QUOTE", // &HDE + 0x73, // L"K_oDF", // &HDF // MCD 01-11-02: Brazilian fix: 00 -> 73 + 0x00, // L"K_oE0", // &HE0 + 0x00, // L"K_oE1", // &HE1 + 0x56, // L"K_oE2", // &HE2 + 0x00, // L"K_oE3", // &HE3 + 0x00, // L"K_oE4", // &HE4 + + 0x00, // L"K_?E5", // &HE5 + + 0x00, // L"K_oE6", // &HE6 + + 0x00, // L"K_?E7", // &HE7 + 0x00, // L"K_?E8", // &HE8 + + 0x71, // L"K_oE9", // &HE9 + 0x5C, // L"K_oEA", // &HEA + 0x7B, // L"K_oEB", // &HEB + 0x00, // L"K_oEC", // &HEC + 0x6F, // L"K_oED", // &HED + 0x5A, // L"K_oEE", // &HEE + 0x00, // L"K_oEF", // &HEF + 0x00, // L"K_oF0", // &HF0 + 0x5B, // L"K_oF1", // &HF1 + 0x00, // L"K_oF2", // &HF2 + 0x5F, // L"K_oF3", // &HF3 + 0x00, // L"K_oF4", // &HF4 + 0x5E, // L"K_oF5", // &HF5 + + 0x00, // L"K_?F6", // &HF6 + 0x00, // L"K_?F7", // &HF7 + 0x00, // L"K_?F8", // &HF8 + 0x5D, // L"K_?F9", // &HF9 + 0x00, // L"K_?FA", // &HFA + 0x62, // L"K_?FB", // &HFB + 0x00, // L"K_?FC", // &HFC + 0x00, // L"K_?FD", // &HFD + 0x00, // L"K_?FE", // &HFE + 0x00 // L"K_?FF" // &HFF +}; + +const KMX_DWORD ScanCodeToUSVirtualKey[128] = { + 0x01, // 0x00 => K_LBUTTON + 0x1b, // 0x01 => K_ESC + 0x31, // 0x02 => K_1 + 0x32, // 0x03 => K_2 + 0x33, // 0x04 => K_3 + 0x34, // 0x05 => K_4 + 0x35, // 0x06 => K_5 + 0x36, // 0x07 => K_6 + 0x37, // 0x08 => K_7 + 0x38, // 0x09 => K_8 + 0x39, // 0x0a => K_9 + 0x30, // 0x0b => K_0 + 0xbd, // 0x0c => K_HYPHEN + 0xbb, // 0x0d => K_EQUAL + 0x08, // 0x0e => K_BKSP + 0x09, // 0x0f => K_TAB + 0x51, // 0x10 => K_Q + 0x57, // 0x11 => K_W + 0x45, // 0x12 => K_E + 0x52, // 0x13 => K_R + 0x54, // 0x14 => K_T + 0x59, // 0x15 => K_Y + 0x55, // 0x16 => K_U + 0x49, // 0x17 => K_I + 0x4f, // 0x18 => K_O + 0x50, // 0x19 => K_P + 0xdb, // 0x1a => K_LBRKT + 0xdd, // 0x1b => K_RBRKT + 0x0d, // 0x1c => K_ENTER + 0x11, // 0x1d => K_CONTROL + 0x41, // 0x1e => K_A + 0x53, // 0x1f => K_S + 0x44, // 0x20 => K_D + 0x46, // 0x21 => K_F + 0x47, // 0x22 => K_G + 0x48, // 0x23 => K_H + 0x4a, // 0x24 => K_J + 0x4b, // 0x25 => K_K + 0x4c, // 0x26 => K_L + 0xba, // 0x27 => K_COLON + 0xde, // 0x28 => K_QUOTE + 0xc0, // 0x29 => K_BKQUOTE + 0x10, // 0x2a => K_SHIFT + 0xdc, // 0x2b => K_BKSLASH + 0x5a, // 0x2c => K_Z + 0x58, // 0x2d => K_X + 0x43, // 0x2e => K_C + 0x56, // 0x2f => K_V + 0x42, // 0x30 => K_B + 0x4e, // 0x31 => K_N + 0x4d, // 0x32 => K_M + 0xbc, // 0x33 => K_COMMA + 0xbe, // 0x34 => K_PERIOD + 0xbf, // 0x35 => K_SLASH + 0xa1, // 0x36 => K_?A1 + 0x6a, // 0x37 => K_NPSTAR + 0x12, // 0x38 => K_ALT + 0x20, // 0x39 => K_SPACE + 0x14, // 0x3a => K_CAPS + 0x70, // 0x3b => K_F1 + 0x71, // 0x3c => K_F2 + 0x72, // 0x3d => K_F3 + 0x73, // 0x3e => K_F4 + 0x74, // 0x3f => K_F5 + 0x75, // 0x40 => K_F6 + 0x76, // 0x41 => K_F7 + 0x77, // 0x42 => K_F8 + 0x78, // 0x43 => K_F9 + 0x79, // 0x44 => K_F10 + 0x90, // 0x45 => K_NUMLOCK + 0x03, // 0x46 => K_CANCEL + 0x24, // 0x47 => K_HOME + 0x26, // 0x48 => K_UP + 0x21, // 0x49 => K_PGUP + 0x6d, // 0x4a => K_NPMINUS + 0x25, // 0x4b => K_LEFT + 0x0c, // 0x4c => K_KP5 + 0x27, // 0x4d => K_RIGHT + 0x6b, // 0x4e => K_NPPLUS + 0x23, // 0x4f => K_END + 0x28, // 0x50 => K_DOWN + 0x22, // 0x51 => K_PGDN + 0x2d, // 0x52 => K_INS + 0x2e, // 0x53 => K_DEL + 0x2c, // 0x54 => K_PRTSCN + 0x00, // 0x55 => No match + 0xe2, // 0x56 => K_oE2 + 0x7a, // 0x57 => K_F11 + 0x7b, // 0x58 => K_F12 + 0x00, // 0x59 => No match + 0xee, // 0x5a => K_oEE + 0x5b, // 0x5b => K_?5B + 0x5c, // 0x5c => K_?5C + 0x5d, // 0x5d => K_?5D + 0xf5, // 0x5e => K_oF5 + 0x5f, // 0x5f => K_?5F + 0x00, // 0x60 => No match + 0x00, // 0x61 => No match + 0xfb, // 0x62 => K_?FB + 0x2f, // 0x63 => K_HELP + 0x7c, // 0x64 => K_F13 + 0x7d, // 0x65 => K_F14 + 0x7e, // 0x66 => K_F15 + 0x7f, // 0x67 => K_F16 + 0x80, // 0x68 => K_F17 + 0x81, // 0x69 => K_F18 + 0x82, // 0x6a => K_F19 + 0x83, // 0x6b => K_F20 + 0x84, // 0x6c => K_F21 + 0x85, // 0x6d => K_F22 + 0x86, // 0x6e => K_F23 + 0xed, // 0x6f => K_oED + 0x00, // 0x70 => No match + 0xe9, // 0x71 => K_oE9 + 0x00, // 0x72 => No match + 0xc1, // 0x73 => K_?C1 + 0x00, // 0x74 => No match + 0x00, // 0x75 => No match + 0x87, // 0x76 => K_F24 + 0x00, // 0x77 => No match + 0x00, // 0x78 => No match + 0x00, // 0x79 => No match + 0x00, // 0x7a => No match + 0xeb, // 0x7b => K_oEB + 0x00, // 0x7c => No match + 0x00, // 0x7d => No match + 0x6c, // 0x7e => K_SEPARATOR + 0x00 // 0x7f => No match +}; + +/** @brief check if keyval correponds to a character used in mcompile */ +bool IsKeymanUsedChar(int kv); + +/** @brief convert a deadkey-value to a u16string if it is in the range of deadkeys used for mcompile */ +std::u16string convert_DeadkeyValues_To_U16str(KMX_DWORD in); + +/** @brief return the keyvalue for a given Keycode, shiftstate and caps of the currently used (underlying) keyboard layout. */ +KMX_DWORD KMX_get_KeyVal_From_KeyCode(GdkKeymap* keymap, guint keycode, ShiftState ss, int caps); + +/** @brief return the keyvalue for a given Keycode and shiftstate of the currently used (underlying) keyboard layout. */ +KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap* keymap, guint keycode, int shiftState); + +/** @brief return the keyvalue for a given Keycode and shiftstate of the currently used (underlying) keyboard layout. */ +KMX_DWORD KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(GdkKeymap* keymap, guint keycode, KMX_DWORD shiftState, PKMX_WCHAR deadkey); + +/** @brief return the keyvalue of a key of the the currently used (underlying) keyboard for a given keyvalue of the US keyboard */ +KMX_DWORD KMX_get_KeyValUnderlying_From_KeyValUS(vec_dword_3D& all_vector, KMX_DWORD kv_us); + +/** @brief return the keycode of the currently used (underlying) keyboard for a given keycode of the US keyboard */ +KMX_DWORD KMX_get_KeyCodeUnderlying_From_KeyCodeUS(GdkKeymap* keymap, vec_dword_3D& all_vector, KMX_DWORD kc_us, ShiftState ss, int caps); + +/** @brief return the keycode of the currently used (underlying) keyboard for a given virtual key of the US keyboard */ +KMX_DWORD KMX_get_KeyCodeUnderlying_From_VKUS(KMX_DWORD virtualKeyUS); + +/** @brief return a virtual key of the US keyboard for a given keycode of the currently used (underlying) keyboard */ +KMX_DWORD KMX_get_VKUS_From_KeyCodeUnderlying(KMX_DWORD keycode); + +/** @brief convert a codepoint to a u16string */ +std::u16string CodePointToU16String(unsigned int codepoint); + +#endif /*KEYMAP_H*/ diff --git a/linux/mcompile/keymap/km_types.h b/linux/mcompile/keymap/km_types.h deleted file mode 100644 index 5e6c25e8136..00000000000 --- a/linux/mcompile/keymap/km_types.h +++ /dev/null @@ -1,88 +0,0 @@ -#pragma once -#include - -#include - -/* -#if defined(_WIN32) || defined(_WIN64) -#define snprintf _snprintf -#define vsnprintf _vsnprintf -#define strcasecmp _stricmp -#define strncasecmp _strnicmp -#endif -*/ - -#if defined(__LP64__) || defined(_LP64) -/* 64-bit, g++ */ -#define KMX_64BIT -#endif - -#if defined(_WIN64) && !defined(USE_64) -/* 64-bit, Windows */ -#define KMX_64BIT -#endif - -typedef uint32_t KMX_DWORD; -typedef int32_t KMX_BOOL; -typedef uint8_t KMX_BYTE; -typedef uint16_t KMX_WORD; - -#if defined(__cplusplus) -typedef char16_t km_kbp_cp; -typedef char32_t km_kbp_usv; -#else -typedef uint16_t km_kbp_cp; // code point -typedef uint32_t km_kbp_usv; // Unicode Scalar Value -#endif - -typedef km_kbp_cp KMX_WCHAR; // wc, 16-bit UNICODE character - -typedef wchar_t WCHAR; // _S2 needs to be removed/ wchart-> char16 -typedef WCHAR KMX_WCHART; // _S2 needs to be removed/ wchart-> char16 -typedef KMX_WCHAR* PKMX_WCHAR; // _S2 -typedef wchar_t* PWSTR; // _S2 needs to be removed/ wchart-> char16 -typedef PWSTR PKMX_WCHART; // _S2 needs to be removed/ wchart-> char16 - -typedef wchar_t* LPKMX_WCHART; // _S2 needs to be removed/ wchart-> char16 - -typedef char* LPSTR; // _S2 needs to be removed? -typedef LPSTR LPKMX_STR; // _S2 needs to be removed? - -typedef uint8_t* LPBYTE; // _S2 needs to be removed/? -typedef LPBYTE LPKMX_BYTE; // _S2 needs to be removed? - -typedef uint8_t* PBYTE; // _S2 needs to be removed/? -typedef PBYTE PKMX_BYTE; // _S2 needs to be removed? - - // _S2 LPKEYBOARD ok to leave as is?? - -typedef char KMX_CHAR; // _S2 needs to be removed/? -typedef char* PKMX_STR; // _S2 needs to be removed/? - -typedef KMX_CHAR* PKMX_CHAR; // _S2 needs to be removed/? - -typedef uint32_t KMX_UINT; - -typedef KMX_BYTE* PKMX_BYTE; -typedef KMX_WORD* PKMX_WORD; -typedef KMX_DWORD* PKMX_DWORD; - -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - -// Macros and types to support char16_t vs wchar_t depending on project - -#ifdef USE_CHAR16_T -#define lpuch(x) u ## x -typedef km_kbp_cp KMX_UCHAR; -#else -#define lpuch(x) L ## x -typedef wchar_t KMX_UCHAR; -#endif - -typedef KMX_UCHAR* KMX_PUCHAR; diff --git a/linux/mcompile/keymap/kmx_file.h b/linux/mcompile/keymap/kmx_file.h deleted file mode 100644 index 998c9780072..00000000000 --- a/linux/mcompile/keymap/kmx_file.h +++ /dev/null @@ -1,384 +0,0 @@ -/* - Copyright: Copyright (C) 2003-2018 SIL International. - Authors: mcdurdin -*/ - -#pragma once - -#include - -#ifdef KMN_KBP -// TODO: move this to a common namespace keyman::common::kmx_file or similar in the future -namespace km { -namespace kbp { -namespace kmx { -#endif - -#define KMX_MAX_ALLOWED_FILE_SIZE (128 * 1024 * 1024) /* 128MB */ -/* */ - -#define KEYMAN_LAYOUT_DEFAULT 0x000005FE - -#define KEYMANID_NONKEYMAN 0xFFFFFFFF -#define KEYMANID_IGNORE 0xFFFFFFFE -#define KEYMANID_INVALID 0xFFFFFFFD - -/* Shift flags for hotkeys (version 1.0) */ - -#define SHIFTFLAG 0x2000 -#define CTRLFLAG 0x4000 -#define ALTFLAG 0x8000 - -/* Miscellaneous flags and defines */ - -#define MAXGROUPS 128 - -/* File version identifiers */ - -#define VERSION_30 0x00000300 -#define VERSION_31 0x00000301 -#define VERSION_32 0x00000302 -#define VERSION_40 0x00000400 -#define VERSION_50 0x00000500 -#define VERSION_501 0x00000501 -#define VERSION_60 0x00000600 -#define VERSION_70 0x00000700 -#define VERSION_80 0x00000800 -#define VERSION_90 0x00000900 -#define VERSION_100 0x00000A00 -#define VERSION_140 0x00000E00 -#define VERSION_150 0x00000F00 - -#define VERSION_160 0x00001000 - -#define VERSION_MIN VERSION_50 -#define VERSION_MAX VERSION_160 - -// -// Backspace types -// - -#define BK_DEFAULT 0 -#define BK_DEADKEY 1 - -// Different begin types -#define BEGIN_ANSI 0 -#define BEGIN_UNICODE 1 -#define BEGIN_NEWCONTEXT 2 -#define BEGIN_POSTKEYSTROKE 3 - -#define TSS_NONE 0 -#define TSS_BITMAP 1 -#define TSS_COPYRIGHT 2 -#define TSS_HOTKEY 3 -#define TSS_LANGUAGE 4 -#define TSS_LAYOUT 5 -#define TSS_MESSAGE 6 -#define TSS_NAME 7 -#define TSS_VERSION 8 -#define TSS_CAPSONONLY 9 -#define TSS_CAPSALWAYSOFF 10 -#define TSS_SHIFTFREESCAPS 11 -#define TSS_LANGUAGENAME 12 - -#define TSS_CALLDEFINITION 13 -#define TSS_CALLDEFINITION_LOADFAILED 14 - -#define TSS_ETHNOLOGUECODE 15 - -#define TSS_DEBUG_LINE 16 - -#define TSS_MNEMONIC 17 - -#define TSS_INCLUDECODES 18 - -#define TSS_OLDCHARPOSMATCHING 19 - -#define TSS_COMPILEDVERSION 20 -#define TSS_KEYMANCOPYRIGHT 21 - -#define TSS_CUSTOMKEYMANEDITION 22 -#define TSS_CUSTOMKEYMANEDITIONNAME 23 - -/* Keyman 7.0 system stores */ - -#define TSS__KEYMAN_60_MAX 23 - -#define TSS_VISUALKEYBOARD 24 -#define TSS_KMW_RTL 25 -#define TSS_KMW_HELPFILE 26 -#define TSS_KMW_HELPTEXT 27 -#define TSS_KMW_EMBEDJS 28 - -#define TSS_WINDOWSLANGUAGES 29 - -#define TSS__KEYMAN_70_MAX 29 - -/* Keyman 8.0 system stores */ - -#define TSS_COMPARISON 30 - -#define TSS__KEYMAN_80_MAX 30 - -/* Keyman 9.0 system stores */ - -#define TSS_PLATFORM 31 -#define TSS_BASELAYOUT 32 -#define TSS_LAYER 33 - -#define TSS_PLATFORM_NOMATCH 0x8001 // Reserved for internal use - after platform statement is run, set to either TSS_PLATFORM_NOMATCH or TSS_PLATFORM_MATCH -#define TSS_PLATFORM_MATCH 0x8002 // Reserved for internal use - as the result will never change for the lifetime of the process. - -#define TSS_VKDICTIONARY 34 // Dictionary of virtual key names for v9 dynamic layouts -#define TSS_LAYOUTFILE 35 // Keyman 9 layer-based JSON OSK -#define TSS_KEYBOARDVERSION 36 // &keyboardversion system store // I4140 -#define TSS_KMW_EMBEDCSS 37 - -#define TSS_TARGETS 38 - -#define TSS__KEYMAN_90_MAX 38 - -/* Keyman 14.0 system stores */ - -#define TSS_CASEDKEYS 39 - -#define TSS__KEYMAN_140_MAX 39 - -/* Keyman 15.0 system stores */ - -#define TSS_BEGIN_NEWCONTEXT 40 -#define TSS_BEGIN_POSTKEYSTROKE 41 -#define TSS_NEWLAYER 42 -#define TSS_OLDLAYER 43 - -#define TSS__KEYMAN_150_MAX 43 - -#define TSS__MAX 43 - -/* wm_keyman_control_internal message control codes */ - -#define KMCI_SELECTKEYBOARD 3 // I3933 -#define KMCI_SELECTKEYBOARD_TSF 4 // I3933 -#define KMCI_GETACTIVEKEYBOARD 5 // I3933 -#define KMCI_SETFOREGROUND 6 // I3933 -#define KMCI_SELECTKEYBOARD_BACKGROUND 7 // I4271 -#define KMCI_SELECTKEYBOARD_BACKGROUND_TSF 8 // I4271 - -#define FILEID_COMPILED 0x5354584B - -#define SZMAX_LANGUAGENAME 80 -#define SZMAX_KEYBOARDNAME 80 -#define SZMAX_COPYRIGHT 256 -#define SZMAX_MESSAGE 1024 - -#define UC_SENTINEL 0xFFFF -#define UC_SENTINEL_EXTENDEDEND 0x10 // was ((CODE_LASTCODE)+1)... what was I thinking? - -#define U_UC_SENTINEL u"\uFFFF" - -/* - * VK__MAX defines the highest virtual key code defined in the system = 0xFF. Custom VK codes start at 256 - */ -#define VK__MAX 255 - -#define CODE_ANY 0x01 -#define CODE_INDEX 0x02 -#define CODE_CONTEXT 0x03 -#define CODE_NUL 0x04 -#define CODE_USE 0x05 -#define CODE_RETURN 0x06 -#define CODE_BEEP 0x07 -#define CODE_DEADKEY 0x08 -// 0x09 = bkspace.-- we don't need to keep this separate though with UC_SENTINEL -#define CODE_EXTENDED 0x0A -//#define CODE_EXTENDEDEND 0x0B deprecated -#define CODE_SWITCH 0x0C -#define CODE_KEY 0x0D -#define CODE_CLEARCONTEXT 0x0E -#define CODE_CALL 0x0F -// UC_SENTINEL_EXTENDEDEND 0x10 -#define CODE_CONTEXTEX 0x11 - -#define CODE_NOTANY 0x12 - -#define CODE_KEYMAN70_LASTCODE 0x12 - -#define CODE_SETOPT 0x13 -#define CODE_IFOPT 0x14 -#define CODE_SAVEOPT 0x15 -#define CODE_RESETOPT 0x16 - -#define CODE_KEYMAN80_LASTCODE 0x16 - -/* Keyman 9.0 codes */ - -#define CODE_IFSYSTEMSTORE 0x17 -#define CODE_SETSYSTEMSTORE 0x18 - -#define CODE_LASTCODE 0x18 - -#define U_CODE_ANY u"\u0001" -#define U_CODE_INDEX u"\u0002" -#define U_CODE_CONTEXT u"\u0003" -#define U_CODE_NUL u"\u0004" -#define U_CODE_USE u"\u0005" -#define U_CODE_RETURN u"\u0006" -#define U_CODE_BEEP u"\u0007" -#define U_CODE_DEADKEY u"\u0008" -#define U_CODE_EXTENDED u"\u000A" -#define U_CODE_SWITCH u"\u000C" -#define U_CODE_CLEARCONTEXT u"\u000E" -#define U_CODE_CALL u"\u000F" -#define U_CODE_EXTENDEDEND u"\u0010" -#define U_CODE_CONTEXTEX u"\u0011" -#define U_CODE_NOTANY u"\u0012" -#define U_CODE_SETOPT u"\u0013" -#define U_CODE_IFOPT u"\u0014" -#define U_CODE_SAVEOPT u"\u0015" -#define U_CODE_RESETOPT u"\u0016" -#define U_CODE_IFSYSTEMSTORE u"\u0017" -#define U_CODE_SETSYSTEMSTORE u"\u0018" - -#define C_CODE_ANY(store) U_UC_SENTINEL U_CODE_ANY store -#define C_CODE_INDEX(val1, val2) U_UC_SENTINEL U_CODE_INDEX val1 val2 -#define C_CODE_CONTEXT() U_UC_SENTINEL U_CODE_CONTEXT -#define C_CODE_NUL() U_UC_SENTINEL U_CODE_NUL -#define C_CODE_USE(val) U_UC_SENTINEL U_CODE_USE val -#define C_CODE_RETURN() U_UC_SENTINEL U_CODE_RETURN -#define C_CODE_BEEP() U_UC_SENTINEL U_CODE_BEEP -#define C_CODE_DEADKEY(deadkey) U_UC_SENTINEL U_CODE_DEADKEY deadkey -#define C_CODE_EXTENDED(varargs) U_UC_SENTINEL U_CODE_EXTENDED varargs -#define C_CODE_SWITCH(val) U_UC_SENTINEL U_CODE_SWITCH val -#define C_CODE_CLEARCONTEXT() U_UC_SENTINEL U_CODE_CLEARCONTEXT -#define C_CODE_CALL(val) U_UC_SENTINEL U_CODE_CALL val -#define C_CODE_CONTEXTEX(val) U_UC_SENTINEL U_CODE_CONTEXTEX val -#define C_CODE_NOTANY(val) U_UC_SENTINEL U_CODE_NOTANY val -#define C_CODE_SETOPT(val1, val2) U_UC_SENTINEL U_CODE_SETOPT val1 val2 -#define C_CODE_IFOPT(opt, val1, val2) U_UC_SENTINEL U_CODE_IFOPT opt val1 val2 -#define C_CODE_SAVEOPT(opt) U_UC_SENTINEL U_CODE_SAVEOPT opt -#define C_CODE_RESETOPT(opt) U_UC_SENTINEL U_CODE_RESETOPT opt -#define C_CODE_IFSYSTEMSTORE(store, val1, val2) U_UC_SENTINEL U_CODE_IFSYSTEMSTORE store val1 val2 -#define C_CODE_SETSYSTEMSTORE(store, val) U_UC_SENTINEL U_CODE_SETSYSTEMSTORE store val - -#define KF_SHIFTFREESCAPS 0x0001 -#define KF_CAPSONONLY 0x0002 -#define KF_CAPSALWAYSOFF 0x0004 -#define KF_LOGICALLAYOUT 0x0008 -#define KF_AUTOMATICVERSION 0x0010 - -// 16.0: Support for LDML Keyboards in KMXPlus file format -#define KF_KMXPLUS 0x0020 - -#define HK_ALT 0x00010000 -#define HK_CTRL 0x00020000 -#define HK_SHIFT 0x00040000 - -#define LCTRLFLAG 0x0001 // Left Control flag -#define RCTRLFLAG 0x0002 // Right Control flag -#define LALTFLAG 0x0004 // Left Alt flag -#define RALTFLAG 0x0008 // Right Alt flag -#define K_SHIFTFLAG 0x0010 // Either shift flag -#define K_CTRLFLAG 0x0020 // Either ctrl flag -#define K_ALTFLAG 0x0040 // Either alt flag -//#define K_METAFLAG 0x0080 // Either Meta-key flag (tentative). Not usable in keyboard rules; - // Used internally (currently, only by KMW) to ensure Meta-key - // shortcuts safely bypass rules - // Meta key = Command key on macOS, Windows key on Windows -#define CAPITALFLAG 0x0100 // Caps lock on -#define NOTCAPITALFLAG 0x0200 // Caps lock NOT on -#define NUMLOCKFLAG 0x0400 // Num lock on -#define NOTNUMLOCKFLAG 0x0800 // Num lock NOT on -#define SCROLLFLAG 0x1000 // Scroll lock on -#define NOTSCROLLFLAG 0x2000 // Scroll lock NOT on -#define ISVIRTUALKEY 0x4000 // It is a Virtual Key Sequence -#define VIRTUALCHARKEY 0x8000 // Keyman 6.0: Virtual Key Cap Sequence NOT YET - -#define K_MODIFIERFLAG 0x007F -#define K_NOTMODIFIERFLAG 0xFF00 // I4548 - -struct COMP_STORE { - KMX_DWORD dwSystemID; - KMX_DWORD dpName; - KMX_DWORD dpString; - }; - -struct COMP_KEY { - KMX_WORD Key; - KMX_WORD _reserved; - KMX_DWORD Line; - KMX_DWORD ShiftFlags; - KMX_DWORD dpOutput; - KMX_DWORD dpContext; - }; - -struct COMP_GROUP { - KMX_DWORD dpName; - KMX_DWORD dpKeyArray; // [LPKEY] address of first item in key array - KMX_DWORD dpMatch; - KMX_DWORD dpNoMatch; - KMX_DWORD cxKeyArray; // in array entries - KMX_BOOL fUsingKeys; // group(xx) [using keys] <-- specified or not - }; - -struct COMP_KEYBOARD { - KMX_DWORD dwIdentifier; // 0000 Keyman compiled keyboard id - - KMX_DWORD dwFileVersion; // 0004 Version of the file - Keyman 4.0 is 0x0400 - - KMX_DWORD dwCheckSum; // 0008 As stored in keyboard. DEPRECATED as of 16.0 - KMX_DWORD KeyboardID; // 000C as stored in HKEY_LOCAL_MACHINE//system//currentcontrolset//control//keyboard layouts - KMX_DWORD IsRegistered; // 0010 - KMX_DWORD version; // 0014 keyboard version - - KMX_DWORD cxStoreArray; // 0018 in array entries - KMX_DWORD cxGroupArray; // 001C in array entries - - KMX_DWORD dpStoreArray; // 0020 [LPSTORE] address of first item in store array - KMX_DWORD dpGroupArray; // 0024 [LPGROUP] address of first item in group array - - KMX_DWORD StartGroup[2]; // 0028 index of starting groups [2 of them] - - KMX_DWORD dwFlags; // 0030 Flags for the keyboard file - - KMX_DWORD dwHotKey; // 0034 standard windows hotkey (hiword=shift/ctrl/alt stuff, loword=vkey) - - KMX_DWORD dpBitmapOffset; // 0038 offset of the bitmaps in the file - KMX_DWORD dwBitmapSize; // 003C size in bytes of the bitmaps -}; - -struct COMP_KEYBOARD_KMXPLUSINFO { - KMX_DWORD dpKMXPlus; // 0040 offset of KMXPlus data, header is first - KMX_DWORD dwKMXPlusSize; // 0044 size in bytes of entire KMXPlus data -}; - -/** - * Only valid if comp_keyboard.dwFlags&KF_KMXPLUS - */ -struct COMP_KEYBOARD_EX { - COMP_KEYBOARD header; // 0000 see COMP_KEYBOARD - COMP_KEYBOARD_KMXPLUSINFO kmxplus; // 0040 see COMP_KEYBOARD_EXTRA -}; - -typedef COMP_KEYBOARD *PCOMP_KEYBOARD; -typedef COMP_STORE *PCOMP_STORE; -typedef COMP_KEY *PCOMP_KEY; -typedef COMP_GROUP *PCOMP_GROUP; - -extern const int CODE__SIZE[]; -#define CODE__SIZE_MAX 5 - -#define KEYBOARDFILEHEADER_SIZE 64 -#define KEYBOARDFILESTORE_SIZE 12 -#define KEYBOARDFILEGROUP_SIZE 24 -#define KEYBOARDFILEKEY_SIZE 20 - -static_assert(sizeof(COMP_STORE) == KEYBOARDFILESTORE_SIZE, "COMP_STORE must be KEYBOARDFILESTORE_SIZE bytes"); -static_assert(sizeof(COMP_KEY) == KEYBOARDFILEKEY_SIZE, "COMP_KEY must be KEYBOARDFILEKEY_SIZE bytes"); -static_assert(sizeof(COMP_GROUP) == KEYBOARDFILEGROUP_SIZE, "COMP_GROUP must be KEYBOARDFILEGROUP_SIZE bytes"); -static_assert(sizeof(COMP_KEYBOARD) == KEYBOARDFILEHEADER_SIZE, "COMP_KEYBOARD must be KEYBOARDFILEHEADER_SIZE bytes"); - -#ifdef KMN_KBP -} // namespace kmx -} // namespace kbp -} // namespace km -#endif diff --git a/linux/mcompile/keymap/main.cpp b/linux/mcompile/keymap/main.cpp deleted file mode 100644 index 2fa3409d871..00000000000 --- a/linux/mcompile/keymap/main.cpp +++ /dev/null @@ -1,47 +0,0 @@ -#include - - -static void PrintKeymapForCode(GdkKeymap *keymap, guint keycode) -{ - GdkKeymapKey *maps; - guint *keyvals; - gint count; - - if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count)) - return; - - for (int i = 0; i < count; i++) { - if (maps[i].level > 0 || maps[i].group > 1) - continue; - printf(" i=%d, keycode=%d, keyval=%d (%c), level=%d, group=%d\n", i, maps[i].keycode, keyvals[i], keyvals[i], maps[i].level, maps[i].group); - } - - g_free(keyvals); - g_free(maps); -} - -int main(gint argc, gchar **argv) -{ - gdk_init(&argc, &argv); - GdkDisplay *display = gdk_display_get_default(); - if (!display) { - printf("ERROR: can't get display\n"); - return 1; - } - GdkKeymap *keymap = gdk_keymap_get_for_display(display); - if (!keymap) { - printf("ERROR: Can't get keymap\n"); - gdk_display_close(display); - return 2; - } - - for (int keycode = 10; keycode <= 61; keycode++) { - printf("-------------------\n"); - printf("Keycode %d:\n", keycode); - PrintKeymapForCode(keymap, keycode); - } - - gdk_display_close(display); - - return 0; -} diff --git a/linux/mcompile/keymap/mc_import_rules.cpp b/linux/mcompile/keymap/mc_import_rules.cpp new file mode 100644 index 00000000000..9c376dafd6a --- /dev/null +++ b/linux/mcompile/keymap/mc_import_rules.cpp @@ -0,0 +1,669 @@ +/* + * Keyman is copyright (C) 2004 - 2024 SIL International. MIT License. + * + * Mnemonic layout support for Linux + */ + + +#include +#include +#include +#include "mc_kmxfile.h" +#include "keymap.h" + +const int KMX_ShiftStateMap[] = { + ISVIRTUALKEY, + ISVIRTUALKEY | K_SHIFTFLAG, + ISVIRTUALKEY | K_CTRLFLAG, + ISVIRTUALKEY | K_SHIFTFLAG | K_CTRLFLAG, + 0, + 0, + ISVIRTUALKEY | RALTFLAG, + ISVIRTUALKEY | RALTFLAG | K_SHIFTFLAG, + 0, + 0}; + +/** + * @brief Constructor + * @param deadCharacter a deadkey +*/ +DeadKey::DeadKey(KMX_WCHAR deadCharacter) { + this->m_deadchar = deadCharacter; +} + +/** + * @brief return dead character + * @return deadkey character +*/ +KMX_WCHAR DeadKey::KMX_DeadCharacter() { + return this->m_deadchar; +} + +/** + * @brief set Deadkey with values + * @param baseCharacter the base character + * @param combinedCharacter the combined character +*/ +void DeadKey::KMX_AddDeadKeyRow(KMX_WCHAR baseCharacter, KMX_WCHAR combinedCharacter) { + this->m_rgbasechar.push_back(baseCharacter); + this->m_rgcombchar.push_back(combinedCharacter); +} + +/** + * @brief check if character exists in DeadKey + * @param baseCharacter a character to be found + * @return true if found; + * false if not found +*/ +bool DeadKey::KMX_ContainsBaseCharacter(KMX_WCHAR baseCharacter) { + std::vector::iterator it; + for (it = this->m_rgbasechar.begin(); it < m_rgbasechar.end(); it++) { + if (*it == baseCharacter) { + return true; + } + } + return false; +} + +/** + * @brief Find a keyvalue for given keycode, shiftstate and caps. A function similar to Window`s ToUnicodeEx() function. + * + * Contrary to what the function name might suggest, the function KMX_ToUnicodeEx does not process surrogate pairs. + * This is because it is used in mcompile only which only deals with latin scripts. + * In case this function should be used for surrogate pairs, they will be ignored and a message will be printed out + * + * @param keycode a key of the currently used keyboard Layout + * @param pwszBuff Buffer to store resulting character + * @param ss a shiftstate of the currently used keyboard Layout + * @param caps state of the caps key of the currently used keyboard Layout + * @param keymap the currently used (underlying)keyboard Layout + * @return -1 if a deadkey was found; + * 0 if no translation is available; + * +1 if character was found and written to pwszBuff +*/ +int KMX_ToUnicodeEx(guint keycode, PKMX_WCHAR pwszBuff, ShiftState rgkey_ss, int caps, GdkKeymap* keymap) { + + GdkKeymapKey* maps; + guint* keyvals; + gint count; + + if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count)) + return 0; + + if (!(ensureValidInputForKeyboardTranslation(convert_rgkey_Shiftstate_to_LinuxShiftstate(rgkey_ss), keycode))){ + g_free(keyvals); + g_free(maps); + return 0; + } + + KMX_DWORD keyVal = (KMX_DWORD)KMX_get_KeyVal_From_KeyCode(keymap, keycode, rgkey_ss, caps); + std::u16string str = convert_DeadkeyValues_To_U16str(keyVal); + KMX_WCHAR firstchar = *(PKMX_WCHAR)str.c_str(); + + if ((firstchar >= 0xD800) &&(firstchar <= 0xDFFF)) { + wprintf(L"Surrogate pair found that is not processed in KMX_ToUnicodeEx\n"); + return 0; + } + + pwszBuff[0] = firstchar; + + g_free(keyvals); + g_free(maps); + + if (u16len(pwszBuff) < 1) + return 0; + + if ((keyVal >= deadkey_min) && (keyVal <= deadkey_max)) // deadkeys + return -1; + else if (gdk_keyval_to_unicode(keyVal) == 0) // NO UNICODE + return 0; + else // usable char + return 1; +} + +KMX_WCHAR KMX_DeadKeyMap(int index, std::vector* deadkeys, int deadkeyBase, std::vector* deadkeyMappings) { // I4327 // I4353 + for (size_t i = 0; i < deadkeyMappings->size(); i++) { + if ((*deadkeyMappings)[i].deadkey == index) { + return (*deadkeyMappings)[i].dkid; + } + } + + for (size_t i = 0; i < deadkeys->size(); i++) { + if ((*deadkeys)[i]->KMX_DeadCharacter() == index) { + return (KMX_WCHAR)(deadkeyBase + i); + } + } + return 0xFFFF; +} + +/** + * @brief Base class for dealing with rgkey +*/ +class KMX_VirtualKey { +private: + KMX_DWORD m_vk; + KMX_DWORD m_sc; + bool m_rgfDeadKey[10][2]; + std::u16string m_rgss[10][2]; + +public: + KMX_VirtualKey(KMX_DWORD scanCode) { + this->m_vk = KMX_get_VKUS_From_KeyCodeUnderlying(scanCode); + this->m_sc = scanCode; + memset(this->m_rgfDeadKey, 0, sizeof(this->m_rgfDeadKey)); + } + +/** + * @brief return member variable virtual key +*/ + KMX_DWORD VK() { + return this->m_vk; + } + +/** + * @brief return member variable scancode +*/ + KMX_DWORD SC() { + return this->m_sc; + } + + std::u16string KMX_GetShiftState(ShiftState shiftState, bool capsLock) { + return this->m_rgss[(KMX_DWORD)shiftState][(capsLock ? 1 : 0)]; + } + + void KMX_SetShiftState(ShiftState shiftState, std::u16string value, bool isDeadKey, bool capsLock) { + this->m_rgfDeadKey[(KMX_DWORD)shiftState][(capsLock ? 1 : 0)] = isDeadKey; + this->m_rgss[(KMX_DWORD)shiftState][(capsLock ? 1 : 0)] = value; + } + + bool KMX_IsSGCAPS() { + std::u16string stBase = this->KMX_GetShiftState(Base, false); + std::u16string stShift = this->KMX_GetShiftState(Shft, false); + std::u16string stCaps = this->KMX_GetShiftState(Base, true); + std::u16string stShiftCaps = this->KMX_GetShiftState(Shft, true); + return ( + ((stCaps.size() > 0) && + (stBase.compare(stCaps) != 0) && + (stShift.compare(stCaps) != 0)) || + ((stShiftCaps.size() > 0) && + (stBase.compare(stShiftCaps) != 0) && + (stShift.compare(stShiftCaps) != 0))); + } + + bool KMX_IsCapsEqualToShift() { + std::u16string stBase = this->KMX_GetShiftState(Base, false); + std::u16string stShift = this->KMX_GetShiftState(Shft, false); + std::u16string stCaps = this->KMX_GetShiftState(Base, true); + return ( + (stBase.size() > 0) && + (stShift.size() > 0) && + (stBase.compare(stShift) != 0) && + (stShift.compare(stCaps) == 0)); + } + + bool KMX_IsAltGrCapsEqualToAltGrShift() { + std::u16string stBase = this->KMX_GetShiftState(MenuCtrl, false); + std::u16string stShift = this->KMX_GetShiftState(ShftMenuCtrl, false); + std::u16string stCaps = this->KMX_GetShiftState(MenuCtrl, true); + return ( + (stBase.size() > 0) && + (stShift.size() > 0) && + (stBase.compare(stShift) != 0) && + (stShift.compare(stCaps) == 0)); + } + + bool KMX_IsXxxxGrCapsEqualToXxxxShift() { + std::u16string stBase = this->KMX_GetShiftState(Xxxx, false); + std::u16string stShift = this->KMX_GetShiftState(ShftXxxx, false); + std::u16string stCaps = this->KMX_GetShiftState(Xxxx, true); + return ( + (stBase.size() > 0) && + (stShift.size() > 0) && + (stBase.compare(stShift) != 0) && + (stShift.compare(stCaps) == 0)); + } + + bool KMX_IsEmpty() { + for (int i = 0; i < 10; i++) { + for (int j = 0; j <= 1; j++) { + if (this->KMX_GetShiftState((ShiftState)i, (j == 1)).size() > 0) { + return (false); + } + } + } + return true; + } +/** + * @brief check if we use only keys used in mcompile +*/ + bool KMX_IsKeymanUsedKey() { + return (this->m_vk >= 0x20 && this->m_vk <= 0x5F) || (this->m_vk >= 0x88); + } + + KMX_DWORD KMX_GetShiftStateValue(int capslock, int caps, ShiftState ss) { + return KMX_ShiftStateMap[(int)ss] | (capslock ? (caps ? CAPITALFLAG : NOTCAPITALFLAG) : 0); + } + +/** + * @brief count the number of keys +*/ + int KMX_GetKeyCount(int MaxShiftState) { + int nkeys = 0; + + // Get the CAPSLOCK value + for (int ss = 0; ss <= MaxShiftState; ss++) { + if (ss == Menu || ss == ShftMenu) { + // Alt and Shift+Alt don't work, so skip them + continue; + } + for (int caps = 0; caps <= 1; caps++) { + std::u16string st = this->KMX_GetShiftState((ShiftState)ss, (caps == 1)); + // ctrl and shift+ctrl will be skipped since rgkey has no entries in m_rgss[2] m_rgss[3] + if (st.size() == 0) { + // No character assigned here + } else if (this->m_rgfDeadKey[(int)ss][caps]) { + // It's a dead key, append an @ sign. + nkeys++; + } else { + bool isvalid = true; + for (size_t ich = 0; ich < st.size(); ich++) { + if (st[ich] < 0x20 || st[ich] == 0x7F) { + isvalid = false; + printf("invalid for: %i\n", st[ich]); + break; + } + } + if (isvalid) { + nkeys++; + } + } + } + } + return nkeys; + } + + bool KMX_LayoutRow(int MaxShiftState, LPKMX_KEY key, std::vector* deadkeys, int deadkeyBase, bool bDeadkeyConversion, vec_dword_3D& all_vector, GdkKeymap* keymap) { // I4552 + // Get the CAPSLOCK value + /*int capslock = + (this->KMX_IsCapsEqualToShift() ? 1 : 0) | + (this->KMX_IsSGCAPS() ? 2 : 0) | + (this->KMX_IsAltGrCapsEqualToAltGrShift() ? 4 : 0) | + (this->KMX_IsXxxxGrCapsEqualToXxxxShift() ? 8 : 0);*/ + + int capslock = 1; // we do not use the equation to obtain capslock. On Linux we set capslock = 1 + + for (int ss = 0; ss <= MaxShiftState; ss++) { + if (ss == Menu || ss == ShftMenu) { + // Alt and Shift+Alt don't work, so skip them + continue; + } + for (int caps = 0; caps <= 1; caps++) { + std::u16string st = this->KMX_GetShiftState((ShiftState)ss, (caps == 1)); + + PKMX_WCHAR p; + + if (st.size() == 0) { + // No character assigned here + } else if (this->m_rgfDeadKey[(int)ss][caps]) { + // It's a dead key, append an @ sign. + key->dpContext = new KMX_WCHAR[1]; + *key->dpContext = 0; + + key->ShiftFlags = this->KMX_GetShiftStateValue(capslock, caps, (ShiftState)ss); + // we already use VK_US so no need to convert it as we do on Windows + key->Key = this->VK(); + key->Line = 0; + + if (bDeadkeyConversion) { // I4552 + p = key->dpOutput = new KMX_WCHAR[2]; + *p++ = st[0]; + *p = 0; + } else { + p = key->dpOutput = new KMX_WCHAR[4]; + *p++ = UC_SENTINEL; + *p++ = CODE_DEADKEY; + *p++ = KMX_DeadKeyMap(st[0], deadkeys, deadkeyBase, &KMX_FDeadkeys); // I4353 + *p = 0; + } + key++; + } else { + bool isvalid = true; + for (size_t ich = 0; ich < st.size(); ich++) { + if (st[ich] < 0x20 || st[ich] == 0x7F) { + isvalid = false; + printf("invalid 16 for: %i\n", st[ich]); + break; + } + } + if (isvalid) { + /* + * this is different to mcompile Windows !!!! + * this->m_sc stores SC-US = SCUnderlying + * this->m_vk stores VK-US ( not VK underlying !!) + * key->Key stores VK-US ( not VK underlying !!) + * key->dpOutput stores character 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(sc_underlying); + + key->Line = 0; + key->ShiftFlags = this->KMX_GetShiftStateValue(capslock, caps, (ShiftState)ss); + + key->dpContext = new KMX_WCHAR; + *key->dpContext = 0; + p = key->dpOutput = new KMX_WCHAR[st.size() + 1]; + for (size_t ich = 0; ich < st.size(); ich++) { + *p++ = st[ich]; + } + *p = 0; + key++; + } + } + } + } + return true; + } +}; + +/** + * @brief Base class for KMX_loader + */ +class KMX_Loader { +private: + KMX_BYTE lpKeyStateNull[256]; + KMX_DWORD m_XxxxVk; + +public: + KMX_Loader() { + m_XxxxVk = 0; + memset(lpKeyStateNull, 0, sizeof(lpKeyStateNull)); + } + + KMX_DWORD Get_XxxxVk() { + return m_XxxxVk; + } + + void Set_XxxxVk(KMX_DWORD value) { + m_XxxxVk = value; + } + + ShiftState KMX_MaxShiftState() { + return (Get_XxxxVk() == 0 ? ShftMenuCtrl : ShftXxxx); + } + + bool KMX_IsControlChar(char16_t ch) { + return (ch < 0x0020) || (ch >= 0x007F && ch <= 0x009F); + } +}; + +/** + * @brief find the maximum index of a deadkey + @param p pointer to deadkey + * @return index of deadkey +*/ +int KMX_GetMaxDeadkeyIndex(KMX_WCHAR* p) { + int n = 0; + while (p && *p) { + if (*p == UC_SENTINEL && *(p + 1) == CODE_DEADKEY) + n = std::max(n, (int)*(p + 2)); + p = KMX_incxstr(p); + } + return n; +} + +/** + * @brief Collect the key data, translate it to kmx and append to the existing keyboard + * It is important to understand that this function has different sorting order in rgkey compared to mcompile-windows! + * On Windows the values of rgkey are sorted according to the VK of the underlying keyboard + * On Linux the values of rgkey are sorted according to the VK of the the US keyboard + * Since Linux Keyboards do not use a VK mcompile uses the VK of the the US keyboard because + * these are available in mcompile through USVirtualKeyToScanCode/ScanCodeToUSVirtualKey and an offset of 8 + * @param kp pointer to keyboard + * @param all_vector vector that holds the data of the US keyboard and the currently used (underlying) keyboard + * @param keymap the currently used (underlying)keyboard Layout + * @param FDeadkeys vector of all deadkeys for the currently used (underlying)keyboard Layout + * @param bDeadkeyConversion 1 to convert a deadkey to a character; 0 no conversion + * @return true in case of success + */ +bool KMX_ImportRules(LPKMX_KEYBOARD kp, vec_dword_3D& all_vector, GdkKeymap** keymap, std::vector* FDeadkeys, KMX_BOOL bDeadkeyConversion) { // I4353 // I4552 + KMX_Loader loader; + + std::vector rgKey; //= new VirtualKey[256]; + std::vector alDead; + std::vector alDead_byBasechar = create_deadkeys_by_basechar(); + + rgKey.resize(256); + + // Scroll through the Scan Code (SC) values and get the valid Virtual Key (VK) + // values in it. Then, store the SC in each valid VK so it can act as both a + // flag that the VK is valid, and it can store the SC value. + + // Windows and Linux Keycodes start with 1; Mac keycodes start with 0 + for (KMX_DWORD sc = 0x01; sc <= 0x7f; sc++) { + /* HERE IS A BIG DIFFERENCE COMPARED TO MCOMPILE FOR WINDOWS: + * mcompile on Windows fills rgkey.m_vk with the VK of the Underlying keyboard + * mcompile for Linux fills rgkey.m_vk with the VK of the US keyboard + * this results in a different sorting order in rgkey[] ! + + * Linux cannot get a VK for the underling Keyboard since this does not exist + * Linux can only get a VK for the US Keyboard (by using USVirtualKeyToScanCode/ScanCodeToUSVirtualKey) + * therefore we use VK_US in rgkey[ ] which we get from all_vector + */ + KMX_VirtualKey* key = new KMX_VirtualKey(sc); + + if ((key->VK() != 0)) { + rgKey[key->VK()] = key; + } else { + delete key; + } + } + + // in this part we skip shiftstates 4, 5, 8, 9 + for (KMX_DWORD iKey = 0; iKey < rgKey.size(); iKey++) { + if (rgKey[iKey] != NULL) { + KMX_WCHAR sbBuffer[256]; // Scratchpad we use many places + for (ShiftState ss = Base; ss <= loader.KMX_MaxShiftState(); ss = (ShiftState)((int)ss + 1)) { + if (ss == Menu || ss == ShftMenu) { + // Alt and Shift+Alt don't work, so skip them (ss 4+5) + continue; + } + + KMX_DWORD kc_underlying = KMX_get_KeyCodeUnderlying_From_VKUS(iKey); + + for (int caps = 0; caps <= 1; caps++) { + int rc = KMX_ToUnicodeEx(kc_underlying, sbBuffer, ss, caps, *keymap); + + if (rc > 0) { + if (*sbBuffer == 0) { + rgKey[iKey]->KMX_SetShiftState(ss, u"", false, (caps)); // different to windows since behavior on Linux is different (see above) + } else { + if ((ss == Ctrl || ss == ShftCtrl)) { + continue; + } + sbBuffer[rc] = 0; + rgKey[iKey]->KMX_SetShiftState(ss, sbBuffer, false, (caps)); // different to windows since behavior on Linux is different (see above) + } + } else if (rc < 0) { + sbBuffer[2] = 0; + rgKey[iKey]->KMX_SetShiftState(ss, sbBuffer, true, (caps)); // different to windows since behavior on Linux is different (see above) + + refine_alDead(sbBuffer[0], alDead, alDead_byBasechar); + } + } + } + } + } + + //------------------------------------------------------------- + // Now that we've collected the key data, we need to + // translate it to kmx and append to the existing keyboard + //------------------------------------------------------------- + + int nDeadkey = 0; + LPKMX_GROUP gp = new KMX_GROUP[kp->cxGroupArray + 4]; // leave space for old + memcpy(gp, kp->dpGroupArray, sizeof(KMX_GROUP) * kp->cxGroupArray); + + // + // Find the current highest deadkey index + // + + kp->dpGroupArray = gp; + for (KMX_DWORD i = 0; i < kp->cxGroupArray; i++, gp++) { + LPKMX_KEY kkp = gp->dpKeyArray; + + for (KMX_DWORD j = 0; j < gp->cxKeyArray; j++, kkp++) { + nDeadkey = std::max(nDeadkey, KMX_GetMaxDeadkeyIndex(kkp->dpContext)); + nDeadkey = std::max(nDeadkey, KMX_GetMaxDeadkeyIndex(kkp->dpOutput)); + } + } + + kp->cxGroupArray++; + gp = &kp->dpGroupArray[kp->cxGroupArray - 1]; + + // calculate the required size of `gp->dpKeyArray` + + KMX_DWORD nkeys = 0; + for (KMX_DWORD iKey = 0; iKey < rgKey.size(); iKey++) { + if ((rgKey[iKey] != NULL) && rgKey[iKey]->KMX_IsKeymanUsedKey() && (!rgKey[iKey]->KMX_IsEmpty())) { + nkeys += rgKey[iKey]->KMX_GetKeyCount(loader.KMX_MaxShiftState()); + } + } + + gp->fUsingKeys = TRUE; + gp->dpMatch = NULL; + gp->dpName = NULL; + gp->dpNoMatch = NULL; + gp->cxKeyArray = nkeys; + gp->dpKeyArray = new KMX_KEY[gp->cxKeyArray]; + + nDeadkey++; // ensure a 1-based index above the max deadkey value already in the keyboard + + // + // Fill in the new rules + // + nkeys = 0; + for (KMX_DWORD iKey = 0; iKey < rgKey.size(); iKey++) { + if ((rgKey[iKey] != NULL) && rgKey[iKey]->KMX_IsKeymanUsedKey() && (!rgKey[iKey]->KMX_IsEmpty())) { + if (rgKey[iKey]->KMX_LayoutRow(loader.KMX_MaxShiftState(), &gp->dpKeyArray[nkeys], &alDead, nDeadkey, bDeadkeyConversion, all_vector, *keymap)) { // I4552 + nkeys += rgKey[iKey]->KMX_GetKeyCount(loader.KMX_MaxShiftState()); + } + } + } + + gp->cxKeyArray = nkeys; + + // + // Add nomatch control to each terminating 'using keys' group // I4550 + // + LPKMX_GROUP gp2 = kp->dpGroupArray; + for (KMX_DWORD i = 0; i < kp->cxGroupArray - 1; i++, gp2++) { + if (gp2->fUsingKeys && gp2->dpNoMatch == NULL) { + KMX_WCHAR* p = gp2->dpNoMatch = new KMX_WCHAR[4]; + *p++ = UC_SENTINEL; + *p++ = CODE_USE; + *p++ = (KMX_WCHAR)(kp->cxGroupArray); + *p = 0; + + // I4550 - Each place we have a nomatch > use(baselayout) (this last group), we need to add all + // the AltGr and ShiftAltGr combinations as rules to allow them to be matched as well. Yes, this + // loop is not very efficient but it's not worthy of optimisation. + // + KMX_DWORD j; + LPKMX_KEY kkp; + for (j = 0, kkp = gp->dpKeyArray; j < gp->cxKeyArray; j++, kkp++) { + if ((kkp->ShiftFlags & (K_CTRLFLAG | K_ALTFLAG | LCTRLFLAG | LALTFLAG | RCTRLFLAG | RALTFLAG)) != 0) { + gp2->cxKeyArray++; + LPKMX_KEY kkp2 = new KMX_KEY[gp2->cxKeyArray]; + memcpy(kkp2, gp2->dpKeyArray, sizeof(KMX_KEY) * (gp2->cxKeyArray - 1)); + gp2->dpKeyArray = kkp2; + kkp2 = &kkp2[gp2->cxKeyArray - 1]; + kkp2->dpContext = new KMX_WCHAR; + *kkp2->dpContext = 0; + kkp2->Key = kkp->Key; + kkp2->ShiftFlags = kkp->ShiftFlags; + kkp2->Line = 0; + KMX_WCHAR* p = kkp2->dpOutput = new KMX_WCHAR[4]; + *p++ = UC_SENTINEL; + *p++ = CODE_USE; + *p++ = (KMX_WCHAR)(kp->cxGroupArray); + *p = 0; + } + } + } + } + + // If we have deadkeys, then add a new group to translate the deadkeys per the deadkey tables + // We only do this if not in deadkey conversion mode + // + + if (alDead.size() > 0 && !bDeadkeyConversion) { // I4552 + kp->cxGroupArray++; + + KMX_WCHAR* p = gp->dpMatch = new KMX_WCHAR[4]; + *p++ = UC_SENTINEL; + *p++ = CODE_USE; + *p++ = (KMX_WCHAR)kp->cxGroupArray; + *p = 0; + + gp++; + + gp->fUsingKeys = FALSE; + gp->dpMatch = NULL; + gp->dpName = NULL; + gp->dpNoMatch = NULL; + gp->cxKeyArray = alDead.size(); + LPKMX_KEY kkp = gp->dpKeyArray = new KMX_KEY[alDead.size()]; + + LPKMX_STORE sp = new KMX_STORE[kp->cxStoreArray + alDead.size() * 2]; + memcpy(sp, kp->dpStoreArray, sizeof(KMX_STORE) * kp->cxStoreArray); + + kp->dpStoreArray = sp; + + sp = &sp[kp->cxStoreArray]; + int nStoreBase = kp->cxStoreArray; + kp->cxStoreArray += alDead.size() * 2; + + for (KMX_DWORD i = 0; i < alDead.size(); i++) { + DeadKey* dk = alDead[i]; + + sp->dpName = NULL; + sp->dwSystemID = 0; + sp->dpString = new KMX_WCHAR[dk->KMX_Count() + 1]; + for (int j = 0; j < dk->KMX_Count(); j++) + sp->dpString[j] = dk->KMX_GetBaseCharacter(j); + sp->dpString[dk->KMX_Count()] = 0; + sp++; + + sp->dpName = NULL; + sp->dwSystemID = 0; + sp->dpString = new KMX_WCHAR[dk->KMX_Count() + 1]; + for (int j = 0; j < dk->KMX_Count(); j++) + sp->dpString[j] = dk->KMX_GetCombinedCharacter(j); + sp->dpString[dk->KMX_Count()] = 0; + sp++; + + kkp->Line = 0; + kkp->ShiftFlags = 0; + kkp->Key = 0; + KMX_WCHAR* p = kkp->dpContext = new KMX_WCHAR[8]; + *p++ = UC_SENTINEL; + *p++ = CODE_DEADKEY; + *p++ = KMX_DeadKeyMap(dk->KMX_DeadCharacter(), &alDead, nDeadkey, FDeadkeys); // I4353 + // *p++ = nDeadkey+i; + *p++ = UC_SENTINEL; + *p++ = CODE_ANY; + *p++ = nStoreBase + i * 2 + 1; + *p = 0; + + p = kkp->dpOutput = new KMX_WCHAR[5]; + *p++ = UC_SENTINEL; + *p++ = CODE_INDEX; + *p++ = nStoreBase + i * 2 + 2; + *p++ = 2; + *p = 0; + kkp++; + } + } +return true; +} diff --git a/linux/mcompile/keymap/mc_import_rules.h b/linux/mcompile/keymap/mc_import_rules.h new file mode 100644 index 00000000000..f955830eac3 --- /dev/null +++ b/linux/mcompile/keymap/mc_import_rules.h @@ -0,0 +1,43 @@ + +#pragma once +#ifndef MC_IMPORT_RULES_H +#define MC_IMPORT_RULES_H + +/** @brief Base class for Deadkey*/ +class DeadKey { +private: + KMX_WCHAR m_deadchar; + std::vector m_rgbasechar; + std::vector m_rgcombchar; + +public: + /** @brief Constructor */ + DeadKey(KMX_WCHAR deadCharacter); + + /** @brief return dead character */ + KMX_WCHAR KMX_DeadCharacter(); + + /** @brief set Deadkey with values */ + void KMX_AddDeadKeyRow(KMX_WCHAR baseCharacter, KMX_WCHAR combinedCharacter); + + int KMX_Count() { + return this->m_rgbasechar.size(); + } + + KMX_WCHAR KMX_GetDeadCharacter() { + return this->m_deadchar; + } + + KMX_WCHAR KMX_GetBaseCharacter(int index) { + return this->m_rgbasechar[index]; + } + + KMX_WCHAR KMX_GetCombinedCharacter(int index) { + return this->m_rgcombchar[index]; + } + + /** @brief check if character exists in DeadKey */ + bool KMX_ContainsBaseCharacter(KMX_WCHAR baseCharacter); +}; + +#endif /*MC_IMPORT_RULES_H*/ diff --git a/linux/mcompile/keymap/mc_kmxfile.cpp b/linux/mcompile/keymap/mc_kmxfile.cpp index e0a20c34ac7..f30ff5daefd 100644 --- a/linux/mcompile/keymap/mc_kmxfile.cpp +++ b/linux/mcompile/keymap/mc_kmxfile.cpp @@ -1,297 +1,581 @@ +/* + * Keyman is copyright (C) 2004 - 2024 SIL International. MIT License. + * + * Mnemonic layout support for Linux + */ #include "mc_kmxfile.h" +#include + +#define CERR_None 0x00000000 +#define CERR_CannotAllocateMemory 0x00008004 +#define CERR_UnableToWriteFully 0x00008007 +#define CERR_SomewhereIGotItWrong 0x00008009 + + +const int CODE__SIZE[] = { + -1, // undefined 0x00 + 1, // CODE_ANY 0x01 + 2, // CODE_INDEX 0x02 + 0, // CODE_CONTEXT 0x03 + 0, // CODE_NUL 0x04 + 1, // CODE_USE 0x05 + 0, // CODE_RETURN 0x06 + 0, // CODE_BEEP 0x07 + 1, // CODE_DEADKEY 0x08 + -1, // unused 0x09 + 2, // CODE_EXTENDED 0x0A + -1, // CODE_EXTENDEDEND 0x0B (unused) + 1, // CODE_SWITCH 0x0C + -1, // CODE_KEY 0x0D (never used) + 0, // CODE_CLEARCONTEXT 0x0E + 1, // CODE_CALL 0x0F + -1, // UC_SENTINEL_EXTENDEDEND 0x10 (not valid with UC_SENTINEL) + 1, // CODE_CONTEXTEX 0x11 + 1, // CODE_NOTANY 0x12 + 2, // CODE_SETOPT 0x13 + 3, // CODE_IFOPT 0x14 + 1, // CODE_SAVEOPT 0x15 + 1, // CODE_RESETOPT 0x16 + 3, // CODE_IFSYSTEMSTORE 0x17 + 2 // CODE_SETSYSTEMSTORE 0x18 +}; + +/** @brief check if the file has correct version */ +KMX_BOOL KMX_VerifyKeyboard(PKMX_BYTE filebase, KMX_DWORD file_size); + +/** @brief Fixup the keyboard by expanding pointers. */ +LPKMX_KEYBOARD KMX_FixupKeyboard(PKMX_BYTE bufp, PKMX_BYTE base, KMX_DWORD dwFileSize); + +/** + * @brief Save a Keyboard to a file + * @param fk pointer to the keyboard + * @param hOutfile pointer to the output file + * @param FSaveDebug + * @return an Error in case of failure + */ +KMX_DWORD KMX_WriteCompiledKeyboardToFile(LPKMX_KEYBOARD fk, FILE* hOutfile, KMX_BOOL FSaveDebug) { + LPKMX_GROUP fgp; + LPKMX_STORE fsp; + LPKMX_KEY fkp; + + PCOMP_KEYBOARD ck; + PCOMP_GROUP gp; + PCOMP_STORE sp; + PCOMP_KEY kp; + PKMX_BYTE buf; + KMX_DWORD size, offset; + KMX_DWORD i, j; + + // Calculate how much memory to allocate + size = sizeof(COMP_KEYBOARD) + + fk->cxGroupArray * sizeof(COMP_GROUP) + + fk->cxStoreArray * sizeof(COMP_STORE) + + // wcslen(fk->szName)*2 + 2 + + // wcslen(fk->szCopyright)*2 + 2 + + // wcslen(fk->szLanguageName)*2 + 2 + + // wcslen(fk->szMessage)*2 + 2 + + fk->dwBitmapSize; + + for (i = 0, fgp = fk->dpGroupArray; i < fk->cxGroupArray; i++, fgp++) { + if (fgp->dpName) + size += (u16len(fgp->dpName) + 1) * sizeof(KMX_WCHAR); + size += fgp->cxKeyArray * sizeof(COMP_KEY); + for (j = 0, fkp = fgp->dpKeyArray; j < fgp->cxKeyArray; j++, fkp++) { + size += (u16len(fkp->dpOutput) + 1) * sizeof(KMX_WCHAR); + size += (u16len(fkp->dpContext) + 1) * sizeof(KMX_WCHAR); + } + + if (fgp->dpMatch) + size += (u16len(fgp->dpMatch) + 1) * sizeof(KMX_WCHAR); + if (fgp->dpNoMatch) + size += (u16len(fgp->dpNoMatch) + 1) * sizeof(KMX_WCHAR); + } -KMX_DWORD TEST2; - -static KMX_BOOL LoadKeyboardFile(LPKMX_STR fileName, LPKEYBOARD *lpKeyboard); - -KMX_BOOL VerifyKeyboard(LPKMX_BYTE filebase, KMX_DWORD sz); - -LPKEYBOARD FixupKeyboard(PKMX_BYTE bufp, PKMX_BYTE base, KMX_DWORD dwFileSize); - -/*void Err(wchar_t *s) { - LogError(L"LoadKeyboard: %s, last error = %d\n", s, GetLastError()); -}*/ -/*BOOL LoadKeyboard(LPWSTR fileName, LPKEYBOARD *lpKeyboard) { - DWORD sz; - LPBYTE buf; - HANDLE hFile; - LPKEYBOARD kbp; - PBYTE filebase; + for (i = 0; i < fk->cxStoreArray; i++) { + size += (u16len(fk->dpStoreArray[i].dpString) + 1) * sizeof(KMX_WCHAR); + if (fk->dpStoreArray[i].dpName) + size += (u16len(fk->dpStoreArray[i].dpName) + 1) * sizeof(KMX_WCHAR); + } - if(!fileName || !lpKeyboard) { - Err(L"Bad Filename"); - return FALSE; - } + buf = new KMX_BYTE[size]; + if (!buf) + return CERR_CannotAllocateMemory; + memset(buf, 0, size); + + ck = (PCOMP_KEYBOARD)buf; + + ck->dwIdentifier = FILEID_COMPILED; + + ck->dwFileVersion = fk->dwFileVersion; + ck->dwCheckSum = 0; // No checksum in 16.0, see #7276 + ck->KeyboardID = fk->xxkbdlayout; + ck->IsRegistered = fk->IsRegistered; + ck->cxStoreArray = fk->cxStoreArray; + ck->cxGroupArray = fk->cxGroupArray; + ck->StartGroup[0] = fk->StartGroup[0]; + ck->StartGroup[1] = fk->StartGroup[1]; + ck->dwHotKey = fk->dwHotKey; + + ck->dwFlags = fk->dwFlags; + + offset = sizeof(COMP_KEYBOARD); + + ck->dpStoreArray = offset; + sp = (PCOMP_STORE)(buf + offset); + fsp = fk->dpStoreArray; + offset += sizeof(COMP_STORE) * ck->cxStoreArray; + for (i = 0; i < ck->cxStoreArray; i++, sp++, fsp++) { + sp->dwSystemID = fsp->dwSystemID; + sp->dpString = offset; + u16ncpy((PKMX_WCHAR)(buf + offset), fsp->dpString, (size - offset) / sizeof(KMX_WCHAR)); // I3481 // I3641 + + offset += (u16len(fsp->dpString) + 1) * sizeof(KMX_WCHAR); + if (!fsp->dpName) { + sp->dpName = 0; + } else { + sp->dpName = offset; + u16ncpy((PKMX_WCHAR)(buf + offset), fsp->dpName, (size - offset) / sizeof(KMX_WCHAR)); // I3481 // I3641 + offset += (u16len(fsp->dpName) + 1) * sizeof(KMX_WCHAR); + } + } - hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); - if(hFile == INVALID_HANDLE_VALUE) { - Err(L"Could not open file"); - return FALSE; + ck->dpGroupArray = offset; + gp = (PCOMP_GROUP)(buf + offset); + + offset += sizeof(COMP_GROUP) * ck->cxGroupArray; + + for (i = 0, fgp = fk->dpGroupArray; i < ck->cxGroupArray; i++, gp++, fgp++) { + gp->cxKeyArray = fgp->cxKeyArray; + gp->fUsingKeys = fgp->fUsingKeys; + + gp->dpMatch = gp->dpNoMatch = 0; + + if (fgp->dpMatch) { + gp->dpMatch = offset; + u16ncpy((PKMX_WCHAR)(buf + offset), fgp->dpMatch, (size - offset) / sizeof(KMX_WCHAR)); // I3481 // I3641 + offset += (u16len(fgp->dpMatch) + 1) * sizeof(KMX_WCHAR); + } + if (fgp->dpNoMatch) { + gp->dpNoMatch = offset; + u16ncpy((PKMX_WCHAR)(buf + offset), fgp->dpNoMatch, (size - offset) / sizeof(KMX_WCHAR)); // I3481 // I3641 + offset += (u16len(fgp->dpNoMatch) + 1) * sizeof(KMX_WCHAR); + } + + if (fgp->dpName) { + gp->dpName = offset; + u16ncpy((PKMX_WCHAR)(buf + offset), fgp->dpName, (size - offset) / sizeof(KMX_WCHAR)); // I3481 // I3641 + offset += (u16len(fgp->dpName) + 1) * sizeof(KMX_WCHAR); + } else { + gp->dpName = 0; + } + + gp->dpKeyArray = offset; + kp = (PCOMP_KEY)(buf + offset); + offset += gp->cxKeyArray * sizeof(COMP_KEY); + + for (j = 0, fkp = fgp->dpKeyArray; j < gp->cxKeyArray; j++, kp++, fkp++) { + kp->Key = fkp->Key; + kp->Line = fkp->Line; + kp->ShiftFlags = fkp->ShiftFlags; + kp->dpOutput = offset; + + u16ncpy((PKMX_WCHAR)(buf + offset), fkp->dpOutput, (size - offset) / sizeof(KMX_WCHAR)); // I3481 // I3641 + offset += (u16len(fkp->dpOutput) + 1) * sizeof(KMX_WCHAR); + + kp->dpContext = offset; + u16ncpy((PKMX_WCHAR)(buf + offset), fkp->dpContext, (size - offset) / sizeof(KMX_WCHAR)); // I3481 // I3641 + offset += (u16len(fkp->dpContext) + 1) * sizeof(KMX_WCHAR); + } } - sz = GetFileSize(hFile, NULL); - - buf = new BYTE[sz]; - - if(!buf) { - Err(L"Not allocmem"); - CloseHandle(hFile); - return FALSE; - } + if (fk->dwBitmapSize > 0) { + ck->dwBitmapSize = fk->dwBitmapSize; + ck->dpBitmapOffset = offset; + memcpy(buf + offset, ((PKMX_BYTE)fk) + fk->dpBitmapOffset, fk->dwBitmapSize); + offset += fk->dwBitmapSize; + } else { + ck->dwBitmapSize = 0; + ck->dpBitmapOffset = 0; + } - filebase = buf; + size_t nr_elements = fwrite(buf, size, 1, hOutfile); - if(!ReadFile(hFile, filebase, sz, &sz, NULL)) { - Err(L"errReadFile"); - CloseHandle(hFile); + if (nr_elements < 1) { delete[] buf; - return FALSE; + return CERR_SomewhereIGotItWrong; } - CloseHandle(hFile); - if(!VerifyKeyboard(filebase, sz)) { - Err(L"errVerifyKeyboard"); + if (offset != size) { delete[] buf; - return FALSE; + return CERR_UnableToWriteFully; } - kbp = FixupKeyboard(buf, filebase, sz); - if(!kbp) { - Err(L"errFixupKeyboard"); - delete[] buf; + delete[] buf; + + return CERR_None; +} + +/** + * @brief save keyboard to file + * @param kbd pointer to the keyboard + * @param filename pointer to filename of a kmx-file + * @return TRUE on success; + * else FALSE + */ +KMX_BOOL KMX_SaveKeyboard(LPKMX_KEYBOARD kbd, KMX_CHAR* filename) { + FILE* fp; + fp = Open_File(filename, "wb"); + + if (fp == NULL) { + KMX_LogError(L"Failed to create output file (%d)", errno); return FALSE; } - if(kbp->dwIdentifier != FILEID_COMPILED) { - Err(L"errNotFileID"); - delete[] buf; + KMX_DWORD err = KMX_WriteCompiledKeyboardToFile(kbd, fp, FALSE); + fclose(fp); + + if (err != CERR_None) { + KMX_LogError(L"Failed to write compiled keyboard with error %d", err); + std::string s(filename); + remove(s.c_str()); return FALSE; } - *lpKeyboard = kbp; - return TRUE; + return TRUE; } -*/ - -/*PKMX_WCHART StringOffset(PKMX_BYTE base, KMX_DWORD offset) { - if(offset == 0) return NULL; - return (PKMX_WCHART)(base + offset); -}*/ +/** + * @brief add an offset + * @param base pointer to starting point + * @param offset a given offset + * @return pointer to base + offset + */ +PKMX_WCHAR KMX_StringOffset(PKMX_BYTE base, KMX_DWORD offset) { + if (offset == 0) + return NULL; + return (PKMX_WCHAR)(base + offset); +} -/*LPKEYBOARD FixupKeyboard(PBYTE bufp, PBYTE base, DWORD dwFileSize) { - UNREFERENCED_PARAMETER(dwFileSize); +#ifdef KMX_64BIT + +/** + * @brief CopyKeyboard will copy the data into bufp from x86-sized structures into + * x64-sized structures starting at `base`. After this function finishes, we still + * need to keep the original data because we don't copy the strings. The method is + * used on 64-bit architectures. + * @param bufp pointer to buffer where data is copied into + * @param base pointer to starting point + * @return pointer to the keyboard + */ +LPKMX_KEYBOARD CopyKeyboard(PKMX_BYTE bufp, PKMX_BYTE base) { + PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD)base; + + /* Copy keyboard structure */ + + LPKMX_KEYBOARD kbp = (LPKMX_KEYBOARD)bufp; + bufp += sizeof(KMX_KEYBOARD); + + kbp->dwIdentifier = ckbp->dwIdentifier; + kbp->dwFileVersion = ckbp->dwFileVersion; + kbp->dwCheckSum = ckbp->dwCheckSum; + kbp->xxkbdlayout = ckbp->KeyboardID; + kbp->IsRegistered = ckbp->IsRegistered; + kbp->version = ckbp->version; + kbp->cxStoreArray = ckbp->cxStoreArray; + kbp->cxGroupArray = ckbp->cxGroupArray; + kbp->StartGroup[0] = ckbp->StartGroup[0]; + kbp->StartGroup[1] = ckbp->StartGroup[1]; + kbp->dwFlags = ckbp->dwFlags; + kbp->dwHotKey = ckbp->dwHotKey; + + kbp->dpStoreArray = (LPKMX_STORE)bufp; + bufp += sizeof(KMX_STORE) * kbp->cxStoreArray; + + kbp->dpGroupArray = (LPKMX_GROUP)bufp; + bufp += sizeof(KMX_GROUP) * kbp->cxGroupArray; - DWORD i, j; - PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD) base; - PCOMP_GROUP cgp; PCOMP_STORE csp; - PCOMP_KEY ckp; - LPKEYBOARD kbp = (LPKEYBOARD) bufp; - LPSTORE sp; - LPGROUP gp; - LPKEY kp; - - kbp->dpStoreArray = (LPSTORE) (base + ckbp->dpStoreArray); - kbp->dpGroupArray = (LPGROUP) (base + ckbp->dpGroupArray); - - for(sp = kbp->dpStoreArray, csp = (PCOMP_STORE) sp, i = 0; i < kbp->cxStoreArray; i++, sp++, csp++) { - sp->dpName = StringOffset(base, csp->dpName); - sp->dpString = StringOffset(base, csp->dpString); - } + LPKMX_STORE sp; + KMX_DWORD i; - for(gp = kbp->dpGroupArray, cgp = (PCOMP_GROUP) gp, i = 0; i < kbp->cxGroupArray; i++, gp++, cgp++) { - gp->dpName = StringOffset(base, cgp->dpName); - gp->dpKeyArray = (LPKEY) (base + cgp->dpKeyArray); - if(cgp->dpMatch != NULL) gp->dpMatch = (PWSTR) (base + cgp->dpMatch); - if(cgp->dpNoMatch != NULL) gp->dpNoMatch = (PWSTR) (base + cgp->dpNoMatch); - - for(kp = gp->dpKeyArray, ckp = (PCOMP_KEY) kp, j = 0; j < gp->cxKeyArray; j++, kp++, ckp++) { - kp->dpOutput = (PWSTR) (base + ckp->dpOutput); - kp->dpContext = (PWSTR) (base + ckp->dpContext); - } - } + for (csp = (PCOMP_STORE)(base + ckbp->dpStoreArray), sp = kbp->dpStoreArray, i = 0; i < kbp->cxStoreArray; i++, sp++, csp++) { + sp->dwSystemID = csp->dwSystemID; + sp->dpName = KMX_StringOffset(base, csp->dpName); + sp->dpString = KMX_StringOffset(base, csp->dpString); + } + PCOMP_GROUP cgp; + LPKMX_GROUP gp; + + for (cgp = (PCOMP_GROUP)(base + ckbp->dpGroupArray), gp = kbp->dpGroupArray, i = 0; i < kbp->cxGroupArray; i++, gp++, cgp++) { + gp->dpName = KMX_StringOffset(base, cgp->dpName); + gp->dpKeyArray = cgp->cxKeyArray > 0 ? (LPKMX_KEY)bufp : NULL; + gp->cxKeyArray = cgp->cxKeyArray; + bufp += sizeof(KMX_KEY) * gp->cxKeyArray; + gp->dpMatch = KMX_StringOffset(base, cgp->dpMatch); + gp->dpNoMatch = KMX_StringOffset(base, cgp->dpNoMatch); + gp->fUsingKeys = cgp->fUsingKeys; + + PCOMP_KEY ckp; + LPKMX_KEY kp; + KMX_DWORD j; + + for (ckp = (PCOMP_KEY)(base + cgp->dpKeyArray), kp = gp->dpKeyArray, j = 0; j < gp->cxKeyArray; j++, kp++, ckp++) { + kp->Key = ckp->Key; + kp->Line = ckp->Line; + kp->ShiftFlags = ckp->ShiftFlags; + kp->dpOutput = KMX_StringOffset(base, ckp->dpOutput); + kp->dpContext = KMX_StringOffset(base, ckp->dpContext); + } + } return kbp; } -*/ +// else KMX_FixupKeyboard +#else +/** + * @brief Fixup the keyboard by expanding pointers. On disk the pointers are stored relative to the + * beginning of the file, but we need real pointers. This method is used on 32-bit architectures. + * @param bufp pointer to buffer where data will be copied into + * @param base pointer to starting point + * @param dwFileSize size of the file + * @return pointer to the keyboard + */ +LPKMX_KEYBOARD KMX_FixupKeyboard(PKMX_BYTE bufp, PKMX_BYTE base, KMX_DWORD dwFileSize) { + UNREFERENCED_PARAMETER(dwFileSize); -/*BOOL VerifyKeyboard(LPBYTE filebase, DWORD sz) { - DWORD i; - PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD) filebase; + KMX_DWORD i, j; + PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD)base; + PCOMP_GROUP cgp; PCOMP_STORE csp; + PCOMP_KEY ckp; + LPKMX_KEYBOARD kbp = (LPKMX_KEYBOARD)bufp; + LPKMX_STORE sp; + LPKMX_GROUP gp; + LPKMX_KEY kp; - // Check file version // - - if(ckbp->dwFileVersion < VERSION_MIN || - ckbp->dwFileVersion > VERSION_MAX) { - // Old or new version -- identify the desired program version // - for(csp = (PCOMP_STORE)(filebase + ckbp->dpStoreArray), i = 0; i < ckbp->cxStoreArray; i++, csp++) { - if(csp->dwSystemID == TSS_COMPILEDVERSION) { - wchar_t buf2[256]; - if(csp->dpString == 0) { - wsprintf(buf2, L"errWrongFileVersion:NULL"); - } else { - wsprintf(buf2, L"errWrongFileVersion:%10.10ls", StringOffset(filebase, csp->dpString)); - } - Err(buf2); - return FALSE; - } - } - Err(L"errWrongFileVersion"); - return FALSE; - } - - - return TRUE; -}*/ + kbp->dpStoreArray = (LPKMX_STORE)(base + ckbp->dpStoreArray); + kbp->dpGroupArray = (LPKMX_GROUP)(base + ckbp->dpGroupArray); + for (sp = kbp->dpStoreArray, csp = (PCOMP_STORE)sp, i = 0; i < kbp->cxStoreArray; i++, sp++, csp++) { + sp->dpName = KMX_StringOffset(base, csp->dpName); + sp->dpString = KMX_StringOffset(base, csp->dpString); + } -//---------------------old---------------------------------------- -/* -#include "pch.h" + for (gp = kbp->dpGroupArray, cgp = (PCOMP_GROUP)gp, i = 0; i < kbp->cxGroupArray; i++, gp++, cgp++) { + gp->dpName = KMX_StringOffset(base, cgp->dpName); + gp->dpKeyArray = (LPKMX_KEY)(base + cgp->dpKeyArray); + if (cgp->dpMatch != NULL) + gp->dpMatch = (PKMX_WCHAR)(base + cgp->dpMatch); + if (cgp->dpNoMatch != NULL) + gp->dpNoMatch = (PKMX_WCHAR)(base + cgp->dpNoMatch); + + for (kp = gp->dpKeyArray, ckp = (PCOMP_KEY)kp, j = 0; j < gp->cxKeyArray; j++, kp++, ckp++) { + kp->dpOutput = (PKMX_WCHAR)(base + ckp->dpOutput); + kp->dpContext = (PKMX_WCHAR)(base + ckp->dpContext); + } + } + return kbp; +} -static BOOL LoadKeyboardFile(LPSTR fileName, LPKEYBOARD *lpKeyboard); -BOOL VerifyKeyboard(LPBYTE filebase, DWORD sz); +#endif -LPKEYBOARD FixupKeyboard(PBYTE bufp, PBYTE base, DWORD dwFileSize); +/** @brief load a keyboard kmx-file */ +KMX_BOOL KMX_LoadKeyboard(KMX_CHAR* fileName, LPKMX_KEYBOARD* lpKeyboard) { + *lpKeyboard = NULL; + PKMX_BYTE buf; + FILE* fp; + LPKMX_KEYBOARD kbp; + PKMX_BYTE filebase; -void Err(wchar_t *s) { - LogError(L"LoadKeyboard: %s, last error = %d\n", s, GetLastError()); -} + if (!fileName || !lpKeyboard) { + KMX_LogError(L"Bad Filename\n"); + return FALSE; + } -BOOL LoadKeyboard(LPWSTR fileName, LPKEYBOARD *lpKeyboard) { - DWORD sz; - LPBYTE buf; - HANDLE hFile; - LPKEYBOARD kbp; - PBYTE filebase; + fp = Open_File((const KMX_CHAR*)fileName, "rb"); - if(!fileName || !lpKeyboard) { - Err(L"Bad Filename"); - return FALSE; - } + if (fp == NULL) { + KMX_LogError(L"Could not open file\n"); + return FALSE; + } - hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); - if(hFile == INVALID_HANDLE_VALUE) { - Err(L"Could not open file"); - return FALSE; - } + if (fseek(fp, 0, SEEK_END) != 0) { + fclose(fp); + KMX_LogError(L"Could not fseek file\n"); + return FALSE; + } - sz = GetFileSize(hFile, NULL); + auto file_size = ftell(fp); + if (file_size <= 0) { + fclose(fp); + return FALSE; + } - buf = new BYTE[sz]; + if (fseek(fp, 0, SEEK_SET) != 0) { + fclose(fp); + KMX_LogError(L"Could not fseek(set) file\n"); + return FALSE; + } - if(!buf) { - Err(L"Not allocmem"); - CloseHandle(hFile); - return FALSE; - } +#ifdef KMX_64BIT + /** + * allocate enough memory for expanded data structure + original data. + * Expanded data structure is double the size of data on disk (8-byte + * pointers) - on disk the "pointers" are relative to the beginning of + * the file. + * We save the original data at the end of buf; we don't copy strings, so + * those will remain in the location at the end of the buffer. + */ + buf = new KMX_BYTE[file_size * 3]; +#else + buf = new KMX_BYTE[file_size]; +#endif + + if (!buf) { + delete[] buf; + fclose(fp); + KMX_LogError(L"Not allocmem\n"); + return FALSE; + } +#ifdef KMX_64BIT + filebase = buf + file_size * 2; +#else filebase = buf; +#endif - if(!ReadFile(hFile, filebase, sz, &sz, NULL)) { - Err(L"errReadFile"); - CloseHandle(hFile); + if (fread(filebase, 1, file_size, fp) < (size_t)file_size) { + KMX_LogError(L"Could not read file\n"); delete[] buf; + fclose(fp); return FALSE; } - CloseHandle(hFile); + fclose(fp); - if(!VerifyKeyboard(filebase, sz)) { - Err(L"errVerifyKeyboard"); + if (*((PKMX_DWORD)filebase) != (KMX_DWORD)FILEID_COMPILED) { delete[] buf; + KMX_LogError(L"Invalid file - signature is invalid\n"); return FALSE; } - kbp = FixupKeyboard(buf, filebase, sz); - if(!kbp) { - Err(L"errFixupKeyboard"); + if (!KMX_VerifyKeyboard(filebase, file_size)) { delete[] buf; + KMX_LogError(L"errVerifyKeyboard\n"); return FALSE; } - if(kbp->dwIdentifier != FILEID_COMPILED) { - Err(L"errNotFileID"); +#ifdef KMX_64BIT + kbp = CopyKeyboard(buf, filebase); +#else + kbp = KMX_FixupKeyboard(buf, filebase, file_size); +#endif + + if (!kbp) { delete[] buf; + KMX_LogError(L"errFixupKeyboard\n"); return FALSE; } - *lpKeyboard = kbp; - return TRUE; -} - -PWCHAR StringOffset(PBYTE base, DWORD offset) { - if(offset == 0) return NULL; - return (PWCHAR)(base + offset); + if (kbp->dwIdentifier != FILEID_COMPILED) { + delete[] buf; + KMX_LogError(L"errNotFileID\n"); + return FALSE; + } + *lpKeyboard = kbp; + return TRUE; } -LPKEYBOARD FixupKeyboard(PBYTE bufp, PBYTE base, DWORD dwFileSize) { - UNREFERENCED_PARAMETER(dwFileSize); - - DWORD i, j; - PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD) base; - PCOMP_GROUP cgp; +/** + * @brief check if the file has correct version + * @param filebase containing data of the input file + * @param file_size a size + * @return true if successful; + * false if not + */ +KMX_BOOL KMX_VerifyKeyboard(PKMX_BYTE filebase, KMX_DWORD file_size) { + KMX_DWORD i; + PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD)filebase; PCOMP_STORE csp; - PCOMP_KEY ckp; - LPKEYBOARD kbp = (LPKEYBOARD) bufp; - LPSTORE sp; - LPGROUP gp; - LPKEY kp; - - kbp->dpStoreArray = (LPSTORE) (base + ckbp->dpStoreArray); - kbp->dpGroupArray = (LPGROUP) (base + ckbp->dpGroupArray); - - for(sp = kbp->dpStoreArray, csp = (PCOMP_STORE) sp, i = 0; i < kbp->cxStoreArray; i++, sp++, csp++) { - sp->dpName = StringOffset(base, csp->dpName); - sp->dpString = StringOffset(base, csp->dpString); - } - - for(gp = kbp->dpGroupArray, cgp = (PCOMP_GROUP) gp, i = 0; i < kbp->cxGroupArray; i++, gp++, cgp++) { - gp->dpName = StringOffset(base, cgp->dpName); - gp->dpKeyArray = (LPKEY) (base + cgp->dpKeyArray); - if(cgp->dpMatch != NULL) gp->dpMatch = (PWSTR) (base + cgp->dpMatch); - if(cgp->dpNoMatch != NULL) gp->dpNoMatch = (PWSTR) (base + cgp->dpNoMatch); - - for(kp = gp->dpKeyArray, ckp = (PCOMP_KEY) kp, j = 0; j < gp->cxKeyArray; j++, kp++, ckp++) { - kp->dpOutput = (PWSTR) (base + ckp->dpOutput); - kp->dpContext = (PWSTR) (base + ckp->dpContext); - } - } - return kbp; + // Check file version // + + if (ckbp->dwFileVersion < VERSION_MIN || ckbp->dwFileVersion > VERSION_MAX) { + // Old or new version -- identify the desired program version // + for (csp = (PCOMP_STORE)(filebase + ckbp->dpStoreArray), i = 0; i < ckbp->cxStoreArray; i++, csp++) { + if (csp->dwSystemID == TSS_COMPILEDVERSION) { + if (csp->dpString == 0) { + KMX_LogError(L"errWrongFileVersion:NULL"); + } else { + KMX_LogError(L"errWrongFileVersion:%10.10ls", (const PKMX_WCHAR)KMX_StringOffset((PKMX_BYTE)filebase, csp->dpString)); + } + return FALSE; + } + } + KMX_LogError(L"errWrongFileVersion"); + return FALSE; + } + return TRUE; } -BOOL VerifyKeyboard(LPBYTE filebase, DWORD sz) { - DWORD i; - PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD) filebase; - PCOMP_STORE csp; +/** + * @brief increment in a string + * @param p pointer to a character + * @return pointer to the incremented character + */ +PKMX_WCHAR KMX_incxstr(PKMX_WCHAR p) { + if (p == NULL || *p == 0) + return p; + if (*p != UC_SENTINEL) { + if (*p >= 0xD800 && *p <= 0xDBFF && *(p + 1) >= 0xDC00 && *(p + 1) <= 0xDFFF) + return p + 2; + return p + 1; + } + // UC_SENTINEL(FFFF) with UC_SENTINEL_EXTENDEDEND(0x10) ==> variable length + if (*(p + 1) == CODE_EXTENDED) { + p += 2; + while (*p && *p != UC_SENTINEL_EXTENDEDEND) + p++; + + if (*p == 0) + return p; + return p + 1; + } - // Check file version // - - if(ckbp->dwFileVersion < VERSION_MIN || - ckbp->dwFileVersion > VERSION_MAX) { - // Old or new version -- identify the desired program version // - for(csp = (PCOMP_STORE)(filebase + ckbp->dpStoreArray), i = 0; i < ckbp->cxStoreArray; i++, csp++) { - if(csp->dwSystemID == TSS_COMPILEDVERSION) { - wchar_t buf2[256]; - if(csp->dpString == 0) { - wsprintf(buf2, L"errWrongFileVersion:NULL"); - } else { - wsprintf(buf2, L"errWrongFileVersion:%10.10ls", StringOffset(filebase, csp->dpString)); - } - Err(buf2); - return FALSE; - } - } - Err(L"errWrongFileVersion"); - return FALSE; - } + if (*(p + 1) > CODE_LASTCODE || CODE__SIZE[*(p + 1)] == -1) { + return p + 1; + } + int deltaptr = 2 + CODE__SIZE[*(p + 1)]; - return TRUE; + // check for \0 between UC_SENTINEL(FFFF) and next printable character + for (int i = 0; i < deltaptr; i++) { + if (*p == 0) + return p; + p++; + } + return p; } -*/ \ No newline at end of file + +/** + * @brief open a file + * @param filename name of the file + * @param mode same as mode in fopen + * @return pointer to file. + * On error returns a null pointer + */ +FILE* Open_File(const KMX_CHAR* filename, const KMX_CHAR* mode) { +#ifdef _MSC_VER + std::string cpath = filename; //, cmode = mode; + std::replace(cpath.begin(), cpath.end(), '/', '\\'); + return fopen(cpath.c_str(), (const KMX_CHAR*)mode); +#else + return fopen(filename, mode); + std::string cpath, cmode; + cpath = (const KMX_CHAR*)filename; + cmode = (const KMX_CHAR*)mode; + return fopen(cpath.c_str(), cmode.c_str()); +#endif +}; diff --git a/linux/mcompile/keymap/mc_kmxfile.h b/linux/mcompile/keymap/mc_kmxfile.h index 2d82db90b1e..f89a240a774 100644 --- a/linux/mcompile/keymap/mc_kmxfile.h +++ b/linux/mcompile/keymap/mc_kmxfile.h @@ -1,147 +1,83 @@ #pragma once -#include "km_types.h" +#ifndef MC_KMXFILE_H +#define MC_KMXFILE_H -KMX_DWORD TEST; +#include "km_types.h" +#include +#include "mcompile.h" #ifndef _KMXFILE_H #define _KMXFILE_H -typedef struct tagSTORE { - KMX_DWORD dwSystemID; - PKMX_WCHART dpName; - PKMX_WCHART dpString; -} STORE, *LPSTORE; - - -typedef struct tagKEY { - KMX_WCHAR Key; - KMX_DWORD Line; - KMX_DWORD ShiftFlags; - PKMX_WCHART dpOutput; - PKMX_WCHART dpContext; -} KEY, *LPKEY; - - -typedef struct tagGROUP { - PKMX_WCHART dpName; - LPKEY dpKeyArray; // [LPKEY] address of first item in key array - PKMX_WCHART dpMatch; - PKMX_WCHART dpNoMatch; - KMX_DWORD cxKeyArray; // in array entries - KMX_BOOL fUsingKeys; // group(xx) [using keys] <-- specified or not -} GROUP, *LPGROUP; - - - -typedef struct tagKEYBOARD { - KMX_DWORD dwIdentifier; // Keyman compiled keyboard id - - KMX_DWORD dwFileVersion; // Version of the file - Keyman 4.0 is 0x0400 - - KMX_DWORD dwCheckSum; // As stored in keyboard. DEPRECATED as of 16.0 - KMX_DWORD xxkbdlayout; // as stored in HKEY_LOCAL_MACHINE//system//currentcontrolset//control//keyboard layouts - KMX_DWORD IsRegistered; // layout id, from same registry key - KMX_DWORD version; // keyboard version - - KMX_DWORD cxStoreArray; // in array entries - KMX_DWORD cxGroupArray; // in array entries - - LPSTORE dpStoreArray; // [LPSTORE] address of first item in store array, from start of file - LPGROUP dpGroupArray; // [LPGROUP] address of first item in group array, from start of file - - KMX_DWORD StartGroup[2]; // index of starting groups [2 of them] - // Ansi=0, Unicode=1 +typedef struct KMX_tagSTORE { + KMX_DWORD dwSystemID; + PKMX_WCHAR dpName; + PKMX_WCHAR dpString; +} KMX_STORE, *LPKMX_STORE; - KMX_DWORD dwFlags; // Flags for the keyboard file - - KMX_DWORD dwHotKey; // standard windows hotkey (hiword=shift/ctrl/alt stuff, loword=vkey) - - //PKMX_WCHART dpName; // offset of name - //PKMX_WCHART dpLanguageName; // offset of language name; - //PKMX_WCHART dpCopyright; // offset of copyright - //PKMX_WCHART dpMessage; // offset of message in Keyboard About box - - KMX_DWORD dpBitmapOffset; // 0038 offset of the bitmaps in the file - KMX_DWORD dwBitmapSize; // 003C size in bytes of the bitmaps - //HBITMAP hBitmap; // handle to the bitmap in the file; -} KEYBOARD, *LPKEYBOARD; - -KMX_BOOL LoadKeyboard(LPKMX_WCHART fileName, LPKEYBOARD *lpKeyboard); // _S2 LPKEYBOARD ok to leave as is?? - -#endif - - - - - - -//---------------------old---------------------------------------- -/* -#include - -#ifndef _KMXFILE_H -#define _KMXFILE_H +typedef struct KMX_tagKEY { + KMX_WCHAR Key; + KMX_DWORD Line; + KMX_DWORD ShiftFlags; + PKMX_WCHAR dpOutput; + PKMX_WCHAR dpContext; +} KMX_KEY, *LPKMX_KEY; -typedef struct tagSTORE { - DWORD dwSystemID; - PWSTR dpName; - PWSTR dpString; -} STORE, *LPSTORE; +typedef struct KMX_tagGROUP { + KMX_WCHAR* dpName; + LPKMX_KEY dpKeyArray; // [LPKEY] address of first item in key array + PKMX_WCHAR dpMatch; + PKMX_WCHAR dpNoMatch; + KMX_DWORD cxKeyArray; // in array entries + int32_t fUsingKeys; // group(xx) [using keys] <-- specified or not +} KMX_GROUP, *LPKMX_GROUP; -typedef struct tagKEY { - WCHAR Key; - DWORD Line; - DWORD ShiftFlags; - PWSTR dpOutput; - PWSTR dpContext; -} KEY, *LPKEY; +typedef struct KMX_tagKEYBOARD { + KMX_DWORD dwIdentifier; // Keyman compiled keyboard id + KMX_DWORD dwFileVersion; // Version of the file - Keyman 4.0 is 0x0400 -typedef struct tagGROUP { - PWSTR dpName; - LPKEY dpKeyArray; // [LPKEY] address of first item in key array - PWSTR dpMatch; - PWSTR dpNoMatch; - DWORD cxKeyArray; // in array entries - BOOL fUsingKeys; // group(xx) [using keys] <-- specified or not -} GROUP, *LPGROUP; + KMX_DWORD dwCheckSum; // As stored in keyboard. DEPRECATED as of 16.0 + KMX_DWORD xxkbdlayout; // as stored in HKEY_LOCAL_MACHINE//system//currentcontrolset//control//keyboard layouts + KMX_DWORD IsRegistered; // layout id, from same registry key + KMX_DWORD version; // keyboard version + KMX_DWORD cxStoreArray; // in array entries + KMX_DWORD cxGroupArray; // in array entries -typedef struct tagKEYBOARD { - DWORD dwIdentifier; // Keyman compiled keyboard id + LPKMX_STORE dpStoreArray; // [LPSTORE] address of first item in store array, from start of file + LPKMX_GROUP dpGroupArray; // [LPGROUP] address of first item in group array, from start of file - DWORD dwFileVersion; // Version of the file - Keyman 4.0 is 0x0400 + KMX_DWORD StartGroup[2]; // index of starting groups [2 of them] + // Ansi=0, Unicode=1 - DWORD dwCheckSum; // As stored in keyboard. DEPRECATED as of 16.0 - DWORD xxkbdlayout; // as stored in HKEY_LOCAL_MACHINE//system//currentcontrolset//control//keyboard layouts - DWORD IsRegistered; // layout id, from same registry key - DWORD version; // keyboard version + KMX_DWORD dwFlags; // Flags for the keyboard file - DWORD cxStoreArray; // in array entries - DWORD cxGroupArray; // in array entries + KMX_DWORD dwHotKey; // standard windows hotkey (hiword=shift/ctrl/alt stuff, loword=vkey) - LPSTORE dpStoreArray; // [LPSTORE] address of first item in store array, from start of file - LPGROUP dpGroupArray; // [LPGROUP] address of first item in group array, from start of file + // PWSTR dpName; // offset of name + // PWSTR dpLanguageName; // offset of language name; + // PWSTR dpCopyright; // offset of copyright + // PWSTR dpMessage; // offset of message in Keyboard About box - DWORD StartGroup[2]; // index of starting groups [2 of them] - // Ansi=0, Unicode=1 + KMX_DWORD dpBitmapOffset; // 0038 offset of the bitmaps in the file + KMX_DWORD dwBitmapSize; // 003C size in bytes of the bitmaps + //HBITMAP hBitmap; // handle to the bitmap in the file; +} KMX_KEYBOARD, *LPKMX_KEYBOARD; - DWORD dwFlags; // Flags for the keyboard file - DWORD dwHotKey; // standard windows hotkey (hiword=shift/ctrl/alt stuff, loword=vkey) +/** @brief load a keyboard kmx-file */ +KMX_BOOL KMX_LoadKeyboard(KMX_CHAR* fileName, LPKMX_KEYBOARD* lpKeyboard); - //PWSTR dpName; // offset of name - //PWSTR dpLanguageName; // offset of language name; - //PWSTR dpCopyright; // offset of copyright - //PWSTR dpMessage; // offset of message in Keyboard About box +/** @brief save keyboard to file */ +KMX_BOOL KMX_SaveKeyboard(LPKMX_KEYBOARD kbd, KMX_CHAR* filename); - DWORD dpBitmapOffset; // 0038 offset of the bitmaps in the file - DWORD dwBitmapSize; // 003C size in bytes of the bitmaps - //HBITMAP hBitmap; // handle to the bitmap in the file; -} KEYBOARD, *LPKEYBOARD; +/** @brief increment in a string */ +PKMX_WCHAR KMX_incxstr(PKMX_WCHAR p); -BOOL LoadKeyboard(LPWSTR fileName, LPKEYBOARD *lpKeyboard); +/** @brief open a file */ +FILE* Open_File(const KMX_CHAR* filename, const KMX_CHAR* mode); -#endif -*/ +#endif // _KMXFILE_H +#endif /*MC_KMXFILE_H*/ diff --git a/linux/mcompile/keymap/mc_savekeyboard.cpp b/linux/mcompile/keymap/mc_savekeyboard.cpp deleted file mode 100644 index 497f2d4379d..00000000000 --- a/linux/mcompile/keymap/mc_savekeyboard.cpp +++ /dev/null @@ -1,423 +0,0 @@ -#include "mc_savekeyboard.h" - - -/*BOOL SaveKeyboard(LPKEYBOARD kbd, PWSTR filename) { - HANDLE hOutfile = CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL); - if(hOutfile == INVALID_HANDLE_VALUE) { - LogError(L"Failed to create output file (%d)", GetLastError()); - return FALSE; - } - - DWORD err = WriteCompiledKeyboard(kbd, hOutfile, FALSE); - - CloseHandle(hOutfile); - - if(err != CERR_None) { - LogError(L"Failed to write compiled keyboard with error %d", err); - DeleteFile(filename); - return FALSE; - } - - return TRUE; -}*/ - -/*DWORD WriteCompiledKeyboard(LPKEYBOARD fk, HANDLE hOutfile, BOOL FSaveDebug) -{ - LPGROUP fgp; - LPSTORE fsp; - LPKEY fkp; - - PCOMP_KEYBOARD ck; - PCOMP_GROUP gp; - PCOMP_STORE sp; - PCOMP_KEY kp; - PBYTE buf; - DWORD size, offset; - DWORD i, j; - - // Calculate how much memory to allocate - - size = sizeof(COMP_KEYBOARD) + - fk->cxGroupArray * sizeof(COMP_GROUP) + - fk->cxStoreArray * sizeof(COMP_STORE) + - //wcslen(fk->szName)*2 + 2 + - //wcslen(fk->szCopyright)*2 + 2 + - //wcslen(fk->szLanguageName)*2 + 2 + - //wcslen(fk->szMessage)*2 + 2 + - fk->dwBitmapSize; - - for(i = 0, fgp = fk->dpGroupArray; i < fk->cxGroupArray; i++, fgp++) { - if(fgp->dpName) - size += wcslen(fgp->dpName)*2 + 2; - size += fgp->cxKeyArray * sizeof(COMP_KEY); - for(j = 0, fkp = fgp->dpKeyArray; j < fgp->cxKeyArray; j++, fkp++) { - size += wcslen(fkp->dpOutput)*2 + 2; - size += wcslen(fkp->dpContext)*2 + 2; - } - - if( fgp->dpMatch ) size += wcslen(fgp->dpMatch)*2 + 2; - if( fgp->dpNoMatch ) size += wcslen(fgp->dpNoMatch)*2 + 2; - } - - for(i = 0; i < fk->cxStoreArray; i++) - { - size += wcslen(fk->dpStoreArray[i].dpString)*2 + 2; - if(fk->dpStoreArray[i].dpName) - size += wcslen(fk->dpStoreArray[i].dpName)*2 + 2; - } - - buf = new BYTE[size]; - if(!buf) return CERR_CannotAllocateMemory; - memset(buf, 0, size); - - ck = (PCOMP_KEYBOARD) buf; - - ck->dwIdentifier = FILEID_COMPILED; - - ck->dwFileVersion = fk->dwFileVersion; - ck->dwCheckSum = 0; // No checksum in 16.0, see #7276 - ck->KeyboardID = fk->xxkbdlayout; - ck->IsRegistered = fk->IsRegistered; - ck->cxStoreArray = fk->cxStoreArray; - ck->cxGroupArray = fk->cxGroupArray; - ck->StartGroup[0] = fk->StartGroup[0]; - ck->StartGroup[1] = fk->StartGroup[1]; - ck->dwHotKey = fk->dwHotKey; - - ck->dwFlags = fk->dwFlags; - - offset = sizeof(COMP_KEYBOARD); - - //ck->dpLanguageName = offset; - //wcscpy((PWSTR)(buf + offset), fk->szLanguageName); - //offset += wcslen(fk->szLanguageName)*2 + 2; - - //ck->dpName = offset; - //wcscpy((PWSTR)(buf + offset), fk->szName); - //offset += wcslen(fk->szName)*2 + 2; - - //ck->dpCopyright = offset; - //wcscpy((PWSTR)(buf + offset), fk->szCopyright); - //offset += wcslen(fk->szCopyright)*2 + 2; - - //ck->dpMessage = offset; - //wcscpy((PWSTR)(buf + offset), fk->szMessage); - //offset += wcslen(fk->szMessage)*2 + 2; - - ck->dpStoreArray = offset; - sp = (PCOMP_STORE)(buf+offset); - fsp = fk->dpStoreArray; - offset += sizeof(COMP_STORE) * ck->cxStoreArray; - for(i = 0; i < ck->cxStoreArray; i++, sp++, fsp++) { - sp->dwSystemID = fsp->dwSystemID; - sp->dpString = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fsp->dpString); // I3481 // I3641 - offset += wcslen(fsp->dpString)*2 + 2; - - if(!fsp->dpName) { - sp->dpName = 0; - } else { - sp->dpName = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fsp->dpName); // I3481 // I3641 - offset += wcslen(fsp->dpName)*2 + 2; - } - } - - ck->dpGroupArray = offset; - gp = (PCOMP_GROUP)(buf+offset); - fgp = fk->dpGroupArray; - - offset += sizeof(COMP_GROUP) * ck->cxGroupArray; - - for(i = 0; i < ck->cxGroupArray; i++, gp++, fgp++) { - gp->cxKeyArray = fgp->cxKeyArray; - gp->fUsingKeys = fgp->fUsingKeys; - - gp->dpMatch = gp->dpNoMatch = 0; - - if(fgp->dpMatch) { - gp->dpMatch = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fgp->dpMatch); // I3481 // I3641 - offset += wcslen(fgp->dpMatch)*2 + 2; - } - if(fgp->dpNoMatch) { - gp->dpNoMatch = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fgp->dpNoMatch); // I3481 // I3641 - offset += wcslen(fgp->dpNoMatch)*2 + 2; - } - - if(fgp->dpName) { - gp->dpName = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fgp->dpName); // I3481 // I3641 - offset += wcslen(fgp->dpName)*2 + 2; - } else { - gp->dpName = 0; - } - - gp->dpKeyArray = offset; - kp = (PCOMP_KEY) (buf + offset); - fkp = fgp->dpKeyArray; - offset += gp->cxKeyArray * sizeof(COMP_KEY); - for(j = 0; j < gp->cxKeyArray; j++, kp++, fkp++) { - kp->Key = fkp->Key; - kp->Line = fkp->Line; - kp->ShiftFlags = fkp->ShiftFlags; - kp->dpOutput = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fkp->dpOutput); // I3481 // I3641 - offset += wcslen(fkp->dpOutput)*2 + 2; - - - kp->dpContext = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fkp->dpContext); // I3481 // I3641 - offset += wcslen(fkp->dpContext)*2 + 2; - } - } - - if(fk->dwBitmapSize > 0) { - ck->dwBitmapSize = fk->dwBitmapSize; - ck->dpBitmapOffset = offset; - memcpy(buf + offset, ((PBYTE)fk) + fk->dpBitmapOffset, fk->dwBitmapSize); - offset += fk->dwBitmapSize; - } else { - ck->dwBitmapSize = 0; - ck->dpBitmapOffset = 0; - } - - if(offset != size) - { - delete[] buf; - return CERR_SomewhereIGotItWrong; - } - - WriteFile(hOutfile, buf, size, &offset, NULL); - - if(offset != size) - { - delete[] buf; - return CERR_UnableToWriteFully; - } - - delete[] buf; - - return CERR_None; -}*/ - - - - -//---------------------old---------------------------------------- -/*#include "pch.h" - -// These four errors are copied from kmn_compiler_errors.h, because WriteCompiledKeyboard is -// a clone of the compiler's equivalent function. However, the functions -// diverge, as mc_savekeyboard.cpp's version is copying from an existing -// compiled keyboard. The error codes have been kept consistent with those in -// kmn_compiler_errors.h -#define CERR_None 0x00000000 -#define CERR_CannotAllocateMemory 0x00008004 -#define CERR_UnableToWriteFully 0x00008007 -#define CERR_SomewhereIGotItWrong 0x00008009 - -DWORD WriteCompiledKeyboard(LPKEYBOARD fk, HANDLE hOutfile, BOOL FSaveDebug); - -BOOL SaveKeyboard(LPKEYBOARD kbd, PWSTR filename) { - HANDLE hOutfile = CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL); - if(hOutfile == INVALID_HANDLE_VALUE) { - LogError(L"Failed to create output file (%d)", GetLastError()); - return FALSE; - } - - DWORD err = WriteCompiledKeyboard(kbd, hOutfile, FALSE); - - CloseHandle(hOutfile); - - if(err != CERR_None) { - LogError(L"Failed to write compiled keyboard with error %d", err); - DeleteFile(filename); - return FALSE; - } - - return TRUE; -} - -DWORD WriteCompiledKeyboard(LPKEYBOARD fk, HANDLE hOutfile, BOOL FSaveDebug) -{ - LPGROUP fgp; - LPSTORE fsp; - LPKEY fkp; - - PCOMP_KEYBOARD ck; - PCOMP_GROUP gp; - PCOMP_STORE sp; - PCOMP_KEY kp; - PBYTE buf; - DWORD size, offset; - DWORD i, j; - - // Calculate how much memory to allocate - - size = sizeof(COMP_KEYBOARD) + - fk->cxGroupArray * sizeof(COMP_GROUP) + - fk->cxStoreArray * sizeof(COMP_STORE) + - //wcslen(fk->szName)*2 + 2 + - //wcslen(fk->szCopyright)*2 + 2 + - //wcslen(fk->szLanguageName)*2 + 2 + - //wcslen(fk->szMessage)*2 + 2 + - fk->dwBitmapSize; - - for(i = 0, fgp = fk->dpGroupArray; i < fk->cxGroupArray; i++, fgp++) { - if(fgp->dpName) - size += wcslen(fgp->dpName)*2 + 2; - size += fgp->cxKeyArray * sizeof(COMP_KEY); - for(j = 0, fkp = fgp->dpKeyArray; j < fgp->cxKeyArray; j++, fkp++) { - size += wcslen(fkp->dpOutput)*2 + 2; - size += wcslen(fkp->dpContext)*2 + 2; - } - - if( fgp->dpMatch ) size += wcslen(fgp->dpMatch)*2 + 2; - if( fgp->dpNoMatch ) size += wcslen(fgp->dpNoMatch)*2 + 2; - } - - for(i = 0; i < fk->cxStoreArray; i++) - { - size += wcslen(fk->dpStoreArray[i].dpString)*2 + 2; - if(fk->dpStoreArray[i].dpName) - size += wcslen(fk->dpStoreArray[i].dpName)*2 + 2; - } - - buf = new BYTE[size]; - if(!buf) return CERR_CannotAllocateMemory; - memset(buf, 0, size); - - ck = (PCOMP_KEYBOARD) buf; - - ck->dwIdentifier = FILEID_COMPILED; - - ck->dwFileVersion = fk->dwFileVersion; - ck->dwCheckSum = 0; // No checksum in 16.0, see #7276 - ck->KeyboardID = fk->xxkbdlayout; - ck->IsRegistered = fk->IsRegistered; - ck->cxStoreArray = fk->cxStoreArray; - ck->cxGroupArray = fk->cxGroupArray; - ck->StartGroup[0] = fk->StartGroup[0]; - ck->StartGroup[1] = fk->StartGroup[1]; - ck->dwHotKey = fk->dwHotKey; - - ck->dwFlags = fk->dwFlags; - - offset = sizeof(COMP_KEYBOARD); - - //ck->dpLanguageName = offset; - //wcscpy((PWSTR)(buf + offset), fk->szLanguageName); - //offset += wcslen(fk->szLanguageName)*2 + 2; - - //ck->dpName = offset; - //wcscpy((PWSTR)(buf + offset), fk->szName); - //offset += wcslen(fk->szName)*2 + 2; - - //ck->dpCopyright = offset; - //wcscpy((PWSTR)(buf + offset), fk->szCopyright); - //offset += wcslen(fk->szCopyright)*2 + 2; - - //ck->dpMessage = offset; - //wcscpy((PWSTR)(buf + offset), fk->szMessage); - //offset += wcslen(fk->szMessage)*2 + 2; - - ck->dpStoreArray = offset; - sp = (PCOMP_STORE)(buf+offset); - fsp = fk->dpStoreArray; - offset += sizeof(COMP_STORE) * ck->cxStoreArray; - for(i = 0; i < ck->cxStoreArray; i++, sp++, fsp++) { - sp->dwSystemID = fsp->dwSystemID; - sp->dpString = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fsp->dpString); // I3481 // I3641 - offset += wcslen(fsp->dpString)*2 + 2; - - if(!fsp->dpName) { - sp->dpName = 0; - } else { - sp->dpName = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fsp->dpName); // I3481 // I3641 - offset += wcslen(fsp->dpName)*2 + 2; - } - } - - ck->dpGroupArray = offset; - gp = (PCOMP_GROUP)(buf+offset); - fgp = fk->dpGroupArray; - - offset += sizeof(COMP_GROUP) * ck->cxGroupArray; - - for(i = 0; i < ck->cxGroupArray; i++, gp++, fgp++) { - gp->cxKeyArray = fgp->cxKeyArray; - gp->fUsingKeys = fgp->fUsingKeys; - - gp->dpMatch = gp->dpNoMatch = 0; - - if(fgp->dpMatch) { - gp->dpMatch = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fgp->dpMatch); // I3481 // I3641 - offset += wcslen(fgp->dpMatch)*2 + 2; - } - if(fgp->dpNoMatch) { - gp->dpNoMatch = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fgp->dpNoMatch); // I3481 // I3641 - offset += wcslen(fgp->dpNoMatch)*2 + 2; - } - - if(fgp->dpName) { - gp->dpName = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fgp->dpName); // I3481 // I3641 - offset += wcslen(fgp->dpName)*2 + 2; - } else { - gp->dpName = 0; - } - - gp->dpKeyArray = offset; - kp = (PCOMP_KEY) (buf + offset); - fkp = fgp->dpKeyArray; - offset += gp->cxKeyArray * sizeof(COMP_KEY); - for(j = 0; j < gp->cxKeyArray; j++, kp++, fkp++) { - kp->Key = fkp->Key; - kp->Line = fkp->Line; - kp->ShiftFlags = fkp->ShiftFlags; - kp->dpOutput = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fkp->dpOutput); // I3481 // I3641 - offset += wcslen(fkp->dpOutput)*2 + 2; - - - kp->dpContext = offset; - wcscpy_s((PWSTR)(buf+offset), (size-offset) / sizeof(WCHAR), fkp->dpContext); // I3481 // I3641 - offset += wcslen(fkp->dpContext)*2 + 2; - } - } - - if(fk->dwBitmapSize > 0) { - ck->dwBitmapSize = fk->dwBitmapSize; - ck->dpBitmapOffset = offset; - memcpy(buf + offset, ((PBYTE)fk) + fk->dpBitmapOffset, fk->dwBitmapSize); - offset += fk->dwBitmapSize; - } else { - ck->dwBitmapSize = 0; - ck->dpBitmapOffset = 0; - } - - if(offset != size) - { - delete[] buf; - return CERR_SomewhereIGotItWrong; - } - - WriteFile(hOutfile, buf, size, &offset, NULL); - - if(offset != size) - { - delete[] buf; - return CERR_UnableToWriteFully; - } - - delete[] buf; - - return CERR_None; -} -*/ \ No newline at end of file diff --git a/linux/mcompile/keymap/mc_savekeyboard.h b/linux/mcompile/keymap/mc_savekeyboard.h deleted file mode 100644 index 7ac15f4ff1a..00000000000 --- a/linux/mcompile/keymap/mc_savekeyboard.h +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once - -#include "km_types.h" -KMX_DWORD TEST3; -// this file is all new _S2 - -//#include "../../../common/include/km_types.h" - - -#define CERR_None 0x00000000 -#define CERR_CannotAllocateMemory 0x00008004 -#define CERR_UnableToWriteFully 0x00008007 -#define CERR_SomewhereIGotItWrong 0x00008009 -/* -DWORD WriteCompiledKeyboard(LPKEYBOARD fk, HANDLE hOutfile, BOOL FSaveDebug); -BOOL SaveKeyboard(LPKEYBOARD kbd, PWSTR filename) ; -DWORD WriteCompiledKeyboard(LPKEYBOARD fk, HANDLE hOutfile, BOOL FSaveDebug); -*/ \ No newline at end of file diff --git a/linux/mcompile/keymap/mcompile.cpp b/linux/mcompile/keymap/mcompile.cpp index b990f02806c..8c8d8b7c177 100644 --- a/linux/mcompile/keymap/mcompile.cpp +++ b/linux/mcompile/keymap/mcompile.cpp @@ -1,98 +1,88 @@ /* - Name: mcompile - Copyright: Copyright (C) SIL International. - Documentation: - Description: - Create Date: 24 Apr 2014 - - Modified Date: 8 Apr 2015 - Authors: mcdurdin - Related Files: - Dependencies: - - Bugs: - Todo: - Notes: - History: 24 Apr 2014 - mcdurdin - I4174 - V9 - mcompile logs should be stored in diag folder - 16 Jun 2014 - mcdurdin - I4273 - V9.0 - Convert keyboards to Unicode before installing - 23 Jun 2014 - mcdurdin - I4279 - V9.0 - mcompile fails to start when converting keyboard to Unicode - 03 Aug 2014 - mcdurdin - I4353 - V9.0 - mnemonic layout recompiler mixes up deadkey rules - 03 Aug 2014 - mcdurdin - I4327 - V9.0 - Mnemonic layout compiler follow-up - 31 Dec 2014 - mcdurdin - I4549 - V9.0 - Mnemonic layout recompiler does not translate Lctrl Ralt for deadkeys correctly - 06 Feb 2015 - mcdurdin - I4552 - V9.0 - Add mnemonic recompile option to ignore deadkeys - 08 Apr 2015 - mcdurdin - I4651 - V9.0 - Mnemonic layout recompiler maps AltGr+VK_BKSLASH rather than VK_OEM_102 -*/ -// -// m-to-p.cpp : Defines the entry point for the console application. -// -// Note: this program deliberately leaks memory as it has a very short life cycle and managing the memory allocations -// for the subcomponents of the compiled keyboard is an unnecessary optimisation. Just so you know. -// - -#include "pch.h" -#include - -#include -#include -#include + * Keyman is copyright (C) 2004 - 2024 SIL International. MIT License. + * + * Mnemonic layout support for Linux + * + * Defines the entry point for the console application. + * + * Note: this program deliberately leaks memory as it has a very short life cycle and managing the memory allocations + * for the subcomponents of the compiled keyboard is an unnecessary optimisation. Just so you know. + */ + +#include "mcompile.h" + +/** @brief convert mnemonic keyboard layout to positional keyboard layout and translate keyboard */ +KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint argc, gchar* argv[]); + +/** @brief Collect the key data, translate it to kmx and append to the existing keyboard */ +bool KMX_ImportRules(LPKMX_KEYBOARD kp, vec_dword_3D& all_vector, GdkKeymap** keymap, std::vector* KMX_FDeadkeys, KMX_BOOL bDeadkeyConversion); // I4353 // I4327 + +/** @brief start of mcompile; load, convert and save keyboard */ +int run(int argc, char* argv[]); + +/** @brief return an array of [usvk, ch_out] pairs: all existing combinations of a deadkey + character for the underlying keyboard */ +int KMX_GetDeadkeys(vec_dword_2D& dk_Table, KMX_WORD deadkey, KMX_WORD* outputPairs, GdkKeymap* keymap); + +std::vector KMX_FDeadkeys; // I4353 + +#define _countof(a) (sizeof(a) / sizeof(*(a))) + +/** + * @brief main function for mcompile for Windows, Linux, Mac + * @param argc number of commandline arguments + * @param argv pointer to commandline arguments: executable, inputfile, outputfile + * @return 0 on success + */ +#if defined(_WIN32) || defined(_WIN64) + int wmain(int argc, wchar_t* argv[]) { +/** + * TODO for cross platform use: if we want to use wmain instead of main: + * inside wmain convert wchar_t* argv[] to char* argv_ch[] + * to be able to use run(int argc, char* argv[]) + */ +#else // LINUX + int main(int argc, char* argv[]) { +#endif + + run(argc, argv); +} + + +/** + * @brief start of mcompile; load, convert and save keyboard + * @param argc number of commandline arguments + * @param argv pointer to commandline arguments: executable, inputfile, outputfile + * @return 0 on success, + * 1 for wrong usage of calling parameters, + * 3 if unable to load keyboard + */ +int run(int argc, char* argv[]) { + + int bDeadkeyConversion = 0; + + if (argc > 1) + bDeadkeyConversion = (strcmp(argv[1], "-d") == 0); // I4552 -BOOL DoConvert(LPKEYBOARD kbd, PWSTR kbid, BOOL bDeadkeyConversion); -BOOL SaveKeyboard(LPKEYBOARD kbd, PWSTR filename); -bool ImportRules(WCHAR *kbid, LPKEYBOARD kp, std::vector *FDeadkeys, BOOL bDeadkeyConversion); // I4353 // I4327 -BOOL ConvertKeyboardToUnicode(LPKEYBOARD kbd); // I4273 -int run(int argc, wchar_t * argv[]); - -std::vector FDeadkeys; // I4353 - -#define KEYMAN_SENTRY_LOGGER_DESKTOP_ENGINE_MCOMPILE KEYMAN_SENTRY_LOGGER_DESKTOP_ENGINE ".mcompile" - -int wmain(int argc, wchar_t * argv[]) -{ - return keyman_sentry_wmain(false, KEYMAN_SENTRY_LOGGER_DESKTOP_ENGINE_MCOMPILE, argc, argv, run); -} + int n = (bDeadkeyConversion ? 2 : 1); -int run(int argc, wchar_t * argv[]) -{ - if(argc < 3 || (argc < 5 && wcscmp(argv[1], L"-u") != 0)) { // I4273 + if (argc < 3 || argc > 4 || (argc - n) != 2) { // I4273// I4273 printf( - "Usage: mcompile -u infile.kmx outfile.kmx\n" - " mcompile [-d] infile.kmx kbdfile.dll kbid outfile.kmx\n" - " With -u parameter, converts keyboard from ANSI to Unicode\n" - " Otherwise, mcompile converts a Keyman mnemonic layout to a\n" - " positional one based on the Windows keyboard\n" - " layout file given by kbdfile.dll\n\n" - " kbid should be a hexadecimal number e.g. 409 for US English\n" - " -d convert deadkeys to plain keys\n"); // I4552 + "Usage: \tmcompile [-d] infile.kmx outfile.kmx\n" + " \tmcompile -u ... (not available for Linux)\n " + " \tmcompile converts a Keyman mnemonic layout to\n" + " \ta positional one based on the currently used \n" + " \tLinux keyboard layout\n" + " \t(-d convert deadkeys to plain keys) \n \n"); // I4552 return 1; } - if(wcscmp(argv[1], L"-u") == 0) { // I4273 - wchar_t *infile = argv[2], *outfile = argv[3]; - - LPKEYBOARD kmxfile; - - if(!LoadKeyboard(infile, &kmxfile)) { - LogError(L"Failed to load keyboard (%d)", GetLastError()); - return 3; - } - - if(ConvertKeyboardToUnicode(kmxfile)) { - SaveKeyboard(kmxfile, outfile); - } - - //DeleteReallocatedPointers(kmxfile); :TODO - delete[] kmxfile; - - return 0; // I4279 - } - - int bDeadkeyConversion = wcscmp(argv[1], L"-d") == 0; // I4552 - int n = (bDeadkeyConversion ? 2 : 1); + // -u option is not available for Linux and macOS - wchar_t *infile = argv[n], *indll = argv[n+1], *kbid = argv[n+2], *outfile = argv[n+3]; + KMX_CHAR* infile = argv[n]; + KMX_CHAR* outfile = argv[n + 1]; - wprintf(L"mcompile%ls \"%ls\" \"%ls\" \"%ls\" \"%ls\"\n", bDeadkeyConversion ? L" -d":L"", infile, indll, kbid, outfile); // I4174 + printf("mcompile%s \"%s\" \"%s\"\n", bDeadkeyConversion ? " -d" : "", infile, outfile); // I4174 // 1. Load the keyman keyboard file @@ -117,52 +107,33 @@ int run(int argc, wchar_t * argv[]) // switch the shift state from the VIRTUALCHARKEY to VIRTUALKEY, without changing any // other properties of the key. // - // 3. Write the new keyman keyboard file - if(!LoadNewLibrary(indll)) { - LogError(L"Failed to load keyboard DLL (%d)", GetLastError()); - return 2; - } + LPKMX_KEYBOARD kmxfile; - LPKEYBOARD kmxfile; - - if(!LoadKeyboard(infile, &kmxfile)) { - LogError(L"Failed to load keyboard (%d)", GetLastError()); + if (!KMX_LoadKeyboard(infile, &kmxfile)) { + KMX_LogError(L"Failed to load keyboard (%d)\n", errno); return 3; } - if(DoConvert(kmxfile, kbid, bDeadkeyConversion)) { // I4552 - SaveKeyboard(kmxfile, outfile); +#if defined(_WIN32) || defined(_WIN64) + /*if (DoConvert(kmxfile, kbid, bDeadkeyConversion)) { // I4552F + KMX_SaveKeyboard(kmxfile, outfile); + }*/ + +#else // LINUX + if (KMX_DoConvert(kmxfile, bDeadkeyConversion, argc, (gchar**)argv)) { // I4552F + KMX_SaveKeyboard(kmxfile, outfile); } - //DeleteReallocatedPointers(kmxfile); :TODO +#endif + // DeleteReallocatedPointers(kmxfile); :TODO // _S2 not my ToDo :-) delete kmxfile; - - return 0; + return 0; } - -// -// Map of all US English virtual key codes that we can translate -// -const WORD VKMap[] = { - 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z', - '0','1','2','3','4','5','6','7','8','9', - VK_SPACE, - VK_ACCENT, VK_HYPHEN, VK_EQUAL, - VK_LBRKT, VK_RBRKT, VK_BKSLASH, - VK_COLON, VK_QUOTE, - VK_COMMA, VK_PERIOD, VK_SLASH, - VK_xDF, VK_OEM_102, - 0 -}; - - -// // Map of all shift states that we will work with -// -const UINT VKShiftState[] = {0, K_SHIFTFLAG, LCTRLFLAG|RALTFLAG, K_SHIFTFLAG|LCTRLFLAG|RALTFLAG, 0xFFFF}; +const KMX_DWORD VKShiftState[] = {0, K_SHIFTFLAG, LCTRLFLAG | RALTFLAG, K_SHIFTFLAG | LCTRLFLAG | RALTFLAG, 0xFFFF}; // // TranslateKey @@ -170,127 +141,191 @@ const UINT VKShiftState[] = {0, K_SHIFTFLAG, LCTRLFLAG|RALTFLAG, K_SHIFTFLAG|LCT // For each key rule on the keyboard, remap its key to the // correct shift state and key. Adjust the LCTRL+RALT -> RALT if necessary // -void TranslateKey(LPKEY key, WORD vk, UINT shift, WCHAR ch) { +/** + * @brief translate each key of a group: remap the content of a key (key->Key) of the US keyboard to a character (ch) + * @param key pointer to a key + * @param vk a keyvalue of the US keyboard + * @param shift shiftstate + * @param ch character of the underlying keyboard to be remapped + */ +void KMX_TranslateKey(LPKMX_KEY key, KMX_WORD vk, KMX_DWORD shift, KMX_WCHAR ch) { // The weird LCTRL+RALT is Windows' way of mapping the AltGr key. // We store that as just RALT, and use the option "Simulate RAlt with Ctrl+Alt" // to provide an alternate.. - if((shift & (LCTRLFLAG|RALTFLAG)) == (LCTRLFLAG|RALTFLAG)) + if ((shift & (LCTRLFLAG | RALTFLAG)) == (LCTRLFLAG | RALTFLAG)) shift &= ~LCTRLFLAG; - if(key->ShiftFlags == 0 && key->Key == ch) { + if (key->ShiftFlags == 0 && key->Key == ch) { // Key is a mnemonic key with no shift state defined. // Remap the key according to the character on the key cap. - //LogError(L"Converted mnemonic rule on line %d, + '%c' TO + [%x K_%d]", key->Line, key->Key, shift, vk); + // KMX_LogError(L"Converted mnemonic rule on line %d, + '%c' TO + [%x K_%d]", key->Line, key->Key, shift, vk); key->ShiftFlags = ISVIRTUALKEY | shift; key->Key = vk; - } else if(key->ShiftFlags & VIRTUALCHARKEY && key->Key == ch) { + } else if (key->ShiftFlags & VIRTUALCHARKEY && key->Key == ch) { // Key is a virtual character key with a hard-coded shift state. // Do not remap the shift state, just move the key. // This will not result in 100% wonderful mappings as there could // be overlap, depending on how keys are arranged on the target layout. // But that is up to the designer. - //LogError(L"Converted mnemonic virtual char key rule on line %d, + [%x '%c'] TO + [%x K_%d]", key->Line, key->ShiftFlags, key->Key, key->ShiftFlags & ~VIRTUALCHARKEY, vk); + // KMX_LogError(L"Converted mnemonic virtual char key rule on line %d, + [%x '%c'] TO + [%x K_%d]", key->Line, key->ShiftFlags, key->Key, key->ShiftFlags & ~VIRTUALCHARKEY, vk); key->ShiftFlags &= ~VIRTUALCHARKEY; key->Key = vk; } } -void TranslateGroup(LPGROUP group, WORD vk, UINT shift, WCHAR ch) { - for(unsigned int i = 0; i < group->cxKeyArray; i++) { - TranslateKey(&group->dpKeyArray[i], vk, shift, ch); +/** + * @brief translate a group of a keyboard + * @param group pointer to a keyboard group + * @param vk a keyvalue of the US keyboard + * @param shift shiftstate + * @param ch character of the underlying keyboard to be remapped + */ +void KMX_TranslateGroup(LPKMX_GROUP group, KMX_WORD vk, KMX_DWORD shift, KMX_WCHAR ch) { + for (unsigned int i = 0; i < group->cxKeyArray; i++) { + KMX_TranslateKey(&group->dpKeyArray[i], vk, shift, ch); } } -void TranslateKeyboard(LPKEYBOARD kbd, WORD vk, UINT shift, WCHAR ch) { - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - TranslateGroup(&kbd->dpGroupArray[i], vk, shift, ch); +/** + * @brief translate a keyboard + * @param kbd pointer to the US keyboard + * @param vk a keyvalue of the US keyboard + * @param shift shiftstate + * @param ch character of the underlying keyboard to be remapped + */ +void KMX_TranslateKeyboard(LPKMX_KEYBOARD kbd, KMX_WORD vk, KMX_DWORD shift, KMX_WCHAR ch) { + for (unsigned int i = 0; i < kbd->cxGroupArray; i++) { + if (kbd->dpGroupArray[i].fUsingKeys) { + KMX_TranslateGroup(&kbd->dpGroupArray[i], vk, shift, ch); } } } -void ReportUnconvertedKeyRule(LPKEY key) { - if(key->ShiftFlags == 0) { - LogError(L"Did not find a match for mnemonic rule on line %d, + '%c' > ...", key->Line, key->Key); - } else if(key->ShiftFlags & VIRTUALCHARKEY) { - LogError(L"Did not find a match for mnemonic virtual character key rule on line %d, + [%x '%c'] > ...", key->Line, key->ShiftFlags, key->Key); +/** + * @brief check key for unconverted key rules + * @param key pointer to a key + */ +void KMX_ReportUnconvertedKeyRule(LPKMX_KEY key) { + if (key->ShiftFlags == 0) { + // KMX_LogError(L"Did not find a match for mnemonic rule on line %d, + '%c' > ...", key->Line, key->Key); + } else if (key->ShiftFlags & VIRTUALCHARKEY) { + KMX_LogError(L"Did not find a match for mnemonic virtual character key rule on line %d, + [%x '%c'] > ...", key->Line, key->ShiftFlags, key->Key); } } -void ReportUnconvertedGroupRules(LPGROUP group) { - for(unsigned int i = 0; i < group->cxKeyArray; i++) { - ReportUnconvertedKeyRule(&group->dpKeyArray[i]); +/** + * @brief check a group for unconverted rules + * @param group pointer to a keyboard group + */ +void KMX_ReportUnconvertedGroupRules(LPKMX_GROUP group) { + for (unsigned int i = 0; i < group->cxKeyArray; i++) { + KMX_ReportUnconvertedKeyRule(&group->dpKeyArray[i]); } } -void ReportUnconvertedKeyboardRules(LPKEYBOARD kbd) { - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - ReportUnconvertedGroupRules(&kbd->dpGroupArray[i]); +/** + * @brief check a keyboard for unconverted rules + * @param kbd pointer to the US keyboard + */ +void KMX_ReportUnconvertedKeyboardRules(LPKMX_KEYBOARD kbd) { + for (unsigned int i = 0; i < kbd->cxGroupArray; i++) { + if (kbd->dpGroupArray[i].fUsingKeys) { + KMX_ReportUnconvertedGroupRules(&kbd->dpGroupArray[i]); } } } -void TranslateDeadkeyKey(LPKEY key, WCHAR deadkey, WORD vk, UINT shift, WORD ch) { - if((key->ShiftFlags == 0 || key->ShiftFlags & VIRTUALCHARKEY) && key->Key == ch) { +/** + * @brief remap the content of a key (key->dpContext) of the US keyboard to a deadkey sequence + * @param key pointer to a key + * @param deadkey a deadkey to be remapped + * @param vk a keyvalue of the US keyboard + * @param shift shiftstate + * @param ch character of the underlying keyboard + */ +void KMX_TranslateDeadkeyKey(LPKMX_KEY key, KMX_WCHAR deadkey, KMX_WORD vk, KMX_DWORD shift, KMX_WORD ch) { + if ((key->ShiftFlags == 0 || key->ShiftFlags & VIRTUALCHARKEY) && key->Key == ch) { // The weird LCTRL+RALT is Windows' way of mapping the AltGr key. // We store that as just RALT, and use the option "Simulate RAlt with Ctrl+Alt" // to provide an alternate.. - if((shift & (LCTRLFLAG|RALTFLAG)) == (LCTRLFLAG|RALTFLAG)) // I4327 + if ((shift & (LCTRLFLAG | RALTFLAG)) == (LCTRLFLAG | RALTFLAG)) // I4327 shift &= ~LCTRLFLAG; - if(key->ShiftFlags == 0) { - //LogError("Converted mnemonic rule on line %d, + '%c' TO dk(%d) + [%x K_%d]", key->Line, key->Key, deadkey, shift, vk); + if (key->ShiftFlags == 0) { + // KMX_LogError(L"Converted mnemonic rule on line %d, + '%c' TO dk(%d) + [%x K_%d]", key->Line, key->Key, deadkey, shift, vk); key->ShiftFlags = ISVIRTUALKEY | shift; } else { - //LogError("Converted mnemonic virtual char key rule on line %d, + [%x '%c'] TO dk(%d) + [%x K_%d]", key->Line, key->ShiftFlags, key->Key, deadkey, key->ShiftFlags & ~VIRTUALCHARKEY, vk); + // KMX_LogError(L"Converted mnemonic virtual char key rule on line %d, + [%x '%c'] TO dk(%d) + [%x K_%d]", key->Line, key->ShiftFlags, key->Key, deadkey, key->ShiftFlags & ~VIRTUALCHARKEY, vk); key->ShiftFlags &= ~VIRTUALCHARKEY; } - int len = wcslen(key->dpContext); - PWSTR context = new WCHAR[len + 4]; - memcpy(context, key->dpContext, len * sizeof(WCHAR)); + int len = u16len(key->dpContext); + + PKMX_WCHAR context = new KMX_WCHAR[len + 4]; + memcpy(context, key->dpContext, len * sizeof(KMX_WCHAR)); context[len] = UC_SENTINEL; - context[len+1] = CODE_DEADKEY; - context[len+2] = deadkey; - context[len+3] = 0; + context[len + 1] = CODE_DEADKEY; + context[len + 2] = deadkey; + context[len + 3] = 0; key->dpContext = context; key->Key = vk; } } -void TranslateDeadkeyGroup(LPGROUP group, WCHAR deadkey, WORD vk, UINT shift, WORD ch) { - for(unsigned int i = 0; i < group->cxKeyArray; i++) { - TranslateDeadkeyKey(&group->dpKeyArray[i], deadkey, vk, shift, ch); - } -} - -void TranslateDeadkeyKeyboard(LPKEYBOARD kbd, WCHAR deadkey, WORD vk, UINT shift, WORD ch) { - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - TranslateDeadkeyGroup(&kbd->dpGroupArray[i], deadkey, vk, shift, ch); +/** + * @brief translate a group + * @param group pointer to a keyboard group + * @param deadkey deadkey to be remapped + * @param vk a keyvalue of the US keyboard + * @param shift shiftstate + * @param ch character of the underlying keyboard + */ +void KMX_TranslateDeadkeyGroup(LPKMX_GROUP group, KMX_WCHAR deadkey, KMX_WORD vk, KMX_DWORD shift, KMX_WORD ch) { + for (unsigned int i = 0; i < group->cxKeyArray; i++) { + KMX_TranslateDeadkeyKey(&group->dpKeyArray[i], deadkey, vk, shift, ch); + } +} + +/** + * @brief translate a keyboard + * @param kbd pointer to the US keyboard + * @param deadkey a deadkey to be remapped + * @param vk a keyvalue of the US keyboard + * @param shift shiftstate + * @param ch character of the underlying keyboard + */ +void KMX_TranslateDeadkeyKeyboard(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey, KMX_WORD vk, KMX_DWORD shift, KMX_WORD ch) { + for (unsigned int i = 0; i < kbd->cxGroupArray; i++) { + if (kbd->dpGroupArray[i].fUsingKeys) { + KMX_TranslateDeadkeyGroup(&kbd->dpGroupArray[i], deadkey, vk, shift, ch); } } } -void AddDeadkeyRule(LPKEYBOARD kbd, WCHAR deadkey, WORD vk, UINT shift) { +/** + * @brief add a deadkey rule + * @param kbd pointer to the US keyboard + * @param deadkey a deadkey to be added + * @param vk a keyvalue of the US keyboard + * @param shift shiftstate + */ +void KMX_AddDeadkeyRule(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey, KMX_WORD vk, KMX_DWORD shift) { // The weird LCTRL+RALT is Windows' way of mapping the AltGr key. // We store that as just RALT, and use the option "Simulate RAlt with Ctrl+Alt" // to provide an alternate.. - if((shift & (LCTRLFLAG|RALTFLAG)) == (LCTRLFLAG|RALTFLAG)) // I4549 + if ((shift & (LCTRLFLAG | RALTFLAG)) == (LCTRLFLAG | RALTFLAG)) // I4549 shift &= ~LCTRLFLAG; - // If the first group is not a matching-keys group, then we need to add into // each subgroup, otherwise just the match group - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - LPKEY keys = new KEY[kbd->dpGroupArray[i].cxKeyArray + 1]; - memcpy(keys+1, kbd->dpGroupArray[i].dpKeyArray, kbd->dpGroupArray[i].cxKeyArray * sizeof(KEY)); - keys[0].dpContext = new WCHAR[1]; + for (unsigned int i = 0; i < kbd->cxGroupArray; i++) { + if (kbd->dpGroupArray[i].fUsingKeys) { + LPKMX_KEY keys = new KMX_KEY[kbd->dpGroupArray[i].cxKeyArray + 1]; + memcpy(keys + 1, kbd->dpGroupArray[i].dpKeyArray, kbd->dpGroupArray[i].cxKeyArray * sizeof(KMX_KEY)); + keys[0].dpContext = new KMX_WCHAR[1]; keys[0].dpContext[0] = 0; - keys[0].dpOutput = new WCHAR[4]; // UC_SENTINEL, CODE_DEADKEY, deadkey_value, 0 + keys[0].dpOutput = new KMX_WCHAR[4]; keys[0].dpOutput[0] = UC_SENTINEL; keys[0].dpOutput[1] = CODE_DEADKEY; keys[0].dpOutput[2] = deadkey; // TODO: translate to unique index @@ -300,42 +335,52 @@ void AddDeadkeyRule(LPKEYBOARD kbd, WCHAR deadkey, WORD vk, UINT shift) { keys[0].ShiftFlags = shift | ISVIRTUALKEY; kbd->dpGroupArray[i].dpKeyArray = keys; kbd->dpGroupArray[i].cxKeyArray++; - //LogError("Add deadkey rule: + [%d K_%d] > dk(%d)", shift, vk, deadkey); - if(i == kbd->StartGroup[1]) break; // If this is the initial group, that's all we need to do. + KMX_LogError(L"Add deadkey rule: + [%d K_%d] > dk(%d)", shift, vk, deadkey); + if (i == kbd->StartGroup[1]) + break; // If this is the initial group, that's all we need to do. } } } -WCHAR ScanXStringForMaxDeadkeyID(LPWSTR str) { - WCHAR dkid = 0; - while(str && *str) { - if(*str == UC_SENTINEL) { - switch(*(str+1)) { - case CODE_DEADKEY: - dkid = max(dkid, *(str+2)); - } +/** + * @brief find the maximal deadkey id + * @param str the deadkey + * @return the maximum deadkey id + */ +KMX_WCHAR KMX_ScanXStringForMaxDeadkeyID(PKMX_WCHAR str) { + KMX_WCHAR dkid = 0; + while (str && *str) { + if (*str == UC_SENTINEL && *(str + 1) == CODE_DEADKEY) { + dkid = std::max(dkid, *(str + 2)); } - str = incxstr(str); + str = KMX_incxstr(str); } return dkid; } -struct dkidmap { - WCHAR src_deadkey, dst_deadkey; +struct KMX_dkidmap { + KMX_WCHAR src_deadkey, dst_deadkey; }; -WCHAR GetUniqueDeadkeyID(LPKEYBOARD kbd, WCHAR deadkey) { - LPGROUP gp; - LPKEY kp; - LPSTORE sp; - UINT i, j; - WCHAR dkid = 0; - static WCHAR s_next_dkid = 0; - static dkidmap *s_dkids = NULL; +/** + * @brief find the deadkey id for a given deadkey + * @param kbd pointer to the keyboard + * @param deadkey for which an id is to be found + * @return 0 if failed; + * otherwise a deadkey-id + */ +KMX_WCHAR KMX_GetUniqueDeadkeyID(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey) { + LPKMX_GROUP gp; + LPKMX_KEY kp; + LPKMX_STORE sp; + KMX_DWORD i, j; + KMX_WCHAR dkid = 0; + static KMX_WCHAR s_next_dkid = 0; + static KMX_dkidmap* s_dkids = NULL; static int s_ndkids = 0; - if(!kbd) { - if(s_dkids) { + if (!kbd) { + if (s_dkids) { delete s_dkids; } s_dkids = NULL; @@ -344,86 +389,111 @@ WCHAR GetUniqueDeadkeyID(LPKEYBOARD kbd, WCHAR deadkey) { return 0; } - for(int i = 0; i < s_ndkids; i++) { - if(s_dkids[i].src_deadkey == deadkey) { + for (int i = 0; i < s_ndkids; i++) { + if (s_dkids[i].src_deadkey == deadkey) { return s_dkids[i].dst_deadkey; } } - if(s_next_dkid != 0) { - s_dkids = (dkidmap*) realloc(s_dkids, sizeof(dkidmap) * (s_ndkids+1)); + if (s_next_dkid != 0) { + s_dkids = (KMX_dkidmap*)realloc(s_dkids, sizeof(KMX_dkidmap) * (s_ndkids + 1)); s_dkids[s_ndkids].src_deadkey = deadkey; return s_dkids[s_ndkids++].dst_deadkey = ++s_next_dkid; } - for(i = 0, gp = kbd->dpGroupArray; i < kbd->cxGroupArray; i++, gp++) { - for(j = 0, kp = gp->dpKeyArray; j < gp->cxKeyArray; j++, kp++) { - dkid = max(dkid, ScanXStringForMaxDeadkeyID(kp->dpContext)); - dkid = max(dkid, ScanXStringForMaxDeadkeyID(kp->dpOutput)); + for (i = 0, gp = kbd->dpGroupArray; i < kbd->cxGroupArray; i++, gp++) { + for (j = 0, kp = gp->dpKeyArray; j < gp->cxKeyArray; j++, kp++) { + dkid = std::max(dkid, KMX_ScanXStringForMaxDeadkeyID(kp->dpContext)); + dkid = std::max(dkid, KMX_ScanXStringForMaxDeadkeyID(kp->dpOutput)); } - dkid = max(dkid, ScanXStringForMaxDeadkeyID(gp->dpMatch)); - dkid = max(dkid, ScanXStringForMaxDeadkeyID(gp->dpNoMatch)); + dkid = std::max(dkid, KMX_ScanXStringForMaxDeadkeyID(gp->dpMatch)); + dkid = std::max(dkid, KMX_ScanXStringForMaxDeadkeyID(gp->dpNoMatch)); } - for(i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) { - dkid = max(dkid, ScanXStringForMaxDeadkeyID(sp->dpString)); + for (i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) { + dkid = std::max(dkid, KMX_ScanXStringForMaxDeadkeyID(sp->dpString)); } - s_dkids = (dkidmap*) realloc(s_dkids, sizeof(dkidmap) * (s_ndkids+1)); + s_dkids = (KMX_dkidmap*)realloc(s_dkids, sizeof(KMX_dkidmap) * (s_ndkids + 1)); s_dkids[s_ndkids].src_deadkey = deadkey; return s_dkids[s_ndkids++].dst_deadkey = s_next_dkid = ++dkid; } - -void ConvertDeadkey(LPKEYBOARD kbd, WORD vk, UINT shift, WCHAR deadkey) { - WORD deadkeys[512], *pdk; +/** + * @brief Lookup the deadkey table for the deadkey in the physical keyboard. Then for each character, go through and map it through + * @param kbd pointer to the keyboard + * @param vk_US virtual key of the us keyboard + * @param shift shiftstate + * @param deadkey character produced by a deadkey + * @param all_vector vector that holds the data of the US keyboard and the currently used (underlying) keyboard + * @param keymap pointer to the currently used (underlying) keyboard Layout + * @param dk_Table a vector of all possible deadkey combinations for all Linux keyboards + */ +void KMX_ConvertDeadkey(LPKMX_KEYBOARD kbd, KMX_WORD vk_US, KMX_DWORD shift, KMX_WCHAR deadkey, vec_dword_3D& all_vector, GdkKeymap* keymap, vec_dword_2D dk_Table) { + KMX_WORD deadkeys[512], *pdk; // Lookup the deadkey table for the deadkey in the physical keyboard // Then for each character, go through and map it through - - WCHAR dkid = GetUniqueDeadkeyID(kbd, deadkey); + KMX_WCHAR dkid = KMX_GetUniqueDeadkeyID(kbd, deadkey); // Add the deadkey to the mapping table for use in the import rules phase - DeadkeyMapping deadkeyMapping = { deadkey, dkid, shift, vk }; // I4353 - FDeadkeys.push_back(deadkeyMapping); //dkid, vk, shift); // I4353 + KMX_DeadkeyMapping KMX_deadkeyMapping = {deadkey, dkid, shift, vk_US}; // I4353 - AddDeadkeyRule(kbd, dkid, vk, shift); + KMX_FDeadkeys.push_back(KMX_deadkeyMapping); // dkid, vk, shift); // I4353 + KMX_AddDeadkeyRule(kbd, dkid, vk_US, shift); - GetDeadkeys(deadkey, pdk = deadkeys); // returns array of [usvk, ch_out] pairs - while(*pdk) { - // Look up the ch - UINT vkUnderlying = VKUnderlyingLayoutToVKUS(*pdk); - TranslateDeadkeyKeyboard(kbd, dkid, vkUnderlying, *(pdk+1), *(pdk+2)); - pdk+=3; - } -} + KMX_GetDeadkeys(dk_Table, deadkey, pdk = deadkeys, keymap); // returns array of [usvk, ch_out] pairs -BOOL SetKeyboardToPositional(LPKEYBOARD kbd) { - LPSTORE sp; - UINT i; - for(i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) { - if(sp->dwSystemID == TSS_MNEMONIC) { - if(!sp->dpString) { - LogError(L"Invalid &mnemoniclayout system store"); + while (*pdk) { + // Look up the ch + KMX_DWORD KeyValUnderlying = (KMX_DWORD) KMX_get_KeyValUnderlying_From_KeyValUS(all_vector, *pdk); + KMX_TranslateDeadkeyKeyboard(kbd, dkid, KeyValUnderlying, *(pdk + 1), *(pdk + 2)); + pdk += 3; + } +} + +/** + * @brief convert a mnemonic keyboard to a positional keyboard + * (i.e. setting *sp->dpString = '0' / TSS_MNEMONIC=0) + * @param kbd pointer to keyboard + * @return TRUE if conversion was successful; + * FALSE otherwise + */ +KMX_BOOL KMX_SetKeyboardToPositional(LPKMX_KEYBOARD kbd) { + LPKMX_STORE sp; + KMX_DWORD i; + for (i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) { + if (sp->dwSystemID == TSS_MNEMONIC) { + if (!sp->dpString) { + KMX_LogError(L"Invalid &mnemoniclayout system store"); return FALSE; } - if(wcscmp(sp->dpString, L"1") != 0) { - LogError(L"Keyboard is not a mnemonic layout keyboard"); + if (u16cmp((const KMX_WCHAR*)sp->dpString, u"1") != 0) { + KMX_LogError(L"Keyboard is not a mnemonic layout keyboard"); return FALSE; } *sp->dpString = '0'; return TRUE; } } - - LogError(L"Keyboard is not a mnemonic layout keyboard"); + KMX_LogError(L"Keyboard is not a mnemonic layout keyboard"); return FALSE; } -BOOL DoConvert(LPKEYBOARD kbd, LPWSTR kbid, BOOL bDeadkeyConversion) { // I4552 - WCHAR DeadKey; +/** + * @brief convert mnemonic keyboard layout to positional keyboard layout and translate keyboard + * @param kbd pointer to US keyboard + * @param bDeadkeyConversion option for converting a deadkey to a character: 1 = dk conversion; 0 = no dk conversion + * @param argc number of command line arguments + * @param argv pointer to command line arguments + * @return TRUE if conversion was successful; + * FALSE if not + */ +KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint argc, gchar* argv[]) { + KMX_WCHAR DeadKey = 0; - if(!SetKeyboardToPositional(kbd)) return FALSE; + if (!KMX_SetKeyboardToPositional(kbd)) + return FALSE; // Go through each of the shift states - base, shift, ctrl+alt, ctrl+alt+shift, [caps vs ncaps?] // Currently, we go in this order so the 102nd key works. But this is not ideal for keyboards without 102nd key: // I4651 @@ -431,494 +501,101 @@ BOOL DoConvert(LPKEYBOARD kbd, LPWSTR kbid, BOOL bDeadkeyConversion) { // I455 // evident for the 102nd key on UK, for example, where \ can be generated with VK_OEM_102 or AltGr+VK_QUOTE. // For now, we get the least shifted version, which is hopefully adequate. - for(int j = 0; VKShiftState[j] != 0xFFFF; j++) { // I4651 - // Go through each possible key on the keyboard - for(int i = 0; VKMap[i]; i++) { // I4651 - UINT vkUnderlying = VKUSToVKUnderlyingLayout(VKMap[i]); - - WCHAR ch = CharFromVK(vkUnderlying, VKShiftState[j], &DeadKey); - - //LogError("--- VK_%d -> VK_%d [%c] dk=%d", VKMap[i], vkUnderlying, ch == 0 ? 32 : ch, DeadKey); - - if(bDeadkeyConversion) { // I4552 - if(ch == 0xFFFF) { - ch = DeadKey; - } - } - - switch(ch) { - case 0x0000: break; - case 0xFFFF: ConvertDeadkey(kbd, VKMap[i], VKShiftState[j], DeadKey); break; - default: TranslateKeyboard(kbd, VKMap[i], VKShiftState[j], ch); - } - - // - } - } - - ReportUnconvertedKeyboardRules(kbd); - - if(!ImportRules(kbid, kbd, &FDeadkeys, bDeadkeyConversion)) { // I4353 // I4552 + GdkKeymap* keymap; + if (InitializeGDK(&keymap, argc, argv)) { + printf("ERROR: can't Initialize GDK\n"); return FALSE; } - return TRUE; -} - -void LogError(PWSTR fmt, ...) { - WCHAR fmtbuf[256]; - - va_list vars; - va_start(vars, fmt); - _vsnwprintf_s(fmtbuf, _countof(fmtbuf), _TRUNCATE, fmt, vars); // I2248 // I3547 - fmtbuf[255] = 0; - _putws(fmtbuf); -} - -//---------old------------------------------------------- -/*#include "pch.h" -#include - -#include -#include -#include - -BOOL DoConvert(LPKEYBOARD kbd, PWSTR kbid, BOOL bDeadkeyConversion); -BOOL SaveKeyboard(LPKEYBOARD kbd, PWSTR filename); -bool ImportRules(WCHAR *kbid, LPKEYBOARD kp, std::vector *FDeadkeys, BOOL bDeadkeyConversion); // I4353 // I4327 -BOOL ConvertKeyboardToUnicode(LPKEYBOARD kbd); // I4273 -int run(int argc, wchar_t * argv[]); - -std::vector FDeadkeys; // I4353 - -#define KEYMAN_SENTRY_LOGGER_DESKTOP_ENGINE_MCOMPILE KEYMAN_SENTRY_LOGGER_DESKTOP_ENGINE ".mcompile" - -int wmain(int argc, wchar_t * argv[]) -{ - return keyman_sentry_wmain(false, KEYMAN_SENTRY_LOGGER_DESKTOP_ENGINE_MCOMPILE, argc, argv, run); -} - -int run(int argc, wchar_t * argv[]) -{ - if(argc < 3 || (argc < 5 && wcscmp(argv[1], L"-u") != 0)) { // I4273 - printf( - "Usage: mcompile -u infile.kmx outfile.kmx\n" - " mcompile [-d] infile.kmx kbdfile.dll kbid outfile.kmx\n" - " With -u parameter, converts keyboard from ANSI to Unicode\n" - " Otherwise, mcompile converts a Keyman mnemonic layout to a\n" - " positional one based on the Windows keyboard\n" - " layout file given by kbdfile.dll\n\n" - " kbid should be a hexadecimal number e.g. 409 for US English\n" - " -d convert deadkeys to plain keys\n"); // I4552 - - return 1; - } - - if(wcscmp(argv[1], L"-u") == 0) { // I4273 - wchar_t *infile = argv[2], *outfile = argv[3]; - - LPKEYBOARD kmxfile; - - if(!LoadKeyboard(infile, &kmxfile)) { - LogError(L"Failed to load keyboard (%d)", GetLastError()); - return 3; - } - - if(ConvertKeyboardToUnicode(kmxfile)) { - SaveKeyboard(kmxfile, outfile); - } - - //DeleteReallocatedPointers(kmxfile); :TODO - delete[] kmxfile; - - return 0; // I4279 - } - - int bDeadkeyConversion = wcscmp(argv[1], L"-d") == 0; // I4552 - int n = (bDeadkeyConversion ? 2 : 1); - - wchar_t *infile = argv[n], *indll = argv[n+1], *kbid = argv[n+2], *outfile = argv[n+3]; - - wprintf(L"mcompile%ls \"%ls\" \"%ls\" \"%ls\" \"%ls\"\n", bDeadkeyConversion ? L" -d":L"", infile, indll, kbid, outfile); // I4174 - - // 1. Load the keyman keyboard file - - // 2. For each key on the system layout, determine its output character and perform a - // 1-1 replacement on the keyman keyboard of that character with the base VK + shift - // state. This fixup will transform the char to a vk, which will avoid any issues - // with the key. - // - // --> deadkeys we will attack after the POC - // - // For each deadkey, we need to determine its possible outputs. Then we generate a VK - // rule for that deadkey, e.g. [K_LBRKT] > dk(c101) - // - // Next, update each rule that references the output from that deadkey to add an extra - // context deadkey at the end of the context match, e.g. 'a' dk(c101) + [K_SPACE] > 'b'. - // This will require a memory layout change for the .kmx file, plus fixups on the - // context+output index offsets - // - // --> virtual character keys - // - // [CTRL ' '] : we look at the character, and replace it in the same way, but merely - // switch the shift state from the VIRTUALCHARKEY to VIRTUALKEY, without changing any - // other properties of the key. - // - - // 3. Write the new keyman keyboard file - - if(!LoadNewLibrary(indll)) { - LogError(L"Failed to load keyboard DLL (%d)", GetLastError()); - return 2; - } - - LPKEYBOARD kmxfile; - - if(!LoadKeyboard(infile, &kmxfile)) { - LogError(L"Failed to load keyboard (%d)", GetLastError()); - return 3; - } - - if(DoConvert(kmxfile, kbid, bDeadkeyConversion)) { // I4552 - SaveKeyboard(kmxfile, outfile); - } - - //DeleteReallocatedPointers(kmxfile); :TODO - delete kmxfile; - - return 0; -} - - -// -// Map of all US English virtual key codes that we can translate -// -const WORD VKMap[] = { - 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z', - '0','1','2','3','4','5','6','7','8','9', - VK_SPACE, - VK_ACCENT, VK_HYPHEN, VK_EQUAL, - VK_LBRKT, VK_RBRKT, VK_BKSLASH, - VK_COLON, VK_QUOTE, - VK_COMMA, VK_PERIOD, VK_SLASH, - VK_xDF, VK_OEM_102, - 0 -}; - - -// -// Map of all shift states that we will work with -// -const UINT VKShiftState[] = {0, K_SHIFTFLAG, LCTRLFLAG|RALTFLAG, K_SHIFTFLAG|LCTRLFLAG|RALTFLAG, 0xFFFF}; - -// -// TranslateKey -// -// For each key rule on the keyboard, remap its key to the -// correct shift state and key. Adjust the LCTRL+RALT -> RALT if necessary -// -void TranslateKey(LPKEY key, WORD vk, UINT shift, WCHAR ch) { - - // The weird LCTRL+RALT is Windows' way of mapping the AltGr key. - // We store that as just RALT, and use the option "Simulate RAlt with Ctrl+Alt" - // to provide an alternate.. - if((shift & (LCTRLFLAG|RALTFLAG)) == (LCTRLFLAG|RALTFLAG)) - shift &= ~LCTRLFLAG; - - if(key->ShiftFlags == 0 && key->Key == ch) { - // Key is a mnemonic key with no shift state defined. - // Remap the key according to the character on the key cap. - //LogError(L"Converted mnemonic rule on line %d, + '%c' TO + [%x K_%d]", key->Line, key->Key, shift, vk); - key->ShiftFlags = ISVIRTUALKEY | shift; - key->Key = vk; - } else if(key->ShiftFlags & VIRTUALCHARKEY && key->Key == ch) { - // Key is a virtual character key with a hard-coded shift state. - // Do not remap the shift state, just move the key. - // This will not result in 100% wonderful mappings as there could - // be overlap, depending on how keys are arranged on the target layout. - // But that is up to the designer. - //LogError(L"Converted mnemonic virtual char key rule on line %d, + [%x '%c'] TO + [%x K_%d]", key->Line, key->ShiftFlags, key->Key, key->ShiftFlags & ~VIRTUALCHARKEY, vk); - key->ShiftFlags &= ~VIRTUALCHARKEY; - key->Key = vk; - } -} - -void TranslateGroup(LPGROUP group, WORD vk, UINT shift, WCHAR ch) { - for(unsigned int i = 0; i < group->cxKeyArray; i++) { - TranslateKey(&group->dpKeyArray[i], vk, shift, ch); - } -} - -void TranslateKeyboard(LPKEYBOARD kbd, WORD vk, UINT shift, WCHAR ch) { - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - TranslateGroup(&kbd->dpGroupArray[i], vk, shift, ch); - } - } -} - -void ReportUnconvertedKeyRule(LPKEY key) { - if(key->ShiftFlags == 0) { - LogError(L"Did not find a match for mnemonic rule on line %d, + '%c' > ...", key->Line, key->Key); - } else if(key->ShiftFlags & VIRTUALCHARKEY) { - LogError(L"Did not find a match for mnemonic virtual character key rule on line %d, + [%x '%c'] > ...", key->Line, key->ShiftFlags, key->Key); - } -} - -void ReportUnconvertedGroupRules(LPGROUP group) { - for(unsigned int i = 0; i < group->cxKeyArray; i++) { - ReportUnconvertedKeyRule(&group->dpKeyArray[i]); - } -} - -void ReportUnconvertedKeyboardRules(LPKEYBOARD kbd) { - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - ReportUnconvertedGroupRules(&kbd->dpGroupArray[i]); - } - } -} - -void TranslateDeadkeyKey(LPKEY key, WCHAR deadkey, WORD vk, UINT shift, WORD ch) { - if((key->ShiftFlags == 0 || key->ShiftFlags & VIRTUALCHARKEY) && key->Key == ch) { - - // The weird LCTRL+RALT is Windows' way of mapping the AltGr key. - // We store that as just RALT, and use the option "Simulate RAlt with Ctrl+Alt" - // to provide an alternate.. - if((shift & (LCTRLFLAG|RALTFLAG)) == (LCTRLFLAG|RALTFLAG)) // I4327 - shift &= ~LCTRLFLAG; - - if(key->ShiftFlags == 0) { - //LogError("Converted mnemonic rule on line %d, + '%c' TO dk(%d) + [%x K_%d]", key->Line, key->Key, deadkey, shift, vk); - key->ShiftFlags = ISVIRTUALKEY | shift; - } else { - //LogError("Converted mnemonic virtual char key rule on line %d, + [%x '%c'] TO dk(%d) + [%x K_%d]", key->Line, key->ShiftFlags, key->Key, deadkey, key->ShiftFlags & ~VIRTUALCHARKEY, vk); - key->ShiftFlags &= ~VIRTUALCHARKEY; - } - - int len = wcslen(key->dpContext); - PWSTR context = new WCHAR[len + 4]; - memcpy(context, key->dpContext, len * sizeof(WCHAR)); - context[len] = UC_SENTINEL; - context[len+1] = CODE_DEADKEY; - context[len+2] = deadkey; - context[len+3] = 0; - key->dpContext = context; - key->Key = vk; - } -} - -void TranslateDeadkeyGroup(LPGROUP group, WCHAR deadkey, WORD vk, UINT shift, WORD ch) { - for(unsigned int i = 0; i < group->cxKeyArray; i++) { - TranslateDeadkeyKey(&group->dpKeyArray[i], deadkey, vk, shift, ch); - } -} - -void TranslateDeadkeyKeyboard(LPKEYBOARD kbd, WCHAR deadkey, WORD vk, UINT shift, WORD ch) { - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - TranslateDeadkeyGroup(&kbd->dpGroupArray[i], deadkey, vk, shift, ch); - } - } -} - -void AddDeadkeyRule(LPKEYBOARD kbd, WCHAR deadkey, WORD vk, UINT shift) { - // The weird LCTRL+RALT is Windows' way of mapping the AltGr key. - // We store that as just RALT, and use the option "Simulate RAlt with Ctrl+Alt" - // to provide an alternate.. - if((shift & (LCTRLFLAG|RALTFLAG)) == (LCTRLFLAG|RALTFLAG)) // I4549 - shift &= ~LCTRLFLAG; - - // If the first group is not a matching-keys group, then we need to add into - // each subgroup, otherwise just the match group - for(unsigned int i = 0; i < kbd->cxGroupArray; i++) { - if(kbd->dpGroupArray[i].fUsingKeys) { - LPKEY keys = new KEY[kbd->dpGroupArray[i].cxKeyArray + 1]; - memcpy(keys+1, kbd->dpGroupArray[i].dpKeyArray, kbd->dpGroupArray[i].cxKeyArray * sizeof(KEY)); - keys[0].dpContext = new WCHAR[1]; - keys[0].dpContext[0] = 0; - keys[0].dpOutput = new WCHAR[4]; // UC_SENTINEL, CODE_DEADKEY, deadkey_value, 0 - keys[0].dpOutput[0] = UC_SENTINEL; - keys[0].dpOutput[1] = CODE_DEADKEY; - keys[0].dpOutput[2] = deadkey; // TODO: translate to unique index - keys[0].dpOutput[3] = 0; - keys[0].Key = vk; - keys[0].Line = 0; - keys[0].ShiftFlags = shift | ISVIRTUALKEY; - kbd->dpGroupArray[i].dpKeyArray = keys; - kbd->dpGroupArray[i].cxKeyArray++; - //LogError("Add deadkey rule: + [%d K_%d] > dk(%d)", shift, vk, deadkey); - if(i == kbd->StartGroup[1]) break; // If this is the initial group, that's all we need to do. - } - } -} - -WCHAR ScanXStringForMaxDeadkeyID(LPWSTR str) { - WCHAR dkid = 0; - while(str && *str) { - if(*str == UC_SENTINEL) { - switch(*(str+1)) { - case CODE_DEADKEY: - dkid = max(dkid, *(str+2)); - } - } - str = incxstr(str); - } - return dkid; -} - -struct dkidmap { - WCHAR src_deadkey, dst_deadkey; -}; - -WCHAR GetUniqueDeadkeyID(LPKEYBOARD kbd, WCHAR deadkey) { - LPGROUP gp; - LPKEY kp; - LPSTORE sp; - UINT i, j; - WCHAR dkid = 0; - static WCHAR s_next_dkid = 0; - static dkidmap *s_dkids = NULL; - static int s_ndkids = 0; - - if(!kbd) { - if(s_dkids) { - delete s_dkids; - } - s_dkids = NULL; - s_ndkids = 0; - s_next_dkid = 0; - return 0; - } - - for(int i = 0; i < s_ndkids; i++) { - if(s_dkids[i].src_deadkey == deadkey) { - return s_dkids[i].dst_deadkey; - } - } - - if(s_next_dkid != 0) { - s_dkids = (dkidmap*) realloc(s_dkids, sizeof(dkidmap) * (s_ndkids+1)); - s_dkids[s_ndkids].src_deadkey = deadkey; - return s_dkids[s_ndkids++].dst_deadkey = ++s_next_dkid; - } - - for(i = 0, gp = kbd->dpGroupArray; i < kbd->cxGroupArray; i++, gp++) { - for(j = 0, kp = gp->dpKeyArray; j < gp->cxKeyArray; j++, kp++) { - dkid = max(dkid, ScanXStringForMaxDeadkeyID(kp->dpContext)); - dkid = max(dkid, ScanXStringForMaxDeadkeyID(kp->dpOutput)); - } - dkid = max(dkid, ScanXStringForMaxDeadkeyID(gp->dpMatch)); - dkid = max(dkid, ScanXStringForMaxDeadkeyID(gp->dpNoMatch)); - } - - for(i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) { - dkid = max(dkid, ScanXStringForMaxDeadkeyID(sp->dpString)); - } - - s_dkids = (dkidmap*) realloc(s_dkids, sizeof(dkidmap) * (s_ndkids+1)); - s_dkids[s_ndkids].src_deadkey = deadkey; - return s_dkids[s_ndkids++].dst_deadkey = s_next_dkid = ++dkid; -} - - -void ConvertDeadkey(LPKEYBOARD kbd, WORD vk, UINT shift, WCHAR deadkey) { - WORD deadkeys[512], *pdk; - - // Lookup the deadkey table for the deadkey in the physical keyboard - // Then for each character, go through and map it through - - WCHAR dkid = GetUniqueDeadkeyID(kbd, deadkey); - - // Add the deadkey to the mapping table for use in the import rules phase - DeadkeyMapping deadkeyMapping = { deadkey, dkid, shift, vk }; // I4353 - FDeadkeys.push_back(deadkeyMapping); //dkid, vk, shift); // I4353 - - AddDeadkeyRule(kbd, dkid, vk, shift); - - GetDeadkeys(deadkey, pdk = deadkeys); // returns array of [usvk, ch_out] pairs - while(*pdk) { - // Look up the ch - UINT vkUnderlying = VKUnderlyingLayoutToVKUS(*pdk); - TranslateDeadkeyKeyboard(kbd, dkid, vkUnderlying, *(pdk+1), *(pdk+2)); - pdk+=3; - } -} - -BOOL SetKeyboardToPositional(LPKEYBOARD kbd) { - LPSTORE sp; - UINT i; - for(i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) { - if(sp->dwSystemID == TSS_MNEMONIC) { - if(!sp->dpString) { - LogError(L"Invalid &mnemoniclayout system store"); - return FALSE; - } - if(wcscmp(sp->dpString, L"1") != 0) { - LogError(L"Keyboard is not a mnemonic layout keyboard"); - return FALSE; - } - *sp->dpString = '0'; - return TRUE; - } + // create vector that contains Keycode, base, shift for US-KEyboard and underlying keyboard + vec_dword_3D all_vector; + if (createOneVectorFromBothKeyboards(all_vector, keymap)) { + printf("ERROR: can't create one vector from both keyboards\n"); + return FALSE; } - LogError(L"Keyboard is not a mnemonic layout keyboard"); - return FALSE; -} - -BOOL DoConvert(LPKEYBOARD kbd, LPWSTR kbid, BOOL bDeadkeyConversion) { // I4552 - WCHAR DeadKey; - - if(!SetKeyboardToPositional(kbd)) return FALSE; + vec_dword_2D dk_Table; + create_DKTable(dk_Table); - // Go through each of the shift states - base, shift, ctrl+alt, ctrl+alt+shift, [caps vs ncaps?] - // Currently, we go in this order so the 102nd key works. But this is not ideal for keyboards without 102nd key: // I4651 - // it catches only the first key that matches a given rule, but multiple keys may match that rule. This is particularly - // evident for the 102nd key on UK, for example, where \ can be generated with VK_OEM_102 or AltGr+VK_QUOTE. - // For now, we get the least shifted version, which is hopefully adequate. + for (int j = 0; VKShiftState[j] != 0xFFFF; j++) { // I4651 - for(int j = 0; VKShiftState[j] != 0xFFFF; j++) { // I4651 - // Go through each possible key on the keyboard - for(int i = 0; VKMap[i]; i++) { // I4651 - UINT vkUnderlying = VKUSToVKUnderlyingLayout(VKMap[i]); + // Loop through each possible key on the keyboard + for (int i = 0; KMX_VKMap[i]; i++) { // I4651 - WCHAR ch = CharFromVK(vkUnderlying, VKShiftState[j], &DeadKey); + // windows uses VK, Linux uses SC/Keycode + KMX_DWORD scUnderlying = (KMX_DWORD)KMX_get_KeyCodeUnderlying_From_VKUS(KMX_VKMap[i]); + KMX_WCHAR ch = KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(keymap, scUnderlying, VKShiftState[j], &DeadKey); - //LogError("--- VK_%d -> VK_%d [%c] dk=%d", VKMap[i], vkUnderlying, ch == 0 ? 32 : ch, DeadKey); + // printf("--- VK_%d -> SC_ [%c] dk=%d ( ss %i) \n", KMX_VKMap[i], ch == 0 ? 32 : ch, DeadKey, VKShiftState[j]); - if(bDeadkeyConversion) { // I4552 - if(ch == 0xFFFF) { + if (bDeadkeyConversion) { // I4552 + if (ch == 0xFFFF) { ch = DeadKey; } } - switch(ch) { + switch (ch) { case 0x0000: break; - case 0xFFFF: ConvertDeadkey(kbd, VKMap[i], VKShiftState[j], DeadKey); break; - default: TranslateKeyboard(kbd, VKMap[i], VKShiftState[j], ch); + case 0xFFFF: KMX_ConvertDeadkey(kbd, KMX_VKMap[i], VKShiftState[j], DeadKey, all_vector, keymap, dk_Table); break; + default: KMX_TranslateKeyboard(kbd, KMX_VKMap[i], VKShiftState[j], ch); } - - // } } - ReportUnconvertedKeyboardRules(kbd); + KMX_ReportUnconvertedKeyboardRules(kbd); - if(!ImportRules(kbid, kbd, &FDeadkeys, bDeadkeyConversion)) { // I4353 // I4552 + if (!KMX_ImportRules(kbd, all_vector, &keymap, &KMX_FDeadkeys, bDeadkeyConversion)) { // I4353 // I4552 return FALSE; } - return TRUE; } -void LogError(PWSTR fmt, ...) { - WCHAR fmtbuf[256]; +/** + * @brief return an array of [usvk, ch_out] pairs: all existing combinations of a deadkey + character for the underlying keyboard + * @param dk_Table shiftstate of the deadkey + * @param deadkey deadkey character + * @param[out] outputPairs pointer to array of [usvk, ch_out] pairs + * @param keymap pointer to the currently used (underlying) keyboard Layout + * @return size of array of [usvk, ch_out] pairs + */ +int KMX_GetDeadkeys(vec_dword_2D& dk_Table, KMX_WORD deadkey, KMX_WORD* outputPairs, GdkKeymap* keymap) { + KMX_WORD* p = outputPairs; + KMX_DWORD shift; + vec_dword_2D dk_SingleTable; + + query_dk_combinations_for_specific_dk(dk_Table, deadkey, dk_SingleTable); + for (int i = 0; i < (int)dk_SingleTable.size(); i++) { + KMX_WORD vk = KMX_change_keyname_to_capital(dk_SingleTable[i][1], shift, keymap); + if (vk != 0) { + *p++ = vk; + *p++ = shift; + *p++ = dk_SingleTable[i][2]; + } else { + KMX_LogError(L"Warning: complex deadkey not supported."); + } + } + *p = 0; + return (p - outputPairs); +} + +/** + * @brief print (error) messages + * @param fmt text to print + */ +void KMX_LogError(const wchar_t* fmt, ...) { + wchar_t fmtbuf[256]; + const wchar_t* end = L"\0"; + const wchar_t* nl = L"\n"; + va_list vars; + int j = 0; + + va_start(vars, fmt); + vswprintf(fmtbuf, _countof(fmtbuf), fmt, vars); + fmtbuf[255] = 0; - va_list vars; - va_start(vars, fmt); - _vsnwprintf_s(fmtbuf, _countof(fmtbuf), _TRUNCATE, fmt, vars); // I2248 // I3547 - fmtbuf[255] = 0; - _putws(fmtbuf); + do { + putwchar(fmtbuf[j]); + j++; + } while (fmtbuf[j] != *end); + putwchar(*nl); } -*/ diff --git a/linux/mcompile/keymap/mcompile.h b/linux/mcompile/keymap/mcompile.h index 3b1e2abad10..ca3cd78395a 100644 --- a/linux/mcompile/keymap/mcompile.h +++ b/linux/mcompile/keymap/mcompile.h @@ -1,51 +1,38 @@ /* Name: mcompile Copyright: Copyright (C) 2003-2017 SIL International. - Documentation: - Description: + Documentation: + Description: Create Date: 3 Aug 2014 Modified Date: 3 Aug 2014 Authors: mcdurdin - Related Files: - Dependencies: + Related Files: + Dependencies: - Bugs: - Todo: - Notes: + Bugs: + Todo: + Notes: History: 03 Aug 2014 - mcdurdin - I4353 - V9.0 - mnemonic layout recompiler mixes up deadkey rules - -*/ - +*/ +#ifndef MCOMPILE_H +#define MCOMPILE_H #include -#include "km_types.h" - -void LogError(PKMX_WCHART message, ...); +#include "keymap.h" +#include "deadkey.h" +#include "mc_kmxfile.h" - -struct DeadkeyMapping { // I4353 - KMX_WCHART deadkey, dkid; - KMX_UINT shift; +struct KMX_DeadkeyMapping { // I4353 + KMX_WCHAR deadkey, dkid; + KMX_DWORD shift; KMX_WORD vk; }; -extern std::vector FDeadkeys; // I4353 +extern std::vector KMX_FDeadkeys; // I4353 +/** @brief print (error) messages */ +void KMX_LogError(const wchar_t* fmt, ...); -//--------------------old -/* -#include - -void LogError(PWSTR message, ...); - - -struct DeadkeyMapping { // I4353 - WCHAR deadkey, dkid; - UINT shift; - WORD vk; -}; - -extern std::vector FDeadkeys; // I4353 -*/ +#endif /*MCOMPILE_H*/ diff --git a/linux/mcompile/keymap/meson.build b/linux/mcompile/keymap/meson.build index eb1e03783b7..3866ca34f10 100644 --- a/linux/mcompile/keymap/meson.build +++ b/linux/mcompile/keymap/meson.build @@ -1,11 +1,31 @@ -project('keymap', 'c', 'cpp', +project('mcompile', 'c', 'cpp', license: 'MIT', meson_version: '>=1.0') -gtk = dependency('gtk+-3.0', version: '>= 2.4') +gtk = dependency('gtk+-3.0', version: '>= 2.4') +xkb = dependency('xkbcommon') +libxklavier = dependency('libxklavier') -keymap = executable( - 'keymap', - sources: ['keymap.cpp'], - dependencies: [gtk] -) +deps = [gtk, xkb,libxklavier] + +subdir('resources') + +cpp_files = files( + 'keymap.cpp', + 'deadkey.cpp', + 'mcompile.cpp', + 'mc_kmxfile.cpp', + 'mc_import_rules.cpp', + '../../../common/cpp/km_u16.cpp', + ) + +comon_include_dir = [ + include_directories('../../../common/include') +] + +mcompile = executable( + 'mcompile', + sources: [cpp_files], + dependencies: deps, + include_directories : comon_include_dir + )