ckLua/InputListener.cpp at master · Jeflux/ckLua · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#include "InputListener.h"

#include <string>

#include <Windows.h>
#include <iostream>
#pragma comment(lib,"user32.lib")

HHOOK _hook = NULL;

void(*keyDownCallback)(int, int);
void(*keyUpCallback)(int, int);

// Not used anymore. Keeping for reference (used by low level hook)
/*LRESULT CALLBACK hookCallback(int nCode, WPARAM wParam, LPARAM lParam) {
	KBDLLHOOKSTRUCT *kbdStruct = (KBDLLHOOKSTRUCT*)lParam;

	// Check which kind of event was received
	switch (wParam) {
		case WM_KEYDOWN:
		case WM_SYSKEYDOWN:
			if (keyDownCallback != NULL)
				keyDownCallback(kbdStruct->vkCode, kbdStruct->flags);
			break;
		case WM_KEYUP:
		case WM_SYSKEYUP:
			if (keyUpCallback != NULL)
				keyUpCallback(kbdStruct->vkCode, kbdStruct->flags);
			break;
	}

	return  CallNextHookEx(_hook, nCode, wParam, lParam);
}*/

InputListener::InputListener(void(*keyDown)(int, int), void(*keyUp)(int, int)) :
	hooked(false){
	keyDownCallback = keyDown;
	keyUpCallback = keyUp;

	for (int i = 0; i < sizeof(keyPressed); i++)
		keyPressed[i] = false;
	int a = 0;
}

InputListener::~InputListener() {
	unhook();
}

void InputListener::hook() {
	if (hooked) return;
	hooked = true;
	//_hook = SetWindowsHookEx(WH_KEYBOARD_LL, hookCallback, NULL, NULL); // Keeping for reference
}

void InputListener::unhook() {
	if (!hooked) return;
	hooked = false;

	//UnhookWindowsHookEx(_hook); // Keeping for reference

	keyDownCallback = NULL;
	keyUpCallback = NULL;
}

// Magic message interception here!
void InputListener::interceptMessage(MSG& msg) {
	// Check which type of message
	switch (msg.message) {
	case WM_INPUT:
		UINT dwSize;

		// Try to get raw data
		GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize,
			sizeof(RAWINPUTHEADER));
		LPBYTE lpb = new BYTE[dwSize];
		if (lpb == NULL) {
			break;
		}

		if (GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize)
			OutputDebugString(TEXT("GetRawInputData does not return correct size !\n"));

		// Raw data here
		RAWINPUT* raw = (RAWINPUT*)lpb;

		// Try to get device name. We only want to listen to corsair keyboards
		UINT nBufferSize;
		bool del = false;
		WCHAR* wcDeviceName = L"\\\\?\\HID#Vid_1B1C&Pid_1B13&MI_01"; // Assume it's good if we can't get it
		if (GetRawInputDeviceInfo(raw->header.hDevice, RIDI_DEVICENAME, NULL, &nBufferSize) == 0) {
			del = true;
			wcDeviceName = new WCHAR[nBufferSize + 1];
			GetRawInputDeviceInfo(raw->header.hDevice, RIDI_DEVICENAME, wcDeviceName, &nBufferSize);
		}

		// Map virtual keys to scan codes
		int key = MapVirtualKey(raw->data.keyboard.VKey, 0);

		// If we have any flags describing if key is right version, use "the other side of the spectrum"
		if (((raw->data.keyboard.Flags & 0x6) >> 1) == 1) {
			key = 0xFC - key;
		}
		// Null key
		if (key == 0xFC)
			key = 0xFF;

		// Pause break is exception here
		if (key == 0x00 && ((raw->data.keyboard.Flags & 0x6) >> 1) == 2) {
			key = 0xFE;
		}
		// Special case for right shift (must check make code)
		else if (key == 0x2A && raw->data.keyboard.MakeCode == 0x36)
			key = 0xFC;

		// Convert to upper case
		int i = 0;
		wchar_t c;
		while (wcDeviceName[i]) {
			c = wcDeviceName[i];
			putwchar(towupper(c));
			i++;
		}

		// Check if corsair keyboard and keys are valid
		if (std::wcsncmp(wcDeviceName, L"\\\\?\\HID#VID_1B1C&PID_1B13&MI_01", 31) == 0 && key != 0x00 && key != 0xFF) {

			// Key down. Call function if key is pressed and not held
			if (!(raw->data.keyboard.Flags & RI_KEY_BREAK) && !keyPressed[key]) {
				keyDownCallback(key, raw->data.keyboard.Flags);
				keyPressed[key] = true;
			}

			// Key up
			else if ((raw->data.keyboard.Flags & RI_KEY_BREAK)) {
				keyUpCallback(key, raw->data.keyboard.Flags);
				keyPressed[key] = false;
			}

		}

		// Clean up
		if (del)
			delete[] wcDeviceName;

		break;
	}
}