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

fixed OpenRazer compiling error on windows

Browse source
This commit is contained in:
Cooper Hall 2023-07-10 19:51:27 +00:00 • committed by Adam Honse
parent 3ee6af0dfd
commit 14c74248dd
2 changed files with 251 additions and 251 deletions
Download patch file Download diff file Expand all files Collapse all files

466
Controllers/OpenRazerController/RGBController_OpenRazerWindows.cpp
View file

@ -22,9 +22,9 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
{ {
switch(matrix_type) switch(matrix_type)
{ {
case RAZER_TYPE_MATRIX_FRAME: case OPEN_RAZER_TYPE_MATRIX_FRAME:
case RAZER_TYPE_MATRIX_NOFRAME: case OPEN_RAZER_TYPE_MATRIX_NOFRAME:
case RAZER_TYPE_MATRIX_STATIC: case OPEN_RAZER_TYPE_MATRIX_STATIC:
{ {
char update_value = 1; char update_value = 1;
@ -34,7 +34,7 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
unsigned int output_offset; unsigned int output_offset;
unsigned int row_offset = (row * matrix_cols); 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_array_size = 3 + (matrix_cols* 3);
output_offset = 3; output_offset = 3;
@ -47,7 +47,7 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
char* output_array = new char[output_array_size]; 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[0] = row;
output_array[1] = 0; output_array[1] = 0;
@ -62,17 +62,17 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
output_array[(col * 3) + 2 + output_offset] = (char)RGBGetBValue(colors[color_idx]); 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)
{ {
razer_functions->matrix_custom_frame->store(razer_device, NULL, output_array, output_array_size); open_razer_functions->matrix_custom_frame->store(open_razer_device, NULL, output_array, output_array_size);
} }
else if(matrix_type == RAZER_TYPE_MATRIX_NOFRAME) else if(matrix_type == OPEN_RAZER_TYPE_MATRIX_NOFRAME)
{ {
razer_functions->matrix_effect_custom->store(razer_device, NULL, output_array, output_array_size); open_razer_functions->matrix_effect_custom->store(open_razer_device, NULL, output_array, output_array_size);
} }
else else
{ {
razer_functions->matrix_effect_static->store(razer_device, NULL, output_array, output_array_size); open_razer_functions->matrix_effect_static->store(open_razer_device, NULL, output_array, output_array_size);
} }
delete[] output_array; delete[] output_array;
@ -80,14 +80,14 @@ void RGBController_OpenRazer::DeviceUpdateLEDs()
std::this_thread::sleep_for(1ms); std::this_thread::sleep_for(1ms);
} }
if(matrix_type == RAZER_TYPE_MATRIX_FRAME) if(matrix_type == OPEN_RAZER_TYPE_MATRIX_FRAME)
{ {
razer_functions->matrix_effect_custom->store(razer_device, NULL, &update_value, 1); open_razer_functions->matrix_effect_custom->store(open_razer_device, NULL, &update_value, 1);
} }
} }
break; break;
case RAZER_TYPE_NOMATRIX: case OPEN_RAZER_TYPE_NOMATRIX:
{ {
DeviceUpdateMode(); DeviceUpdateMode();
} }
@ -105,17 +105,17 @@ void RGBController_OpenRazer::UpdateSingleLED(int /*led*/)
DeviceUpdateLEDs(); DeviceUpdateLEDs();
} }
void RGBController_OpenRazer::SetupMatrixDevice(device_fn_type* razer_functions, unsigned int rows, unsigned int cols) void RGBController_OpenRazer::SetupMatrixDevice(device_fn_type* open_razer_functions, unsigned int rows, unsigned int cols)
{ {
if(!razer_functions->matrix_custom_frame) if(!open_razer_functions->matrix_custom_frame)
{ {
if(!razer_functions->matrix_effect_custom) if(!open_razer_functions->matrix_effect_custom)
{ {
matrix_type = RAZER_TYPE_MATRIX_STATIC; matrix_type = OPEN_RAZER_TYPE_MATRIX_STATIC;
} }
else else
{ {
matrix_type = RAZER_TYPE_MATRIX_NOFRAME; matrix_type = OPEN_RAZER_TYPE_MATRIX_NOFRAME;
} }
matrix_rows = 1; matrix_rows = 1;
@ -123,7 +123,7 @@ void RGBController_OpenRazer::SetupMatrixDevice(device_fn_type* razer_functions,
} }
else else
{ {
matrix_type = RAZER_TYPE_MATRIX_FRAME; matrix_type = OPEN_RAZER_TYPE_MATRIX_FRAME;
matrix_rows = rows; matrix_rows = rows;
matrix_cols = cols; matrix_cols = cols;
@ -132,7 +132,7 @@ void RGBController_OpenRazer::SetupMatrixDevice(device_fn_type* razer_functions,
void RGBController_OpenRazer::SetupNonMatrixDevice() void RGBController_OpenRazer::SetupNonMatrixDevice()
{ {
matrix_type = RAZER_TYPE_NOMATRIX; matrix_type = OPEN_RAZER_TYPE_NOMATRIX;
} }
/**------------------------------------------------------------------*\ /**------------------------------------------------------------------*\
@ -147,12 +147,12 @@ void RGBController_OpenRazer::SetupNonMatrixDevice()
the in built Razer controller. the in built Razer controller.
\*-------------------------------------------------------------------*/ \*-------------------------------------------------------------------*/
RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_fn_type* razer_functions) RGBController_OpenRazer::RGBController_OpenRazer(device * open_razer_device, device_fn_type* open_razer_functions)
{ {
char string_buf[1024]; char string_buf[1024];
this->razer_device = razer_device; this->open_razer_device = open_razer_device;
this->razer_functions = razer_functions; this->open_razer_functions = open_razer_functions;
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| Start device at -1. This indicates the device was not detected | | Start device at -1. This indicates the device was not detected |
@ -162,7 +162,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| Get the device name from the OpenRazer driver | | Get the device name from the OpenRazer driver |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
razer_functions->device_type->show(razer_device, NULL, string_buf); open_razer_functions->device_type->show(open_razer_device, NULL, string_buf);
name = string_buf; name = string_buf;
name.erase(std::remove(name.begin(), name.end(), '\n'), name.end()); name.erase(std::remove(name.begin(), name.end(), '\n'), name.end());
name.erase(std::remove(name.begin(), name.end(), '\r'), name.end()); name.erase(std::remove(name.begin(), name.end(), '\r'), name.end());
@ -180,7 +180,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| Get the serial number from the dev path | | Get the serial number from the dev path |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
razer_functions->device_serial->show(razer_device, NULL, string_buf); open_razer_functions->device_serial->show(open_razer_device, NULL, string_buf);
serial = string_buf; serial = string_buf;
serial.erase(std::remove(serial.begin(), serial.end(), '\n'), serial.end()); serial.erase(std::remove(serial.begin(), serial.end(), '\n'), serial.end());
serial.erase(std::remove(serial.begin(), serial.end(), '\r'), serial.end()); serial.erase(std::remove(serial.begin(), serial.end(), '\r'), serial.end());
@ -188,7 +188,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| Get the firmware version from the dev path | | Get the firmware version from the dev path |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
razer_functions->firmware_version->show(razer_device, NULL, string_buf); open_razer_functions->firmware_version->show(open_razer_device, NULL, string_buf);
version = string_buf; version = string_buf;
version.erase(std::remove(version.begin(), version.end(), '\n'), version.end()); version.erase(std::remove(version.begin(), version.end(), '\n'), version.end());
version.erase(std::remove(version.begin(), version.end(), '\r'), version.end()); version.erase(std::remove(version.begin(), version.end(), '\r'), version.end());
@ -201,7 +201,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| Loop through all known devices to look for a name match | | Loop through all known devices to look for a name match |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
for (unsigned int i = 0; i < RAZER_NUM_DEVICES; i++) for (unsigned int i = 0; i < OPEN_RAZER_NUM_DEVICES; i++)
{ {
if (device_list[i]->name == name) if (device_list[i]->name == name)
{ {
@ -218,11 +218,11 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Device has Direct mode if matrix_custom_frame exists | | Device has Direct mode if matrix_custom_frame exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if(razer_functions->matrix_effect_custom) if(open_razer_functions->matrix_effect_custom)
{ {
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = RAZER_MODE_CUSTOM; Direct.value = OPEN_RAZER_MODE_CUSTOM;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
@ -232,18 +232,18 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
| Device has Off mode if any _effect_none or any _state | | Device has Off mode if any _effect_none or any _state |
| exists | | exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( razer_functions->matrix_effect_none if( open_razer_functions->matrix_effect_none
|| razer_functions->logo_matrix_effect_none || open_razer_functions->logo_matrix_effect_none
|| razer_functions->scroll_matrix_effect_none || open_razer_functions->scroll_matrix_effect_none
|| razer_functions->left_matrix_effect_none || open_razer_functions->left_matrix_effect_none
|| razer_functions->right_matrix_effect_none || open_razer_functions->right_matrix_effect_none
/*|| razer_functions->backlight_led_state*/ /*|| open_razer_functions->backlight_led_state*/
|| razer_functions->logo_led_state || open_razer_functions->logo_led_state
|| razer_functions->scroll_led_state) || open_razer_functions->scroll_led_state)
{ {
mode Off; mode Off;
Off.name = "Off"; Off.name = "Off";
Off.value = RAZER_MODE_OFF; Off.value = OPEN_RAZER_MODE_OFF;
Off.flags = 0; Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE; Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off); modes.push_back(Off);
@ -253,18 +253,18 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
| Device has Static mode if any _effect_static or any | | Device has Static mode if any _effect_static or any |
| _effect exists | | _effect exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( razer_functions->matrix_effect_static if( open_razer_functions->matrix_effect_static
|| razer_functions->logo_matrix_effect_static || open_razer_functions->logo_matrix_effect_static
|| razer_functions->scroll_matrix_effect_static || open_razer_functions->scroll_matrix_effect_static
|| razer_functions->left_matrix_effect_static || open_razer_functions->left_matrix_effect_static
|| razer_functions->right_matrix_effect_static || open_razer_functions->right_matrix_effect_static
/*|| razer_functions->backlight_led_effect*/ /*|| open_razer_functions->backlight_led_effect*/
|| razer_functions->logo_led_effect || open_razer_functions->logo_led_effect
|| razer_functions->scroll_led_effect) || open_razer_functions->scroll_led_effect)
{ {
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.value = RAZER_MODE_STATIC; Static.value = OPEN_RAZER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
@ -276,15 +276,15 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Device has Breathing mode if any _effect_breath exists | | Device has Breathing mode if any _effect_breath exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( razer_functions->matrix_effect_breath if( open_razer_functions->matrix_effect_breath
|| razer_functions->logo_matrix_effect_breath || open_razer_functions->logo_matrix_effect_breath
|| razer_functions->scroll_matrix_effect_breath || open_razer_functions->scroll_matrix_effect_breath
|| razer_functions->left_matrix_effect_breath || open_razer_functions->left_matrix_effect_breath
|| razer_functions->right_matrix_effect_breath) || open_razer_functions->right_matrix_effect_breath)
{ {
mode Breathing; mode Breathing;
Breathing.name = "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.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 2; Breathing.colors_max = 2;
@ -296,13 +296,13 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Device has limited Breathing mode if any _effect exists | | Device has limited Breathing mode if any _effect exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( /*razer_functions->backlight_led_effect ||*/ if( /*open_razer_functions->backlight_led_effect ||*/
razer_functions->logo_led_effect open_razer_functions->logo_led_effect
|| razer_functions->scroll_led_effect) || open_razer_functions->scroll_led_effect)
{ {
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = RAZER_MODE_BREATHING; Breathing.value = OPEN_RAZER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 1; Breathing.colors_max = 1;
@ -314,13 +314,13 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Device has Flashing mode if any _effect exists | | Device has Flashing mode if any _effect exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( /*razer_functions->backlight_led_effect ||*/ if( /*open_razer_functions->backlight_led_effect ||*/
razer_functions->logo_led_effect open_razer_functions->logo_led_effect
|| razer_functions->scroll_led_effect) || open_razer_functions->scroll_led_effect)
{ {
mode Flashing; mode Flashing;
Flashing.name = "Flashing"; Flashing.name = "Flashing";
Flashing.value = RAZER_MODE_FLASHING; Flashing.value = OPEN_RAZER_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Flashing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flashing.colors_min = 1; Flashing.colors_min = 1;
Flashing.colors_max = 1; Flashing.colors_max = 1;
@ -333,18 +333,18 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
| Device has Spectrum Cycle mode if any _effect_spectrum or | | Device has Spectrum Cycle mode if any _effect_spectrum or |
| _effect exists | | _effect exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( razer_functions->matrix_effect_spectrum if( open_razer_functions->matrix_effect_spectrum
|| razer_functions->logo_matrix_effect_spectrum || open_razer_functions->logo_matrix_effect_spectrum
|| razer_functions->scroll_matrix_effect_spectrum || open_razer_functions->scroll_matrix_effect_spectrum
|| razer_functions->left_matrix_effect_spectrum || open_razer_functions->left_matrix_effect_spectrum
|| razer_functions->right_matrix_effect_spectrum || open_razer_functions->right_matrix_effect_spectrum
/*|| razer_functions->backlight_led_effect*/ /*|| open_razer_functions->backlight_led_effect*/
|| razer_functions->logo_led_effect || open_razer_functions->logo_led_effect
|| razer_functions->scroll_led_effect) || open_razer_functions->scroll_led_effect)
{ {
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE; SpectrumCycle.value = OPEN_RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0; SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE; SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle); modes.push_back(SpectrumCycle);
@ -353,13 +353,13 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Device has Wave mode if any _effect_wave exists | | Device has Wave mode if any _effect_wave exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( razer_functions->matrix_effect_wave if( open_razer_functions->matrix_effect_wave
|| razer_functions->left_matrix_effect_wave || open_razer_functions->left_matrix_effect_wave
|| razer_functions->right_matrix_effect_wave) || open_razer_functions->right_matrix_effect_wave)
{ {
mode Wave; mode Wave;
Wave.name = "Wave"; Wave.name = "Wave";
Wave.value = RAZER_MODE_WAVE; Wave.value = OPEN_RAZER_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_DIRECTION_LR; Wave.flags = MODE_FLAG_HAS_DIRECTION_LR;
Wave.direction = MODE_DIRECTION_RIGHT; Wave.direction = MODE_DIRECTION_RIGHT;
Wave.color_mode = MODE_COLORS_NONE; Wave.color_mode = MODE_COLORS_NONE;
@ -369,15 +369,15 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Device has Reactive mode if any _effect_reactive exists | | Device has Reactive mode if any _effect_reactive exists |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if( razer_functions->matrix_effect_reactive if( open_razer_functions->matrix_effect_reactive
|| razer_functions->logo_matrix_effect_reactive || open_razer_functions->logo_matrix_effect_reactive
|| razer_functions->scroll_matrix_effect_reactive || open_razer_functions->scroll_matrix_effect_reactive
|| razer_functions->left_matrix_effect_reactive || open_razer_functions->left_matrix_effect_reactive
|| razer_functions->right_matrix_effect_reactive) || open_razer_functions->right_matrix_effect_reactive)
{ {
mode Reactive; mode Reactive;
Reactive.name = "Reactive"; Reactive.name = "Reactive";
Reactive.value = RAZER_MODE_REACTIVE; Reactive.value = OPEN_RAZER_MODE_REACTIVE;
Reactive.flags = 0; Reactive.flags = 0;
Reactive.color_mode = MODE_COLORS_NONE; Reactive.color_mode = MODE_COLORS_NONE;
modes.push_back(Reactive); modes.push_back(Reactive);
@ -388,7 +388,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
if(device_list[i]->matrix_type == true) if(device_list[i]->matrix_type == true)
{ {
SetupMatrixDevice(razer_functions, device_list[i]->rows, device_list[i]->cols); SetupMatrixDevice(open_razer_functions, device_list[i]->rows, device_list[i]->cols);
} }
else else
{ {
@ -425,7 +425,7 @@ void RGBController_OpenRazer::SetupZones()
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Fill in zone information based on device table | | 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) if(device_list[device_index]->zones[zone_id] != NULL)
{ {
@ -514,7 +514,7 @@ void RGBController_OpenRazer::SetCustomMode()
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| If device supports custom mode, it will be mode index 0 | | 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; active_mode = 0;
} }
@ -525,7 +525,7 @@ void RGBController_OpenRazer::SetCustomMode()
{ {
for(unsigned int i = 0; i < modes.size(); i++) 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; active_mode = i;
break; break;
@ -543,193 +543,193 @@ void RGBController_OpenRazer::DeviceUpdateMode()
switch(modes[active_mode].value) switch(modes[active_mode].value)
{ {
case RAZER_MODE_CUSTOM: case OPEN_RAZER_MODE_CUSTOM:
if(razer_functions->matrix_effect_custom) if(open_razer_functions->matrix_effect_custom)
{ {
razer_functions->matrix_effect_custom->store(razer_device, NULL, update_value, 1); open_razer_functions->matrix_effect_custom->store(open_razer_device, NULL, update_value, 1);
} }
break; break;
case RAZER_MODE_OFF: case OPEN_RAZER_MODE_OFF:
if(razer_functions->matrix_effect_none) if(open_razer_functions->matrix_effect_none)
{ {
razer_functions->matrix_effect_none->store(razer_device, NULL, update_value, 1); open_razer_functions->matrix_effect_none->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->logo_matrix_effect_none) if(open_razer_functions->logo_matrix_effect_none)
{ {
razer_functions->logo_matrix_effect_none->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_matrix_effect_none->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_matrix_effect_none) if(open_razer_functions->scroll_matrix_effect_none)
{ {
razer_functions->scroll_matrix_effect_none->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_matrix_effect_none->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->left_matrix_effect_none) if(open_razer_functions->left_matrix_effect_none)
{ {
razer_functions->left_matrix_effect_none->store(razer_device, NULL, update_value, 1); open_razer_functions->left_matrix_effect_none->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->right_matrix_effect_none) if(open_razer_functions->right_matrix_effect_none)
{ {
razer_functions->right_matrix_effect_none->store(razer_device, NULL, update_value, 1); open_razer_functions->right_matrix_effect_none->store(open_razer_device, NULL, update_value, 1);
} }
//if(razer_functions->backlight_led_state) //if(open_razer_functions->backlight_led_state)
//{ //{
// update_value[0] = '0'; // update_value[0] = '0';
// razer_functions->backlight_led_state->store(razer_device, NULL, update_value, 1); // open_razer_functions->backlight_led_state->store(open_razer_device, NULL, update_value, 1);
//} //}
if(razer_functions->logo_led_state) if(open_razer_functions->logo_led_state)
{ {
update_value[0] = '0'; update_value[0] = '0';
razer_functions->logo_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_led_state->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_led_state) if(open_razer_functions->scroll_led_state)
{ {
update_value[0] = '0'; update_value[0] = '0';
razer_functions->scroll_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_led_state->store(open_razer_device, NULL, update_value, 1);
} }
break; break;
case RAZER_MODE_STATIC: case OPEN_RAZER_MODE_STATIC:
effect_value[0] = '0'; effect_value[0] = '0';
//if(razer_functions->backlight_led_state) //if(open_razer_functions->backlight_led_state)
//{ //{
// update_value[0] = '1'; // update_value[0] = '1';
// razer_functions->backlight_led_state->store(razer_device, NULL, update_value, 1); // open_razer_functions->backlight_led_state->store(open_razer_device, NULL, update_value, 1);
//} //}
if(razer_functions->logo_led_state) if(open_razer_functions->logo_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->logo_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_led_state->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_led_state) if(open_razer_functions->scroll_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->scroll_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_led_state->store(open_razer_device, NULL, update_value, 1);
} }
update_value[0] = RGBGetRValue(modes[active_mode].colors[0]); update_value[0] = RGBGetRValue(modes[active_mode].colors[0]);
update_value[1] = RGBGetGValue(modes[active_mode].colors[0]); update_value[1] = RGBGetGValue(modes[active_mode].colors[0]);
update_value[2] = RGBGetBValue(modes[active_mode].colors[0]); update_value[2] = RGBGetBValue(modes[active_mode].colors[0]);
if(razer_functions->matrix_effect_static) if(open_razer_functions->matrix_effect_static)
{ {
razer_functions->matrix_effect_static->store(razer_device, NULL, update_value, 3); open_razer_functions->matrix_effect_static->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->logo_matrix_effect_static) if(open_razer_functions->logo_matrix_effect_static)
{ {
razer_functions->logo_matrix_effect_static->store(razer_device, NULL, update_value, 3); open_razer_functions->logo_matrix_effect_static->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->scroll_matrix_effect_static) if(open_razer_functions->scroll_matrix_effect_static)
{ {
razer_functions->scroll_matrix_effect_static->store(razer_device, NULL, update_value, 3); open_razer_functions->scroll_matrix_effect_static->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->left_matrix_effect_static) if(open_razer_functions->left_matrix_effect_static)
{ {
razer_functions->left_matrix_effect_static->store(razer_device, NULL, update_value, 3); open_razer_functions->left_matrix_effect_static->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->right_matrix_effect_static) if(open_razer_functions->right_matrix_effect_static)
{ {
razer_functions->right_matrix_effect_static->store(razer_device, NULL, update_value, 3); open_razer_functions->right_matrix_effect_static->store(open_razer_device, NULL, update_value, 3);
} }
//if(razer_functions->backlight_led_effect && razer_functions->backlight_led_rgb) //if(open_razer_functions->backlight_led_effect && open_razer_functions->backlight_led_rgb)
//{ //{
// razer_functions->backlight_led_rgb->store(razer_device, NULL, update_value, 3); // open_razer_functions->backlight_led_rgb->store(open_razer_device, NULL, update_value, 3);
// razer_functions->backlight_led_effect->store(razer_device, NULL, effect_value, 1); // open_razer_functions->backlight_led_effect->store(open_razer_device, NULL, effect_value, 1);
//} //}
if(razer_functions->logo_led_effect && razer_functions->logo_led_rgb) if(open_razer_functions->logo_led_effect && open_razer_functions->logo_led_rgb)
{ {
razer_functions->logo_led_rgb->store(razer_device, NULL, update_value, 3); open_razer_functions->logo_led_rgb->store(open_razer_device, NULL, update_value, 3);
razer_functions->logo_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->logo_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
if(razer_functions->scroll_led_effect && razer_functions->scroll_led_rgb) if(open_razer_functions->scroll_led_effect && open_razer_functions->scroll_led_rgb)
{ {
razer_functions->scroll_led_rgb->store(razer_device, NULL, update_value, 3); open_razer_functions->scroll_led_rgb->store(open_razer_device, NULL, update_value, 3);
razer_functions->scroll_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->scroll_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
break; break;
case RAZER_MODE_FLASHING: case OPEN_RAZER_MODE_FLASHING:
effect_value[0] = '1'; effect_value[0] = '1';
//if(razer_functions->backlight_led_state) //if(open_razer_functions->backlight_led_state)
//{ //{
// update_value[0] = '1'; // update_value[0] = '1';
// razer_functions->backlight_led_state->store(razer_device, NULL, update_value, 1); // open_razer_functions->backlight_led_state->store(open_razer_device, NULL, update_value, 1);
//} //}
if(razer_functions->logo_led_state) if(open_razer_functions->logo_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->logo_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_led_state->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_led_state) if(open_razer_functions->scroll_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->scroll_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_led_state->store(open_razer_device, NULL, update_value, 1);
} }
update_value[0] = RGBGetRValue(modes[active_mode].colors[0]); update_value[0] = RGBGetRValue(modes[active_mode].colors[0]);
update_value[1] = RGBGetGValue(modes[active_mode].colors[0]); update_value[1] = RGBGetGValue(modes[active_mode].colors[0]);
update_value[2] = RGBGetBValue(modes[active_mode].colors[0]); update_value[2] = RGBGetBValue(modes[active_mode].colors[0]);
//if(razer_functions->backlight_led_effect && razer_functions->backlight_led_rgb) //if(open_razer_functions->backlight_led_effect && open_razer_functions->backlight_led_rgb)
//{ //{
// razer_functions->backlight_led_rgb->store(razer_device, NULL, update_value, 3); // open_razer_functions->backlight_led_rgb->store(open_razer_device, NULL, update_value, 3);
// razer_functions->backlight_led_effect->store(razer_device, NULL, effect_value, 1); // open_razer_functions->backlight_led_effect->store(open_razer_device, NULL, effect_value, 1);
//} //}
if(razer_functions->logo_led_effect && razer_functions->logo_led_rgb) if(open_razer_functions->logo_led_effect && open_razer_functions->logo_led_rgb)
{ {
razer_functions->logo_led_rgb->store(razer_device, NULL, update_value, 3); open_razer_functions->logo_led_rgb->store(open_razer_device, NULL, update_value, 3);
razer_functions->logo_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->logo_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
if(razer_functions->scroll_led_effect && razer_functions->scroll_led_rgb) if(open_razer_functions->scroll_led_effect && open_razer_functions->scroll_led_rgb)
{ {
razer_functions->scroll_led_rgb->store(razer_device, NULL, update_value, 3); open_razer_functions->scroll_led_rgb->store(open_razer_device, NULL, update_value, 3);
razer_functions->scroll_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->scroll_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
break; break;
case RAZER_MODE_BREATHING: case OPEN_RAZER_MODE_BREATHING:
effect_value[0] = '2'; effect_value[0] = '2';
switch(modes[active_mode].color_mode) switch(modes[active_mode].color_mode)
{ {
case MODE_COLORS_MODE_SPECIFIC: case MODE_COLORS_MODE_SPECIFIC:
//if(razer_functions->backlight_led_state) //if(open_razer_functions->backlight_led_state)
//{ //{
// update_value[0] = '1'; // update_value[0] = '1';
// razer_functions->backlight_led_state->store(razer_device, NULL, update_value, 1); // open_razer_functions->backlight_led_state->store(open_razer_device, NULL, update_value, 1);
//} //}
if(razer_functions->logo_led_state) if(open_razer_functions->logo_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->logo_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_led_state->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_led_state) if(open_razer_functions->scroll_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->scroll_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_led_state->store(open_razer_device, NULL, update_value, 1);
} }
update_value[0] = RGBGetRValue(modes[active_mode].colors[0]); update_value[0] = RGBGetRValue(modes[active_mode].colors[0]);
@ -742,170 +742,170 @@ void RGBController_OpenRazer::DeviceUpdateMode()
update_value[4] = RGBGetGValue(modes[active_mode].colors[1]); update_value[4] = RGBGetGValue(modes[active_mode].colors[1]);
update_value[5] = RGBGetBValue(modes[active_mode].colors[1]); update_value[5] = RGBGetBValue(modes[active_mode].colors[1]);
if(razer_functions->matrix_effect_breath) if(open_razer_functions->matrix_effect_breath)
{ {
razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 6); open_razer_functions->matrix_effect_breath->store(open_razer_device, NULL, update_value, 6);
} }
if(razer_functions->logo_matrix_effect_breath) if(open_razer_functions->logo_matrix_effect_breath)
{ {
razer_functions->logo_matrix_effect_breath->store(razer_device, NULL, update_value, 6); open_razer_functions->logo_matrix_effect_breath->store(open_razer_device, NULL, update_value, 6);
} }
if(razer_functions->scroll_matrix_effect_breath) if(open_razer_functions->scroll_matrix_effect_breath)
{ {
razer_functions->scroll_matrix_effect_breath->store(razer_device, NULL, update_value, 6); open_razer_functions->scroll_matrix_effect_breath->store(open_razer_device, NULL, update_value, 6);
} }
if(razer_functions->left_matrix_effect_breath) if(open_razer_functions->left_matrix_effect_breath)
{ {
razer_functions->left_matrix_effect_breath->store(razer_device, NULL, update_value, 6); open_razer_functions->left_matrix_effect_breath->store(open_razer_device, NULL, update_value, 6);
} }
if(razer_functions->right_matrix_effect_breath) if(open_razer_functions->right_matrix_effect_breath)
{ {
razer_functions->right_matrix_effect_breath->store(razer_device, NULL, update_value, 6); open_razer_functions->right_matrix_effect_breath->store(open_razer_device, NULL, update_value, 6);
} }
} }
else else
{ {
if(razer_functions->matrix_effect_breath) if(open_razer_functions->matrix_effect_breath)
{ {
razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 3); open_razer_functions->matrix_effect_breath->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->logo_matrix_effect_breath) if(open_razer_functions->logo_matrix_effect_breath)
{ {
razer_functions->logo_matrix_effect_breath->store(razer_device, NULL, update_value, 3); open_razer_functions->logo_matrix_effect_breath->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->scroll_matrix_effect_breath) if(open_razer_functions->scroll_matrix_effect_breath)
{ {
razer_functions->scroll_matrix_effect_breath->store(razer_device, NULL, update_value, 3); open_razer_functions->scroll_matrix_effect_breath->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->left_matrix_effect_breath) if(open_razer_functions->left_matrix_effect_breath)
{ {
razer_functions->left_matrix_effect_breath->store(razer_device, NULL, update_value, 3); open_razer_functions->left_matrix_effect_breath->store(open_razer_device, NULL, update_value, 3);
} }
if(razer_functions->right_matrix_effect_breath) if(open_razer_functions->right_matrix_effect_breath)
{ {
razer_functions->right_matrix_effect_breath->store(razer_device, NULL, update_value, 3); open_razer_functions->right_matrix_effect_breath->store(open_razer_device, NULL, update_value, 3);
} }
//if(razer_functions->backlight_led_effect && razer_functions->backlight_led_rgb) //if(open_razer_functions->backlight_led_effect && open_razer_functions->backlight_led_rgb)
//{ //{
// razer_functions->backlight_led_rgb->store(razer_device, NULL, update_value, 3); // open_razer_functions->backlight_led_rgb->store(open_razer_device, NULL, update_value, 3);
// razer_functions->backlight_led_effect->store(razer_device, NULL, effect_value, 1); // open_razer_functions->backlight_led_effect->store(open_razer_device, NULL, effect_value, 1);
//} //}
if(razer_functions->logo_led_effect && razer_functions->logo_led_rgb) if(open_razer_functions->logo_led_effect && open_razer_functions->logo_led_rgb)
{ {
razer_functions->logo_led_rgb->store(razer_device, NULL, update_value, 3); open_razer_functions->logo_led_rgb->store(open_razer_device, NULL, update_value, 3);
razer_functions->logo_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->logo_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
if(razer_functions->scroll_led_effect && razer_functions->scroll_led_rgb) if(open_razer_functions->scroll_led_effect && open_razer_functions->scroll_led_rgb)
{ {
razer_functions->scroll_led_rgb->store(razer_device, NULL, update_value, 3); open_razer_functions->scroll_led_rgb->store(open_razer_device, NULL, update_value, 3);
razer_functions->scroll_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->scroll_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
} }
break; break;
case MODE_COLORS_RANDOM: case MODE_COLORS_RANDOM:
if(razer_functions->matrix_effect_breath) if(open_razer_functions->matrix_effect_breath)
{ {
razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 1); open_razer_functions->matrix_effect_breath->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->logo_matrix_effect_breath) if(open_razer_functions->logo_matrix_effect_breath)
{ {
razer_functions->logo_matrix_effect_breath->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_matrix_effect_breath->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_matrix_effect_breath) if(open_razer_functions->scroll_matrix_effect_breath)
{ {
razer_functions->scroll_matrix_effect_breath->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_matrix_effect_breath->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->left_matrix_effect_breath) if(open_razer_functions->left_matrix_effect_breath)
{ {
razer_functions->left_matrix_effect_breath->store(razer_device, NULL, update_value, 1); open_razer_functions->left_matrix_effect_breath->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->right_matrix_effect_breath) if(open_razer_functions->right_matrix_effect_breath)
{ {
razer_functions->right_matrix_effect_breath->store(razer_device, NULL, update_value, 1); open_razer_functions->right_matrix_effect_breath->store(open_razer_device, NULL, update_value, 1);
} }
break; break;
} }
break; break;
case RAZER_MODE_SPECTRUM_CYCLE: case OPEN_RAZER_MODE_SPECTRUM_CYCLE:
effect_value[0] = '4'; effect_value[0] = '4';
//if(razer_functions->backlight_led_state) //if(open_razer_functions->backlight_led_state)
//{ //{
// update_value[0] = '1'; // update_value[0] = '1';
// razer_functions->backlight_led_state->store(razer_device, NULL, update_value, 1); // open_razer_functions->backlight_led_state->store(open_razer_device, NULL, update_value, 1);
//} //}
if(razer_functions->logo_led_state) if(open_razer_functions->logo_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->logo_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_led_state->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_led_state) if(open_razer_functions->scroll_led_state)
{ {
update_value[0] = '1'; update_value[0] = '1';
razer_functions->scroll_led_state->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_led_state->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->matrix_effect_spectrum) if(open_razer_functions->matrix_effect_spectrum)
{ {
razer_functions->matrix_effect_spectrum->store(razer_device, NULL, update_value, 1); open_razer_functions->matrix_effect_spectrum->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->logo_matrix_effect_spectrum) if(open_razer_functions->logo_matrix_effect_spectrum)
{ {
razer_functions->logo_matrix_effect_spectrum->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_matrix_effect_spectrum->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_matrix_effect_spectrum) if(open_razer_functions->scroll_matrix_effect_spectrum)
{ {
razer_functions->scroll_matrix_effect_spectrum->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_matrix_effect_spectrum->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->left_matrix_effect_spectrum) if(open_razer_functions->left_matrix_effect_spectrum)
{ {
razer_functions->left_matrix_effect_spectrum->store(razer_device, NULL, update_value, 1); open_razer_functions->left_matrix_effect_spectrum->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->right_matrix_effect_spectrum) if(open_razer_functions->right_matrix_effect_spectrum)
{ {
razer_functions->right_matrix_effect_spectrum->store(razer_device, NULL, update_value, 1); open_razer_functions->right_matrix_effect_spectrum->store(open_razer_device, NULL, update_value, 1);
} }
//if(razer_functions->backlight_led_effect) //if(open_razer_functions->backlight_led_effect)
//{ //{
// razer_functions->backlight_led_effect->store(razer_device, NULL, effect_value, 1); // open_razer_functions->backlight_led_effect->store(open_razer_device, NULL, effect_value, 1);
//} //}
if(razer_functions->logo_led_effect) if(open_razer_functions->logo_led_effect)
{ {
razer_functions->logo_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->logo_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
if(razer_functions->scroll_led_effect) if(open_razer_functions->scroll_led_effect)
{ {
razer_functions->scroll_led_effect->store(razer_device, NULL, effect_value, 1); open_razer_functions->scroll_led_effect->store(open_razer_device, NULL, effect_value, 1);
} }
break; break;
case RAZER_MODE_WAVE: case OPEN_RAZER_MODE_WAVE:
switch(modes[active_mode].direction) switch(modes[active_mode].direction)
{ {
case MODE_DIRECTION_LEFT: case MODE_DIRECTION_LEFT:
@ -917,46 +917,46 @@ void RGBController_OpenRazer::DeviceUpdateMode()
break; break;
} }
if(razer_functions->matrix_effect_wave) if(open_razer_functions->matrix_effect_wave)
{ {
razer_functions->matrix_effect_wave->store(razer_device, NULL, update_value, 1); open_razer_functions->matrix_effect_wave->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->left_matrix_effect_wave) if(open_razer_functions->left_matrix_effect_wave)
{ {
razer_functions->left_matrix_effect_wave->store(razer_device, NULL, update_value, 1); open_razer_functions->left_matrix_effect_wave->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->right_matrix_effect_wave) if(open_razer_functions->right_matrix_effect_wave)
{ {
razer_functions->right_matrix_effect_wave->store(razer_device, NULL, update_value, 1); open_razer_functions->right_matrix_effect_wave->store(open_razer_device, NULL, update_value, 1);
} }
break; break;
case RAZER_MODE_REACTIVE: case OPEN_RAZER_MODE_REACTIVE:
if(razer_functions->matrix_effect_reactive) if(open_razer_functions->matrix_effect_reactive)
{ {
razer_functions->matrix_effect_reactive->store(razer_device, NULL, update_value, 1); open_razer_functions->matrix_effect_reactive->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->logo_matrix_effect_reactive) if(open_razer_functions->logo_matrix_effect_reactive)
{ {
razer_functions->logo_matrix_effect_reactive->store(razer_device, NULL, update_value, 1); open_razer_functions->logo_matrix_effect_reactive->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->scroll_matrix_effect_reactive) if(open_razer_functions->scroll_matrix_effect_reactive)
{ {
razer_functions->scroll_matrix_effect_reactive->store(razer_device, NULL, update_value, 1); open_razer_functions->scroll_matrix_effect_reactive->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->left_matrix_effect_reactive) if(open_razer_functions->left_matrix_effect_reactive)
{ {
razer_functions->left_matrix_effect_reactive->store(razer_device, NULL, update_value, 1); open_razer_functions->left_matrix_effect_reactive->store(open_razer_device, NULL, update_value, 1);
} }
if(razer_functions->right_matrix_effect_reactive) if(open_razer_functions->right_matrix_effect_reactive)
{ {
razer_functions->right_matrix_effect_reactive->store(razer_device, NULL, update_value, 1); open_razer_functions->right_matrix_effect_reactive->store(open_razer_device, NULL, update_value, 1);
} }
break; break;
} }

36
Controllers/OpenRazerController/RGBController_OpenRazerWindows.h
View file

@ -76,28 +76,28 @@ class RGBController_OpenRazer : public RGBController
public: public:
enum enum
{ {
RAZER_MODE_CUSTOM, OPEN_RAZER_MODE_CUSTOM,
RAZER_MODE_OFF, OPEN_RAZER_MODE_OFF,
RAZER_MODE_STATIC, OPEN_RAZER_MODE_STATIC,
RAZER_MODE_BREATHING, OPEN_RAZER_MODE_BREATHING,
RAZER_MODE_SPECTRUM_CYCLE, OPEN_RAZER_MODE_SPECTRUM_CYCLE,
RAZER_MODE_WAVE, OPEN_RAZER_MODE_WAVE,
RAZER_MODE_REACTIVE, OPEN_RAZER_MODE_REACTIVE,
RAZER_MODE_FLASHING, OPEN_RAZER_MODE_FLASHING,
RAZER_NUM_MODES OPEN_RAZER_NUM_MODES
}; };
enum enum
{ {
RAZER_TYPE_MATRIX_FRAME, OPEN_RAZER_TYPE_MATRIX_FRAME,
RAZER_TYPE_MATRIX_NOFRAME, OPEN_RAZER_TYPE_MATRIX_NOFRAME,
RAZER_TYPE_MATRIX_STATIC, OPEN_RAZER_TYPE_MATRIX_STATIC,
RAZER_TYPE_NOMATRIX, OPEN_RAZER_TYPE_NOMATRIX,
RAZER_NUM_TYPES OPEN_RAZER_NUM_TYPES
}; };
public: public:
RGBController_OpenRazer(device * razer_device, device_fn_type* razer_functions); RGBController_OpenRazer(device * open_razer_device, device_fn_type* open_razer_functions);
~RGBController_OpenRazer(); ~RGBController_OpenRazer();
void SetupZones(); void SetupZones();
@ -114,15 +114,15 @@ public:
int device_index; int device_index;
private: private:
void SetupMatrixDevice(device_fn_type* razer_functions, unsigned int rows, unsigned int cols); void SetupMatrixDevice(device_fn_type* open_razer_functions, unsigned int rows, unsigned int cols);
void SetupNonMatrixDevice(); void SetupNonMatrixDevice();
unsigned int matrix_type; unsigned int matrix_type;
unsigned int matrix_rows; unsigned int matrix_rows;
unsigned int matrix_cols; unsigned int matrix_cols;
device* razer_device; device* open_razer_device;
device_fn_type* razer_functions; device_fn_type* open_razer_functions;
//OpenRazer Sysfs Entries for Matrix Devices //OpenRazer Sysfs Entries for Matrix Devices
std::ofstream matrix_custom_frame; std::ofstream matrix_custom_frame;