Example #1
0
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;
}
Example #2
0
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);
	}
}
Example #3
0
	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);
		} 
	}
Example #4
0
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;
}
Example #5
0
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;
}
Example #6
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;
}
Example #7
0
	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);
	}
Example #8
0
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
		}
	}
}
Example #9
0
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);				
		}
	}
}
Example #10
0
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);
		}
	}
}
Example #12
0
/*
 * 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;
}
Example #13
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; 
	}
Example #14
0
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) );
	}
}
Example #15
0
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));
}
Example #18
0
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
}
Example #19
0
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);
}
Example #20
0
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;
		}
	}
}
Example #21
0
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);
}
Example #22
0
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);
}
Example #23
0
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;
}
Example #24
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);
}
Example #25
0
//------------------------------------------------------------------------------------
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);
	}	
}
Example #26
0
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;
	}
}
Example #27
0
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;
}
Example #28
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;
}
Example #30
0
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);
}