Reformat all the things. Have fun with merge conflicts.

9 files changed, 660 insertions, 751 deletions

diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/DInput.cpp b/Source/Core/InputCommon/ControllerInterface/DInput/DInput.cpp
index 4a68474618..09227b5932 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/DInput.cpp
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/DInput.cpp
@@ -16,50 +16,47 @@ namespace ciface
 {
 namespace DInput
 {
-
 BOOL CALLBACK DIEnumDeviceObjectsCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef)
 {
-	((std::list<DIDEVICEOBJECTINSTANCE>*)pvRef)->push_back(*lpddoi);
-	return DIENUM_CONTINUE;
+  ((std::list<DIDEVICEOBJECTINSTANCE>*)pvRef)->push_back(*lpddoi);
+  return DIENUM_CONTINUE;
 }
 
 BOOL CALLBACK DIEnumDevicesCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef)
 {
-	((std::list<DIDEVICEINSTANCE>*)pvRef)->push_back(*lpddi);
-	return DIENUM_CONTINUE;
+  ((std::list<DIDEVICEINSTANCE>*)pvRef)->push_back(*lpddi);
+  return DIENUM_CONTINUE;
 }
 
 std::string GetDeviceName(const LPDIRECTINPUTDEVICE8 device)
 {
-	DIPROPSTRING str = {};
-	str.diph.dwSize = sizeof(str);
-	str.diph.dwHeaderSize = sizeof(str.diph);
-	str.diph.dwHow = DIPH_DEVICE;
-
-	std::string result;
-	if (SUCCEEDED(device->GetProperty(DIPROP_PRODUCTNAME, &str.diph)))
-	{
-		result = StripSpaces(UTF16ToUTF8(str.wsz));
-	}
-
-	return result;
+  DIPROPSTRING str = {};
+  str.diph.dwSize = sizeof(str);
+  str.diph.dwHeaderSize = sizeof(str.diph);
+  str.diph.dwHow = DIPH_DEVICE;
+
+  std::string result;
+  if (SUCCEEDED(device->GetProperty(DIPROP_PRODUCTNAME, &str.diph)))
+  {
+    result = StripSpaces(UTF16ToUTF8(str.wsz));
+  }
+
+  return result;
 }
 
 void Init(std::vector<Core::Device*>& devices, HWND hwnd)
 {
-	IDirectInput8* idi8;
-	if (FAILED(DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION,
-		IID_IDirectInput8, (LPVOID*)&idi8, nullptr)))
-	{
-		return;
-	}
+  IDirectInput8* idi8;
+  if (FAILED(DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8,
+                                (LPVOID*)&idi8, nullptr)))
+  {
+    return;
+  }
 
-	InitKeyboardMouse(idi8, devices, hwnd);
-	InitJoystick(idi8, devices, hwnd);
-
-	idi8->Release();
+  InitKeyboardMouse(idi8, devices, hwnd);
+  InitJoystick(idi8, devices, hwnd);
 
+  idi8->Release();
 }
-
 }
 }
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/DInput.h b/Source/Core/InputCommon/ControllerInterface/DInput/DInput.h
index 1823499e98..2f5e2f83a7 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/DInput.h
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/DInput.h
@@ -9,20 +9,18 @@
 #include <list>
 #include <windows.h>
 
-#include "InputCommon/ControllerInterface/Device.h"
 #include "InputCommon/ControllerInterface/DInput/DInput8.h"
+#include "InputCommon/ControllerInterface/Device.h"
 
 namespace ciface
 {
 namespace DInput
 {
-
-//BOOL CALLBACK DIEnumEffectsCallback(LPCDIEFFECTINFO pdei, LPVOID pvRef);
+// BOOL CALLBACK DIEnumEffectsCallback(LPCDIEFFECTINFO pdei, LPVOID pvRef);
 BOOL CALLBACK DIEnumDeviceObjectsCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef);
 BOOL CALLBACK DIEnumDevicesCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef);
 std::string GetDeviceName(const LPDIRECTINPUTDEVICE8 device);
 
 void Init(std::vector<Core::Device*>& devices, HWND hwnd);
