Painter& Painter::Text(double x, double y, const char *text, Font fnt, int n, double *dx) { Text(x, y, ToUnicode(text, n < 0 ? strlen(text) : n, CHARSET_DEFAULT), fnt, dx); return *this; }
/* _al_win_kbd_handle_key_press: * Does stuff when a key is pressed. */ void _al_win_kbd_handle_key_press(int scode, int vcode, bool extended, bool repeated, ALLEGRO_DISPLAY_WIN *win_disp) { ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY *)win_disp; ALLEGRO_EVENT event; int my_code; bool actual_repeat; int char_count; int event_count; int i; BYTE ks[256]; WCHAR buf[8] = { 0 }; if (!installed) return; /* Check for an extended key first. */ my_code = 0; if (extended) my_code = extkey_to_keycode(vcode); /* Map a non-extended key. This also works as a fallback in case the key was extended, but no extended mapping was found. */ if (my_code == 0) { if (vcode == VK_SHIFT) /* Left or right Shift key? */ vcode = MapVirtualKey(scode, MAPVK_VSC_TO_VK_EX); my_code = hw_to_mycode[vcode]; } update_modifiers(my_code, true); actual_repeat = repeated && _AL_KEYBOARD_STATE_KEY_DOWN(the_state, my_code); _AL_KEYBOARD_STATE_SET_KEY_DOWN(the_state, my_code); if (!_al_event_source_needs_to_generate_event(&the_keyboard.es)) return; event.keyboard.type = ALLEGRO_EVENT_KEY_DOWN; event.keyboard.timestamp = al_get_time(); event.keyboard.display = display; event.keyboard.keycode = my_code; event.keyboard.unichar = 0; event.keyboard.modifiers = 0; event.keyboard.repeat = false; _al_event_source_lock(&the_keyboard.es); if (my_code > 0 && !actual_repeat) { _al_event_source_emit_event(&the_keyboard.es, &event); } /* Send char events, but not for modifier keys or dead keys. */ if (my_code < ALLEGRO_KEY_MODIFIERS) { char_count = ToUnicode(vcode, scode, GetKeyboardState(ks) ? ks : NULL, buf, 8, 0); /* Send ASCII code 127 for both Del keys. */ if (char_count == 0 && vcode == VK_DELETE) { char_count = 1; buf[0] = 127; } if (char_count != -1) { /* -1 means it was a dead key. */ event_count = char_count ? char_count : 1; event.keyboard.type = ALLEGRO_EVENT_KEY_CHAR; update_toggle_modifiers(); event.keyboard.modifiers = modifiers; event.keyboard.repeat = actual_repeat; for (i = 0; i < event_count; i++) { event.keyboard.unichar = buf[i]; _al_event_source_emit_event(&the_keyboard.es, &event); } } } _al_event_source_unlock(&the_keyboard.es); /* Toggle mouse grab key. */ if (my_code && !repeated) { ALLEGRO_SYSTEM_WIN *system = (void *)al_get_system_driver(); if (my_code == system->toggle_mouse_grab_keycode && (modifiers & system->toggle_mouse_grab_modifiers) == system->toggle_mouse_grab_modifiers) { if (system->mouse_grab_display == display) { al_ungrab_mouse(); } else { al_grab_mouse(display); } } } }
/* The return code indicates key code size. cpID is the codepage to use for translation to Unicode; -1 means use the current console input codepage. */ int w32_kbd_patch_key (KEY_EVENT_RECORD *event, int cpId) { unsigned int key_code = event->wVirtualKeyCode; unsigned int mods = event->dwControlKeyState; BYTE keystate[256]; static BYTE ansi_code[4]; static int isdead = 0; if (isdead == 2) { event->uChar.AsciiChar = ansi_code[2]; isdead = 0; return 1; } if (event->uChar.AsciiChar != 0) return 1; memset (keystate, 0, sizeof (keystate)); keystate[key_code] = 0x80; if (mods & SHIFT_PRESSED) keystate[VK_SHIFT] = 0x80; if (mods & CAPSLOCK_ON) keystate[VK_CAPITAL] = 1; /* If we recognize right-alt and left-ctrl as AltGr, set the key states accordingly before invoking ToAscii. */ if (!NILP (Vw32_recognize_altgr) && (mods & LEFT_CTRL_PRESSED) && (mods & RIGHT_ALT_PRESSED)) { keystate[VK_CONTROL] = 0x80; keystate[VK_LCONTROL] = 0x80; keystate[VK_MENU] = 0x80; keystate[VK_RMENU] = 0x80; } #if 0 /* Because of an OS bug, ToAscii corrupts the stack when called to convert a dead key in console mode on NT4. Unfortunately, trying to check for dead keys using MapVirtualKey doesn't work either - these functions apparently use internal information about keyboard layout which doesn't get properly updated in console programs when changing layout (though apparently it gets partly updated, otherwise ToAscii wouldn't crash). */ if (is_dead_key (event->wVirtualKeyCode)) return 0; #endif /* On NT, call ToUnicode instead and then convert to the current console input codepage. */ if (os_subtype == OS_NT) { WCHAR buf[128]; isdead = ToUnicode (event->wVirtualKeyCode, event->wVirtualScanCode, keystate, buf, 128, 0); if (isdead > 0) { /* When we are called from the GUI message processing code, we are passed the current keyboard codepage, a positive number, to use below. */ if (cpId == -1) cpId = GetConsoleCP (); event->uChar.UnicodeChar = buf[isdead - 1]; isdead = WideCharToMultiByte (cpId, 0, buf, isdead, ansi_code, 4, NULL, NULL); } else isdead = 0; } else { isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode, keystate, (LPWORD) ansi_code, 0); } if (isdead == 0) return 0; event->uChar.AsciiChar = ansi_code[0]; return isdead; }
//准备发送的消息包,进行封装操作 QString Gprs::PreSendMessage(QString strSendMsg, QString strPhoneNumber) { char ctl_Z=0x1A; QString strEncodeMsg=""; QString strSendTemp=""; QString addr="86"+serverNumber+"F"; QString phoneNum="86"+strPhoneNumber+"F"; QString msg=""; QString content=""; //将短信中心号奇数位和偶数位交换 addr=NumberConversion(addr); qDebug()<<addr; //将短信息中心号码前面加上字符91,91是国际化的意思 addr="91"+addr; qDebug()<<addr; //算出addr长度,结果除2,格式化成2位的16进制字符串 int al=addr.length()/2; QString addrLength= QString::number(al, 16); if(al<16){ addrLength="0"+addrLength; } qDebug()<<addrLength; addr=addrLength+addr; //将手机号码奇数位和偶数位交换。 phoneNum=NumberConversion(phoneNum); qDebug()<<phoneNum; //信息内容转字符串转换为Unicode代码 msg=ToUnicode(strSendMsg); qDebug()<<msg; //将 msg 长度除2,保留两位16进制数,再加上 msg int ml=msg.length()/2; QString msgLength= QString::number(ml, 16); if(ml<16){ msgLength="0"+msgLength; } qDebug()<<msgLength; msg=msgLength+msg; //组合 //手机号码前加上字符串 11000D91(1100:固定,0D:手机号码的长度,不算+号,十六进制表示,91:发送到手机为91,发送到小灵通为81) phoneNum = "11000D91" + phoneNum; qDebug()<<phoneNum; //手机号码后加上 000800 和刚才的短信息内容,000800短信有效期z,再加上ctl_Z; content = phoneNum + "000800"+msg; qDebug()<<content; //phone 长度除以2,格式化成2位的十进制数 int length=content.length()/2; qDebug()<<length; content =addr+content+ctl_Z; if ( fd>0 ) { QString sendata=QString("AT+CMGS=%1").arg(length); sendata+="\r\n"; const char *send=sendata.toLatin1().data(); int len=strlen(send); SerialPort::nwrite( fd, send, len); } return content; }
bool Paragraph::Format(ParaTypo& pfmt, int cx, int zoom) const { int len = length + !!style.indent; Buffer<char> chr(len); Buffer<int> width(len); Buffer<ParaTypo::Part *> info(len); Buffer<ParaTypo::Part> pinfo(part.GetCount() + !!style.indent); const Part *pptr = part.Begin(); const Part *plim = part.End(); ParaTypo::Part *pp = pinfo; char *cp = chr; int *wp = width; ParaTypo::Part **ip = info; if(!IsNull(parafont)) { Font pf = parafont; // pf.Height(max(1, DocZoom(zoom, parafont.GetHeight()))); int n = DocZoom(zoom, parafont.GetHeight()); pf.Height(n ? n : 1); FontInfo f = pf.Info(); pfmt.SetMin(f.GetAscent(), f.GetDescent(), f.GetExternal()); } /* if(!IsNull(parafont)) { FontInfo f = w.GetFontInfo(parafont); pfmt.SetMin(DocZoom(zoom, f.GetAscent()), DocZoom(zoom, f.GetDescent()), DocZoom(zoom, f.GetExternal())); } */ if(style.indent) { static Part dummy; *cp++ = ' '; *wp++ = DocZoom(zoom, style.indent); pp->Set(Arial(0), Black); pp->voidptr = &dummy; *ip++ = pp; pp++; } while(pptr != plim) { if(pptr->pr) { *cp++ = '@'; Size sz = pptr->pr.GetStdSize(); *wp++ = pp->width = pptr->pr && !pptr->sz.cx ? sz.cx : DocZoom(zoom, pptr->sz.cx); *ip++ = pp; pp->ascent = minmax(pptr->pr && !pptr->sz.cy ? sz.cy : DocZoom(zoom, pptr->sz.cy), 0, 1000); pp->descent = 0; pp->external = pp->overhang = 0; pp->color = pptr->color; } else { Font font = pptr->font; font.Height(DocZoom(zoom, pptr->font.GetHeight())); FontInfo pf = pp->Set(font, pptr->color); const char *s = pptr->text; int n = pptr->text.GetLength(); while(n--) { *cp++ = *s; *wp++ = pf[*s == 31 ? 32 : ToUnicode((byte) *s, CHARSET_DEFAULT)]; *ip++ = pp; s++; } } pp->voidptr = (void *)pptr; pp++; pptr++; } return pfmt.Format(style.align, len, chr, width, info, cx); }
void RawProperty::Read(CParser& p) { editor.SetData(ToUnicode(ReadPropertyParam(p), CHARSET_WIN1252)); }
static XBMC_keysym *TranslateKey(WPARAM vkey, UINT scancode, XBMC_keysym *keysym, int pressed) { uint16_t mod; uint8_t keystate[256]; /* Set the keysym information */ keysym->scancode = (unsigned char) scancode; keysym->unicode = 0; if ((vkey == VK_RETURN) && (scancode & 0x100)) { /* No VK_ code for the keypad enter key */ keysym->sym = XBMCK_KP_ENTER; } else { keysym->sym = VK_keymap[XBMC_MapVirtualKey(scancode, vkey)]; } // Attempt to convert the keypress to a UNICODE character GetKeyboardState(keystate); if ( pressed && XBMC_TranslateUNICODE ) { uint16_t wchars[2]; /* Numlock isn't taken into account in ToUnicode, * so we handle it as a special case here */ if ((keystate[VK_NUMLOCK] & 1) && vkey >= VK_NUMPAD0 && vkey <= VK_NUMPAD9) { keysym->unicode = vkey - VK_NUMPAD0 + '0'; } else if (ToUnicode((UINT)vkey, scancode, keystate, (LPWSTR)wchars, sizeof(wchars)/sizeof(wchars[0]), 0) > 0) { keysym->unicode = wchars[0]; } } // Set the modifier bitmap mod = (uint16_t) XBMCKMOD_NONE; // If left control and right alt are down this usually means that // AltGr is down if ((keystate[VK_LCONTROL] & 0x80) && (keystate[VK_RMENU] & 0x80)) { mod |= XBMCKMOD_MODE; } else { if (keystate[VK_LCONTROL] & 0x80) mod |= XBMCKMOD_LCTRL; if (keystate[VK_RMENU] & 0x80) mod |= XBMCKMOD_RALT; } // Check the remaining modifiers if (keystate[VK_LSHIFT] & 0x80) mod |= XBMCKMOD_LSHIFT; if (keystate[VK_RSHIFT] & 0x80) mod |= XBMCKMOD_RSHIFT; if (keystate[VK_RCONTROL] & 0x80) mod |= XBMCKMOD_RCTRL; if (keystate[VK_LMENU] & 0x80) mod |= XBMCKMOD_LALT; if (keystate[VK_LWIN] & 0x80) mod |= XBMCKMOD_LSUPER; if (keystate[VK_RWIN] & 0x80) mod |= XBMCKMOD_LSUPER; keysym->mod = (XBMCMod) mod; // Return the updated keysym return(keysym); }
void wxListCtrlEx::OnKeyDown(wxKeyEvent& event) { if (!m_prefixSearch_enabled) { event.Skip(); return; } int code = event.GetKeyCode(); if (code == WXK_LEFT || code == WXK_RIGHT || code == WXK_UP || code == WXK_DOWN || code == WXK_HOME || code == WXK_END) { ResetSearchPrefix(); event.Skip(); return; } if (event.AltDown() && !event.ControlDown()) // Alt but not AltGr { event.Skip(); return; } wxChar key; switch (code) { case WXK_NUMPAD0: case WXK_NUMPAD1: case WXK_NUMPAD2: case WXK_NUMPAD3: case WXK_NUMPAD4: case WXK_NUMPAD5: case WXK_NUMPAD6: case WXK_NUMPAD7: case WXK_NUMPAD8: case WXK_NUMPAD9: key = '0' + code - WXK_NUMPAD0; break; case WXK_NUMPAD_ADD: key = '+'; break; case WXK_NUMPAD_SUBTRACT: key = '-'; break; case WXK_NUMPAD_MULTIPLY: key = '*'; break; case WXK_NUMPAD_DIVIDE: key = '/'; break; default: key = 0; break; } if (key) { if (event.GetModifiers()) { // Numpad keys can not have modifiers event.Skip(); } HandlePrefixSearch(key); return; } #if defined(__WXMSW__) if (code >= 300 && code != WXK_NUMPAD_DECIMAL) { event.Skip(); return; } // Get the actual key BYTE state[256]; if (!GetKeyboardState(state)) { event.Skip(); return; } wxChar buffer[1]; int res = ToUnicode(event.GetRawKeyCode(), 0, state, buffer, 1, 0); if (res != 1) { event.Skip(); return; } key = buffer[0]; if (key < 32) { event.Skip(); return; } if (key == 32 && event.HasModifiers()) { event.Skip(); return; } HandlePrefixSearch(key); return; #else if (code > 32 && code < 300 && !event.HasModifiers()) { int unicodeKey = event.GetUnicodeKey(); if (unicodeKey) code = unicodeKey; HandlePrefixSearch(code); } else event.Skip(); #endif //defined(__WXMSW__) }
Painter& Painter::Text(const Pointf& p, const char *text, Font fnt, int n, double *dx) { WString s = ToUnicode(text, CHARSET_DEFAULT); return Text(p, s, fnt, n < 0 ? s.GetCount() : n, dx); }
// This function processes the main loop LRESULT CALLBACK _WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { WCHAR chars[2]; static bool isDragging = false; BYTE keyboardState[256]; int width = DGConfig::getInstance().displayWidth; int height = DGConfig::getInstance().displayHeight; switch(msg) { case WM_ACTIVATE: switch (wParam) { case WA_ACTIVE: if (_isMinimized) { LeaveCriticalSection(&csSystemThread); _isMinimized = false; } break; } break; case WM_ERASEBKGND: break; case WM_SIZE: switch (wParam) { case SIZE_MINIMIZED: EnterCriticalSection(&csSystemThread); _isMinimized = true; break; default: EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); DGControl::getInstance().reshape(LOWORD(lParam), HIWORD(lParam)); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); break; } break; case WM_MOUSEMOVE: // For the fixed control mode, we reset the cursor position when it drifts out of the screen if (DGControl::getInstance().isDirectControlActive()) { if ((LOWORD(lParam) <= 1) || (LOWORD(lParam) >= (width - 1))) { SetCursorPos(width / 2, height / 2); } if ((HIWORD(lParam) <= 1) || (HIWORD(lParam) >= (height - 1))) { SetCursorPos(width / 2, height / 2); } } EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); if (isDragging) DGControl::getInstance().processMouse(LOWORD(lParam), HIWORD(lParam), DGMouseEventDrag); else DGControl::getInstance().processMouse(LOWORD(lParam), HIWORD(lParam), DGMouseEventMove); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); if (GetCapture() != g_hWnd) { SetCapture(g_hWnd); } else { RECT rect; GetWindowRect(g_hWnd, &rect); POINT pt = { LOWORD(lParam), HIWORD(lParam) }; ClientToScreen(g_hWnd, &pt); if (!PtInRect(&rect, pt)) { EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); DGControl::getInstance().processMouse(width / 2, height / 2, DGMouseEventMove); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); ReleaseCapture(); } } break; case WM_LBUTTONDOWN: EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); DGControl::getInstance().processMouse(LOWORD(lParam), HIWORD(lParam), DGMouseEventDown); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); isDragging = true; break; case WM_LBUTTONUP: EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); DGControl::getInstance().processMouse(LOWORD(lParam), HIWORD(lParam), DGMouseEventUp); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); isDragging = false; break; case WM_RBUTTONDOWN: EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); DGControl::getInstance().processMouse(LOWORD(lParam), HIWORD(lParam), DGMouseEventRightDown); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); break; case WM_RBUTTONUP: EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); DGControl::getInstance().processMouse(LOWORD(lParam), HIWORD(lParam), DGMouseEventRightUp); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); break; case WM_KEYDOWN: EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); // A different switch to handle keystrokes switch(wParam) { case VK_F1: case VK_F2: case VK_F3: case VK_F4: case VK_F5: case VK_F6: case VK_F7: case VK_F8: case VK_F9: case VK_F10: case VK_F11: case VK_F12: DGControl::getInstance().processFunctionKey(wParam); break; // Ignored keys case VK_SHIFT: case VK_CAPITAL: case VK_CONTROL: case VK_LWIN: case VK_RWIN: break; case VK_ESCAPE: case VK_TAB: case VK_SPACE: case VK_RETURN: case VK_BACK: DGControl::getInstance().processKey(wParam, DGKeyEventDown); break; case VK_OEM_3: // Open console DGControl::getInstance().processKey(DGKeyTab, DGKeyEventDown); break; default: if (GetKeyState(VK_CONTROL) < 0) { ToUnicode(wParam, MapVirtualKey(wParam, 0), defKeyboardState, chars, 2, 0); DGControl::getInstance().processKey(chars[0], DGKeyEventModified); } else { GetKeyboardState(keyboardState); ToUnicode(wParam, MapVirtualKey(wParam, 0), keyboardState, chars, 2, 0); DGControl::getInstance().processKey(chars[0], DGKeyEventDown); } break; } wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); break; case WM_KEYUP: EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); GetKeyboardState(keyboardState); ToUnicode(wParam, MapVirtualKey(wParam, 0), keyboardState, chars, 2, 0); DGControl::getInstance().processKey(chars[0], DGKeyEventUp); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); break; case WM_CLOSE: // Simulate the ESC key EnterCriticalSection(&csSystemThread); wglMakeCurrent(g_hDC, g_hRC); DGControl::getInstance().processKey(DGKeyEsc, false); wglMakeCurrent(NULL, NULL); LeaveCriticalSection(&csSystemThread); break; case WM_DESTROY: case WM_QUIT: default: // Any other messages are passed to the default window process return DefWindowProc(hWnd, msg, wParam, lParam); break; } return 0; }
/***************************************************************************\ * ImmTranslateMessage (Called from user\client\ntstubs.c\TranslateMessage()) * * Call ImeToAsciiEx() * * History: * 01-Mar-1996 TakaoK Created \***************************************************************************/ BOOL ImmTranslateMessage( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { HIMC hImc; PINPUTCONTEXT pInputContext; BOOL fReturn = FALSE; HKL hkl; PIMEDPI pImeDpi = NULL; PBYTE pbKeyState; PTRANSMSG pTransMsg; PTRANSMSGLIST pTransMsgList; DWORD dwSize; UINT uVKey; INT iNum; UNREFERENCED_PARAMETER(wParam); // // we're interested in only those keyboard messages. // switch (message) { case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP: break; default: return FALSE; } // // input context is necessary for further handling // hImc = ImmGetContext(hwnd); pInputContext = ImmLockIMC(hImc); if (pInputContext == NULL) { ImmReleaseContext(hwnd, hImc); return FALSE; } // // At first, handle VK_PROCESSKEY generated by IME. // if (!pInputContext->fChgMsg) { if ((iNum=pInputContext->dwNumMsgBuf) != 0) { pTransMsg = (PTRANSMSG)ImmLockIMCC(pInputContext->hMsgBuf); if (pTransMsg != NULL) { ImmPostMessages(hwnd, hImc, iNum, pTransMsg); ImmUnlockIMCC(pInputContext->hMsgBuf); fReturn = TRUE; } pInputContext->dwNumMsgBuf = 0; } goto ExitITM; } pInputContext->fChgMsg = FALSE; // // retrieve the keyboard layout and IME entry points // hkl = GetKeyboardLayout( GetWindowThreadProcessId(hwnd, NULL) ); pImeDpi = ImmLockImeDpi(hkl); if (pImeDpi == NULL) { RIPMSG1(RIP_WARNING, "ImmTranslateMessage pImeDpi is NULL(hkl=%x)", hkl); goto ExitITM; } pbKeyState = ImmLocalAlloc(0, 256); if ( pbKeyState == NULL ) { RIPMSG0(RIP_WARNING, "ImmTranslateMessage out of memory" ); goto ExitITM; } if (!GetKeyboardState(pbKeyState)) { RIPMSG0(RIP_WARNING, "ImmTranslateMessage GetKeyboardState() failed" ); ImmLocalFree( pbKeyState ); goto ExitITM; } // // Translate the saved vkey into character code if needed // uVKey = pInputContext->uSavedVKey; if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_KBD_CHAR_FIRST) { if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE) { WCHAR wcTemp; iNum = ToUnicode(pInputContext->uSavedVKey, // virtual-key code HIWORD(lParam), // scan code pbKeyState, // key-state array &wcTemp, // buffer for translated key 1, // size of buffer 0); if (iNum == 1) { // // hi word : unicode character code // hi byte of lo word : zero // lo byte of lo word : virtual key // uVKey = (uVKey & 0x00ff) | ((UINT)wcTemp << 16); } } else { WORD wTemp = 0; iNum = ToAsciiEx(pInputContext->uSavedVKey, // virtual-key code HIWORD(lParam), // scan code pbKeyState, // key-state array &wTemp, // buffer for translated key 0, // active-menu flag hkl); ImmAssert(iNum <= 2); if (iNum > 0) { // // hi word : should be zero // hi byte of lo word : character code // lo byte of lo word : virtual key // uVKey = (uVKey & 0x00FF) | ((UINT)wTemp << 8); if ((BYTE)uVKey == VK_PACKET) { // // If ANSI IME is wide vkey aware, its ImeToAsciiEx will receive the uVKey // as follows: // // 31 24 23 16 15 8 7 0 // +----------------+-----------------------------+-------------------+---------------+ // | 24~31:reserved | 16~23:trailing byte(if any) | 8~15:leading byte | 0~7:VK_PACKET | // +----------------+-----------------------------+-------------------+---------------+ // ImmAssert(pImeDpi->ImeInfo.fdwProperty & IME_PROP_ACCEPT_WIDE_VKEY); } else { uVKey &= 0xffff; } } } } dwSize = FIELD_OFFSET(TRANSMSGLIST, TransMsg) + TRANSMSGCOUNT * sizeof(TRANSMSG); pTransMsgList = (PTRANSMSGLIST)ImmLocalAlloc(0, dwSize); if (pTransMsgList == NULL) { RIPMSG0(RIP_WARNING, "ImmTranslateMessage out of memory" ); ImmLocalFree(pbKeyState); goto ExitITM; } pTransMsgList->uMsgCount = TRANSMSGCOUNT; iNum = (*pImeDpi->pfn.ImeToAsciiEx)(uVKey, HIWORD(lParam), pbKeyState, pTransMsgList, 0, hImc); if (iNum > TRANSMSGCOUNT) { // // The message buffer is not big enough. IME put messages // into hMsgBuf in the input context. // pTransMsg = (PTRANSMSG)ImmLockIMCC(pInputContext->hMsgBuf); if (pTransMsg != NULL) { ImmPostMessages(hwnd, hImc, iNum, pTransMsg); ImmUnlockIMCC(pInputContext->hMsgBuf); } #ifdef LATER // Shouldn't we need this ? fReturn = TRUE; #endif } else if (iNum > 0) { ImmPostMessages(hwnd, hImc, iNum, &pTransMsgList->TransMsg[0]); fReturn = TRUE; } ImmLocalFree(pbKeyState); ImmLocalFree(pTransMsgList); ExitITM: ImmUnlockImeDpi(pImeDpi); ImmUnlockIMC(hImc); ImmReleaseContext(hwnd, hImc); return fReturn; }
/** * clutter_win32_handle_event: * @msg: A pointer to a structure describing a Win32 message. * * This function processes a single Win32 message. It can be used to * hook into external windows message processing (for example, a GDK * filter function). * * If clutter_win32_disable_event_retrieval() has been called, you must * let this function process events to update Clutter's internal state. * * Return value: %TRUE if the message was handled entirely by Clutter * and no further processing (such as calling the default window * procedure) should take place. %FALSE is returned if is the message * was not handled at all or if Clutter expects processing to take * place. * * Since: 1.6 */ gboolean clutter_win32_handle_event (const MSG *msg) { ClutterBackendWin32 *backend_win32; ClutterStageWin32 *stage_win32; ClutterDeviceManager *manager; ClutterInputDevice *core_pointer, *core_keyboard; ClutterStage *stage; ClutterStageWindow *impl; gboolean return_value = FALSE; stage = clutter_win32_get_stage_from_window (msg->hwnd); /* Ignore any messages for windows which we don't have a stage for */ if (stage == NULL) return FALSE; impl = _clutter_stage_get_window (stage); stage_win32 = CLUTTER_STAGE_WIN32 (impl); backend_win32 = stage_win32->backend; manager = clutter_device_manager_get_default (); core_pointer = clutter_device_manager_get_core_device (manager, CLUTTER_POINTER_DEVICE); core_keyboard = clutter_device_manager_get_core_device (manager, CLUTTER_KEYBOARD_DEVICE); switch (msg->message) { case WM_SIZE: if (!stage_win32->is_foreign_win /* Ignore size changes resulting from the stage being minimized - otherwise the window size will be set to 0,0 */ && msg->wParam != SIZE_MINIMIZED) { WORD new_width = LOWORD (msg->lParam); WORD new_height = HIWORD (msg->lParam); gfloat old_width, old_height; clutter_actor_get_size (CLUTTER_ACTOR (stage), &old_width, &old_height); if (new_width != old_width || new_height != old_height) clutter_actor_set_size (CLUTTER_ACTOR (stage), new_width, new_height); } break; case WM_SHOWWINDOW: if (msg->wParam) clutter_stage_win32_map (stage_win32); else clutter_stage_win32_unmap (stage_win32); break; case WM_ACTIVATE: if (msg->wParam == WA_INACTIVE) { if (stage_win32->state & CLUTTER_STAGE_STATE_ACTIVATED) { ClutterEvent *event = clutter_event_new (CLUTTER_STAGE_STATE); stage_win32->state &= ~CLUTTER_STAGE_STATE_ACTIVATED; event->any.stage = stage; event->stage_state.changed_mask = CLUTTER_STAGE_STATE_ACTIVATED; event->stage_state.new_state = stage_win32->state; take_and_queue_event (event); } } else if (!(stage_win32->state & CLUTTER_STAGE_STATE_ACTIVATED)) { ClutterEvent *event = clutter_event_new (CLUTTER_STAGE_STATE); stage_win32->state |= CLUTTER_STAGE_STATE_ACTIVATED; event->any.stage = stage; event->stage_state.changed_mask = CLUTTER_STAGE_STATE_ACTIVATED; event->stage_state.new_state = stage_win32->state; take_and_queue_event (event); } break; case WM_PAINT: CLUTTER_NOTE (MULTISTAGE, "expose for stage:%p, redrawing", stage); clutter_redraw (stage); break; case WM_DESTROY: { ClutterEvent *event = clutter_event_new (CLUTTER_DESTROY_NOTIFY); CLUTTER_NOTE (EVENT, "WM_DESTROY"); event->any.stage = stage; take_and_queue_event (event); } break; case WM_CLOSE: { ClutterEvent *event = clutter_event_new (CLUTTER_DELETE); CLUTTER_NOTE (EVENT, "WM_CLOSE"); event->any.stage = stage; take_and_queue_event (event); /* The default window proc will destroy the window so we want to prevent this to allow applications to optionally destroy the window themselves */ return_value = TRUE; } break; case WM_LBUTTONDOWN: make_button_event (msg, stage, 1, 1, FALSE, core_pointer); break; case WM_MBUTTONDOWN: make_button_event (msg, stage, 2, 1, FALSE, core_pointer); break; case WM_RBUTTONDOWN: make_button_event (msg, stage, 3, 1, FALSE, core_pointer); break; case WM_LBUTTONUP: make_button_event (msg, stage, 1, 1, TRUE, core_pointer); break; case WM_MBUTTONUP: make_button_event (msg, stage, 2, 1, TRUE, core_pointer); break; case WM_RBUTTONUP: make_button_event (msg, stage, 3, 1, TRUE, core_pointer); break; case WM_LBUTTONDBLCLK: make_button_event (msg, stage, 1, 2, FALSE, core_pointer); break; case WM_MBUTTONDBLCLK: make_button_event (msg, stage, 2, 2, FALSE, core_pointer); break; case WM_RBUTTONDBLCLK: make_button_event (msg, stage, 3, 2, FALSE, core_pointer); break; case WM_MOUSEWHEEL: stage_win32->scroll_pos += (SHORT) HIWORD (msg->wParam); while (abs (stage_win32->scroll_pos) >= WHEEL_DELTA) { ClutterEvent *event = clutter_event_new (CLUTTER_SCROLL); POINT pt; event->scroll.time = msg->time; event->scroll.modifier_state = get_modifier_state (LOWORD (msg->wParam)); event->any.stage = stage; clutter_event_set_device (event, core_pointer); /* conversion to window coordinates is required */ pt.x = GET_X_LPARAM (msg->lParam); pt.y = GET_Y_LPARAM (msg->lParam); ScreenToClient (msg->hwnd, &pt); event->scroll.x = pt.x; event->scroll.y = pt.y; if (stage_win32->scroll_pos > 0) { event->scroll.direction = CLUTTER_SCROLL_UP; stage_win32->scroll_pos -= WHEEL_DELTA; } else { event->scroll.direction = CLUTTER_SCROLL_DOWN; stage_win32->scroll_pos += WHEEL_DELTA; } take_and_queue_event (event); } break; case WM_MOUSEMOVE: { ClutterEvent *event = clutter_event_new (CLUTTER_MOTION); event->motion.time = msg->time; event->motion.x = GET_X_LPARAM (msg->lParam); event->motion.y = GET_Y_LPARAM (msg->lParam); event->motion.modifier_state = get_modifier_state (msg->wParam); event->any.stage = stage; clutter_event_set_device (event, core_pointer); /* We need to start tracking when the mouse enters the stage if we're not already */ if (!stage_win32->tracking_mouse) { ClutterEvent *crossing = clutter_event_new (CLUTTER_ENTER); TRACKMOUSEEVENT tmevent; tmevent.cbSize = sizeof (tmevent); tmevent.dwFlags = TME_LEAVE; tmevent.hwndTrack = stage_win32->hwnd; TrackMouseEvent (&tmevent); event->crossing.time = msg->time; event->crossing.x = event->motion.x; event->crossing.y = event->motion.y; event->crossing.stage = stage; event->crossing.source = CLUTTER_ACTOR (stage); event->crossing.related = NULL; clutter_event_set_device (event, core_pointer); /* we entered the stage */ _clutter_stage_add_device (stage, event->crossing.device); take_and_queue_event (crossing); stage_win32->tracking_mouse = TRUE; } take_and_queue_event (event); } break; case WM_MOUSELEAVE: { ClutterEvent *event = clutter_event_new (CLUTTER_LEAVE); event->crossing.time = msg->time; event->crossing.x = msg->pt.x; event->crossing.y = msg->pt.y; event->crossing.stage = stage; event->crossing.source = CLUTTER_ACTOR (stage); event->crossing.related = NULL; clutter_event_set_device (event, core_pointer); /* we left the stage */ _clutter_stage_remove_device (stage, core_pointer); /* When we get a leave message the mouse tracking is automatically cancelled so we'll need to start it again when the mouse next enters the window */ stage_win32->tracking_mouse = FALSE; take_and_queue_event (event); } break; case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP: { ClutterEvent *event = clutter_event_new (CLUTTER_EVENT_NONE); int scan_code = (msg->lParam >> 16) & 0xff; int min = 0, max = CLUTTER_WIN32_KEY_MAP_SIZE, mid; BYTE key_states[256]; /* Get the keyboard modifier states. GetKeyboardState conveniently gets the key state that was current when the last keyboard message read was generated */ GetKeyboardState(key_states); /* Binary chop to check if we have a direct mapping for this key code */ while (min < max) { mid = (min + max) / 2; if (clutter_win32_key_map[mid].win_sym == msg->wParam) { event->key.keyval = clutter_win32_key_map[mid].clutter_sym; event->key.unicode_value = 0; break; } else if (clutter_win32_key_map[mid].win_sym < msg->wParam) min = mid + 1; else max = mid; } /* If we don't have a direct mapping then try getting the unicode value of the key sym */ if (min >= max) { WCHAR ch; BYTE shift_state[256]; /* Translate to a Unicode value, but only take into account the shift key. That way Ctrl+Shift+C will generate a capital C virtual key code with a zero unicode value for example */ memset (shift_state, 0, 256); shift_state[VK_SHIFT] = key_states[VK_SHIFT]; shift_state[VK_LSHIFT] = key_states[VK_LSHIFT]; shift_state[VK_RSHIFT] = key_states[VK_RSHIFT]; shift_state[VK_CAPITAL] = key_states[VK_CAPITAL]; if (ToUnicode (msg->wParam, scan_code, shift_state, &ch, 1, 0) == 1 /* The codes in this range directly match the Latin 1 codes so we can just use the Unicode value as the key sym */ && ch >= 0x20 && ch <= 0xff) event->key.keyval = ch; else /* Otherwise we don't know what the key means but the application might be able to do something with the scan code so we might as well still generate the event */ event->key.keyval = CLUTTER_KEY_VoidSymbol; /* Get the unicode value of the keypress again using the full modifier state */ if (ToUnicode (msg->wParam, scan_code, key_states, &ch, 1, 0) == 1) event->key.unicode_value = ch; else event->key.unicode_value = 0; } event->key.type = msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN ? CLUTTER_KEY_PRESS : CLUTTER_KEY_RELEASE; event->key.time = msg->time; event->key.modifier_state = get_key_modifier_state (key_states); event->key.hardware_keycode = scan_code; event->any.stage = stage; clutter_event_set_device (event, core_keyboard); take_and_queue_event (event); } break; case WM_GETMINMAXINFO: { MINMAXINFO *min_max_info = (MINMAXINFO *) msg->lParam; _clutter_stage_win32_get_min_max_info (stage_win32, min_max_info); return_value = TRUE; } break; case WM_SETCURSOR: /* If the cursor is in the window's client area and the stage's cursor should be invisible then we'll set a blank cursor instead */ if (LOWORD (msg->lParam) == HTCLIENT && !stage_win32->is_cursor_visible) { return_value = TRUE; _clutter_stage_win32_update_cursor (stage_win32); } break; } return return_value; }
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_WindowsKeyboard_ToUnicode(JNIEnv *env, jclass unused, jint wVirtKey, jint wScanCode, jobject lpKeyState_obj, jobject pwszBuff_obj, jint cchBuff, jint flags) { const PBYTE lpKeyState = (*env)->GetDirectBufferAddress(env, lpKeyState_obj); LPWSTR pwszBuff = (*env)->GetDirectBufferAddress(env, pwszBuff_obj); return ToUnicode(wVirtKey, wScanCode, lpKeyState, pwszBuff, cchBuff, flags); }
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { #ifdef _WIN64 CWindowsToolkit* toolkit = (CWindowsToolkit*)GetWindowLongPtr(hWnd, GWLP_USERDATA); #else CWindowsToolkit* toolkit = (CWindowsToolkit*)GetWindowLong (hWnd, GWL_USERDATA ); #endif if (!toolkit) { return DefWindowProc(hWnd, message, wParam, lParam); } switch (message) { case WM_LBUTTONDBLCLK: { toolkit->editor->OnLButtonDblClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); return 0; } case WM_LBUTTONDOWN: { toolkit->editor->OnLButtonDown(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); SetFocus(hWnd); return 0; } case WM_LBUTTONUP: { toolkit->editor->OnLButtonUp(); SetFocus(hWnd); return 0; } case WM_KEYDOWN: { // from juce_win32_Windowing.cpp:doKeyDown const UINT keyChar = MapVirtualKey ((UINT) wParam, 2); const UINT scanCode = MapVirtualKey ((UINT) wParam, 0); BYTE keyState[256]; GetKeyboardState (keyState); WCHAR text[16] = { 0 }; if (ToUnicode ((UINT) wParam, scanCode, keyState, text, 8, 0) != 1) text[0] = 0; if (toolkit->editor->OnChar(text[0]) == true) return 0; else if (toolkit->parentWindow) PostMessage(GetParent((HWND)toolkit->parentWindow), message, wParam, lParam); // --------------------------------------- break; } case WM_MOUSEMOVE: { toolkit->editor->OnMouseMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); return 0; } case WM_MOUSEWHEEL: { RECT rect; POINT point; point.x = GET_X_LPARAM(lParam); point.y = GET_Y_LPARAM(lParam); GetWindowRect(hWnd, &rect); GetCursorPos(&point); if (PtInRect(&rect, point)) { int zDelta = GET_WHEEL_DELTA_WPARAM(wParam); zDelta /= WHEEL_DELTA; ScreenToClient(hWnd, &point); toolkit->editor->OnMouseWheel(point.x, point.y, zDelta); SetFocus(hWnd); return 0; } break; } case WM_PAINT: { PAINTSTRUCT ps; HDC dc = BeginPaint(hWnd, &ps); RECT *rect = &ps.rcPaint; int w = rect->right - rect->left; int h = rect->bottom - rect->top; BitBlt(dc, rect->left, rect->top, w, h, toolkit->hdcMem, rect->left, rect->top, SRCCOPY); EndPaint(hWnd, &ps); return 0; } case WM_TIMER: { toolkit->editor->Update(); return 0; } case WM_DESTROY: { if (!toolkit->parentWindow) { PostQuitMessage(0); } return 0L; } default: break; } return DefWindowProc (hWnd, message, wParam, lParam); }
void TestOptionRegistry::setUpSuite() { if(RegUtils::IsRegKeyPresent(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1"))) { assertTest(RegUtils::RecursiveDeleteKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1"))); } if(RegUtils::IsRegKeyPresent(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory3"))) { assertTest(RegUtils::RecursiveDeleteKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory3"))); } assertTest(RegUtils::CreateKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1"))); assertTest(RegUtils::CreateKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"))); assertTest(RegUtils::CreateKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory2"))); assertTest(RegUtils::CreateKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory2\\TestCategory2Sub3"))); assertTest(RegUtils::CreateKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory3"))); assertTest(RegUtils::CreateKey(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory3\\TestCategory3Sub2"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory2\\TestCategory2Sub3"), _T("RegSzStringValue"), _T("This is a Registry test string value"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory3\\TestCategory3Sub2"), _T("RegSzIntValue"), _T("-7"))); assertTest(RegUtils::SetRegDWORDValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory3\\TestCategory3Sub2"), _T("RegDWordIntValue"), 235)); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBoolTrue"), _T("True"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBoolFalse"), _T("False"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBooltrueLowerCase"), _T("true"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBoolfalseLowerCase"), _T("false"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBool1"), _T("1"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBool0"), _T("0"))); assertTest(RegUtils::SetRegDWORDValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegDWordBool1"), 1)); assertTest(RegUtils::SetRegDWORDValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegDWordBool0"), 0)); assertTest(RegUtils::SetRegDWORDValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegDWordBoolNon1Or0"), 5)); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBoolSomeString"), _T("This a string"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("RegSzBoolSomeNumber"), _T("234"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("ThisStringOptionDoesNotExist"), _T("It exists in the registry but not in the default map file"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("ThisIntOptionDoesNotExist"), _T("-457"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), _T("ThisBoolOptionDoesNotExist"), _T("1"))); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), ToUnicode(std::string("название-имя")).GetString(), ToUnicode(std::string("Мир языков")).GetString())); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), ToUnicode(std::string("名字")).GetString(), ToUnicode(std::string("世界多语言")).GetString())); assertTest(RegUtils::SetRegStringValue(HKEY_CURRENT_USER, OPTION_REG_LOCATION _T("\\TestCategory1\\TestCategory1Sub1"), ToUnicode(std::string("Русский")).GetString(), ToUnicode(std::string("<имет>")).GetString())); }
KeyActionSpec KeyMap::PCtoX(UINT virtkey, DWORD keyData) { UINT numkeys = 0; KeyActionSpec kas; kas.releaseModifiers = 0; bool extended = ((keyData & 0x1000000) != 0); vnclog.Print(8, "VK %.2x (%.8x)", virtkey, keyData); if (extended) { vnclog.Print(8, " [ext]"); switch (virtkey) { case VK_MENU : virtkey = VK_RMENU; break; case VK_CONTROL: virtkey = VK_RCONTROL; break; case VK_RETURN: virtkey = VK_KEYPAD_ENTER; break; } } else { switch (virtkey) { case VK_HOME: virtkey = VK_KEYPAD_HOME; break; case VK_LEFT: virtkey = VK_KEYPAD_LEFT; break; case VK_UP: virtkey = VK_KEYPAD_UP; break; case VK_RIGHT: virtkey = VK_KEYPAD_RIGHT; break; case VK_DOWN: virtkey = VK_KEYPAD_DOWN; break; case VK_PRIOR: virtkey = VK_KEYPAD_PRIOR; break; case VK_NEXT: virtkey = VK_KEYPAD_NEXT; break; case VK_END: virtkey = VK_KEYPAD_END; break; case VK_CLEAR: virtkey = VK_KEYPAD_BEGIN; break; case VK_INSERT: virtkey = VK_KEYPAD_INSERT; break; case VK_DELETE: virtkey = VK_KEYPAD_DELETE; break; } } // Try looking it up in our table UINT mapsize = sizeof(keymap) / sizeof(vncKeymapping); // Look up the desired code in the table for (UINT i = 0; i < mapsize; i++) { if (keymap[i].wincode == virtkey) { kas.keycodes[numkeys++] = keymap[i].Xcode; break; } } if (numkeys != 0) { // A special case - use Meta instead of Alt if ScrollLock is on UINT key = kas.keycodes[numkeys - 1]; if ((key == XK_Alt_L || key == XK_Alt_R) && GetKeyState(VK_SCROLL)) { if (key == XK_Alt_L) kas.keycodes[numkeys - 1] = XK_Meta_L; else kas.keycodes[numkeys - 1] = XK_Meta_R; } vnclog.Print(8, ": keymap gives %.4x", key); } else { // not found in table vnclog.Print(8, ": not in keymap"); // Try a simple conversion to ASCII, using the current keyboard mapping GetKeyboardState(keystate); // If Left Ctrl & Alt are both pressed and ToAscii() gives a valid keysym. // (This is for AltGr on international keyboards (= LCtrl-Alt). // e.g. Ctrl-Alt-Q gives @ on German keyboards.) if (((keystate[VK_RMENU] & 0x80) != 0) && ((keystate[VK_LCONTROL] & 0x80) != 0)) { // Windows doesn't have a proper AltGr key event. It instead handles // AltGr with fake left Ctrl and right Alt key events. Xvnc will // automatically insert an AltGr (ISO Level 3 Shift) event if necessary // (if it receives a key symbol that could not have been generated any // other way), and unfortunately X11 doesn't generally like the sequence // Ctrl + Alt + AltGr. Thus, for Windows viewers, we have to temporarily // release Ctrl and Alt, then process the AltGr-modified symbol, then // press Ctrl and Alt again. if (GetKeyState(VK_LCONTROL) & 0x8000) kas.releaseModifiers |= KEYMAP_LCONTROL; if (GetKeyState(VK_RMENU) & 0x8000) kas.releaseModifiers |= KEYMAP_RALT; // This is for Windows '95, and possibly other systems. The above // GetKeyState() calls don't work in '95 - they always return 0. // But if we're at this point in the code, we know that left Ctrl and // right Alt are pressed, so let's release those keys if we haven't // registered them as already having been released. if (kas.releaseModifiers == 0) kas.releaseModifiers = KEYMAP_LCONTROL | KEYMAP_RALT; } else { // There are no keysyms corresponding to control characters, e.g. Ctrl-F. // The server already knows whether the Ctrl key is pressed, so we are // interested in the key that would be sent if the Ctrl key were not // pressed. keystate[VK_CONTROL] = keystate[VK_LCONTROL] = keystate[VK_RCONTROL] = 0; } int ret = ToUnicode(virtkey, 0, keystate, buf, 10, 0); if (ret == 0) { // Most Ctrl+Alt combinations will fail to produce a symbol, so // try it again with Ctrl unconditionally disabled. keystate[VK_CONTROL] = keystate[VK_LCONTROL] = keystate[VK_RCONTROL] = 0; ret = ToUnicode(virtkey, 0, keystate, buf, 10, 0); } unsigned keysym = ucs2keysym(buf[0]); if (ret == 1 && keysym != 0) { // If the key means anything in this keyboard layout if (((keystate[VK_RMENU] & 0x80) != 0) && ((keystate[VK_LCONTROL] & 0x80) != 0)) vnclog.Print(8, "\n Ctrl-Alt: UCS->KS (w/o mods): "); else vnclog.Print(8, "\n UCS->KS (w/o ctrl): "); kas.keycodes[numkeys++] = keysym; vnclog.Print(8, " %.2x->%.2x", buf[0], keysym); } if (ret < 0 || ret > 1) { // NOTE: For some reason, TigerVNC never gets a return value > 1 from // ToUnicode(), but we do, even though we're using basically the same // keyboard handling logic. Not sure why. WCHAR dead_char = buf[0]; while (ret < 0) { // Need to clear out the state that the dead key has caused. // This is the recommended method by Microsoft's engineers: // http://blogs.msdn.com/b/michkap/archive/2007/10/27/5717859.aspx ret = ToUnicode(virtkey, 0, keystate, buf, 10, 0); } kas.keycodes[numkeys++] = ucs2keysym(ucs2combining(dead_char)); vnclog.Print(8, " %.2x->%.2x", dead_char, kas.keycodes[numkeys - 1]); } } vnclog.Print(8, "\n"); kas.keycodes[numkeys] = VoidKeyCode; return kas; };
void EditBox_OnKeyDown(struct Box_s *pbox, int vk, int scan) { struct editboxdata_s *data = pbox->boxdata; int len = (int)wcslen(data->text); WCHAR beforecur[1024], aftercur[1024]; char keystate[256]; WCHAR unicode; if (data->disabled) { return; } /* reject alt, ctrl, and shift keys, since they won't add a character */ if (vk == VK_CONTROL || vk == VK_SHIFT || vk == VK_MENU) { return; } GetKeyboardState(keystate); if (Util_OldWinVer()) { char ascii[2]; len = ToAscii(vk, scan, keystate, (LPWORD)ascii, 0); if (!len) { return; } MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, ascii, len, &unicode, 1); } else { ToUnicode(vk, scan, keystate, &unicode, 1, 0); } wcsncpy(beforecur, data->text, data->curpos); beforecur[data->curpos] = 0; aftercur[0] = 0; wcscpy(aftercur, data->text + data->curpos); if (vk == 8) /* backspace */ { if (data->curpos != 0) { data->curpos--; beforecur[data->curpos] = 0; data->text[0] = 0; wcscat(data->text, beforecur); wcscat(data->text, aftercur); if (data->OnKey) { data->OnKey(pbox, EditBox_GetText(pbox)); } } } else if (vk == 46) /* delete */ { if (wcslen(aftercur) > 0) { data->text[0] = 0; wcscat(data->text, beforecur); wcscat(data->text, aftercur + 1); if (data->OnKey) { data->OnKey(pbox, EditBox_GetText(pbox)); } } } else if (vk == 9) /* tab */ { Box_SetNextFocus(pbox, keystate[VK_SHIFT] & 0x8000); } else if (vk == 13) /* enter */ { if (data->OnKey) { data->OnKey(pbox, EditBox_GetText(pbox)); } if (data->OnEnter) { data->OnEnter(pbox, EditBox_GetText(pbox)); } } else if (vk == 35) /* end */ { data->curpos = len; } else if (vk == 36) /* home */ { data->curpos = 0; } else if (vk == 37) /* left */ { if (data->curpos != 0) { data->curpos--; } } else if (vk == 39) /* right */ { if (data->curpos != len) { data->curpos++; } } else if ((vk == 86 && (keystate[VK_CONTROL] & 0x8000)) || (vk == 45 && (keystate[VK_SHIFT] & 0x8000))) /* ctrl+v, shift+ins */ { EditBox_OnPaste(pbox); } else if (len < 1023 && unicode > 31) /* Displayable character */ { beforecur[data->curpos] = unicode; data->curpos++; beforecur[data->curpos] = 0; data->text[0] = 0; wcscat(data->text, beforecur); wcscat(data->text, aftercur); if (data->OnKey) { data->OnKey(pbox, EditBox_GetText(pbox)); } } else { Log_Write(0, "unhandled vk %d\n", vk); } Box_Repaint(pbox); }
//************************************************************************ // CLCDInput::ProcessKeyEvent //************************************************************************ LRESULT CLCDInput::ProcessKeyEvent(int Code, WPARAM wParam, LPARAM lParam) { // Event verarbeiten if(Code == HC_ACTION) { KBDLLHOOKSTRUCT *key = (KBDLLHOOKSTRUCT *)(lParam); bool bKeyDown = !(key->flags & LLKHF_UP); bool bToggled = (m_acKeyboardState[key->vkCode] & 0x0F) != 0; if(bKeyDown) bToggled = !bToggled; m_acKeyboardState[key->vkCode] = (bKeyDown?0x80:0x00) | (bToggled?0x01:0x00); if(key->vkCode == VK_LSHIFT || key->vkCode == VK_RSHIFT) m_acKeyboardState[VK_SHIFT] = m_acKeyboardState[key->vkCode]; else if(key->vkCode == VK_LCONTROL || key->vkCode == VK_RCONTROL) m_acKeyboardState[VK_CONTROL] = m_acKeyboardState[key->vkCode]; else if(key->vkCode == VK_LMENU || key->vkCode == VK_RMENU) m_acKeyboardState[VK_MENU] = m_acKeyboardState[key->vkCode]; /* if(bKeyDown) TRACE(_T("Key pressed: %i\n"),key->vkCode); else TRACE(_T("Key released: %i\n"),key->vkCode); */ // Only handle Keyup if(bKeyDown) { // Actions with Control/Menu keys if((m_acKeyboardState[VK_LMENU] & 0x80 || m_acKeyboardState[VK_CONTROL] & 0x80) && m_acKeyboardState[VK_SHIFT] & 0x80) { ActivateKeyboardLayout((HKL)HKL_NEXT,0);//KLF_SETFORPROCESS); TRACE(_T("Keyboardlayout switched!\n")); return 1; } int res = 0,size = 0,dir = MARKER_HORIZONTAL,scroll = 0; /* if(key->vkCode == VK_DELETE) { dir = MARKER_HOLD; res = -1; if(m_strText[m_Marker[0].iPosition] == '\r') res = -2; if(m_strText.length() >= m_Marker[0].iPosition + -res) { m_strText.erase(m_Marker[0].iPosition,-res); scroll = 1; size = 1; } else { res = 0; } } else */if(key->vkCode == VK_BACK ) { if(m_Marker[0].iPosition != 0) { res = -1; if(m_strText[m_Marker[0].iPosition+res] == '\n') res = -2; m_strText.erase(m_Marker[0].iPosition+res,-res); scroll = 1; size = res; } } // Marker navigation else if (key->vkCode == VK_INSERT) { m_bInsert = !m_bInsert; } else if(key->vkCode == VK_HOME) { res = m_vLineOffsets[m_Marker[0].iLine].iOffset - m_Marker[0].iPosition; scroll = 1; } else if(key->vkCode == VK_END) { if(m_vLineOffsets.size()-1 == m_Marker[0].iLine) res = (int)m_strText.length() - m_Marker[0].iPosition; else res = (m_vLineOffsets[m_Marker[0].iLine+1].iOffset - 1 - m_vLineOffsets[m_Marker[0].iLine+1].bLineBreak) -m_Marker[0].iPosition; scroll = 1; } else if(key->vkCode == VK_UP) { res = -1; dir = MARKER_VERTICAL; } else if(key->vkCode == VK_DOWN) { res = 1; dir = MARKER_VERTICAL; } else if(key->vkCode == VK_LEFT) res = -1; else if(key->vkCode == VK_RIGHT) res = 1; else { #ifdef _UNICODE TCHAR output[4]; #else unsigned char output[2]; #endif if(key->vkCode == VK_RETURN) { bool bCtrlDown = (m_acKeyboardState[VK_CONTROL] & 0x80) != 0; if( bCtrlDown != (m_iBreakKeys == KEYS_RETURN)) { DeactivateInput(); //m_pParent->OnInputFinished(); return 1; } else { res = 2; output[0] = '\r'; output[1] = '\n'; output[2] = 0; } } else { #ifdef _UNICODE res = ToUnicode(key->vkCode,key->scanCode,m_acKeyboardState,output,4,0); #else res = ToAscii( key->vkCode,key->scanCode,m_acKeyboardState,(WORD*)output,0); #endif } if(res <= 0) res = 0; else { if(output[0] != '\r' && output[0] <= 0x001F) return 1; if(m_bInsert || m_strText[m_Marker[0].iPosition] == '\r') m_strText.insert(m_Marker[0].iPosition,(TCHAR*)output,res); else m_strText.replace(m_Marker[0].iPosition,res,(TCHAR*)output); scroll = 1; size = res; } } if(res != 0) { if(dir != MARKER_HOLD) { MoveMarker(dir,res); } UpdateOffsets(size); UpdateMarker(); ScrollToMarker(); m_lInputTime = GetTickCount(); } //WrapLine(); // ---- // Block this KeyEvent } return 1; } return CallNextHookEx(m_hKBHook, Code, wParam, lParam); }
// --------------------------------------------------------------------------- // Load() // 2channel.brd形式のファイルから読み込む // --------------------------------------------------------------------------- bool O2Boards:: Load(const wchar_t *fn) { const wchar_t *filename = fn ? fn : filepath.c_str(); #ifdef _WIN32 struct _stat st; if (_tstat(filename, &st) == -1) return false; #else /** VC++ function equivalent */ struct stat st; string unixFilename; FromUnicode(_T(DEFAULT_XML_CHARSET), filename, unixFilename); if (_tstat(unixFilename.c_str(), &st) == -1) return false; #endif if (st.st_size == 0) return false; FILE *fp; #ifdef _WIN32 if (_tfopen_s(&fp, filename, _T("rb")) != 0) return false; #else /** VC++ _s function equivalent */ if (fopen_s(&fp, unixFilename.c_str(), "rb") != 0) return false; #endif string buff; buff.resize(st.st_size); fread(&buff[0], 1, st.st_size, fp); fclose(fp); wstring unicode; if (!ToUnicode(L"shift_jis", buff, unicode)) return false; BoardsLock.Lock(); boards.clear(); BoardsLock.Unlock(); std::wstringstream ss(unicode); std::wstring line; std::wstring category; std::getline(ss, line); //skip first line while (!ss.fail()) { std::getline(ss, line); if (line.empty()) continue; if (*(line.end()-1) == L'\r') line.erase(line.end()-1); boost::wregex regex(L"^\t?([^[\t]+)\t([^[\t]+)(?:\t([^[\t]+))?$"); boost::wsmatch m; boost::regex_match(line, m, regex); if (line[0] != L'\t') { category = m.str(1); } else { const wchar_t *domain = host2domain(m.str(1).c_str()); if (!domain) continue; O2Board brd; brd.bbsname = m.str(2); brd.title = m.str(3); brd.category = category; brd.host = m.str(1); brd.domain = domain; BoardsLock.Lock(); O2BoardArrayIt it = std::find(boards.begin(), boards.end(), brd); if (it == boards.end()) boards.push_back(brd); BoardsLock.Unlock(); } } LastModified = st.st_mtime; /* TRACEA("st.st_mtime:"); TRACEA(ctime(&st.st_mtime)); TRACEA("bbsmenu_lastmodified:"); TRACEA(ctime(&bbsmenu_lastmodified)); */ return true; }
/** Parse a shader state element inside a Pass XML element. */ void U2FrameXmlParser::ParseShaderState(U2FxShaderState::Type type, TiXmlElement* elem, U2FrameSequence* seq) { U2ASSERT(elem && seq); U2FxShaderState::Param eParam = U2FxShaderState:: StringToParam(elem->Attribute("name")); U2ShaderArg* pArg = U2_NEW U2ShaderArg(type); if(HasAttr(elem, "value")) { switch(type) { case U2FxShaderState::Int: pArg->SetInt(GetIntAttr(elem, "value", 0)); break; case U2FxShaderState::Float: pArg->SetFloat(GetFloatAttr(elem, "value", 0.0f)); break; case U2FxShaderState::Float4: { U2Float4 f4 = {0.f}; pArg->SetFloat4(GetFloat4Attr(elem, "value", f4)); } break; case U2FxShaderState::Texture: { #ifdef UNICODE const wchar_t* szFilename = ToUnicode(elem->Attribute("value")); #else const char* szFilename = elem->Attribute("value"); #endif U2ASSERT(szFilename); U2Dx9BaseTexture* pTexIter = U2Dx9BaseTexture::GetHead(); U2Dx9BaseTexture* pNexTex = 0; while(pTexIter) { // Create시 SetName을 함.. if(pTexIter->GetName() == szFilename) { pNexTex = pTexIter; break; } pTexIter = pTexIter->GetNext(); } if(!pNexTex) { U2FilePath fPath; TCHAR fullPath[256]; fPath.ConvertToAbs(fullPath, 256 * sizeof(TCHAR) , szFilename, TEXTURE_PATH); pNexTex = U2Dx9Texture::Create(fullPath, U2Dx9Renderer::GetRenderer()); } pArg->SetTexture(pNexTex); } break; default: FDebug("nRpXmlParser::ParseShaderState(): invalid data type '%s'!", elem->Attribute("name")); break; } seq->AddConstantShaderParam(eParam, *pArg); } else if(HasAttr(elem, "variable")) { #ifdef UNICODE const WCHAR* szVar =ToUnicode(elem->Attribute("variable")); #else const char* szVar = elem->Attribute("variable"); #endif seq->AddVariableShaderParam(szVar, eParam, *pArg); } }
/** Parse a Sequence XML element. */ void U2FrameXmlParser::ParseFrameSequence(TiXmlElement* elem, U2FramePhase* phase) { U2ASSERT(elem && phase); U2FrameSequence* pNewSeq = U2_NEW U2FrameSequence; #ifdef UNICODE pNewSeq->SetShaderAlias(ToUnicode(elem->Attribute("shader"))); #else pNewSeq->SetShaderAlias(elem->Attribute("shader")); #endif if(HasAttr(elem, "technique")) { #ifdef UNICODE pNewSeq->SetTechnique(ToUnicode(elem->Attribute("technique"))); #else pNewSeq->SetTechnique(elem->Attribute("technique")); #endif } pNewSeq->SetShaderUpdateEnabled(GetBoolAttr(elem, "shaderUpdates", true)); pNewSeq->SetFirstLightAlphaEnabled(GetBoolAttr(elem, "firstLightAlpha", false)); pNewSeq->SetModelViewProjOnlyHint(GetBoolAttr(elem, "mvpOnly", false)); TiXmlElement* pChild; for(pChild = elem->FirstChildElement(); pChild; pChild = pChild->NextSiblingElement()) { #ifdef UNICODE if(pChild->Value() == U2DynString(L"Float")) { ParseShaderState(U2FxShaderState::Float, pChild, pNewSeq); } else if(pChild->Value() == U2DynString(L"Float4")) { ParseShaderState(U2FxShaderState::Float4, pChild, pNewSeq); } else if(pChild->Value() == U2DynString(L"Int")) { ParseShaderState(U2FxShaderState::Int, pChild, pNewSeq); } else if(pChild->Value() == U2DynString(L"Texture")) { ParseShaderState(U2FxShaderState::Texture, pChild, pNewSeq); } #else if(pChild->Value() == U2DynString("Float")) { ParseShaderState(U2FxShaderState::Float, pChild, pNewSeq); } else if(pChild->Value() == U2DynString("Float4")) { ParseShaderState(U2FxShaderState::Float4, pChild, pNewSeq); } else if(pChild->Value() == U2DynString("Int")) { ParseShaderState(U2FxShaderState::Int, pChild, pNewSeq); } else if(pChild->Value() == U2DynString("Texture")) { ParseShaderState(U2FxShaderState::Texture, pChild, pNewSeq); } #endif } phase->AddFrameSeq(pNewSeq); }
//------------------------------------------------------------------------------------------------- bool U2FrameXmlParser::Parse() { TiXmlHandle docHandle(m_pXmlDoc); TiXmlElement* pFrameElem = docHandle.FirstChildElement("Frame").Element(); U2ASSERT(pFrameElem); TiXmlElement* pChild; for(pChild = pFrameElem->FirstChildElement(); pChild; pChild = pChild->NextSiblingElement()) { #ifdef UNICODE if(ToUnicode(pChild->Value()) == U2DynString(_T("Shaders"))) { ParseShaders(); } else if(ToUnicode(pChild->Value()) == U2DynString(_T("RenderTarget"))) { ParseRenderTarget(pChild, m_pOwnerFrame); } else if(ToUnicode(pChild->Value()) == U2DynString(_T("Float"))) { ParseGlobalVariable(U2Variable::Float, pChild, m_pOwnerFrame); } else if(ToUnicode(pChild->Value()) == U2DynString(_T("Float4"))) { ParseGlobalVariable(U2Variable::Vector4, pChild, m_pOwnerFrame); } else if(ToUnicode(pChild->Value()) == U2DynString(_T("Int"))) { ParseGlobalVariable(U2Variable::Int, pChild, m_pOwnerFrame); } else if(ToUnicode(pChild->Value()) == U2DynString(_T("Texture"))) { ParseGlobalVariable(U2Variable::Object, pChild, m_pOwnerFrame); } else if(ToUnicode(pChild->Value()) == U2DynString(_T("RenderTarget"))) { ParseFrameSection(pChild, m_pOwnerFrame); } #else if(pChild->Value() == U2DynString(_T("Shaders"))) { PROFILER_DECLARE(prof); PROFILER_START(prof); ParseShaders(); PROFILER_STOP(prof); //FILE_LOG(logINFO) << _T("ParseShaders: ") << prof.GetTimeInSecs(); } else if(pChild->Value() == U2DynString(_T("RenderTarget"))) { PROFILER_DECLARE(prof); PROFILER_START(prof); ParseRenderTarget(pChild, m_pOwnerFrame); PROFILER_STOP(prof); //FILE_LOG(logINFO) << _T("ParseRenderTarget: ") << prof.GetTimeInSecs(); } else if(pChild->Value() == U2DynString(_T("Float"))) { PROFILER_DECLARE(prof); PROFILER_START(prof); ParseGlobalVariable(U2Variable::Float, pChild, m_pOwnerFrame); PROFILER_STOP(prof); //FILE_LOG(logINFO) << _T("ParseGlobalVariable Float: ") << prof.GetTimeInSecs(); } else if(pChild->Value() == U2DynString(_T("Float4"))) { PROFILER_DECLARE(prof); PROFILER_START(prof); ParseGlobalVariable(U2Variable::Vector4, pChild, m_pOwnerFrame); PROFILER_STOP(prof); //FILE_LOG(logINFO) << _T("ParseGlobalVariable Float4: ") << prof.GetTimeInSecs(); } else if(pChild->Value() == U2DynString(_T("Int"))) { PROFILER_DECLARE(prof); PROFILER_START(prof); ParseGlobalVariable(U2Variable::Int, pChild, m_pOwnerFrame); PROFILER_STOP(prof); //FILE_LOG(logINFO) << _T("ParseGlobalVariable Int: ") << prof.GetTimeInSecs(); } else if(pChild->Value() == U2DynString(_T("Texture"))) { PROFILER_DECLARE(prof); PROFILER_START(prof); ParseGlobalVariable(U2Variable::Object, pChild, m_pOwnerFrame); PROFILER_STOP(prof); //FILE_LOG(logINFO) << _T("ParseGlobalVariable Texture: ") << prof.GetTimeInSecs(); } else if(pChild->Value() == U2DynString(_T("FrameSection"))) { PROFILER_DECLARE(prof); PROFILER_START(prof); // Reset 에러... 2011/09/26 ParseFrameSection(pChild, m_pOwnerFrame); PROFILER_STOP(prof); //FILE_LOG(logINFO) << _T("ParseFrameSection: ") << prof.GetTimeInSecs(); } #endif } return true; }
/** Parse a Pass element inside a Section element. */ void U2FrameXmlParser::ParseFramePass(TiXmlElement* elem, U2FrameSection* section) { U2ASSERT(elem && section); U2FramePass* pNewPass = U2_NEW U2FramePass; pNewPass->SetFrame(section->GetFrame()); #ifdef UNICODE pNewPass->SetName(ToUnicode(elem->Attribute("name"))); pNewPass->SetShaderAlias(ToUnicode(elem->Attribute("shader"))); #else pNewPass->SetName(elem->Attribute("name")); pNewPass->SetShaderAlias(elem->Attribute("shader")); #endif U2DynString szRenderTarget(_T("renderTarget")); int i=0; unsigned int uClearFlag = 0; #ifdef UNICODE while(HasAttr(elem, ToAscii(szRenderTarget.Str()))) { //pNewPass->SetRenderTargetName(i, ToUnicode(elem->Attribute(szRenderTarget.Str())); szRenderTarget = L("renderTarget"); szRenderTarget.AppendInt(++i); } #else while(HasAttr(elem, szRenderTarget.Str())) { pNewPass->SetRenderTargetName(i, elem->Attribute(szRenderTarget.Str())); szRenderTarget = "renderTarget"; szRenderTarget.AppendInt(++i); } #endif if(HasAttr(elem, "stats")) { //pNewPass->SetStatsEnabled(GetBoolAttr(elem, "stats", true)); } int clearFlags = 0; if(HasAttr(elem, "clearColor")) { uClearFlag |= U2Dx9Renderer::CLEAR_BACKBUFFER; D3DXVECTOR4 color = GetVector4Attr(elem, "clearColor", D3DXVECTOR4(0.f, 0.f, 0.f, 1.f)); pNewPass->SetBackgroundColor(D3DXCOLOR(color.x, color.y, color.z, color.w)); } if(HasAttr(elem, "clearDepth")) { uClearFlag |= U2Dx9Renderer::CLEAR_ZBUFFER; pNewPass->SetDepthClear(GetFloatAttr(elem, "clearDepth", 1.0f)); } if(HasAttr(elem, "clearStencil")) { uClearFlag |= U2Dx9Renderer::CLEAR_STENCIL; pNewPass->SetStencilClear(GetIntAttr(elem, "clearStencil", 0)); } pNewPass->SetClearFlags(uClearFlag); if(HasAttr(elem, "drawQuad")) { pNewPass->SetDrawFullscreenQuad(GetBoolAttr(elem, "drawQuad", false)); // CreateQuad if (pNewPass->GetDrawFullscreenQuad()) pNewPass->CreateScreenQuad(); } if(HasAttr(elem, "drawShadows")) { #ifdef UNICODE pNewPass->SetShadowTechnique(ToUnicode(U2FramePass::StringToShadowTechnique(elem->Attribute("drawShadows")))); #else pNewPass->SetShadowTechnique(U2FramePass::StringToShadowTechnique(elem->Attribute("drawShadows"))); #endif } if(HasAttr(elem, "occlusionQuery")) { pNewPass->SetOcclusionQuery(GetBoolAttr(elem, "occlusionQuery", false)); } if(HasAttr(elem, "drawGui")) { pNewPass->SetDrawGui(GetBoolAttr(elem, "drawGui", false)); } if(HasAttr(elem, "technique")) { #ifdef UNICODE pNewPass->SetTechnique(ToUnicode(elem->Attribute("technique"))); #else pNewPass->SetTechnique(elem->Attribute("technique")); #endif } if(HasAttr(elem, "shadowEnabledCondition")) { pNewPass->SetShadowEnabled(GetBoolAttr(elem, "shadowEnabledCondition", false)); } if(HasAttr(elem, "addDepthStencil")) { pNewPass->SetDepthStencil(GetBoolAttr(elem, "addDepthStencil", false)); } TiXmlElement* pChild; for(pChild = elem->FirstChildElement(); pChild; pChild = pChild->NextSiblingElement()) { #ifdef UNICODE if(pChild->Value() == U2DynString(L"Float")) { ParseShaderState(U2FxShaderState::Float, pChild, pNewPass); } else if(pChild->Value() == U2DynString(L"Float4")) { ParseShaderState(U2FxShaderState::Float4, pChild, pNewPass); } else if(pChild->Value() == U2DynString(L"Int")) { ParseShaderState(U2FxShaderState::Int, pChild, pNewPass); } else if(pChild->Value() == U2DynString(L"Texture")) { ParseShaderState(U2FxShaderState::Texture, pChild, pNewPass); } else if(pChild->Value() == U2DynString(L"FramePhase")) { ParseFramePhase(pChild, pNewPass); } #else if(pChild->Value() == U2DynString("Float")) { ParseShaderState(U2FxShaderState::Float, pChild, pNewPass); } else if(pChild->Value() == U2DynString("Float4")) { ParseShaderState(U2FxShaderState::Float4, pChild, pNewPass); } else if(pChild->Value() == U2DynString("Int")) { ParseShaderState(U2FxShaderState::Int, pChild, pNewPass); } else if(pChild->Value() == U2DynString("Texture")) { ParseShaderState(U2FxShaderState::Texture, pChild, pNewPass); } else if(pChild->Value() == U2DynString("Phase")) { ParseFramePhase(pChild, pNewPass); } #endif } section->AddFramePass(pNewPass); }
//------------------------------------------------------------------------------------------------- U2Variable* U2FrameXmlParser::ParseVariable(U2Variable::Type dataType, TiXmlElement* elem) { U2ASSERT(elem); const char* szVar = elem->Attribute("name"); U2ASSERT(szVar); U2Variable::Handle varHandle = U2VariableMgr::Instance()->GetVariableHandleByName(szVar); U2Variable* pNewVar = U2_NEW U2Variable(dataType, varHandle); switch(dataType) { case U2Variable::Int: pNewVar->SetInt(GetIntAttr(elem, "value", 0)); break; case U2Variable::Float: pNewVar->SetFloat(GetFloatAttr(elem, "value", 0.0f)); break; case U2Variable::Vector4: { D3DXVECTOR4 v(VECTOR4_ZERO); pNewVar->SetVector4(GetVector4Attr(elem, "value", v)); } break; case U2Variable::Object: { #ifdef UNICODE const wchar_t* szFilename = ToUnicode(elem->Attribute("value")); #else const char* szFilename = elem->Attribute("value"); #endif U2ASSERT(szFilename); U2Dx9BaseTexture* pTexIter = U2Dx9BaseTexture::GetHead(); U2Dx9BaseTexture* pNexTex = 0; while(pTexIter) { // Create시 SetName을 함.. if(pTexIter->GetName() == szFilename) { pNexTex = pTexIter; break; } pTexIter = pTexIter->GetNext(); } if(!pNexTex) { U2FilePath fPath; TCHAR fullPath[256]; fPath.ConvertToAbs(fullPath, 256 * sizeof(TCHAR) , szFilename, TEXTURE_PATH); pNexTex = U2Dx9Texture::Create(fullPath, U2Dx9Renderer::GetRenderer()); } pNewVar->SetObj(pNexTex); } break; default: U2ASSERT(false); FDebug("nRpXmlParser::ParseGlobalVariable(): invalid datatype for variable '%s'!", szVar); break; } return pNewVar; }
static void processkey(WINDISPLAY *mod, WINWINDOW *win, TUINT type, TINT code) { TIMSG *imsg; TINT numchars = 0; WCHAR buff[2]; getqualifier(mod, win); switch (code) { case VK_LEFT: code = TKEYC_CRSRLEFT; break; case VK_UP: code = TKEYC_CRSRUP; break; case VK_RIGHT: code = TKEYC_CRSRRIGHT; break; case VK_DOWN: code = TKEYC_CRSRDOWN; break; case VK_ESCAPE: code = TKEYC_ESC; break; case VK_DELETE: code = TKEYC_DEL; break; case VK_BACK: code = TKEYC_BCKSPC; break; case VK_TAB: code = TKEYC_TAB; break; case VK_RETURN: code = TKEYC_RETURN; break; case VK_HELP: code = TKEYC_HELP; break; case VK_INSERT: code = TKEYC_INSERT; break; case VK_PRIOR: code = TKEYC_PAGEUP; break; case VK_NEXT: code = TKEYC_PAGEDOWN; break; case VK_HOME: code = TKEYC_POSONE; break; case VK_END: code = TKEYC_POSEND; break; case VK_PRINT: code = TKEYC_PRINT; break; case VK_SCROLL: code = TKEYC_SCROLL; break; case VK_PAUSE: code = TKEYC_PAUSE; break; case VK_DECIMAL: code = '.'; imsg->timsg_Qualifier |= TKEYQ_NUMBLOCK; break; case VK_ADD: code = '+'; imsg->timsg_Qualifier |= TKEYQ_NUMBLOCK; break; case VK_SUBTRACT: code = '-'; imsg->timsg_Qualifier |= TKEYQ_NUMBLOCK; break; case VK_MULTIPLY: code = '*'; imsg->timsg_Qualifier |= TKEYQ_NUMBLOCK; break; case VK_DIVIDE: code = '/'; imsg->timsg_Qualifier |= TKEYQ_NUMBLOCK; break; case VK_F1: case VK_F2: case VK_F3: case VK_F4: case VK_F5: case VK_F6: case VK_F7: case VK_F8: case VK_F9: case VK_F10: case VK_F11: case VK_F12: code = (TUINT) (code - VK_F1) + TKEYC_F1; break; default: numchars = ToUnicode(code, 0, win->fbv_KeyState, buff, 2, 0); if (numchars > 0) code = buff[0]; } if ((win->fbv_InputMask & type) && fb_getimsg(mod, win, &imsg, type)) { ptrdiff_t len; imsg->timsg_Code = code; len = (ptrdiff_t) encodeutf8(imsg->timsg_KeyCode, imsg->timsg_Code) - (ptrdiff_t) imsg->timsg_KeyCode; imsg->timsg_KeyCode[len] = 0; fb_sendimsg(mod, win, imsg); } }
void KeyMap::PCtoX(BYTE virtKey, DWORD keyData, ClientConnection* clientCon) { bool down = ((keyData & 0x80000000) == 0); bool extended = ((keyData & 0x1000000) != 0); bool repeated = ((keyData & 0xc0000000) == 0x40000000); UINT extVkey = virtKey + (extended ? 256 : 0); // exclude winkey when not scroll-lock if (virtKey==91 || virtKey==92) return; vnclog.Print(8, _T("\nPCtoX: %svirtKey 0x%02x%s%s, keyData 0x%08x\n"), (extended ? _T("extended ") : _T("")), virtKey, (repeated ? _T(" repeated") : _T("")), (down ? _T(" down") : _T(" up")), keyData); // If this is a key release then just send the associated sent KeySym when // this key was pressed if (!down) { vnclog.Print(8, _T("Release the associated KeySym when this VirtKey was pressed\n")); if (downUnicode[extVkey]) { vnclog.Print(8, _T(" 0x%04x (%c): "), downUnicode[extVkey], downUnicode[extVkey]); downUnicode[extVkey] = NULL; } else { vnclog.Print(8, _T(" Control character: ")); } releaseKey(clientCon, extVkey); vnclog.Print(8, _T("\n")); GetKeyboardState(KBKeysState); if (!((KBKeysState[VK_MENU] & 0x80) && (KBKeysState[VK_CONTROL] & 0x80))) { if (storedDeadChar && reset) { reset=false; keybd_event(VK_SPACE, 0, 0, 0); keybd_event(VK_SPACE, 0, KEYEVENTF_KEYUP, 0); } } return; } // We try to look it up in our key table // Look up the desired code in the keyMap table try to find the exact match according to // the extended flag, then try the opposite of the extended flag CARD32 foundXCode = XK_VoidSymbol; bool exactMatched = false; vnclog.Print(8, _T("Looking in key table ")); for (UINT i = 0; i < (sizeof(keyMap) / sizeof(vncKeyMapping_t)); i++) { if (keyMap[i].WinCode == virtKey) { foundXCode = keyMap[i].XCode; if (extended == keyMap[i].extVK) { exactMatched = true; break; } } } if (foundXCode != XK_VoidSymbol) { vnclog.Print(8, _T("-> keyMap gives (from %s extended flag) KeySym %u (0x%08x)\n"), (exactMatched ? _T("matched") : _T("opposite")), foundXCode, foundXCode); pressKey(clientCon, extVkey, foundXCode); vnclog.Print(8, _T("\n")); return; } else { vnclog.Print(8, _T("-> not in special keyMap\n")); } // Under CE, we're not so concerned about this bit because we handle a WM_CHAR message later #ifndef UNDER_CE GetKeyboardState(KBKeysState); ModifierKeyReleaser lctrl(clientCon, VK_CONTROL, 0); ModifierKeyReleaser lalt(clientCon, VK_MENU, 0); ModifierKeyReleaser ralt(clientCon, VK_MENU, 1); if ((KBKeysState[VK_MENU] & 0x80) && (KBKeysState[VK_CONTROL] & 0x80)) { // This is a Ctrl-Alt (AltGr) key on international keyboards (= LCtrl-RAlt) // Ex. Ctrl-Alt-Q gives '@' on German keyboards vnclog.Print(8, _T("Ctrl-Alt pressed:\n")); // We must release Control and Alt (AltGr) if they were both pressed, so the character // is seen without them by the VNC server // We don't release the Right Control; this allows German users // to use it for doing Ctrl-AltGr-x, e.g. Ctl-@, etc lctrl.release(downKeysym); lalt.release(downKeysym); ralt.release(downKeysym); } else { // This is not a Ctrl-Alt (AltGr) key vnclog.Print(8, _T("Ctrl-Alt not pressed, fake release any Ctrl key\n")); // There are no KeySym corresponding to control characters, e.g. Ctrl-F // The server has already known whether the Ctrl key is pressed from the previouse key event // So we are interested in the key that would be there if the Ctrl key were not pressed KBKeysState[VK_CONTROL] = KBKeysState[VK_LCONTROL] = KBKeysState[VK_RCONTROL] = 0; } int ret; if (storedDeadChar) { SHORT virtDeadKey; BYTE prevModifierState = 0; vnclog.Print(8, _T("[Storing base character modifier(s)]\n")); StoreModifier(&prevModifierState, KBKeysState); virtDeadKey = VkKeyScanW(storedDeadChar); vnclog.Print(8, _T("[A dead key was stored, restoring the dead key state:") _T(" 0x%02x (%c) using virtDeadKey 0x%02x] "), storedDeadChar, storedDeadChar, virtDeadKey); SetModifier(HIBYTE(virtDeadKey), KBKeysState); vnclog.Print(8, _T("\n")); ToUnicode((virtDeadKey & 0xff), 0, KBKeysState, ucsChar, (sizeof(ucsChar) / sizeof(WCHAR)), 0); vnclog.Print(8, _T("[Restoring base character modifier(s)] ")); SetModifier(prevModifierState, KBKeysState); vnclog.Print(8, _T("\n")); storedDeadChar = 0; ret = ToUnicode(virtKey, 0, KBKeysState, ucsChar, (sizeof(ucsChar) / sizeof(WCHAR)), 0); } else ret = ToUnicode(virtKey, 0, KBKeysState, ucsChar, (sizeof(ucsChar) / sizeof(WCHAR)), 0); if (ucsChar[0]==8364) { //euro // return; } if (ret < 0 || ret==2) { // It is a dead key vnclog.Print(8, _T("ToUnicode returns dead key: 0x%02x (%c) "), *ucsChar, *ucsChar); if (sendDeadKey) { // We try to look it up in our dead key table // Look up the desired code in the deadKeyMap table foundXCode = XK_VoidSymbol; for (UINT i = 0; i < (sizeof(deadKeyMap) / sizeof(vncDeadKeyMapping_t)); i++) { if (deadKeyMap[i].deadKeyChar == *ucsChar) { foundXCode = deadKeyMap[i].XCode; break; } } if (foundXCode != XK_VoidSymbol) { vnclog.Print(8, _T("-> deadKeyMap gives KeySym %u (0x%08x)\n"), foundXCode, foundXCode); pressKey(clientCon, extVkey, foundXCode); } else { vnclog.Print(8, _T("-> not in deadKeyMap\n")); } } else { storedDeadChar = *ucsChar; reset=true; vnclog.Print(8, _T("-> Store the dead key state, wait for next key-stroke\n")); } FlushDeadKey(KBKeysState); } else if (ret > 0) { vnclog.Print(8, _T("ToUnicode returns %d character(s):\n"), ret); for (int i = 0; i < ret; i++) { CARD32 xChar = UCS2X(*(ucsChar+i)); if (xChar != XK_VoidSymbol) { downUnicode[extVkey] = *(ucsChar+i); pressKey(clientCon, extVkey, xChar); } } } else { vnclog.Print(8, _T("No character is generated by this key event\n")); } #endif vnclog.Print(8, _T("\n")); };