QString getKeyboardLayoutName() {
wchar_t buffer[KL_NAMELENGTH + 1];
GetKeyboardLayoutName(buffer);
QString kbid = QString("").fromWCharArray(buffer).toLatin1();
kbid = "0000" + kbid.right(4);
return XUtils::StandKBLayout(kbid);
}
void UpdateData(HWND hDlg)
{
WCHAR buf[KL_NAMELENGTH];
WCHAR buf2[512];
HWND hList;
HKL *klList, hKl;
int n, i,j;
GetKeyboardLayoutName(buf);
swprintf(buf2, L"Active: %s (%x)", buf, GetKeyboardLayout(0));
SetWindowText(GetDlgItem(hDlg, IDC_ACTIVE), buf2);
hList = GetDlgItem(hDlg, IDC_LIST);
SendMessage(hList, LB_RESETCONTENT, 0, 0);
n = GetKlList(&klList);
hKl = GetKeyboardLayout(0);
for(i = 0; i < n; i++)
{
swprintf(buf, L"%x", klList[i] );
j = SendMessage(hList, LB_ADDSTRING, 0, (LPARAM) buf);
SendMessage(hList, LB_SETITEMDATA, j, (LPARAM) klList[i]);
if(klList[i] == hKl) SendMessage(hList, LB_SETCURSEL, j, 0);
}
FreeKlList(klList);
}
BOOL CCPPhDlg::OnInitDialog()
{
CDialogEx::OnInitDialog();
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
this->flog.open(_T("cpph.log")); //open log
SetTimer(1, 1000, 0); //timer to show minutes to close
//established token
this->established_token_status = this->token.establish_token();
TCHAR msg_char[200];
if (this->established_token_status == 0){
this->token.list_containers(this->token_containeres);
if (this->cur_container_name != this->token_containeres[this->cur_container_id]){ //if not displayed, show it
wsprintf(msg_char, _T("%s \"%S\""), STATIC_TEXT_1, this->token_containeres[this->cur_container_id].c_str());
mMsg.SetWindowTextW(msg_char);
this->cur_container_name = this->token_containeres[this->cur_container_id];
this->flog << this->loctime() << ": Established container: " << this->cur_container_name << endl; //log
}
}
TCHAR l[100];
GetKeyboardLayoutName(l);
this->flog << this->loctime() << ": Current leyboard layout: " << CT2A(l) << endl;
return TRUE; // return TRUE unless you set the focus to a control
}
void ViewerWindow::dialogConnectionInfo()
{
StringStorage host = m_conData->getHost();
std::vector<TCHAR> kbdName;
kbdName.resize(KL_NAMELENGTH);
memset(&kbdName[0], 0, sizeof(TCHAR) * KL_NAMELENGTH);
if (!GetKeyboardLayoutName(&kbdName[0])) {
kbdName[0] = _T('?');
kbdName[1] = _T('?');
kbdName[2] = _T('?');
}
Rect geometry;
int pixelSize = 0;
m_dsktWnd.getServerGeometry(&geometry, &pixelSize);
StringStorage str;
str.format(StringTable::getString(IDS_CONNECTION_INFO_FORMAT),
host.getString(),
m_viewerCore->getRemoteDesktopName().getString(),
m_viewerCore->getProtocolString().getString(),
geometry.getWidth(),
geometry.getHeight(),
pixelSize,
&kbdName[0]);
MessageBox(getHWnd(),
str.getString(),
StringTable::getString(IDS_CONNECTION_INFO_CAPTION),
MB_OK | MB_ICONINFORMATION);
}
void HS_SendKeys::Init(void)
{
m_nKeyDelay = 5; // Default time in between keystrokes
m_nKeyDownDelay = 1; // Default time before a pressed key is released (needs >0 for SendTo to be reliable)
m_nKeyMod = NONEMOD; // Key modifiers
m_bStoreCapslockMode = true; // Store/restore caps ON
m_bAttachMode = false; // Don't attach to foreground for Send()
// Key scan codes for frequently used keys (mods) to save space later
m_scanLWin = MapVirtualKey(VK_LWIN, 0);
m_scanShift = MapVirtualKey(VK_SHIFT, 0);
m_scanCtrl = MapVirtualKey(VK_CONTROL, 0);
m_scanAlt = MapVirtualKey(VK_MENU, 0);
char szKLID[KL_NAMELENGTH];
GetKeyboardLayoutName(szKLID ); // Get input locale identifier name
// update Diadics char according to keyboard possibility
for (int i=1; i<=7; ++i)
{ // check VK code to check if diadic char can be sent
// English keyboard cannot sent diadics char
if ( VkKeyScan(g_cDiadic[i]) == -1 || (strcmp(&szKLID[6], "09") == 0) )
g_cDiadic[i] = ' '; // reset Diadic setting
}
// need to check if a German keyboard in use
// because ~ does not work as a diadic char
if (strcmp(&szKLID[6], "07") == 0) // german keyboard
g_cDiadic[4] = ' '; // ~
// need to check if a italian keyboard in use
// because ^ does not work as a diadic char
else if (strcmp(&szKLID[6], "10") == 0) // italian keyboard
g_cDiadic[3] = ' '; // ^
/* I cannot have them working (JPM)
// need to check if a hungarian keyboard in use
// because ~^`¨ does not work as a diadic char
else if (strcmp(&szKLID[6], "0E") == 0) // hungarian keyboard
{
g_cDiadic[3] = ' '; // ^
g_cDiadic[4] = ' '; // ~
g_cDiadic[5] = ' '; // ¨
g_cDiadic[6] = ' '; // `
}
// need to check if a czech keyboard in use
// because ~ does not work as a diadic char
else if (strcmp(&szKLID[6], "05") == 0) // czech keyboard
{
g_cDiadic[2] = ' '; // ´
g_cDiadic[4] = ' '; // ~
g_cDiadic[5] = ' '; // ¨
g_cDiadic[6] = ' '; // `
}
*/
} // Constructor()
VOID
GetKbdLayout()
{
WCHAR kbdLayout[MAX_PATH];
memset(kbdLayout, 0, sizeof(kbdLayout));
if (GetKeyboardLayoutName(kbdLayout))
DebugPrint(L"kbdLayout=%ws\n", kbdLayout);
else
DebugPrint(L"GetKeyboardLayoutName failed with err=%d", GetLastError());
}
LRESULT CALLBACK inputLangChange_callWndProcHook(int code, WPARAM wParam, LPARAM lParam) {
static int lastInputLangChange=0;
CWPSTRUCT* pcwp=(CWPSTRUCT*)lParam;
if((pcwp->message==WM_INPUTLANGCHANGE)&&(pcwp->lParam!=lastInputLangChange)) {
wchar_t buf[KL_NAMELENGTH];
GetKeyboardLayoutName(buf);
nvdaControllerInternal_inputLangChangeNotify(GetCurrentThreadId(),pcwp->lParam,buf);
lastInputLangChange=pcwp->lParam;
}
return 0;
}
void CCPPhDlg::OnInputLangChangeRequest(UINT nFlags, UINT nLocaleId)
{
// TODO: Add your message handler code here and/or call default
this->flog << loctime() << ": OnInputLangChangeRequest: " << nFlags << ", " << nLocaleId << endl;
TCHAR l[100];
GetKeyboardLayoutName(l);
this->flog << this->loctime() << ": Current leyboard layout (OnInputLangChangeRequest): " << CT2A(l) << endl;
CDialogEx::OnInputLangChangeRequest(nFlags, nLocaleId);
}
VOID
KbdTest()
{
WCHAR klId[KL_NAMELENGTH];
KbdTestGetKeyNameText();
GetKeyboardLayoutName(klId);
DebugPrint(L"klId is %ws\n", klId);
UINT vkCode = MapVirtualKey(31, MAPVK_VSC_TO_VK_EX);
DebugPrint(L"vkCode(31) is %d\n", vkCode);
vkCode = MapVirtualKey(30, MAPVK_VSC_TO_VK_EX);
DebugPrint(L"vkCode(30) is %d\n", vkCode);
vkCode = MapVirtualKey(21, MAPVK_VSC_TO_VK_EX);
DebugPrint(L"vkCode(21) is %d\n", vkCode);
}
void CConfigurationCheck::CheckInputSettings()
{
TCHAR KeyboardLayout[KL_NAMELENGTH];
bool Success = GetKeyboardLayoutName((LPSTR)&KeyboardLayout);
if (Success && (_tcscmp(KeyboardLayout, k_KeyboardLayout_UK_US_English) != 0))
{
OH_MessageBox("You seem to have non-english keyboard settings.\n"
"Keyboard settings affect especially the decimal point in numbers\n"
"and therefore the scraper-engine and the auto-player.\n"
"If you continue, OpenHoldem may or may not work as expected.\n"
"If you are an experienced user with a working setup\n"
"you may turn this warning off.\n"
"If you are new to OpenHoldem or encounter problems\n"
"you should fix your keyboard settings\n",
"Caution: Improper keyboard settings", MB_OK|MB_ICONWARNING);
}
}
void DIB_InitOSKeymap(_THIS)
{
int i;
#ifndef _WIN32_WCE
char current_layout[KL_NAMELENGTH];
GetKeyboardLayoutName(current_layout);
hLayoutUS = LoadKeyboardLayout("00000409", KLF_NOTELLSHELL);
if (!hLayoutUS) {
hLayoutUS = GetKeyboardLayout(0);
}
LoadKeyboardLayout(current_layout, KLF_ACTIVATE);
#else
#if _WIN32_WCE >=420
TCHAR current_layout[KL_NAMELENGTH];
GetKeyboardLayoutName(current_layout);
hLayoutUS = LoadKeyboardLayout(L"00000409", 0);
if (!hLayoutUS) {
hLayoutUS = GetKeyboardLayout(0);
}
LoadKeyboardLayout(current_layout, 0);
#endif
#endif
for ( i=0; i<SDL_arraysize(VK_keymap); ++i )
VK_keymap[i] = SDLK_UNKNOWN;
VK_keymap[VK_BACK] = SDLK_BACKSPACE;
VK_keymap[VK_TAB] = SDLK_TAB;
VK_keymap[VK_CLEAR] = SDLK_CLEAR;
VK_keymap[VK_RETURN] = SDLK_RETURN;
VK_keymap[VK_PAUSE] = SDLK_PAUSE;
VK_keymap[VK_ESCAPE] = SDLK_ESCAPE;
VK_keymap[VK_SPACE] = SDLK_SPACE;
VK_keymap[VK_APOSTROPHE] = SDLK_QUOTE;
VK_keymap[VK_COMMA] = SDLK_COMMA;
VK_keymap[VK_MINUS] = SDLK_MINUS;
VK_keymap[VK_PERIOD] = SDLK_PERIOD;
VK_keymap[VK_SLASH] = SDLK_SLASH;
VK_keymap[VK_0] = SDLK_0;
VK_keymap[VK_1] = SDLK_1;
VK_keymap[VK_2] = SDLK_2;
VK_keymap[VK_3] = SDLK_3;
VK_keymap[VK_4] = SDLK_4;
VK_keymap[VK_5] = SDLK_5;
VK_keymap[VK_6] = SDLK_6;
VK_keymap[VK_7] = SDLK_7;
VK_keymap[VK_8] = SDLK_8;
VK_keymap[VK_9] = SDLK_9;
VK_keymap[VK_SEMICOLON] = SDLK_SEMICOLON;
VK_keymap[VK_EQUALS] = SDLK_EQUALS;
VK_keymap[VK_LBRACKET] = SDLK_LEFTBRACKET;
VK_keymap[VK_BACKSLASH] = SDLK_BACKSLASH;
VK_keymap[VK_OEM_102] = SDLK_LESS;
VK_keymap[VK_RBRACKET] = SDLK_RIGHTBRACKET;
VK_keymap[VK_GRAVE] = SDLK_BACKQUOTE;
VK_keymap[VK_BACKTICK] = SDLK_BACKQUOTE;
VK_keymap[VK_A] = SDLK_a;
VK_keymap[VK_B] = SDLK_b;
VK_keymap[VK_C] = SDLK_c;
VK_keymap[VK_D] = SDLK_d;
VK_keymap[VK_E] = SDLK_e;
VK_keymap[VK_F] = SDLK_f;
VK_keymap[VK_G] = SDLK_g;
VK_keymap[VK_H] = SDLK_h;
VK_keymap[VK_I] = SDLK_i;
VK_keymap[VK_J] = SDLK_j;
VK_keymap[VK_K] = SDLK_k;
VK_keymap[VK_L] = SDLK_l;
VK_keymap[VK_M] = SDLK_m;
VK_keymap[VK_N] = SDLK_n;
VK_keymap[VK_O] = SDLK_o;
VK_keymap[VK_P] = SDLK_p;
VK_keymap[VK_Q] = SDLK_q;
VK_keymap[VK_R] = SDLK_r;
VK_keymap[VK_S] = SDLK_s;
VK_keymap[VK_T] = SDLK_t;
VK_keymap[VK_U] = SDLK_u;
VK_keymap[VK_V] = SDLK_v;
VK_keymap[VK_W] = SDLK_w;
VK_keymap[VK_X] = SDLK_x;
VK_keymap[VK_Y] = SDLK_y;
VK_keymap[VK_Z] = SDLK_z;
VK_keymap[VK_DELETE] = SDLK_DELETE;
VK_keymap[VK_NUMPAD0] = SDLK_KP0;
VK_keymap[VK_NUMPAD1] = SDLK_KP1;
VK_keymap[VK_NUMPAD2] = SDLK_KP2;
VK_keymap[VK_NUMPAD3] = SDLK_KP3;
VK_keymap[VK_NUMPAD4] = SDLK_KP4;
VK_keymap[VK_NUMPAD5] = SDLK_KP5;
VK_keymap[VK_NUMPAD6] = SDLK_KP6;
VK_keymap[VK_NUMPAD7] = SDLK_KP7;
VK_keymap[VK_NUMPAD8] = SDLK_KP8;
VK_keymap[VK_NUMPAD9] = SDLK_KP9;
VK_keymap[VK_DECIMAL] = SDLK_KP_PERIOD;
VK_keymap[VK_DIVIDE] = SDLK_KP_DIVIDE;
VK_keymap[VK_MULTIPLY] = SDLK_KP_MULTIPLY;
VK_keymap[VK_SUBTRACT] = SDLK_KP_MINUS;
VK_keymap[VK_ADD] = SDLK_KP_PLUS;
VK_keymap[VK_UP] = SDLK_UP;
VK_keymap[VK_DOWN] = SDLK_DOWN;
VK_keymap[VK_RIGHT] = SDLK_RIGHT;
VK_keymap[VK_LEFT] = SDLK_LEFT;
VK_keymap[VK_INSERT] = SDLK_INSERT;
VK_keymap[VK_HOME] = SDLK_HOME;
VK_keymap[VK_END] = SDLK_END;
VK_keymap[VK_PRIOR] = SDLK_PAGEUP;
VK_keymap[VK_NEXT] = SDLK_PAGEDOWN;
VK_keymap[VK_F1] = SDLK_F1;
VK_keymap[VK_F2] = SDLK_F2;
VK_keymap[VK_F3] = SDLK_F3;
VK_keymap[VK_F4] = SDLK_F4;
VK_keymap[VK_F5] = SDLK_F5;
VK_keymap[VK_F6] = SDLK_F6;
VK_keymap[VK_F7] = SDLK_F7;
VK_keymap[VK_F8] = SDLK_F8;
VK_keymap[VK_F9] = SDLK_F9;
VK_keymap[VK_F10] = SDLK_F10;
VK_keymap[VK_F11] = SDLK_F11;
VK_keymap[VK_F12] = SDLK_F12;
VK_keymap[VK_F13] = SDLK_F13;
VK_keymap[VK_F14] = SDLK_F14;
VK_keymap[VK_F15] = SDLK_F15;
VK_keymap[VK_NUMLOCK] = SDLK_NUMLOCK;
VK_keymap[VK_CAPITAL] = SDLK_CAPSLOCK;
VK_keymap[VK_SCROLL] = SDLK_SCROLLOCK;
VK_keymap[VK_RSHIFT] = SDLK_RSHIFT;
VK_keymap[VK_LSHIFT] = SDLK_LSHIFT;
VK_keymap[VK_RCONTROL] = SDLK_RCTRL;
VK_keymap[VK_LCONTROL] = SDLK_LCTRL;
VK_keymap[VK_RMENU] = SDLK_RALT;
VK_keymap[VK_LMENU] = SDLK_LALT;
VK_keymap[VK_RWIN] = SDLK_RSUPER;
VK_keymap[VK_LWIN] = SDLK_LSUPER;
VK_keymap[VK_HELP] = SDLK_HELP;
#ifdef VK_PRINT
VK_keymap[VK_PRINT] = SDLK_PRINT;
#endif
VK_keymap[VK_SNAPSHOT] = SDLK_PRINT;
VK_keymap[VK_CANCEL] = SDLK_BREAK;
VK_keymap[VK_APPS] = SDLK_MENU;
Arrows_keymap[3] = 0x25;
Arrows_keymap[2] = 0x26;
Arrows_keymap[1] = 0x27;
Arrows_keymap[0] = 0x28;
}
void DIB_InitOSKeymap()
{
char current_layout[KL_NAMELENGTH];
GetKeyboardLayoutName(current_layout);
hLayoutUS = LoadKeyboardLayout("00000409", KLF_NOTELLSHELL);
if (!hLayoutUS)
hLayoutUS = GetKeyboardLayout(0);
LoadKeyboardLayout(current_layout, KLF_ACTIVATE);
/* Map the VK keysyms */
for (int i = 0; i < XBMC_arraysize(VK_keymap); ++i)
VK_keymap[i] = XBMCK_UNKNOWN;
VK_keymap[VK_BACK] = XBMCK_BACKSPACE;
VK_keymap[VK_TAB] = XBMCK_TAB;
VK_keymap[VK_CLEAR] = XBMCK_CLEAR;
VK_keymap[VK_RETURN] = XBMCK_RETURN;
VK_keymap[VK_PAUSE] = XBMCK_PAUSE;
VK_keymap[VK_ESCAPE] = XBMCK_ESCAPE;
VK_keymap[VK_SPACE] = XBMCK_SPACE;
VK_keymap[VK_APOSTROPHE] = XBMCK_QUOTE;
VK_keymap[VK_COMMA] = XBMCK_COMMA;
VK_keymap[VK_MINUS] = XBMCK_MINUS;
VK_keymap[VK_PERIOD] = XBMCK_PERIOD;
VK_keymap[VK_SLASH] = XBMCK_SLASH;
VK_keymap[VK_0] = XBMCK_0;
VK_keymap[VK_1] = XBMCK_1;
VK_keymap[VK_2] = XBMCK_2;
VK_keymap[VK_3] = XBMCK_3;
VK_keymap[VK_4] = XBMCK_4;
VK_keymap[VK_5] = XBMCK_5;
VK_keymap[VK_6] = XBMCK_6;
VK_keymap[VK_7] = XBMCK_7;
VK_keymap[VK_8] = XBMCK_8;
VK_keymap[VK_9] = XBMCK_9;
VK_keymap[VK_SEMICOLON] = XBMCK_SEMICOLON;
VK_keymap[VK_EQUALS] = XBMCK_EQUALS;
VK_keymap[VK_LBRACKET] = XBMCK_LEFTBRACKET;
VK_keymap[VK_BACKSLASH] = XBMCK_BACKSLASH;
VK_keymap[VK_OEM_102] = XBMCK_BACKSLASH;
VK_keymap[VK_RBRACKET] = XBMCK_RIGHTBRACKET;
VK_keymap[VK_GRAVE] = XBMCK_BACKQUOTE;
VK_keymap[VK_BACKTICK] = XBMCK_BACKQUOTE;
VK_keymap[VK_A] = XBMCK_a;
VK_keymap[VK_B] = XBMCK_b;
VK_keymap[VK_C] = XBMCK_c;
VK_keymap[VK_D] = XBMCK_d;
VK_keymap[VK_E] = XBMCK_e;
VK_keymap[VK_F] = XBMCK_f;
VK_keymap[VK_G] = XBMCK_g;
VK_keymap[VK_H] = XBMCK_h;
VK_keymap[VK_I] = XBMCK_i;
VK_keymap[VK_J] = XBMCK_j;
VK_keymap[VK_K] = XBMCK_k;
VK_keymap[VK_L] = XBMCK_l;
VK_keymap[VK_M] = XBMCK_m;
VK_keymap[VK_N] = XBMCK_n;
VK_keymap[VK_O] = XBMCK_o;
VK_keymap[VK_P] = XBMCK_p;
VK_keymap[VK_Q] = XBMCK_q;
VK_keymap[VK_R] = XBMCK_r;
VK_keymap[VK_S] = XBMCK_s;
VK_keymap[VK_T] = XBMCK_t;
VK_keymap[VK_U] = XBMCK_u;
VK_keymap[VK_V] = XBMCK_v;
VK_keymap[VK_W] = XBMCK_w;
VK_keymap[VK_X] = XBMCK_x;
VK_keymap[VK_Y] = XBMCK_y;
VK_keymap[VK_Z] = XBMCK_z;
VK_keymap[VK_DELETE] = XBMCK_DELETE;
VK_keymap[VK_NUMPAD0] = XBMCK_KP0;
VK_keymap[VK_NUMPAD1] = XBMCK_KP1;
VK_keymap[VK_NUMPAD2] = XBMCK_KP2;
VK_keymap[VK_NUMPAD3] = XBMCK_KP3;
VK_keymap[VK_NUMPAD4] = XBMCK_KP4;
VK_keymap[VK_NUMPAD5] = XBMCK_KP5;
VK_keymap[VK_NUMPAD6] = XBMCK_KP6;
VK_keymap[VK_NUMPAD7] = XBMCK_KP7;
VK_keymap[VK_NUMPAD8] = XBMCK_KP8;
VK_keymap[VK_NUMPAD9] = XBMCK_KP9;
VK_keymap[VK_DECIMAL] = XBMCK_KP_PERIOD;
VK_keymap[VK_DIVIDE] = XBMCK_KP_DIVIDE;
VK_keymap[VK_MULTIPLY] = XBMCK_KP_MULTIPLY;
VK_keymap[VK_SUBTRACT] = XBMCK_KP_MINUS;
VK_keymap[VK_ADD] = XBMCK_KP_PLUS;
VK_keymap[VK_UP] = XBMCK_UP;
VK_keymap[VK_DOWN] = XBMCK_DOWN;
VK_keymap[VK_RIGHT] = XBMCK_RIGHT;
VK_keymap[VK_LEFT] = XBMCK_LEFT;
VK_keymap[VK_INSERT] = XBMCK_INSERT;
VK_keymap[VK_HOME] = XBMCK_HOME;
VK_keymap[VK_END] = XBMCK_END;
VK_keymap[VK_PRIOR] = XBMCK_PAGEUP;
VK_keymap[VK_NEXT] = XBMCK_PAGEDOWN;
VK_keymap[VK_F1] = XBMCK_F1;
VK_keymap[VK_F2] = XBMCK_F2;
VK_keymap[VK_F3] = XBMCK_F3;
VK_keymap[VK_F4] = XBMCK_F4;
VK_keymap[VK_F5] = XBMCK_F5;
VK_keymap[VK_F6] = XBMCK_F6;
VK_keymap[VK_F7] = XBMCK_F7;
VK_keymap[VK_F8] = XBMCK_F8;
VK_keymap[VK_F9] = XBMCK_F9;
VK_keymap[VK_F10] = XBMCK_F10;
VK_keymap[VK_F11] = XBMCK_F11;
VK_keymap[VK_F12] = XBMCK_F12;
VK_keymap[VK_F13] = XBMCK_F13;
VK_keymap[VK_F14] = XBMCK_F14;
VK_keymap[VK_F15] = XBMCK_F15;
VK_keymap[VK_NUMLOCK] = XBMCK_NUMLOCK;
VK_keymap[VK_CAPITAL] = XBMCK_CAPSLOCK;
VK_keymap[VK_SCROLL] = XBMCK_SCROLLOCK;
VK_keymap[VK_RSHIFT] = XBMCK_RSHIFT;
VK_keymap[VK_LSHIFT] = XBMCK_LSHIFT;
VK_keymap[VK_RCONTROL] = XBMCK_RCTRL;
VK_keymap[VK_LCONTROL] = XBMCK_LCTRL;
VK_keymap[VK_RMENU] = XBMCK_RALT;
VK_keymap[VK_LMENU] = XBMCK_LALT;
VK_keymap[VK_RWIN] = XBMCK_RSUPER;
VK_keymap[VK_LWIN] = XBMCK_LSUPER;
VK_keymap[VK_HELP] = XBMCK_HELP;
#ifdef VK_PRINT
VK_keymap[VK_PRINT] = XBMCK_PRINT;
#endif
VK_keymap[VK_SNAPSHOT] = XBMCK_PRINT;
VK_keymap[VK_CANCEL] = XBMCK_BREAK;
VK_keymap[VK_APPS] = XBMCK_MENU;
// Only include the multimedia keys if they have been enabled in the
// advanced settings
if (g_advancedSettings.m_enableMultimediaKeys)
{
VK_keymap[VK_BROWSER_BACK] = XBMCK_BROWSER_BACK;
VK_keymap[VK_BROWSER_FORWARD] = XBMCK_BROWSER_FORWARD;
VK_keymap[VK_BROWSER_REFRESH] = XBMCK_BROWSER_REFRESH;
VK_keymap[VK_BROWSER_STOP] = XBMCK_BROWSER_STOP;
VK_keymap[VK_BROWSER_SEARCH] = XBMCK_BROWSER_SEARCH;
VK_keymap[VK_BROWSER_FAVORITES] = XBMCK_BROWSER_FAVORITES;
VK_keymap[VK_BROWSER_HOME] = XBMCK_BROWSER_HOME;
VK_keymap[VK_VOLUME_MUTE] = XBMCK_VOLUME_MUTE;
VK_keymap[VK_VOLUME_DOWN] = XBMCK_VOLUME_DOWN;
VK_keymap[VK_VOLUME_UP] = XBMCK_VOLUME_UP;
VK_keymap[VK_MEDIA_NEXT_TRACK] = XBMCK_MEDIA_NEXT_TRACK;
VK_keymap[VK_MEDIA_PREV_TRACK] = XBMCK_MEDIA_PREV_TRACK;
VK_keymap[VK_MEDIA_STOP] = XBMCK_MEDIA_STOP;
VK_keymap[VK_MEDIA_PLAY_PAUSE] = XBMCK_MEDIA_PLAY_PAUSE;
VK_keymap[VK_LAUNCH_MAIL] = XBMCK_LAUNCH_MAIL;
VK_keymap[VK_LAUNCH_MEDIA_SELECT] = XBMCK_LAUNCH_MEDIA_SELECT;
VK_keymap[VK_LAUNCH_APP1] = XBMCK_LAUNCH_APP1;
VK_keymap[VK_LAUNCH_APP2] = XBMCK_LAUNCH_APP2;
}
}
/* Set the keyboard configuration */
Bool
winConfigKeyboard(DeviceIntPtr pDevice)
{
char layoutName[KL_NAMELENGTH];
unsigned char layoutFriendlyName[256];
unsigned int layoutNum = 0;
unsigned int deviceIdentifier = 0;
int keyboardType;
#ifdef XWIN_XF86CONFIG
XF86ConfInputPtr kbd = NULL;
XF86ConfInputPtr input_list = NULL;
MessageType kbdfrom = X_CONFIG;
#endif
MessageType from = X_DEFAULT;
char *s = NULL;
/* Setup defaults */
XkbGetRulesDflts(&g_winInfo.xkb);
/*
* Query the windows autorepeat settings and change the xserver defaults.
*/
{
int kbd_delay;
DWORD kbd_speed;
if (SystemParametersInfo(SPI_GETKEYBOARDDELAY, 0, &kbd_delay, 0) &&
SystemParametersInfo(SPI_GETKEYBOARDSPEED, 0, &kbd_speed, 0)) {
switch (kbd_delay) {
case 0:
g_winInfo.keyboard.delay = 250;
break;
case 1:
g_winInfo.keyboard.delay = 500;
break;
case 2:
g_winInfo.keyboard.delay = 750;
break;
default:
case 3:
g_winInfo.keyboard.delay = 1000;
break;
}
g_winInfo.keyboard.rate = (kbd_speed > 0) ? kbd_speed : 1;
winDebug("Setting autorepeat to delay=%ld, rate=%ld\n",
g_winInfo.keyboard.delay, g_winInfo.keyboard.rate);
}
}
keyboardType = GetKeyboardType(0);
if (keyboardType > 0 && GetKeyboardLayoutName(layoutName)) {
WinKBLayoutPtr pLayout;
Bool bfound = FALSE;
int pass;
layoutNum = strtoul(layoutName, (char **) NULL, 16);
if ((layoutNum & 0xffff) == 0x411) {
if (keyboardType == 7) {
/* Japanese layouts have problems with key event messages
such as the lack of WM_KEYUP for Caps Lock key.
Loading US layout fixes this problem. */
if (LoadKeyboardLayout("00000409", KLF_ACTIVATE) != NULL)
winDebug("Loading US keyboard layout.\n");
else
ErrorF ("LoadKeyboardLayout failed.\n");
}
}
/* Discover the friendly name of the current layout */
{
HKEY regkey = NULL;
const char regtempl[] =
"SYSTEM\\CurrentControlSet\\Control\\Keyboard Layouts\\";
char *regpath;
DWORD namesize = sizeof(layoutFriendlyName);
regpath = malloc(sizeof(regtempl) + KL_NAMELENGTH + 1);
strcpy(regpath, regtempl);
strcat(regpath, layoutName);
if (!RegOpenKey(HKEY_LOCAL_MACHINE, regpath, ®key))
RegQueryValueEx(regkey, "Layout Text", 0, NULL,
layoutFriendlyName, &namesize);
/* Close registry key */
if (regkey)
RegCloseKey(regkey);
free(regpath);
}
winDebug ("Windows keyboard layout: \"%s\" (%08x) \"%s\", type %d\n",
layoutName, layoutNum, layoutFriendlyName, keyboardType);
deviceIdentifier = layoutNum >> 16;
for (pass = 0; pass < 2; pass++) {
/* If we didn't find an exact match for the input locale identifer,
try to find an match on the language identifier part only */
if (pass == 1)
layoutNum = (layoutNum & 0xffff);
for (pLayout = winKBLayouts; pLayout->winlayout != -1; pLayout++) {
if (pLayout->winlayout != layoutNum)
continue;
if (pLayout->winkbtype > 0 && pLayout->winkbtype != keyboardType)
continue;
bfound = TRUE;
winDebug (
"Found matching XKB configuration \"%s\"\n",
pLayout->layoutname);
winDebug(
"Model = \"%s\" Layout = \"%s\""
" Variant = \"%s\" Options = \"%s\"\n",
pLayout->xkbmodel ? pLayout->xkbmodel : "none",
pLayout->xkblayout ? pLayout->xkblayout : "none",
pLayout->xkbvariant ? pLayout->xkbvariant : "none",
pLayout->xkboptions ? pLayout->xkboptions : "none");
g_winInfo.xkb.model = (char *)pLayout->xkbmodel;
g_winInfo.xkb.layout = (char *)pLayout->xkblayout;
g_winInfo.xkb.variant = (char *)pLayout->xkbvariant;
g_winInfo.xkb.options = (char *)pLayout->xkboptions;
if (deviceIdentifier == 0xa000) {
winDebug("Windows keyboard layout device identifier indicates Macintosh, setting Model = \"macintosh\"");
g_winInfo.xkb.model = "macintosh";
}
break;
}
if (bfound)
break;
}
if (!bfound) {
ErrorF ("Keyboardlayout \"%s\" (%s) is unknown, using X server default layout\n",
layoutFriendlyName, layoutName);
}
}
QString getKeyboardLayoutVariant() {
wchar_t buffer[KL_NAMELENGTH + 1];
GetKeyboardLayoutName(buffer);
QString kbid = QString("").fromWCharArray(buffer).toLatin1();
return XUtils::StandKBVariant(kbid);
}
Bool
window_subsystem_init( char * error_buf)
{
WNDCLASSW wc;
HDC dc;
HBITMAP hbm;
OSVERSIONINFO os = { sizeof( OSVERSIONINFO)};
guts. version = GetVersion();
GetVersionEx( &os);
guts. alloc_utf8_to_wchar_visual =
(( os.dwMajorVersion > 5) || (os.dwMajorVersion == 5 && os.dwMinorVersion > 1)) ?
alloc_utf8_to_wchar_visual :
alloc_utf8_to_wchar;
guts. mainThreadId = GetCurrentThreadId();
guts. errorMode = SetErrorMode( SEM_FAILCRITICALERRORS);
guts. desktopWindow = GetDesktopWindow();
memset( &wc, 0, sizeof( wc));
wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
wc.lpfnWndProc = ( WNDPROC) generic_app_handler;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = guts. instance;
wc.hIcon = LoadIcon( guts. instance, IDI_APPLICATION);
wc.hCursor = LoadCursor( NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)NULL;
wc.lpszClassName = L"GenericApp";
RegisterClassW( &wc);
memset( &wc, 0, sizeof( wc));
wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
wc.lpfnWndProc = ( WNDPROC) generic_frame_handler;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = guts. instance;
wc.hIcon = LoadIcon( guts. instance, IDI_APPLICATION);
wc.hCursor = LoadCursor( NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)NULL;
wc.lpszClassName = L"GenericFrame";
RegisterClassW( &wc);
memset( &wc, 0, sizeof( wc));
wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
wc.lpfnWndProc = ( WNDPROC) generic_view_handler;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = guts. instance;
wc.hIcon = LoadIcon( guts. instance, IDI_APPLICATION);
wc.hCursor = NULL; // LoadCursor( NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)NULL;
wc.lpszClassName = L"Generic";
RegisterClassW( &wc);
stylusMan = hash_create();
fontMan = hash_create();
patMan = hash_create();
menuMan = hash_create();
imageMan = hash_create();
regnodeMan = hash_create();
create_font_hash();
{
LOGBRUSH b = { BS_HOLLOW, 0, 0};
Font f;
hPenHollow = CreatePen( PS_NULL, 0, 0);
hBrushHollow = CreateBrushIndirect( &b);
hPatHollow. dotsCount = 0;
hPatHollow. dotsPtr = nil;
FONTSTRUCSIZE = (char *)(&(f. name)) - (char *)(&f);
}
if (!( dc = dc_alloc())) return false;
guts. displayResolution. x = GetDeviceCaps( dc, LOGPIXELSX);
guts. displayResolution. y = GetDeviceCaps( dc, LOGPIXELSY);
{
LOGFONT lf;
HFONT sfont;
// getting most common font name
memset( &lf, 0, sizeof( lf));
lf. lfCharSet = OEM_CHARSET;
lf. lfOutPrecision = OUT_DEFAULT_PRECIS;
lf. lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf. lfQuality = PROOF_QUALITY;
lf. lfPitchAndFamily = DEFAULT_PITCH;
sfont = SelectObject( dc, CreateFontIndirect( &lf));
GetTextFace( dc, 256, guts. defaultSystemFont);
// getting common fixed font name
lf. lfHeight = 320;
lf. lfPitchAndFamily = FIXED_PITCH;
DeleteObject( SelectObject( dc, CreateFontIndirect( &lf)));
GetTextFace( dc, 256, guts. defaultFixedFont);
// getting common variable font name
lf. lfPitchAndFamily = VARIABLE_PITCH;
DeleteObject( SelectObject( dc, CreateFontIndirect( &lf)));
GetTextFace( dc, 256, guts. defaultVariableFont);
DeleteObject( SelectObject( dc, sfont));
// getting system font presets
memset( &guts. windowFont, 0, sizeof( Font));
strcpy( guts. windowFont. name, DEFAULT_WIDGET_FONT);
guts. windowFont. size = DEFAULT_WIDGET_FONT_SIZE;
guts. windowFont. width = guts. windowFont. height = C_NUMERIC_UNDEF;
#ifdef FONT_CHECK
guts. windowFont. size = 12;
#endif
apc_font_pick( nilHandle, &guts. windowFont, &guts. windowFont);
guts. ncmData. cbSize = sizeof( NONCLIENTMETRICS);
SystemParametersInfo( SPI_GETNONCLIENTMETRICS, sizeof( NONCLIENTMETRICS),
( PVOID) &guts. ncmData, 0);
font_logfont2font( &guts. ncmData. lfMenuFont, &guts. menuFont, &guts. displayResolution);
font_logfont2font( &guts. ncmData. lfMessageFont, &guts. msgFont, &guts. displayResolution);
font_logfont2font( &guts. ncmData. lfCaptionFont, &guts. capFont, &guts. displayResolution);
}
memset( &guts. displayBMInfo, 0, sizeof( guts. displayBMInfo));
guts. displayBMInfo. bmiHeader. biSize = sizeof( BITMAPINFO);
if ( !( hbm = GetCurrentObject( dc, OBJ_BITMAP))) {
apiErr;
dc_free();
return false;
}
if ( !GetDIBits( dc, hbm, 0, 0, NULL, &guts. displayBMInfo, DIB_PAL_COLORS)) {
guts. displayBMInfo. bmiHeader. biBitCount = GetDeviceCaps( dc, BITSPIXEL);
guts. displayBMInfo. bmiHeader. biPlanes = GetDeviceCaps( dc, PLANES);
}
dc_free();
guts. insertMode = true;
guts. iconSizeSmall. x = GetSystemMetrics( SM_CXSMICON);
guts. iconSizeSmall. y = GetSystemMetrics( SM_CYSMICON);
guts. iconSizeLarge. x = GetSystemMetrics( SM_CXICON);
guts. iconSizeLarge. y = GetSystemMetrics( SM_CYICON);
guts. pointerSize. x = GetSystemMetrics( SM_CXCURSOR);
guts. pointerSize. y = GetSystemMetrics( SM_CYCURSOR);
list_create( &guts. transp, 8, 8);
list_create( &guts. files, 8, 8);
list_create( &guts. sockets, 8, 8);
// selecting locale layout, more or less latin-like
{
char buf[ KL_NAMELENGTH * 2] = "";
HKL current = GetKeyboardLayout( 0);
int i, j, size = GetKeyboardLayoutList( 0, nil);
HKL * kl = ( HKL *) malloc( sizeof( HKL) * size);
guts. keyLayout = nil;
if ( !GetKeyboardLayoutName( buf)) apiErr;
for ( j = 0; j < ( sizeof( keyLayouts) / sizeof( char*)); j++) {
if ( strncmp( buf + 4, keyLayouts[ j], 4) == 0) {
guts. keyLayout = current;
goto found_1;
}
}
if ( kl) {
GetKeyboardLayoutList( size, kl);
for ( i = 0; i < size; i++) {
ActivateKeyboardLayout( kl[ i], 0);
if ( !GetKeyboardLayoutName( buf)) apiErr;
for ( j = 0; j < ( sizeof( keyLayouts) / sizeof( char*)); j++) {
if ( strncmp( buf + 4, keyLayouts[ j], 4) == 0) {
guts. keyLayout = kl[ i];
goto found_2;
}
}
}
found_2:;
ActivateKeyboardLayout( current, 0);
}
found_1:;
free( kl);
}
guts. currentKeyState = guts. keyState;
memset( guts. emptyKeyState, 0, sizeof( guts. emptyKeyState));
guts. smDblClk. x = GetSystemMetrics( SM_CXDOUBLECLK);
guts. smDblClk. y = GetSystemMetrics( SM_CYDOUBLECLK);
return true;
}
BOOL
GetIMEName(
PCONSOLE_TABLE ConTbl
)
{
WCHAR buf[MaxBufSize];
WCHAR name[MaxBufSize];
DWORD bufsize = MaxBufSize;
LONG lResult;
HKEY hkLayout;
int i;
ConTbl->LayoutName[0] = TEXT('\0');
ConTbl->GuideLine[0] = TEXT('\0');
if (ImmEscape(ConTbl->hklActive, ConTbl->hIMC_Current, IME_ESC_IME_NAME, (LPTSTR)&name) == 0)
{
if (!ImmGetIMEFileName(ConTbl->hklActive, (LPTSTR)&name, MaxBufSize ) )
{
if (GetKeyboardLayoutName((LPTSTR)&name) )
{
/*
* quick dirty ImmIsIME
*/
if (name[0] != TEXT('E') &&
name[0] != TEXT('e'))
{
return FALSE;
}
lstrcpy( buf, KBDLAYOUT );
lstrcat( buf, KBDSEPALATER );
lstrcat( buf, name );
lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
(LPCTSTR)buf,
0,
KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
&hkLayout );
if ( lResult == ERROR_SUCCESS ) {
lResult = RegQueryValueEx( hkLayout,
KBDLAYOUTTEXT,
NULL,
NULL,
(LPBYTE)ConTbl->LayoutName,
&bufsize );
RegCloseKey( hkLayout );
if (ConTbl->LayoutName[0] != TEXT('\0')) {
for (i = 0; i < 8; i ++) {
if ((ConTbl->LayoutName[0] == IMECGuide[i][0]) &&
(ConTbl->LayoutName[1] == IMECGuide[i][1]) ) {
lstrcpyn(&(ConTbl->GuideLine[0]), &(IMECGuide[i][2]), IMECGuideLen+1);
break;
}
}
}
}
else {
return FALSE;
}
}
else
{
return FALSE;
}
}
else
{
lstrcpy( ConTbl->LayoutName, name );
}
}
else
{
lstrcpy( ConTbl->LayoutName, name);
}
return TRUE;
}
