jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Store name in RoccatControllers to avoid setting it in detectors

Browse source
This commit is contained in:
Adam Honse 2025-08-16 02:07:11 -05:00
parent c2e0bd496f
commit 079e344c5a
34 changed files with 333 additions and 304 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Controllers/RoccatController/RoccatBurstController/RGBController_RoccatBurst.cpp
View file

@ -27,10 +27,12 @@ RGBController_RoccatBurst::RGBController_RoccatBurst(RoccatBurstController* cont
{
controller = controller_ptr;
name = "Roccat Burst Core";
name = controller->GetNameString();
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Burst Core Mouse";
description = "Roccat Burst Mouse Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";

18
Controllers/RoccatController/RoccatBurstController/RoccatBurstController.cpp
View file

@ -13,11 +13,11 @@
#include "RoccatBurstController.h"
#include "StringUtils.h"
RoccatBurstController::RoccatBurstController(hid_device* dev_handle, const hid_device_info& info)
RoccatBurstController::RoccatBurstController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
{
dev = dev_handle;
version = "";
location = info.path;
name = dev_name;
SetupDirectMode();
}
@ -27,9 +27,14 @@ RoccatBurstController::~RoccatBurstController()
hid_close(dev);
}
std::string RoccatBurstController::GetFirmwareVersion()
std::string RoccatBurstController::GetDeviceLocation()
{
return version;
return("HID: " + location);
}
std::string RoccatBurstController::GetNameString()
{
return(name);
}
std::string RoccatBurstController::GetSerialString()
@ -45,11 +50,6 @@ std::string RoccatBurstController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatBurstController::GetDeviceLocation()
{
return("HID: " + location);
}
void RoccatBurstController::SetupDirectMode()
{
SwitchControl(true);

8
Controllers/RoccatController/RoccatBurstController/RoccatBurstController.h
View file

@ -44,12 +44,12 @@ enum
class RoccatBurstController
{
public:
RoccatBurstController(hid_device* dev_handle, const hid_device_info& info);
RoccatBurstController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~RoccatBurstController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
std::string GetNameString();
std::string GetSerialString();
void SetupDirectMode();
void SendDirect(std::vector<RGBColor> colors);
@ -63,7 +63,7 @@ public:
private:
hid_device* dev;
std::string location;
std::string version;
std::string name;
unsigned int CalculateCRC(unsigned char* bytes);
void SwitchControl(bool direct);

6
Controllers/RoccatController/RoccatBurstProAirController/RGBController_RoccatBurstProAir.cpp
View file

@ -26,10 +26,12 @@ RGBController_RoccatBurstProAir::RGBController_RoccatBurstProAir(RoccatBurstProA
{
controller = controller_ptr;
name = "Roccat Burst Pro Air";
name = controller->GetNameString();
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Burst Pro Air Mouse";
description = "Roccat Burst Pro Air Mouse Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";

18
Controllers/RoccatController/RoccatBurstProAirController/RoccatBurstProAirController.cpp
View file

@ -13,11 +13,11 @@
#include "RoccatBurstProAirController.h"
#include "StringUtils.h"
RoccatBurstProAirController::RoccatBurstProAirController(hid_device* dev_handle, const hid_device_info& info)
RoccatBurstProAirController::RoccatBurstProAirController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
{
dev = dev_handle;
version = "";
location = info.path;
name = dev_name;
}
RoccatBurstProAirController::~RoccatBurstProAirController()
@ -25,9 +25,14 @@ RoccatBurstProAirController::~RoccatBurstProAirController()
hid_close(dev);
}
std::string RoccatBurstProAirController::GetFirmwareVersion()
std::string RoccatBurstProAirController::GetDeviceLocation()
{
return version;
return("HID: " + location);
}
std::string RoccatBurstProAirController::GetNameString()
{
return(name);
}
std::string RoccatBurstProAirController::GetSerialString()
@ -43,11 +48,6 @@ std::string RoccatBurstProAirController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatBurstProAirController::GetDeviceLocation()
{
return("HID: " + location);
}
void RoccatBurstProAirController::SetColors(std::vector<RGBColor> colors)
{
unsigned char usb_buf[ROCCAT_BURST_PRO_AIR_REPORT_SIZE];

8
Controllers/RoccatController/RoccatBurstProAirController/RoccatBurstProAirController.h
View file

@ -37,12 +37,12 @@ enum
class RoccatBurstProAirController
{
public:
RoccatBurstProAirController(hid_device* dev_handle, const hid_device_info& info);
RoccatBurstProAirController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~RoccatBurstProAirController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
std::string GetNameString();
std::string GetSerialString();
void SetColors(std::vector<RGBColor> colors);
void SetModeValues(unsigned char mode_value, unsigned char speed, unsigned char brightness);
@ -50,5 +50,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string version;
std::string name;
};

69
Controllers/RoccatController/RoccatControllerDetect.cpp
View file

@ -72,9 +72,9 @@ void DetectRoccatMouseControllers(hid_device_info* info, const std::string& name
if(dev)
{
RoccatKoneAimoController * controller = new RoccatKoneAimoController(dev, info->path);
RoccatKoneAimoController * controller = new RoccatKoneAimoController(dev, info->path, name);
RGBController_RoccatKoneAimo * rgb_controller = new RGBController_RoccatKoneAimo(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -100,20 +100,20 @@ void DetectRoccatVulcanKeyboardControllers(hid_device_info* info, const std::str
| through it. This prevents detection from failing if interface 1 comes before interface 0 in the |
| main info list. |
\*-------------------------------------------------------------------------------------------------*/
hid_device* dev_ctrl = nullptr;
hid_device* dev_led = nullptr;
hid_device_info* info_full = hid_enumerate(info->vendor_id, info->product_id);
hid_device_info* info_temp = info_full;
hid_device* dev_ctrl = nullptr;
hid_device* dev_led = nullptr;
hid_device_info* info_full = hid_enumerate(info->vendor_id, info->product_id);
hid_device_info* info_temp = info_full;
/*--------------------------------------------------------------------------------------------*\
| Keep track of paths so they can be added to used_paths only if both interfaces can be found. |
\*--------------------------------------------------------------------------------------------*/
std::string dev_ctrl_path;
std::string dev_led_path;
std::string dev_ctrl_path;
std::string dev_led_path;
int dev_led_page;
int dev_ctrl_page;
int dev_led_page;
int dev_ctrl_page;
switch (info->product_id)
switch(info->product_id)
{
case ROCCAT_VULCAN_PRO_PID:
case ROCCAT_PYRO_PID:
@ -162,10 +162,11 @@ void DetectRoccatVulcanKeyboardControllers(hid_device_info* info, const std::str
if(dev_ctrl && dev_led)
{
RoccatVulcanKeyboardController * controller = new RoccatVulcanKeyboardController(dev_ctrl, dev_led, info->path, info->product_id);
RoccatVulcanKeyboardController * controller = new RoccatVulcanKeyboardController(dev_ctrl, dev_led, info->path, info->product_id, name);
RGBController_RoccatVulcanKeyboard * rgb_controller = new RGBController_RoccatVulcanKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
used_paths.insert(dev_ctrl_path);
used_paths.insert(dev_led_path);
}
@ -183,9 +184,9 @@ void DetectRoccatHordeAimoKeyboardControllers(hid_device_info* info, const std::
if(dev)
{
RoccatHordeAimoController * controller = new RoccatHordeAimoController(dev, *info);
RoccatHordeAimoController * controller = new RoccatHordeAimoController(dev, *info, name);
RGBController_RoccatHordeAimo * rgb_controller = new RGBController_RoccatHordeAimo(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -196,9 +197,9 @@ void DetectRoccatBurstCoreControllers(hid_device_info* info, const std::string&
if(dev)
{
RoccatBurstController * controller = new RoccatBurstController(dev, *info);
RoccatBurstController * controller = new RoccatBurstController(dev, *info, name);
RGBController_RoccatBurst * rgb_controller = new RGBController_RoccatBurst(controller, ROCCAT_BURST_CORE_NUMBER_OF_LEDS);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -209,9 +210,9 @@ void DetectRoccatBurstProControllers(hid_device_info* info, const std::string& n
if(dev)
{
RoccatBurstController * controller = new RoccatBurstController(dev, *info);
RoccatBurstController * controller = new RoccatBurstController(dev, *info, name);
RGBController_RoccatBurst * rgb_controller = new RGBController_RoccatBurst(controller, ROCCAT_BURST_PRO_NUMBER_OF_LEDS);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -222,9 +223,9 @@ void DetectRoccatBurstProAirControllers(hid_device_info* info, const std::string
if(dev)
{
RoccatBurstProAirController * controller = new RoccatBurstProAirController(dev, *info);
RoccatBurstProAirController * controller = new RoccatBurstProAirController(dev, *info, name);
RGBController_RoccatBurstProAir * rgb_controller = new RGBController_RoccatBurstProAir(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -235,9 +236,9 @@ void DetectRoccatKoneProControllers(hid_device_info* info, const std::string& na
if(dev)
{
RoccatKoneProController * controller = new RoccatKoneProController(dev, *info);
RoccatKoneProController * controller = new RoccatKoneProController(dev, *info, name);
RGBController_RoccatKonePro * rgb_controller = new RGBController_RoccatKonePro(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -248,9 +249,9 @@ void DetectRoccatKoneProAirControllers(hid_device_info* info, const std::string&
if(dev)
{
RoccatKoneProAirController * controller = new RoccatKoneProAirController(dev, *info);
RoccatKoneProAirController * controller = new RoccatKoneProAirController(dev, *info, name);
RGBController_RoccatKoneProAir * rgb_controller = new RGBController_RoccatKoneProAir(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -261,9 +262,9 @@ void DetectRoccatKoneXPControllers(hid_device_info* info, const std::string& nam
if(dev)
{
RoccatKoneXPController * controller = new RoccatKoneXPController(dev, info->path);
RoccatKoneXPController * controller = new RoccatKoneXPController(dev, info->path, name);
RGBController_RoccatKoneXP * rgb_controller = new RGBController_RoccatKoneXP(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -274,9 +275,9 @@ void DetectRoccatKovaControllers(hid_device_info* info, const std::string& name)
if(dev)
{
RoccatKovaController * controller = new RoccatKovaController(dev, info->path);
RoccatKovaController * controller = new RoccatKovaController(dev, info->path, name);
RGBController_RoccatKova * rgb_controller = new RGBController_RoccatKova(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -287,9 +288,9 @@ void DetectRoccatEloControllers(hid_device_info* info, const std::string& name)
if(dev)
{
RoccatEloController * controller = new RoccatEloController(dev, *info);
RoccatEloController * controller = new RoccatEloController(dev, *info, name);
RGBController_RoccatElo * rgb_controller = new RGBController_RoccatElo(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -300,9 +301,9 @@ void DetectRoccatSenseAimoControllers(hid_device_info* info, const std::string&
if(dev)
{
RoccatSenseAimoController * controller = new RoccatSenseAimoController(dev, info->path);
RoccatSenseAimoController * controller = new RoccatSenseAimoController(dev, info->path, name);
RGBController_RoccatSenseAimo * rgb_controller = new RGBController_RoccatSenseAimo(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}

6
Controllers/RoccatController/RoccatEloController/RGBController_RoccatElo.cpp
View file

@ -27,13 +27,13 @@
RGBController_RoccatElo::RGBController_RoccatElo(RoccatEloController* controller_ptr)
{
controller = controller_ptr;
name = "Roccat Elo 7.1";
name = controller->GetNameString();
vendor = "Roccat";
type = DEVICE_TYPE_HEADSET;
description = name;
description = "Roccat Elo 7.1 Headset Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
version = "";
mode Direct;
Direct.name = "Direct";

9
Controllers/RoccatController/RoccatEloController/RoccatEloController.cpp
View file

@ -14,11 +14,11 @@
#include "RoccatEloController.h"
#include "StringUtils.h"
RoccatEloController::RoccatEloController(hid_device* dev_handle, const hid_device_info& info)
RoccatEloController::RoccatEloController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
{
dev = dev_handle;
location = info.path;
version = "";
name = dev_name;
SendInit();
}
@ -33,6 +33,11 @@ std::string RoccatEloController::GetDeviceLocation()
return("HID: " + location);
}
std::string RoccatEloController::GetNameString()
{
return(name);
}
std::string RoccatEloController::GetSerialString()
{
wchar_t serial_string[128];

7
Controllers/RoccatController/RoccatEloController/RoccatEloController.h
View file

@ -22,18 +22,19 @@
class RoccatEloController
{
public:
RoccatEloController(hid_device* dev_handle, const hid_device_info& info);
RoccatEloController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~RoccatEloController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString();
void SendDirect(RGBColor color);
private:
hid_device* dev;
std::string location;
std::string version;
std::string name;
void SendInit();
};

6
Controllers/RoccatController/RoccatHordeAimoController/RGBController_RoccatHordeAimo.cpp
View file

@ -26,10 +26,12 @@ RGBController_RoccatHordeAimo::RGBController_RoccatHordeAimo(RoccatHordeAimoCont
{
controller = controller_ptr;
name = "Roccat Horde Aimo";
name = controller->GetNameString();
vendor = "Roccat";
type = DEVICE_TYPE_KEYBOARD;
description = "Roccat Horde Aimo Keyboard";
description = "Roccat Horde Aimo Keyboard Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";

18
Controllers/RoccatController/RoccatHordeAimoController/RoccatHordeAimoController.cpp
View file

@ -13,11 +13,11 @@
#include "RoccatHordeAimoController.h"
#include "StringUtils.h"
RoccatHordeAimoController::RoccatHordeAimoController(hid_device* dev_handle, const hid_device_info& info)
RoccatHordeAimoController::RoccatHordeAimoController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
{
dev = dev_handle;
version = "";
location = info.path;
name = dev_name;
InitialPacket();
}
@ -40,9 +40,14 @@ void RoccatHordeAimoController::InitialPacket()
hid_send_feature_report(dev, usb_buf, 8);
}
std::string RoccatHordeAimoController::GetFirmwareVersion()
std::string RoccatHordeAimoController::GetDeviceLocation()
{
return version;
return("HID: " + location);
}
std::string RoccatHordeAimoController::GetNameString()
{
return(name);
}
std::string RoccatHordeAimoController::GetSerialString()
@ -58,11 +63,6 @@ std::string RoccatHordeAimoController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatHordeAimoController::GetDeviceLocation()
{
return("HID: " + location);
}
void RoccatHordeAimoController::SetColors(std::vector<RGBColor> colors)
{
unsigned char usb_buf[WRITE_PACKET_LENGTH];

8
Controllers/RoccatController/RoccatHordeAimoController/RoccatHordeAimoController.h
View file

@ -22,19 +22,19 @@
class RoccatHordeAimoController
{
public:
RoccatHordeAimoController(hid_device* dev_handle, const hid_device_info& info);
RoccatHordeAimoController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~RoccatHordeAimoController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
std::string GetNameString();
std::string GetSerialString();
void SetColors(std::vector<RGBColor> colors);
private:
hid_device* dev;
std::string location;
std::string version;
std::string name;
void InitialPacket();
};

30
Controllers/RoccatController/RoccatKoneAimoController/RGBController_RoccatKoneAimo.cpp
View file

@ -24,26 +24,26 @@
RGBController_RoccatKoneAimo::RGBController_RoccatKoneAimo(RoccatKoneAimoController* controller_ptr)
{
controller = controller_ptr;
controller = controller_ptr;
name = "Roccat Kone Aimo";
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kone Aimo Mouse";
location = controller->GetLocation();
serial = controller->GetSerial();
name = controller->GetName();
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kone Aimo Mouse Device";
location = controller->GetLocation();
serial = controller->GetSerial();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.speed_min = 0;
Direct.speed_max = 0;
Direct.speed = 0;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.speed_min = 0;
Direct.speed_max = 0;
Direct.speed = 0;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
active_mode = 0;
active_mode = 0;
SetupZones();
}

22
Controllers/RoccatController/RoccatKoneAimoController/RoccatKoneAimoController.cpp
View file

@ -13,21 +13,11 @@
#include "RoccatKoneAimoController.h"
#include "StringUtils.h"
RoccatKoneAimoController::RoccatKoneAimoController(hid_device* dev_handle, char *_path)
RoccatKoneAimoController::RoccatKoneAimoController(hid_device* dev_handle, char *_path, std::string dev_name)
{
dev = dev_handle;
location = _path;
/*---------------------------------------------------------*\
| Get device name from HID manufacturer and product strings |
\*---------------------------------------------------------*/
wchar_t name_string[HID_MAX_STR];
hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
device_name = StringUtils::wstring_to_string(name_string);
hid_get_product_string(dev, name_string, HID_MAX_STR);
device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
dev = dev_handle;
location = _path;
name = dev_name;
/*-----------------------------------------------------*\
| Init usb buffer to 0 and add first two bytes |
@ -44,9 +34,9 @@ RoccatKoneAimoController::~RoccatKoneAimoController()
hid_close(dev);
}
std::string RoccatKoneAimoController::GetDeviceName()
std::string RoccatKoneAimoController::GetName()
{
return device_name;
return(name);
}
std::string RoccatKoneAimoController::GetSerial()

8
Controllers/RoccatController/RoccatKoneAimoController/RoccatKoneAimoController.h
View file

@ -39,19 +39,19 @@ enum ROCCAT_KONE_AIMO_CHANNEL
class RoccatKoneAimoController
{
public:
RoccatKoneAimoController(hid_device* dev_handle, char *_path);
RoccatKoneAimoController(hid_device* dev_handle, char *_path, std::string dev_name);
~RoccatKoneAimoController();
std::string GetDeviceName();
std::string GetSerial();
std::string GetLocation();
std::string GetName();
std::string GetSerial();
void SetChannelColors(ROCCAT_KONE_AIMO_CHANNEL channel, RGBColor * colors, unsigned int num_colors);
void SendUpdate();
private:
std::string device_name;
std::string location;
std::string name;
hid_device* dev;
unsigned char usb_colors_buf[USB_COLOR_BUFF_LEN]; // USB buffer to be sent everytime we update mouse's LEDs

5
Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.cpp
View file

@ -26,13 +26,12 @@ RGBController_RoccatKoneProAir::RGBController_RoccatKoneProAir(RoccatKoneProAirC
{
controller = controller_ptr;
name = "Roccat Kone Pro Air";
name = controller->GetNameString();
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kone Pro Air Mouse";
description = "Roccat Kone Pro Air Mouse Device";
serial = controller->GetSerialString();
location = controller->GetDeviceLocation();
version = controller->GetFirmwareVersion();
mode Direct;
Direct.name = "Direct";

18
Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.cpp
View file

@ -13,11 +13,11 @@
#include "RoccatKoneProAirController.h"
#include "StringUtils.h"
RoccatKoneProAirController::RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info)
RoccatKoneProAirController::RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
{
dev = dev_handle;
version = "";
location = info.path;
name = dev_name;
}
RoccatKoneProAirController::~RoccatKoneProAirController()
@ -25,9 +25,14 @@ RoccatKoneProAirController::~RoccatKoneProAirController()
hid_close(dev);
}
std::string RoccatKoneProAirController::GetFirmwareVersion()
std::string RoccatKoneProAirController::GetDeviceLocation()
{
return version;
return("HID: " + location);
}
std::string RoccatKoneProAirController::GetNameString()
{
return(name);
}
std::string RoccatKoneProAirController::GetSerialString()
@ -43,11 +48,6 @@ std::string RoccatKoneProAirController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatKoneProAirController::GetDeviceLocation()
{
return("HID: " + location);
}
void RoccatKoneProAirController::SendDirect(std::vector<RGBColor> colors)
{
SendRGB(true, colors, ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE, ROCCAT_KONE_PRO_AIR_SPEED_MAX, ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX);

8
Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.h
View file

@ -43,12 +43,12 @@ enum
class RoccatKoneProAirController
{
public:
RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info);
RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~RoccatKoneProAirController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
std::string GetNameString();
std::string GetSerialString();
void SendDirect(std::vector<RGBColor> colors);
void SetMode(std::vector<RGBColor> colors, unsigned char mode_value, unsigned char speed, unsigned char brightness, unsigned int mode_flags);
@ -56,7 +56,7 @@ public:
private:
hid_device* dev;
std::string location;
std::string version;
std::string name;
void SendRGB(bool direct, std::vector<RGBColor> colors, unsigned char mode_value, unsigned char speed, unsigned char brightness);
};

5
Controllers/RoccatController/RoccatKoneProController/RGBController_RoccatKonePro.cpp
View file

@ -26,13 +26,12 @@ RGBController_RoccatKonePro::RGBController_RoccatKonePro(RoccatKoneProController
{
controller = controller_ptr;
name = "Roccat Kone Pro";
name = controller->GetNameString();
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kone Pro Mouse";
description = "Roccat Kone Pro Mouse Device";
serial = controller->GetSerialString();
location = controller->GetDeviceLocation();
version = controller->GetFirmwareVersion();
// Also known as "Intelligent Lighting System" mode in Roccat Swarm
mode Direct;

18
Controllers/RoccatController/RoccatKoneProController/RoccatKoneProController.cpp
View file

@ -13,11 +13,11 @@
#include "RoccatKoneProController.h"
#include "StringUtils.h"
RoccatKoneProController::RoccatKoneProController(hid_device* dev_handle, const hid_device_info& info)
RoccatKoneProController::RoccatKoneProController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
{
dev = dev_handle;
version = "";
location = info.path;
name = dev_name;
SetupDirectMode();
}
@ -27,9 +27,14 @@ RoccatKoneProController::~RoccatKoneProController()
hid_close(dev);
}
std::string RoccatKoneProController::GetFirmwareVersion()
std::string RoccatKoneProController::GetDeviceLocation()
{
return version;
return("HID: " + location);
}
std::string RoccatKoneProController::GetNameString()
{
return(name);
}
std::string RoccatKoneProController::GetSerialString()
@ -45,11 +50,6 @@ std::string RoccatKoneProController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatKoneProController::GetDeviceLocation()
{
return("HID: " + location);
}
void RoccatKoneProController::SetupDirectMode()
{
SwitchControl(true);

8
Controllers/RoccatController/RoccatKoneProController/RoccatKoneProController.h
View file

@ -44,12 +44,12 @@ enum
class RoccatKoneProController
{
public:
RoccatKoneProController(hid_device* dev_handle, const hid_device_info& info);
RoccatKoneProController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~RoccatKoneProController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
std::string GetNameString();
std::string GetSerialString();
void SetupDirectMode();
void SendDirect(std::vector<RGBColor> colors);
@ -63,7 +63,7 @@ public:
private:
hid_device* dev;
std::string location;
std::string version;
std::string name;
unsigned int CalculateCRC(unsigned char* bytes);
void SwitchControl(bool direct);

54
Controllers/RoccatController/RoccatKoneXPController/RGBController_RoccatKoneXP.cpp
View file

@ -24,16 +24,15 @@
RGBController_RoccatKoneXP::RGBController_RoccatKoneXP(RoccatKoneXPController* controller_ptr)
{
controller = controller_ptr;
name = "Roccat Kone XP";
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kone XP Mouse";
version = controller->GetVersion();
location = controller->GetLocation();
serial = controller->GetSerial();
controller = controller_ptr;
name = controller->GetName();
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kone XP Mouse Device";
version = controller->GetVersion();
location = controller->GetLocation();
serial = controller->GetSerial();
mode Direct;
Direct.name = "Direct";
@ -43,10 +42,10 @@ RGBController_RoccatKoneXP::RGBController_RoccatKoneXP(RoccatKoneXPController* c
modes.push_back(Direct);
mode Off;
Off.name = "Off";
Off.value = ROCCAT_KONE_XP_MODE_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
Off.name = "Off";
Off.value = ROCCAT_KONE_XP_MODE_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
@ -112,27 +111,26 @@ RGBController_RoccatKoneXP::RGBController_RoccatKoneXP(RoccatKoneXPController* c
modes.push_back(Heartbeat);
mode Photon;
Photon.name = "Photon FX";
Photon.value = ROCCAT_KONE_XP_MODE_PHOTON_FX;
Photon.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Photon.color_mode = MODE_COLORS_NONE;
Photon.brightness = ROCCAT_KONE_XP_BRIGHTNESS_DEFAULT;
Photon.brightness_min = ROCCAT_KONE_XP_BRIGHTNESS_MIN;
Photon.brightness_max = ROCCAT_KONE_XP_BRIGHTNESS_MAX;
Photon.name = "Photon FX";
Photon.value = ROCCAT_KONE_XP_MODE_PHOTON_FX;
Photon.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Photon.color_mode = MODE_COLORS_NONE;
Photon.brightness = ROCCAT_KONE_XP_BRIGHTNESS_DEFAULT;
Photon.brightness_min = ROCCAT_KONE_XP_BRIGHTNESS_MIN;
Photon.brightness_max = ROCCAT_KONE_XP_BRIGHTNESS_MAX;
modes.push_back(Photon);
/*---------------------------------------------------------------------*\
| This is the default mode for software modes, while swarm isn't active |
\*---------------------------------------------------------------------*/
mode Default;
Default.name = "Default";
Default.value = ROCCAT_KONE_XP_MODE_DEFAULT;
Default.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Default.color_mode = MODE_COLORS_NONE;
Default.brightness = ROCCAT_KONE_XP_BRIGHTNESS_DEFAULT;
Default.brightness_min = ROCCAT_KONE_XP_BRIGHTNESS_MIN;
Default.brightness_max = ROCCAT_KONE_XP_BRIGHTNESS_MAX;
Default.name = "Default";
Default.value = ROCCAT_KONE_XP_MODE_DEFAULT;
Default.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Default.color_mode = MODE_COLORS_NONE;
Default.brightness = ROCCAT_KONE_XP_BRIGHTNESS_DEFAULT;
Default.brightness_min = ROCCAT_KONE_XP_BRIGHTNESS_MIN;
Default.brightness_max = ROCCAT_KONE_XP_BRIGHTNESS_MAX;
modes.push_back(Default);
SetupZones();

50
Controllers/RoccatController/RoccatKoneXPController/RoccatKoneXPController.cpp
View file

@ -16,10 +16,11 @@
#include "RoccatKoneXPController.h"
#include "StringUtils.h"
RoccatKoneXPController::RoccatKoneXPController(hid_device* dev_handle, char *path)
RoccatKoneXPController::RoccatKoneXPController(hid_device* dev_handle, char *path, std::string dev_name)
{
dev = dev_handle;
location = path;
dev = dev_handle;
location = path;
name = dev_name;
}
RoccatKoneXPController::~RoccatKoneXPController()
@ -27,6 +28,30 @@ RoccatKoneXPController::~RoccatKoneXPController()
hid_close(dev);
}
std::string RoccatKoneXPController::GetLocation()
{
return("HID: " + location);
}
std::string RoccatKoneXPController::GetName()
{
return(name);
}
std::string RoccatKoneXPController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatKoneXPController::GetVersion()
{
uint8_t buf[9] = { 0x09 };
@ -44,25 +69,6 @@ std::string RoccatKoneXPController::GetVersion()
return std::string(version);
}
std::string RoccatKoneXPController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatKoneXPController::GetLocation()
{
return("HID: " + location);
}
uint8_t RoccatKoneXPController::GetActiveProfile()
{
uint8_t buf[4] = { 0x05 };

6
Controllers/RoccatController/RoccatKoneXPController/RoccatKoneXPController.h
View file

@ -78,11 +78,12 @@ struct roccat_kone_xp_mode_struct
class RoccatKoneXPController
{
public:
RoccatKoneXPController(hid_device* dev_handle, char *path);
RoccatKoneXPController(hid_device* dev_handle, char *path, std::string dev_name);
~RoccatKoneXPController();
std::string GetSerial();
std::string GetLocation();
std::string GetName();
std::string GetSerial();
std::string GetVersion();
uint8_t GetActiveProfile();
@ -98,4 +99,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

8
Controllers/RoccatController/RoccatKovaController/RGBController_RoccatKova.cpp
View file

@ -29,13 +29,13 @@ RGBController_RoccatKova::RGBController_RoccatKova(RoccatKovaController* control
{
controller = controller_ptr;
type = DEVICE_TYPE_MOUSE;
name = "Roccat Kova";
name = controller->GetName();
vendor = "Roccat";
description = "Controller compatible with the Roccat Kova gaming mouse";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kova Mouse Device";
serial = controller->GetSerial();
location = controller->GetLocation();
version = controller->GetFirmwareVersion();
version = controller->GetVersion();
mode Static;
Static.name = "Static";

24
Controllers/RoccatController/RoccatKovaController/RoccatKovaController.cpp
View file

@ -14,10 +14,11 @@
#include "RoccatKovaController.h"
#include "StringUtils.h"
RoccatKovaController::RoccatKovaController(hid_device* dev_handle, char *path)
RoccatKovaController::RoccatKovaController(hid_device* dev_handle, char *path, std::string dev_name)
{
dev = dev_handle;
location = path;
dev = dev_handle;
location = path;
name = dev_name;
SendInitialPacket();
FetchFirmwareVersion();
@ -30,7 +31,12 @@ RoccatKovaController::~RoccatKovaController()
std::string RoccatKovaController::GetLocation()
{
return ("HID: " + location);
return("HID: " + location);
}
std::string RoccatKovaController::GetName()
{
return(name);
}
std::string RoccatKovaController::GetSerial()
@ -46,9 +52,9 @@ std::string RoccatKovaController::GetSerial()
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatKovaController::GetFirmwareVersion()
std::string RoccatKovaController::GetVersion()
{
return firmware_version;
return(version);
}
void RoccatKovaController::SetColor(RGBColor color_wheel,
@ -118,10 +124,10 @@ void RoccatKovaController::FetchFirmwareVersion()
hid_get_feature_report(dev, buf, ROCCAT_KOVA_VERSION_READ_PACKET_SIZE);
uint8_t version = buf[ROCCAT_KOVA_FIRMWARE_VERSION_IDX];
uint8_t fw_version = buf[ROCCAT_KOVA_FIRMWARE_VERSION_IDX];
char version_str[5] {00};
snprintf(version_str, 5, "%.2f", version / 100.);
firmware_version = version_str;
snprintf(version_str, 5, "%.2f", fw_version / 100.);
version = version_str;
}
void RoccatKovaController::FetchProfileData(uint8_t *buf)

8
Controllers/RoccatController/RoccatKovaController/RoccatKovaController.h
View file

@ -65,12 +65,13 @@ enum
class RoccatKovaController
{
public:
RoccatKovaController(hid_device* dev_handle, char *path);
RoccatKovaController(hid_device* dev_handle, char *path, std::string dev_name);
~RoccatKovaController();
std::string GetLocation();
std::string GetName();
std::string GetSerial();
std::string GetFirmwareVersion();
std::string GetVersion();
void SetColor(RGBColor color_wheel,
RGBColor color_stripe,
@ -81,7 +82,8 @@ public:
private:
hid_device* dev;
std::string location;
std::string firmware_version;
std::string name;
std::string version;
void SendInitialPacket();
void FetchProfileData(uint8_t *buf);

17
Controllers/RoccatController/RoccatSenseAimoController/RGBController_RoccatSenseAimo.cpp
View file

@ -24,15 +24,15 @@
RGBController_RoccatSenseAimo::RGBController_RoccatSenseAimo(RoccatSenseAimoController* controller_ptr)
{
controller = controller_ptr;
controller = controller_ptr;
name = "Roccat Sense Aimo";
vendor = "Roccat";
type = DEVICE_TYPE_MOUSEMAT;
description = "Roccat Sense Aimo Mousepad";
version = controller->GetVersion();
location = controller->GetLocation();
serial = controller->GetSerial();
name = controller->GetName();
vendor = "Roccat";
type = DEVICE_TYPE_MOUSEMAT;
description = "Roccat Sense Aimo Mousepad Device";
version = controller->GetVersion();
location = controller->GetLocation();
serial = controller->GetSerial();
mode Direct;
Direct.name = "Direct";
@ -93,7 +93,6 @@ RGBController_RoccatSenseAimo::RGBController_RoccatSenseAimo(RoccatSenseAimoCont
/*---------------------------------------------------------------------*\
| This is the default mode for software modes, while swarm isn't active |
\*---------------------------------------------------------------------*/
mode Default;
Default.name = "Default";
Default.value = ROCCAT_SENSE_AIMO_MODE_DEFAULT;

48
Controllers/RoccatController/RoccatSenseAimoController/RoccatSenseAimoController.cpp
View file

@ -14,10 +14,11 @@
#include "RoccatSenseAimoController.h"
#include "StringUtils.h"
RoccatSenseAimoController::RoccatSenseAimoController(hid_device* dev_handle, char *path)
RoccatSenseAimoController::RoccatSenseAimoController(hid_device* dev_handle, char *path, std::string dev_name)
{
dev = dev_handle;
location = path;
dev = dev_handle;
location = path;
name = dev_name;
}
RoccatSenseAimoController::~RoccatSenseAimoController()
@ -25,6 +26,29 @@ RoccatSenseAimoController::~RoccatSenseAimoController()
hid_close(dev);
}
std::string RoccatSenseAimoController::GetLocation()
{
return("HID: " + location);
}
std::string RoccatSenseAimoController::GetName()
{
return(name);
}
std::string RoccatSenseAimoController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatSenseAimoController::GetVersion()
{
uint8_t buf[8] = { 0x01 };
@ -42,24 +66,6 @@ std::string RoccatSenseAimoController::GetVersion()
return std::string(version);
}
std::string RoccatSenseAimoController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatSenseAimoController::GetLocation()
{
return("HID: " + location);
}
mode_struct RoccatSenseAimoController::GetMode()
{
uint8_t buf[19] = { 0x02 };

6
Controllers/RoccatController/RoccatSenseAimoController/RoccatSenseAimoController.h
View file

@ -47,11 +47,12 @@ struct mode_struct
class RoccatSenseAimoController
{
public:
RoccatSenseAimoController(hid_device* dev_handle, char *path);
RoccatSenseAimoController(hid_device* dev_handle, char *path, std::string dev_name);
~RoccatSenseAimoController();
std::string GetSerial();
std::string GetLocation();
std::string GetName();
std::string GetSerial();
std::string GetVersion();
mode_struct GetMode();
@ -62,4 +63,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

82
Controllers/RoccatController/RoccatVulcanKeyboardController/RGBController_RoccatVulcanKeyboard.cpp
View file

@ -30,67 +30,67 @@
RGBController_RoccatVulcanKeyboard::RGBController_RoccatVulcanKeyboard(RoccatVulcanKeyboardController* controller_ptr)
{
controller = controller_ptr;
controller = controller_ptr;
pid = controller->device_pid;
pid = controller->device_pid;
controller->InitDeviceInfo();
name = "Roccat Vulcan Keyboard";
vendor = "Roccat";
type = DEVICE_TYPE_KEYBOARD;
description = "Roccat Vulcan Keyboard";
version = controller->GetDeviceInfo().version;
location = controller->GetLocation();
serial = controller->GetSerial();
name = controller->GetName();
vendor = "Roccat";
type = DEVICE_TYPE_KEYBOARD;
description = "Roccat Vulcan Keyboard Device";
version = controller->GetDeviceInfo().version;
location = controller->GetLocation();
serial = controller->GetSerial();
mode Direct;
Direct.name = "Direct";
Direct.value = ROCCAT_VULCAN_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.name = "Direct";
Direct.value = ROCCAT_VULCAN_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
if(pid != ROCCAT_VULCAN_120_AIMO_PID && pid != ROCCAT_VULCAN_100_AIMO_PID)
{
Direct.flags |= MODE_FLAG_HAS_BRIGHTNESS;
Direct.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Direct.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Direct.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Direct.flags |= MODE_FLAG_HAS_BRIGHTNESS;
Direct.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Direct.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Direct.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
}
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = ROCCAT_VULCAN_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Static.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Static.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Static.color_mode = MODE_COLORS_PER_LED;
Static.name = "Static";
Static.value = ROCCAT_VULCAN_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Static.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Static.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = ROCCAT_VULCAN_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Wave.speed_min = ROCCAT_VULCAN_SPEED_MIN;
Wave.speed_max = ROCCAT_VULCAN_SPEED_MAX;
Wave.speed = ROCCAT_VULCAN_SPEED_DEFAULT;
Wave.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Wave.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Wave.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Wave.color_mode = MODE_COLORS_NONE;
Wave.name = "Rainbow Wave";
Wave.value = ROCCAT_VULCAN_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Wave.speed_min = ROCCAT_VULCAN_SPEED_MIN;
Wave.speed_max = ROCCAT_VULCAN_SPEED_MAX;
Wave.speed = ROCCAT_VULCAN_SPEED_DEFAULT;
Wave.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Wave.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Wave.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
mode Default;
Default.name = "Default";
Default.value = ROCCAT_VULCAN_MODE_DEFAULT;
Default.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Default.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Default.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Default.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Default.color_mode = MODE_COLORS_NONE;
Default.name = "Default";
Default.value = ROCCAT_VULCAN_MODE_DEFAULT;
Default.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Default.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Default.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Default.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Default.color_mode = MODE_COLORS_NONE;
modes.push_back(Default);
SetupZones();

19
Controllers/RoccatController/RoccatVulcanKeyboardController/RoccatVulcanKeyboardController.cpp
View file

@ -18,11 +18,12 @@
#include "RoccatVulcanKeyboardController.h"
#include "StringUtils.h"
RoccatVulcanKeyboardController::RoccatVulcanKeyboardController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path, uint16_t pid)
RoccatVulcanKeyboardController::RoccatVulcanKeyboardController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path, uint16_t pid, std::string dev_name)
{
dev_ctrl = dev_ctrl_handle;
dev_led = dev_led_handle;
location = path;
name = dev_name;
device_pid = pid;
}
@ -32,6 +33,16 @@ RoccatVulcanKeyboardController::~RoccatVulcanKeyboardController()
hid_close(dev_led);
}
std::string RoccatVulcanKeyboardController::GetLocation()
{
return("HID: " + location);
}
std::string RoccatVulcanKeyboardController::GetName()
{
return(name);
}
std::string RoccatVulcanKeyboardController::GetSerial()
{
wchar_t serial_string[128];
@ -45,12 +56,6 @@ std::string RoccatVulcanKeyboardController::GetSerial()
return(StringUtils::wstring_to_string(serial_string));
}
std::string RoccatVulcanKeyboardController::GetLocation()
{
return("HID: " + location);
}
device_info RoccatVulcanKeyboardController::InitDeviceInfo()
{
uint8_t packet_length;

6
Controllers/RoccatController/RoccatVulcanKeyboardController/RoccatVulcanKeyboardController.h
View file

@ -70,11 +70,12 @@ struct led_color
class RoccatVulcanKeyboardController
{
public:
RoccatVulcanKeyboardController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path, uint16_t pid);
RoccatVulcanKeyboardController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path, uint16_t pid, std::string dev_name);
~RoccatVulcanKeyboardController();
std::string GetSerial();
std::string GetLocation();
std::string GetName();
device_info InitDeviceInfo();
device_info GetDeviceInfo();
@ -88,8 +89,9 @@ public:
uint16_t device_pid;
private:
std::string location;
hid_device* dev_ctrl;
hid_device* dev_led;
device_info dev_info;
std::string location;
std::string name;
};