BOOL raw_idev_handler(LPARAM l_param){ RAWINPUT *raw_buf; UINT cb_size; /* get the size of the RAWINPUT structure returned */ GetRawInputData((HRAWINPUT)l_param, RID_INPUT, NULL, &cb_size, sizeof(RAWINPUTHEADER) ); /* allocate memory RAWINPUT structure */ raw_buf = (PRAWINPUT)malloc(cb_size); if(!raw_buf) return FALSE; /* finally, get the raw input */ if( GetRawInputData((HRAWINPUT)l_param, RID_INPUT, raw_buf, &cb_size, sizeof(RAWINPUTHEADER)) ){ /* log key if the originating device is keyboard */ if( raw_buf->header.dwType == RIM_TYPEKEYBOARD && ( raw_buf->data.keyboard.Message == WM_KEYDOWN || raw_buf->data.keyboard.Message == WM_SYSKEYDOWN ) ) write_to_log( raw_buf->data.keyboard.VKey ); } free(raw_buf); return TRUE; }
void OnRawInput(bool inForeground, HRAWINPUT hRawInput) { UINT dataSize; GetRawInputData(hRawInput, RID_INPUT, NULL, &dataSize, sizeof(RAWINPUTHEADER)); if(dataSize == 0) { return; } if(dataSize > rawInputMessageData.size()) { rawInputMessageData.resize(dataSize); } void* dataBuf = &rawInputMessageData[0]; GetRawInputData(hRawInput, RID_INPUT, dataBuf, &dataSize, sizeof(RAWINPUTHEADER)); const RAWINPUT *raw = (const RAWINPUT*)dataBuf; if (raw->header.dwType == RIM_TYPEMOUSE) { HANDLE deviceHandle = raw->header.hDevice; const RAWMOUSE& mouseData = raw->data.mouse; TCHAR dataStr[1024]; memset(dataStr, NULL, 1024); _stprintf_s(dataStr, 1024, _T( "Mouse: Device=0x%08X, Flags=%04x, ButtonFlags=%d, ButtonData=%d, ulRawButtons=%d, X=%d, Y=%d, ulExtraInformation=%d\n"), deviceHandle, mouseData.usFlags, mouseData.usButtonFlags, (short)mouseData.usButtonData, mouseData.ulRawButtons, (LONG)mouseData.lLastX, (LONG)mouseData.lLastY, mouseData.ulExtraInformation); OutputDebugString(dataStr); } }
void WinRawInput::ProcessRawInput(MSG& msg) { UINT dwSize; GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); if(dwSize > m_inputBufferBytes) { m_inputBufferBytes = dwSize; mem_free(m_inputBuffer); m_inputBuffer = (uint8*)mem_alloc(dwSize); } if (GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, m_inputBuffer, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize ) { logger() << "GetRawInputData does not return correct size !\n"; return; } RAWINPUT* raw = (RAWINPUT*)m_inputBuffer; if (raw->header.dwType == RIM_TYPEKEYBOARD) { ProcessKeyboard(raw); } else if (raw->header.dwType == RIM_TYPEMOUSE) { ProcessMouse(raw); } }
static void ProcessRawInput(HRAWINPUT hRawInput) { UINT iSize; UINT result = GetRawInputData(hRawInput, RID_INPUT, NULL, &iSize, sizeof(RAWINPUTHEADER)); LPBYTE lpInput = new BYTE[iSize]; result = GetRawInputData(hRawInput, RID_INPUT, lpInput, &iSize, sizeof(RAWINPUTHEADER)); RAWINPUT * pInput = (RAWINPUT *)lpInput; if (rawInputDeviceList.hDevice == pInput->header.hDevice) { switch (pInput->header.dwType) { case RIM_TYPEMOUSE: ProcessRawInputMouse(pInput); break; case RIM_TYPEKEYBOARD: ProcessRawInputKeyboard(pInput); break; case RIM_TYPEHID: break; default: break; } } delete [] lpInput; }
LRESULT CALLBACK Input::wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { auto input = (Input*)GetWindowLongPtr(hWnd, GWLP_USERDATA); switch (message) { case WM_DESTROY: PostQuitMessage(0); break; case WM_INPUT: { UINT dwSize; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); LPBYTE lpb = new BYTE[dwSize]; 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_TYPEKEYBOARD) { auto device = std::find_if(input->_keyboards.begin(), input->_keyboards.end(), [raw](std::shared_ptr<Keyboard> m) {return m->GetHandle() == raw->header.hDevice; }); if (device != input->_keyboards.end()) { (*device)->ApplyInput(*raw); } } else if (raw->header.dwType == RIM_TYPEMOUSE) { auto device = std::find_if(input->_mice.begin(), input->_mice.end(), [raw](std::shared_ptr<Mouse> m) {return m->GetHandle() == raw->header.hDevice; }); if(device != input->_mice.end()){ (*device)->ApplyInput(*raw); } } } break; default: return DefWindowProc(hWnd, message, wParam, lParam); } return 0; }
void wiRawInput::RetrieveData(LPARAM lParam) { UINT dwSize; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); LPBYTE lpb = new BYTE[dwSize]; if (lpb == NULL) { return; } if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize) OutputDebugString(TEXT("GetRawInputData does not return correct size !\n")); raw = RAWINPUT( (const RAWINPUT&)*lpb ); if (raw.header.dwType == RIM_TYPEHID) { int asd = 2; asd = asd; } delete[] lpb; return; }
LRESULT Process(HWND hWnd, WPARAM wParam, LPARAM lParam) { UINT dwSize; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); if (!rawInputBuffer) { rawInputBuffer = malloc(dwSize); rawInputBufferSize = dwSize; } if (dwSize > rawInputBufferSize) { rawInputBuffer = realloc(rawInputBuffer, dwSize); } GetRawInputData((HRAWINPUT)lParam, RID_INPUT, rawInputBuffer, &dwSize, sizeof(RAWINPUTHEADER)); RAWINPUT *raw = (RAWINPUT *)rawInputBuffer; bool foreground = GET_RAWINPUT_CODE_WPARAM(wParam) == RIM_INPUT; switch (raw->header.dwType) { case RIM_TYPEKEYBOARD: ProcessKeyboard(raw, foreground); break; case RIM_TYPEMOUSE: ProcessMouse(raw, foreground); break; case RIM_TYPEHID: ProcessHID(raw, foreground); break; } // Docs say to call DefWindowProc to perform necessary cleanup. return DefWindowProc(hWnd, WM_INPUT, wParam, lParam); }
void Window::CheckMessages(MSG &msg) { switch (msg.message) { // Is There A Message Waiting? case (WM_QUIT): case (WM_CLOSE): { // Have We Received A Quit Message? forceQuit = true; }break; case (WM_INPUT): { UINT dwSize; GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize,sizeof(RAWINPUTHEADER)); BYTE* lpb = new BYTE[dwSize]; GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, lpb, &dwSize,sizeof(RAWINPUTHEADER)); RAWINPUT* raw = (RAWINPUT*)lpb; if (Keyboard::instance && raw->header.dwType == RIM_TYPEKEYBOARD) { Keyboard::instance->Update(raw); } else if (Mouse::instance && raw->header.dwType == RIM_TYPEMOUSE) { Mouse::instance->Update(raw); } delete lpb; }break; default: { // If Not, Deal With Window Messages TranslateMessage(&msg); // Translate The Message DispatchMessage(&msg); // Dispatch The Message } } }
void Window::CheckMessages(MSG &msg) { switch (msg.message) { case (WM_QUIT): case (WM_CLOSE): { forceQuit = true; }break; case (WM_INPUT): { UINT dwSize; GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize,sizeof(RAWINPUTHEADER)); BYTE* lpb = new BYTE[dwSize]; GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, lpb, &dwSize,sizeof(RAWINPUTHEADER)); RAWINPUT* raw = (RAWINPUT*)lpb; if (Keyboard::instance && raw->header.dwType == RIM_TYPEKEYBOARD) { Keyboard::instance->Update(raw); } else if (Mouse::instance && raw->header.dwType == RIM_TYPEMOUSE) { Mouse::instance->Update(raw); } delete lpb; }break; default: { TranslateMessage(&msg); DispatchMessage(&msg); } } }
LRESULT CALLBACK RawInputProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch(uMsg) { case WM_CREATE: if(eatenWnd == NULL) RegisterRaw(hWnd, 0); break; case WM_INPUT: { //if(skipInput) return; PRAWINPUT pRawInput; UINT bufferSize=0; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &bufferSize, sizeof(RAWINPUTHEADER)); pRawInput = (PRAWINPUT)malloc(bufferSize); if(!pRawInput) break; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, pRawInput, &bufferSize, sizeof(RAWINPUTHEADER)); ParseRawInput(pRawInput); free(pRawInput); break; } case WM_DESTROY: if(eatenWnd==NULL) RegisterRaw(hWnd, RIDEV_REMOVE); UninitWindow(); break; } if(eatenWndProc) return CallWindowProc(eatenWndProc, hWnd, uMsg, wParam, lParam); //else // return DefWindowProc(hWnd, uMsg, wParam, lParam); return 0; }
static LRESULT WINAPI window_message_handler(HWND window, UINT message, WPARAM wparam, LPARAM lparam) { switch (message) { case WM_INPUT: { if (wparam == RIM_INPUT) { HRAWINPUT raw_input_handle = (HRAWINPUT)(lparam); int raw_input_size; RAWINPUT *raw_input; int raw_input_device_name_size; char *raw_input_device_name; GetRawInputData(raw_input_handle, RID_INPUT, NULL, &raw_input_size, sizeof(RAWINPUTHEADER)); raw_input = (RAWINPUT *)(malloc(raw_input_size)); GetRawInputData(raw_input_handle, RID_INPUT, raw_input, &raw_input_size, sizeof(RAWINPUTHEADER)); GetRawInputDeviceInfo(raw_input->header.hDevice, RIDI_DEVICENAME, NULL, &raw_input_device_name_size); raw_input_device_name = malloc(raw_input_device_name_size); GetRawInputDeviceInfo(raw_input->header.hDevice, RIDI_DEVICENAME, raw_input_device_name, &raw_input_device_name_size); if (raw_input->header.dwType == RIM_TYPEKEYBOARD) { edit_control_printf("dev = %s, scancode = %d, vkey = %d, message = %d\r\n", raw_input_device_name, raw_input->data.keyboard.MakeCode, raw_input->data.keyboard.VKey, raw_input->data.keyboard.Message); } free(raw_input_device_name); free(raw_input); } return DefWindowProc(window, message, wparam, lparam); } case WM_SETFOCUS: { SetFocus(edit_control); return 0; } case WM_SIZE: { MoveWindow(edit_control, 0, 0, LOWORD(lparam), HIWORD(lparam), TRUE); return 0; } case WM_DESTROY: { PostQuitMessage(0); return 0; } default: { return DefWindowProc(window, message, wparam, lparam); } } }
/* * thanks to this article http://www.rohitab.com/discuss/topic/35415-c-getrawinputdata-keylogger/ */ LRESULT CALLBACK raw_input_device_handler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { UINT dwSize; RAWINPUTDEVICE ridMouse; RAWINPUT *buffer; switch(msg) { case WM_CREATE: // Register a raw input devices to capture input ridMouse.usUsagePage = 0x01; ridMouse.usUsage = 0x02; ridMouse.dwFlags = RIDEV_INPUTSINK; ridMouse.hwndTarget = hwnd; if(!RegisterRawInputDevices(&ridMouse, 1, sizeof(RAWINPUTDEVICE))) { LOG_FATAL("Registering mouse raw input device failed!"); return -1; } case WM_INPUT: // request size of the raw input buffer to dwSize GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); // allocate buffer for input data buffer = (RAWINPUT*)HeapAlloc(GetProcessHeap(), 0, dwSize); if(GetRawInputData((HRAWINPUT)lParam, RID_INPUT, buffer, &dwSize, sizeof(RAWINPUTHEADER))) { if (buffer->header.dwType == RIM_TYPEMOUSE) { is_input_blocked = do_handle_mouse( buffer->data.mouse.lLastX, buffer->data.mouse.lLastY, buffer->data.mouse.usButtonFlags, buffer->data.mouse.usButtonData); } } // free the buffer HeapFree(GetProcessHeap(), 0, buffer); break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hwnd, msg, wParam, lParam); } return 0; }
void WinInput::queWinInput(MSG* msg) { UINT dwSize; static int oldtime = 0; int curtime = OsUtil::milliseconds(); int msgtime = curtime - oldtime; oldtime = curtime; Printf("%d\n", msgtime); GetRawInputData((HRAWINPUT)msg->lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); LPBYTE lpb = new BYTE[dwSize]; if (lpb == NULL) { return; } if (GetRawInputData((HRAWINPUT)msg->lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize) OutputDebugString (TEXT("GetRawInputData doesn't return correct size !\n")); RAWINPUT* raw = (RAWINPUT*)lpb; if (raw->header.dwType == RIM_TYPEKEYBOARD) { RAWKEYBOARD& rk = raw->data.keyboard; Event e; TypeZero(&e); e.key = m_mapVkey[rk.VKey]; if (!e.key) { goto quit; } if (rk.Message == WM_KEYDOWN) { e.type = Event::KeyDown; } else if (rk.Message == WM_KEYUP) { e.type = Event::KeyUp; } else { Errorf("unknown key message"); } g_inputSystem->queEvent(e); } else if (raw->header.dwType == RIM_TYPEMOUSE) { RAWMOUSE& rm = raw->data.mouse; Printf("%x %x %d %d\n", rm.usFlags, rm.usButtonFlags, rm.lLastX, rm.lLastY); } quit: delete[] lpb; }
void GetInput::run() { input.mouse.x = 0; input.mouse.y = 0; input.keys_up.clear(); input.keys_down.clear(); MSG msg; while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); // this calls window procs! if (WM_INPUT == msg.message) { UINT size; GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER)); std::vector<byte> bytes(size); GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, bytes.data(), &size, sizeof(RAWINPUTHEADER)); RAWINPUT* raw = (RAWINPUT*)bytes.data(); if ( RIM_TYPEKEYBOARD == raw->header.dwType ) { RAWKEYBOARD* data = &raw->data.keyboard; bool up = data->Flags & RI_KEY_BREAK; (up ? input.keys_up : input.keys_down).insert(data->VKey); } else if ( RIM_TYPEMOUSE == raw->header.dwType ) { RAWMOUSE* data = &raw->data.mouse; input.mouse.x += data->lLastX; input.mouse.y += data->lLastY; } } } for(auto i = input.keys_down.begin(); i != input.keys_down.end(); i++) { input.keys_held.insert( (*i) ); } for(auto i = input.keys_up.begin(); i != input.keys_up.end(); i++) { input.keys_held.erase( (*i) ); } }
static LRESULT window_proc(HWND window_handle, UINT message, WPARAM wparam, LPARAM lparam) { WindowsWindow* window = (WindowsWindow*)GetWindowLongPtr(window_handle, GWLP_USERDATA); if (window == nullptr) return DefWindowProc(window_handle, message, wparam, lparam); WindowState* state = &window->state; switch(message) { case WM_QUIT: case WM_CLOSE: state->closed = true; return 0; case WM_KEYDOWN: if (state->key_pressed_callback != nullptr) { state->key_pressed_callback(key_from_windows_key_code(wparam, lparam)); } return 0; case WM_KEYUP: if (state->key_released_callback != nullptr) { state->key_released_callback(key_from_windows_key_code(wparam, lparam)); } return 0; case WM_INPUT: { unsigned size; GetRawInputData((HRAWINPUT)lparam, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER)); unsigned char* lpb = new unsigned char[size]; if (lpb == nullptr) return 0; if (GetRawInputData((HRAWINPUT)lparam, RID_INPUT, lpb, &size, sizeof(RAWINPUTHEADER)) != size) return 0; RAWINPUT* raw = (RAWINPUT*)lpb; if (raw->header.dwType == RIM_TYPEMOUSE && state->mouse_moved_callback && (raw->data.mouse.lLastX != 0 || raw->data.mouse.lLastY != 0)) state->mouse_moved_callback({raw->data.mouse.lLastX, raw->data.mouse.lLastY}); return 0; } } return DefWindowProc(window_handle, message, wparam, lparam); }
void WindowInputSource::handleRawInput(WPARAM wParam, LPARAM lParam) { // Only process input when the application is on the foreground. if (wParam != RIM_INPUT) return; RAWINPUT input; UINT szData = sizeof(input), szHeader = sizeof(RAWINPUTHEADER); HRAWINPUT handle = reinterpret_cast<HRAWINPUT>(lParam); UINT bytesWritten = GetRawInputData(handle, RID_INPUT, &input, &szData, szHeader); ASSERT(bytesWritten <= szData, "Unexpected return value from GetRawInputData."); ASSERT(bytesWritten != UINT(-1), "GetRawInputData returned error."); switch (input.header.dwType) { case RIM_TYPEMOUSE: mouseInput(input.data.mouse); break; case RIM_TYPEKEYBOARD: keyboardInput(input.data.keyboard); break; } }
LRESULT PushToTalkController::HandleInput(WPARAM wParam, LPARAM lParam) { RAWINPUT rawInput; UINT bufferSize = sizeof(rawInput); auto result = GetRawInputData((HRAWINPUT)lParam, RID_INPUT, &rawInput, &bufferSize, sizeof(RAWINPUTHEADER)); Assert(result == sizeof(RAWINPUTHEADER) + sizeof(RAWKEYBOARD)); if (rawInput.header.dwType == RIM_TYPEKEYBOARD && rawInput.data.keyboard.VKey == kPushToTalkKey) { if (rawInput.data.keyboard.Message == WM_KEYDOWN) { if (m_Muted) { m_DeviceDatabase.UnmuteAllDevices(); m_Muted = false; } } else if (rawInput.data.keyboard.Message == WM_KEYUP) { if (!m_Muted) { m_DeviceDatabase.MuteAllDevices(); m_Muted = true; } } return 0; } auto rawInputPtr = &rawInput; return DefRawInputProc(&rawInputPtr, 1, sizeof(RAWINPUTHEADER)); }
LPARAM dxfwFireKeyboardEvent(HWND hWnd, LPARAM lparam) { DXFW_UNUSED(hWnd); RAWINPUT ri; UINT size = sizeof(RAWINPUT); GetRawInputData((HRAWINPUT)lparam, RID_INPUT, &ri, &size, sizeof(RAWINPUTHEADER)); if (ri.header.dwType == RIM_TYPEKEYBOARD) { dxfwVirtualKeyCode key_code = dxfwGetKeyCode(ri.data.keyboard.VKey); dxfwVirtualKeyState state; if ((ri.data.keyboard.Flags & RI_KEY_BREAK) != 0) { // Key is UP dxfwRegisterKeyUp(key_code); state = DXFW_KEY_STATE_UP; } else { // Key is DOWN dxfwRegisterKeyDown(key_code); state = DXFW_KEY_STATE_DOWN; } dxfwVirtualKeyModifiers modifier_flags = dxfwGetModifierFlags(); dxfwVirtualKeyState previous_state = dxfwGetPreviousKeyState(key_code); HWND active_hwnd = GetActiveWindow(); struct dxfwWindow* window = dxfwFindWindow(active_hwnd); if (window != NULL && window->m_on_keyboard_) { (*window->m_on_keyboard_)(window, key_code, modifier_flags, state, previous_state); } return 0; // Return 0 to mark the event as handled } return 1; // Return 1 to mark the event as NOT handled }
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) { //fs_log("WndProc %d\n", message); HRAWINPUT raw_input_handle; switch (message) { case WM_INPUTLANGCHANGE: g_keyboard_layout = GetKeyboardLayout(0); break; case WM_INPUT: raw_input_handle = (HRAWINPUT) lparam; /* unsigned int size; if (GetRawInputData(raw_input_handle, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER)) != -1) { void *data = malloc(size); if (GetRawInputData(raw_input_handle, RID_INPUT, data, &size, sizeof(RAWINPUTHEADER)) != -1) { process_input(data); } free(data); } */ unsigned int size = RAW_INPUT_MAX_SIZE; if (GetRawInputData(raw_input_handle, RID_INPUT, &g_raw_input_data, &size, sizeof(RAWINPUTHEADER)) != -1) { process_input(&g_raw_input_data); } // must call DefWindowProc according to http://msdn.microsoft.com/ // en-us/library/windows/desktop/ms645590(v=vs.85).aspx return DefWindowProc(hwnd, message, wparam, lparam); } return CallWindowProc(g_wndproc, hwnd, message, wparam, lparam); }
void Input::OnInput(HRAWINPUT input) { RAWINPUT raw; UINT dataSize = sizeof raw; GetRawInputData(input, RID_INPUT, &raw, &dataSize, sizeof(RAWINPUTHEADER)); if(raw.header.dwType == RIM_TYPEMOUSE) { if(raw.data.mouse.usFlags == MOUSE_MOVE_RELATIVE) { mouseDelta[0] = raw.data.mouse.lLastX; mouseDelta[1] = raw.data.mouse.lLastY; } bool buttons[2]; USHORT buttonFlags = raw.data.mouse.usButtonFlags; buttons[0] = buttonFlags & (~RI_MOUSE_LEFT_BUTTON_UP | RI_MOUSE_LEFT_BUTTON_DOWN); buttons[1] = buttonFlags & (~RI_MOUSE_RIGHT_BUTTON_UP | RI_MOUSE_RIGHT_BUTTON_DOWN); } else if(raw.header.dwType == RIM_TYPEKEYBOARD) { switch(raw.data.keyboard.Message) { case WM_KEYUP: case WM_KEYDOWN: break; } } }
LRESULT __stdcall KeyboardHook::hookedWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { auto& console = GameConsole::Instance(); if ((console.showChat || console.showConsole) && message == WM_INPUT) { UINT uiSize = 40; // sizeof(RAWINPUT) static unsigned char lpb[40]; RAWINPUT* rwInput; if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &uiSize, sizeof(RAWINPUTHEADER)) != -1) { rwInput = (RAWINPUT*)lpb; if (rwInput->header.dwType == RIM_TYPEKEYBOARD && (rwInput->data.keyboard.Flags == RI_KEY_MAKE || rwInput->data.keyboard.Flags == RI_KEY_E0)) { console.virtualKeyCallBack(rwInput->data.keyboard.VKey); } else if (rwInput->header.dwType == RIM_TYPEMOUSE) { console.mouseCallBack(rwInput->data.mouse); } } } return CallWindowProc(realProc, hWnd, message, wParam, lParam); }
static LRESULT CALLBACK wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_INPUT: { RAWINPUT input; UINT size = sizeof(input); GetRawInputData((HRAWINPUT)lParam, RID_INPUT, &input, &size, sizeof(input.header)); PostMessage(hWnd, WM_USER + WMM_MOUSERAW, input.data.mouse.lLastX, input.data.mouse.lLastY); } break; case WM_KILLFOCUS: PostMessage(hWnd, WM_USER + WMM_FOCUS, false, 0); break; case WM_SETFOCUS: PostMessage(hWnd, WM_USER + WMM_FOCUS, true, 0); break; case WM_SYSCOMMAND: switch (wParam) { case SC_SCREENSAVE: case SC_MONITORPOWER: return 0; } break; case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_MBUTTONDOWN: SetCapture(hWnd); break; case WM_LBUTTONUP: case WM_RBUTTONUP: case WM_MBUTTONUP: ReleaseCapture(); break; case WM_SIZE: PostMessage(hWnd, WM_USER + WMM_RESIZE, LOWORD(lParam), HIWORD(lParam)); return 0; case WM_CLOSE: PostQuitMessage(0); return 1; case WM_PAINT: // Request redraw break; } return DefWindowProc(hWnd, message, wParam, lParam); }
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) { //fs_log("WndProc %d\n", message); //static HGLRC hRC; //rendering context //static HDC hDC; //device context HRAWINPUT raw_input_handle; switch (message) { case WM_CREATE: g_hdc = GetDC(hwnd); //get the device context for window if (g_hdc == NULL) { fs_log("could not get window dc\n"); } setup_pixel_format(g_hdc); g_hrc = wglCreateContext(g_hdc); //create rendering context if (g_hrc == NULL) { fs_log("could not create wgl context\n"); } //make rendering context current if (!wglMakeCurrent(g_hdc, g_hrc)) { fs_log("could not set current wgl context in main thread\n"); } break; case WM_DESTROY: wglMakeCurrent(g_hdc, NULL); //deselect rendering context wglDeleteContext(g_hrc); //delete rendering context PostQuitMessage(0); //send wm_quit break; case WM_ERASEBKGND: break; case WM_INPUT: raw_input_handle = (HRAWINPUT) lparam; /* unsigned int size; if (GetRawInputData(raw_input_handle, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER)) != -1) { void *data = malloc(size); if (GetRawInputData(raw_input_handle, RID_INPUT, data, &size, sizeof(RAWINPUTHEADER)) != -1) { process_input(data); } free(data); } */ unsigned int size = RAW_INPUT_MAX_SIZE; if (GetRawInputData(raw_input_handle, RID_INPUT, &g_raw_input_data, &size, sizeof(RAWINPUTHEADER)) != -1) { process_input(&g_raw_input_data); } // must call DefWindowProc according to http://msdn.microsoft.com/ // en-us/library/windows/desktop/ms645590(v=vs.85).aspx return DefWindowProc(hwnd, message, wparam, lparam); default: return DefWindowProc(hwnd, message, wparam, lparam); } return 0; }
void ProcessInputMessage(LPARAM lm) { UINT size = 0; GetRawInputData((HRAWINPUT)lm,RID_INPUT,NULL,&size,sizeof(RAWINPUTHEADER)); if (size == 0) { return; } LPBYTE lp = new BYTE[size]; GetRawInputData((HRAWINPUT)lm,RID_INPUT,lp,&size,sizeof(RAWINPUTHEADER)); RAWINPUT* raw = (RAWINPUT*)lp; DX11::GetInput()->AddInputMessage(raw); }
//------------------------------------------------------------------------------------ void CInput::ProcessInput(LPARAM lParam) { unsigned int Size = 40; unsigned char InputBuffer[40]; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, InputBuffer, &Size, sizeof(RAWINPUTHEADER)); for(IHIDInputBase* pInterface = m_pRegisteredInterfaces; pInterface != NULL; pInterface = pInterface->m_pNext) { pInterface->ProcessHIDInput(InputBuffer); } }
void HID::update( UINT message, LPARAM lParam ) { UINT dwSize; RAWINPUT* pRaw; switch (message) { case WM_INPUT: dwSize = 40; static BYTE lpb[40]; GetRawInputData( (HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER) ); pRaw = (RAWINPUT*)lpb; if (pRaw->header.dwType == RIM_TYPEMOUSE) { if ( m_mouse.click(pRaw, RI_MOUSE_LEFT_BUTTON_DOWN) ) { POINT t_point = m_mouse.getPosition(); XMFLOAT2 t_Vpoint; t_Vpoint.x = (float)t_point.x; t_Vpoint.y = (float)t_point.y; m_observable.broadcastLeftClick( t_Vpoint ); } if( m_mouse.click(pRaw, RI_MOUSE_RIGHT_BUTTON_DOWN) ) { POINT t_point = m_mouse.getPosition(); XMFLOAT2 t_Vpoint; t_Vpoint.x = (float)t_point.x; t_Vpoint.y = (float)t_point.y; m_observable.broadcastRightClick(t_Vpoint); } //POINT t_point = m_mouse.getPosition(); XMFLOAT2 t_Vpoint = m_mouse.mouseMove(pRaw);; /*t_Vpoint.x = (float)t_point.x; t_Vpoint.y = (float)t_point.y;*/ m_observable.broadcastMousePos(t_Vpoint); } if (pRaw->header.dwType == RIM_TYPEKEYBOARD) { if(pRaw->data.keyboard.Flags == 0) m_observable.broadcastKeyPress( m_keyboard.keyDown(pRaw) ); } break; default: break; } }
static LRESULT CALLBACK RawInputProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { MyWndProc(hWnd, uMsg, wParam, lParam); switch(uMsg) { case WM_CREATE: if (eatenWnd == nullptr) RegisterRaw(hWnd); break; case WM_INPUT: { //if(skipInput) return; PRAWINPUT pRawInput; UINT bufferSize=0; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &bufferSize, sizeof(RAWINPUTHEADER)); pRawInput = (PRAWINPUT)malloc(bufferSize); if(!pRawInput) break; if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, pRawInput, &bufferSize, sizeof(RAWINPUTHEADER)) > 0) { for (auto cb : callbacks) cb->ParseRawInput(pRawInput); } free(pRawInput); break; } case WM_ACTIVATE: OSDebugOut(TEXT("****** WM_ACTIVATE ******\n")); break; case WM_DESTROY: if (eatenWnd == nullptr) RegisterRaw(nullptr); Uninitialize(); break; } if(eatenWndProc) return CallWindowProc(eatenWndProc, hWnd, uMsg, wParam, lParam); //else // return DefWindowProc(hWnd, uMsg, wParam, lParam); return 0; }
void Input::mouseRawIn(LPARAM lParam) { UINT dwSize = 40; static BYTE lpb[40]; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)); RAWINPUT* raw = (RAWINPUT*)lpb; if (raw->header.dwType == RIM_TYPEMOUSE) { m_mouseRawX = raw->data.mouse.lLastX; m_mouseRawY = raw->data.mouse.lLastY; } }
int InputInterface::HandleRawInput(HRAWINPUT* pRawData){ if (pRawData == NULL){ return false; } UINT dwSize; GetRawInputData(*pRawData, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); BYTE lpb[4096] = { 0 };// = new BYTE[dwSize]; //if (lpb == NULL) //{ //return 0; //} int readSize = GetRawInputData((HRAWINPUT)*pRawData, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)); if (readSize != dwSize){ OutputDebugString(L"ERROR: GetRawInputData didn't return correct size!\n" ) ; return 0; } RAWINPUT* pRaw = (RAWINPUT*)lpb; if (pRaw->header.dwType == RIM_TYPEHID){ RID_DEVICE_INFO device_info = { 0 }; unsigned int SizeInBytes = sizeof(RID_DEVICE_INFO); m_DualShockMutex.Open(); for (unsigned int i = 0; i < 4; i++){ if (m_DualShock4Info[i].hDevice == pRaw->header.hDevice && m_DualShock4Info[i].Connected){ const int index = i; DualShock4State state = { 0 }; ProcessDS4(state, &pRaw->data.hid); break; } } m_DualShockMutex.Close(); } return true; }
LRESULT CALLBACK EjectKey::OnRawInput(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { // Determine size of raw input data UINT dwSize = 0; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); // Allocate enough room for input data and read it std::unique_ptr<BYTE[]> lpb(new BYTE[dwSize]); GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb.get(), &dwSize, sizeof(RAWINPUTHEADER)); // Get actual HID report RAWINPUT* rawinput = reinterpret_cast<RAWINPUT*>(lpb.get()); RAWHID* rawhid = &(rawinput)->data.hid; uint32_t* report = reinterpret_cast<uint32_t*>(rawhid->bRawData); if (rawhid->dwSizeHid == 4) { // We may receive more than one report from each VM_INPUT, loop through them for (unsigned int p = 0; p<rawhid->dwCount; p++) { // Eject down if (0x00200002 == *report) { SendKeyPress(&timer_param, false); SetTimer(hWnd, reinterpret_cast<UINT_PTR>(&timer_param), timer_param.delay, TimerProc); } // Eject up else if (0x00000002 == *report) { SendKeyPress(&timer_param, true); KillTimer(hWnd, reinterpret_cast<UINT_PTR>(&timer_param)); } report++; } } return DefWindowProc(hWnd, message, wParam, lParam); }