erabo/spiegel-keyman
1
0
Fork 0
mirror of https://github.com/keymanapp/keyman.git synced 2026-08-05 08:25:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10
spiegel-keyman/linux/mcompile/keymap/helpers.cpp

2396 lines
94 KiB
C++
Executable file
Raw Blame History

#include "helpers.h"
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//_S2 do not review - all this will be deleted later
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int append_other_ToVector(v_dw_3D &All_Vector) {
InsertKeyvalsFromVectorFile(All_Vector);
return 0;
}
bool InsertKeyvalsFromVectorFile(v_dw_3D &complete_Vector) {
std::string TxtFileName = "/Projects/keyman/keyman/linux/mcompile/keymap/VectorFile.txt" ;
//wprintf(L" +++++++ dimensions of Vector at beginning of writeFileToVector (languages..characters..shiftstates)\t\t %li..%li..%li\n", complete_Vector.size(), complete_Vector.size(),complete_Vector.size());
//wprintf(L" #### InsertKeyvalsFromVectorFile started: \n");
FILE *fp;
char str[600];
std::vector<char> delim{' ', '[', ']', '}', ';', '\t', '\n'};
v_str_1D complete_List;
v_dw_1D tokens_dw;
v_dw_2D shift_states;
int k = -1;
/* opening file for reading */
fp = fopen(TxtFileName.c_str() , "r");
if(fp == NULL) {
perror("Error opening file");
return(-1);
}
while (fgets(str, 600, fp) != NULL) {
k++;
//puts(str);
complete_List.push_back(str);
if (strcmp(str, "Language 2\n") ==0){
complete_Vector.push_back(shift_states);
shift_states.clear();
continue;
}
// remove all unwanted char
for (int i = 0; i < (int)delim.size(); i++) {
complete_List[k].erase(remove(complete_List[k].begin(), complete_List[k].end(), delim[i]), complete_List[k].end());
}
// split into numbers ( delimiter -)
std::stringstream ss(complete_List[k]);
int end = complete_List[k].find("-");
while (end != -1) { // Loop until no delimiter is left in the string.
tokens_dw.push_back((DWORD)stoi(complete_List[k].substr(0, end)));
complete_List[k].erase(complete_List[k].begin(), complete_List[k].begin() + end + 1);
end = complete_List[k].find("-");
}
shift_states.push_back(tokens_dw);
tokens_dw.clear();
}
complete_Vector.push_back(shift_states);
shift_states.clear();
fclose(fp);
//wprintf(L" #### InsertKeyvalsFromVectorFile ended: \n");
//wprintf(L" +++++++ dimensions of Vector at END of writeFileToVector (languages..characters..shiftstates)\t\t %li..%li..%li\n", complete_Vector.size(), complete_Vector[0].size(),complete_Vector[0][0].size());
}
int createOneVectorFromBothKeyboards(v_dw_3D &All_Vector){
// here we copy all contents of the FILE ( US and other already available in the file) to All_Vector
//wprintf(L" +++++++ dimensions of Vector in createOneVectorFromBothKeyboards 2 \t\t\t\t\t\t %li..%li..%li\n", All_Vector.size(), All_Vector.size(),All_Vector.size());
// add contents of file to All_Vector
if( append_other_ToVector(All_Vector)) {
wprintf(L"ERROR: can't append Other ToVector \n");
return 2;
}
//wprintf(L" +++++++ dimensions of Vector in createOneVectorFromBothKeyboards 3 \t\t\t\t\t\t %li..%li..%li\n", All_Vector.size(), All_Vector[0].size(),All_Vector[0][0].size());
return 0;
}
bool writeVectorToFile(v_dw_3D V) {
std::string TxtFileName = "/Projects/keyman/keyman/linux/mcompile/keymap/VectorFile2.txt" ;
WCHAR DeadKey;
std::ofstream TxTFile(TxtFileName);
//TxTFile << "\n kbid << VKShiftState[j] << US VKMap[i] <<underlying << DE(incl Shiftstate) ch << DeadKey;\n";
//TxTFile << "\nname/Keycode -- unshifted -- shift -- altgr -- shift+altgr\n";
wprintf(L" +++++++ dimensions of Vector after split_US_To_3D_Vector (languages..characters..shiftstates)\t\t %li..%li..%li\n", V.size(), V[0].size(),V[0][0].size());
for ( int i=0; i< V.size();i++)
{
for ( int j=0; j< V[i].size();j++)
{
for ( int k=0; k< V[i][j].size();k++)
{
TxTFile << V[i][j][k] <<"-";
}
TxTFile << "\n";
}
if( i<1)
TxTFile << "Language 2\n";
}
TxTFile.close();
return true;
}
bool writeFileToVector(v_dw_3D& complete_Vector, const char* infile) {
wprintf(L" +++++++ dimensions of Vector at beginning of writeFileToVector (languages..characters..shiftstates)\t\t %li..%li..%li\n", complete_Vector.size(), complete_Vector.size(),complete_Vector.size());
wprintf(L" #### writeFileToVector started: \n");
FILE *fp;
char str[600];
std::vector<char> delim{' ', '[', ']', '}', ';', '\t', '\n'};
v_str_1D complete_List;
v_dw_1D tokens_dw;
v_dw_2D shift_states;
int k = -1;
/* opening file for reading */
fp = fopen("/Projects/keyman/keyman/linux/mcompile/keymap/VectorFile.txt" , "r");
if(fp == NULL) {
perror("Error opening file");
return(-1);
}
while (fgets(str, 600, fp) != NULL) {
k++;
//puts(str);
complete_List.push_back(str);
if (strcmp(str, "Language 2\n") ==0){
complete_Vector.push_back(shift_states);
shift_states.clear();
continue;
}
// remove all unwanted char
for (int i = 0; i < (int)delim.size(); i++) {
complete_List[k].erase(remove(complete_List[k].begin(), complete_List[k].end(), delim[i]), complete_List[k].end());
}
// split into numbers ( delimiter -)
std::stringstream ss(complete_List[k]);
int end = complete_List[k].find("-");
while (end != -1) { // Loop until no delimiter is left in the string.
tokens_dw.push_back((DWORD)stoi(complete_List[k].substr(0, end)));
complete_List[k].erase(complete_List[k].begin(), complete_List[k].begin() + end + 1);
end = complete_List[k].find("-");
}
shift_states.push_back(tokens_dw);
tokens_dw.clear();
}
complete_Vector.push_back(shift_states);
shift_states.clear();
wprintf(L" #### writeFileToVector ended: \n");
fclose(fp);
wprintf(L" +++++++ dimensions of Vector at END of writeFileToVector (languages..characters..shiftstates)\t\t %li..%li..%li\n", complete_Vector.size(), complete_Vector[0].size(),complete_Vector[0][0].size());
return(0);
}
bool CompareVector_To_VectorOfFile(v_dw_3D All_Vector,v_dw_3D File_Vector){
wprintf(L" #### CompareVector_To_VectorOfFile started: ");
wprintf(L" #### dimensions: %i %i %i -- %i %i %i \n", All_Vector.size() ,All_Vector[0].size(), All_Vector[0][0].size(),File_Vector.size() ,File_Vector[0].size(), File_Vector[0][0].size());
if (!(All_Vector.size() == File_Vector.size()) )return false;
if (!(All_Vector[0].size() == File_Vector[0].size())) return false;
if (!(All_Vector[0][0].size() == File_Vector[0][0].size())) return false;
wprintf(L" #### CompareVector_To_VectorOfFile dimensions OK \n");
for ( int i=0; i< All_Vector.size();i++) {
for ( int j=0; j< All_Vector[i].size();j++) {
for ( int k=0; k< All_Vector[i][j].size();k++){
if(( All_Vector[i][j][k] != File_Vector[i][j][k])) {
wprintf(L" All_Vector[%i][%i][%i]: %i %i File_Vector[i][j][k]\n", i,j,k, All_Vector[i][j][k], File_Vector[i][j][k]);
wprintf(L" DIFFERENT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
return false;
}
}
}
}
return true;
}
bool CompareVector_To_VectorOfFile_RGKEY(v_dw_2D Win_Vector,v_dw_2D Lin_Vector, v_dw_2D Map_Vector){
wprintf(L" #### CompareVector_To_VectorOfFile started: ");
wprintf(L" #### dimensions: %i %i -- %i %i \n", Win_Vector.size() ,Win_Vector[0].size(), Lin_Vector.size() ,Lin_Vector[0].size());
KMX_DWORD SC_Win, SC_Lin;
if (!(Win_Vector.size() == Lin_Vector.size()) )return false;
if (!(Win_Vector[0].size() == Lin_Vector[0].size())) return false;
// loop through both vectors and compare VK ( " e.g. do both vectors contain character "Q" ? ( that is VK = 81))
for ( int i=0; i< Lin_Vector.size();i++) {
// for capital letters A-Z
if ( (i >64) && (i<91)) {
if( Lin_Vector[i][1] == (Win_Vector[i][1] +8 )) {
//wprintf(L" GOOD entry for Win/Lin_Vector[%i][0]: Win_Vector[%i][1] (%i/ %c) <--> Lin_Vector[%i][1] (%i/ %c)\n", i, i,Win_Vector[i][0] ,Win_Vector[i][0], i,Lin_Vector[i][0],Lin_Vector[i][0]);
continue;
}
else
wprintf(L" WRONG entry for Win/Lin_Vector[%i][0]: Win_Vector[%i][1] (%i/ %c) <--> Lin_Vector[%i][1] (%i/ %c)\n", i, i,Win_Vector[i][0] ,Win_Vector[i][0], i,Lin_Vector[i][0],Lin_Vector[i][0]);
return false;
}
/*
// for unshifted letters a-z
else if ( (i >96) && (i<123)) {
}
// for all other characters
else {
}
*/
}
wprintf(L" No Difference found in A-Z :-) SC have an offset of 8 ");
return true;
}
/*bool CompareVector_To_VectorOfFile_RGKEY(v_dw_2D Win_Vector,v_dw_2D Lin_Vector, v_dw_2D Map_Vector){
wprintf(L" #### CompareVector_To_VectorOfFile started: ");
wprintf(L" #### dimensions: %i %i -- %i %i \n", Win_Vector.size() ,Win_Vector[0].size(), Lin_Vector.size() ,Lin_Vector[0].size());
KMX_DWORD SC_Win, SC_Lin;
if (!(Win_Vector.size() == Lin_Vector.size()) )return false;
if (!(Win_Vector[0].size() == Lin_Vector[0].size())) return false;
// loop through both vectors and compare VK ( " e.g. do both vectors contain character "Q" ? ( that is VK = 81))
for ( int i=0; i< Lin_Vector.size();i++) {
KMX_DWORD ValueOfVLin = Lin_Vector[i][0];
if ( ValueOfVLin == 999)
continue;
for ( int j=0; j< Win_Vector.size();j++) {
KMX_DWORD ValueOfVWin = Win_Vector[j][0];
if (ValueOfVWin ==ValueOfVLin) {
wprintf(L" same value found: %i; (Lin): %i-%i %i--%i (Win) \n", ValueOfVLin,Lin_Vector[i][0],Lin_Vector[i][1],Win_Vector[i][1],Win_Vector[i][0] );
// do I find these 2 SC as a pair (in a line) in map.txt
SC_Win = Win_Vector[j][0];
SC_Lin = Lin_Vector[i][0];
for( int k=0; k< Map_Vector.size(); k++) {
if((SC_Win == Map_Vector[k][1]) && ( SC_Lin== Map_Vector[k][1]))
wprintf(L" ....same value found: %i; (Lin): %i-%i %i--%i (Win) \n", ValueOfVLin,Lin_Vector[i][0],Lin_Vector[i][1],Win_Vector[i][1],Win_Vector[i][0] );
//wprintf(L" ... That EXISTS in map \n");
//else
//wprintf(L" ... That DOES NOT EXIST in map \n");
}
continue;
}
//else
wprintf(L" same value NOT found: %i\n", ValueOfVLin);//
}
}
return true;
}*/
bool write_RGKEY_FileToVector(v_dw_2D& shift_states, const char* infile) {
FILE *fp;
char str[600];
std::vector<char> delim{' ', '[', ']', '}','*', ')','(','>', '\t', '\n'};
v_str_1D complete_List;
v_dw_1D tokens_dw;
int k = -1;
for ( int i =0; i< 266;i++) {
tokens_dw.push_back(999);
tokens_dw.push_back(999);
shift_states.push_back(tokens_dw);
tokens_dw.clear();
}
fp = fopen(infile , "r");
if(fp == NULL) {
perror("Error opening file");
return(-1);
}
while (fgets(str, 600, fp) != NULL) {
k++;
complete_List.push_back(str);
// remove all unwanted char
for (int i = 0; i < (int)delim.size(); i++) {
complete_List[k].erase(remove(complete_List[k].begin(), complete_List[k].end(), delim[i]), complete_List[k].end());
}
std::stringstream ss(complete_List[k]);
int dash = complete_List[k].find("-");
int len2 =( (complete_List[k].size())-dash-2);
int size_l= sizeof(complete_List[k]);
tokens_dw.push_back((DWORD)stoi(complete_List[k].substr(0, dash)));
tokens_dw.push_back((DWORD)stoi(complete_List[k].substr(dash+1, (len2))));
int posInVec = tokens_dw[0];
shift_states[posInVec]=tokens_dw;
tokens_dw.clear();
}
fclose(fp);
return(0);
}
KMX_DWORD get_VirtualKey_Other_From_SC(KMX_DWORD SC , v_dw_3D &All_Vector) {
for( int i=0; i< (int)All_Vector[0].size();i++) {
//number keys return unshifted value ( e.g. 1, not !)
if(SC <= 19) {
if ( All_Vector[0][i][0] == SC)
return All_Vector[1][i][1];
}
// other keys
if((SC > 19) ) {
if ( All_Vector[0][i][0] == SC) {
// normal capital characters return the value of capital char ( e.g. A)
if ((All_Vector[1][i][2] >= 65 ) && (All_Vector[1][i][2] < 91 ))
return All_Vector[1][i][2];
// special characters return Keyman defined values (e.g. VK_ACCENT)
else
//return All_Vector[1][i][1];
return mapVK_To_char(SC);
}
}
}
return 0;
}
bool test_In_Out(v_dw_3D All_Vector){
for ( int i=0; i<61;i++)
{
KMX_DWORD out_Other= get_VirtualKey_Other_From_SC(i,All_Vector);
KMX_DWORD out_US= get_VirtualKey_US_From_SC(i,All_Vector);
if (out_Other==out_US) {
const wchar_t* ADD = L" ";
wprintf(L" out = %i --- %i (%c) ", out_Other, out_US, *ADD); }
else {
const wchar_t* ADD = L"*" ;
wprintf(L" out = %i --- %i (%c) ", out_Other, out_US, *ADD); }
wprintf(L"\n");
}
wprintf(L"-------------**\n");
for ( int i=0; i<61;i++)
{
KMX_DWORD VK_Other= get_VirtualKey_Other_From_SC(i,All_Vector);
KMX_DWORD SC_Other= get_SC_From_VirtualKey_Other(VK_Other,All_Vector);
if (i==SC_Other) {
const wchar_t* ADD = L" ";
wprintf(L"in %i ---> %i(%c) ---> %i (%c) \n", i, VK_Other,VK_Other, SC_Other ,*ADD);
}
else {
const wchar_t* ADD = L"!";
wprintf(L"in %i ---> %i(%c) ---> %i (%c) \n", i, VK_Other,VK_Other, SC_Other ,*ADD);
}
}
wprintf(L" 3 -------------**\n");
for ( int i=0; i<61;i++)
{
KMX_DWORD VK_Other= get_VirtualKey_US_From_SC(i,All_Vector);
KMX_DWORD SC_Other= get_SC_From_VirtualKey_US(VK_Other,All_Vector);
if (i==SC_Other) {
const wchar_t* ADD = L" ";
wprintf(L"IN %i ---> %i(%c) ---> %i (%c) \n", i, VK_Other,VK_Other, SC_Other ,*ADD);
}
else {
const wchar_t* ADD = L"!";
wprintf(L"IN %i ---> %i(%c) ---> %i (%c) \n", i, VK_Other,VK_Other, SC_Other ,*ADD);
}
}
}
// ToDo write 2 func for return pos of Key_US and Pos of Key_Other
// return the Scancode of for given VirtualKey of Other US
KMX_DWORD get_position_From_VirtualKey_US(KMX_DWORD VK_US , v_dw_3D &All_Vector){
// find correct row of char in US
for( int i=0; i< (int)All_Vector[0].size()-1;i++) {
if ( ( All_Vector[0][i][1] == VK_US ) || ( All_Vector[0][i][2] == VK_US )) {
//if ( ( All_Vector[0][i][1] == VK_US ) ) {
//wprintf(L" VK_US= %i .. i= %i .. %i\t\t %i (%c) : %i (%c) +++ %i\t\t %i (%c) : %i (%c) \n",VK_US , i,
// All_Vector[0][i][0] , All_Vector[0][i][1] ,All_Vector[0][i][1] , All_Vector[0][i][2] , All_Vector[0][i][2],
//All_Vector[1][i][0] , All_Vector[1][i][1] ,All_Vector[1][i][1] , All_Vector[1][i][2] , All_Vector[1][i][2] );
return i;
}
}
return 0; //_S2 what do I return if not found??
}
/*// _S2 where to put this??
std::wstring get_VirtualKey_US_from_iKey(KMX_DWORD iKey, ShiftState &ss, int &caps, v_dw_3D &All_Vector) {
int icaps;
KMX_DWORD pos = get_position_From_VirtualKey_US(iKey, All_Vector);
if (ss >9)
return L"";
if( ss < All_Vector[0][pos].size()-1) {
//if( ss < All_Vector[1][pos].size()-1) { // _S2 numbers need this
if ( ss % 2 == 0)
icaps = ss+2-caps;
if ( ss % 2 == 1)
icaps = ss+caps;
return std::wstring(1, (int) All_Vector[0][pos][icaps]);
//return std::wstring(1, (int) All_Vector[1][pos][icaps]);
}
return L"";
}
*/
int replace_PosKey_with_Keycode(std::string in) {
int out = returnIfCharInvalid;
// _S2 these are the Scancode-Values we use in Keyman ( = like the windows scancodes)
if ( in == "key<TLDE>") out = 49; /* 0X VK_ */ // TOASK correct ???
else if ( in == "key<AE01>") out = 1; /* 0X02 VK_1 */
else if ( in == "key<AE02>") out = 2; /* 0X03 VK_2 */
else if ( in == "key<AE03>") out = 3; /* 0X04 VK_3 */
else if ( in == "key<AE04>") out = 4; /* 0X05 VK_4 */
else if ( in == "key<AE05>") out = 5; /* 0X06 VK_5 */
else if ( in == "key<AE06>") out = 6; /* 0X07 VK_6 */
else if ( in == "key<AE07>") out = 7; /* 0X08 VK_7 */
else if ( in == "key<AE08>") out = 8; /* 0X09 VK_8 */
else if ( in == "key<AE09>") out = 9; /* 0X0A VK_9 */
else if ( in == "key<AE10>") out = 10; /* 0X0B VK_0 */
else if ( in == "key<AE11>") out = 12; /* 0X0C VK_MINUS */
else if ( in == "key<AE12>") out = 13; /* 0X0D VK_EQUALS */
else if ( in == "key<AD01>") out = 16; /* 0X10 VK_Q */
else if ( in == "key<AD02>") out = 17; /* 0X11 VK_W */
else if ( in == "key<AD03>") out = 18; /* 0X12 VK_E */
else if ( in == "key<AD04>") out = 19; /* 0X13 VK_R */
else if ( in == "key<AD05>") out = 20; /* 0X14 VK_T */
else if ( in == "key<AD06>") out = 21; /* 0X15 VK_Y */
else if ( in == "key<AD07>") out = 22; /* 0X16 VK_U */
else if ( in == "key<AD08>") out = 23; /* 0X17 VK_I */
else if ( in == "key<AD09>") out = 24; /* 0X18 VK_O */
else if ( in == "key<AD10>") out = 25; /* 0X19 VK_P */
else if ( in == "key<AD11>") out = 26; /* 0X1A VK_LEFTBRACE */
else if ( in == "key<AD12>") out = 27; /* 0X1B VK_RIGHTBRACE */
else if ( in == "key<AC01>") out = 30; /* 0X1E VK_A */
else if ( in == "key<AC02>") out = 31; /* 0X1F VK_S */
else if ( in == "key<AC03>") out = 32; /* 0X20 VK_D */
else if ( in == "key<AC04>") out = 33; /* 0X21 VK_F */
else if ( in == "key<AC05>") out = 34; /* 0X22 VK_G */
else if ( in == "key<AC06>") out = 35; /* 0X23 VK_H */
else if ( in == "key<AC07>") out = 36; /* 0X24 VK_J */
else if ( in == "key<AC08>") out = 37; /* 0X25 VK_K */
else if ( in == "key<AC09>") out = 38; /* 0X26 VK_L */
else if ( in == "key<AC10>") out = 39; /* 0X27 VK_SEMICOLON */
else if ( in == "key<AC11>") out = 40; /* 0X28 VK_APOSTROPHE */
else if ( in == "key<AC12>") out = 41; /* 0X29 VK_GRAVE */
else if ( in == "key<AB01>") out = 44; /* 0X2C VK_Z */
else if ( in == "key<AB02>") out = 45; /* 0X2D VK_X */
else if ( in == "key<AB03>") out = 46; /* 0X2E VK_C */
else if ( in == "key<AB04>") out = 47; /* 0X2F VK_V */
else if ( in == "key<AB05>") out = 48; /* 0X30 VK_B */
else if ( in == "key<AB06>") out = 49; /* 0X31 VK_N */
else if ( in == "key<AB07>") out = 50; /* 0X32 VK_M */
else if ( in == "key<AB08>") out = 51; /* 0X33 VK_ COMMA */
else if ( in == "key<AB09>") out = 52; /* 0X34 VK_DOT */
else if ( in == "key<AB10>") out = 53; /* 0X35 VK_SLASH */
else if ( in == "key<BKSL>") out = 54; /* 0X36 VK_RIGHTSHIFT */
else if ( in == "key<LSGT>") out = 55; /* 0X37 VK_RIGHTSHIFT */
else if ( in == "key<SPCE>") out = 65; /* 0X20 VK_SPACE */
return out;
}
// return RETURN NON SHIFTED CHAR [1] the VirtualKey of the US Keyboard for given Scancode
KMX_DWORD get_VirtualKey_Other_Layer1_From_SC(KMX_DWORD SC , v_dw_3D &All_Vector){
// find correct row of char in US
for( int i=0; i< (int)All_Vector[0].size()-1;i++) {
if ( All_Vector[0][i][0] == SC ) {
//wprintf(L" SC= %i .. i= %i .. %i:\t\t %i (%c) : %i (%c) --- ",SC , i, All_Vector[0][i][0] , All_Vector[0][i][1] ,All_Vector[0][i][1] , All_Vector[0][i][2] , All_Vector[0][i][2] );
return All_Vector[1][i][1] ;
}
}
return 0; //_S2 what do I return if not found??
}
// return RETURN NON SHIFTED CHAR [1] the VirtualKey of the US Keyboard for given Scancode
KMX_DWORD get_VirtualKey_Other_Layer2_From_SC(KMX_DWORD SC , v_dw_3D &All_Vector){
// find correct row of char in US
for( int i=0; i< (int)All_Vector[0].size()-1;i++) {
if ( All_Vector[0][i][0] == SC ) {
//wprintf(L" SC= %i .. i= %i .. %i:\t\t %i (%c) : %i (%c) --- ",SC , i, All_Vector[0][i][0] , All_Vector[0][i][1] ,All_Vector[0][i][1] , All_Vector[0][i][2] , All_Vector[0][i][2] );
return All_Vector[1][i][2] ;
}
int ertzu=99;
}
int ertzwrtu=99;
return 0; //_S2 what do I return if not found??
int eerurziurtzu=99;
}
// query All_Vector
// return RETURN NON SHIFTED CHAR [1] the VirtualKey of the Other Keyboard for given Scancode
void GDK_Check(guint keyval){
gchar * gg = gdk_keyval_name (keyval);
guint to_up = gdk_keyval_to_upper ( keyval);
guint to_low =gdk_keyval_to_lower ( keyval);
gboolean is_up= gdk_keyval_is_upper ( keyval);
gboolean is_low=gdk_keyval_is_lower ( keyval);
guint kv__frrom= gdk_keyval_from_name ((const gchar *) gg);
guint32 uni= gdk_keyval_to_unicode ( keyval);
gchar * gg1 = gdk_keyval_name (keyval);
guint lower;
guint upper;
gdk_keyval_convert_case (*gg1, &lower,&upper);
gdk_keyval_convert_case (GDK_KEY_A, &lower,&upper);
gdk_keyval_convert_case (66, &lower,&upper);
/*guint *lower; guint *upper;
gdk_keyval_convert_case (GDK_KEY_A, lower,upper);
gdk_keyval_convert_case (GDK_KEY_a, lower,upper);
gdk_keyval_convert_case (GDK_KEY_4, lower,upper);
gdk_keyval_convert_case (GDK_KEY_dollar, lower,upper);*/
}
static void PrintKeymapForCode(GdkKeymap *keymap, guint keycode) {
GdkModifierType consumed;
GdkKeymapKey *maps;
GdkEventKey* event;
guint *keyvals;
guint *keyvalsReturn;
gint *n_entries;
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;
wprintf(L" 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);
}
for( int ii=10; ii<63; ii++) {
//unshifted
GdkModifierType A1 = (GdkModifierType) (event->state & GDK_MODIFIER_MASK);
gdk_keymap_translate_keyboard_state (keymap, ii, (A1 ) , 0,keyvalsReturn, NULL, NULL, & consumed);
wprintf(L"\n ngdk_keymap_translate_keyboard_state: \t keycodeS=%u , n_entries %i\tUNSH: %s(%i)\t", ii, *n_entries, keyvalsReturn, *keyvalsReturn);
//caps
gdk_keymap_translate_keyboard_state (keymap, ii, GDK_LOCK_MASK , 0,keyvalsReturn, NULL, NULL, & consumed);
wprintf(L" CAPS: %s(%i)\t", keyvalsReturn, *keyvalsReturn);
//Shift
gdk_keymap_translate_keyboard_state (keymap, ii, GDK_SHIFT_MASK , 0,keyvalsReturn, NULL, NULL, & consumed);
wprintf(L" SH: %s(%i)\t", keyvalsReturn, *keyvalsReturn);
//SHIFT+CAPS
GdkModifierType A4 = (GdkModifierType) (event->state | (GDK_SHIFT_MASK | GDK_LOCK_MASK));
gdk_keymap_translate_keyboard_state (keymap, ii, A4 , 0,keyvalsReturn, NULL, NULL, & consumed);
wprintf(L" SH+CAPS: %s(%i) \t", keyvalsReturn, *keyvalsReturn);
//ALT-GR
gdk_keymap_translate_keyboard_state (keymap, ii, GDK_MOD5_MASK , 0,keyvalsReturn, NULL, NULL, & consumed);
//wprintf(L"\n NEU1 ngdk_keymap_translate_keyboard_state: \t hardware_keycodeS=%u, keyvalsReturn: %s\n", 52, keyvalsReturn);
wprintf(L" ALTGR: %s(%i)", keyvalsReturn, *keyvalsReturn);
//??
gdk_keymap_translate_keyboard_state (keymap, ii, GDK_MOD1_MASK , 0,keyvalsReturn, NULL, NULL, & consumed);
// wprintf(L" NEU1 ngdk_keymap_translate_keyboard_state: \t hardware_keycodeS=%u, keyvalsReturn: %s\n", 52, keyvalsReturn);
//wprintf(L" A5: %s(%i)", keyvalsReturn, *keyvalsReturn);
//??
gdk_keymap_translate_keyboard_state (keymap, ii, GDK_MOD2_MASK , 0,keyvalsReturn, NULL, NULL, & consumed);
//wprintf(L" NEU1 ngdk_keymap_translate_keyboard_state: \t hardware_keycodeS=%u, keyvalsReturn: %s\n", 52, keyvalsReturn);
//wprintf(L" A6: %s(%i)", keyvalsReturn, *keyvalsReturn);
//??
gdk_keymap_translate_keyboard_state (keymap, ii, GDK_MOD3_MASK , 0,keyvalsReturn, NULL, NULL, & consumed);
// wprintf(L" NEU1 ngdk_keymap_translate_keyboard_state: \t hardware_keycodeS=%u, keyvalsReturn: %s\n", 52, keyvalsReturn);
// wprintf(L" A7: %s(%i)", keyvalsReturn, *keyvalsReturn);
//??
GdkModifierType A8 = (GdkModifierType) (event->state & ~consumed & GDK_MODIFIER_MASK);
gdk_keymap_translate_keyboard_state (keymap, ii, GDK_MOD4_MASK , 0,keyvalsReturn, NULL, NULL, & consumed);
//wprintf(L" NEU1 ngdk_keymap_translate_keyboard_state: \t hardware_keycodeS=%u, keyvalsReturn: %s\n", 52, keyvalsReturn);
//wprintf(L" A8: %s(%i)", keyvalsReturn, *keyvalsReturn);
}
g_free(keyvals);
g_free(maps);
}
bool InsertKeyvalsFromKeymap(v_dw_3D &All_Vector,GdkKeymap * keymap){
// get the keyvals using GDK and copy into All_Vector
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 "other"-block[1][i][0]
All_Vector[1][i][0] = All_Vector[0][i][0];
// get Keyvals of this key and copy to unshifted/shifted in "other"-block[1][i][1] / block[1][i][2]
All_Vector[1][i][0+1] = getKeyvalsFromKeyCode(keymap,(All_Vector[1][i][0]),0); //shift state: unshifted:0
All_Vector[1][i][1+1] = getKeyvalsFromKeyCode(keymap,(All_Vector[1][i][0]),1); //shift state: shifted:1
//wprintf(L" Keycodes US dw : %d (US): -- %i (%c) -- %i (%c) ---- (other): %i (%c) -- %i(%c) \n",(All_Vector[1][i][0]),All_Vector[0][i][1],All_Vector[0][i][1],All_Vector[0][i][2],All_Vector[0][i][2],All_Vector[1][i][1] ,All_Vector[1][i][1],All_Vector[1][i][2],All_Vector[1][i][2]);
//wprintf(L" Keycodes ->Other dw:-: %d (US): -- %i (%c) -- %i (%c) \n\n",(All_Vector[1][i][0]),All_Vector[1][i][1],All_Vector[1][i][1],All_Vector[1][i][2],All_Vector[1][i][2]);
}
}
// _S2 can go later
KMX_DWORD writeKeyvalsFromKeymap(GdkKeymap *keymap, guint keycode, int shift_state_pos) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
KMX_DWORD out;
for ( int ii =1; ii< 255;ii++) {
KMX_DWORD out = getKeyvalsFromKeyCode(keymap,ii,0);
KMX_DWORD out2= getKeyvalsFromKeyCode(keymap,ii,1);
wprintf(L" ii = %i --> keymap = %i (%c)..%i(%c) \n",ii, out,out, out2,out2);
}
}
// _S2 not needed later
bool test(v_dw_3D &V) {
std::string extra = " ";
wprintf(L" +++++++ dimensions of whole Vector in test()\t\t\t\t\t\t\t %li..%li..%li\n", V.size(), V[0].size(),V[0][0].size());
wprintf(L"\n+++++++++ print some characters of US and Other +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
for ( int k=0; k<(int)V[0].size(); k++) {
if(V[0][k][2] != V[1][k][2] )
extra = " *** ";
else
extra = " ";
if (V[0].size()>0) {
/*wprintf(L" row (US) ...... SC= %i .. %i (%c) .. %i (%c) .. --- ",V[0][k][0] , V[0][k][1] , V[0][k][1] , V[0][k][2] , V[0][k][2] );
wprintf(L" \n");
wprintf(L" row (Other)..... SC= %i .. %i (%c) .. %i (%c) .. %s \n", V[1][k][0] , V[1][k][1], V[1][k][1] , V[1][k][2], V[1][k][2] , extra.c_str());
wprintf(L" \n");*/
}
}
wprintf(L"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
return true;
}
bool test_single(v_dw_3D &V) {
std::string extra = " ";
wprintf(L" +++++++ dimensions of single Vector in test_single()\t\t\t\t\t\t %li..%li..%li\n", V.size(), V[0].size(),V[0][0].size());
wprintf(L"\n +++++++++ print characters of SINGLE DW ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
for ( int k=0; k<(int)V[0].size(); k++) {
if (V[0].size()>0) {
wprintf(L" row (US) ...... %i .. %i (%c) .. %i (%c) ........ \n", V[0][k][0] , V[0][k][1] ,V[0][k][1] , V[0][k][2], V[0][k][2] );
}
}
wprintf(L" +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
return true;
}
// return the position of the VK in Other in All_Vector
/*KMX_DWORD get_position_From_VirtualKey_Other(KMX_DWORD VK_Other , v_dw_3D &All_Vector){
// find correct row of char in US
for( int i=0; i< (int)All_Vector[0].size()-1;i++) {
if ( ( All_Vector[1][i][1] == VK_Other ) || ( All_Vector[1][i][2] == VK_Other )) {
return i;
}
}
return 0; //_S2 what do I return if not found??
}*/// _S2 REMOVE
void Try_GDK(GdkKeymap *keymap, guint k ) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
// key 35(DE) = 187= OEM_PLUS;
gdk_keymap_get_entries_for_keycode (keymap, k, &maps, &keyvals, &count);
wprintf(L"----------------------------\nprinting out the characters given by keypress of key SC/Keycode:%i\n",k);
for (int i = 0; i < count; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" 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);
}
wprintf(L"----------------------------\n");
// finds a character on a key(KeyNr/SC) according to shiftstate/caps
// in: SC out: AsciiChar
GdkModifierType consumed;
/* GdkModifierType MOD_base = (GdkModifierType) ( ~GDK_MODIFIER_MASK );
gdk_keymap_translate_keyboard_state (keymap, k, MOD_base , 0, keyvals, NULL, NULL, & consumed);
int kv= (int)*keyvals;
//std::wstring kv_ws= std::wstring(1, (int) *keyvals);
wprintf(L" gdk_keymap_translate_keyboard_state (keycode/SC %i) gives unshifted: %i (%c) -- ", k, kv,kv );
GdkModifierType MOD_Shift = (GdkModifierType) ( GDK_SHIFT_MASK );
gdk_keymap_translate_keyboard_state (keymap, k, MOD_Shift , 0, keyvals, NULL, NULL, & consumed);
int kv1= (int)*keyvals;
//std::wstring kv_ws1= std::wstring(1, (int) *keyvals);
wprintf(L" and shifted %i (%c) \n", kv1,kv1 );*/
for ( int iii=1; iii< 66;iii++)
{
GdkModifierType consumed;
GdkModifierType MOD_base = (GdkModifierType) ( ~GDK_MODIFIER_MASK );
gdk_keymap_translate_keyboard_state (keymap, iii, MOD_base , 0, keyvals, NULL, NULL, & consumed);
int kv= (int)*keyvals;
//std::wstring kv_ws= std::wstring(1, (int) *keyvals);
wprintf(L" gdk_keymap_translate_keyboard_state (keycode/SC %i) gives unshifted: %i (%c) -- \t", iii, kv,kv );
GdkModifierType MOD_Shift = (GdkModifierType) ( GDK_SHIFT_MASK );
gdk_keymap_translate_keyboard_state (keymap, iii, MOD_Shift , 0, keyvals, NULL, NULL, & consumed);
int kv1= (int)*keyvals;
//std::wstring kv_ws1= std::wstring(1, (int) *keyvals);
wprintf(L" and shifted \t%i(%c) \n", kv1,kv1 );
}
wprintf(L"----------------------------\n");
// finds a character on a key(KeyNr/SC) according to shiftstate/caps
// in: SC out: AsciiChar
gchar * gch;
char * ch;
GdkModifierType consumedS;
for ( int iii=1; iii< 66;iii++)
{ /*gchar * gch1;
gch1 = gdk_keyval_name ((guint) iii);
std::string str_ch((char*)gch1);*/
gch = gdk_keyval_name ((guint) iii);
ch = (char*) gch;
std::string str_ch(ch);
//wprintf(L" key nr %i has the name: -- %s ", iii, str_ch.c_str());
GdkModifierType MOD_base = (GdkModifierType) ( ~GDK_MODIFIER_MASK );
gdk_keymap_translate_keyboard_state (keymap, iii, MOD_base , 0, keyvals, NULL, NULL, & consumedS);
int kv= (int)*keyvals;
//std::wstring kv_ws= std::wstring(1, (int) *keyvals);
wprintf(L" (keycode/SC %i) has the name: %s \t\t---- gives unshifted: %i (%c) -- \t", iii, str_ch.c_str(),kv,kv );
GdkModifierType MOD_Shift = (GdkModifierType) ( GDK_SHIFT_MASK );
gdk_keymap_translate_keyboard_state (keymap, iii, MOD_Shift , 0, keyvals, NULL, NULL, & consumedS);
int kv1= (int)*keyvals;
//std::wstring kv_ws1= std::wstring(1, (int) *keyvals);
wprintf(L" and shifted \t%i(%c) \n", kv1,kv1 );
}
wprintf(L"----------------------------\n");
GdkKeymapKey **keys1;
guint kval = 42;
gint *n_keys;
gboolean gboo = gdk_keymap_get_entries_for_keyval ( keymap, kval, keys1, n_keys);
wprintf(L" gdk_keymap_get_entries_for_keyval gives %i keys for this keyval( %i) :\n", *n_keys),(int) kval;
//for (int i = 0; i < *n_keys; i++) {
for (int i = 0; i < 1; i++) {
wprintf(L" character 43 can be obtained by pressing %i keys:, keys1[%i]\n",
*n_keys, *keys1[i]);
int iii=99;
}
wprintf(L"----------------------------\n");
// converts the Ascii-nr to the name specified in symbols-file( 35 -> numbersign( KEY_numbersign); 65 -> A( KEY_A)
// in: AsciiNr out: name in symbolfile
gchar * gch1;
char * ch1;
guint *keyvalsU;
guint *keyvalsS;
for ( int ii=10; ii<65;ii++) {
gch1 = gdk_keyval_name ((guint) ii);
ch1 = (char*) gch;
std::string str_ch1(ch1);
wprintf(L" key nr %i has the name: -- %s \n ", ii, str_ch1.c_str());
//g_free(keyvalsU);
//g_free(maps);
/*gdk_keymap_translate_keyboard_state (keymap, ii, MOD_Shift , 0, keyvalsS, NULL, NULL, & consumed);
int char_shifted = (int) *keyvalsS;*/
/* GdkModifierType MOD_base = (GdkModifierType) ( ~GDK_MODIFIER_MASK );
gdk_keymap_translate_keyboard_state (keymap, ii, MOD_base , 0, keyvalsS, NULL, NULL, & consumed);
int char_shifted = (int) *keyvalsS;*/
/* GdkModifierType MOD_Shift = (GdkModifierType) ( GDK_SHIFT_MASK );
gdk_keymap_translate_keyboard_state (keymap, ii, MOD_base , 0, keyvalsU, NULL, NULL, & consumed);
int char_unshifted = (int) *keyvalsU;*/
//wprintf(L" key nr %i has the name: -- %ls \t\tand prints --> %c\t(%i)-\n ", ii, gch.c_str(), char_shifted,char_shifted);
//wprintf(L", %c (%i) -- %c (%i) \n", ii,ii,char_shifted,char_shifted);
}
wprintf(L"----------------------------\n");
// convert the content of a key which is more than 1 char long to the char ( plus -> +)
// in: name in symbolfile out: Ascii-Nr
std::string name = "plus";
const char* name_ch = name.c_str();
guint name_int= gdk_keyval_from_name (name_ch);
wprintf(L" key with name '%s' has the (ASCII)value: :%i(%c)\n", name.c_str(), name_int,name_int);
wprintf(L"----------------------------\n");
guint32 g32= gdk_keyval_to_unicode ('R');
wprintf(L"----------------------------\n");
guint g= gdk_unicode_to_keyval ('\u0052');
wprintf(L"----------------------------\n");
}
std::wstring PrintKeymapForCodeReturnKeySym(GdkKeymap *keymap, guint VK, v_dw_3D &All_Vector, ShiftState ss, int caps ){
//GdkKeymap *keymap;
GdkModifierType consumed;
GdkKeymapKey *maps;
GdkEventKey* event;
guint *keyvals;
guint *keyvals_shift;
gint *n_entries;
gint count;
guint keycode;
GdkKeymapKey* keys;
gint n_keys;
gdk_keymap_get_entries_for_keyval(keymap, VK,&keys,&n_keys);
int pos_1 =get_position_From_VirtualKey_Other(VK , All_Vector, 99);
// wprintf(L" get_position_From_VirtualKey_Other %i of VK%i (%c) \n", pos_1, VK,VK);
keycode = All_Vector[1][pos_1][0];
if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count))
return L"1";
//unshifted
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);
std::wstring rV1= std::wstring(1, (int) *keyvals);
gchar * gg1 = gdk_keyval_name (*keyvals);
guint lower;
guint upper;
gdk_keyval_convert_case (*gg1, &lower,&upper);
std::wstring rv2= std::wstring(1, (int) upper);
std::wstring rv1= std::wstring(1, (int) *keyvals);
//return rv2;
return std::wstring(1, (int) *keyvals);
}
//SHIFT+CAPS
else if ( ( ss == Shft ) && ( caps ==1 )) {
GdkModifierType MOD_ShiftCaps= (GdkModifierType) ((GDK_SHIFT_MASK | GDK_LOCK_MASK));
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_ShiftCaps , 0, keyvals, NULL, NULL, & consumed);
std::wstring rV1= std::wstring(1, (int) *keyvals);
gchar * gg1 = gdk_keyval_name (*keyvals);
guint lower;
guint upper;
gdk_keyval_convert_case (*gg1, &lower,&upper);
std::wstring rv2= std::wstring(1, (int) upper);
std::wstring rv1= std::wstring(1, (int) *keyvals);
//return rv2;
return std::wstring(1, (int) *keyvals);
}
//Shift
else if (( ss == Shft ) && ( caps == 0 )) {
GdkModifierType MOD_Shift = (GdkModifierType) ( GDK_SHIFT_MASK );
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_Shift , 0, keyvals, NULL, NULL, & consumed);
std::wstring rV1= std::wstring(1, (int) *keyvals);
gchar * gg1 = gdk_keyval_name (*keyvals);
guint lower;
guint upper;
gdk_keyval_convert_case (*gg1, &lower,&upper);
//keyvals_shift = gg1;
std::wstring rv2= std::wstring(1, (int) upper);
std::wstring rv1= std::wstring(1, (int) *keyvals);
return std::wstring(1, (int) *keyvals);
}
//caps
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);
std::wstring rV1= std::wstring(1, (int) *keyvals);
gchar * gg1 = gdk_keyval_name (*keyvals);
guint lower;
guint upper;
gdk_keyval_convert_case (*gg1, &lower,&upper);
std::wstring rv2= std::wstring(1, (int) upper);
std::wstring rv1= std::wstring(1, (int) *keyvals);
//return rv2;
return std::wstring(1, (int) *keyvals);
}
/*//ALT-GR
else if {
GdkModifierType MOD_AltGr = (GdkModifierType) ( GDK_MOD5_MASK );
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_AltGr , 0, keyvals, NULL, NULL, & consumed);
return *keyvals;
}*/
else
return L"0";
}
/*
bool write_rgKey_ToFile(std::vector<KMX_VirtualKey*> rgKey ){
std::string RGKey_FileName="/Projects/keyman/keyman/linux/mcompile/keymap/rgKey_lin.txt";
std::wofstream TxTFile(RGKey_FileName);
for ( int i=0; i< rgKey.size();i++) {
if(rgKey[i] != NULL) {
TxTFile << rgKey[i]->VK() << "-" << rgKey[i]->SC()<< " -> ( " << rgKey[i]->KMX_GetShiftState(Base, 0) << "-" << rgKey[i]->KMX_GetShiftState(Base, 1) << " )"
<< " *-* ( " << rgKey[i]->KMX_GetShiftState(Shft, 0) << "-" << rgKey[i]->KMX_GetShiftState(Shft, 1) << " )";
TxTFile << "\n";
}
}
TxTFile.close();
return true;
}
// _S2 can go later: check if all correct
/*write_rgKey_ToFile(rgKey) ;
v_dw_2D V_lin,V_win,V_map;
write_RGKEY_FileToVector(V_lin, "rgKey_lin.txt");
write_RGKEY_FileToVector(V_win, "rgKey_Win.txt");
write_RGKEY_FileToVector(V_map, "map.txt");
CompareVector_To_VectorOfFile_RGKEY( V_win, V_lin,V_map);*/
/* // _S2 maybe not needed
bool get_US_Keysym_From_OtherKeysym(v_str_3D &All_Vector, int inOther, int &OutUS){
MyCoutW(L" #### get_US_Char_FromOther of keymap started", 1);
// loop and find char in Other; then find char of US
for( int i=0; i< All_Vector[1].size();i++) {
for( int j=1; j< (int)All_Vector[1][0].size();j++) {
int KeysymUS = (int) *All_Vector[0][i][j].c_str();
int KeysymOther = (int) *All_Vector[1][i][j].c_str();
std::wstring KeysymUS_wstr = wstring_from_string(All_Vector[1][i][j]);
if( inOther == KeysymOther ) {
OutUS = KeysymUS;
return true;
}
}
}
MyCoutW(L" #### get_US_Char_FromOther of keymap ended", 1);
return true;
}*/
// _S2 maybe I will need that later??
/* static xkb_keysym_t get_ascii(struct xkb_state *state, xkb_keycode_t keycode) {
struct xkb_keymap *keymap;
xkb_layout_index_t num_layouts;
xkb_layout_index_t layout;
xkb_level_index_t level;
const xkb_keysym_t *syms;
int num_syms;
keymap = xkb_state_get_keymap(state);
num_layouts = xkb_keymap_num_layouts_for_key(keymap, keycode);
for (layout = 0; layout < num_layouts; layout++) {
level = xkb_state_key_get_level(state, keycode, layout);
num_syms = xkb_keymap_key_get_syms_by_level(keymap, keycode,
layout, level, &syms);
if (num_syms != 1)
continue;
if (syms[0] > 0 && xkb_keysym_to_utf32(syms[0]) < 128)
return syms[0];
}
return XKB_KEY_NoSymbol;
}
*/
/*static xkb_keysym_t get_ascii_SAB(xkb_keycode_t keycode) {
xkb_layout_index_t num_layouts;
xkb_layout_index_t layout;
xkb_level_index_t level;
const xkb_keysym_t *syms;
int num_syms;
struct xkb_context *ctx;
ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (!ctx)
MyCoutW(L" # Error in xkb_context_new", 1);
// get a keymap from a given name ( is)
struct xkb_keymap *keymap_is;
struct xkb_rule_names names = {
// Example RMLVO for Icelandic Dvorak.
.rules = NULL,
.model = "pc105",
.layout = "is",
.variant = "dvorak",
.options = "terminate:ctrl_alt_bksp"
};
keymap_is = xkb_keymap_new_from_names(ctx, &names, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (!keymap_is)
MyCoutW(L" # Error in xkb_keymap_new_from_names", 1);
// how many layouts are in keymap ( here is: 4)
num_layouts = xkb_keymap_num_layouts_for_key(keymap_is, keycode);
std::wcout << L" num_layouts: " << num_layouts << L"\n";
for (layout = 0; layout < num_layouts; layout++) {
// how many levels do we have per key e.g. [a, A, ä, ascitilde ]
std::wcout << L" layout: Nr" << layout << L"\n";
xkb_level_index_t level = xkb_keymap_num_levels_for_key ( keymap_is, keycode, layout ) ;
std::wcout << L" we have level nr of : " << level << L"\n";
for( int j=0; j< level;j++)
{
std::wcout << L" j: " << j << L"\n";
// get the keysym(characzter) in level level ( get a for level 1; A for level 2;)
num_syms = xkb_keymap_key_get_syms_by_level(keymap_is, keycode, layout, j, &syms);
std::wcout << L" num_syms(j): " << num_syms << L"\n";
// if no entry for this level
if (num_syms != 1)
continue;
if (syms[0] > 0 && xkb_keysym_to_utf32(syms[0]) < 128)
return syms[0];
}
}
return XKB_KEY_NoSymbol;
}*/
// bak all tries for DoConvert here:
/*
//#include "XKeyboard.h"
#include "/usr/include/libxklavier/xklavier.h"
#include "/usr/include/libxklavier/xkl_config_item.h"
#include "/usr/include/libxklavier/xkl_config_rec.h
#include "/usr/include/libxklavier/xkl_config_registry.h
#include "/usr/include/libxklavier/xkl_engine.h
#include "/usr/include/libxklavier/xkl_engine_marshal.h
#include "/usr/include/libxklavier/xkl-enum-types.h
#include "/usr/include/libxklavier/xklavier.h"
#include "/usr/include/libxklavier/xklavier.h"
std::wcout << L"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\n";
std::string st = std::locale("").name() ;
std::wstring wstr = wstring_from_string(st);
std::wcout << wstr;
std::wcout << L"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\n";
xklgetg
//const char** ccc = XklGetGroupNames ( ) ;
//xkl_engine_get_groups_names
//const char** cccc = XkbGetNames ( ) ;
/*
Display *dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "Cannot open display\n");
exit(1);
}
XkbStateRec state;
XkbGetState(dpy, XkbUseCoreKbd, &state);
XkbDescPtr desc = XkbGetKeyboard(dpy, XkbAllComponentsMask, XkbUseCoreKbd);
char*symbols = XGetAtomName(dpy, desc->names->symbols);
//char *group = XGetAtomName(dpy, desc->names->groups[state.group]);
//printf("Full name: %s\n", group);
XKeyboard xkb;
std::string cGrpName=xkb.currentGroupName(); //return somethings like "USA"
std::string cGrpSymb=xkb.currentGroupSymbol(); //return somethings like "us"
xkb.setGroupByNum(0);//set keyboard layout to first layout in available ones
//wprintf(L"Full name: %s\n", symbols);
//std::wcout << L"qqqqqqqqqqqqqqqqqqqq: " << *symbols;
xkb_keysym_t in;
xkb_keysym_t out;
std::vector < int > vi ={34,39,43,47,48,61,57};
for( int i=0; i<vi.size();i++)
{
in = vi[i];
out = get_ascii_SAB(in) ;
std:: wcout << L" in : " << in << L" out : " << out << L" ( " << (char)out << L")\n " ;
}
MyCoutW(L"#### KMX_DoConvert of keymap started", 1);
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;
}
MyCoutW(L" # Top checks of keymap OK", 1);
das geht... v
struct xkb_context *ctx;
ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (!ctx)
MyCoutW(L" # Error in xkb_context_new", 1);
struct xkb_keymap *keymap;
struct xkb_rule_names names = {
// Example RMLVO for Icelandic Dvorak.
.rules = NULL,
.model = "pc105",
.layout = "is",
.variant = "dvorak",
.options = "terminate:ctrl_alt_bksp"
};
keymap = xkb_keymap_new_from_names(ctx, &names,
XKB_KEYMAP_COMPILE_NO_FLAGS);
if (!keymap)
MyCoutW(L" # Error in xkb_keymap_new_from_names", 1);
MyCoutW(L" # XKB setup OK", 1);
xkb_layout_index_t num_layouts;
xkb_layout_index_t layout;
xkb_level_index_t level;
const xkb_keysym_t *syms;
int num_syms;
std::vector < int > vi ={34,39,43,47,48,61,57};
for( int i=0; i<vi.size();i++)
{
num_syms = xkb_keymap_key_get_syms_by_level(keymap, vi[i], layout, 0, &syms);
std::wcout << L"keycode in: " << vi[i] << L" keysym out: " << num_syms << L"\n";;
}
das geht... ^
//num_syms = xkb_keymap_key_get_syms_by_level(keymap, keycode, layout, level, &syms);
// *******************************************************************************************************************
struct xkb_keymap *keymap1;
xkb_layout_index_t num_layouts;
xkb_layout_index_t layout;
xkb_level_index_t level;
const xkb_keysym_t *syms;
int num_syms;
keymap1 = xkb_state_get_keymap(state);
num_layouts = xkb_keymap_num_layouts_for_key(keymap1, keycode);
for (layout = 0; layout < num_layouts; layout++) {
level = xkb_state_key_get_level(state, keycode, layout);
num_syms = xkb_keymap_key_get_syms_by_level(keymap1, keycode,
layout, level, &syms);
if (num_syms != 1)
continue;
if (syms[0] > 0 && xkb_keysym_to_utf32(syms[0]) < 128)
return syms[0];
}
//return XKB_KEY_NoSymbol;
MyCoutW(L" # XKB get syn OK", 1);
// https://cpp.hotexamples.com/examples/-/-/xkb_state_get_keymap/cpp-xkb_state_get_keymap-function-examples.html
int num;
lv = xkb_state_key_get_level(state, code + KBDXKB_SHIFT, lo);
num = xkb_keymap_key_get_syms_by_level(keymap, code + KBDXKB_SHIFT, lo, lv, &s);
*/
/*int get_OtherKeysym_From_US_Keysym(v_str_3D &All_Vector,int inUS){
int outOther;
MyCoutW(L" #### get_OtherKeysym_From_US_Keysym of keymap started", 1);
wprintf(L" in Us ##################### %i and KeysymsUS : \n", inUS );
// loop and find char in US; then find char of Other
for( int i=0; i< (int)All_Vector[1].size();i++) {
for( int j=0; j< (int)All_Vector[1][0].size();j++) {
int KeysymUS = (int) *All_Vector[0][i][j].c_str();
int KeysymOther = (int) *All_Vector[1][i][j].c_str();
std::wstring KeysymUS_wstr = wstring_from_string(All_Vector[0][i][j]);
//if ( inUS == 58)
wprintf(L" in Us %i and KeysymsUS %i : \n", inUS ,KeysymUS );
//wprintf(L" ................................................................................... inxx: %s outxx: %s %s\n", All_Vector[0][25][2].c_str(),All_Vector[1][25][0].c_str(),All_Vector[1][25][2].c_str());
if( inUS == KeysymUS ) {
//wprintf(L" FOUND Value in US !!!!! : %i out ########: %S \n", inUS,KeysymUS_wstr.c_str());
//wprintf(L" FOUND Value in US !!!!! : %i out ########: %S \n", inUS,KeysymUS_wstr.c_str());
// wprintf(L" FOUND Value in OTHER !!!!! : Other in: %i ( %s ) -- Keycode : %s -- US out ########: %i ( %s ) \n", KeysymUS,All_Vector[0][i][j].c_str(), All_Vector[1][i][0].c_str() , KeysymOther,All_Vector[1][i][j].c_str());
wprintf(L" get_OtherKeysym_From_US_Keysym FOUND Value in US !!!!! : Other in: %i ( %s ) -- Keycode : %s -- US out ########: %i ( %s ) \n",
KeysymUS,All_Vector[0][i][j].c_str(), All_Vector[1][i][0].c_str() , KeysymOther,All_Vector[1][i][j].c_str());
//wprintf(L" FOUND 2 Value in OTHER !!!!! : Other in: %i ( %s ) -- Keycode : %s -- US out ########: %i ( %s ) \n", KeysymOther,All_Vector[1][i][j].c_str(), All_Vector[1][i][0].c_str() , KeysymUS,All_Vector[0][i][j].c_str());
outOther = KeysymOther;
MyCoutW(L" #### get_OtherKeysym_From_US_Keysym of keymap ended", 1);
return outOther;
}
}
}
MyCoutW(L" #### get_US_Char_FromOther of keymap ended", 1);
return true;
}
*/
bool is_Letter(int pos, v_dw_3D & All_Vector){
if( ( All_Vector[1][pos][1] == All_Vector[1][pos][2] + 32) )
return true;
return false;
}
bool is_Number(int pos, v_dw_3D & All_Vector){
if( (All_Vector[1][pos][1] >= 48) && (All_Vector[1][pos][1] <= 57) )
return true;
return false;
}
bool is_Special(int pos, v_dw_3D & All_Vector){
if( !is_Number && !is_Letter)
return true;
return false;
}
bool is_Edges(int pos, v_dw_3D & All_Vector){
if( (All_Vector[1][pos][1] == 48))
return true;
return false;
}
// _S2 can go later
std::wstring get_VirtualKey_Other_from_iKey(KMX_DWORD iKey, ShiftState &ss, int &caps, v_dw_3D &All_Vector) {
// _S2 this will find the correct row in All_Vector
//( e.g. get_position_From_VirtualKey_Other(65 ,All_Vector.99 ) returns 25
// All_Vector[25] contains SC(38), unshifted A (97) shifted A (65) )
KMX_DWORD pos = get_position_From_VirtualKey_Other(iKey, All_Vector,99);
int icaps;
if (ss >9)
return L"";
if( ss < All_Vector[1][pos].size()-1) {
// ss 0,2,4...
if ( ss % 2 == 0) {
// aAAa 4$$4
if ( is_Letter(pos, All_Vector) || is_Number(pos, All_Vector))
icaps = ss+2-caps;
// ..:: ##''
else
icaps = ss+1;
}
// ss 1,3,5...
if ( ss % 2 == 1) {
// aAAa 4$$4
if ( is_Letter(pos, All_Vector) || is_Number(pos, All_Vector))
icaps = ss+caps;
// ..:: ##''
else
icaps = ss+1;
}
return std::wstring(1, (int) All_Vector[1][pos][icaps]);
}
return L"";
}
// _S2 This can go later
/*KMX_DWORD get_VirtualKey_Other_From_SC(KMX_DWORD SC , v_dw_3D &All_Vector) {
for( int i=0; i< (int)All_Vector[0].size();i++) {
//number keys return unshifted value ( e.g. 1, not !)
if(SC <= 19) {
if ( All_Vector[0][i][0] == SC)
return All_Vector[1][i][1];
}
// other keys
if((SC > 19) ) {
if ( All_Vector[0][i][0] == SC) {
// normal capital characters return the value of capital char ( e.g. A)
if ((All_Vector[1][i][2] >= 65 ) && (All_Vector[1][i][2] < 91 ))
return All_Vector[1][i][2];
// special characters return Keyman defined values (e.g. VK_ACCENT)
else
//return All_Vector[1][i][1];
return mapVK_To_char(SC);
}
}
}
return 0;
}
*/
// _S2 not needed, can go later
// return RETURN NON SHIFTED CHAR [1] the VirtualKey of the US Keyboard for given Scancode
KMX_DWORD get_VirtualKey_US_From_SC(KMX_DWORD SC , v_dw_3D &All_Vector){
// find correct row of char in US
for( int i=0; i< (int)All_Vector[0].size()-1;i++) {
if ( All_Vector[0][i][0] == SC ) {
return All_Vector[0][i][1] ;
}
}
return 0; //_S2 TODO what do I return if not found??
}
// return the Scancode of for given VirtualKey of Other Keyboard
KMX_DWORD get_SC_From_VirtualKey_Other(KMX_DWORD VK_Other , v_dw_3D &All_Vector){
// find correct row of char in US
for( int i=0; i< (int)All_Vector[1].size()-1;i++) {
if ( All_Vector[1][i][1] == VK_Other ) {
return All_Vector[1][i][0] ;
}
}
return 0; //_S2 TODO what do I return if not found??
}
// return the Scancode of for given VirtualKey of Other US
KMX_DWORD get_SC_From_VirtualKey_US(KMX_DWORD VK_US , v_dw_3D &All_Vector){
// find correct row of char in US
for( int i=0; i< (int)All_Vector[0].size()-1;i++) {
if ( All_Vector[0][i][2] == VK_US ) {
return All_Vector[0][i][0] ;
}
}
return 0; //_S2 TODO what do I return if not found??
}
// returns the position in All_Vector where VK_Other is found
KMX_DWORD get_position_From_VirtualKey_Other(KMX_DWORD VK_Other , v_dw_3D &All_Vector, int which_columns) {
// find correct row of char in US
if((which_columns <0 ) )
return 0;
// search all columns
if(which_columns >(int)All_Vector[1][0].size()) {
for( int i=1; i< (int)All_Vector[1][0].size();i++) {
for( int j=0; j< (int)All_Vector[1].size()-1;j++) {
if ( ( All_Vector[1][j][i] == VK_Other ) )
return j;
}
}
}
else {
for( int j=0; j< (int)All_Vector[1].size()-1;j++) {
if ( ( All_Vector[1][j][which_columns] == VK_Other ) )
return j;
}
}
return 0; //_S2 TODO what do I return if not found??
}
// returns KeyCode which hold the Keysym/Keyval (in unshifted, shifted)
KMX_DWORD get_KeyCode_From_KeyVal_GDK(GdkKeymap *keymap, UINT Keyval ) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
for (int k=0; k<255 ; k++ ){
if (gdk_keymap_get_entries_for_keycode (keymap, k, &maps, &keyvals, &count)) {
if ( (keyvals[0] == Keyval) || (keyvals[1] == Keyval) ) {
return (KMX_DWORD) maps[0].keycode;
}
}
}
g_free(keyvals);
g_free(maps);
return 0; //_S2 TODO what do I return if not found??
}
// returns KeyCode which holds the Keysym (in unshifted, shifted)
/*KMX_DWORD get_SC_From_Keycode_GDK(GdkKeymap *keymap, UINT SC ) {
GdkKeymapKey *maps;
guint *keyvals;
gint count;
for (int k=0; k<255 ; k++ ){
if (gdk_keymap_get_entries_for_keycode (keymap, k, &maps, &keyvals, &count)) {
if ( (keyvals[0] == SC) || (keyvals[1] == SC) ) {
return (KMX_DWORD) maps[0].keycode;
}
}
}
g_free(keyvals);
g_free(maps);
return 0; //_S2 TODO what do I return if not found??
}*/
KMX_DWORD mapVK_To_char(KMX_DWORD SC ){
// if there is a Keyman VK.. defined map to Keyman VKcode
// if ( SC == 49) return VK_BKSLASH; /* ; 220 = ` oder ^ */
// if ( SC == 20) return VK_LBRKT; /* ; 219 = - oder ß */
// if ( SC == 21) return VK_RBRKT; /* ; 221 = = oder ' */
// if ( SC == 34) return VK_COLON; /* ; 186 VK_OEM_4 = [ oder ü */
//if ( SC == 35) return VK_EQUAL; /* ; 187 = ] oder + */
// if ( SC == 47) return VK_ACCENT; /* ; 192 VK_OEM_1 = : oder ö */
// if ( SC == 48) return VK_QUOTE; /* ' 222 VK_OEM_7 = " oder Ä */
// if ( SC == 51) return VK_SLASH; /* ; 191 = \ oder # */
// if ( SC == 59) return VK_COMMA; /* ; 188 = , oder , */
// if ( SC == 60) return VK_PERIOD; /* ; 190 = . oder . */
// if ( SC == 61) return VK_HYPHEN; /* ; 189 = / oder - */
// if ( SC == 65) return VK_SPACE; /* ; 32 VK_SPACE = oder */
// else
return SC;
}
// _S2 TODO is this correct ??
KMX_DWORD mapChar_To_VK(KMX_DWORD chr ){
// if there is a Keyman VK.. defined map to Keyman VKcode
// if ( SC == 49) return VK_BKSLASH; /* ; 220 = ` oder ^ */
// if ( SC == 20) return VK_LBRKT; /* ; 219 = - oder ß */
// if ( SC == 21) return VK_RBRKT; /* ; 221 = = oder ' */
// if ( chr == VK_COLON) return 220; /* ; 186 VK_OEM_4 = [ oder ü */
// if ( chr == 187) return 42; /* ; 186 VK_OEM_4 = [ oder ü */
// if ( SC == 35) return VK_EQUAL; /* ; 187 = ] oder + */
// if ( SC == 47) return VK_ACCENT; /* ; 192 VK_OEM_1 = : oder ö */
// if ( SC == 48) return VK_QUOTE; /* ' 222 VK_OEM_7 = " oder Ä */
// if ( SC == 51) return VK_SLASH; /* ; 191 = \ oder # */
// if ( SC == 59) return VK_COMMA; /* ; 188 = , oder , */
// if ( SC == 60) return VK_PERIOD; /* ; 190 = . oder . */
// if ( SC == 61) return VK_HYPHEN; /* ; 189 = / oder - */
// if ( SC == 65) return VK_SPACE; /* ; 32 VK_SPACE = oder */
// else
return chr;
}
void Inspect_Key_S2(GdkKeymap *keymap ) {
guint KCode = 34;
guint Keyval_Base= 35;
guint Keyval_Shift = 39;
guint Keyval = Keyval_Base;
gchar* KeyvalName_Base;
char* KeyvalName_ch_Base;
gchar* KeyvalName_Shift;
char* KeyvalName_ch_Shift;
GdkKeymapKey* keys;
gint n_keys;
GdkKeymapKey *maps;
guint *keyvals;
guint *keyvals_shift;
gint *n_entries;
gint count;
GdkModifierType consumed;
// ___ ___ ___ ___
// | A | | Ö | | & | | ' |
// Key |_a_| |_ö_| |_6_| |_#_|
// KeyCode 38 47 15 51
// Keyval Base 97 246 54 35
// Keyval Shift 65 214 38 39
// KeyValname(Base) a odiaresis 6 apostrophe
// KeyValname(Shift) A Odiaresis ampersand numbersign
//---------------------------------------
gchar * gc= gdk_keyval_name (214);
gchar * gc0= gdk_keyval_name (65);
//---------------------------------------
std::string sr = "odiaeresis";
gchar * chr= (gchar*) sr.c_str(); ;
guint gi= gdk_keyval_from_name (chr);
//---------------------------------------
//guint32 gdk_keyval_to_unicode (guint keyval);
guint32 gg323 = gdk_keyval_to_unicode (65106);
//---------------------------------------
//guint gdk_unicode_to_keyval (guint32 wc);
guint GGGIII= gdk_unicode_to_keyval (gg323);
//---------------------------------------
Keyval= Keyval_Shift;
// finds ALL CHARACTERS ON KEY KCode for all levels and groups
// key 51 gr=0 (DE); lev=0 keyval 35(#)
// key 51 gr=0 (FR); lev=0 keyval 35(*)
// key 51 gr=0 (US); lev=0 keyval 35(\)
// key 51 gr=0 (ES); lev=0 keyval 35(\)
gdk_keymap_get_entries_for_keycode(keymap, KCode, &maps, &keyvals, &count);
wprintf(L"----------------------------\nprinting out the characters given by keypress of key SC/Keycode:%i\n",KCode);
for (int i = 0; i < count; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" 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);
}
// finds all levels, groups WHERE KEYVAL IS LOCATED
// ' is on key 13, gr=0,lev=0 for swedish;
// ' is on key 51, gr=0,lev=1 for german;
// ' is on key 48, gr=2,lev=0 for english?;
// ' is on key 48, gr=3,lev=0 for spanish?;
//gdk_keymap_get_entries_for_keyval(keymap, Keyval,&keys,&n_keys);
gdk_keymap_get_entries_for_keyval(keymap, Keyval,&keys,&n_keys);
wprintf(L"----------------------------\nprinting out the characters given by keypress of Keyval :%i\n",Keyval);
for (int i = 0; i < n_keys; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" i=%d, Keyval=%d, (%c) keycode %i group %i level %i\n",
i, Keyval,Keyval, keys[i].keycode,keys[i].group,keys[i].level);
}
//---------------------------------------
gint Key_on_DE;
gint KeyVal_on_US;
Keyval = 214;
gdk_keymap_get_entries_for_keyval(keymap, Keyval,&keys,&n_keys);
wprintf(L"----------------------------\nprinting out the characters given by keypress of Keyval :%i\n",Keyval);
for (int i = 0; i < n_keys; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" i=%d, Keyval=%d, (%c) keycode %i group %i level %i\n",
i, Keyval,Keyval, keys[i].keycode,keys[i].group,keys[i].level);
}
for (int i = 0; i < n_keys; i++) {
if (keys[i].group ==0)
Key_on_DE = keys[i].keycode;
}
g_free(keyvals);
g_free(maps);
gdk_keymap_get_entries_for_keycode(keymap, Key_on_DE, &maps, &keyvals, &count);
wprintf(L"----------------------------\nprinting out the characters given by keypress of key SC/Keycode:%i\n",Key_on_DE);
for (int i = 0; i < count; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" 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);
}
for (int i = 0; i < count; i++) {
if ((maps[i].group ==2 )&& (maps[i].level ==0))
KeyVal_on_US = maps[i].keycode;
}
const UINT VK_US= ScanCodeToUSVirtualKey[KeyVal_on_US-8];
const UINT VK_US2= USVirtualKeyToScanCode[KeyVal_on_US];
GdkModifierType MOD_base = (GdkModifierType) ( ~GDK_MODIFIER_MASK );
gdk_keymap_translate_keyboard_state (keymap, KCode, MOD_base , 0, keyvals, NULL, NULL, & consumed);
std::wstring rV1= std::wstring(1, (int) *keyvals);
KeyvalName_Base = gdk_keyval_name (Keyval_Base);
KeyvalName_ch_Base = (char*) KeyvalName_Base;
std::string KeyvalName_str_Base(KeyvalName_ch_Base);
KeyvalName_Shift= gdk_keyval_name (Keyval_Shift);
KeyvalName_ch_Shift = (char*) KeyvalName_Shift;
std::string KeyvalName_str_Shift(KeyvalName_ch_Shift);
wprintf(L" keyval_Base %i has the name: %s ------ ", Keyval_Base, KeyvalName_str_Base.c_str());
wprintf(L" keyval_Shift %i has the name: %s \n", Keyval_Shift, KeyvalName_str_Shift.c_str());
//wprintf(L" keyval ");
int stop=99;
g_free(keyvals);
g_free(maps);
}
void Inspect_Key_S(GdkKeymap *keymap ) {
guint KCode = 51;
guint Keyval_Base= 35;
guint Keyval_Shift = 60;
guint Keyval = Keyval_Base;
gchar* KeyvalName_Base;
char* KeyvalName_ch_Base;
gchar* KeyvalName_Shift;
char* KeyvalName_ch_Shift;
GdkKeymapKey* keys;
gint n_keys;
GdkKeymapKey *maps;
guint *keyvals;
guint *keyvals_shift;
gint *n_entries;
gint count;
GdkModifierType consumed;
// ___ ___ ___ ___
// | A | | Ö | | & | | ' |
// Key |_a_| |_ö_| |_6_| |_#_|
// KeyCode 38 47 15 51
// Keyval Base 97 246 54 35
// Keyval Shift 65 214 38 39
// KeyValname(Base) a odiaresis 6 apostrophe
// KeyValname(Shift) A Odiaresis ampersand numbersign
//---------------------------------------
gchar * gc= gdk_keyval_name (60);
gchar * gc0= gdk_keyval_name (94);
//---------------------------------------
std::string sr = "less";
gchar * chr= (gchar*) sr.c_str(); ;
guint gi= gdk_keyval_from_name (chr);
//---------------------------------------
/*std::string sr4= "acute";
gchar * chr4= (gchar*) sr4.c_str(); ;
guint gi4= gdk_keyval_from_name (chr4);
//---------------------------------------
std::string sr1= "dead_grave";
gchar * chr1= (gchar*) sr1.c_str(); ;
guint gi1= gdk_keyval_from_name (chr1);
//---------------------------------------
std::string sr2 = "grave";
gchar * chr2= (gchar*) sr2.c_str(); ;
guint gi2= gdk_keyval_from_name (chr2);
//---------------------------------------
std::string sr21 = "dead_abovedot";
gchar * chr21= (gchar*) sr21.c_str(); ;
guint gi21= gdk_keyval_from_name (chr21);*/
//---------------------------------------
//---------------------------------------
//guint32 gdk_keyval_to_unicode (guint keyval);
/*guint32 gg323 = gdk_keyval_to_unicode (65106);
guint32 gz = gdk_keyval_to_unicode (65);
guint32 gz1 = gdk_keyval_to_unicode (220);
guint32 gz2 = gdk_keyval_to_unicode (7838);
//---------------------------------------
//guint gdk_unicode_to_keyval (guint32 wc);
guint GGGIII= gdk_unicode_to_keyval (gg323);
guint GGGIII2= gdk_unicode_to_keyval (gz2);
guint GGGIII3= gdk_unicode_to_keyval (gz);
guint GGGIII4= gdk_unicode_to_keyval (gz1);
//guint GGGIII2 =gdk_unicode_to_keyval (L"\u1E9E");
//gchar * gc2= gdk_keyval_name ((int) \u1E9E);
wchar_t w[] = L"\u1E9E";
wchar_t ww[] = L"A";
unsigned int Alef = (unsigned int) L'ẞ';
guint GGII4= gdk_unicode_to_keyval (Alef);
guint GGI4= gdk_unicode_to_keyval ((unsigned int) L'ẞ');*/
//---------------------------------------
Keyval= Keyval_Shift;
// finds ALL CHARACTERS ON KEY KCode for all levels and groups
// key 51 gr=0 (DE); lev=0 keyval 35(#)
// key 51 gr=0 (FR); lev=0 keyval 35(*)
// key 51 gr=0 (US); lev=0 keyval 35(\)
// key 51 gr=0 (ES); lev=0 keyval 35(\)
gdk_keymap_get_entries_for_keycode(keymap, KCode, &maps, &keyvals, &count);
wprintf(L"----------------------------\nprinting out the characters given by keypress of key SC/Keycode:%i\n",KCode);
for (int i = 0; i < count; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" 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);
}
// finds all levels, groups WHERE KEYVAL IS LOCATED
// ' is on key 13, gr=0,lev=0 for swedish;
// ' is on key 51, gr=0,lev=1 for german;
// ' is on key 48, gr=2,lev=0 for english?;
// ' is on key 48, gr=3,lev=0 for spanish?;
//gdk_keymap_get_entries_for_keyval(keymap, Keyval,&keys,&n_keys);
gdk_keymap_get_entries_for_keyval(keymap, Keyval,&keys,&n_keys);
wprintf(L"----------------------------\nprinting out the characters given by keypress of Keyval :%i\n",Keyval);
for (int i = 0; i < n_keys; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" i=%d, Keyval=%d, (%c) keycode %i group %i level %i\n",
i, Keyval,Keyval, keys[i].keycode,keys[i].group,keys[i].level);
}
//---------------------------------------
gint Key_on_DE;
gint KeyVal_on_US;
Keyval = 38;
gdk_keymap_get_entries_for_keyval(keymap, Keyval,&keys,&n_keys);
wprintf(L"----------------------------\nprinting out the characters given by keypress of Keyval :%i\n",Keyval);
for (int i = 0; i < n_keys; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" i=%d, Keyval=%d, (%c) keycode %i group %i level %i\n",
i, Keyval,Keyval, keys[i].keycode,keys[i].group,keys[i].level);
}
for (int i = 1; i < n_keys; i++) {
if (keys[i].group ==0)
Key_on_DE = keys[i].keycode;
}
gdk_keymap_get_entries_for_keycode(keymap, Key_on_DE, &maps, &keyvals, &count);
wprintf(L"----------------------------\nprinting out the characters given by keypress of key SC/Keycode:%i\n",Key_on_DE);
for (int i = 0; i < count; i++) {
//if (maps[i].level > 0 || maps[i].group > 1)
// continue;
wprintf(L" 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);
}
for (int i = 0; i < count; i++) {
if ((maps[i].group ==2 )&& (maps[i].level ==0))
KeyVal_on_US = maps[i].keycode;
}
const UINT VK_US= ScanCodeToUSVirtualKey[KeyVal_on_US-8];
const UINT VK_US2= USVirtualKeyToScanCode[KeyVal_on_US];
GdkModifierType MOD_base = (GdkModifierType) ( ~GDK_MODIFIER_MASK );
gdk_keymap_translate_keyboard_state (keymap, KCode, MOD_base , 0, keyvals, NULL, NULL, & consumed);
std::wstring rV1= std::wstring(1, (int) *keyvals);
KeyvalName_Base = gdk_keyval_name (Keyval_Base);
KeyvalName_ch_Base = (char*) KeyvalName_Base;
std::string KeyvalName_str_Base(KeyvalName_ch_Base);
KeyvalName_Shift= gdk_keyval_name (Keyval_Shift);
KeyvalName_ch_Shift = (char*) KeyvalName_Shift;
std::string KeyvalName_str_Shift(KeyvalName_ch_Shift);
wprintf(L" keyval_Base %i has the name: %s ------ ", Keyval_Base, KeyvalName_str_Base.c_str());
wprintf(L" keyval_Shift %i has the name: %s \n", Keyval_Shift, KeyvalName_str_Shift.c_str());
//wprintf(L" keyval ");
int stop=99;
}
// _S2 TODO
/*std::wstring get_KeyVals_according_to_Shiftstate(GdkKeymap *keymap, guint keycode, ShiftState ss, int caps ){
GdkModifierType consumed;
GdkKeymapKey *maps;
guint *keyvals;
gint count;
// _S2 TODO what to return if it fails?
if (!gdk_keymap_get_entries_for_keycode(keymap, keycode, &maps, &keyvals, &count))
return L"1";
//unshifted
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);
return std::wstring(1, (int) *keyvals);
}
//SHIFT+CAPS
else if ( ( ss == Shft ) && ( caps ==1 )) {
GdkModifierType MOD_ShiftCaps= (GdkModifierType) ((GDK_SHIFT_MASK | GDK_LOCK_MASK));
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_ShiftCaps , 0, keyvals, NULL, NULL, & consumed);
return std::wstring(1, (int) *keyvals);
}
//Shift
else if (( ss == Shft ) && ( caps == 0 )) {
return std::wstring(1, (int) get_VirtualKey_Other_GDK(keymap, keycode));
}
//caps
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);
return std::wstring(1, (int) *keyvals);
}
//ALT-GR
//else if {
// GdkModifierType MOD_AltGr = (GdkModifierType) ( GDK_MOD5_MASK );
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_AltGr , 0, keyvals, NULL, NULL, & consumed);
return *keyvals;
}
else
return L"0";
}
*/
// _S2 this needs to go; only to check if mcompile gives the same end result.
// _S2 helps to force filling rgkey[VK_FR]
UINT map_Ikey_FR(UINT iKey) {
if (iKey == 186 ) return 221;
if (iKey == 187 ) return 187;
if (iKey == 188 ) return 77;
if (iKey == 189 ) return 223;
if (iKey == 190 ) return 188;
if (iKey == 191 ) return 190;
if (iKey == 192 ) return 222;
if (iKey == 219 ) return 189;
if (iKey == 220 ) return 220;
if (iKey == 221 ) return 219;
if (iKey == 222 ) return 192;
if (iKey == 223 ) return 191;
if (iKey == 226 ) return 226;
if (iKey == 77 ) return 186;
return iKey;
}
/*bool KMX_Lin_ImportRules_Lin(KMX_WCHAR *kbid, LPKMX_KEYBOARD kp,v_dw_3D &All_Vector, GdkKeymap **keymap, std::vector<KMX_DeadkeyMapping> *FDeadkeys, KMX_BOOL bDeadkeyConversion) { // I4353 // I4552
KMX_Loader loader;
const size_t BUF_sz= 256;
//Inspect_kp(kp); // _ _S2 only open for inspecting; if used when running the program it will crash :-( )
KMX_HKL hkl = NULL; //_S2 added: but can I do this?? hkl is not needed in Linux??
BYTE lpKeyState[256];// = new KeysEx[256];
std::vector<KMX_VirtualKey*> rgKey; //= new VirtualKey[256];
std::vector<DeadKey*> alDead;
KMX_VirtualKey* rgKey_single = new KMX_VirtualKey(1, hkl, All_Vector, keymap);
UINT nkeys_single =0;
rgKey.resize(256);
// _S2 scroll through OTHER
// 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.
for(UINT sc = 0x01; sc <= 0x7f; sc++) {
// fills m_vk with the VK of the US keyboard which is not right!!
// ( mcompile win uses MapVirtualKeyEx() to fill m_vk with the VK of the Other keyboard)
// Linux cant get a VK for the US Keyboard using USVirtualKeyToScanCode/ScanCodeToUSVirtualKey
// Linux cannot get a VK for Other Keyboard
// it could return SC if that helps
KMX_VirtualKey *key = new KMX_VirtualKey(sc, hkl, All_Vector, keymap);
if((key->VK() != 0) && (key->VK()< 255)) { // if used without ScanCodeToUSVirtualKey[]
rgKey[key->VK()] = key;
} else {
delete key;
}
}
for(UINT ke = VK_NUMPAD0; ke <= VK_NUMPAD9; ke++) {
rgKey[ke] = new KMX_VirtualKey(hkl, ke, All_Vector, keymap);
}
rgKey[VK_DIVIDE] = new KMX_VirtualKey(hkl, VK_DIVIDE, All_Vector, keymap);
rgKey[VK_CANCEL] = new KMX_VirtualKey(hkl, VK_CANCEL, All_Vector, keymap);
rgKey[VK_DECIMAL] = new KMX_VirtualKey(hkl, VK_DECIMAL, All_Vector, keymap);
// // _S2 do we need special shift state now or later?
// // See if there is a special shift state added
// for(UINT vk = 0; vk <= VK_OEM_CLEAR; vk++) {
// UINT sc = MapVirtualKeyEx(vk, 0, hkl);
// UINT vkL = MapVirtualKeyEx(sc, 1, hkl);
// UINT vkR = MapVirtualKeyEx(sc, 3, hkl);
// if((vkL != vkR) &&
// (vk != vkL)) {
// switch(vk) {
// case VK_LCONTROL:
// case VK_RCONTROL:
// case VK_LSHIFT:
// case VK_RSHIFT:
// case VK_LMENU:
// case VK_RMENU:
// break;
//
// default:
// loader.Set_XxxxVk(vk);
// break;
// }
// }
// }
// _S2 in this part we skip shiftstates 4, 5, 8, 9
for(UINT iKey = 0; iKey < rgKey.size(); iKey++) {
if(rgKey[iKey] != NULL) {
WCHAR sbBuffer[256]; // Scratchpad we use many places
for(ShiftState ss = Base; ss <= loader.MaxShiftState(); ss = (ShiftState)((int)ss + 1)) {
if(ss == Menu || ss == ShftMenu) {
continue; // Alt and Shift+Alt don't work, so skip them
}
KMX_DWORD SC_US = get_KeyCode_fromVKUS(iKey); // _S2 only for testing can go later helps to force filling rgkey[VK_DE]
for(int caps = 0; caps <= 1; caps++) {
//_S2 TODO get char - do I need rc ?? ( was rc = ToUnicodeEx...)
std::wstring KeyVal_Other = get_KeyVals_according_to_keycode_and_Shiftstate( *keymap, SC_US, ss, caps);
if (!IsKeymanUsedKeyVal(KeyVal_Other))
KeyVal_Other = L"\0";
//_S2 TODO do I need that ??
//if rc >0: it got 1 or more char AND buffer is empty ( nothing inside ) {
if(KeyVal_Other == L"") {
//rgKey[iKey]->KMX_SetShiftState(ss, L"", false, (caps == 0));
rgKey[iKey]->KMX_SetShiftState(ss, L"", false, (caps));
rgKey_single->KMX_SetShiftState(ss, L"", false, (caps));
}
//_S2 TODO
//else // if rc ==1 : it got 1 char && +40 in Buffer CTRl pressed {
//It's dealing with control characters. If ToUnicodeEx gets VK_A with the Ctrl key pressed,
//it will write 0x01 to sBuffer[0] , without Ctrl it's 0x41. The if detects this case.
//&& CTRl +0x40 in the buffer ( which indicates a ctrl press)
if( (ss == Ctrl || ss == ShftCtrl) //&& CTRl +0x40 in the buffer ( which indicates a ctrl press) //) {
continue;
}
//_S2 TODO fill m_rgfDeadkey ( m_rgfDeadkey will be done later)
//rgKey[iKey]->KMX_SetShiftState(ss, KeyVal_Other, false, (caps==0));
rgKey[iKey]->KMX_SetShiftState(ss, KeyVal_Other, false, (caps));
rgKey_single->KMX_SetShiftState(ss, KeyVal_Other, false, (caps));
//if( KeyVal_Other != L"")
if( IsKeymanUsedKeyVal(KeyVal_Other) )
nkeys_single ++ ;
int ertzu=888;
//_S2 TODO
// _S2 handle deadkeys later
// if rc <0: it got a deadkey {
// fill m_rgss and m_rgfDeadkey and alDead
//SET_SHIFTSTATES( deadkey) //sbuffer is value out of ToUnicodeEx / AllVector
// do more stuff for deadkeys...
// } from rc<0
}
}
}
}
//-------------------------------------------------------------
// 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(UINT i = 0; i < kp->cxGroupArray; i++, gp++) {
//if(gp->fUsingKeys && gp->dpNoMatch == NULL) { // I4550
// WCHAR *p = gp->dpNoMatch = new WCHAR[4];
// *p++ = UC_SENTINEL;
// *p++ = CODE_USE;
// *p++ = (WCHAR)(kp->cxGroupArray + 1);
// *p = 0;
//}
LPKMX_KEY kkp = gp->dpKeyArray;
for(UINT j = 0; j < gp->cxKeyArray; j++, kkp++) {
nDeadkey = std::max(nDeadkey, KMX_GetMaxDeadkeyIndex(kkp->dpContext));
nDeadkey = std::max(nDeadkey, KMX_GetMaxDeadkeyIndex(kkp->dpOutput));
}
}
// _S2 find nkeys
// kp->cxGroupArray++;
// gp = &kp->dpGroupArray[kp->cxGroupArray-1];
// UINT nKeys = 0;
// for (UINT iKey = 0; iKey < rgKey.size(); iKey++) {
// if ((rgKey[iKey] != NULL) && rgKey[iKey]->KMX_IsKeymanUsedKey() && (!rgKey[iKey]->KMX_IsEmpty())) {
// nKeys+= rgKey[iKey]->KMX_GetKeyCount(loader.MaxShiftState());
// wprintf(L" iKey = %i, Delta: %i -> Sum %i\n", iKey, rgKey[iKey]->KMX_GetKeyCount(loader.MaxShiftState()), nKeys);
// }
// }
nDeadkey++; // ensure a 1-based index above the max deadkey value already in the keyboard
gp->fUsingKeys = TRUE;
gp->dpMatch = NULL;
gp->dpName = NULL;
gp->dpNoMatch = NULL;
//gp->cxKeyArray = nKeys;
gp->cxKeyArray = nkeys_single;
gp->dpKeyArray = new KMX_KEY[gp->cxKeyArray];
UINT nKeys = 0;
//
// Fill in the new rules
//
for (UINT iKey = 0; iKey < rgKey.size(); iKey++) {
if ((rgKey[iKey] != NULL) && rgKey[iKey]->KMX_IsKeymanUsedKey() && (!rgKey[iKey]->KMX_IsEmpty())) {
if(rgKey[iKey]->KMX_LayoutRow_Lin(loader.MaxShiftState(), &gp->dpKeyArray[nKeys], &alDead, nDeadkey, bDeadkeyConversion, All_Vector,*keymap)) { // I4552
//if(rgKey_single->KMX_LayoutRow_Lin(loader.MaxShiftState(), &gp->dpKeyArray[nKeys], &alDead, nDeadkey, bDeadkeyConversion, All_Vector,*keymap)) { // I4552
nKeys+=rgKey[iKey]->KMX_GetKeyCount(loader.MaxShiftState());
wprintf(L"nKeys sum: %i\n", nKeys);
}
}
}
// ---------------------------------------------------------------------------------------------
// A _S2 Look at the character in the key rule,
// e.g. + 'y' > '... (so, key->Key == 'y' && key->ShiftFlags == 0)
KMX_WCHAR key_key;
KMX_DWORD key_shiftFlag;
// ---------------------------------------------------------------------------------------------
// B _S2 Find the key data by finding 'y' keyval in the target layout. (DE?)
// ---------------------------------------------------------------------------------------------
// C _S2 Look up the scan code (and modifiers) associated with that keyval.
// ---------------------------------------------------------------------------------------------
// D _S2 Use that scan code to get the US english vkey equivalent via ScanCodeToUSVirtualKey[]
// ---------------------------------------------------------------------------------------------
// E _S2 Rewrite the key rule to + [K_Z] > ...
// ---------------------------------------------------------------------------------------------
// F _S2 Nuance needed around modifier keys (so it may need to be + [SHIFT K_Z] for 'Y', for example).
// ---------------------------------------------------------------------------------------------
// Keyval(DE) -> SC_DE -> SC_US -> VK_US
// ---------------------------------------------------------------------------------------------
// _S2 no changes here after removing rgkey
gp->cxKeyArray = nKeys;
//
// Add nomatch control to each terminating 'using keys' group // I4550
//
LPKMX_GROUP gp2 = kp->dpGroupArray;
for(UINT i = 0; i < kp->cxGroupArray - 1; i++, gp2++) {
if(gp2->fUsingKeys && gp2->dpNoMatch == NULL) {
KMX_WCHAR *p = gp2->dpNoMatch = new KMX_WCHAR[4];
KMX_WCHAR *q = p;
*p++ = UC_SENTINEL;
*p++ = CODE_USE;
*p++ = (KMX_WCHAR)(kp->cxGroupArray);
*p = 0;
// _S2 TODO not sure if this works OK -> we need to use more shiftstates than base+Shift
// 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.
//
UINT j;
LPKMX_KEY kkp;
for(j = 0, kkp = gp->dpKeyArray; j < gp->cxKeyArray; j++, kkp++) {
wprintf(L"key: kkp->key%i(%c) and SFlag %i\n",kkp->Key,kkp->Key,kkp->ShiftFlags );
//wprintf(L"key: gp ->key%i(%c) and SFlag %i\n",gp->dpKeyArray->Key,gp->dpKeyArray->Key,gp->dpKeyArray->ShiftFlags );
//wprintf(L"key: gp2->key%i(%c) and SFlag %i\n",gp2->dpKeyArray->Key,gp2->dpKeyArray->Key,gp2->dpKeyArray->ShiftFlags );
//wprintf(L"key: kp ->key%i(%c) and SFlag %i\n",kp->dpGroupArray->dpKeyArray->Key,kp->dpGroupArray->dpKeyArray->Key,kp->dpGroupArray->dpKeyArray->ShiftFlags );
//&& CTRl +0x40 in the buffer ( which indicates a ctrl press) //
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];
KMX_WCHAR *q=p;
*p++ = UC_SENTINEL;
*p++ = CODE_USE;
*p++ = (KMX_WCHAR)(kp->cxGroupArray);
*p = 0;
}
}
}
}
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(UINT 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;
}*/
// _S2 maybe not needed
UINT find_SC_Other_from_SC_US_GDK(UINT SC_US,GdkKeymap *keymap) {
UINT SC__Other;
for ( int i=0; i<255;i++) {
SC__Other= (UINT )get_KeyCode_From_KeyVal_GDK( keymap, i);
if(SC__Other==SC_US )
return SC__Other;
}
return SC_US;
}
std::wstring get_KeyVals_according_to_keycode_and_Shiftstate_Lin(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 L"\0";
//return L"1";
// _S2 remove! only for testing helps to force filling rgkey[VK_DE]
if((keycode == 49) && (ss == Base)) return L"^";
if((keycode == 21) && (ss == Base)) return L"'";
if((keycode == 21) && (ss == Shft)) return L"`";
if((keycode == 21) && (ss == Base) && (caps == 1)) return L"'";
if((keycode == 20) && (ss == Base) && (caps == 1)) return L"ß"; //L"ẞ";
if((keycode == 20) && (ss == ShftMenuCtrl) && (caps == 0)) return L"ß"; //L"ẞ";
if((keycode == 20) && (ss == ShftMenuCtrl) && (caps == 1)) return L"ß"; //L"ẞ";
//unshifted
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);
return std::wstring(1, (int) *keyvals);
}
//SHIFT+CAPS
else if ( ( ss == Shft ) && ( caps ==1 )) {
GdkModifierType MOD_ShiftCaps= (GdkModifierType) ((GDK_SHIFT_MASK | GDK_LOCK_MASK));
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_ShiftCaps , 0, keyvals, NULL, NULL, & consumed);
return std::wstring(1, (int) *keyvals);
}
//Shift
else if (( ss == Shft ) && ( caps == 0 )) {
GdkModifierType MOD_Shift = (GdkModifierType) ( GDK_SHIFT_MASK );
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_Shift , 0, keyvals, NULL, NULL, & consumed);
std::wstring rV1= std::wstring(1, (int) *keyvals);
return std::wstring(1, (int) *keyvals);
}
//caps
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);
return std::wstring(1, (int) *keyvals);
}
//ALT-GR
else if (( ss == MenuCtrl ) && ( caps == 0 )){
//GdkModifierType MOD_AltGr = (GdkModifierType) ( 144 );
GdkModifierType MOD_AltGr = (GdkModifierType) ( (GDK_MOD2_MASK | GDK_MOD5_MASK) );
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_AltGr , 0, keyvals, NULL, NULL, & consumed);
return std::wstring(1, (int) *keyvals);
}
//ALT-GR
else if (( ss == MenuCtrl ) && ( caps == 1 )){
//GdkModifierType MOD_AltGr = (GdkModifierType) ( 146 );
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);
return std::wstring(1, (int) *keyvals);
}
else
return L"\0";
}
std::wstring get_KeyVals_according_to_keycode_and_Shiftstate(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 L"\0";
//return L"1";
//unshifted
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);
return std::wstring(1, (int) *keyvals);
}
//SHIFT+CAPS
else if ( ( ss == Shft ) && ( caps ==1 )) {
GdkModifierType MOD_ShiftCaps= (GdkModifierType) ((GDK_SHIFT_MASK | GDK_LOCK_MASK));
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_ShiftCaps , 0, keyvals, NULL, NULL, & consumed);
return std::wstring(1, (int) *keyvals);
}
//Shift
else if (( ss == Shft ) && ( caps == 0 )) {
GdkModifierType MOD_Shift = (GdkModifierType) ( GDK_SHIFT_MASK );
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_Shift , 0, keyvals, NULL, NULL, & consumed);
std::wstring rV1= std::wstring(1, (int) *keyvals);
return std::wstring(1, (int) *keyvals);
}
//caps
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);
return std::wstring(1, (int) *keyvals);
}
//ALT-GR
else if (( ss == MenuCtrl ) && ( caps == 0 )){
//GdkModifierType MOD_AltGr = (GdkModifierType) ( 144 );
GdkModifierType MOD_AltGr = (GdkModifierType) ( (GDK_MOD2_MASK | GDK_MOD5_MASK) );
gdk_keymap_translate_keyboard_state (keymap, keycode, MOD_AltGr , 0, keyvals, NULL, NULL, & consumed);
return std::wstring(1, (int) *keyvals);
}
//ALT-GR
else if (( ss == MenuCtrl ) && ( caps == 1 )){
//GdkModifierType MOD_AltGr = (GdkModifierType) ( 146 );
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);
return std::wstring(1, (int) *keyvals);
}
else
return L"\0";
}
// takes capital letter of Other returns cpital character of US keyboard
/*KMX_WORD VKUS(v_dw_3D &All_Vector,KMX_DWORD inOther) {
// loop and find char in Other; then return char of US
for( int i=0; i< (int)All_Vector[1].size();i++) {
for( int j=1; j< (int)All_Vector[1][0].size();j++) {
if((inOther == All_Vector[1][i][j] )) {
return All_Vector[0][i][2];
}
}
}
return inOther;
}*/
Reference in a new issue View git blame Copy permalink