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

Store name in SinowealthControllers to avoid setting it in detectors

Browse source
This commit is contained in:
Adam Honse 2025-08-16 01:08:09 -05:00
parent f1a050a503
commit c2e0bd496f
23 changed files with 538 additions and 490 deletions
Download patch file Download diff file Expand all files Collapse all files

14
Controllers/SinowealthController/GenesisXenon200Controller/GenesisXenon200Controller.cpp
View file

@ -11,11 +11,12 @@
#include "GenesisXenon200Controller.h" #include "GenesisXenon200Controller.h"
GenesisXenon200Controller::GenesisXenon200Controller(hid_device* dev_handle, hid_device* cmd_dev_handle, const char* path) GenesisXenon200Controller::GenesisXenon200Controller(hid_device* dev_handle, hid_device* cmd_dev_handle, const char* path, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
cmd_dev = cmd_dev_handle; cmd_dev = cmd_dev_handle;
location = path; location = path;
name = dev_name;
} }
GenesisXenon200Controller::~GenesisXenon200Controller() GenesisXenon200Controller::~GenesisXenon200Controller()
@ -28,6 +29,11 @@ std::string GenesisXenon200Controller::GetLocationString()
return("HID: " + location); return("HID: " + location);
} }
std::string GenesisXenon200Controller::GetNameString()
{
return(name);
}
void GenesisXenon200Controller::SaveMode(unsigned char mode, unsigned char value, RGBColor color) void GenesisXenon200Controller::SaveMode(unsigned char mode, unsigned char value, RGBColor color)
{ {
unsigned char usb_buf[154]; unsigned char usb_buf[154];

8
Controllers/SinowealthController/GenesisXenon200Controller/GenesisXenon200Controller.h
View file

@ -17,13 +17,17 @@
class GenesisXenon200Controller class GenesisXenon200Controller
{ {
public: public:
GenesisXenon200Controller(hid_device* dev_handle, hid_device* cmd_dev_handle, const char* path); GenesisXenon200Controller(hid_device* dev_handle, hid_device* cmd_dev_handle, const char* path, std::string dev_name);
~GenesisXenon200Controller(); ~GenesisXenon200Controller();
void SaveMode(unsigned char mode, unsigned char value, RGBColor color);
std::string GetLocationString(); std::string GetLocationString();
std::string GetNameString();
void SaveMode(unsigned char mode, unsigned char value, RGBColor color);
private: private:
hid_device* dev; hid_device* dev;
hid_device* cmd_dev; hid_device* cmd_dev;
std::string location; std::string location;
std::string name;
}; };

70
Controllers/SinowealthController/GenesisXenon200Controller/RGBController_GenesisXenon200.cpp
View file

@ -23,55 +23,55 @@
RGBController_GenesisXenon200::RGBController_GenesisXenon200(GenesisXenon200Controller* controller_ptr) RGBController_GenesisXenon200::RGBController_GenesisXenon200(GenesisXenon200Controller* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "Genesis Xenon 200"; name = controller->GetNameString();
vendor = "Genesis"; vendor = "Genesis";
description = "Genesis Xenon 200 Mouse"; description = "Genesis Xenon 200 Mouse Device";
type = DEVICE_TYPE_MOUSE; type = DEVICE_TYPE_MOUSE;
location = controller->GetLocationString(); location = controller->GetLocationString();
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.value = GENESIS_XENON_200_MODE_STATIC; Static.value = GENESIS_XENON_200_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE; Static.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC; Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.brightness = 1; Static.brightness = 1;
Static.brightness_min = 0; Static.brightness_min = 0;
Static.brightness_max = 2; Static.brightness_max = 2;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
Static.colors.resize(1); Static.colors.resize(1);
modes.push_back(Static); modes.push_back(Static);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = GENESIS_XENON_200_MODE_BREATHING; Breathing.value = GENESIS_XENON_200_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE; Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = 1; Breathing.speed = 1;
Breathing.speed_min = 0; Breathing.speed_min = 0;
Breathing.speed_max = 2; Breathing.speed_max = 2;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 1; Breathing.colors_max = 1;
Breathing.colors.resize(1); Breathing.colors.resize(1);
modes.push_back(Breathing); modes.push_back(Breathing);
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = GENESIS_XENON_200_MODE_SPECTRUM_CYCLE; SpectrumCycle.value = GENESIS_XENON_200_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.color_mode = MODE_COLORS_NONE; SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.speed = 1; SpectrumCycle.speed = 1;
SpectrumCycle.speed_min = 0; SpectrumCycle.speed_min = 0;
SpectrumCycle.speed_max = 2; SpectrumCycle.speed_max = 2;
modes.push_back(SpectrumCycle); modes.push_back(SpectrumCycle);
mode Off; mode Off;
Off.name = "Off"; Off.name = "Off";
Off.value = GENESIS_XENON_200_MODE_OFF; Off.value = GENESIS_XENON_200_MODE_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE; Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE; Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off); modes.push_back(Off);
SetupColors(); SetupColors();

14
Controllers/SinowealthController/Sinowealth1007Controller/RGBController_Sinowealth1007.cpp
View file

@ -35,14 +35,14 @@ static const char *led_names[] =
RGBController_Sinowealth1007::RGBController_Sinowealth1007(SinowealthController1007* controller_ptr) RGBController_Sinowealth1007::RGBController_Sinowealth1007(SinowealthController1007* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ZET Fury Pro Mouse Device"; name = controller->GetName();
vendor = "ZET"; vendor = "ZET";
type = DEVICE_TYPE_MOUSE; type = DEVICE_TYPE_MOUSE;
description = "ZET Fury Pro Mouse Device"; description = "ZET Fury Pro Mouse Device";
location = controller->GetLocation(); location = controller->GetLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
mode Custom; mode Custom;
Custom.name = "Custom"; Custom.name = "Custom";

15
Controllers/SinowealthController/Sinowealth1007Controller/SinowealthController1007.cpp
View file

@ -14,16 +14,16 @@
#include "SinowealthController1007.h" #include "SinowealthController1007.h"
#include "StringUtils.h" #include "StringUtils.h"
SinowealthController1007::SinowealthController1007(hid_device* dev, char *_path) SinowealthController1007::SinowealthController1007(hid_device* dev, char *_path, std::string dev_name)
{ {
this->dev = dev; this->dev = dev;
this->location = _path;
this->led_count = 7; this->name = dev_name;
this->led_count = 7;
this->current_mode = ZET_FURY_PRO_MODE_CUSTOM + ZET_FURY_PRO_SPEED_DEF; this->current_mode = ZET_FURY_PRO_MODE_CUSTOM + ZET_FURY_PRO_SPEED_DEF;
this->current_direction = ZET_FURY_PRO_DIR_RIGHT; this->current_direction = ZET_FURY_PRO_DIR_RIGHT;
this->location = _path;
memset(device_colors, 0x00, sizeof(device_colors)); memset(device_colors, 0x00, sizeof(device_colors));
} }
@ -37,6 +37,11 @@ std::string SinowealthController1007::GetLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string SinowealthController1007::GetName()
{
return(name);
}
unsigned int SinowealthController1007::GetLEDCount() unsigned int SinowealthController1007::GetLEDCount()
{ {
return(led_count); return(led_count);

18
Controllers/SinowealthController/Sinowealth1007Controller/SinowealthController1007.h
View file

@ -57,11 +57,12 @@ enum
class SinowealthController1007 class SinowealthController1007
{ {
public: public:
SinowealthController1007(hid_device* dev, char *_path); SinowealthController1007(hid_device* dev, char *_path, std::string dev_name);
~SinowealthController1007(); ~SinowealthController1007();
unsigned int GetLEDCount(); unsigned int GetLEDCount();
std::string GetLocation(); std::string GetLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
void SetLEDColors(const std::vector<RGBColor>& colors); void SetLEDColors(const std::vector<RGBColor>& colors);
@ -69,14 +70,15 @@ public:
int GetProfile(); int GetProfile();
void SendPacket(); void SendPacket();
private: private:
hid_device* dev; hid_device* dev;
unsigned int led_count; unsigned int led_count;
unsigned char current_mode; unsigned char current_mode;
unsigned char current_direction; unsigned char current_direction;
unsigned char device_configuration[ZET_FURY_PRO_STATE_BUFFER_LENGTH]; unsigned char device_configuration[ZET_FURY_PRO_STATE_BUFFER_LENGTH];
unsigned char device_colors[ZET_FURY_PRO_COLOR_BUFFER_LENGTH]; unsigned char device_colors[ZET_FURY_PRO_COLOR_BUFFER_LENGTH];
std::string location; std::string location;
std::string name;
}; };

150
Controllers/SinowealthController/SinowealthController/RGBController_Sinowealth.cpp
View file

@ -24,113 +24,113 @@
RGBController_Sinowealth::RGBController_Sinowealth(SinowealthController* controller_ptr) RGBController_Sinowealth::RGBController_Sinowealth(SinowealthController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "Sinowealth Device"; name = controller->GetName();
type = DEVICE_TYPE_MOUSE; type = DEVICE_TYPE_MOUSE;
description = "Sinowealth Device"; description = "Sinowealth Device";
location = controller->GetLocation(); location = controller->GetLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
version = controller->GetFirmwareVersion(); version = controller->GetFirmwareVersion();
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE; Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_PER_LED; Static.color_mode = MODE_COLORS_PER_LED;
Static.value = GLORIOUS_MODE_STATIC; Static.value = GLORIOUS_MODE_STATIC;
modes.push_back(Static); modes.push_back(Static);
mode Off; mode Off;
Off.name = "Off"; Off.name = "Off";
Off.flags = MODE_FLAG_AUTOMATIC_SAVE; Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE; Off.color_mode = MODE_COLORS_NONE;
Off.value = GLORIOUS_MODE_OFF; Off.value = GLORIOUS_MODE_OFF;
modes.push_back(Off); modes.push_back(Off);
mode Rainbow; mode Rainbow;
Rainbow.name = "Glorious Mode"; Rainbow.name = "Glorious Mode";
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE; Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
Rainbow.speed_min = GLORIOUS_SPEED_SLOW; Rainbow.speed_min = GLORIOUS_SPEED_SLOW;
Rainbow.speed = GLORIOUS_SPEED_NORMAL; Rainbow.speed = GLORIOUS_SPEED_NORMAL;
Rainbow.speed_max = GLORIOUS_SPEED_FAST; Rainbow.speed_max = GLORIOUS_SPEED_FAST;
Rainbow.direction = MODE_DIRECTION_UP; Rainbow.direction = MODE_DIRECTION_UP;
Rainbow.color_mode = MODE_COLORS_NONE; Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.value = GLORIOUS_MODE_RAINBOW; Rainbow.value = GLORIOUS_MODE_RAINBOW;
modes.push_back(Rainbow); modes.push_back(Rainbow);
mode SpectrumBreathing; mode SpectrumBreathing;
SpectrumBreathing.name = "Seemless Breathing"; SpectrumBreathing.name = "Seemless Breathing";
SpectrumBreathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE; SpectrumBreathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumBreathing.speed_min = GLORIOUS_SPEED_SLOW; SpectrumBreathing.speed_min = GLORIOUS_SPEED_SLOW;
SpectrumBreathing.speed = GLORIOUS_SPEED_NORMAL; SpectrumBreathing.speed = GLORIOUS_SPEED_NORMAL;
SpectrumBreathing.speed_max = GLORIOUS_SPEED_FAST; SpectrumBreathing.speed_max = GLORIOUS_SPEED_FAST;
SpectrumBreathing.colors_min = 7; SpectrumBreathing.colors_min = 7;
SpectrumBreathing.colors_max = 7; SpectrumBreathing.colors_max = 7;
SpectrumBreathing.color_mode = MODE_COLORS_MODE_SPECIFIC; SpectrumBreathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
SpectrumBreathing.value = GLORIOUS_MODE_SPECTRUM_BREATING; SpectrumBreathing.value = GLORIOUS_MODE_SPECTRUM_BREATING;
SpectrumBreathing.colors.resize(7); SpectrumBreathing.colors.resize(7);
modes.push_back(SpectrumBreathing); modes.push_back(SpectrumBreathing);
mode Chase; mode Chase;
Chase.name = "Tail"; Chase.name = "Tail";
Chase.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; Chase.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Chase.speed_min = GLORIOUS_SPEED_SLOW; Chase.speed_min = GLORIOUS_SPEED_SLOW;
Chase.speed = GLORIOUS_SPEED_NORMAL; Chase.speed = GLORIOUS_SPEED_NORMAL;
Chase.speed_max = GLORIOUS_SPEED_FAST; Chase.speed_max = GLORIOUS_SPEED_FAST;
Chase.color_mode = MODE_COLORS_NONE; Chase.color_mode = MODE_COLORS_NONE;
Chase.value = GLORIOUS_MODE_TAIL; Chase.value = GLORIOUS_MODE_TAIL;
modes.push_back(Chase); modes.push_back(Chase);
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.speed_min = GLORIOUS_SPEED_SLOW; SpectrumCycle.speed_min = GLORIOUS_SPEED_SLOW;
SpectrumCycle.speed = GLORIOUS_SPEED_NORMAL; SpectrumCycle.speed = GLORIOUS_SPEED_NORMAL;
SpectrumCycle.speed_max = GLORIOUS_SPEED_FAST; SpectrumCycle.speed_max = GLORIOUS_SPEED_FAST;
SpectrumCycle.color_mode = MODE_COLORS_NONE; SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.value = GLORIOUS_MODE_SPECTRUM_CYCLE; SpectrumCycle.value = GLORIOUS_MODE_SPECTRUM_CYCLE;
modes.push_back(SpectrumCycle); modes.push_back(SpectrumCycle);
mode Flashing; mode Flashing;
Flashing.name = "Rave"; Flashing.name = "Rave";
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE; Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Flashing.speed_min = GLORIOUS_SPEED_SLOW; Flashing.speed_min = GLORIOUS_SPEED_SLOW;
Flashing.speed = GLORIOUS_SPEED_NORMAL; Flashing.speed = GLORIOUS_SPEED_NORMAL;
Flashing.speed_max = GLORIOUS_SPEED_FAST; Flashing.speed_max = GLORIOUS_SPEED_FAST;
Flashing.colors_min = 2; Flashing.colors_min = 2;
Flashing.colors_max = 2; Flashing.colors_max = 2;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC; Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.value = GLORIOUS_MODE_RAVE; Flashing.value = GLORIOUS_MODE_RAVE;
Flashing.colors.resize(2); Flashing.colors.resize(2);
modes.push_back(Flashing); modes.push_back(Flashing);
mode Epilepsy; mode Epilepsy;
Epilepsy.name = "Epilepsy"; Epilepsy.name = "Epilepsy";
Epilepsy.flags = MODE_FLAG_AUTOMATIC_SAVE; Epilepsy.flags = MODE_FLAG_AUTOMATIC_SAVE;
Epilepsy.color_mode = MODE_COLORS_NONE; Epilepsy.color_mode = MODE_COLORS_NONE;
Epilepsy.value = GLORIOUS_MODE_EPILEPSY; Epilepsy.value = GLORIOUS_MODE_EPILEPSY;
modes.push_back(Epilepsy); modes.push_back(Epilepsy);
mode RainbowSlow; mode RainbowSlow;
RainbowSlow.name = "Wave"; RainbowSlow.name = "Wave";
RainbowSlow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; RainbowSlow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
RainbowSlow.speed_min = GLORIOUS_SPEED_SLOW; RainbowSlow.speed_min = GLORIOUS_SPEED_SLOW;
RainbowSlow.speed = GLORIOUS_SPEED_NORMAL; RainbowSlow.speed = GLORIOUS_SPEED_NORMAL;
RainbowSlow.speed_max = GLORIOUS_SPEED_FAST; RainbowSlow.speed_max = GLORIOUS_SPEED_FAST;
RainbowSlow.color_mode = MODE_COLORS_NONE; RainbowSlow.color_mode = MODE_COLORS_NONE;
RainbowSlow.value = GLORIOUS_MODE_WAVE; RainbowSlow.value = GLORIOUS_MODE_WAVE;
modes.push_back(RainbowSlow); modes.push_back(RainbowSlow);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE; Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.speed_min = GLORIOUS_MODE_BREATING_SLOW; Breathing.speed_min = GLORIOUS_MODE_BREATING_SLOW;
Breathing.speed = GLORIOUS_MODE_BREATING_NORMAL; Breathing.speed = GLORIOUS_MODE_BREATING_NORMAL;
Breathing.speed_max = GLORIOUS_MODE_BREATING_FAST; Breathing.speed_max = GLORIOUS_MODE_BREATING_FAST;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 1; Breathing.colors_max = 1;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.value = GLORIOUS_MODE_BREATHING; Breathing.value = GLORIOUS_MODE_BREATHING;
Breathing.colors.resize(1); Breathing.colors.resize(1);
modes.push_back(Breathing); modes.push_back(Breathing);

1
Controllers/SinowealthController/SinowealthController/RGBController_Sinowealth.h
View file

@ -29,7 +29,6 @@ public:
void DeviceUpdateMode(); void DeviceUpdateMode();
private: private:
SinowealthController* controller; SinowealthController* controller;
}; };

23
Controllers/SinowealthController/SinowealthController/SinowealthController.cpp
View file

@ -14,22 +14,24 @@
#include "SinowealthController.h" #include "SinowealthController.h"
#include "StringUtils.h" #include "StringUtils.h"
SinowealthController::SinowealthController(hid_device* dev_data_handle, hid_device* dev_cmd_handle, char *_path) SinowealthController::SinowealthController(hid_device* dev_data_handle, hid_device* dev_cmd_handle, char *_path, std::string dev_name)
{ {
dev_data = dev_data_handle; dev_data = dev_data_handle;
dev_cmd = dev_cmd_handle; dev_cmd = dev_cmd_handle;
location = _path; location = _path;
name = dev_name;
led_count = 1; led_count = 1;
current_mode = GLORIOUS_MODE_STATIC; current_mode = GLORIOUS_MODE_STATIC;
current_speed = GLORIOUS_SPEED_NORMAL; current_speed = GLORIOUS_SPEED_NORMAL;
current_direction = GLORIOUS_DIRECTION_UP; current_direction = GLORIOUS_DIRECTION_UP;
} }
SinowealthController::~SinowealthController() SinowealthController::~SinowealthController()
{ {
hid_close(dev_data); hid_close(dev_data);
/*---------------------------------------------------------------------*\ /*---------------------------------------------------------------------*\
| If the dev_cmd handle was passed in as the same device as dev_data | | If the dev_cmd handle was passed in as the same device as dev_data |
| then attempting to close it a second time will segfault | | then attempting to close it a second time will segfault |
@ -45,6 +47,11 @@ std::string SinowealthController::GetLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string SinowealthController::GetName()
{
return(name);
}
unsigned int SinowealthController::GetLEDCount() unsigned int SinowealthController::GetLEDCount()
{ {
return(led_count); return(led_count);

23
Controllers/SinowealthController/SinowealthController/SinowealthController.h
View file

@ -57,11 +57,12 @@ enum
class SinowealthController class SinowealthController
{ {
public: public:
SinowealthController(hid_device* dev_data_handle, hid_device* dev_cmd_handle, char *_path); //RGB, Command, path SinowealthController(hid_device* dev_data_handle, hid_device* dev_cmd_handle, char *_path, std::string dev_name); //RGB, Command, path
~SinowealthController(); ~SinowealthController();
unsigned int GetLEDCount(); unsigned int GetLEDCount();
std::string GetLocation(); std::string GetLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetFirmwareVersion(); std::string GetFirmwareVersion();
@ -69,15 +70,13 @@ public:
void SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor* color_buf); void SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor* color_buf);
int GetProfile(); int GetProfile();
private: private:
hid_device* dev_cmd; hid_device* dev_cmd;
hid_device* dev_data; hid_device* dev_data;
unsigned int led_count;
unsigned int led_count; unsigned char current_mode;
unsigned char current_speed;
unsigned char current_mode; unsigned char current_direction;
unsigned char current_speed; unsigned char device_configuration[SINOWEALTH_CONFIG_REPORT_SIZE];
unsigned char current_direction; std::string location;
unsigned char device_configuration[SINOWEALTH_CONFIG_REPORT_SIZE]; std::string name;
std::string location;
}; };

58
Controllers/SinowealthController/SinowealthControllerDetect.cpp
View file

@ -240,7 +240,7 @@ static void DetectGenesisXenon200(hid_device_info* info, const std::string name)
hid_device* dev = reports.at(0).device; hid_device* dev = reports.at(0).device;
hid_device* cmd_dev = reports.at(1).device; hid_device* cmd_dev = reports.at(1).device;
GenesisXenon200Controller* controller = new GenesisXenon200Controller(dev, cmd_dev, info->path); GenesisXenon200Controller* controller = new GenesisXenon200Controller(dev, cmd_dev, info->path, name);
RGBController* rgb_controller = new RGBController_GenesisXenon200(controller); RGBController* rgb_controller = new RGBController_GenesisXenon200(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
@ -259,11 +259,11 @@ static void DetectZetFuryPro(hid_device_info* info, const std::string& name)
#else #else
hid_device* dev = hid_open_path(info->path); hid_device* dev = hid_open_path(info->path);
#endif #endif
if(dev) if(dev)
{ {
SinowealthController1007* controller = new SinowealthController1007(dev, info->path); SinowealthController1007* controller = new SinowealthController1007(dev, info->path, name);
RGBController *rgb_controller = new RGBController_Sinowealth1007(controller); RGBController_Sinowealth1007* rgb_controller = new RGBController_Sinowealth1007(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
@ -279,18 +279,18 @@ static void DetectSinowealthMouse(hid_device_info* info, const std::string& name
{ {
return; return;
} }
hid_device *dev = reports.at(0).device;
hid_device *dev_cmd = reports.at(0).cmd_device;
hid_device *dev = reports.at(0).device;
hid_device *dev_cmd = reports.at(0).cmd_device;
#else #else
hid_device* dev = hid_open_path(info->path); hid_device* dev = hid_open_path(info->path);
hid_device* dev_cmd = dev; hid_device* dev_cmd = dev;
#endif #endif
if(dev && dev_cmd) if(dev && dev_cmd)
{ {
SinowealthController* controller = new SinowealthController(dev, dev_cmd, info->path); SinowealthController* controller = new SinowealthController(dev, dev_cmd, info->path, name);
RGBController* rgb_controller = new RGBController_Sinowealth(controller); RGBController_Sinowealth* rgb_controller = new RGBController_Sinowealth(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
@ -300,11 +300,11 @@ static void DetectGMOW_Cable(hid_device_info* info, const std::string& name)
{ {
LOG_DEBUG("[%s] Detected connection via USB cable", name.c_str()); LOG_DEBUG("[%s] Detected connection via USB cable", name.c_str());
hid_device *dev = hid_open_path(info->path); hid_device *dev = hid_open_path(info->path);
if(dev) if(dev)
{ {
SinowealthGMOWController* controller = new SinowealthGMOWController(dev, info->path, GMOW_CABLE_CONNECTED); SinowealthGMOWController* controller = new SinowealthGMOWController(dev, info->path, GMOW_CABLE_CONNECTED, name);
RGBController* rgb_controller = new RGBController_GMOW(controller); RGBController_GMOW* rgb_controller = new RGBController_GMOW(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
@ -334,11 +334,11 @@ static void DetectGMOW_Dongle(hid_device_info* info, const std::string& name)
hid_free_enumeration(start); hid_free_enumeration(start);
hid_device *dev = hid_open_path(info->path); hid_device *dev = hid_open_path(info->path);
if(dev) if(dev)
{ {
SinowealthGMOWController* controller = new SinowealthGMOWController(dev, info->path, GMOW_DONGLE_CONNECTED); SinowealthGMOWController* controller = new SinowealthGMOWController(dev, info->path, GMOW_DONGLE_CONNECTED, name);
RGBController *rgb_controller = new RGBController_GMOW(controller); RGBController_GMOW* rgb_controller = new RGBController_GMOW(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
@ -361,9 +361,8 @@ static void DetectGMOW_Dongle(hid_device_info* info, const std::string& name)
// #endif // #endif
// if(dev && dev_cmd) // if(dev && dev_cmd)
// { // {
// SinowealthKeyboard16Controller* controller = new SinowealthKeyboard16Controller(dev_cmd, dev, info->path, name); // SinowealthKeyboard16Controller* controller = new SinowealthKeyboard16Controller(dev_cmd, dev, info->path, name);
// RGBController *rgb_controller = new RGBController_SinowealthKeyboard16(controller); // RGBController_SinowealthKeyboard16* rgb_controller = new RGBController_SinowealthKeyboard16(controller);
// rgb_controller->name = name;
// //
// ResourceManager::get()->RegisterRGBController(rgb_controller); // ResourceManager::get()->RegisterRGBController(rgb_controller);
// } // }
@ -378,24 +377,25 @@ static void DetectGMOW_Dongle(hid_device_info* info, const std::string& name)
// { // {
// return; // return;
// } // }
// hid_device *dev = reports.at(0).device; //
// hid_device *dev_cmd = reports.at(0).cmd_device; // hid_device *dev = reports.at(0).device;
// hid_device *dev_cmd = reports.at(0).cmd_device;
//
// if(dev && dev_cmd) // if(dev && dev_cmd)
// { // {
// SinowealthKeyboardController* controller = new SinowealthKeyboardController(dev_cmd, dev, info->path); // SinowealthKeyboardController* controller = new SinowealthKeyboardController(dev_cmd, dev, info->path, name);
// RGBController* rgb_controller = new RGBController_SinowealthKeyboard(controller); // RGBController_SinowealthKeyboard* rgb_controller = new RGBController_SinowealthKeyboard(controller);
// rgb_controller->name = name;
// //
// ResourceManager::get()->RegisterRGBController(rgb_controller); // ResourceManager::get()->RegisterRGBController(rgb_controller);
// } // }
// #else // #else
// // It is unknown why this code used the MOUSE controller here; could it be the reason why it was disabled? // // It is unknown why this code used the MOUSE controller here; could it be the reason why it was disabled?
// hid_device* dev = hid_open_path(info->path); // hid_device* dev = hid_open_path(info->path);
//
// if(dev) // if(dev)
// { // {
// SinowealthController* controller = new SinowealthController(dev, dev, info->path); // SinowealthController* controller = new SinowealthController(dev, dev, info->path, name);
// RGBController* rgb_controller = new RGBController_Sinowealth(controller); // RGBController_Sinowealth* rgb_controller = new RGBController_Sinowealth(controller);
// rgb_controller->name = name;
// //
// ResourceManager::get()->RegisterRGBController(rgb_controller); // ResourceManager::get()->RegisterRGBController(rgb_controller);
// } // }
@ -406,11 +406,11 @@ static void DetectSinowealthGenesisKeyboard(hid_device_info* info, const std::st
{ {
unsigned int pid = info->product_id; unsigned int pid = info->product_id;
hid_device* dev = hid_open_path(info->path); hid_device* dev = hid_open_path(info->path);
if(dev) if(dev)
{ {
SinowealthKeyboard90Controller* controller = new SinowealthKeyboard90Controller(dev, info->path, pid); SinowealthKeyboard90Controller* controller = new SinowealthKeyboard90Controller(dev, info->path, pid, name);
RGBController_SinowealthKeyboard90* rgb_controller = new RGBController_SinowealthKeyboard90(controller); RGBController_SinowealthKeyboard90* rgb_controller = new RGBController_SinowealthKeyboard90(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }

194
Controllers/SinowealthController/SinowealthGMOWController/RGBController_SinowealthGMOW.cpp
View file

@ -23,134 +23,134 @@
RGBController_GMOW::RGBController_GMOW(SinowealthGMOWController* controller_ptr) RGBController_GMOW::RGBController_GMOW(SinowealthGMOWController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "Sinowealth Device"; name = controller->GetName();
type = DEVICE_TYPE_MOUSE; type = DEVICE_TYPE_MOUSE;
description = "Sinowealth Device"; description = "Sinowealth Device";
location = controller->GetLocation(); location = controller->GetLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
version = controller->GetFirmwareVersion(); version = controller->GetFirmwareVersion();
mode Off; mode Off;
Off.name = "Off"; Off.name = "Off";
Off.flags = MODE_FLAG_AUTOMATIC_SAVE; Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE; Off.color_mode = MODE_COLORS_NONE;
Off.value = GMOW_MODE_OFF; Off.value = GMOW_MODE_OFF;
modes.push_back(Off); modes.push_back(Off);
mode RainbowWave; mode RainbowWave;
RainbowWave.name = "Rainbow Wave"; RainbowWave.name = "Rainbow Wave";
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowWave.speed_min = GMOW_SPEED1_MIN; RainbowWave.speed_min = GMOW_SPEED1_MIN;
RainbowWave.speed = GMOW_SPEED1_MID; RainbowWave.speed = GMOW_SPEED1_MID;
RainbowWave.speed_max = GMOW_SPEED1_MAX; RainbowWave.speed_max = GMOW_SPEED1_MAX;
RainbowWave.direction = MODE_DIRECTION_UP; RainbowWave.direction = MODE_DIRECTION_UP;
RainbowWave.color_mode = MODE_COLORS_NONE; RainbowWave.color_mode = MODE_COLORS_NONE;
RainbowWave.brightness_min = GMOW_BRIGHTNESS_MIN; RainbowWave.brightness_min = GMOW_BRIGHTNESS_MIN;
RainbowWave.brightness = GMOW_BRIGHTNESS_MID; RainbowWave.brightness = GMOW_BRIGHTNESS_MID;
RainbowWave.brightness_max = GMOW_BRIGHTNESS_MAX; RainbowWave.brightness_max = GMOW_BRIGHTNESS_MAX;
RainbowWave.value = GMOW_MODE_RAINBOW_WAVE; RainbowWave.value = GMOW_MODE_RAINBOW_WAVE;
modes.push_back(RainbowWave); modes.push_back(RainbowWave);
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.speed_min = GMOW_SPEED1_MIN; SpectrumCycle.speed_min = GMOW_SPEED1_MIN;
SpectrumCycle.speed = GMOW_SPEED1_MID; SpectrumCycle.speed = GMOW_SPEED1_MID;
SpectrumCycle.speed_max = GMOW_SPEED1_MAX; SpectrumCycle.speed_max = GMOW_SPEED1_MAX;
SpectrumCycle.color_mode = MODE_COLORS_NONE; SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.brightness_min = GMOW_BRIGHTNESS_MIN; SpectrumCycle.brightness_min = GMOW_BRIGHTNESS_MIN;
SpectrumCycle.brightness = GMOW_BRIGHTNESS_MID; SpectrumCycle.brightness = GMOW_BRIGHTNESS_MID;
SpectrumCycle.brightness_max = GMOW_BRIGHTNESS_MAX; SpectrumCycle.brightness_max = GMOW_BRIGHTNESS_MAX;
SpectrumCycle.value = GMOW_MODE_SPECTRUM_CYCLE; SpectrumCycle.value = GMOW_MODE_SPECTRUM_CYCLE;
modes.push_back(SpectrumCycle); modes.push_back(SpectrumCycle);
mode CustomBreathing; mode CustomBreathing;
CustomBreathing.name = "Custom Breathing"; CustomBreathing.name = "Custom Breathing";
CustomBreathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; CustomBreathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
CustomBreathing.speed_min = GMOW_SPEED1_MIN; CustomBreathing.speed_min = GMOW_SPEED1_MIN;
CustomBreathing.speed = GMOW_SPEED1_MID; CustomBreathing.speed = GMOW_SPEED1_MID;
CustomBreathing.speed_max = GMOW_SPEED1_MAX; CustomBreathing.speed_max = GMOW_SPEED1_MAX;
CustomBreathing.color_mode = MODE_COLORS_MODE_SPECIFIC; CustomBreathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
CustomBreathing.colors_min = 2; CustomBreathing.colors_min = 2;
CustomBreathing.colors_max = 7; CustomBreathing.colors_max = 7;
CustomBreathing.brightness_min = GMOW_BRIGHTNESS_MIN; CustomBreathing.brightness_min = GMOW_BRIGHTNESS_MIN;
CustomBreathing.brightness = GMOW_BRIGHTNESS_MID; CustomBreathing.brightness = GMOW_BRIGHTNESS_MID;
CustomBreathing.brightness_max = GMOW_BRIGHTNESS_MAX; CustomBreathing.brightness_max = GMOW_BRIGHTNESS_MAX;
CustomBreathing.value = GMOW_MODE_CUSTOM_BREATHING; CustomBreathing.value = GMOW_MODE_CUSTOM_BREATHING;
CustomBreathing.colors.resize(7); CustomBreathing.colors.resize(7);
modes.push_back(CustomBreathing); modes.push_back(CustomBreathing);
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC; Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
Static.brightness_min = GMOW_BRIGHTNESS_MIN; Static.brightness_min = GMOW_BRIGHTNESS_MIN;
Static.brightness = GMOW_BRIGHTNESS_MID; Static.brightness = GMOW_BRIGHTNESS_MID;
Static.brightness_max = GMOW_BRIGHTNESS_MAX; Static.brightness_max = GMOW_BRIGHTNESS_MAX;
Static.value = GMOW_MODE_STATIC; Static.value = GMOW_MODE_STATIC;
Static.colors.resize(1); Static.colors.resize(1);
modes.push_back(Static); modes.push_back(Static);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.speed_min = GMOW_SPEED1_MIN; Breathing.speed_min = GMOW_SPEED1_MIN;
Breathing.speed = GMOW_SPEED1_MID; Breathing.speed = GMOW_SPEED1_MID;
Breathing.speed_max = GMOW_SPEED1_MAX; Breathing.speed_max = GMOW_SPEED1_MAX;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 1; Breathing.colors_max = 1;
Breathing.brightness_min = GMOW_BRIGHTNESS_MIN; Breathing.brightness_min = GMOW_BRIGHTNESS_MIN;
Breathing.brightness = GMOW_BRIGHTNESS_MID; Breathing.brightness = GMOW_BRIGHTNESS_MID;
Breathing.brightness_max = GMOW_BRIGHTNESS_MAX; Breathing.brightness_max = GMOW_BRIGHTNESS_MAX;
Breathing.value = GMOW_MODE_BREATHING; Breathing.value = GMOW_MODE_BREATHING;
Breathing.colors.resize(1); Breathing.colors.resize(1);
modes.push_back(Breathing); modes.push_back(Breathing);
mode Tail; mode Tail;
Tail.name = "Tail"; Tail.name = "Tail";
Tail.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; Tail.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Tail.speed_min = GMOW_SPEED1_MIN; Tail.speed_min = GMOW_SPEED1_MIN;
Tail.speed = GMOW_SPEED1_MID; Tail.speed = GMOW_SPEED1_MID;
Tail.speed_max = GMOW_SPEED1_MAX; Tail.speed_max = GMOW_SPEED1_MAX;
Tail.color_mode = MODE_COLORS_NONE; Tail.color_mode = MODE_COLORS_NONE;
Tail.brightness_min = GMOW_BRIGHTNESS_MIN; Tail.brightness_min = GMOW_BRIGHTNESS_MIN;
Tail.brightness = GMOW_BRIGHTNESS_MID; Tail.brightness = GMOW_BRIGHTNESS_MID;
Tail.brightness_max = GMOW_BRIGHTNESS_MAX; Tail.brightness_max = GMOW_BRIGHTNESS_MAX;
Tail.value = GMOW_MODE_TAIL; Tail.value = GMOW_MODE_TAIL;
modes.push_back(Tail); modes.push_back(Tail);
mode Rave; mode Rave;
Rave.name = "Rave"; Rave.name = "Rave";
Rave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; Rave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Rave.speed_min = GMOW_SPEED2_MIN; Rave.speed_min = GMOW_SPEED2_MIN;
Rave.speed = GMOW_SPEED2_MID; Rave.speed = GMOW_SPEED2_MID;
Rave.speed_max = GMOW_SPEED2_MAX; Rave.speed_max = GMOW_SPEED2_MAX;
Rave.color_mode = MODE_COLORS_MODE_SPECIFIC; Rave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Rave.colors_min = 1; Rave.colors_min = 1;
Rave.colors_max = 2; Rave.colors_max = 2;
Rave.brightness_min = GMOW_BRIGHTNESS_MIN; Rave.brightness_min = GMOW_BRIGHTNESS_MIN;
Rave.brightness = GMOW_BRIGHTNESS_MID; Rave.brightness = GMOW_BRIGHTNESS_MID;
Rave.brightness_max = GMOW_BRIGHTNESS_MAX; Rave.brightness_max = GMOW_BRIGHTNESS_MAX;
Rave.value = GMOW_MODE_RAVE; Rave.value = GMOW_MODE_RAVE;
Rave.colors.resize(2); Rave.colors.resize(2);
modes.push_back(Rave); modes.push_back(Rave);
mode Wave; mode Wave;
Wave.name = "Wave"; Wave.name = "Wave";
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Wave.speed_min = GMOW_SPEED2_MIN; Wave.speed_min = GMOW_SPEED2_MIN;
Wave.speed = GMOW_SPEED2_MID; Wave.speed = GMOW_SPEED2_MID;
Wave.speed_max = GMOW_SPEED2_MAX; Wave.speed_max = GMOW_SPEED2_MAX;
Wave.color_mode = MODE_COLORS_NONE; Wave.color_mode = MODE_COLORS_NONE;
Wave.brightness_min = GMOW_BRIGHTNESS_MIN; Wave.brightness_min = GMOW_BRIGHTNESS_MIN;
Wave.brightness = GMOW_BRIGHTNESS_MID; Wave.brightness = GMOW_BRIGHTNESS_MID;
Wave.brightness_max = GMOW_BRIGHTNESS_MAX; Wave.brightness_max = GMOW_BRIGHTNESS_MAX;
Wave.value = GMOW_MODE_WAVE; Wave.value = GMOW_MODE_WAVE;
modes.push_back(Wave); modes.push_back(Wave);
SetupZones(); SetupZones();

15
Controllers/SinowealthController/SinowealthGMOWController/SinowealthGMOWController.cpp
View file

@ -15,10 +15,12 @@
#include "SinowealthGMOWController.h" #include "SinowealthGMOWController.h"
#include "StringUtils.h" #include "StringUtils.h"
SinowealthGMOWController::SinowealthGMOWController(hid_device* dev_handle, char *_path, int _type) SinowealthGMOWController::SinowealthGMOWController(hid_device* dev_handle, char *_path, int _type, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = _path; location = _path;
name = dev_name;
type = _type;
memset(mode_packet,0x00, GMOW_PACKET_SIZE); memset(mode_packet,0x00, GMOW_PACKET_SIZE);
mode_packet[0x03] = 0x02; mode_packet[0x03] = 0x02;
@ -35,8 +37,6 @@ SinowealthGMOWController::SinowealthGMOWController(hid_device* dev_handle, char
memcpy(less_packet, wired_packet, GMOW_PACKET_SIZE); memcpy(less_packet, wired_packet, GMOW_PACKET_SIZE);
less_packet[0x07] = 0x00; less_packet[0x07] = 0x00;
type = _type;
} }
SinowealthGMOWController::~SinowealthGMOWController() SinowealthGMOWController::~SinowealthGMOWController()
@ -49,6 +49,11 @@ std::string SinowealthGMOWController::GetLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string SinowealthGMOWController::GetName()
{
return(name);
}
std::string SinowealthGMOWController::GetSerialString() std::string SinowealthGMOWController::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

4
Controllers/SinowealthController/SinowealthGMOWController/SinowealthGMOWController.h
View file

@ -59,10 +59,11 @@ enum
class SinowealthGMOWController class SinowealthGMOWController
{ {
public: public:
SinowealthGMOWController(hid_device* dev_handle, char *_path, int type); SinowealthGMOWController(hid_device* dev_handle, char *_path, int type, std::string dev_name);
~SinowealthGMOWController(); ~SinowealthGMOWController();
std::string GetLocation(); std::string GetLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
void SetMode(unsigned char mode, void SetMode(unsigned char mode,
@ -81,5 +82,6 @@ private:
unsigned char less_packet[GMOW_PACKET_SIZE]; unsigned char less_packet[GMOW_PACKET_SIZE];
std::string location; std::string location;
std::string name;
int type; int type;
}; };

12
Controllers/SinowealthController/SinowealthKeyboard16Controller/RGBController_SinowealthKeyboard16.cpp
View file

@ -182,13 +182,13 @@ static const char *led_names_tkl[] =
RGBController_SinowealthKeyboard16::RGBController_SinowealthKeyboard16(SinowealthKeyboard16Controller* controller_ptr) RGBController_SinowealthKeyboard16::RGBController_SinowealthKeyboard16(SinowealthKeyboard16Controller* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "Sinowealth Keyboard"; name = controller->GetName();
type = DEVICE_TYPE_KEYBOARD; type = DEVICE_TYPE_KEYBOARD;
description = "Generic Sinowealth Keyboard"; description = "Sinowealth Keyboard Device";
location = controller->GetLocation(); location = controller->GetLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
std::vector<ModeCfg> modes_cfg = controller->GetDeviceModes(); std::vector<ModeCfg> modes_cfg = controller->GetDeviceModes();
std::vector<ModeColorCfg> color_presets = controller->GetDeviceColors(); std::vector<ModeColorCfg> color_presets = controller->GetDeviceColors();

5
Controllers/SinowealthController/SinowealthKeyboard16Controller/SinowealthKeyboard16Controller.cpp
View file

@ -56,6 +56,11 @@ std::string SinowealthKeyboard16Controller::GetLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string SinowealthKeyboard16Controller::GetName()
{
return(name);
}
unsigned char SinowealthKeyboard16Controller::GetCurrentMode() unsigned char SinowealthKeyboard16Controller::GetCurrentMode()
{ {
return current_mode; return current_mode;

1
Controllers/SinowealthController/SinowealthKeyboard16Controller/SinowealthKeyboard16Controller.h
View file

@ -109,6 +109,7 @@ public:
unsigned int GetLEDCount(); unsigned int GetLEDCount();
std::string GetLocation(); std::string GetLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
unsigned char GetCurrentMode(); unsigned char GetCurrentMode();
std::vector<ModeCfg> GetDeviceModes(); std::vector<ModeCfg> GetDeviceModes();

2
Controllers/SinowealthController/SinowealthKeyboard90Controller/RGBController_SinowealthKeyboard90.cpp
View file

@ -28,7 +28,7 @@ RGBController_SinowealthKeyboard90::RGBController_SinowealthKeyboard90(Sinowealt
{ {
controller = controller_ptr; controller = controller_ptr;
name = "Genesis Thor 300"; name = controller->GetNameString();
vendor = "Sinowealth"; vendor = "Sinowealth";
type = DEVICE_TYPE_KEYBOARD; type = DEVICE_TYPE_KEYBOARD;
description = "Generic Sinowealth Keyboard"; description = "Generic Sinowealth Keyboard";

8
Controllers/SinowealthController/SinowealthKeyboard90Controller/SinowealthKeyboard90Controller.cpp
View file

@ -15,10 +15,11 @@
using namespace thor300; using namespace thor300;
SinowealthKeyboard90Controller::SinowealthKeyboard90Controller(hid_device* dev_handle, const char* path, const unsigned short pid) SinowealthKeyboard90Controller::SinowealthKeyboard90Controller(hid_device* dev_handle, const char* path, const unsigned short pid, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
usb_pid = pid; usb_pid = pid;
} }
@ -32,6 +33,11 @@ std::string SinowealthKeyboard90Controller::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string SinowealthKeyboard90Controller::GetNameString()
{
return(name);
}
std::string SinowealthKeyboard90Controller::GetSerialString() std::string SinowealthKeyboard90Controller::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

4
Controllers/SinowealthController/SinowealthKeyboard90Controller/SinowealthKeyboard90Controller.h
View file

@ -201,11 +201,13 @@ namespace thor300
class SinowealthKeyboard90Controller class SinowealthKeyboard90Controller
{ {
public: public:
SinowealthKeyboard90Controller(hid_device* dev_handle, const char* path, const unsigned short pid); SinowealthKeyboard90Controller(hid_device* dev_handle, const char* path, const unsigned short pid, std::string dev_name);
~SinowealthKeyboard90Controller(); ~SinowealthKeyboard90Controller();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString(); std::string GetSerialString();
unsigned short GetUSBPID(); unsigned short GetUSBPID();
void SendMode void SendMode

370
Controllers/SinowealthController/SinowealthKeyboardController/RGBController_SinowealthKeyboard.cpp
View file

@ -131,273 +131,273 @@ static const char *led_names_tkl[] =
RGBController_SinowealthKeyboard::RGBController_SinowealthKeyboard(SinowealthKeyboardController* controller_ptr) RGBController_SinowealthKeyboard::RGBController_SinowealthKeyboard(SinowealthKeyboardController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "Sinowealth Keyboard"; name = controller->GetName();
type = DEVICE_TYPE_KEYBOARD; type = DEVICE_TYPE_KEYBOARD;
description = "Sinowealth Keyboard"; description = "Sinowealth Keyboard Device";
location = controller->GetLocation(); location = controller->GetLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC; Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.value = MODE_STATIC; Static.value = MODE_STATIC;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
Static.colors.resize(1); Static.colors.resize(1);
modes.push_back(Static); modes.push_back(Static);
mode Custom; mode Custom;
Custom.name = "Custom"; Custom.name = "Custom";
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR; Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Custom.color_mode = MODE_COLORS_PER_LED; Custom.color_mode = MODE_COLORS_PER_LED;
Custom.value = MODE_PER_KEY; Custom.value = MODE_PER_KEY;
modes.push_back(Custom); modes.push_back(Custom);
mode Off; mode Off;
Off.name = "Off"; Off.name = "Off";
Off.flags = 0; Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE; Off.color_mode = MODE_COLORS_NONE;
Off.value = MODE_OFF; Off.value = MODE_OFF;
modes.push_back(Off); modes.push_back(Off);
mode Respire; mode Respire;
Respire.name = "Respire"; Respire.name = "Respire";
Respire.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; Respire.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Respire.speed_min = SPEED_SLOW; Respire.speed_min = SPEED_SLOW;
Respire.speed = SPEED_NORMAL; Respire.speed = SPEED_NORMAL;
Respire.speed_max = SPEED_FASTEST; Respire.speed_max = SPEED_FASTEST;
Respire.color_mode = MODE_COLORS_RANDOM; Respire.color_mode = MODE_COLORS_RANDOM;
Respire.value = MODE_RESPIRE; Respire.value = MODE_RESPIRE;
Respire.colors_min = 1; Respire.colors_min = 1;
Respire.colors_max = 1; Respire.colors_max = 1;
Respire.colors.resize(1); Respire.colors.resize(1);
modes.push_back(Respire); modes.push_back(Respire);
mode Rainbow; mode Rainbow;
Rainbow.name = "Rainbow"; Rainbow.name = "Rainbow";
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Rainbow.speed_min = SPEED_SLOW; Rainbow.speed_min = SPEED_SLOW;
Rainbow.speed = SPEED_NORMAL; Rainbow.speed = SPEED_NORMAL;
Rainbow.speed_max = SPEED_FASTEST; Rainbow.speed_max = SPEED_FASTEST;
Rainbow.color_mode = MODE_COLORS_NONE; Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.value = MODE_RAINBOW; Rainbow.value = MODE_RAINBOW;
modes.push_back(Rainbow); modes.push_back(Rainbow);
mode FlashAway; mode FlashAway;
FlashAway.name = "Flash Away"; FlashAway.name = "Flash Away";
FlashAway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; FlashAway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
FlashAway.speed_min = SPEED_SLOW; FlashAway.speed_min = SPEED_SLOW;
FlashAway.speed = SPEED_NORMAL; FlashAway.speed = SPEED_NORMAL;
FlashAway.speed_max = SPEED_FASTEST; FlashAway.speed_max = SPEED_FASTEST;
FlashAway.color_mode = MODE_COLORS_RANDOM; FlashAway.color_mode = MODE_COLORS_RANDOM;
FlashAway.value = MODE_FLASH_AWAY; FlashAway.value = MODE_FLASH_AWAY;
FlashAway.colors_min = 1; FlashAway.colors_min = 1;
FlashAway.colors_max = 1; FlashAway.colors_max = 1;
FlashAway.colors.resize(1); FlashAway.colors.resize(1);
modes.push_back(FlashAway); modes.push_back(FlashAway);
mode Raindrops; mode Raindrops;
Raindrops.name = "Raindrops"; Raindrops.name = "Raindrops";
Raindrops.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; Raindrops.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Raindrops.speed_min = SPEED_SLOW; Raindrops.speed_min = SPEED_SLOW;
Raindrops.speed = SPEED_NORMAL; Raindrops.speed = SPEED_NORMAL;
Raindrops.speed_max = SPEED_FASTEST; Raindrops.speed_max = SPEED_FASTEST;
Raindrops.color_mode = MODE_COLORS_RANDOM; Raindrops.color_mode = MODE_COLORS_RANDOM;
Raindrops.value = MODE_RAINDROPS; Raindrops.value = MODE_RAINDROPS;
Raindrops.colors_min = 1; Raindrops.colors_min = 1;
Raindrops.colors_max = 1; Raindrops.colors_max = 1;
Raindrops.colors.resize(1); Raindrops.colors.resize(1);
modes.push_back(Raindrops); modes.push_back(Raindrops);
mode RainbowWheel; mode RainbowWheel;
RainbowWheel.name = "Rainbow Wheel"; RainbowWheel.name = "Rainbow Wheel";
RainbowWheel.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; RainbowWheel.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RainbowWheel.speed_min = SPEED_SLOW; RainbowWheel.speed_min = SPEED_SLOW;
RainbowWheel.speed = SPEED_NORMAL; RainbowWheel.speed = SPEED_NORMAL;
RainbowWheel.speed_max = SPEED_FASTEST; RainbowWheel.speed_max = SPEED_FASTEST;
RainbowWheel.color_mode = MODE_COLORS_RANDOM; RainbowWheel.color_mode = MODE_COLORS_RANDOM;
RainbowWheel.value = MODE_RAINBOW_WHEEL; RainbowWheel.value = MODE_RAINBOW_WHEEL;
RainbowWheel.colors_min = 1; RainbowWheel.colors_min = 1;
RainbowWheel.colors_max = 1; RainbowWheel.colors_max = 1;
RainbowWheel.colors.resize(1); RainbowWheel.colors.resize(1);
modes.push_back(RainbowWheel); modes.push_back(RainbowWheel);
mode RipplesShining; mode RipplesShining;
RipplesShining.name = "Ripples Shining"; RipplesShining.name = "Ripples Shining";
RipplesShining.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; RipplesShining.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RipplesShining.speed_min = SPEED_SLOW; RipplesShining.speed_min = SPEED_SLOW;
RipplesShining.speed = SPEED_NORMAL; RipplesShining.speed = SPEED_NORMAL;
RipplesShining.speed_max = SPEED_FASTEST; RipplesShining.speed_max = SPEED_FASTEST;
RipplesShining.color_mode = MODE_COLORS_RANDOM; RipplesShining.color_mode = MODE_COLORS_RANDOM;
RipplesShining.value = MODE_RIPPLES_SHINING; RipplesShining.value = MODE_RIPPLES_SHINING;
RipplesShining.colors_min = 1; RipplesShining.colors_min = 1;
RipplesShining.colors_max = 1; RipplesShining.colors_max = 1;
RipplesShining.colors.resize(1); RipplesShining.colors.resize(1);
modes.push_back(RipplesShining); modes.push_back(RipplesShining);
mode StarsTwinkle; mode StarsTwinkle;
StarsTwinkle.name = "Stars Twinkle"; StarsTwinkle.name = "Stars Twinkle";
StarsTwinkle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; StarsTwinkle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
StarsTwinkle.speed_min = SPEED_SLOW; StarsTwinkle.speed_min = SPEED_SLOW;
StarsTwinkle.speed = SPEED_NORMAL; StarsTwinkle.speed = SPEED_NORMAL;
StarsTwinkle.speed_max = SPEED_FASTEST; StarsTwinkle.speed_max = SPEED_FASTEST;
StarsTwinkle.color_mode = MODE_COLORS_RANDOM; StarsTwinkle.color_mode = MODE_COLORS_RANDOM;
StarsTwinkle.value = MODE_STARS_TWINKLE; StarsTwinkle.value = MODE_STARS_TWINKLE;
StarsTwinkle.colors_min = 1; StarsTwinkle.colors_min = 1;
StarsTwinkle.colors_max = 1; StarsTwinkle.colors_max = 1;
StarsTwinkle.colors.resize(1); StarsTwinkle.colors.resize(1);
modes.push_back(StarsTwinkle); modes.push_back(StarsTwinkle);
mode ShadowDisappear; mode ShadowDisappear;
ShadowDisappear.name = "Shadow Disappear"; ShadowDisappear.name = "Shadow Disappear";
ShadowDisappear.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; ShadowDisappear.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
ShadowDisappear.speed_min = SPEED_SLOW; ShadowDisappear.speed_min = SPEED_SLOW;
ShadowDisappear.speed = SPEED_NORMAL; ShadowDisappear.speed = SPEED_NORMAL;
ShadowDisappear.speed_max = SPEED_FASTEST; ShadowDisappear.speed_max = SPEED_FASTEST;
ShadowDisappear.color_mode = MODE_COLORS_RANDOM; ShadowDisappear.color_mode = MODE_COLORS_RANDOM;
ShadowDisappear.value = MODE_SHADOW_DISAPPEAR; ShadowDisappear.value = MODE_SHADOW_DISAPPEAR;
ShadowDisappear.colors_min = 1; ShadowDisappear.colors_min = 1;
ShadowDisappear.colors_max = 1; ShadowDisappear.colors_max = 1;
ShadowDisappear.colors.resize(1); ShadowDisappear.colors.resize(1);
modes.push_back(ShadowDisappear); modes.push_back(ShadowDisappear);
mode RetroSnake; mode RetroSnake;
RetroSnake.name = "Retro Snake"; RetroSnake.name = "Retro Snake";
RetroSnake.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; RetroSnake.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RetroSnake.speed_min = SPEED_SLOW; RetroSnake.speed_min = SPEED_SLOW;
RetroSnake.speed = SPEED_NORMAL; RetroSnake.speed = SPEED_NORMAL;
RetroSnake.speed_max = SPEED_FASTEST; RetroSnake.speed_max = SPEED_FASTEST;
RetroSnake.color_mode = MODE_COLORS_RANDOM; RetroSnake.color_mode = MODE_COLORS_RANDOM;
RetroSnake.value = MODE_RETRO_SNAKE; RetroSnake.value = MODE_RETRO_SNAKE;
RetroSnake.colors_min = 1; RetroSnake.colors_min = 1;
RetroSnake.colors_max = 1; RetroSnake.colors_max = 1;
RetroSnake.colors.resize(1); RetroSnake.colors.resize(1);
modes.push_back(RetroSnake); modes.push_back(RetroSnake);
mode NeonStream; mode NeonStream;
NeonStream.name = "Neon Stream"; NeonStream.name = "Neon Stream";
NeonStream.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; NeonStream.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
NeonStream.speed_min = SPEED_SLOW; NeonStream.speed_min = SPEED_SLOW;
NeonStream.speed = SPEED_NORMAL; NeonStream.speed = SPEED_NORMAL;
NeonStream.speed_max = SPEED_FASTEST; NeonStream.speed_max = SPEED_FASTEST;
NeonStream.color_mode = MODE_COLORS_RANDOM; NeonStream.color_mode = MODE_COLORS_RANDOM;
NeonStream.value = MODE_NEON_STREAM; NeonStream.value = MODE_NEON_STREAM;
NeonStream.colors_min = 1; NeonStream.colors_min = 1;
NeonStream.colors_max = 1; NeonStream.colors_max = 1;
NeonStream.colors.resize(1); NeonStream.colors.resize(1);
modes.push_back(NeonStream); modes.push_back(NeonStream);
mode Reaction; mode Reaction;
Reaction.name = "Reaction"; Reaction.name = "Reaction";
Reaction.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; Reaction.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Reaction.speed_min = SPEED_SLOW; Reaction.speed_min = SPEED_SLOW;
Reaction.speed = SPEED_NORMAL; Reaction.speed = SPEED_NORMAL;
Reaction.speed_max = SPEED_FASTEST; Reaction.speed_max = SPEED_FASTEST;
Reaction.color_mode = MODE_COLORS_RANDOM; Reaction.color_mode = MODE_COLORS_RANDOM;
Reaction.value = MODE_REACTION; Reaction.value = MODE_REACTION;
Reaction.colors_min = 1; Reaction.colors_min = 1;
Reaction.colors_max = 1; Reaction.colors_max = 1;
Reaction.colors.resize(1); Reaction.colors.resize(1);
modes.push_back(Reaction); modes.push_back(Reaction);
mode SineWave; mode SineWave;
SineWave.name = "Sine Wave"; SineWave.name = "Sine Wave";
SineWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; SineWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
SineWave.speed_min = SPEED_SLOW; SineWave.speed_min = SPEED_SLOW;
SineWave.speed = SPEED_NORMAL; SineWave.speed = SPEED_NORMAL;
SineWave.speed_max = SPEED_FASTEST; SineWave.speed_max = SPEED_FASTEST;
SineWave.color_mode = MODE_COLORS_RANDOM; SineWave.color_mode = MODE_COLORS_RANDOM;
SineWave.value = MODE_SINE_WAVE; SineWave.value = MODE_SINE_WAVE;
SineWave.colors_min = 1; SineWave.colors_min = 1;
SineWave.colors_max = 1; SineWave.colors_max = 1;
SineWave.colors.resize(1); SineWave.colors.resize(1);
modes.push_back(SineWave); modes.push_back(SineWave);
mode RetinueScanning; mode RetinueScanning;
RetinueScanning.name = "Retinue Scanning"; RetinueScanning.name = "Retinue Scanning";
RetinueScanning.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; RetinueScanning.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RetinueScanning.speed_min = SPEED_SLOW; RetinueScanning.speed_min = SPEED_SLOW;
RetinueScanning.speed = SPEED_NORMAL; RetinueScanning.speed = SPEED_NORMAL;
RetinueScanning.speed_max = SPEED_FASTEST; RetinueScanning.speed_max = SPEED_FASTEST;
RetinueScanning.color_mode = MODE_COLORS_RANDOM; RetinueScanning.color_mode = MODE_COLORS_RANDOM;
RetinueScanning.value = MODE_RETINUE_SCANNING; RetinueScanning.value = MODE_RETINUE_SCANNING;
RetinueScanning.colors_min = 1; RetinueScanning.colors_min = 1;
RetinueScanning.colors_max = 1; RetinueScanning.colors_max = 1;
RetinueScanning.colors.resize(1); RetinueScanning.colors.resize(1);
modes.push_back(RetinueScanning); modes.push_back(RetinueScanning);
mode RotatingWindmill; mode RotatingWindmill;
RotatingWindmill.name = "Rotating Windmill"; RotatingWindmill.name = "Rotating Windmill";
RotatingWindmill.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; RotatingWindmill.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RotatingWindmill.speed_min = SPEED_SLOW; RotatingWindmill.speed_min = SPEED_SLOW;
RotatingWindmill.speed = SPEED_NORMAL; RotatingWindmill.speed = SPEED_NORMAL;
RotatingWindmill.speed_max = SPEED_FASTEST; RotatingWindmill.speed_max = SPEED_FASTEST;
RotatingWindmill.color_mode = MODE_COLORS_RANDOM; RotatingWindmill.color_mode = MODE_COLORS_RANDOM;
RotatingWindmill.value = MODE_ROTATING_WINDMILL; RotatingWindmill.value = MODE_ROTATING_WINDMILL;
RotatingWindmill.colors_min = 1; RotatingWindmill.colors_min = 1;
RotatingWindmill.colors_max = 1; RotatingWindmill.colors_max = 1;
RotatingWindmill.colors.resize(1); RotatingWindmill.colors.resize(1);
modes.push_back(RotatingWindmill); modes.push_back(RotatingWindmill);
mode ColorfulWaterfall; mode ColorfulWaterfall;
ColorfulWaterfall.name = "Colorful Waterfall"; ColorfulWaterfall.name = "Colorful Waterfall";
ColorfulWaterfall.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; ColorfulWaterfall.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
ColorfulWaterfall.speed_min = SPEED_SLOW; ColorfulWaterfall.speed_min = SPEED_SLOW;
ColorfulWaterfall.speed = SPEED_NORMAL; ColorfulWaterfall.speed = SPEED_NORMAL;
ColorfulWaterfall.speed_max = SPEED_FASTEST; ColorfulWaterfall.speed_max = SPEED_FASTEST;
ColorfulWaterfall.color_mode = MODE_COLORS_NONE; ColorfulWaterfall.color_mode = MODE_COLORS_NONE;
ColorfulWaterfall.value = MODE_COLORFUL_WATERFALL; ColorfulWaterfall.value = MODE_COLORFUL_WATERFALL;
modes.push_back(ColorfulWaterfall); modes.push_back(ColorfulWaterfall);
mode Blossoming; mode Blossoming;
Blossoming.name = "Blossoming"; Blossoming.name = "Blossoming";
Blossoming.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; Blossoming.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Blossoming.speed_min = SPEED_SLOW; Blossoming.speed_min = SPEED_SLOW;
Blossoming.speed = SPEED_NORMAL; Blossoming.speed = SPEED_NORMAL;
Blossoming.speed_max = SPEED_FASTEST; Blossoming.speed_max = SPEED_FASTEST;
Blossoming.color_mode = MODE_COLORS_NONE; Blossoming.color_mode = MODE_COLORS_NONE;
Blossoming.value = MODE_BLOSSOMING; Blossoming.value = MODE_BLOSSOMING;
modes.push_back(Blossoming); modes.push_back(Blossoming);
mode RotatingStorm; mode RotatingStorm;
RotatingStorm.name = "Rotating Storm"; RotatingStorm.name = "Rotating Storm";
RotatingStorm.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; RotatingStorm.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RotatingStorm.speed_min = SPEED_SLOW; RotatingStorm.speed_min = SPEED_SLOW;
RotatingStorm.speed = SPEED_NORMAL; RotatingStorm.speed = SPEED_NORMAL;
RotatingStorm.speed_max = SPEED_FASTEST; RotatingStorm.speed_max = SPEED_FASTEST;
RotatingStorm.color_mode = MODE_COLORS_RANDOM; RotatingStorm.color_mode = MODE_COLORS_RANDOM;
RotatingStorm.value = MODE_ROTATING_STORM; RotatingStorm.value = MODE_ROTATING_STORM;
RotatingStorm.colors_min = 1; RotatingStorm.colors_min = 1;
RotatingStorm.colors_max = 1; RotatingStorm.colors_max = 1;
RotatingStorm.colors.resize(1); RotatingStorm.colors.resize(1);
modes.push_back(RotatingStorm); modes.push_back(RotatingStorm);
mode Collision; mode Collision;
Collision.name = "Collision"; Collision.name = "Collision";
Collision.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; Collision.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Collision.speed_min = SPEED_SLOW; Collision.speed_min = SPEED_SLOW;
Collision.speed = SPEED_NORMAL; Collision.speed = SPEED_NORMAL;
Collision.speed_max = SPEED_FASTEST; Collision.speed_max = SPEED_FASTEST;
Collision.color_mode = MODE_COLORS_RANDOM; Collision.color_mode = MODE_COLORS_RANDOM;
Collision.value = MODE_COLLISION; Collision.value = MODE_COLLISION;
Collision.colors_min = 1; Collision.colors_min = 1;
Collision.colors_max = 1; Collision.colors_max = 1;
Collision.colors.resize(1); Collision.colors.resize(1);
modes.push_back(Collision); modes.push_back(Collision);
mode Perfect; mode Perfect;
Perfect.name = "Perfect"; Perfect.name = "Perfect";
Perfect.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; Perfect.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Perfect.speed_min = SPEED_SLOW; Perfect.speed_min = SPEED_SLOW;
Perfect.speed = SPEED_NORMAL; Perfect.speed = SPEED_NORMAL;
Perfect.speed_max = SPEED_FASTEST; Perfect.speed_max = SPEED_FASTEST;
Perfect.color_mode = MODE_COLORS_RANDOM; Perfect.color_mode = MODE_COLORS_RANDOM;
Perfect.value = MODE_PERFECT; Perfect.value = MODE_PERFECT;
Perfect.colors_min = 1; Perfect.colors_min = 1;
Perfect.colors_max = 1; Perfect.colors_max = 1;
Perfect.colors.resize(1); Perfect.colors.resize(1);
modes.push_back(Perfect); modes.push_back(Perfect);

12
Controllers/SinowealthController/SinowealthKeyboardController/SinowealthKeyboardController.cpp
View file

@ -71,10 +71,11 @@ static unsigned int keys_tkl_keys_indices_static_command[] = { 0x0022, 0x0024,
0x01E0, 0x01E2, 0x01E4, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA}; 0x01E0, 0x01E2, 0x01E4, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA};
SinowealthKeyboardController::SinowealthKeyboardController(hid_device* dev_cmd_handle, hid_device* dev_data_handle, char* path) SinowealthKeyboardController::SinowealthKeyboardController(hid_device* dev_cmd_handle, hid_device* dev_data_handle, char* path, std::string dev_name)
{ {
dev_cmd = dev_cmd_handle; dev_cmd = dev_cmd_handle;
dev_data = dev_data_handle; dev_data = dev_data_handle;
name = dev_name;
led_count = sizeof(tkl_keys_per_key_index) / sizeof(*tkl_keys_per_key_index); led_count = sizeof(tkl_keys_per_key_index) / sizeof(*tkl_keys_per_key_index);
@ -95,6 +96,11 @@ std::string SinowealthKeyboardController::GetLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string SinowealthKeyboardController::GetName()
{
return(name);
}
unsigned char SinowealthKeyboardController::GetCurrentMode() unsigned char SinowealthKeyboardController::GetCurrentMode()
{ {
return current_mode; return current_mode;

7
Controllers/SinowealthController/SinowealthKeyboardController/SinowealthKeyboardController.h
View file

@ -61,11 +61,12 @@ enum
class SinowealthKeyboardController class SinowealthKeyboardController
{ {
public: public:
SinowealthKeyboardController(hid_device* dev_cmd_handle, hid_device* dev_data_handle, char *_path); //RGB, Command, path SinowealthKeyboardController(hid_device* dev_cmd_handle, hid_device* dev_data_handle, char *_path, std::string dev_name); //RGB, Command, path
~SinowealthKeyboardController(); ~SinowealthKeyboardController();
unsigned int GetLEDCount(); unsigned int GetLEDCount();
std::string GetLocation(); std::string GetLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
unsigned char GetCurrentMode(); unsigned char GetCurrentMode();
@ -79,11 +80,9 @@ private:
hid_device* dev_cmd; hid_device* dev_cmd;
hid_device* dev_data; hid_device* dev_data;
device_type type; device_type type;
unsigned int led_count; unsigned int led_count;
unsigned char current_mode; unsigned char current_mode;
unsigned char current_speed; unsigned char current_speed;
std::string location; std::string location;
std::string name;
}; };