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; }