Remove unnecessary Src/ folders

6 files changed, 930 insertions, 0 deletions

diff --git a/Source/Core/InputCommon/ControllerInterface/OSX/OSX.h b/Source/Core/InputCommon/ControllerInterface/OSX/OSX.h
new file mode 100644
index 0000000000..a922e3f2dd
--- /dev/null
+++ b/Source/Core/InputCommon/ControllerInterface/OSX/OSX.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../Device.h"
+
+namespace ciface
+{
+namespace OSX
+{
+
+void Init(std::vector<Core::Device*>& devices, void *window);
+void DeInit();
+
+void DeviceElementDebugPrint(const void *, void *);
+
+}
+}
diff --git a/Source/Core/InputCommon/ControllerInterface/OSX/OSX.mm b/Source/Core/InputCommon/ControllerInterface/OSX/OSX.mm
new file mode 100644
index 0000000000..8a859f46c8
--- /dev/null
+++ b/Source/Core/InputCommon/ControllerInterface/OSX/OSX.mm
@@ -0,0 +1,213 @@
+#include <Foundation/Foundation.h>
+#include <IOKit/hid/IOHIDLib.h>
+#include <Cocoa/Cocoa.h>
+
+#include "OSX.h"
+#include "OSXKeyboard.h"
+#include "OSXJoystick.h"
+
+#include <map>
+
+namespace ciface
+{
+namespace OSX
+{
+
+
+static IOHIDManagerRef HIDManager = NULL;
+static CFStringRef OurRunLoop = CFSTR("DolphinOSXInput");
+static std::map<std::string, int> kbd_name_counts, joy_name_counts;
+
+void DeviceElementDebugPrint(const void *value, void *context)
+{
+	IOHIDElementRef e = (IOHIDElementRef)value;
+	bool recurse = false;
+	if (context)
+		recurse = *(bool*)context;
+
+	std::string type = "";
+	switch (IOHIDElementGetType(e)) {
+	case kIOHIDElementTypeInput_Axis:
+		type = "axis";
+		break;
+	case kIOHIDElementTypeInput_Button:
+		type = "button";
+		break;
+	case kIOHIDElementTypeInput_Misc:
+		type = "misc";
+		break;
+	case kIOHIDElementTypeInput_ScanCodes:
+		type = "scancodes";
+		break;
+	case kIOHIDElementTypeOutput:
+		type = "output";
+		break;
+	case kIOHIDElementTypeFeature:
+		type = "feature";
+		break;
+	case kIOHIDElementTypeCollection:
+		type = "collection";
+		break;
+	}
+
+	std::string c_type = "";
+	if (type == "collection")
+	{
+		switch (IOHIDElementGetCollectionType(e)) {
+		case kIOHIDElementCollectionTypePhysical:
+			c_type = "physical";
+			break;
+		case kIOHIDElementCollectionTypeApplication:
+			c_type = "application";
+			break;
+		case kIOHIDElementCollectionTypeLogical:
+			c_type = "logical";
+			break;
+		case kIOHIDElementCollectionTypeReport:
+			c_type = "report";
+			break;
+		case kIOHIDElementCollectionTypeNamedArray:
+			c_type = "namedArray";
+			break;
+		case kIOHIDElementCollectionTypeUsageSwitch:
+			c_type = "usageSwitch";
+			break;
+		case kIOHIDElementCollectionTypeUsageModifier:
+			c_type = "usageModifier";
+			break;
+		}
+	}
+
+	c_type.append(" ");
+	NSLog(@"%s%s%spage: 0x%x usage: 0x%x name: %@ "
+		"lmin: %ld lmax: %ld pmin: %ld pmax: %ld",
+		  type.c_str(),
+		  type == "collection" ? ":" : "",
+		  type == "collection" ? c_type.c_str() : " ",
+		  IOHIDElementGetUsagePage(e),
+		  IOHIDElementGetUsage(e),
+		  IOHIDElementGetName(e),		// usually just NULL
+		  IOHIDElementGetLogicalMin(e),
+		  IOHIDElementGetLogicalMax(e),
+		  IOHIDElementGetPhysicalMin(e),
+		  IOHIDElementGetPhysicalMax(e));
+
+	if ((type == "collection") && recurse)
+	{
+		CFArrayRef elements = IOHIDElementGetChildren(e);
+		CFRange range = {0, CFArrayGetCount(elements)};
+		// this leaks...but it's just debug code, right? :D
+		CFArrayApplyFunction(elements, range,
+			DeviceElementDebugPrint, NULL);
+	}
+}
+
+void DeviceDebugPrint(IOHIDDeviceRef device)
+{
+#if 0
+#define shortlog(x) NSLog(@"%s: %@", \
+		x, IOHIDDeviceGetProperty(device, CFSTR(x)));
+	NSLog(@"-------------------------");
+	NSLog(@"Got Device: %@",
+		IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey)));
+	shortlog(kIOHIDTransportKey)
+	shortlog(kIOHIDVendorIDKey)
+	shortlog(kIOHIDVendorIDSourceKey)
+	shortlog(kIOHIDProductIDKey)
+	shortlog(kIOHIDVersionNumberKey)
+	shortlog(kIOHIDManufacturerKey)
+	shortlog(kIOHIDProductKey)
+	shortlog(kIOHIDSerialNumberKey)
+	shortlog(kIOHIDCountryCodeKey)
+	shortlog(kIOHIDLocationIDKey)
+	shortlog(kIOHIDDeviceUsageKey)
+	shortlog(kIOHIDDeviceUsagePageKey)
+	shortlog(kIOHIDDeviceUsagePairsKey)
+	shortlog(kIOHIDPrimaryUsageKey)
+	shortlog(kIOHIDPrimaryUsagePageKey)
+	shortlog(kIOHIDMaxInputReportSizeKey)
+	shortlog(kIOHIDMaxOutputReportSizeKey)
+	shortlog(kIOHIDMaxFeatureReportSizeKey)
+	shortlog(kIOHIDReportIntervalKey)
+	shortlog(kIOHIDReportDescriptorKey)
+#endif
+}
+
+static void *g_window;
+
+static void DeviceMatching_callback(void* inContext,
+	IOReturn inResult,
+	void *inSender,
+	IOHIDDeviceRef inIOHIDDeviceRef)
+{
+	NSString *pName = (NSString *)
+		IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDProductKey));
+	std::string name = (pName != NULL) ? [pName UTF8String] : "Unknown device";
+
+	DeviceDebugPrint(inIOHIDDeviceRef);
+
+	std::vector<Core::Device*> *devices =
+		(std::vector<Core::Device*> *)inContext;
+
+	// Add to the devices vector if it's of a type we want
+	if (IOHIDDeviceConformsTo(inIOHIDDeviceRef,
+		kHIDPage_GenericDesktop, kHIDUsage_GD_Keyboard))
+		devices->push_back(new Keyboard(inIOHIDDeviceRef,
+			name, kbd_name_counts[name]++, g_window));
+#if 0
+	else if (IOHIDDeviceConformsTo(inIOHIDDeviceRef,
+		kHIDPage_GenericDesktop, kHIDUsage_GD_Mouse))
+		devices->push_back(new Mouse(inIOHIDDeviceRef,
+			name, mouse_name_counts[name]++));
+#endif
+	else 
+		devices->push_back(new Joystick(inIOHIDDeviceRef,
+			name, joy_name_counts[name]++));
+}
+
+void Init(std::vector<Core::Device*>& devices, void *window)
+{
+	HIDManager = IOHIDManagerCreate(kCFAllocatorDefault,
+		kIOHIDOptionsTypeNone);
+	if (!HIDManager)
+		NSLog(@"Failed to create HID Manager reference");
+
+	g_window = window;
+
+	IOHIDManagerSetDeviceMatching(HIDManager, NULL);
+
+	// Callbacks for acquisition or loss of a matching device
+	IOHIDManagerRegisterDeviceMatchingCallback(HIDManager,
+		DeviceMatching_callback, (void *)&devices);
+
+	// Match devices that are plugged in right now
+	IOHIDManagerScheduleWithRunLoop(HIDManager,
+		CFRunLoopGetCurrent(), OurRunLoop);
+	if (IOHIDManagerOpen(HIDManager, kIOHIDOptionsTypeNone) !=
+		kIOReturnSuccess)
+		NSLog(@"Failed to open HID Manager");
+
+	kbd_name_counts.clear();
+	joy_name_counts.clear();
+
+	// Wait while current devices are initialized
+	while (CFRunLoopRunInMode(OurRunLoop, 0, TRUE) ==
+		kCFRunLoopRunHandledSource) {};
+
+	// Things should be configured now
+	// Disable hotplugging and other scheduling
+	IOHIDManagerRegisterDeviceMatchingCallback(HIDManager, NULL, NULL);
+	IOHIDManagerUnscheduleFromRunLoop(HIDManager,
+		CFRunLoopGetCurrent(), OurRunLoop);
+}
+
+void DeInit()
+{
+	// This closes all devices as well
+	IOHIDManagerClose(HIDManager, kIOHIDOptionsTypeNone);
+	CFRelease(HIDManager);
+}
+
+
+}
+}
diff --git a/Source/Core/InputCommon/ControllerInterface/OSX/OSXJoystick.h b/Source/Core/InputCommon/ControllerInterface/OSX/OSXJoystick.h
new file mode 100644
index 0000000000..ebe908522b
--- /dev/null
+++ b/Source/Core/InputCommon/ControllerInterface/OSX/OSXJoystick.h
@@ -0,0 +1,80 @@
+#include <IOKit/hid/IOHIDLib.h>
+
+#include "../Device.h"
+
+namespace ciface
+{
+namespace OSX
+{
+
+class Joystick : public Core::Device
+{
+private:
+	class Button : public Input
+	{
+	public:
+		std::string GetName() const;
+		Button(IOHIDElementRef element, IOHIDDeviceRef device)
+			: m_element(element), m_device(device) {}
+		ControlState GetState() const;
+	private:
+		const IOHIDElementRef	m_element;
+		const IOHIDDeviceRef m_device;
+	};
+
+	class Axis : public Input
+	{
+	public:
+		enum direction {
+			positive = 0,
+			negative
+		};
+		std::string GetName() const;
+		Axis(IOHIDElementRef element, IOHIDDeviceRef device, direction dir);
+		ControlState GetState() const;
+	private:
+		const IOHIDElementRef	m_element;
+		const IOHIDDeviceRef m_device;
+		std::string		m_name;
+		const direction		m_direction;
+		float			m_neutral;
+		float			m_scale;
+	};
+
+	class Hat : public Input
+	{
+	public:
+		enum direction {
+			up = 0,
+			right,
+			down,
+			left
+		};
+		std::string GetName() const;
+		Hat(IOHIDElementRef element, IOHIDDeviceRef device, direction dir);
+		ControlState GetState() const;
+	private:
+		const IOHIDElementRef	m_element;
+		const IOHIDDeviceRef m_device;
+		const char*		m_name;
+		const direction		m_direction;
+	};
+
+public:
+	bool UpdateInput();
+	bool UpdateOutput();
+
+	Joystick(IOHIDDeviceRef device, std::string name, int index);
+
+	std::string GetName() const;
+	std::string GetSource() const;
+	int GetId() const;
+
+private:
+	const IOHIDDeviceRef	m_device;
+	const std::string	m_device_name;
+	const int	m_index;
+};
+
+}
+}
diff --git a/Source/Core/InputCommon/ControllerInterface/OSX/OSXJoystick.mm b/Source/Core/InputCommon/ControllerInterface/OSX/OSXJoystick.mm
new file mode 100644
index 0000000000..ebd713d142
--- /dev/null
+++ b/Source/Core/InputCommon/ControllerInterface/OSX/OSXJoystick.mm
@@ -0,0 +1,274 @@
+#include <Foundation/Foundation.h>
+#include <IOKit/hid/IOHIDLib.h>
+
+#include "OSXJoystick.h"
+
+#include <sstream>
+
+namespace ciface
+{
+namespace OSX
+{
+
+
+Joystick::Joystick(IOHIDDeviceRef device, std::string name, int index)
+	: m_device(device)
+	, m_device_name(name)
+	, m_index(index)
+{
+	// Buttons
+	NSDictionary *buttonDict =
+	 [NSDictionary dictionaryWithObjectsAndKeys:
+	  [NSNumber numberWithInteger: kIOHIDElementTypeInput_Button],
+		@kIOHIDElementTypeKey,
+	  [NSNumber numberWithInteger: kHIDPage_Button],
+		@kIOHIDElementUsagePageKey,
+	  nil];
+
+	CFArrayRef buttons = IOHIDDeviceCopyMatchingElements(m_device,
+		(CFDictionaryRef)buttonDict, kIOHIDOptionsTypeNone);
+
+	if (buttons)
+	{
+		for (int i = 0; i < CFArrayGetCount(buttons); i++)
+		{
+			IOHIDElementRef e =
+			(IOHIDElementRef)CFArrayGetValueAtIndex(buttons, i);
+			//DeviceElementDebugPrint(e, NULL);
+
+			AddInput(new Button(e, m_device));
+		}
+		CFRelease(buttons);
+	}
+
+	// Axes
+	NSDictionary *axisDict =
+	[NSDictionary dictionaryWithObjectsAndKeys:
+	 [NSNumber numberWithInteger: kIOHIDElementTypeInput_Misc],
+		@kIOHIDElementTypeKey,
+	 nil];
+
+	CFArrayRef axes = IOHIDDeviceCopyMatchingElements(m_device,
+		(CFDictionaryRef)axisDict, kIOHIDOptionsTypeNone);
+
+	if (axes)
+	{
+		for (int i = 0; i < CFArrayGetCount(axes); i++)
+		{
+			IOHIDElementRef e =
+			(IOHIDElementRef)CFArrayGetValueAtIndex(axes, i);
+			//DeviceElementDebugPrint(e, NULL);
+
+			if (IOHIDElementGetUsage(e) == kHIDUsage_GD_Hatswitch) {
+				AddInput(new Hat(e, m_device, Hat::up));
+				AddInput(new Hat(e, m_device, Hat::right));
+				AddInput(new Hat(e, m_device, Hat::down));
+				AddInput(new Hat(e, m_device, Hat::left));
+			} else {
+				AddAnalogInputs(new Axis(e, m_device, Axis::negative),
+					new Axis(e, m_device, Axis::positive));
+			}
+		}
+		CFRelease(axes);
+	}
+}
+
+bool Joystick::UpdateInput()
+{
+	return true;
+}
+
+bool Joystick::UpdateOutput()
+{
+	return true;
+}
+
+std::string Joystick::GetName() const
+{
+	return m_device_name;
+}
+
+std::string Joystick::GetSource() const
+{
+	return "Input";
+}
+
+int Joystick::GetId() const
+{
+	return m_index;
+}
+
+ControlState Joystick::Button::GetState() const
+{
+	IOHIDValueRef value;
+	if (IOHIDDeviceGetValue(m_device, m_element, &value) == kIOReturnSuccess)
+		return IOHIDValueGetIntegerValue(value);
+	else
+		return 0;
+}
+
+std::string Joystick::Button::GetName() const
+{
+	std::ostringstream s;
+	s << IOHIDElementGetUsage(m_element);
+	return std::string("Button ") + s.str();
+}
+
+Joystick::Axis::Axis(IOHIDElementRef element, IOHIDDeviceRef device, direction dir)
+	: m_element(element)
+	, m_device(device)
+	, m_direction(dir)
+{
+	// Need to parse the element a bit first
+	std::string description("unk");
+
+	int const usage = IOHIDElementGetUsage(m_element);
+	switch (usage)
+	{
+	case kHIDUsage_GD_X:
+		description = "X";
+		break;
+	case kHIDUsage_GD_Y:
+		description = "Y";
+		break;
+	case kHIDUsage_GD_Z:
+		description = "Z";
+		break;
+	case kHIDUsage_GD_Rx:
+		description = "Rx";
+		break;
+	case kHIDUsage_GD_Ry:
+		description = "Ry";
+		break;
+	case kHIDUsage_GD_Rz:
+		description = "Rz";
+		break;
+	case kHIDUsage_GD_Wheel:
+		description = "Wheel";
+		break;
+	case kHIDUsage_Csmr_ACPan:
+		description = "Pan";
+		break;
+	default:
+	{
+		std::ostringstream s;
+		s << usage;
+		description = s.str();
+		break;
+	}
+	}
+
+	m_name = std::string("Axis ") + description;
+	m_name.append((m_direction == positive) ? "+" : "-");
+
+	m_neutral = (IOHIDElementGetLogicalMax(m_element) +
+		IOHIDElementGetLogicalMin(m_element)) / 2.;
+	m_scale = 1 / fabs(IOHIDElementGetLogicalMax(m_element) - m_neutral);
+}
+
+ControlState Joystick::Axis::GetState() const
+{
+	IOHIDValueRef value;
+
+	if (IOHIDDeviceGetValue(m_device, m_element, &value) == kIOReturnSuccess)
+	{
+		// IOHIDValueGetIntegerValue() crashes when trying
+		// to convert unusually large element values.
+		if (IOHIDValueGetLength(value) > 2)
+			return 0;
+
+		float position = IOHIDValueGetIntegerValue(value);
+
+		if (m_direction == positive && position > m_neutral)
+			return (position - m_neutral) * m_scale;
+		if (m_direction == negative && position < m_neutral)
+			return (m_neutral - position) * m_scale;
+	}
+
+	return 0;
+}
+
+std::string Joystick::Axis::GetName() const
+{
+	return m_name;
+}
+
+Joystick::Hat::Hat(IOHIDElementRef element, IOHIDDeviceRef device, direction dir)
+	: m_element(element)
+	, m_device(device)
+	, m_direction(dir)
+{
+	switch (dir) {
+	case up:
+		m_name = "Up";
+		break;
+	case right:
+		m_name = "Right";
+		break;
+	case down:
+		m_name = "Down";
+		break;
+	case left:
+		m_name = "Left";
+		break;
+	default:
+		m_name = "unk";
+	}
+}
+
+ControlState Joystick::Hat::GetState() const
+{
+	IOHIDValueRef value;
+	int position;
+
+	if (IOHIDDeviceGetValue(m_device, m_element, &value) == kIOReturnSuccess)
+	{
+		position = IOHIDValueGetIntegerValue(value);
+
+		switch (position) {
+		case 0:
+			if (m_direction == up)
+				return 1;
+			break;
+		case 1:
+			if (m_direction == up || m_direction == right)
+				return 1;
+			break;
+		case 2:
+			if (m_direction == right)
+				return 1;
+			break;
+		case 3:
+			if (m_direction == right || m_direction == down)
+				return 1;
+			break;
+		case 4:
+			if (m_direction == down)
+				return 1;
+			break;
+		case 5:
+			if (m_direction == down || m_direction == left)
+				return 1;
+			break;
+		case 6:
+			if (m_direction == left)
+				return 1;
+			break;
+		case 7:
+			if (m_direction == left || m_direction == up)
+				return 1;
+			break;
+		};
+	}
+
+	return 0;
+}
+
+std::string Joystick::Hat::GetName() const
+{
+	return m_name;
+}
+
+
+}
+}
diff --git a/Source/Core/InputCommon/ControllerInterface/OSX/OSXKeyboard.h b/Source/Core/InputCommon/ControllerInterface/OSX/OSXKeyboard.h
new file mode 100644
index 0000000000..e5c2c1b3d4
--- /dev/null
+++ b/Source/Core/InputCommon/ControllerInterface/OSX/OSXKeyboard.h
@@ -0,0 +1,71 @@
+#include <IOKit/hid/IOHIDLib.h>
+
+#include "../Device.h"
+
+namespace ciface
+{
+namespace OSX
+{
+
+class Keyboard : public Core::Device
+{
+private:
+	class Key : public Input
+	{
+	public:
+		std::string GetName() const;
+		Key(IOHIDElementRef element, IOHIDDeviceRef device);
+		ControlState GetState() const;
+	private:
+		const IOHIDElementRef	m_element;
+		const IOHIDDeviceRef	m_device;
+		std::string		m_name;
+	};
+	class Cursor : public Input
+	{
+	public:
+		std::string GetName() const;
+		bool IsDetectable() { return false; }
+		Cursor(u8 index, const float& axis, const bool positive) : m_axis(axis), m_index(index), m_positive(positive) {}
+		ControlState GetState() const;
+	private:
+		const float& m_axis;
+		const u8 m_index;
+		const bool m_positive;
+	};
+	class Button : public Input
+	{
+	public:
+		std::string GetName() const;
+		Button(u8 index, const unsigned char& button) : m_button(button), m_index(index) {}
+		ControlState GetState() const;
+	private:
+		const unsigned char& m_button;
+		const u8 m_index;
+	};
+
+public:
+	bool UpdateInput();
+	bool UpdateOutput();
+
+	Keyboard(IOHIDDeviceRef device, std::string name, int index, void *window);
+
+	std::string GetName() const;
+	std::string GetSource() const;
+	int GetId() const;
+
+private:
+	struct
+	{
+		float x, y;
+	} m_cursor;
+
+	const IOHIDDeviceRef	m_device;
+	const std::string	m_device_name;
+	int		m_index;
+	uint32_t m_windowid;
+	unsigned char m_mousebuttons[3];
+};
+
+}
+}
diff --git a/Source/Core/InputCommon/ControllerInterface/OSX/OSXKeyboard.mm b/Source/Core/InputCommon/ControllerInterface/OSX/OSXKeyboard.mm
new file mode 100644
index 0000000000..93de15daa4
--- /dev/null
+++ b/Source/Core/InputCommon/ControllerInterface/OSX/OSXKeyboard.mm
@@ -0,0 +1,276 @@
+#include <Foundation/Foundation.h>
+#include <IOKit/hid/IOHIDLib.h>
+#include <Cocoa/Cocoa.h>
+#include <wx/wx.h> // wxWidgets
+
+#include "OSXKeyboard.h"
+
+#include <sstream>
+
+namespace ciface
+{
+namespace OSX
+{
+
+Keyboard::Keyboard(IOHIDDeviceRef device, std::string name, int index, void *window)
+	: m_device(device)
+	, m_device_name(name)
+	, m_index(index)
+{
+	// This class should only recieve Keyboard or Keypad devices
+	// Now, filter on just the buttons we can handle sanely
+	NSDictionary *matchingElements =
+	 [NSDictionary dictionaryWithObjectsAndKeys:
+	  [NSNumber numberWithInteger: kIOHIDElementTypeInput_Button],
+		@kIOHIDElementTypeKey,
+	  [NSNumber numberWithInteger: 0], @kIOHIDElementMinKey,
+	  [NSNumber numberWithInteger: 1], @kIOHIDElementMaxKey,
+	  nil];
+
+	CFArrayRef elements = IOHIDDeviceCopyMatchingElements(m_device,
+		(CFDictionaryRef)matchingElements, kIOHIDOptionsTypeNone);
+
+	if (elements)
+	{
+		for (int i = 0; i < CFArrayGetCount(elements); i++)
+		{
+			IOHIDElementRef e =
+			(IOHIDElementRef)CFArrayGetValueAtIndex(elements, i);
+			//DeviceElementDebugPrint(e, NULL);
+
+			AddInput(new Key(e, m_device));
+		}
+		CFRelease(elements);
+	}
+
+	m_windowid = [[(NSView *)(((wxWindow *)window)->GetHandle()) window] windowNumber];
+
+	// cursor, with a hax for-loop
+	for (unsigned int i=0; i<4; ++i)
+		AddInput(new Cursor(!!(i&2), (&m_cursor.x)[i/2], !!(i&1)));
+
+	for (u8 i = 0; i < sizeof(m_mousebuttons) / sizeof(m_mousebuttons[0]); ++i)
+		AddInput(new Button(i, m_mousebuttons[i]));
+}
+
+bool Keyboard::UpdateInput()
+{
+	CGRect bounds = CGRectZero;
+	uint32_t windowid[1] = { m_windowid };
+	CFArrayRef windowArray = CFArrayCreate(NULL, (const void **) windowid, 1, NULL);
+	CFArrayRef windowDescriptions = CGWindowListCreateDescriptionFromArray(windowArray);
+	CFDictionaryRef windowDescription = (CFDictionaryRef) CFArrayGetValueAtIndex((CFArrayRef) windowDescriptions, 0);
+
+	if (CFDictionaryContainsKey(windowDescription, kCGWindowBounds))
+	{
+		CFDictionaryRef boundsDictionary = (CFDictionaryRef) CFDictionaryGetValue(windowDescription, kCGWindowBounds);
+
+		if (boundsDictionary != NULL)
+			CGRectMakeWithDictionaryRepresentation(boundsDictionary, &bounds);
+	}
+
+	CFRelease(windowDescriptions);
+	CFRelease(windowArray);
+
+	CGEventRef event = CGEventCreate(nil);
+	CGPoint loc = CGEventGetLocation(event);
+	CFRelease(event);
+
+	loc.x -= bounds.origin.x;
+	loc.y -= bounds.origin.y;
+	m_cursor.x = loc.x / bounds.size.width * 2 - 1.0;
+	m_cursor.y = loc.y / bounds.size.height * 2 - 1.0;
+
+	m_mousebuttons[0] = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonLeft);
+	m_mousebuttons[1] = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonRight);
+	m_mousebuttons[2] = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonCenter);
+
+	return true;
+}
+
+bool Keyboard::UpdateOutput()
+{
+	return true;
+}
+
+std::string Keyboard::GetName() const
+{
+	return m_device_name;
+}
+
+std::string Keyboard::GetSource() const
+{
+	return "Keyboard";
+}
+
+int Keyboard::GetId() const
+{
+	return m_index;
+}
+
+Keyboard::Key::Key(IOHIDElementRef element, IOHIDDeviceRef device)
+	: m_element(element)
+	, m_device(device)
+{
+	static const struct PrettyKeys {
+		const uint32_t		code;
+		const char *const	name;
+	} named_keys[] = {
+		{ kHIDUsage_KeyboardA, "A" },
+		{ kHIDUsage_KeyboardB, "B" },
+		{ kHIDUsage_KeyboardC, "C" },
+		{ kHIDUsage_KeyboardD, "D" },
+		{ kHIDUsage_KeyboardE, "E" },
+		{ kHIDUsage_KeyboardF, "F" },
+		{ kHIDUsage_KeyboardG, "G" },
+		{ kHIDUsage_KeyboardH, "H" },
+		{ kHIDUsage_KeyboardI, "I" },
+		{ kHIDUsage_KeyboardJ, "J" },
+		{ kHIDUsage_KeyboardK, "K" },
+		{ kHIDUsage_KeyboardL, "L" },
+		{ kHIDUsage_KeyboardM, "M" },
+		{ kHIDUsage_KeyboardN, "N" },
+		{ kHIDUsage_KeyboardO, "O" },
+		{ kHIDUsage_KeyboardP, "P" },
+		{ kHIDUsage_KeyboardQ, "Q" },
+		{ kHIDUsage_KeyboardR, "R" },
+		{ kHIDUsage_KeyboardS, "S" },
+		{ kHIDUsage_KeyboardT, "T" },
+		{ kHIDUsage_KeyboardU, "U" },
+		{ kHIDUsage_KeyboardV, "V" },
+		{ kHIDUsage_KeyboardW, "W" },
+		{ kHIDUsage_KeyboardX, "X" },
+		{ kHIDUsage_KeyboardY, "Y" },
+		{ kHIDUsage_KeyboardZ, "Z" },
+		{ kHIDUsage_Keyboard1, "1" },
+		{ kHIDUsage_Keyboard2, "2" },
+		{ kHIDUsage_Keyboard3, "3" },
+		{ kHIDUsage_Keyboard4, "4" },
+		{ kHIDUsage_Keyboard5, "5" },
+		{ kHIDUsage_Keyboard6, "6" },
+		{ kHIDUsage_Keyboard7, "7" },
+		{ kHIDUsage_Keyboard8, "8" },
+		{ kHIDUsage_Keyboard9, "9" },
+		{ kHIDUsage_Keyboard0, "0" },
+		{ kHIDUsage_KeyboardReturnOrEnter, "Return" },
+		{ kHIDUsage_KeyboardEscape, "Escape" },
+		{ kHIDUsage_KeyboardDeleteOrBackspace, "Backspace" },
+		{ kHIDUsage_KeyboardTab, "Tab" },
+		{ kHIDUsage_KeyboardSpacebar, "Space" },
+		{ kHIDUsage_KeyboardHyphen, "-" },
+		{ kHIDUsage_KeyboardEqualSign, "=" },
+		{ kHIDUsage_KeyboardOpenBracket, "[" },
+		{ kHIDUsage_KeyboardCloseBracket, "]" },
+		{ kHIDUsage_KeyboardBackslash, "\\" },
+		{ kHIDUsage_KeyboardSemicolon, ";" },
+		{ kHIDUsage_KeyboardQuote, "'" },
+		{ kHIDUsage_KeyboardGraveAccentAndTilde, "Tilde" },
+		{ kHIDUsage_KeyboardComma, "," },
+		{ kHIDUsage_KeyboardPeriod, "." },
+		{ kHIDUsage_KeyboardSlash, "/" },
+		{ kHIDUsage_KeyboardCapsLock, "Caps Lock" },
+		{ kHIDUsage_KeyboardF1, "F1" },
+		{ kHIDUsage_KeyboardF2, "F2" },
+		{ kHIDUsage_KeyboardF3, "F3" },
+		{ kHIDUsage_KeyboardF4, "F4" },
+		{ kHIDUsage_KeyboardF5, "F5" },
+		{ kHIDUsage_KeyboardF6, "F6" },
+		{ kHIDUsage_KeyboardF7, "F7" },
+		{ kHIDUsage_KeyboardF8, "F8" },
+		{ kHIDUsage_KeyboardF9, "F9" },
+		{ kHIDUsage_KeyboardF10, "F10" },
+		{ kHIDUsage_KeyboardF11, "F11" },
+		{ kHIDUsage_KeyboardF12, "F12" },
+		{ kHIDUsage_KeyboardInsert, "Insert" },
+		{ kHIDUsage_KeyboardHome, "Home" },
+		{ kHIDUsage_KeyboardPageUp, "Page Up" },
+		{ kHIDUsage_KeyboardDeleteForward, "Delete" },
+		{ kHIDUsage_KeyboardEnd, "End" },
+		{ kHIDUsage_KeyboardPageDown, "Page Down" },
+		{ kHIDUsage_KeyboardRightArrow, "Right Arrow" },
+		{ kHIDUsage_KeyboardLeftArrow, "Left Arrow" },
+		{ kHIDUsage_KeyboardDownArrow, "Down Arrow" },
+		{ kHIDUsage_KeyboardUpArrow, "Up Arrow" },
+		{ kHIDUsage_KeypadSlash, "Keypad /" },
+		{ kHIDUsage_KeypadAsterisk, "Keypad *" },
+		{ kHIDUsage_KeypadHyphen, "Keypad -" },
+		{ kHIDUsage_KeypadPlus, "Keypad +" },
+		{ kHIDUsage_KeypadEnter, "Keypad Enter" },
+		{ kHIDUsage_Keypad1, "Keypad 1" },
+		{ kHIDUsage_Keypad2, "Keypad 2" },
+		{ kHIDUsage_Keypad3, "Keypad 3" },
+		{ kHIDUsage_Keypad4, "Keypad 4" },
+		{ kHIDUsage_Keypad5, "Keypad 5" },
+		{ kHIDUsage_Keypad6, "Keypad 6" },
+		{ kHIDUsage_Keypad7, "Keypad 7" },
+		{ kHIDUsage_Keypad8, "Keypad 8" },
+		{ kHIDUsage_Keypad9, "Keypad 9" },
+		{ kHIDUsage_Keypad0, "Keypad 0" },
+		{ kHIDUsage_KeypadPeriod, "Keypad ." },
+		{ kHIDUsage_KeyboardNonUSBackslash, "Paragraph" },
+		{ kHIDUsage_KeypadEqualSign, "Keypad =" },
+		{ kHIDUsage_KeypadComma, "Keypad ," },
+		{ kHIDUsage_KeyboardLeftControl, "Left Control" },
+		{ kHIDUsage_KeyboardLeftShift, "Left Shift" },
+		{ kHIDUsage_KeyboardLeftAlt, "Left Alt" },
+		{ kHIDUsage_KeyboardLeftGUI, "Left Command" },
+		{ kHIDUsage_KeyboardRightControl, "Right Control" },
+		{ kHIDUsage_KeyboardRightShift, "Right Shift" },
+		{ kHIDUsage_KeyboardRightAlt, "Right Alt" },
+		{ kHIDUsage_KeyboardRightGUI, "Right Command" },
+		{ 184, "Eject" },
+	};
+	
+	const uint32_t keycode = IOHIDElementGetUsage(m_element);
+	for (auto & named_key : named_keys)
+		if (named_key.code == keycode) {
+			m_name = named_key.name;
+			return;
+		}
+	
+	std::stringstream ss;
+	ss << "Key " << keycode;
+	m_name = ss.str();
+}
+
+ControlState Keyboard::Key::GetState() const
+{
+	IOHIDValueRef value;
+
+	if (IOHIDDeviceGetValue(m_device, m_element, &value) == kIOReturnSuccess)
+		return IOHIDValueGetIntegerValue(value);
+	else
+		return 0;
+}
+
+ControlState Keyboard::Cursor::GetState() const
+{
+	return std::max(0.0f, ControlState(m_axis) / (m_positive ? 1.0f : -1.0f));
+}
+
+ControlState Keyboard::Button::GetState() const
+{
+	return (m_button != 0);
+}
+
+std::string Keyboard::Cursor::GetName() const
+{
+	static char tmpstr[] = "Cursor ..";
+	tmpstr[7] = (char)('X' + m_index);
+	tmpstr[8] = (m_positive ? '+' : '-');
+	return tmpstr;
+}
+
+std::string Keyboard::Button::GetName() const
+{
+	return std::string("Click ") + char('0' + m_index);
+}
+
+std::string Keyboard::Key::GetName() const
+{
+	return m_name;
+}
+
+
+}
+}