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