-
 }
 }
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.cpp b/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.cpp
index aa1e972126..bf2c1f3e7e 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.cpp
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.cpp
@@ -14,268 +14,270 @@ namespace ciface
 {
 namespace DInput
 {
-
 #define DATA_BUFFER_SIZE 32
 
 void InitJoystick(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND hwnd)
 {
-	std::list<DIDEVICEINSTANCE> joysticks;
-	idi8->EnumDevices(DI8DEVCLASS_GAMECTRL, DIEnumDevicesCallback, (LPVOID)&joysticks, DIEDFL_ATTACHEDONLY);
-
-	// this is used to number the joysticks
-	// multiple joysticks with the same name shall get unique ids starting at 0
-	std::map< std::basic_string<TCHAR>, int> name_counts;
-
-	std::vector<DWORD> xinput_guids;
-	GetXInputGUIDS(&xinput_guids);
-
-	for (DIDEVICEINSTANCE& joystick : joysticks)
-	{
-		// skip XInput Devices
-		if (std::find(xinput_guids.begin(), xinput_guids.end(), joystick.guidProduct.Data1) != xinput_guids.end())
-		{
-			continue;
-		}
-
-		LPDIRECTINPUTDEVICE8 js_device;
-		if (SUCCEEDED(idi8->CreateDevice(joystick.guidInstance, &js_device, nullptr)))
-		{
-			if (SUCCEEDED(js_device->SetDataFormat(&c_dfDIJoystick)))
-			{
-				if (FAILED(js_device->SetCooperativeLevel(GetAncestor(hwnd, GA_ROOT), DISCL_BACKGROUND | DISCL_EXCLUSIVE)))
-				{
-					//PanicAlert("SetCooperativeLevel(DISCL_EXCLUSIVE) failed!");
-					// fall back to non-exclusive mode, with no rumble
-					if (FAILED(js_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
-					{
-						//PanicAlert("SetCooperativeLevel failed!");
-						js_device->Release();
-						continue;
-					}
-				}
-
-				Joystick* js = new Joystick(/*&*i, */js_device, name_counts[joystick.tszInstanceName]++);
-				// only add if it has some inputs/outputs
-				if (js->Inputs().size() || js->Outputs().size())
-					devices.push_back(js);
-				else
-					delete js;
-			}
-			else
-			{
-				//PanicAlert("SetDataFormat failed!");
-				js_device->Release();
-			}
-		}
-	}
+  std::list<DIDEVICEINSTANCE> joysticks;
+  idi8->EnumDevices(DI8DEVCLASS_GAMECTRL, DIEnumDevicesCallback, (LPVOID)&joysticks,
+                    DIEDFL_ATTACHEDONLY);
+
+  // this is used to number the joysticks
+  // multiple joysticks with the same name shall get unique ids starting at 0
+  std::map<std::basic_string<TCHAR>, int> name_counts;
+
+  std::vector<DWORD> xinput_guids;
+  GetXInputGUIDS(&xinput_guids);
+
+  for (DIDEVICEINSTANCE& joystick : joysticks)
+  {
+    // skip XInput Devices
+    if (std::find(xinput_guids.begin(), xinput_guids.end(), joystick.guidProduct.Data1) !=
+        xinput_guids.end())
+    {
+      continue;
+    }
+
+    LPDIRECTINPUTDEVICE8 js_device;
+    if (SUCCEEDED(idi8->CreateDevice(joystick.guidInstance, &js_device, nullptr)))
+    {
+      if (SUCCEEDED(js_device->SetDataFormat(&c_dfDIJoystick)))
+      {
+        if (FAILED(js_device->SetCooperativeLevel(GetAncestor(hwnd, GA_ROOT),
+                                                  DISCL_BACKGROUND | DISCL_EXCLUSIVE)))
+        {
+          // PanicAlert("SetCooperativeLevel(DISCL_EXCLUSIVE) failed!");
+          // fall back to non-exclusive mode, with no rumble
+          if (FAILED(
+                  js_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
+          {
+            // PanicAlert("SetCooperativeLevel failed!");
+            js_device->Release();
+            continue;
+          }
+        }
+
+        Joystick* js = new Joystick(/*&*i, */ js_device, name_counts[joystick.tszInstanceName]++);
+        // only add if it has some inputs/outputs
+        if (js->Inputs().size() || js->Outputs().size())
+          devices.push_back(js);
+        else
+          delete js;
+      }
+      else
+      {
+        // PanicAlert("SetDataFormat failed!");
+        js_device->Release();
+      }
+    }
+  }
 }
 
-Joystick::Joystick( /*const LPCDIDEVICEINSTANCE lpddi, */const LPDIRECTINPUTDEVICE8 device, const unsigned int index )
-	: m_device(device)
-	, m_index(index)
-	//, m_name(TStringToString(lpddi->tszInstanceName))
+Joystick::Joystick(/*const LPCDIDEVICEINSTANCE lpddi, */ const LPDIRECTINPUTDEVICE8 device,
+                   const unsigned int index)
+    : m_device(device), m_index(index)
+//, m_name(TStringToString(lpddi->tszInstanceName))
 {
-	// seems this needs to be done before GetCapabilities
-	// polled or buffered data
-	DIPROPDWORD dipdw;
-	dipdw.diph.dwSize = sizeof(DIPROPDWORD);
-	dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
-	dipdw.diph.dwObj = 0;
-	dipdw.diph.dwHow = DIPH_DEVICE;
-	dipdw.dwData = DATA_BUFFER_SIZE;
-	// set the buffer size,
-	// if we can't set the property, we can't use buffered data
-	m_buffered = SUCCEEDED(m_device->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph));
-
-	// seems this needs to be done after SetProperty of buffer size
-	m_device->Acquire();
-
-	// get joystick caps
-	DIDEVCAPS js_caps;
-	js_caps.dwSize = sizeof(js_caps);
-	if (FAILED(m_device->GetCapabilities(&js_caps)))
-		return;
-
-	// max of 32 buttons and 4 hats / the limit of the data format I am using
-	js_caps.dwButtons = std::min((DWORD)32, js_caps.dwButtons);
-	js_caps.dwPOVs = std::min((DWORD)4, js_caps.dwPOVs);
-
-	//m_must_poll = (js_caps.dwFlags & DIDC_POLLEDDATAFORMAT) != 0;
-
-	// buttons
-	for (u8 i = 0; i != js_caps.dwButtons; ++i)
-		AddInput(new Button(i, m_state_in.rgbButtons[i]));
-
-	// hats
-	for (u8 i = 0; i != js_caps.dwPOVs; ++i)
-	{
-		// each hat gets 4 input instances associated with it, (up down left right)
-		for (u8 d = 0; d != 4; ++d)
-			AddInput(new Hat(i, m_state_in.rgdwPOV[i], d));
-	}
-
-	// get up to 6 axes and 2 sliders
-	DIPROPRANGE range;
-	range.diph.dwSize = sizeof(range);
-	range.diph.dwHeaderSize = sizeof(range.diph);
-	range.diph.dwHow = DIPH_BYOFFSET;
-	// screw EnumObjects, just go through all the axis offsets and try to GetProperty
-	// this should be more foolproof, less code, and probably faster
-	for (unsigned int offset = 0; offset < DIJOFS_BUTTON(0) / sizeof(LONG); ++offset)
-	{
-		range.diph.dwObj = offset * sizeof(LONG);
-		// try to set some nice power of 2 values (128) to match the GameCube controls
-		range.lMin = -(1 << 7);
-		range.lMax = (1 << 7);
-		m_device->SetProperty(DIPROP_RANGE, &range.diph);
-		// but I guess not all devices support setting range
-		// so I getproperty right afterward incase it didn't set.
-		// This also checks that the axis is present
-		if (SUCCEEDED(m_device->GetProperty(DIPROP_RANGE, &range.diph)))
-		{
-			const LONG base = (range.lMin + range.lMax) / 2;
-			const LONG& ax = (&m_state_in.lX)[offset];
-
-			// each axis gets a negative and a positive input instance associated with it
-			AddAnalogInputs(new Axis(offset, ax, base, range.lMin-base),
-				new Axis(offset, ax, base, range.lMax-base));
-		}
-	}
-
-	// force feedback
-	std::list<DIDEVICEOBJECTINSTANCE> objects;
-	if (SUCCEEDED(m_device->EnumObjects(DIEnumDeviceObjectsCallback, (LPVOID)&objects, DIDFT_AXIS)))
-	{
-		InitForceFeedback(m_device, (int)objects.size());
-	}
-
-	ZeroMemory(&m_state_in, sizeof(m_state_in));
-	// set hats to center
-	memset(m_state_in.rgdwPOV, 0xFF, sizeof(m_state_in.rgdwPOV));
+  // seems this needs to be done before GetCapabilities
+  // polled or buffered data
+  DIPROPDWORD dipdw;
+  dipdw.diph.dwSize = sizeof(DIPROPDWORD);
+  dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
+  dipdw.diph.dwObj = 0;
+  dipdw.diph.dwHow = DIPH_DEVICE;
+  dipdw.dwData = DATA_BUFFER_SIZE;
+  // set the buffer size,
+  // if we can't set the property, we can't use buffered data
+  m_buffered = SUCCEEDED(m_device->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph));
+
+  // seems this needs to be done after SetProperty of buffer size
+  m_device->Acquire();
+
+  // get joystick caps
+  DIDEVCAPS js_caps;
+  js_caps.dwSize = sizeof(js_caps);
+  if (FAILED(m_device->GetCapabilities(&js_caps)))
+    return;
+
+  // max of 32 buttons and 4 hats / the limit of the data format I am using
+  js_caps.dwButtons = std::min((DWORD)32, js_caps.dwButtons);
+  js_caps.dwPOVs = std::min((DWORD)4, js_caps.dwPOVs);
+
+  // m_must_poll = (js_caps.dwFlags & DIDC_POLLEDDATAFORMAT) != 0;
+
+  // buttons
+  for (u8 i = 0; i != js_caps.dwButtons; ++i)
+    AddInput(new Button(i, m_state_in.rgbButtons[i]));
+
+  // hats
+  for (u8 i = 0; i != js_caps.dwPOVs; ++i)
+  {
+    // each hat gets 4 input instances associated with it, (up down left right)
+    for (u8 d = 0; d != 4; ++d)
+      AddInput(new Hat(i, m_state_in.rgdwPOV[i], d));
+  }
+
+  // get up to 6 axes and 2 sliders
+  DIPROPRANGE range;
+  range.diph.dwSize = sizeof(range);
+  range.diph.dwHeaderSize = sizeof(range.diph);
+  range.diph.dwHow = DIPH_BYOFFSET;
+  // screw EnumObjects, just go through all the axis offsets and try to GetProperty
+  // this should be more foolproof, less code, and probably faster
+  for (unsigned int offset = 0; offset < DIJOFS_BUTTON(0) / sizeof(LONG); ++offset)
+  {
+    range.diph.dwObj = offset * sizeof(LONG);
+    // try to set some nice power of 2 values (128) to match the GameCube controls
+    range.lMin = -(1 << 7);
+    range.lMax = (1 << 7);
+    m_device->SetProperty(DIPROP_RANGE, &range.diph);
+    // but I guess not all devices support setting range
+    // so I getproperty right afterward incase it didn't set.
+    // This also checks that the axis is present
+    if (SUCCEEDED(m_device->GetProperty(DIPROP_RANGE, &range.diph)))
+    {
+      const LONG base = (range.lMin + range.lMax) / 2;
+      const LONG& ax = (&m_state_in.lX)[offset];
+
+      // each axis gets a negative and a positive input instance associated with it
+      AddAnalogInputs(new Axis(offset, ax, base, range.lMin - base),
+                      new Axis(offset, ax, base, range.lMax - base));
+    }
+  }
+
+  // force feedback
+  std::list<DIDEVICEOBJECTINSTANCE> objects;
+  if (SUCCEEDED(m_device->EnumObjects(DIEnumDeviceObjectsCallback, (LPVOID)&objects, DIDFT_AXIS)))
+  {
+    InitForceFeedback(m_device, (int)objects.size());
+  }
+
+  ZeroMemory(&m_state_in, sizeof(m_state_in));
+  // set hats to center
+  memset(m_state_in.rgdwPOV, 0xFF, sizeof(m_state_in.rgdwPOV));
 }
 
 Joystick::~Joystick()
 {
-	m_device->Unacquire();
-	m_device->Release();
+  m_device->Unacquire();
+  m_device->Release();
 }
 
 std::string Joystick::GetName() const
 {
-	return GetDeviceName(m_device);
+  return GetDeviceName(m_device);
 }
 
 int Joystick::GetId() const
 {
-	return m_index;
+  return m_index;
 }
 
 std::string Joystick::GetSource() const
 {
-	return DINPUT_SOURCE_NAME;
+  return DINPUT_SOURCE_NAME;
 }
 
 // update IO
 
 void Joystick::UpdateInput()
 {
-	HRESULT hr = 0;
-
-	// just always poll,
-	// MSDN says if this isn't needed it doesn't do anything
-	m_device->Poll();
-
-	if (m_buffered)
-	{
-		DIDEVICEOBJECTDATA evtbuf[DATA_BUFFER_SIZE];
-		DWORD numevents = DATA_BUFFER_SIZE;
-		hr = m_device->GetDeviceData(sizeof(*evtbuf), evtbuf, &numevents, 0);
-
-		if (SUCCEEDED(hr))
-		{
-			for (LPDIDEVICEOBJECTDATA evt = evtbuf; evt != (evtbuf + numevents); ++evt)
-			{
-				// all the buttons are at the end of the data format
-				// they are bytes rather than longs
-				if (evt->dwOfs < DIJOFS_BUTTON(0))
-					*(DWORD*)(((BYTE*)&m_state_in) + evt->dwOfs) = evt->dwData;
-				else
-					((BYTE*)&m_state_in)[evt->dwOfs] = (BYTE)evt->dwData;
-			}
-
-			// seems like this needs to be done maybe...
-			if (DI_BUFFEROVERFLOW == hr)
-				hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
-		}
-	}
-	else
-	{
-		hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
-	}
-
-	// try reacquire if input lost
-	if (DIERR_INPUTLOST == hr || DIERR_NOTACQUIRED == hr)
-		m_device->Acquire();
+  HRESULT hr = 0;
+
+  // just always poll,
+  // MSDN says if this isn't needed it doesn't do anything
+  m_device->Poll();
+
+  if (m_buffered)
+  {
+    DIDEVICEOBJECTDATA evtbuf[DATA_BUFFER_SIZE];
+    DWORD numevents = DATA_BUFFER_SIZE;
+    hr = m_device->GetDeviceData(sizeof(*evtbuf), evtbuf, &numevents, 0);
+
+    if (SUCCEEDED(hr))
+    {
+      for (LPDIDEVICEOBJECTDATA evt = evtbuf; evt != (evtbuf + numevents); ++evt)
+      {
+        // all the buttons are at the end of the data format
+        // they are bytes rather than longs
+        if (evt->dwOfs < DIJOFS_BUTTON(0))
+          *(DWORD*)(((BYTE*)&m_state_in) + evt->dwOfs) = evt->dwData;
+        else
+          ((BYTE*)&m_state_in)[evt->dwOfs] = (BYTE)evt->dwData;
+      }
+
+      // seems like this needs to be done maybe...
+      if (DI_BUFFEROVERFLOW == hr)
+        hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
+    }
+  }
+  else
+  {
+    hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
+  }
+
+  // try reacquire if input lost
+  if (DIERR_INPUTLOST == hr || DIERR_NOTACQUIRED == hr)
+    m_device->Acquire();
 }
 
 // get name
 
 std::string Joystick::Button::GetName() const
 {
-	std::ostringstream ss;
-	ss << "Button " << (int)m_index;
-	return ss.str();
+  std::ostringstream ss;
+  ss << "Button " << (int)m_index;
+  return ss.str();
 }
 
 std::string Joystick::Axis::GetName() const
 {
-	std::ostringstream ss;
-	// axis
-	if (m_index < 6)
-	{
-		ss << "Axis " << (char)('X' + (m_index % 3));
-		if (m_index > 2)
-			ss << 'r';
-	}
-	// slider
-	else
-	{
-		ss << "Slider " << (int)(m_index - 6);
-	}
-
-	ss << (m_range < 0 ? '-' : '+');
-	return ss.str();
+  std::ostringstream ss;
+  // axis
+  if (m_index < 6)
+  {
+    ss << "Axis " << (char)('X' + (m_index % 3));
+    if (m_index > 2)
+      ss << 'r';
+  }
+  // slider
+  else
+  {
+    ss << "Slider " << (int)(m_index - 6);
+  }
+
+  ss << (m_range < 0 ? '-' : '+');
+  return ss.str();
 }
 
 std::string Joystick::Hat::GetName() const
 {
-	static char tmpstr[] = "Hat . .";
-	tmpstr[4] = (char)('0' + m_index);
-	tmpstr[6] = "NESW"[m_direction];
-	return tmpstr;
+  static char tmpstr[] = "Hat . .";
+  tmpstr[4] = (char)('0' + m_index);
+  tmpstr[6] = "NESW"[m_direction];
+  return tmpstr;
 }
 
 // get / set state
 
 ControlState Joystick::Axis::GetState() const
 {
-	return std::max(0.0, ControlState(m_axis - m_base) / m_range);
+  return std::max(0.0, ControlState(m_axis - m_base) / m_range);
 }
 
 ControlState Joystick::Button::GetState() const
 {
-	return ControlState(m_button > 0);
+  return ControlState(m_button > 0);
 }
 
 ControlState Joystick::Hat::GetState() const
 {
-	// can this func be simplified ?
-	// hat centered code from MSDN
-	if (0xFFFF == LOWORD(m_hat))
-		return 0;
+  // can this func be simplified ?
+  // hat centered code from MSDN
+  if (0xFFFF == LOWORD(m_hat))
+    return 0;
 
-	return (abs((int)(m_hat / 4500 - m_direction * 2 + 8) % 8 - 4) > 2);
+  return (abs((int)(m_hat / 4500 - m_direction * 2 + 8) % 8 - 4) > 2);
 }
-
 }
 }
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.h b/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.h
index 3064051101..9a14e910de 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.h
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.h
@@ -11,64 +11,71 @@ namespace ciface
 {
 namespace DInput
 {
-
 void InitJoystick(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND hwnd);
 
 class Joystick : public ForceFeedback::ForceFeedbackDevice
 {
 private:
-	class Button : public Input
-	{
-	public:
-		Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
-		std::string GetName() const override;
-		ControlState GetState() const override;
-	private:
-		const BYTE& m_button;
-		const u8 m_index;
-	};
+  class Button : public Input
+  {
+  public:
+    Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
+    std::string GetName() const override;
+    ControlState GetState() const override;
+
+  private:
+    const BYTE& m_button;
+    const u8 m_index;
+  };
+
+  class Axis : public Input
+  {
+  public:
+    Axis(u8 index, const LONG& axis, LONG base, LONG range)
+        : m_axis(axis), m_base(base), m_range(range), m_index(index)
+    {
+    }
+    std::string GetName() const override;
+    ControlState GetState() const override;
 
-	class Axis : public Input
-	{
-	public:
-		Axis(u8 index, const LONG& axis, LONG base, LONG range) : m_axis(axis), m_base(base), m_range(range), m_index(index) {}
-		std::string GetName() const override;
-		ControlState GetState() const override;
-	private:
-		const LONG& m_axis;
-		const LONG m_base, m_range;
-		const u8 m_index;
-	};
+  private:
+    const LONG& m_axis;
+    const LONG m_base, m_range;
+    const u8 m_index;
+  };
 
-	class Hat : public Input
-	{
-	public:
-		Hat(u8 index, const DWORD& hat, u8 direction) : m_hat(hat), m_direction(direction), m_index(index) {}
-		std::string GetName() const override;
-		ControlState GetState() const override;
-	private:
-		const DWORD& m_hat;
-		const u8 m_index, m_direction;
-	};
+  class Hat : public Input
+  {
+  public:
+    Hat(u8 index, const DWORD& hat, u8 direction)
+        : m_hat(hat), m_direction(direction), m_index(index)
+    {
+    }
+    std::string GetName() const override;
+    ControlState GetState() const override;
+
+  private:
+    const DWORD& m_hat;
+    const u8 m_index, m_direction;
+  };
 
 public:
-	void UpdateInput() override;
+  void UpdateInput() override;
 
-	Joystick(const LPDIRECTINPUTDEVICE8 device, const unsigned int index);
-	~Joystick();
+  Joystick(const LPDIRECTINPUTDEVICE8 device, const unsigned int index);
+  ~Joystick();
 
-	std::string GetName() const override;
-	int GetId() const override;
-	std::string GetSource() const override;
+  std::string GetName() const override;
+  int GetId() const override;
+  std::string GetSource() const override;
 
 private:
-	const LPDIRECTINPUTDEVICE8 m_device;
-	const unsigned int         m_index;
+  const LPDIRECTINPUTDEVICE8 m_device;
+  const unsigned int m_index;
 
-	DIJOYSTATE                 m_state_in;
+  DIJOYSTATE m_state_in;
 
-	bool                       m_buffered;
+  bool m_buffered;
 };
-
 }
 }
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.cpp b/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.cpp
index 2111f24d62..92c8514825 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.cpp
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.cpp
@@ -7,27 +7,25 @@
 #include "InputCommon/ControllerInterface/DInput/DInput.h"
 #include "InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h"
 
-	// (lower would be more sensitive) user can lower sensitivity by setting range
-	// seems decent here ( at 8 ), I don't think anyone would need more sensitive than this
-	// and user can lower it much farther than they would want to with the range
-#define MOUSE_AXIS_SENSITIVITY   8
+// (lower would be more sensitive) user can lower sensitivity by setting range
+// seems decent here ( at 8 ), I don't think anyone would need more sensitive than this
+// and user can lower it much farther than they would want to with the range
+#define MOUSE_AXIS_SENSITIVITY 8
 
-	// if input hasn't been received for this many ms, mouse input will be skipped
-	// otherwise it is just some crazy value
-#define DROP_INPUT_TIME          250
+// if input hasn't been received for this many ms, mouse input will be skipped
+// otherwise it is just some crazy value
+#define DROP_INPUT_TIME 250
 
 namespace ciface
 {
 namespace DInput
 {
-
 static const struct
 {
-	const BYTE        code;
-	const char* const name;
-} named_keys[] =
-{
-#include "InputCommon/ControllerInterface/DInput/NamedKeys.h" // NOLINT
+  const BYTE code;
+  const char* const name;
+} named_keys[] = {
+#include "InputCommon/ControllerInterface/DInput/NamedKeys.h"  // NOLINT
 };
 
 // lil silly
@@ -35,223 +33,225 @@ static HWND m_hwnd;
 
 void InitKeyboardMouse(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND _hwnd)
 {
-	m_hwnd = _hwnd;
-
-	// mouse and keyboard are a combined device, to allow shift+click and stuff
-	// if that's dumb, I will make a VirtualDevice class that just uses ranges of inputs/outputs from other devices
-	// so there can be a separated Keyboard and mouse, as well as combined KeyboardMouse
-
-	LPDIRECTINPUTDEVICE8 kb_device = nullptr;
-	LPDIRECTINPUTDEVICE8 mo_device = nullptr;
-
-	if (SUCCEEDED(idi8->CreateDevice( GUID_SysKeyboard, &kb_device, nullptr)))
-	{
-		if (SUCCEEDED(kb_device->SetDataFormat(&c_dfDIKeyboard)))
-		{
-			if (SUCCEEDED(kb_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
-			{
-				if (SUCCEEDED(idi8->CreateDevice( GUID_SysMouse, &mo_device, nullptr )))
-				{
-					if (SUCCEEDED(mo_device->SetDataFormat(&c_dfDIMouse2)))
-					{
-						if (SUCCEEDED(mo_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
-						{
-							devices.push_back(new KeyboardMouse(kb_device, mo_device));
-							return;
-						}
-					}
-				}
-			}
-		}
-	}
-
-	if (kb_device)
-		kb_device->Release();
-	if (mo_device)
-		mo_device->Release();
+  m_hwnd = _hwnd;
+
+  // mouse and keyboard are a combined device, to allow shift+click and stuff
+  // if that's dumb, I will make a VirtualDevice class that just uses ranges of inputs/outputs from
+  // other devices
+  // so there can be a separated Keyboard and mouse, as well as combined KeyboardMouse
+
+  LPDIRECTINPUTDEVICE8 kb_device = nullptr;
+  LPDIRECTINPUTDEVICE8 mo_device = nullptr;
+
+  if (SUCCEEDED(idi8->CreateDevice(GUID_SysKeyboard, &kb_device, nullptr)))
+  {
+    if (SUCCEEDED(kb_device->SetDataFormat(&c_dfDIKeyboard)))
+    {
+      if (SUCCEEDED(kb_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
+      {
+        if (SUCCEEDED(idi8->CreateDevice(GUID_SysMouse, &mo_device, nullptr)))
+        {
+          if (SUCCEEDED(mo_device->SetDataFormat(&c_dfDIMouse2)))
+          {
+            if (SUCCEEDED(
+                    mo_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
+            {
+              devices.push_back(new KeyboardMouse(kb_device, mo_device));
+              return;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (kb_device)
+    kb_device->Release();
+  if (mo_device)
+    mo_device->Release();
 }
 
 KeyboardMouse::~KeyboardMouse()
 {
-	// kb
-	m_kb_device->Unacquire();
-	m_kb_device->Release();
-	// mouse
-	m_mo_device->Unacquire();
-	m_mo_device->Release();
+  // kb
+  m_kb_device->Unacquire();
+  m_kb_device->Release();
+  // mouse
+  m_mo_device->Unacquire();
+  m_mo_device->Release();
 }
 
-KeyboardMouse::KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device)
-	: m_kb_device(kb_device)
-	, m_mo_device(mo_device)
+KeyboardMouse::KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device,
+                             const LPDIRECTINPUTDEVICE8 mo_device)
+    : m_kb_device(kb_device), m_mo_device(mo_device)
 {
-	m_kb_device->Acquire();
-	m_mo_device->Acquire();
-
-	m_last_update = GetTickCount();
-
-	ZeroMemory(&m_state_in, sizeof(m_state_in));
-
-	// KEYBOARD
-	// add keys
-	for (u8 i = 0; i < sizeof(named_keys)/sizeof(*named_keys); ++i)
-		AddInput(new Key(i, m_state_in.keyboard[named_keys[i].code]));
-
-	// MOUSE
-	// get caps
-	DIDEVCAPS mouse_caps;
-	ZeroMemory( &mouse_caps, sizeof(mouse_caps) );
-	mouse_caps.dwSize = sizeof(mouse_caps);
-	m_mo_device->GetCapabilities(&mouse_caps);
-	// mouse buttons
-	for (u8 i = 0; i < mouse_caps.dwButtons; ++i)
-		AddInput(new Button(i, m_state_in.mouse.rgbButtons[i]));
-	// mouse axes
-	for (unsigned int i = 0; i < mouse_caps.dwAxes; ++i)
-	{
-		const LONG& ax = (&m_state_in.mouse.lX)[i];
-
-		// each axis gets a negative and a positive input instance associated with it
-		AddInput(new Axis(i, ax, (2==i) ? -1 : -MOUSE_AXIS_SENSITIVITY));
-		AddInput(new Axis(i, ax, -(2==i) ? 1 : MOUSE_AXIS_SENSITIVITY));
-	}
-	// cursor, with a hax for-loop
-	for (unsigned int i=0; i<4; ++i)
-		AddInput(new Cursor(!!(i&2), (&m_state_in.cursor.x)[i/2], !!(i&1)));
+  m_kb_device->Acquire();
+  m_mo_device->Acquire();
+
+  m_last_update = GetTickCount();
+
+  ZeroMemory(&m_state_in, sizeof(m_state_in));
+
+  // KEYBOARD
+  // add keys
+  for (u8 i = 0; i < sizeof(named_keys) / sizeof(*named_keys); ++i)
+    AddInput(new Key(i, m_state_in.keyboard[named_keys[i].code]));
+
+  // MOUSE
+  // get caps
+  DIDEVCAPS mouse_caps;
+  ZeroMemory(&mouse_caps, sizeof(mouse_caps));
+  mouse_caps.dwSize = sizeof(mouse_caps);
+  m_mo_device->GetCapabilities(&mouse_caps);
+  // mouse buttons
+  for (u8 i = 0; i < mouse_caps.dwButtons; ++i)
+    AddInput(new Button(i, m_state_in.mouse.rgbButtons[i]));
+  // mouse axes
+  for (unsigned int i = 0; i < mouse_caps.dwAxes; ++i)
+  {
+    const LONG& ax = (&m_state_in.mouse.lX)[i];
+
+    // each axis gets a negative and a positive input instance associated with it
+    AddInput(new Axis(i, ax, (2 == i) ? -1 : -MOUSE_AXIS_SENSITIVITY));
+    AddInput(new Axis(i, ax, -(2 == i) ? 1 : MOUSE_AXIS_SENSITIVITY));
+  }
+  // cursor, with a hax for-loop
+  for (unsigned int i = 0; i < 4; ++i)
+    AddInput(new Cursor(!!(i & 2), (&m_state_in.cursor.x)[i / 2], !!(i & 1)));
 }
 
 void GetMousePos(ControlState* const x, ControlState* const y)
 {
-	POINT point = { 1, 1 };
-	GetCursorPos(&point);
-	// Get the cursor position relative to the upper left corner of the current window (separate or render to main)
-	HWND hwnd = WindowFromPoint(point);
-	DWORD processId;
-	GetWindowThreadProcessId(hwnd, &processId);
-	if (processId == GetCurrentProcessId())
-	{
-		ScreenToClient(hwnd, &point);
-
-		// Get the size of the current window. (In my case Rect.top and Rect.left was zero.)
-		RECT rect;
-		GetClientRect(hwnd, &rect);
-		// Width and height is the size of the rendering window
-		unsigned int win_width = rect.right - rect.left;
-		unsigned int win_height = rect.bottom - rect.top;
-
-		// Return the mouse position as a range from -1 to 1
-		*x = (ControlState)point.x / (ControlState)win_width * 2 - 1;
-		*y = (ControlState)point.y / (ControlState)win_height * 2 - 1;
-	}
-	else
-	{
-		*x = (ControlState)1;
-		*y = (ControlState)1;
-	}
+  POINT point = {1, 1};
+  GetCursorPos(&point);
+  // Get the cursor position relative to the upper left corner of the current window (separate or
+  // render to main)
+  HWND hwnd = WindowFromPoint(point);
+  DWORD processId;
+  GetWindowThreadProcessId(hwnd, &processId);
+  if (processId == GetCurrentProcessId())
+  {
+    ScreenToClient(hwnd, &point);
+
+    // Get the size of the current window. (In my case Rect.top and Rect.left was zero.)
+    RECT rect;
+    GetClientRect(hwnd, &rect);
+    // Width and height is the size of the rendering window
+    unsigned int win_width = rect.right - rect.left;
+    unsigned int win_height = rect.bottom - rect.top;
+
+    // Return the mouse position as a range from -1 to 1
+    *x = (ControlState)point.x / (ControlState)win_width * 2 - 1;
+    *y = (ControlState)point.y / (ControlState)win_height * 2 - 1;
+  }
+  else
+  {
+    *x = (ControlState)1;
+    *y = (ControlState)1;
+  }
 }
 
 void KeyboardMouse::UpdateInput()
 {
-	DIMOUSESTATE2 tmp_mouse;
+  DIMOUSESTATE2 tmp_mouse;
 
-	// if mouse position hasn't been updated in a short while, skip a dev state
-	DWORD cur_time = GetTickCount();
-	if (cur_time - m_last_update > DROP_INPUT_TIME)
-	{
-		// set axes to zero
-		ZeroMemory(&m_state_in.mouse, sizeof(m_state_in.mouse));
-		// skip this input state
-		m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
-	}
+  // if mouse position hasn't been updated in a short while, skip a dev state
+  DWORD cur_time = GetTickCount();
+  if (cur_time - m_last_update > DROP_INPUT_TIME)
+  {
+    // set axes to zero
+    ZeroMemory(&m_state_in.mouse, sizeof(m_state_in.mouse));
+    // skip this input state
+    m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
+  }
 
-	m_last_update = cur_time;
+  m_last_update = cur_time;
 
-	HRESULT kb_hr = m_kb_device->GetDeviceState(sizeof(m_state_in.keyboard), &m_state_in.keyboard);
-	HRESULT mo_hr = m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
+  HRESULT kb_hr = m_kb_device->GetDeviceState(sizeof(m_state_in.keyboard), &m_state_in.keyboard);
+  HRESULT mo_hr = m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
 
-	if (DIERR_INPUTLOST == kb_hr || DIERR_NOTACQUIRED == kb_hr)
-		m_kb_device->Acquire();
+  if (DIERR_INPUTLOST == kb_hr || DIERR_NOTACQUIRED == kb_hr)
+    m_kb_device->Acquire();
 
-	if (DIERR_INPUTLOST == mo_hr || DIERR_NOTACQUIRED == mo_hr)
-		m_mo_device->Acquire();
+  if (DIERR_INPUTLOST == mo_hr || DIERR_NOTACQUIRED == mo_hr)
+    m_mo_device->Acquire();
 
-	if (SUCCEEDED(kb_hr) && SUCCEEDED(mo_hr))
-	{
-		// need to smooth out the axes, otherwise it doesn't work for shit
-		for (unsigned int i = 0; i < 3; ++i)
-			((&m_state_in.mouse.lX)[i] += (&tmp_mouse.lX)[i]) /= 2;
+  if (SUCCEEDED(kb_hr) && SUCCEEDED(mo_hr))
+  {
+    // need to smooth out the axes, otherwise it doesn't work for shit
+    for (unsigned int i = 0; i < 3; ++i)
+      ((&m_state_in.mouse.lX)[i] += (&tmp_mouse.lX)[i]) /= 2;
 
-		// copy over the buttons
-		memcpy(m_state_in.mouse.rgbButtons, tmp_mouse.rgbButtons, sizeof(m_state_in.mouse.rgbButtons));
+    // copy over the buttons
+    memcpy(m_state_in.mouse.rgbButtons, tmp_mouse.rgbButtons, sizeof(m_state_in.mouse.rgbButtons));
 
-		// update mouse cursor
-		GetMousePos(&m_state_in.cursor.x, &m_state_in.cursor.y);
-	}
+    // update mouse cursor
+    GetMousePos(&m_state_in.cursor.x, &m_state_in.cursor.y);
+  }
 }
 
 std::string KeyboardMouse::GetName() const
 {
-	return "Keyboard Mouse";
+  return "Keyboard Mouse";
 }
 
 int KeyboardMouse::GetId() const
 {
-	// should this be -1, idk
-	return 0;
+  // should this be -1, idk
+  return 0;
 }
 
 std::string KeyboardMouse::GetSource() const
 {
-	return DINPUT_SOURCE_NAME;
+  return DINPUT_SOURCE_NAME;
 }
 
 // names
 std::string KeyboardMouse::Key::GetName() const
 {
-	return named_keys[m_index].name;
+  return named_keys[m_index].name;
 }
 
 std::string KeyboardMouse::Button::GetName() const
 {
-	return std::string("Click ") + char('0' + m_index);
+  return std::string("Click ") + char('0' + m_index);
 }
 
 std::string KeyboardMouse::Axis::GetName() const
 {
-	static char tmpstr[] = "Axis ..";
-	tmpstr[5] = (char)('X' + m_index);
-	tmpstr[6] = (m_range<0 ? '-' : '+');
-	return tmpstr;
+  static char tmpstr[] = "Axis ..";
+  tmpstr[5] = (char)('X' + m_index);
+  tmpstr[6] = (m_range < 0 ? '-' : '+');
+  return tmpstr;
 }
 
 std::string KeyboardMouse::Cursor::GetName() const
 {
-	static char tmpstr[] = "Cursor ..";
-	tmpstr[7] = (char)('X' + m_index);
-	tmpstr[8] = (m_positive ? '+' : '-');
-	return tmpstr;
+  static char tmpstr[] = "Cursor ..";
+  tmpstr[7] = (char)('X' + m_index);
+  tmpstr[8] = (m_positive ? '+' : '-');
+  return tmpstr;
 }
 
 // get/set state
 ControlState KeyboardMouse::Key::GetState() const
 {
-	return (m_key != 0);
+  return (m_key != 0);
 }
 
 ControlState KeyboardMouse::Button::GetState() const
 {
-	return (m_button != 0);
+  return (m_button != 0);
 }
 
 ControlState KeyboardMouse::Axis::GetState() const
 {
-	return std::max(0.0, ControlState(m_axis) / m_range);
+  return std::max(0.0, ControlState(m_axis) / m_range);
 }
 
 ControlState KeyboardMouse::Cursor::GetState() const
 {
-	return std::max(0.0, ControlState(m_axis) / (m_positive ? 1.0 : -1.0));
+  return std::max(0.0, ControlState(m_axis) / (m_positive ? 1.0 : -1.0));
 }
-
 }
 }
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h b/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h
index 14d885ff94..1ba9022f9d 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h
@@ -6,93 +6,98 @@
 
 #include <windows.h>
 
-#include "InputCommon/ControllerInterface/Device.h"
 #include "InputCommon/ControllerInterface/DInput/DInput8.h"
+#include "InputCommon/ControllerInterface/Device.h"
 
 namespace ciface
 {
 namespace DInput
 {
-
 void InitKeyboardMouse(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND _hwnd);
 
 class KeyboardMouse : public Core::Device
 {
 private:
-	struct State
-	{
-		BYTE          keyboard[256];
-		DIMOUSESTATE2 mouse;
-		struct
-		{
-			ControlState x, y;
-		} cursor;
-	};
-
-	class Key : public Input
-	{
-	public:
-		Key(u8 index, const BYTE& key) : m_key(key), m_index(index) {}
-		std::string GetName() const override;
-		ControlState GetState() const override;
-	private:
-		const BYTE& m_key;
-		const u8 m_index;
-	};
-
-	class Button : public Input
-	{
-	public:
-		Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
-		std::string GetName() const override;
-		ControlState GetState() const override;
-	private:
-		const BYTE& m_button;
-		const u8 m_index;
-	};
-
-	class Axis : public Input
-	{
-	public:
-		Axis(u8 index, const LONG& axis, LONG range) : m_axis(axis), m_range(range), m_index(index) {}
-		std::string GetName() const override;
-		ControlState GetState() const override;
-	private:
-		const LONG& m_axis;
-		const LONG m_range;
-		const u8 m_index;
-	};
-
-	class Cursor : public Input
-	{
-	public:
-		Cursor(u8 index, const ControlState& axis, const bool positive) :  m_axis(axis), m_index(index), m_positive(positive) {}
-		std::string GetName() const override;
-		bool IsDetectable() override { return false; }
-		ControlState GetState() const override;
-	private:
-		const ControlState& m_axis;
-		const u8 m_index;
-		const bool m_positive;
-	};
+  struct State
+  {
+    BYTE keyboard[256];
+    DIMOUSESTATE2 mouse;
+    struct
+    {
+      ControlState x, y;
+    } cursor;
+  };
+
+  class Key : public Input
+  {
+  public:
+    Key(u8 index, const BYTE& key) : m_key(key), m_index(index) {}
+    std::string GetName() const override;
+    ControlState GetState() const override;
+
+  private:
+    const BYTE& m_key;
+    const u8 m_index;
+  };
+
+  class Button : public Input
+  {
+  public:
+    Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
+    std::string GetName() const override;
+    ControlState GetState() const override;
+
+  private:
+    const BYTE& m_button;
+    const u8 m_index;
+  };
+
+  class Axis : public Input
+  {
+  public:
+    Axis(u8 index, const LONG& axis, LONG range) : m_axis(axis), m_range(range), m_index(index) {}
+    std::string GetName() const override;
+    ControlState GetState() const override;
+
+  private:
+    const LONG& m_axis;
+    const LONG m_range;
+    const u8 m_index;
+  };
+
+  class Cursor : public Input
+  {
+  public:
+    Cursor(u8 index, const ControlState& axis, const bool positive)
+        : m_axis(axis), m_index(index), m_positive(positive)
+    {
+    }
+    std::string GetName() const override;
+    bool IsDetectable() override { return false; }
+    ControlState GetState() const override;
+
+  private:
+    const ControlState& m_axis;
+    const u8 m_index;
+    const bool m_positive;
+  };
 
 public:
-	void UpdateInput() override;
+  void UpdateInput() override;
 
-	KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device);
-	~KeyboardMouse();
+  KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device);
+  ~KeyboardMouse();
 
-	std::string GetName() const override;
-	int GetId() const override;
-	std::string GetSource() const override;
+  std::string GetName() const override;
+  int GetId() const override;
+  std::string GetSource() const override;
 
 private:
-	const LPDIRECTINPUTDEVICE8 m_kb_device;
-	const LPDIRECTINPUTDEVICE8 m_mo_device;
+  const LPDIRECTINPUTDEVICE8 m_kb_device;
+  const LPDIRECTINPUTDEVICE8 m_mo_device;
 
-	DWORD         m_last_update;
-	State         m_state_in;
+  DWORD m_last_update;
+  State m_state_in;
 };
-
 }
 }
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/NamedKeys.h b/Source/Core/InputCommon/ControllerInterface/DInput/NamedKeys.h
index 6802fd7888..2ac38a86fe 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/NamedKeys.h
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/NamedKeys.h
@@ -2,147 +2,40 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
-{ DIK_A, "A" },
-{ DIK_B, "B" },
-{ DIK_C, "C" },
-{ DIK_D, "D" },
-{ DIK_E, "E" },
-{ DIK_F, "F" },
-{ DIK_G, "G" },
-{ DIK_H, "H" },
-{ DIK_I, "I" },
-{ DIK_J, "J" },
-{ DIK_K, "K" },
-{ DIK_L, "L" },
-{ DIK_M, "M" },
-{ DIK_N, "N" },
-{ DIK_O, "O" },
-{ DIK_P, "P" },
-{ DIK_Q, "Q" },
-{ DIK_R, "R" },
-{ DIK_S, "S" },
-{ DIK_T, "T" },
-{ DIK_U, "U" },
-{ DIK_V, "V" },
-{ DIK_W, "W" },
-{ DIK_X, "X" },
-{ DIK_Y, "Y" },
-{ DIK_Z, "Z" },
-{ DIK_0, "0" },
-{ DIK_1, "1" },
-{ DIK_2, "2" },
-{ DIK_3, "3" },
-{ DIK_4, "4" },
-{ DIK_5, "5" },
-{ DIK_6, "6" },
-{ DIK_7, "7" },
-{ DIK_8, "8" },
-{ DIK_9, "9" },
-{ DIK_UP, "UP" },
-{ DIK_DOWN, "DOWN" },
-{ DIK_LEFT, "LEFT" },
-{ DIK_RIGHT, "RIGHT" },
-{ DIK_ABNT_C1, "ABNT_C1" },
-{ DIK_ABNT_C2, "ABNT_C2" },
-{ DIK_ADD, "ADD" },
-{ DIK_APOSTROPHE, "APOSTROPHE" },
-{ DIK_APPS, "APPS" },
-{ DIK_AT, "AT" },
-{ DIK_AX, "AX" },
-{ DIK_BACK, "BACK" },
-{ DIK_BACKSLASH, "BACKSLASH" },
-{ DIK_CALCULATOR, "CALCULATOR" },
-{ DIK_CAPITAL, "CAPITAL" },
-{ DIK_COLON, "COLON" },
-{ DIK_COMMA, "COMMA" },
-{ DIK_CONVERT, "CONVERT" },
-{ DIK_DECIMAL, "DECIMAL" },
-{ DIK_DELETE, "DELETE" },
-{ DIK_DIVIDE, "DIVIDE" },
-{ DIK_EQUALS, "EQUALS" },
-{ DIK_ESCAPE, "ESCAPE" },
-{ DIK_F1, "F1" },
-{ DIK_F2, "F2" },
-{ DIK_F3, "F3" },
-{ DIK_F4, "F4" },
-{ DIK_F5, "F5" },
-{ DIK_F6, "F6" },
-{ DIK_F7, "F7" },
-{ DIK_F8, "F8" },
-{ DIK_F9, "F9" },
-{ DIK_F10, "F10" },
-{ DIK_F11, "F11" },
-{ DIK_F12, "F12" },
-{ DIK_F13, "F13" },
-{ DIK_F14, "F14" },
-{ DIK_F15, "F15" },
-{ DIK_GRAVE, "GRAVE" },
-{ DIK_HOME, "HOME" },
-{ DIK_END, "END" },
-{ DIK_INSERT, "INSERT" },
-{ DIK_KANA, "KANA" },
-{ DIK_KANJI, "KANJI" },
-{ DIK_MAIL, "MAIL" },
-{ DIK_MEDIASELECT, "MEDIASELECT" },
-{ DIK_MEDIASTOP, "MEDIASTOP" },
-{ DIK_MINUS, "MINUS" },
-{ DIK_MULTIPLY, "MULTIPLY" },
-{ DIK_MUTE, "MUTE" },
-{ DIK_MYCOMPUTER, "MYCOMPUTER" },
-{ DIK_NEXTTRACK, "NEXTTRACK" },
-{ DIK_NOCONVERT, "NOCONVERT" },
-{ DIK_NUMLOCK, "NUMLOCK" },
-{ DIK_NUMPAD0, "NUMPAD0" },
-{ DIK_NUMPAD1, "NUMPAD1" },
-{ DIK_NUMPAD2, "NUMPAD2" },
-{ DIK_NUMPAD3, "NUMPAD3" },
-{ DIK_NUMPAD4, "NUMPAD4" },
-{ DIK_NUMPAD5, "NUMPAD5" },
-{ DIK_NUMPAD6, "NUMPAD6" },
-{ DIK_NUMPAD7, "NUMPAD7" },
-{ DIK_NUMPAD8, "NUMPAD8" },
-{ DIK_NUMPAD9, "NUMPAD9" },
-{ DIK_NUMPADCOMMA, "NUMPADCOMMA" },
-{ DIK_NUMPADENTER, "NUMPADENTER" },
-{ DIK_NUMPADEQUALS, "NUMPADEQUALS" },
-{ DIK_OEM_102, "OEM_102" },
-{ DIK_PAUSE, "PAUSE" },
-{ DIK_PERIOD, "PERIOD" },
-{ DIK_PLAYPAUSE, "PLAYPAUSE" },
-{ DIK_POWER, "POWER" },
-{ DIK_PREVTRACK, "PREVTRACK" },
-{ DIK_PRIOR, "PRIOR" },
-{ DIK_NEXT, "NEXT" },
-{ DIK_RETURN, "RETURN" },
-{ DIK_LBRACKET, "LBRACKET" },
-{ DIK_RBRACKET, "RBRACKET" },
-{ DIK_LCONTROL, "LCONTROL" },
-{ DIK_RCONTROL, "RCONTROL" },
-{ DIK_LMENU, "LMENU" },
-{ DIK_RMENU, "RMENU" },
-{ DIK_LSHIFT, "LSHIFT" },
-{ DIK_RSHIFT, "RSHIFT" },
-{ DIK_LWIN, "LWIN" },
-{ DIK_RWIN, "RWIN" },
-{ DIK_SCROLL, "SCROLL" },
-{ DIK_SEMICOLON, "SEMICOLON" },
-{ DIK_SLASH, "SLASH" },
-{ DIK_SLEEP, "SLEEP" },
-{ DIK_SPACE, "SPACE" },
-{ DIK_STOP, "STOP" },
-{ DIK_SUBTRACT, "SUBTRACT" },
-{ DIK_SYSRQ, "SYSRQ" },
-{ DIK_TAB, "TAB" },
-{ DIK_UNDERLINE, "UNDERLINE" },
-{ DIK_UNLABELED, "UNLABELED" },
-{ DIK_VOLUMEDOWN, "VOLUMEDOWN" },
-{ DIK_VOLUMEUP, "VOLUMEUP" },
-{ DIK_WAKE, "WAKE" },
-{ DIK_WEBBACK, "WEBBACK" },
-{ DIK_WEBFAVORITES, "WEBFAVORITES" },
-{ DIK_WEBFORWARD, "WEBFORWARD" },
-{ DIK_WEBHOME, "WEBHOME" },
-{ DIK_WEBREFRESH, "WEBREFRESH" },
-{ DIK_WEBSEARCH, "WEBSEARCH" },
-{ DIK_WEBSTOP, "WEBSTOP" },
-{ DIK_YEN, "YEN" },
+{DIK_A, "A"}, {DIK_B, "B"}, {DIK_C, "C"}, {DIK_D, "D"}, {DIK_E, "E"}, {DIK_F, "F"}, {DIK_G, "G"},
+    {DIK_H, "H"}, {DIK_I, "I"}, {DIK_J, "J"}, {DIK_K, "K"}, {DIK_L, "L"}, {DIK_M, "M"},
+    {DIK_N, "N"}, {DIK_O, "O"}, {DIK_P, "P"}, {DIK_Q, "Q"}, {DIK_R, "R"}, {DIK_S, "S"},
+    {DIK_T, "T"}, {DIK_U, "U"}, {DIK_V, "V"}, {DIK_W, "W"}, {DIK_X, "X"}, {DIK_Y, "Y"},
+    {DIK_Z, "Z"}, {DIK_0, "0"}, {DIK_1, "1"}, {DIK_2, "2"}, {DIK_3, "3"}, {DIK_4, "4"},
+    {DIK_5, "5"}, {DIK_6, "6"}, {DIK_7, "7"}, {DIK_8, "8"}, {DIK_9, "9"}, {DIK_UP, "UP"},
+    {DIK_DOWN, "DOWN"}, {DIK_LEFT, "LEFT"}, {DIK_RIGHT, "RIGHT"}, {DIK_ABNT_C1, "ABNT_C1"},
+    {DIK_ABNT_C2, "ABNT_C2"}, {DIK_ADD, "ADD"}, {DIK_APOSTROPHE, "APOSTROPHE"}, {DIK_APPS, "APPS"},
+    {DIK_AT, "AT"}, {DIK_AX, "AX"}, {DIK_BACK, "BACK"}, {DIK_BACKSLASH, "BACKSLASH"},
+    {DIK_CALCULATOR, "CALCULATOR"}, {DIK_CAPITAL, "CAPITAL"}, {DIK_COLON, "COLON"},
+    {DIK_COMMA, "COMMA"}, {DIK_CONVERT, "CONVERT"}, {DIK_DECIMAL, "DECIMAL"},
+    {DIK_DELETE, "DELETE"}, {DIK_DIVIDE, "DIVIDE"}, {DIK_EQUALS, "EQUALS"}, {DIK_ESCAPE, "ESCAPE"},
+    {DIK_F1, "F1"}, {DIK_F2, "F2"}, {DIK_F3, "F3"}, {DIK_F4, "F4"}, {DIK_F5, "F5"}, {DIK_F6, "F6"},
+    {DIK_F7, "F7"}, {DIK_F8, "F8"}, {DIK_F9, "F9"}, {DIK_F10, "F10"}, {DIK_F11, "F11"},
+    {DIK_F12, "F12"}, {DIK_F13, "F13"}, {DIK_F14, "F14"}, {DIK_F15, "F15"}, {DIK_GRAVE, "GRAVE"},
+    {DIK_HOME, "HOME"}, {DIK_END, "END"}, {DIK_INSERT, "INSERT"}, {DIK_KANA, "KANA"},
+    {DIK_KANJI, "KANJI"}, {DIK_MAIL, "MAIL"}, {DIK_MEDIASELECT, "MEDIASELECT"},
+    {DIK_MEDIASTOP, "MEDIASTOP"}, {DIK_MINUS, "MINUS"}, {DIK_MULTIPLY, "MULTIPLY"},
+    {DIK_MUTE, "MUTE"}, {DIK_MYCOMPUTER, "MYCOMPUTER"}, {DIK_NEXTTRACK, "NEXTTRACK"},
+    {DIK_NOCONVERT, "NOCONVERT"}, {DIK_NUMLOCK, "NUMLOCK"}, {DIK_NUMPAD0, "NUMPAD0"},
+    {DIK_NUMPAD1, "NUMPAD1"}, {DIK_NUMPAD2, "NUMPAD2"}, {DIK_NUMPAD3, "NUMPAD3"},
+    {DIK_NUMPAD4, "NUMPAD4"}, {DIK_NUMPAD5, "NUMPAD5"}, {DIK_NUMPAD6, "NUMPAD6"},
+    {DIK_NUMPAD7, "NUMPAD7"}, {DIK_NUMPAD8, "NUMPAD8"}, {DIK_NUMPAD9, "NUMPAD9"},
+    {DIK_NUMPADCOMMA, "NUMPADCOMMA"}, {DIK_NUMPADENTER, "NUMPADENTER"},
+    {DIK_NUMPADEQUALS, "NUMPADEQUALS"}, {DIK_OEM_102, "OEM_102"}, {DIK_PAUSE, "PAUSE"},
+    {DIK_PERIOD, "PERIOD"}, {DIK_PLAYPAUSE, "PLAYPAUSE"}, {DIK_POWER, "POWER"},
+    {DIK_PREVTRACK, "PREVTRACK"}, {DIK_PRIOR, "PRIOR"}, {DIK_NEXT, "NEXT"}, {DIK_RETURN, "RETURN"},
+    {DIK_LBRACKET, "LBRACKET"}, {DIK_RBRACKET, "RBRACKET"}, {DIK_LCONTROL, "LCONTROL"},
+    {DIK_RCONTROL, "RCONTROL"}, {DIK_LMENU, "LMENU"}, {DIK_RMENU, "RMENU"}, {DIK_LSHIFT, "LSHIFT"},
+    {DIK_RSHIFT, "RSHIFT"}, {DIK_LWIN, "LWIN"}, {DIK_RWIN, "RWIN"}, {DIK_SCROLL, "SCROLL"},
+    {DIK_SEMICOLON, "SEMICOLON"}, {DIK_SLASH, "SLASH"}, {DIK_SLEEP, "SLEEP"}, {DIK_SPACE, "SPACE"},
+    {DIK_STOP, "STOP"}, {DIK_SUBTRACT, "SUBTRACT"}, {DIK_SYSRQ, "SYSRQ"}, {DIK_TAB, "TAB"},
+    {DIK_UNDERLINE, "UNDERLINE"}, {DIK_UNLABELED, "UNLABELED"}, {DIK_VOLUMEDOWN, "VOLUMEDOWN"},
+    {DIK_VOLUMEUP, "VOLUMEUP"}, {DIK_WAKE, "WAKE"}, {DIK_WEBBACK, "WEBBACK"},
+    {DIK_WEBFAVORITES, "WEBFAVORITES"}, {DIK_WEBFORWARD, "WEBFORWARD"}, {DIK_WEBHOME, "WEBHOME"},
+    {DIK_WEBREFRESH, "WEBREFRESH"}, {DIK_WEBSEARCH, "WEBSEARCH"}, {DIK_WEBSTOP, "WEBSTOP"},
+    {DIK_YEN, "YEN"},
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.cpp b/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.cpp
index aedfc5dc44..d6f1cab257 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.cpp
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.cpp
@@ -5,118 +5,127 @@
 // This function is contained in a separate file because WbemIdl.h pulls in files which break on
 // /Zc:strictStrings, so this compilation unit is compiled without /Zc:strictStrings.
 
-#include <vector>
 #include <WbemIdl.h>
 #include <Windows.h>
+#include <vector>
 
-#define SAFE_RELEASE(p) { if (p) { (p)->Release(); (p)=nullptr; } }
+#define SAFE_RELEASE(p)                                                                            \
+  {                                                                                                \
+    if (p)                                                                                         \
+    {                                                                                              \
+      (p)->Release();                                                                              \
+      (p) = nullptr;                                                                               \
+    }                                                                                              \
+  }
 
 namespace ciface
 {
 namespace DInput
 {
-
 //-----------------------------------------------------------------------------
 // Modified some MSDN code to get all the XInput device GUID.Data1 values in a vector,
 // faster than checking all the devices for each DirectInput device, like MSDN says to do
 //-----------------------------------------------------------------------------
 void GetXInputGUIDS(std::vector<DWORD>* guids)
 {
-	IWbemLocator*           pIWbemLocator  = nullptr;
-	IEnumWbemClassObject*   pEnumDevices   = nullptr;
-	IWbemClassObject*       pDevices[20]   = {0};
-	IWbemServices*          pIWbemServices = nullptr;
-	BSTR                    bstrNamespace  = nullptr;
-	BSTR                    bstrDeviceID   = nullptr;
-	BSTR                    bstrClassName  = nullptr;
-	DWORD                   uReturned      = 0;
-	VARIANT                 var;
-	HRESULT                 hr;
-
-	// CoInit if needed
-	hr = CoInitialize(nullptr);
-	bool bCleanupCOM = SUCCEEDED(hr);
-
-	// Create WMI
-	hr = CoCreateInstance(__uuidof(WbemLocator),
-	                      nullptr,
-	                      CLSCTX_INPROC_SERVER,
-	                      __uuidof(IWbemLocator),
-	                      (LPVOID*) &pIWbemLocator);
-	if (FAILED(hr) || pIWbemLocator == nullptr)
-		goto LCleanup;
-
-	bstrNamespace = SysAllocString(L"\\\\.\\root\\cimv2"); if (bstrNamespace == nullptr) goto LCleanup;
-	bstrClassName = SysAllocString(L"Win32_PNPEntity");    if (bstrClassName == nullptr) goto LCleanup;
-	bstrDeviceID  = SysAllocString(L"DeviceID");           if (bstrDeviceID == nullptr)  goto LCleanup;
-
-	// Connect to WMI
-	hr = pIWbemLocator->ConnectServer(bstrNamespace, nullptr, nullptr, 0L, 0L, nullptr, nullptr, &pIWbemServices);
-	if (FAILED(hr) || pIWbemServices == nullptr)
-		goto LCleanup;
-
-	// Switch security level to IMPERSONATE.
-	CoSetProxyBlanket(pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr,
-	                  RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE);
-
-	hr = pIWbemServices->CreateInstanceEnum(bstrClassName, 0, nullptr, &pEnumDevices);
-	if (FAILED(hr) || pEnumDevices == nullptr)
-		goto LCleanup;
-
-	// Loop over all devices
-	while (true)
-	{
-		// Get 20 at a time
-		hr = pEnumDevices->Next(10000, 20, pDevices, &uReturned);
-		if (FAILED(hr) || uReturned == 0)
-			break;
-
-		for (UINT iDevice = 0; iDevice < uReturned; ++iDevice)
-		{
-			// For each device, get its device ID
-			hr = pDevices[iDevice]->Get(bstrDeviceID, 0L, &var, nullptr, nullptr);
-			if (SUCCEEDED(hr) && var.vt == VT_BSTR && var.bstrVal != nullptr)
-			{
-				// Check if the device ID contains "IG_".  If it does, then it's an XInput device
-				// This information can not be found from DirectInput
-				if (wcsstr(var.bstrVal, L"IG_"))
-				{
-					// If it does, then get the VID/PID from var.bstrVal
-					DWORD dwPid = 0, dwVid = 0;
-					WCHAR* strVid = wcsstr(var.bstrVal, L"VID_");
-					if (strVid && swscanf(strVid, L"VID_%4X", &dwVid) != 1)
-						dwVid = 0;
-					WCHAR* strPid = wcsstr(var.bstrVal, L"PID_");
-					if (strPid && swscanf(strPid, L"PID_%4X", &dwPid) != 1)
-						dwPid = 0;
-
-					// Compare the VID/PID to the DInput device
-					DWORD dwVidPid = MAKELONG(dwVid, dwPid);
-					guids->push_back(dwVidPid);
-					//bIsXinputDevice = true;
-				}
-			}
-			SAFE_RELEASE(pDevices[iDevice]);
-		}
-	}
+  IWbemLocator* pIWbemLocator = nullptr;
+  IEnumWbemClassObject* pEnumDevices = nullptr;
+  IWbemClassObject* pDevices[20] = {0};
+  IWbemServices* pIWbemServices = nullptr;
+  BSTR bstrNamespace = nullptr;
+  BSTR bstrDeviceID = nullptr;
+  BSTR bstrClassName = nullptr;
+  DWORD uReturned = 0;
+  VARIANT var;
+  HRESULT hr;
+
+  // CoInit if needed
+  hr = CoInitialize(nullptr);
+  bool bCleanupCOM = SUCCEEDED(hr);
+
+  // Create WMI
+  hr = CoCreateInstance(__uuidof(WbemLocator), nullptr, CLSCTX_INPROC_SERVER,
+                        __uuidof(IWbemLocator), (LPVOID*)&pIWbemLocator);
+  if (FAILED(hr) || pIWbemLocator == nullptr)
+    goto LCleanup;
+
+  bstrNamespace = SysAllocString(L"\\\\.\\root\\cimv2");
+  if (bstrNamespace == nullptr)
+    goto LCleanup;
+  bstrClassName = SysAllocString(L"Win32_PNPEntity");
+  if (bstrClassName == nullptr)
+    goto LCleanup;
+  bstrDeviceID = SysAllocString(L"DeviceID");
+  if (bstrDeviceID == nullptr)
+    goto LCleanup;
+
+  // Connect to WMI
+  hr = pIWbemLocator->ConnectServer(bstrNamespace, nullptr, nullptr, 0L, 0L, nullptr, nullptr,
+                                    &pIWbemServices);
+  if (FAILED(hr) || pIWbemServices == nullptr)
+    goto LCleanup;
+
+  // Switch security level to IMPERSONATE.
+  CoSetProxyBlanket(pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr,
+                    RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE);
+
+  hr = pIWbemServices->CreateInstanceEnum(bstrClassName, 0, nullptr, &pEnumDevices);
+  if (FAILED(hr) || pEnumDevices == nullptr)
+    goto LCleanup;
+
+  // Loop over all devices
+  while (true)
+  {
+    // Get 20 at a time
+    hr = pEnumDevices->Next(10000, 20, pDevices, &uReturned);
+    if (FAILED(hr) || uReturned == 0)
+      break;
+
+    for (UINT iDevice = 0; iDevice < uReturned; ++iDevice)
+    {
+      // For each device, get its device ID
+      hr = pDevices[iDevice]->Get(bstrDeviceID, 0L, &var, nullptr, nullptr);
+      if (SUCCEEDED(hr) && var.vt == VT_BSTR && var.bstrVal != nullptr)
+      {
+        // Check if the device ID contains "IG_".  If it does, then it's an XInput device
+        // This information can not be found from DirectInput
+        if (wcsstr(var.bstrVal, L"IG_"))
+        {
+          // If it does, then get the VID/PID from var.bstrVal
+          DWORD dwPid = 0, dwVid = 0;
+          WCHAR* strVid = wcsstr(var.bstrVal, L"VID_");
+          if (strVid && swscanf(strVid, L"VID_%4X", &dwVid) != 1)
+            dwVid = 0;
+          WCHAR* strPid = wcsstr(var.bstrVal, L"PID_");
+          if (strPid && swscanf(strPid, L"PID_%4X", &dwPid) != 1)
+            dwPid = 0;
+
+          // Compare the VID/PID to the DInput device
+          DWORD dwVidPid = MAKELONG(dwVid, dwPid);
+          guids->push_back(dwVidPid);
+          // bIsXinputDevice = true;
+        }
+      }
+      SAFE_RELEASE(pDevices[iDevice]);
+    }
+  }
 
 LCleanup:
-	if (bstrNamespace)
-		SysFreeString(bstrNamespace);
-	if (bstrDeviceID)
-		SysFreeString(bstrDeviceID);
-	if (bstrClassName)
-		SysFreeString(bstrClassName);
-	for (UINT iDevice = 0; iDevice < 20; iDevice++)
-		SAFE_RELEASE(pDevices[iDevice]);
-	SAFE_RELEASE(pEnumDevices);
-	SAFE_RELEASE(pIWbemLocator);
-	SAFE_RELEASE(pIWbemServices);
-
-	if (bCleanupCOM)
-		CoUninitialize();
+  if (bstrNamespace)
+    SysFreeString(bstrNamespace);
+  if (bstrDeviceID)
+    SysFreeString(bstrDeviceID);
+  if (bstrClassName)
+    SysFreeString(bstrClassName);
+  for (UINT iDevice = 0; iDevice < 20; iDevice++)
+    SAFE_RELEASE(pDevices[iDevice]);
+  SAFE_RELEASE(pEnumDevices);
+  SAFE_RELEASE(pIWbemLocator);
+  SAFE_RELEASE(pIWbemServices);
+
+  if (bCleanupCOM)
+    CoUninitialize();
 }
-
 }
 }
 
diff --git a/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.h b/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.h
index 6506dd156e..be075deb9b 100644
--- a/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.h
+++ b/Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.h
@@ -4,15 +4,13 @@
 
 #pragma once
 
-#include <vector>
 #include <Windows.h>
+#include <vector>
 
 namespace ciface
 {
 namespace DInput
 {
-
 void GetXInputGUIDS(std::vector<DWORD>* guids);
-
 }
 }