mirror of
https://github.com/keymanapp/keyman.git
synced 2026-09-19 14:17:40 +00:00
feat(linux): char-filenames, check parameters in run()
This commit is contained in:
Sabine
parent
69660376d9
commit
ec05b41546
5 changed files with 132 additions and 144 deletions
|
|
@ -17,7 +17,7 @@ int convert_Shiftstate_to_LinuxShiftstate(int shiftState) {
|
|||
|
||||
|
||||
bool ensureValidInputForKeyboardTranslation(int gdk_level, gint count, gint keycode) {
|
||||
if (gdk_level >= (int) count)
|
||||
if (gdk_level > (int) count)
|
||||
return false;
|
||||
|
||||
if ((int) keycode > (int)keycode_max)
|
||||
|
|
|
|||
|
|
@ -358,7 +358,7 @@ LPKMX_KEYBOARD KMX_FixupKeyboard(PKMX_BYTE bufp, PKMX_BYTE base, KMX_DWORD dwFil
|
|||
|
||||
#endif
|
||||
|
||||
KMX_BOOL KMX_LoadKeyboard(char16_t* fileName, LPKMX_KEYBOARD* lpKeyboard) {
|
||||
KMX_BOOL KMX_LoadKeyboard(KMX_CHAR* fileName, LPKMX_KEYBOARD* lpKeyboard) {
|
||||
|
||||
*lpKeyboard = NULL;
|
||||
PKMX_BYTE buf;
|
||||
|
|
@ -371,7 +371,7 @@ KMX_BOOL KMX_LoadKeyboard(char16_t* fileName, LPKMX_KEYBOARD* lpKeyboard) {
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
fp = Open_File((const KMX_WCHAR*)fileName, u"rb");
|
||||
fp = Open_File((const KMX_CHAR*)fileName, "rb");
|
||||
|
||||
if(fp == NULL) {
|
||||
KMX_LogError(L"Could not open file\n" );
|
||||
|
|
|
|||
|
|
@ -68,8 +68,7 @@ typedef struct KMX_tagKEYBOARD {
|
|||
//HBITMAP hBitmap; // handle to the bitmap in the file;
|
||||
} KMX_KEYBOARD, *LPKMX_KEYBOARD;
|
||||
|
||||
KMX_BOOL KMX_LoadKeyboard(char16_t* fileName, LPKMX_KEYBOARD *lpKeyboard);
|
||||
|
||||
KMX_BOOL KMX_LoadKeyboard(KMX_CHAR* fileName, LPKMX_KEYBOARD* lpKeyboard) ;
|
||||
KMX_BOOL KMX_SaveKeyboard(LPKMX_KEYBOARD kbd, KMX_CHAR* filename);
|
||||
|
||||
PKMX_WCHAR KMX_incxstr(PKMX_WCHAR p);
|
||||
|
|
|
|||
|
|
@ -36,69 +36,58 @@
|
|||
|
||||
KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint argc, gchar *argv[]);
|
||||
|
||||
bool KMX_ImportRules( LPKMX_KEYBOARD kp,vec_dword_3D& all_vector, GdkKeymap **keymap,std::vector<KMX_DeadkeyMapping> *KMX_FDeadkeys, KMX_BOOL bDeadkeyConversion); // I4353 // I4327
|
||||
bool KMX_ImportRules(LPKMX_KEYBOARD kp, vec_dword_3D& all_vector, GdkKeymap** keymap, std::vector<KMX_DeadkeyMapping>* KMX_FDeadkeys, KMX_BOOL bDeadkeyConversion); // I4353 // I4327
|
||||
|
||||
int run(int argc, std::vector<std::u16string> str_argv, char* argv_ch[]);
|
||||
int run(int argc, char* argv[], char* argv_gdk[] = NULL);
|
||||
|
||||
int KMX_GetDeadkeys(vec_dword_2D & dk_Table, KMX_WORD DeadKey, KMX_WORD *OutputPairs, GdkKeymap* keymap);
|
||||
int KMX_GetDeadkeys(vec_dword_2D& dk_Table, KMX_WORD DeadKey, KMX_WORD* OutputPairs, GdkKeymap* keymap);
|
||||
|
||||
std::vector<KMX_DeadkeyMapping> KMX_FDeadkeys; // I4353
|
||||
|
||||
// Note: max is not a standard c api function or macro
|
||||
#ifndef max
|
||||
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
||||
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
#define _countof(a) (sizeof(a)/sizeof(*(a)))
|
||||
#define _countof(a) (sizeof(a) / sizeof(*(a)))
|
||||
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
int wmain(int argc, wchar_t* argv[]) {
|
||||
std::vector<std::u16string> str_argv_16 = convert_argvW_to_Vector_u16str( argc, argv);
|
||||
run(argc, str_argv_16);
|
||||
run(argc, argv);
|
||||
|
||||
#else // LINUX
|
||||
int main(int argc, char* argv[]) {
|
||||
std::vector<std::u16string> str_argv_16 = convert_argv_to_Vector_u16str(argc, argv);
|
||||
run(argc, str_argv_16, argv);
|
||||
run(argc, argv, argv);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
int run(int argc, std::vector<std::u16string> str_argv, char* argv_ch[] = NULL){
|
||||
int run(int argc, char* argv[], char* argv_gdk[]) {
|
||||
|
||||
std::vector<const char16_t*> argv;
|
||||
for (int i = 0; i < argc; i++) {
|
||||
const char16_t* cmdl_par = str_argv[i].c_str();
|
||||
argv.push_back(cmdl_par);
|
||||
}
|
||||
int bDeadkeyConversion = 0;
|
||||
|
||||
if(argc < 3 || (argc > 4)) { // I4273// I4273
|
||||
if( argc > 1)
|
||||
bDeadkeyConversion = (strcmp(argv[1], "-d") == 0); // I4552
|
||||
|
||||
int n = (bDeadkeyConversion ? 2 : 1);
|
||||
|
||||
if (argc < 3 || argc > 4 || argc-n !=2) { // I4273// I4273
|
||||
wprintf(
|
||||
L"Usage: mcompile [-d] infile.kmx outfile.kmx\n"
|
||||
L" mmcompile -u ... (not available for Linux)\n "
|
||||
L" mcompile converts a Keyman mnemonic layout to a\n"
|
||||
L" positional one based on the Linux keyboard\n"
|
||||
L" layout on top position\n"
|
||||
L" (-d convert deadkeys to plain keys) not available yet \n\n"
|
||||
); // I4552
|
||||
L"Usage: \tmcompile [-d] infile.kmx outfile.kmx\n"
|
||||
L" \tmcompile -u ... (not available for Linux)\n "
|
||||
L" \tmcompile converts a Keyman mnemonic layout to a\n"
|
||||
L" \tpositional one based on the Linux keyboard\n"
|
||||
L" \tlayout on top position\n"
|
||||
L" \t(-d convert deadkeys to plain keys) \n \n"); // I4552
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// -u option is not available for Linux
|
||||
|
||||
KMX_CHAR* infile = argv[n];
|
||||
KMX_CHAR* outfile = argv[n + 1];
|
||||
|
||||
int bDeadkeyConversion = u16cmp(argv[1], u"-d") == 0; // I4552
|
||||
int n = (bDeadkeyConversion ? 2 : 1);
|
||||
|
||||
// _S2 needs more work once mcompile is changed after review ( use char* only instead of char16_t*)
|
||||
char16_t* infile = (char16_t*) argv[n];
|
||||
char16_t* outfile_16 = (char16_t*) argv[n+1];
|
||||
std::u16string u16stri(outfile_16);
|
||||
std::string str= string_from_u16string(u16stri);
|
||||
char* outfile = (char*) str.c_str();
|
||||
|
||||
|
||||
printf("mcompile%ls \"%ls\" \"%ls\"\n", bDeadkeyConversion ? L" -d" : L"", u16fmt((const char16_t*) infile).c_str(), u16fmt((const char16_t*) outfile_16).c_str() ); // I4174
|
||||
printf("mcompile%s \"%s\" \"%s\"\n", bDeadkeyConversion ? " -d" : "", infile, outfile); // I4174
|
||||
|
||||
// 1. Load the keyman keyboard file
|
||||
|
||||
|
|
@ -125,33 +114,36 @@ int run(int argc, std::vector<std::u16string> str_argv, char* argv_ch[] = NULL){
|
|||
//
|
||||
// 3. Write the new keyman keyboard file
|
||||
|
||||
|
||||
LPKMX_KEYBOARD kmxfile;
|
||||
|
||||
if(!KMX_LoadKeyboard(infile, &kmxfile)) {
|
||||
KMX_LogError(L"Failed to load keyboard (%d)\n", errno );
|
||||
if (!KMX_LoadKeyboard(infile, &kmxfile)) {
|
||||
KMX_LogError(L"Failed to load keyboard (%d)\n", errno);
|
||||
return 3;
|
||||
}
|
||||
|
||||
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
/*if(DoConvert(kmxfile, kbid, bDeadkeyConversion)) { // I4552F
|
||||
/*if (DoConvert(kmxfile, kbid, bDeadkeyConversion)) { // I4552F
|
||||
KMX_SaveKeyboard(kmxfile, outfile);
|
||||
}*/
|
||||
|
||||
#else // LINUX
|
||||
if(KMX_DoConvert( kmxfile, bDeadkeyConversion, argc, (gchar**) argv_ch)) { // I4552F
|
||||
if (argv_gdk == NULL) {
|
||||
KMX_LogError(L"Missing parameter for initializing GdkKeymap \n");
|
||||
return 3;
|
||||
}
|
||||
|
||||
if (KMX_DoConvert(kmxfile, bDeadkeyConversion, argc, (gchar**)argv_gdk)) { // I4552F
|
||||
KMX_SaveKeyboard(kmxfile, outfile);
|
||||
}
|
||||
|
||||
#endif
|
||||
//DeleteReallocatedPointers(kmxfile); :TODO // _S2 not my ToDo :-)
|
||||
// DeleteReallocatedPointers(kmxfile); :TODO // _S2 not my ToDo :-)
|
||||
delete kmxfile;
|
||||
return 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 UINT VKShiftState[] = {0, K_SHIFTFLAG, LCTRLFLAG | RALTFLAG, K_SHIFTFLAG | LCTRLFLAG | RALTFLAG, 0xFFFF};
|
||||
|
||||
//
|
||||
// TranslateKey
|
||||
|
|
@ -163,58 +155,58 @@ void KMX_TranslateKey(LPKMX_KEY key, KMX_WORD vk, UINT 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.
|
||||
//KMX_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.
|
||||
//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);
|
||||
// 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 KMX_TranslateGroup(LPKMX_GROUP group, KMX_WORD vk, UINT shift, KMX_WCHAR ch) {
|
||||
for(unsigned int i = 0; i < group->cxKeyArray; i++) {
|
||||
for (unsigned int i = 0; i < group->cxKeyArray; i++) {
|
||||
KMX_TranslateKey(&group->dpKeyArray[i], vk, shift, ch);
|
||||
}
|
||||
}
|
||||
|
||||
void KMX_TranslateKeyboard(LPKMX_KEYBOARD kbd, KMX_WORD vk, UINT shift, KMX_WCHAR ch) {
|
||||
for(unsigned int i = 0; i < kbd->cxGroupArray; i++) {
|
||||
if(kbd->dpGroupArray[i].fUsingKeys) {
|
||||
for (unsigned int i = 0; i < kbd->cxGroupArray; i++) {
|
||||
if (kbd->dpGroupArray[i].fUsingKeys) {
|
||||
KMX_TranslateGroup(&kbd->dpGroupArray[i], vk, shift, ch);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
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 KMX_ReportUnconvertedGroupRules(LPKMX_GROUP group) {
|
||||
for(unsigned int i = 0; i < group->cxKeyArray; i++) {
|
||||
for (unsigned int i = 0; i < group->cxKeyArray; i++) {
|
||||
KMX_ReportUnconvertedKeyRule(&group->dpKeyArray[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void KMX_ReportUnconvertedKeyboardRules(LPKMX_KEYBOARD kbd) {
|
||||
for(unsigned int i = 0; i < kbd->cxGroupArray; i++) {
|
||||
if(kbd->dpGroupArray[i].fUsingKeys) {
|
||||
for (unsigned int i = 0; i < kbd->cxGroupArray; i++) {
|
||||
if (kbd->dpGroupArray[i].fUsingKeys) {
|
||||
KMX_ReportUnconvertedGroupRules(&kbd->dpGroupArray[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -223,18 +215,18 @@ void KMX_ReportUnconvertedKeyboardRules(LPKMX_KEYBOARD kbd) {
|
|||
void KMX_TranslateDeadkeyKey(LPKMX_KEY key, KMX_WCHAR deadkey, KMX_WORD vk, UINT shift, KMX_WORD ch) {
|
||||
// _S2 TOP_2 INFO this produces a different output due to different layouts for Lin<-> win ( for the same language!!)
|
||||
|
||||
if((key->ShiftFlags == 0 || key->ShiftFlags & VIRTUALCHARKEY) && key->Key == 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) {
|
||||
//KMX_LogError(L"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 {
|
||||
//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);
|
||||
// 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;
|
||||
}
|
||||
|
||||
|
|
@ -243,23 +235,23 @@ void KMX_TranslateDeadkeyKey(LPKMX_KEY key, KMX_WCHAR deadkey, KMX_WORD vk, UINT
|
|||
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 KMX_TranslateDeadkeyGroup(LPKMX_GROUP group,KMX_WCHAR deadkey, KMX_WORD vk, UINT shift, KMX_WORD ch) {
|
||||
for(unsigned int i = 0; i < group->cxKeyArray; i++) {
|
||||
void KMX_TranslateDeadkeyGroup(LPKMX_GROUP group, KMX_WCHAR deadkey, KMX_WORD vk, UINT shift, KMX_WORD ch) {
|
||||
for (unsigned int i = 0; i < group->cxKeyArray; i++) {
|
||||
KMX_TranslateDeadkeyKey(&group->dpKeyArray[i], deadkey, vk, shift, ch);
|
||||
}
|
||||
}
|
||||
|
||||
void KMX_TranslateDeadkeyKeyboard(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey, KMX_WORD vk, UINT shift, KMX_WORD ch) {
|
||||
for(unsigned int i = 0; i < kbd->cxGroupArray; i++) {
|
||||
if(kbd->dpGroupArray[i].fUsingKeys) {
|
||||
for (unsigned int i = 0; i < kbd->cxGroupArray; i++) {
|
||||
if (kbd->dpGroupArray[i].fUsingKeys) {
|
||||
KMX_TranslateDeadkeyGroup(&kbd->dpGroupArray[i], deadkey, vk, shift, ch);
|
||||
}
|
||||
}
|
||||
|
|
@ -269,14 +261,14 @@ void KMX_AddDeadkeyRule(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey, KMX_WORD vk, UINT
|
|||
// 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) {
|
||||
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));
|
||||
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 KMX_WCHAR[4];
|
||||
|
|
@ -290,16 +282,17 @@ void KMX_AddDeadkeyRule(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey, KMX_WORD vk, UINT
|
|||
kbd->dpGroupArray[i].dpKeyArray = keys;
|
||||
kbd->dpGroupArray[i].cxKeyArray++;
|
||||
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.
|
||||
if (i == kbd->StartGroup[1])
|
||||
break; // If this is the initial group, that's all we need to do.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
KMX_WCHAR KMX_ScanXStringForMaxDeadkeyID(PKMX_WCHAR str) {
|
||||
KMX_WCHAR dkid = 0;
|
||||
while(str && *str) {
|
||||
if(*str == UC_SENTINEL && *(str+1) == CODE_DEADKEY) {
|
||||
dkid = max(dkid, *(str+2));
|
||||
while (str && *str) {
|
||||
if (*str == UC_SENTINEL && *(str + 1) == CODE_DEADKEY) {
|
||||
dkid = max(dkid, *(str + 2));
|
||||
}
|
||||
str = KMX_incxstr(str);
|
||||
}
|
||||
|
|
@ -317,11 +310,11 @@ KMX_WCHAR KMX_GetUniqueDeadkeyID(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey) {
|
|||
UINT i, j;
|
||||
KMX_WCHAR dkid = 0;
|
||||
static KMX_WCHAR s_next_dkid = 0;
|
||||
static KMX_dkidmap *s_dkids = NULL;
|
||||
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;
|
||||
|
|
@ -330,20 +323,20 @@ KMX_WCHAR KMX_GetUniqueDeadkeyID(LPKMX_KEYBOARD kbd, KMX_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 = (KMX_dkidmap*) realloc(s_dkids, sizeof(KMX_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++) {
|
||||
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, KMX_ScanXStringForMaxDeadkeyID(kp->dpContext));
|
||||
dkid = max(dkid, KMX_ScanXStringForMaxDeadkeyID(kp->dpOutput));
|
||||
}
|
||||
|
|
@ -351,16 +344,16 @@ KMX_WCHAR KMX_GetUniqueDeadkeyID(LPKMX_KEYBOARD kbd, KMX_WCHAR deadkey) {
|
|||
dkid = max(dkid, KMX_ScanXStringForMaxDeadkeyID(gp->dpNoMatch));
|
||||
}
|
||||
|
||||
for(i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) {
|
||||
for (i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) {
|
||||
dkid = max(dkid, KMX_ScanXStringForMaxDeadkeyID(sp->dpString));
|
||||
}
|
||||
|
||||
s_dkids = (KMX_dkidmap*) realloc(s_dkids, sizeof(KMX_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 KMX_ConvertDeadkey(LPKMX_KEYBOARD kbd, KMX_WORD vk_US, UINT shift, KMX_WCHAR deadkey, vec_dword_3D& all_vector, GdkKeymap* keymap,vec_dword_2D dk_Table) {
|
||||
void KMX_ConvertDeadkey(LPKMX_KEYBOARD kbd, KMX_WORD vk_US, UINT 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
|
||||
|
|
@ -368,31 +361,31 @@ void KMX_ConvertDeadkey(LPKMX_KEYBOARD kbd, KMX_WORD vk_US, UINT shift, KMX_WCHA
|
|||
KMX_WCHAR dkid = KMX_GetUniqueDeadkeyID(kbd, deadkey);
|
||||
|
||||
// Add the deadkey to the mapping table for use in the import rules phase
|
||||
KMX_DeadkeyMapping KMX_deadkeyMapping = { deadkey, dkid, shift, vk_US}; // I4353
|
||||
KMX_DeadkeyMapping KMX_deadkeyMapping = {deadkey, dkid, shift, vk_US}; // I4353
|
||||
|
||||
KMX_FDeadkeys.push_back(KMX_deadkeyMapping); //dkid, vk, shift); // I4353
|
||||
KMX_FDeadkeys.push_back(KMX_deadkeyMapping); // dkid, vk, shift); // I4353
|
||||
KMX_AddDeadkeyRule(kbd, dkid, vk_US, shift);
|
||||
|
||||
KMX_GetDeadkeys(dk_Table, deadkey, pdk = deadkeys, keymap); // returns array of [usvk, ch_out] pairs
|
||||
|
||||
while(*pdk) {
|
||||
while (*pdk) {
|
||||
// Look up the ch
|
||||
UINT KeyValUnderlying = KMX_get_KeyValUnderlying_From_KeyValUS(all_vector, *pdk);
|
||||
KMX_TranslateDeadkeyKeyboard(kbd, dkid, KeyValUnderlying, *(pdk+1), *(pdk+2));
|
||||
pdk+=3;
|
||||
KMX_TranslateDeadkeyKeyboard(kbd, dkid, KeyValUnderlying, *(pdk + 1), *(pdk + 2));
|
||||
pdk += 3;
|
||||
}
|
||||
}
|
||||
|
||||
KMX_BOOL KMX_SetKeyboardToPositional(LPKMX_KEYBOARD kbd) {
|
||||
LPKMX_STORE sp;
|
||||
UINT i;
|
||||
for(i = 0, sp = kbd->dpStoreArray; i < kbd->cxStoreArray; i++, sp++) {
|
||||
if(sp->dwSystemID == TSS_MNEMONIC) {
|
||||
if(!sp->dpString) {
|
||||
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(u16cmp((const KMX_WCHAR*)sp->dpString, u"1") != 0) {
|
||||
if (u16cmp((const KMX_WCHAR*)sp->dpString, u"1") != 0) {
|
||||
KMX_LogError(L"Keyboard is not a mnemonic layout keyboard");
|
||||
return FALSE;
|
||||
}
|
||||
|
|
@ -404,11 +397,11 @@ KMX_BOOL KMX_SetKeyboardToPositional(LPKMX_KEYBOARD kbd) {
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint argc, gchar *argv[]) {
|
||||
KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint argc, gchar* argv[]) {
|
||||
KMX_WCHAR DeadKey = 0;
|
||||
|
||||
KMX_WCHAR DeadKey=0;
|
||||
|
||||
if(!KMX_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
|
||||
|
|
@ -416,42 +409,42 @@ KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint arg
|
|||
// 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.
|
||||
|
||||
GdkKeymap *keymap;
|
||||
if(InitializeGDK(&keymap, argc, argv)) {
|
||||
GdkKeymap* keymap;
|
||||
if (InitializeGDK(&keymap, argc, argv)) {
|
||||
printf("ERROR: can't Initialize GDK\n");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// create vector that contains Keycode, base, shift for US-KEyboard and underlying keyboard
|
||||
vec_dword_3D all_vector;
|
||||
if(createOneVectorFromBothKeyboards(all_vector, keymap)){
|
||||
if (createOneVectorFromBothKeyboards(all_vector, keymap)) {
|
||||
printf("ERROR: can't create one vector from both keyboards\n");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
vec_dword_2D dk_Table;
|
||||
vec_dword_2D dk_Table;
|
||||
create_DKTable(dk_Table);
|
||||
|
||||
for (int j = 0; VKShiftState[j] != 0xFFFF; j++) { // I4651
|
||||
for (int j = 0; VKShiftState[j] != 0xFFFF; j++) { // I4651
|
||||
|
||||
// Loop through each possible key on the keyboard
|
||||
for (int i = 0;KMX_VKMap[i]; i++) { // I4651
|
||||
for (int i = 0; KMX_VKMap[i]; i++) { // I4651
|
||||
|
||||
// windows uses VK, Linux uses SC/Keycode
|
||||
UINT scUnderlying = KMX_get_KeyCodeUnderlying_From_VKUS(KMX_VKMap[i]);
|
||||
UINT scUnderlying = KMX_get_KeyCodeUnderlying_From_VKUS(KMX_VKMap[i]);
|
||||
KMX_WCHAR ch = KMX_get_KeyValUnderlying_From_KeyCodeUnderlying(keymap, VKShiftState[j], scUnderlying, &DeadKey);
|
||||
|
||||
//printf("--- VK_%d -> SC_ [%c] dk=%d ( ss %i) \n", KMX_VKMap[i], ch == 0 ? 32 : ch, DeadKey, VKShiftState[j]);
|
||||
// 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: KMX_ConvertDeadkey(kbd, KMX_VKMap[i], VKShiftState[j], DeadKey, all_vector, keymap, dk_Table); break;
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
|
@ -459,32 +452,30 @@ KMX_BOOL KMX_DoConvert(LPKMX_KEYBOARD kbd, KMX_BOOL bDeadkeyConversion, gint arg
|
|||
|
||||
KMX_ReportUnconvertedKeyboardRules(kbd);
|
||||
|
||||
if(!KMX_ImportRules(kbd, all_vector, &keymap, &KMX_FDeadkeys, bDeadkeyConversion)) { // I4353 // I4552
|
||||
if (!KMX_ImportRules(kbd, all_vector, &keymap, &KMX_FDeadkeys, bDeadkeyConversion)) { // I4353 // I4552
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int KMX_GetDeadkeys(vec_dword_2D & dk_Table, KMX_WORD deadkey, KMX_WORD *OutputPairs, GdkKeymap* keymap) {
|
||||
|
||||
KMX_WORD *p = OutputPairs;
|
||||
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++) {
|
||||
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) {
|
||||
if (vk != 0) {
|
||||
*p++ = vk;
|
||||
*p++ = shift;
|
||||
*p++ = dk_SingleTable[i][2];
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
KMX_LogError(L"Warning: complex deadkey not supported.");
|
||||
}
|
||||
}
|
||||
*p = 0;
|
||||
return (p-OutputPairs);
|
||||
return (p - OutputPairs);
|
||||
}
|
||||
|
||||
void KMX_LogError(const wchar_t* fmt, ...) {
|
||||
|
|
@ -492,16 +483,15 @@ void KMX_LogError(const wchar_t* fmt, ...) {
|
|||
const wchar_t* end = L"\0";
|
||||
const wchar_t* nl = L"\n";
|
||||
va_list vars;
|
||||
int j=0;
|
||||
int j = 0;
|
||||
|
||||
va_start(vars, fmt);
|
||||
vswprintf (fmtbuf,_countof(fmtbuf), fmt, vars );
|
||||
vswprintf(fmtbuf, _countof(fmtbuf), fmt, vars);
|
||||
fmtbuf[255] = 0;
|
||||
|
||||
do {
|
||||
putwchar(fmtbuf[j]);
|
||||
j++;
|
||||
}
|
||||
while(fmtbuf[j] != *end);
|
||||
} while (fmtbuf[j] != *end);
|
||||
putwchar(*nl);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,22 +1,21 @@
|
|||
/*
|
||||
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
|
||||
|
|
@ -25,13 +24,13 @@
|
|||
#include "deadkey.h"
|
||||
#include "mc_kmxfile.h"
|
||||
|
||||
struct KMX_DeadkeyMapping { // I4353
|
||||
struct KMX_DeadkeyMapping { // I4353
|
||||
KMX_WCHAR deadkey, dkid;
|
||||
UINT shift;
|
||||
KMX_WORD vk;
|
||||
};
|
||||
|
||||
extern std::vector<KMX_DeadkeyMapping> KMX_FDeadkeys; // I4353
|
||||
extern std::vector<KMX_DeadkeyMapping> KMX_FDeadkeys; // I4353
|
||||
|
||||
void KMX_LogError(const wchar_t* fmt, ...);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue