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

fixed one definition rule warnings

Browse source
This commit is contained in:
Cooper Hall 2023-07-10 18:13:47 +00:00 • committed by Adam Honse
parent 9c2a648d09
commit 9fab4110d7
14 changed files with 343 additions and 343 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp
View file

@ -45,9 +45,9 @@ typedef struct
const char * name;
const unsigned char zone;
const unsigned char idx;
} led_type;
} aw510k_led_type;
static const led_type led_names[] =
static const aw510k_led_type led_names[] =
{
/* Key Label Zone, Index */
{ KEY_EN_ESCAPE, ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD, 0xB0 },

4
Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp
View file

@ -40,9 +40,9 @@ typedef struct
{
const char * name;
const unsigned char idx;
} led_type;
} annepro2_led_type;
static const led_type led_names[] =
static const annepro2_led_type led_names[] =
{
/* Key Label Index */
{ KEY_EN_ESCAPE, 0 },

8
Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp
View file

@ -44,7 +44,7 @@ static unsigned int falchion_matrix_map[5][16] =
{ 3, NA, 12, 17, 21, 25, 29, 34, 38, 42, 47, 52, 56, NA, 61, 66 },
{ 4, 8, 13, NA, NA, NA, 30, NA, NA, NA, 43, 48, 53, 57, 62, 67 } };
static const std::vector<led_type> default_led_names =
static const std::vector<aura_keyboard_led> default_led_names =
{
/* Key Label Index */
{ KEY_EN_ESCAPE, 0x00 },
@ -153,7 +153,7 @@ static const std::vector<led_type> default_led_names =
{ KEY_EN_NUMPAD_ENTER, 0xB4 },
};
static const std::vector<led_type> default_tkl_led_names =
static const std::vector<aura_keyboard_led> default_tkl_led_names =
{
/* Key Label Index */
{ KEY_EN_ESCAPE, 0x00 },
@ -270,7 +270,7 @@ static const std::vector<led_type> default_tkl_led_names =
{ "Underglow 26", 0xCE },
};
static const std::vector<led_type> default_65pct_led_names =
static const std::vector<aura_keyboard_led> default_65pct_led_names =
{
/* Key Label Index */
{ KEY_EN_ESCAPE, 0x00 },
@ -395,7 +395,7 @@ void RGBController_AuraKeyboard::SetupZones()
| Set up zones |
\*---------------------------------------------------------*/
std::vector<led_zone> led_zones;
std::vector<led_type> led_names;
std::vector<aura_keyboard_led> led_names;
switch(layout)
{

2
Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h
View file

@ -24,7 +24,7 @@ typedef struct
{
const char* name;
unsigned char idx;
} led_type;
} aura_keyboard_led;
typedef struct
{

40
Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.cpp
View file

@ -130,7 +130,7 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
}
}
break;
case EVGA_GPU_V3_MODE_BREATHING:
{
uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_BREATHING + zone, 10, data_pkt);
@ -147,8 +147,8 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
uint8_t blue2 = data_pkt[7];
zone_config.colors[1] = ToRGBColor(red2, green2, blue2);
zone_config.numberOfColors= (zone_config.colors[1] != 0 ) ? 2 : 1 ;
speed16.LSB = data_pkt[8];
speed16.MSB = data_pkt[9];
speed16.lsb = data_pkt[8];
speed16.msb = data_pkt[9];
zone_config.speed = speed16.u16;
zone_config.direction = 0;
}
@ -169,8 +169,8 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
//Load data
zone_config.brightness = data_pkt[1];
zone_config.numberOfColors = 0;
speed16.LSB = data_pkt[2];
speed16.MSB = data_pkt[3];
speed16.lsb = data_pkt[2];
speed16.msb = data_pkt[3];
zone_config.speed = speed16.u16;
}
else
@ -192,8 +192,8 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
uint8_t blue = data_pkt[4];
zone_config.colors[0] = ToRGBColor(red, green, blue);
zone_config.numberOfColors = 1;
speed16.LSB = data_pkt[5];
speed16.MSB = data_pkt[6];
speed16.lsb = data_pkt[5];
speed16.msb = data_pkt[6];
zone_config.speed = speed16.u16;
}
else
@ -230,7 +230,7 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
{
readFail = true;
}
}
else
{
@ -257,11 +257,11 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
uint8_t blue = data_pkt[(color_index * 4) + 4];
zone_config.colors[color_index] = ToRGBColor(red, green, blue);
}
speed16.LSB = data_pkt[29];
speed16.MSB = data_pkt[30];
speed16.lsb = data_pkt[29];
speed16.msb = data_pkt[30];
zone_config.speed = speed16.u16;
}
else
else
{
readFail = true;
}
@ -288,7 +288,7 @@ EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
for(uint8_t i = 0; i < 7; i++)
{
zone_config.colors[i] = 0;
}
}
LOG_DEBUG("[%s] Failed while loading Zone %1d configuration from HW", evgaGPUName, zone);
}
return zone_config;
@ -423,8 +423,8 @@ void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone
zone_pkt[5] = RGBGetRValue(zone_config.colors[1]);
zone_pkt[6] = RGBGetGValue(zone_config.colors[1]);
zone_pkt[7] = RGBGetBValue(zone_config.colors[1]);
zone_pkt[8] = speed16.LSB;
zone_pkt[9] = speed16.MSB;
zone_pkt[8] = speed16.lsb;
zone_pkt[9] = speed16.msb;
bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
}
@ -439,8 +439,8 @@ void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone
zone_pkt[0] = sizeof(zone_pkt) - 1;
zone_pkt[1] = zone_config.brightness;
zone_pkt[2] = speed16.LSB;
zone_pkt[3] = speed16.MSB;
zone_pkt[2] = speed16.lsb;
zone_pkt[3] = speed16.msb;
bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
}
@ -456,8 +456,8 @@ void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone
zone_pkt[2] = RGBGetRValue(zone_config.colors[0]);
zone_pkt[3] = RGBGetGValue(zone_config.colors[0]);
zone_pkt[4] = RGBGetBValue(zone_config.colors[0]);
zone_pkt[5] = speed16.LSB;
zone_pkt[6] = speed16.MSB;
zone_pkt[5] = speed16.lsb;
zone_pkt[6] = speed16.msb;
bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
}
@ -480,8 +480,8 @@ void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone
zone_pkt[3 + color_index * 4] = RGBGetGValue(zone_config.colors[color_index]);
zone_pkt[4 + color_index * 4] = RGBGetBValue(zone_config.colors[color_index]);
}
zone_pkt[29] = speed16.LSB;
zone_pkt[30] = speed16.MSB;
zone_pkt[29] = speed16.lsb;
zone_pkt[30] = speed16.msb;
// Color Count packet construction
color_cnt_pkt[0] = sizeof(color_cnt_pkt) - 1;

6
Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.h
View file

@ -27,8 +27,8 @@ union u16_to_u8
uint16_t u16;
struct
{
uint8_t LSB;
uint8_t MSB;
uint8_t lsb;
uint8_t msb;
};
};
@ -67,7 +67,7 @@ enum //Control registers and offsets
enum //Mode values for EVGA_GPU_V3_REG_MODE
{
EVGA_GPU_V3_MODE_OFF = 0x00,
EVGA_GPU_V3_MODE_STATIC = 0x01,
EVGA_GPU_V3_MODE_STATIC = 0x01,
EVGA_GPU_V3_MODE_BREATHING = 0x02,
EVGA_GPU_V3_MODE_RAINBOW = 0x03,
EVGA_GPU_V3_MODE_COLOR_CYCLE = 0x04,

30
Controllers/EVGATuringGPUController/EVGAGPUv2Controller.cpp
View file

@ -70,7 +70,7 @@ unsigned char EVGAGPUv2Controller::GetMode()
return_mode = EVGA_GPU_V2_RGB_MODE_OFF;
}
break;
case EVGA_GPU_V2_MODE_STATIC:
{
return_mode = EVGA_GPU_V2_RGB_MODE_STATIC;
@ -87,8 +87,8 @@ unsigned char EVGAGPUv2Controller::GetMode()
{
u16_to_u8 speed_16 = { (uint16_t) 0 };
speed_16.LSB = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_LSB);
speed_16.MSB = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_MSB);
speed_16.lsb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_LSB);
speed_16.msb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_MSB);
if (speed_16.u16 == 0)
{
@ -112,8 +112,8 @@ unsigned char EVGAGPUv2Controller::GetSpeed()
{
u16_to_u8 speed_16 = { (uint16_t) 0 };
speed_16.LSB = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_LSB);
speed_16.MSB = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB);
speed_16.lsb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_LSB);
speed_16.msb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB);
speed_16.u16 /= SPEED_MULTIPLIER;
@ -235,16 +235,16 @@ void EVGAGPUv2Controller::SendMode(uint8_t mode)
void EVGAGPUv2Controller::SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to_u8 b2a, u16_to_u8 a2b, u16_to_u8 speed_un)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_UN_LSB, (unsigned char) speed_un.LSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_UN_MSB, (unsigned char) speed_un.MSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_LSB, (unsigned char) b2a.LSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_MSB, (unsigned char) b2a.MSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_ONTIME_LSB, (unsigned char) bOnTime.LSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_ONTIME_MSB, (unsigned char) bOnTime.MSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_A_TO_B_SPEED_LSB, (unsigned char) a2b.LSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_A_TO_B_SPEED_MSB, (unsigned char) a2b.MSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_LSB, (unsigned char) aOnTime.LSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB, (unsigned char) aOnTime.MSB );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_UN_LSB, (unsigned char) speed_un.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_UN_MSB, (unsigned char) speed_un.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_LSB, (unsigned char) b2a.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_MSB, (unsigned char) b2a.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_ONTIME_LSB, (unsigned char) bOnTime.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_ONTIME_MSB, (unsigned char) bOnTime.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_A_TO_B_SPEED_LSB, (unsigned char) a2b.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_A_TO_B_SPEED_MSB, (unsigned char) a2b.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_LSB, (unsigned char) aOnTime.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB, (unsigned char) aOnTime.msb );
}
void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness)

6
Controllers/EVGATuringGPUController/EVGAGPUv2Controller.h
View file

@ -26,8 +26,8 @@ union u16_to_u8
uint16_t u16;
struct
{
uint8_t LSB;
uint8_t MSB;
uint8_t lsb;
uint8_t msb;
};
};
@ -66,7 +66,7 @@ enum
enum
{
EVGA_GPU_V2_MODE_OFF = 0x00,
EVGA_GPU_V2_MODE_STATIC = 0x01,
EVGA_GPU_V2_MODE_STATIC = 0x01,
EVGA_GPU_V2_MODE_RAINBOW = 0x0F,
EVGA_GPU_V2_MODE_BREATHING = 0x22,
};

4
Controllers/LogitechController/RGBController_LogitechG815.cpp
View file

@ -46,9 +46,9 @@ typedef struct
const char * name;
const unsigned char zone;
const unsigned char idx;
} led_type;
} logitech_g815_led;
static const led_type led_names[] =
static const logitech_g815_led led_names[] =
{
/* Key Label Zone, Index */
{ KEY_EN_A, LOGITECH_G815_ZONE_DIRECT_KEYBOARD, 0x04 },

8
Controllers/MSIMysticLightController/MSIMysticLight162Controller.cpp
View file

@ -17,7 +17,7 @@
#define BITSET(val, bit, pos) ((unsigned char)std::bitset<8>(val).set((pos), (bit)).to_ulong())
struct Config
struct mystic_light_162_config
{
unsigned short pid; // PID of the board
size_t numof_onboard_leds; // number of onboard leds
@ -65,9 +65,9 @@ const std::vector<MSI_ZONE> zones_set3 =
| Boards with yet unknown supported zones are configured to support all zones. |
\*-----------------------------------------------------------------------------------------------------------------------------*/
#define NUMOF_CONFIGS (sizeof(board_configs) / sizeof(Config))
#define NUMOF_CONFIGS (sizeof(board_configs) / sizeof(mystic_light_162_config))
static const Config board_configs[] =
static const mystic_light_162_config board_configs[] =
{
{ 0x1720, 10, &zones_set0 }, // MPG Z390 GAMING EDGE AC
{ 0x7B12, 10, &zones_set0 }, // MEG Z390 ACE
@ -107,7 +107,7 @@ MSIMysticLight162Controller::MSIMysticLight162Controller
/*-----------------------------------------*\
| Initialize zone based per LED data |
\*-----------------------------------------*/
const Config* board_config = nullptr;
const mystic_light_162_config* board_config = nullptr;
for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
{

8
Controllers/MSIMysticLightController/MSIMysticLight185Controller.cpp
View file

@ -34,7 +34,7 @@ using namespace std::chrono_literals;
#define PER_LED_FULL_SYNC_MODE (PER_LED_BASIC_SYNC_MODE | SYNC_SETTING_JRAINBOW1 | SYNC_SETTING_JRAINBOW2 | SYNC_SETTING_JCORSAIR)
struct Config
struct mystic_light_185_config
{
unsigned short pid; // PID of the board
int numof_onboard_leds; // number of onboard leds
@ -210,9 +210,9 @@ const std::vector<MSI_ZONE> zones_set16 =
| Boards with yet unknown supported zones are configured to support all zones. |
\*---------------------------------------------------------------------------------------------------------------------------------*/
#define NUMOF_CONFIGS (sizeof(board_configs) / sizeof(Config))
#define NUMOF_CONFIGS (sizeof(board_configs) / sizeof(mystic_light_185_config))
static const Config board_configs[] =
static const mystic_light_185_config board_configs[] =
{
{ 0x7B93, 6, 1, 0, 1, &zones_set3, MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED }, // MPG X570 GAMING PRO CARBON WIFI
{ 0x7C34, 0, 1, 1, 1, &zones_set8, MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED }, // MEG X570 GODLIKE
@ -325,7 +325,7 @@ MSIMysticLight185Controller::MSIMysticLight185Controller
data.save_data = 0;
data.on_board_led.colorFlags = 0x80 | SYNC_SETTING_ONBOARD; // always enable onboard sync flag to have expected zone control
const Config* board_config = nullptr;
const mystic_light_185_config* board_config = nullptr;
for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
{

466
Controllers/OpenRazerController/OpenRazerDevices.h
View file

File diff suppressed because it is too large Load diff

68
Controllers/OpenRazerController/RGBController_OpenRazer.cpp
View file

@ -20,9 +20,9 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
switch(matrix_type)
{
case RAZER_TYPE_MATRIX_FRAME:
case RAZER_TYPE_MATRIX_NOFRAME:
case RAZER_TYPE_MATRIX_STATIC:
case OPEN_RAZER_TYPE_MATRIX_FRAME:
case OPEN_RAZER_TYPE_MATRIX_NOFRAME:
case OPEN_RAZER_TYPE_MATRIX_STATIC:
{
char update_value = 1;
@ -32,7 +32,7 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
unsigned int output_offset;
unsigned int row_offset = (row * matrix_cols);
if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
if(matrix_type == OPEN_RAZER_TYPE_MATRIX_FRAME)
{
output_array_size = 3 + (matrix_cols* 3);
output_offset = 3;
@ -45,7 +45,7 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
char* output_array = new char[output_array_size];
if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
if(matrix_type == OPEN_RAZER_TYPE_MATRIX_FRAME)
{
output_array[0] = row;
output_array[1] = 0;
@ -60,12 +60,12 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
output_array[(col * 3) + 2 + output_offset] = (char)RGBGetBValue(colors[color_idx]);
}
if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
if(matrix_type == OPEN_RAZER_TYPE_MATRIX_FRAME)
{
matrix_custom_frame.write(output_array, output_array_size);
matrix_custom_frame.flush();
}
else if(matrix_type == RAZER_TYPE_MATRIX_NOFRAME)
else if(matrix_type == OPEN_RAZER_TYPE_MATRIX_NOFRAME)
{
matrix_effect_custom.write(output_array, output_array_size);
matrix_effect_custom.flush();
@ -81,7 +81,7 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
std::this_thread::sleep_for(1ms);
}
if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
if(matrix_type == OPEN_RAZER_TYPE_MATRIX_FRAME)
{
matrix_effect_custom.write(&update_value, 1);
matrix_effect_custom.flush();
@ -89,7 +89,7 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
}
break;
case RAZER_TYPE_NOMATRIX:
case OPEN_RAZER_TYPE_NOMATRIX:
{
DeviceUpdateMode();
}
@ -113,11 +113,11 @@ void RGBController_OpenRazer::SetupMatrixDevice(unsigned int rows, unsigned int
{
if(!matrix_effect_custom)
{
matrix_type = RAZER_TYPE_MATRIX_STATIC;
matrix_type = OPEN_RAZER_TYPE_MATRIX_STATIC;
}
else
{
matrix_type = RAZER_TYPE_MATRIX_NOFRAME;
matrix_type = OPEN_RAZER_TYPE_MATRIX_NOFRAME;
}
matrix_rows = 1;
@ -125,7 +125,7 @@ void RGBController_OpenRazer::SetupMatrixDevice(unsigned int rows, unsigned int
}
else
{
matrix_type = RAZER_TYPE_MATRIX_FRAME;
matrix_type = OPEN_RAZER_TYPE_MATRIX_FRAME;
matrix_rows = rows;
matrix_cols = cols;
@ -134,7 +134,7 @@ void RGBController_OpenRazer::SetupMatrixDevice(unsigned int rows, unsigned int
void RGBController_OpenRazer::SetupNonMatrixDevice()
{
matrix_type = RAZER_TYPE_NOMATRIX;
matrix_type = OPEN_RAZER_TYPE_NOMATRIX;
}
void RGBController_OpenRazer::OpenFunctions(std::string dev_path)
@ -267,7 +267,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
/*-----------------------------------------------------------------*\
| Loop through all known devices to look for a name match |
\*-----------------------------------------------------------------*/
for (std::size_t i = 0; i < RAZER_NUM_DEVICES; i++)
for (std::size_t i = 0; i < OPEN_RAZER_NUM_DEVICES; i++)
{
if (device_list[i]->name == name)
{
@ -288,7 +288,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Direct;
Direct.name = "Direct";
Direct.value = RAZER_MODE_CUSTOM;
Direct.value = OPEN_RAZER_MODE_CUSTOM;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
@ -309,7 +309,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Off;
Off.name = "Off";
Off.value = RAZER_MODE_OFF;
Off.value = OPEN_RAZER_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
@ -330,7 +330,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Static;
Static.name = "Static";
Static.value = RAZER_MODE_STATIC;
Static.value = OPEN_RAZER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
@ -350,7 +350,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = RAZER_MODE_BREATHING;
Breathing.value = OPEN_RAZER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
@ -368,7 +368,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = RAZER_MODE_BREATHING;
Breathing.value = OPEN_RAZER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
@ -386,7 +386,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = RAZER_MODE_FLASHING;
Flashing.value = OPEN_RAZER_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flashing.colors_min = 1;
Flashing.colors_max = 1;
@ -410,7 +410,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.value = OPEN_RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
@ -425,7 +425,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Wave;
Wave.name = "Wave";
Wave.value = RAZER_MODE_WAVE;
Wave.value = OPEN_RAZER_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_DIRECTION_LR;
Wave.direction = MODE_DIRECTION_RIGHT;
Wave.color_mode = MODE_COLORS_NONE;
@ -443,7 +443,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
{
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = RAZER_MODE_REACTIVE;
Reactive.value = OPEN_RAZER_MODE_REACTIVE;
Reactive.flags = 0;
Reactive.color_mode = MODE_COLORS_NONE;
modes.push_back(Reactive);
@ -490,7 +490,7 @@ void RGBController_OpenRazer::SetupZones()
/*---------------------------------------------------------*\
| Fill in zone information based on device table |
\*---------------------------------------------------------*/
for(unsigned int zone_id = 0; zone_id < RAZER_MAX_ZONES; zone_id++)
for(unsigned int zone_id = 0; zone_id < OPEN_RAZER_MAX_ZONES; zone_id++)
{
if(device_list[device_index]->zones[zone_id] != NULL)
{
@ -579,7 +579,7 @@ void RGBController_OpenRazer::SetCustomMode()
/*---------------------------------------------------------*\
| If device supports custom mode, it will be mode index 0 |
\*---------------------------------------------------------*/
if(modes[0].value == RAZER_MODE_CUSTOM)
if(modes[0].value == OPEN_RAZER_MODE_CUSTOM)
{
active_mode = 0;
}
@ -590,7 +590,7 @@ void RGBController_OpenRazer::SetCustomMode()
{
for(unsigned int i = 0; i < modes.size(); i++)
{
if(modes[i].value == RAZER_MODE_STATIC)
if(modes[i].value == OPEN_RAZER_MODE_STATIC)
{
active_mode = i;
break;
@ -608,7 +608,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
switch(modes[active_mode].value)
{
case RAZER_MODE_CUSTOM:
case OPEN_RAZER_MODE_CUSTOM:
if(matrix_effect_custom)
{
matrix_effect_custom.write(update_value, 1);
@ -616,7 +616,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
}
break;
case RAZER_MODE_OFF:
case OPEN_RAZER_MODE_OFF:
if(matrix_effect_none)
{
matrix_effect_none.write(update_value, 1);
@ -669,7 +669,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
}
break;
case RAZER_MODE_STATIC:
case OPEN_RAZER_MODE_STATIC:
effect_value[0] = '0';
if(backlight_led_state)
@ -752,7 +752,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
}
break;
case RAZER_MODE_FLASHING:
case OPEN_RAZER_MODE_FLASHING:
effect_value[0] = '1';
if(backlight_led_state)
@ -805,7 +805,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
}
break;
case RAZER_MODE_BREATHING:
case OPEN_RAZER_MODE_BREATHING:
effect_value[0] = '2';
switch(modes[active_mode].color_mode)
@ -965,7 +965,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
}
break;
case RAZER_MODE_SPECTRUM_CYCLE:
case OPEN_RAZER_MODE_SPECTRUM_CYCLE:
effect_value[0] = '4';
if(backlight_led_state)
@ -1038,7 +1038,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
}
break;
case RAZER_MODE_WAVE:
case OPEN_RAZER_MODE_WAVE:
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
@ -1069,7 +1069,7 @@ void RGBController_OpenRazer::DeviceUpdateMode()
}
break;
case RAZER_MODE_REACTIVE:
case OPEN_RAZER_MODE_REACTIVE:
if(matrix_effect_reactive)
{
matrix_effect_reactive.write(update_value, 1);

32
Controllers/OpenRazerController/RGBController_OpenRazer.h
View file

@ -18,24 +18,24 @@ class RGBController_OpenRazer : public RGBController
public:
enum
{
RAZER_MODE_CUSTOM,
RAZER_MODE_OFF,
RAZER_MODE_STATIC,
RAZER_MODE_BREATHING,
RAZER_MODE_SPECTRUM_CYCLE,
RAZER_MODE_WAVE,
RAZER_MODE_REACTIVE,
RAZER_MODE_FLASHING,
RAZER_NUM_MODES
OPEN_RAZER_MODE_CUSTOM,
OPEN_RAZER_MODE_OFF,
OPEN_RAZER_MODE_STATIC,
OPEN_RAZER_MODE_BREATHING,
OPEN_RAZER_MODE_SPECTRUM_CYCLE,
OPEN_RAZER_MODE_WAVE,
OPEN_RAZER_MODE_REACTIVE,
OPEN_RAZER_MODE_FLASHING,
OPEN_RAZER_NUM_MODES
};
enum
{
RAZER_TYPE_MATRIX_FRAME,
RAZER_TYPE_MATRIX_NOFRAME,
RAZER_TYPE_MATRIX_STATIC,
RAZER_TYPE_NOMATRIX,
RAZER_NUM_TYPES
OPEN_RAZER_TYPE_MATRIX_FRAME,
OPEN_RAZER_TYPE_MATRIX_NOFRAME,
OPEN_RAZER_TYPE_MATRIX_STATIC,
OPEN_RAZER_TYPE_NOMATRIX,
OPEN_RAZER_NUM_TYPES
};
public:
@ -113,11 +113,11 @@ private:
std::ofstream backlight_led_effect;
std::ofstream backlight_led_rgb;
std::ofstream backlight_led_state;
std::ofstream logo_led_effect;
std::ofstream logo_led_rgb;
std::ofstream logo_led_state;
std::ofstream scroll_led_effect;
std::ofstream scroll_led_rgb;
std::ofstream scroll_led_state;