diff --git a/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510Controller.cpp b/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510Controller.cpp new file mode 100644 index 0000000000000000000000000000000000000000..023d11bec5f4fb16ed4c38f293723f6a340b305b --- /dev/null +++ b/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510Controller.cpp @@ -0,0 +1,101 @@ +/*---------------------------------------------------------*\ +| LenovoK510Controller.cpp | +| | +| Driver for Lenovo Legion K510 keyboard | +| | +| Bnyro 27 Oct 2025 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#include +#include +#include "LenovoK510Controller.h" + +using namespace std; + +LenovoK510Controller::LenovoK510Controller(hid_device* dev_handle, const hid_device_info& info, std::string dev_name) +{ + device = dev_handle; + location = info.path; + name = dev_name; +} + +LenovoK510Controller::~LenovoK510Controller() +{ + hid_close(device); +} + +std::string LenovoK510Controller::GetDeviceLocation() +{ + return("HID: " + location); +} + +std::string LenovoK510Controller::GetDeviceName() +{ + return(name); +} + +void LenovoK510Controller::SetMode(unsigned int color_mode, RGBColor color, unsigned char mode_value, unsigned int brigthness, unsigned int speed, unsigned int direction) +{ + unsigned char usb_buf[K510_DATA_SIZE]; + memset(usb_buf, 0x00, K510_DATA_SIZE); + usb_buf[0x00] = 0x04; // ReportID + + // magic bytes to trigger an LED update + usb_buf[0x03] = 0x06; + usb_buf[0x04] = 0x38; + + usb_buf[0x09] = mode_value; + usb_buf[0x0A] = static_cast(brigthness); + // speed behaves contrary to normal expectations: the lower the value, the higher the speed + usb_buf[0x0B] = static_cast(speed); + + if(direction == MODE_DIRECTION_UP || direction == MODE_DIRECTION_LEFT) + { + // 0x01 reverses the direction of the animation + usb_buf[0x0C] = 0x01; + } + + if(color_mode == MODE_COLORS_MODE_SPECIFIC) + { + usb_buf[0x0D] = 0x00; + usb_buf[0x0E] = static_cast(RGBGetRValue(color)); + usb_buf[0x0F] = static_cast(RGBGetGValue(color)); + usb_buf[0x10] = static_cast(RGBGetBValue(color)); + } + else + { + // sets color to automatic + usb_buf[0x0D] = 0x01; + } + + hid_write(device, usb_buf, K510_DATA_SIZE); +} + +mode LenovoK510Controller::GetCurrentState() +{ + unsigned char usb_buf[K510_DATA_SIZE]; + memset(usb_buf, 0x00, K510_DATA_SIZE); + usb_buf[0x00] = 0x04; // ReportID + + // magic bytes to get a response containing the current configuration + usb_buf[0x03] = 0x05; + usb_buf[0x04] = 0x38; + + hid_write(device, usb_buf, K510_DATA_SIZE); + + unsigned char res_buf[K510_DATA_SIZE]; + hid_read_timeout(device, res_buf, K510_DATA_SIZE, 50); + + mode current_mode; + current_mode.value = res_buf[0x09]; + current_mode.brightness = res_buf[0x0A]; + current_mode.speed = res_buf[0x0B]; + current_mode.direction = res_buf[0x0C]; + current_mode.color_mode = res_buf[0x0D] ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC; + current_mode.colors.push_back(ToRGBColor(res_buf[0x0E], res_buf[0x0F], res_buf[0x10])); + + return(current_mode); +} diff --git a/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510Controller.h b/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510Controller.h new file mode 100644 index 0000000000000000000000000000000000000000..fa8ad6b5ccc52b030de19d0469449598aed707a8 --- /dev/null +++ b/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510Controller.h @@ -0,0 +1,68 @@ +/*---------------------------------------------------------*\ +| LenovoK510Controller.h | +| | +| Driver for Lenovo Legion K510 keyboard | +| | +| Bnyro 27 Oct 2025 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#pragma once + +#include +#include +#include "RGBController.h" + +#define K510_DATA_SIZE 64 + +#define K510_BRIGHTNESS_DEFAULT 2 +#define K510_BRIGHTNESS_MIN 0 +#define K510_BRIGHTNESS_MAX 2 + +// the lower the speed value, the faster the animation +#define K510_SPEED_DEFAULT 2 +#define K510_SPEED_MIN 4 +#define K510_SPEED_MAX 0 + +enum +{ + K510_MODE_CORRUGATED = 0x01, + K510_MODE_CLOUD = 0x02, + K510_MODE_SERPENTINE = 0x03, + K510_MODE_SPECTRUM = 0x04, + K510_MODE_BREATH = 0x05, + K510_MODE_NORMAL = 0x06, + K510_MODE_REACTION = 0x07, + K510_MODE_RIPPLES = 0x08, + K510_MODE_TRAVERSE = 0x09, + K510_MODE_STARS = 0x0A, + K510_MODE_FLOWERS = 0x0B, + K510_MODE_ROLL = 0x0C, + K510_MODE_WAVE = 0x0D, + K510_MODE_CARTOON = 0x0E, + K510_MODE_RAIN = 0x0F, + K510_MODE_SCAN = 0x10, + K510_MODE_SURMOUNT = 0x11, + K510_MODE_SPEED = 0x12, +}; + +class LenovoK510Controller +{ +public: + LenovoK510Controller(hid_device* dev_handle, const hid_device_info& info, std::string dev_name); + ~LenovoK510Controller(); + + std::string GetDeviceLocation(); + std::string GetDeviceName(); + + void SetMode(unsigned int color_mode, RGBColor color, unsigned char mode_value, unsigned int brightness, unsigned int speed, unsigned int direction); + mode GetCurrentState(); +; + +private: + hid_device* device; + std::string location; + std::string name; +}; diff --git a/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510ControllerDetect.cpp b/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510ControllerDetect.cpp new file mode 100644 index 0000000000000000000000000000000000000000..62ba654b46151d065c353ac340e7474bfb74634e --- /dev/null +++ b/Controllers/LenovoControllers/LenovoLegionK510Controller/LenovoK510ControllerDetect.cpp @@ -0,0 +1,38 @@ +/*---------------------------------------------------------*\ +| LenovoK510ControllerDetect.cpp | +| | +| Detector for Lenovo Legion K510 keyboard | +| | +| Bnyro 27 Oct 2025 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#include "Detector.h" +#include "RGBController_LenovoK510.h" +#include "LenovoK510Controller.h" + +/*---------------------------------------------------------*\ +| Lenovo vendor, product, usage and page IDs | +\*---------------------------------------------------------*/ +#define LENOVO_VID 0x17EF +#define LEGION_K510_PID 0x619A +#define LENOVO_IFACE_NUM 0x01 +#define LENOVO_PAGE 0xFF1C +#define LENOVO_USAGE 0x0092 + +void DetectLenovoLegionK510Controllers(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + LenovoK510Controller* controller = new LenovoK510Controller(dev, *info, name); + RGBController_LenovoK510* rgb_controller = new RGBController_LenovoK510(controller); + + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + +REGISTER_HID_DETECTOR_IPU("Lenovo Legion K510 Mini Pro", DetectLenovoLegionK510Controllers, LENOVO_VID, LEGION_K510_PID, LENOVO_IFACE_NUM, LENOVO_PAGE, LENOVO_USAGE); diff --git a/Controllers/LenovoControllers/LenovoLegionK510Controller/RGBController_LenovoK510.cpp b/Controllers/LenovoControllers/LenovoLegionK510Controller/RGBController_LenovoK510.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5cf6c53eb9323fd4879ecbd655c68f7946bfbf51 --- /dev/null +++ b/Controllers/LenovoControllers/LenovoLegionK510Controller/RGBController_LenovoK510.cpp @@ -0,0 +1,352 @@ +/*---------------------------------------------------------*\ +| RGBController_LenovoM300.cpp | +| | +| RGBController for Lenovo Legion K510 keyboard | +| | +| Bnyro 27 Oct 2025 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#include "RGBController_LenovoK510.h" + +/**------------------------------------------------------------------*\ + @name Lenovo Legion K510 + @category Keyboard + @type USB + @save :robot: + @direct :x: + @effects :white_check_mark: + @detectors DetectLenovoLegionK510Controllers + @comment +\*-------------------------------------------------------------------*/ + +RGBController_LenovoK510::RGBController_LenovoK510(LenovoK510Controller* controller_ptr) +{ + controller = controller_ptr; + + name = controller->GetDeviceName(); + vendor = "Lenovo"; + type = DEVICE_TYPE_KEYBOARD; + description = "Lenovo Legion K510 Mini Pro"; + location = controller->GetDeviceLocation(); + + mode Corrugated; + Corrugated.name = "Corrugated"; + Corrugated.value = K510_MODE_CORRUGATED; + Corrugated.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_DIRECTION_LR; + Corrugated.color_mode = MODE_COLORS_RANDOM; + Corrugated.brightness = K510_BRIGHTNESS_DEFAULT; + Corrugated.brightness_min = K510_BRIGHTNESS_MIN; + Corrugated.brightness_max = K510_BRIGHTNESS_MAX; + Corrugated.speed = K510_SPEED_DEFAULT; + Corrugated.speed_min = K510_SPEED_MIN; + Corrugated.speed_max = K510_SPEED_MAX; + Corrugated.colors.resize(1); + modes.push_back(Corrugated); + + mode Cloud; + Cloud.name = "Cloud"; + Cloud.value = K510_MODE_CLOUD; + Cloud.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_DIRECTION_LR; + Cloud.color_mode = MODE_COLORS_RANDOM; + Cloud.brightness = K510_BRIGHTNESS_DEFAULT; + Cloud.brightness_min = K510_BRIGHTNESS_MIN; + Cloud.brightness_max = K510_BRIGHTNESS_MAX; + Cloud.speed = K510_SPEED_DEFAULT; + Cloud.speed_min = K510_SPEED_MIN; + Cloud.speed_max = K510_SPEED_MAX; + Cloud.colors.resize(1); + modes.push_back(Cloud); + + mode Serpentine; + Serpentine.name = "Serpentine"; + Serpentine.value = K510_MODE_SERPENTINE; + Serpentine.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_DIRECTION_LR; + Serpentine.color_mode = MODE_COLORS_RANDOM; + Serpentine.brightness = K510_BRIGHTNESS_DEFAULT; + Serpentine.brightness_min = K510_BRIGHTNESS_MIN; + Serpentine.brightness_max = K510_BRIGHTNESS_MAX; + Serpentine.speed = K510_SPEED_DEFAULT; + Serpentine.speed_min = K510_SPEED_MIN; + Serpentine.speed_max = K510_SPEED_MAX; + Serpentine.colors.resize(1); + modes.push_back(Serpentine); + + mode Spectrum; + Spectrum.name = "Spectrum Cycle"; + Spectrum.value = K510_MODE_SPECTRUM; + Spectrum.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Spectrum.color_mode = MODE_COLORS_NONE; + Spectrum.brightness = K510_BRIGHTNESS_DEFAULT; + Spectrum.brightness_min = K510_BRIGHTNESS_MIN; + Spectrum.brightness_max = K510_BRIGHTNESS_MAX; + Spectrum.speed = K510_SPEED_DEFAULT; + Spectrum.speed_min = K510_SPEED_MIN; + Spectrum.speed_max = K510_SPEED_MAX; + modes.push_back(Spectrum); + + mode Breath; + Breath.name = "Breathing"; + Breath.value = K510_MODE_BREATH; + Breath.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Breath.color_mode = MODE_COLORS_RANDOM; + Breath.brightness = K510_BRIGHTNESS_DEFAULT; + Breath.brightness_min = K510_BRIGHTNESS_MIN; + Breath.brightness_max = K510_BRIGHTNESS_MAX; + Breath.speed = K510_SPEED_DEFAULT; + Breath.speed_min = K510_SPEED_MIN; + Breath.speed_max = K510_SPEED_MAX; + Breath.colors.resize(1); + modes.push_back(Breath); + + mode Normal; + Normal.name = "Static"; + Normal.value = K510_MODE_NORMAL; + Normal.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + Normal.color_mode = MODE_COLORS_RANDOM; + Normal.brightness = K510_BRIGHTNESS_DEFAULT; + Normal.brightness_min = K510_BRIGHTNESS_MIN; + Normal.brightness_max = K510_BRIGHTNESS_MAX; + Normal.colors.resize(1); + modes.push_back(Normal); + + mode Reaction; + Reaction.name = "Reaction"; + Reaction.value = K510_MODE_REACTION; + Reaction.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Reaction.color_mode = MODE_COLORS_RANDOM; + Reaction.brightness = K510_BRIGHTNESS_DEFAULT; + Reaction.brightness_min = K510_BRIGHTNESS_MIN; + Reaction.brightness_max = K510_BRIGHTNESS_MAX; + Reaction.speed = K510_SPEED_DEFAULT; + Reaction.speed_min = K510_SPEED_MIN; + Reaction.speed_max = K510_SPEED_MAX; + Reaction.colors.resize(1); + modes.push_back(Reaction); + + mode Ripples; + Ripples.name = "Ripples"; + Ripples.value = K510_MODE_RIPPLES; + Ripples.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Ripples.color_mode = MODE_COLORS_RANDOM; + Ripples.brightness = K510_BRIGHTNESS_DEFAULT; + Ripples.brightness_min = K510_BRIGHTNESS_MIN; + Ripples.brightness_max = K510_BRIGHTNESS_MAX; + Ripples.speed = K510_SPEED_DEFAULT; + Ripples.speed_min = K510_SPEED_MIN; + Ripples.speed_max = K510_SPEED_MAX; + Ripples.colors.resize(1); + modes.push_back(Ripples); + + mode Traverse; + Traverse.name = "Traverse"; + Traverse.value = K510_MODE_TRAVERSE; + Traverse.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Traverse.color_mode = MODE_COLORS_RANDOM; + Traverse.brightness = K510_BRIGHTNESS_DEFAULT; + Traverse.brightness_min = K510_BRIGHTNESS_MIN; + Traverse.brightness_max = K510_BRIGHTNESS_MAX; + Traverse.speed = K510_SPEED_DEFAULT; + Traverse.speed_min = K510_SPEED_MIN; + Traverse.speed_max = K510_SPEED_MAX; + Traverse.colors.resize(1); + modes.push_back(Traverse); + + mode Stars; + Stars.name = "Stars"; + Stars.value = K510_MODE_STARS; + Stars.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Stars.color_mode = MODE_COLORS_RANDOM; + Stars.brightness = K510_BRIGHTNESS_DEFAULT; + Stars.brightness_min = K510_BRIGHTNESS_MIN; + Stars.brightness_max = K510_BRIGHTNESS_MAX; + Stars.speed = K510_SPEED_DEFAULT; + Stars.speed_min = K510_SPEED_MIN; + Stars.speed_max = K510_SPEED_MAX; + Stars.colors.resize(1); + modes.push_back(Stars); + + mode Flowers; + Flowers.name = "Flowers"; + Flowers.value = K510_MODE_FLOWERS; + Flowers.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Flowers.color_mode = MODE_COLORS_RANDOM; + Flowers.brightness = K510_BRIGHTNESS_DEFAULT; + Flowers.brightness_min = K510_BRIGHTNESS_MIN; + Flowers.brightness_max = K510_BRIGHTNESS_MAX; + Flowers.speed = K510_SPEED_DEFAULT; + Flowers.speed_min = K510_SPEED_MIN; + Flowers.speed_max = K510_SPEED_MAX; + modes.push_back(Flowers); + + mode Roll; + Roll.name = "Rainbow Wave"; + Roll.value = K510_MODE_ROLL; + Roll.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_DIRECTION_UD; + Roll.color_mode = MODE_COLORS_NONE; + Roll.brightness = K510_BRIGHTNESS_DEFAULT; + Roll.brightness_min = K510_BRIGHTNESS_MIN; + Roll.brightness_max = K510_BRIGHTNESS_MAX; + Roll.speed = K510_SPEED_DEFAULT; + Roll.speed_min = K510_SPEED_MIN; + Roll.speed_max = K510_SPEED_MAX; + modes.push_back(Roll); + + mode Wave; + Wave.name = "Wave"; + Wave.value = K510_MODE_WAVE; + Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Wave.color_mode = MODE_COLORS_RANDOM; + Wave.brightness = K510_BRIGHTNESS_DEFAULT; + Wave.brightness_min = K510_BRIGHTNESS_MIN; + Wave.brightness_max = K510_BRIGHTNESS_MAX; + Wave.speed = K510_SPEED_DEFAULT; + Wave.speed_min = K510_SPEED_MIN; + Wave.speed_max = K510_SPEED_MAX; + Wave.colors.resize(1); + modes.push_back(Wave); + + mode Cartoon; + Cartoon.name = "Cartoon"; + Cartoon.value = K510_MODE_CARTOON; + Cartoon.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Cartoon.color_mode = MODE_COLORS_RANDOM; + Cartoon.brightness = K510_BRIGHTNESS_DEFAULT; + Cartoon.brightness_min = K510_BRIGHTNESS_MIN; + Cartoon.brightness_max = K510_BRIGHTNESS_MAX; + Cartoon.speed = K510_SPEED_DEFAULT; + Cartoon.speed_min = K510_SPEED_MIN; + Cartoon.speed_max = K510_SPEED_MAX; + Cartoon.colors.resize(1); + modes.push_back(Cartoon); + + mode Rain; + Rain.name = "Rain"; + Rain.value = K510_MODE_RAIN; + Rain.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Rain.color_mode = MODE_COLORS_RANDOM; + Rain.brightness = K510_BRIGHTNESS_DEFAULT; + Rain.brightness_min = K510_BRIGHTNESS_MIN; + Rain.brightness_max = K510_BRIGHTNESS_MAX; + Rain.speed = K510_SPEED_DEFAULT; + Rain.speed_min = K510_SPEED_MIN; + Rain.speed_max = K510_SPEED_MAX; + Rain.colors.resize(1); + modes.push_back(Rain); + + mode Scan; + Scan.name = "Scan"; + Scan.value = K510_MODE_SCAN; + Scan.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + Scan.color_mode = MODE_COLORS_NONE; + Scan.brightness = K510_BRIGHTNESS_DEFAULT; + Scan.brightness_min = K510_BRIGHTNESS_MIN; + Scan.brightness_max = K510_BRIGHTNESS_MAX; + modes.push_back(Scan); + + mode Surmount; + Surmount.name = "Surmount"; + Surmount.value = K510_MODE_SURMOUNT; + Surmount.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; + Surmount.color_mode = MODE_COLORS_NONE; + Surmount.brightness = K510_BRIGHTNESS_DEFAULT; + Surmount.brightness_min = K510_BRIGHTNESS_MIN; + Surmount.brightness_max = K510_BRIGHTNESS_MAX; + modes.push_back(Surmount); + + mode Speed; + Speed.name = "Speed"; + Speed.value = K510_MODE_SPEED; + Speed.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_DIRECTION_LR; + Speed.color_mode = MODE_COLORS_NONE; + Speed.brightness = K510_BRIGHTNESS_DEFAULT; + Speed.brightness_min = K510_BRIGHTNESS_MIN; + Speed.brightness_max = K510_BRIGHTNESS_MAX; + Speed.speed = K510_SPEED_DEFAULT; + Speed.speed_min = K510_SPEED_MIN; + Speed.speed_max = K510_SPEED_MAX; + modes.push_back(Speed); + + SetupZones(); + ReadAndUpdateCurrentDeviceState(); +} + +RGBController_LenovoK510::~RGBController_LenovoK510() +{ + delete controller; +} + +void RGBController_LenovoK510::SetupZones() +{ + zone default_zone; + default_zone.name = "Keyboard"; + default_zone.type = ZONE_TYPE_SINGLE; + default_zone.leds_min = 1; + default_zone.leds_max = 1; + default_zone.leds_count = 1; + default_zone.matrix_map = nullptr; + zones.emplace_back(default_zone); + + leds.resize(1); + leds[0].name = "Keyboard"; + + SetupColors(); +} + +void RGBController_LenovoK510::ReadAndUpdateCurrentDeviceState() +{ + mode current_active_mode = controller->GetCurrentState(); + + for(std::vector::size_type i = 0; i < modes.size(); ++i) + { + if(modes[i].value == current_active_mode.value) + { + // override the default config of the mode with the current one + modes[i].brightness = current_active_mode.brightness; + modes[i].speed = current_active_mode.speed; + modes[i].color_mode = current_active_mode.color_mode; + zones[0].colors[0] = current_active_mode.colors[0]; + + if(modes[i].flags & MODE_FLAG_HAS_DIRECTION_LR) + { + current_active_mode.direction = current_active_mode.direction ? MODE_DIRECTION_LEFT : MODE_DIRECTION_RIGHT; + } + else if(modes[i].flags & MODE_FLAG_HAS_DIRECTION_UD) + { + current_active_mode.direction = current_active_mode.direction ? MODE_DIRECTION_UP : MODE_DIRECTION_DOWN; + } + + active_mode = i; + break; + } + } +} + +void RGBController_LenovoK510::ResizeZone(int /*zone*/, int /*new_size*/) +{ + // Not Supported +} + +void RGBController_LenovoK510::DeviceUpdateLEDs() +{ + // Not Supported +} + +void RGBController_LenovoK510::UpdateZoneLEDs(int /*zone*/) +{ + // Not Supported +} + +void RGBController_LenovoK510::UpdateSingleLED(int /*led*/) +{ + // Not Supported +} + +void RGBController_LenovoK510::DeviceUpdateMode() +{ + const mode& active = modes[active_mode]; + RGBColor color = active.colors.size() > 0 ? active.colors[0] : 0x00; + controller->SetMode(active.color_mode, color, active.value, active.brightness, active.speed, active.direction); +} diff --git a/Controllers/LenovoControllers/LenovoLegionK510Controller/RGBController_LenovoK510.h b/Controllers/LenovoControllers/LenovoLegionK510Controller/RGBController_LenovoK510.h new file mode 100644 index 0000000000000000000000000000000000000000..0ec40b5ce4b7a9e8314403860fda5d509f5d1d5f --- /dev/null +++ b/Controllers/LenovoControllers/LenovoLegionK510Controller/RGBController_LenovoK510.h @@ -0,0 +1,36 @@ +/*---------------------------------------------------------*\ +| RGBController_LenovoK510.h | +| | +| RGBController for Lenovo Legion K510 keyboard | +| | +| Bnyro 27 Oct 2025 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-or-later | +\*---------------------------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include "LenovoK510Controller.h" + +class RGBController_LenovoK510 : public RGBController +{ +public: + RGBController_LenovoK510(LenovoK510Controller* controller_ptr); + ~RGBController_LenovoK510(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + +private: + LenovoK510Controller* controller; + + void ReadAndUpdateCurrentDeviceState(); +};