From 0e07d222db9b3cac32a179776a9414dfca1d65bf Mon Sep 17 00:00:00 2001 From: Adam Honse Date: Wed, 18 Feb 2026 11:39:51 -0600 Subject: [PATCH] Rework how manual configuration (previously sizes) are loaded to newly detected controllers, load active profile to newly detected controllers --- DetectionManager.cpp | 24 +--- DetectionManager.h | 7 - ProfileManager.cpp | 302 ++++++++++++++++++++++++------------------- ProfileManager.h | 20 ++- 4 files changed, 192 insertions(+), 161 deletions(-) diff --git a/DetectionManager.cpp b/DetectionManager.cpp index fc2ddbf2e..ab86b762d 100644 --- a/DetectionManager.cpp +++ b/DetectionManager.cpp @@ -402,9 +402,14 @@ void DetectionManager::RegisterRGBController(RGBController *rgb_controller) rgb_controller->flags |= CONTROLLER_FLAG_LOCAL; /*-----------------------------------------------------*\ - | Load sizes for the new controller | + | Load manual configuration for the new controller | \*-----------------------------------------------------*/ - ResourceManager::get()->GetProfileManager()->LoadControllerFromListWithOptions(rgb_controllers_sizes, detection_size_entry_used, rgb_controller, true, false); + ResourceManager::get()->GetProfileManager()->LoadControllerConfiguration(rgb_controller); + + /*-----------------------------------------------------*\ + | Load active profile for the new controller | + \*-----------------------------------------------------*/ + ResourceManager::get()->GetProfileManager()->LoadControllerActiveProfile(rgb_controller); /*-----------------------------------------------------*\ | Add the new controller to the list | @@ -653,16 +658,6 @@ void DetectionManager::BackgroundDetectDevices() initial_detection = false; } - /*-----------------------------------------------------*\ - | Reset the size entry used flags vector | - \*-----------------------------------------------------*/ - detection_size_entry_used.resize(rgb_controllers_sizes.size()); - - for(std::size_t size_idx = 0; size_idx < detection_size_entry_used.size(); size_idx++) - { - detection_size_entry_used[size_idx] = false; - } - /*-----------------------------------------------------*\ | Enumerate HID devices unless using HID safe mode | \*-----------------------------------------------------*/ @@ -1656,11 +1651,6 @@ bool DetectionManager::ProcessPreDetection() \*-----------------------------------------------------*/ UpdateDetectorSettings(); - /*-----------------------------------------------------*\ - | Initialize sizes list | - \*-----------------------------------------------------*/ - rgb_controllers_sizes = ResourceManager::get()->GetProfileManager()->GetControllerListFromSizes(); - /*-----------------------------------------------------*\ | Clean up any existing detected devices | \*-----------------------------------------------------*/ diff --git a/DetectionManager.h b/DetectionManager.h index 015ca2f50..26df90927 100644 --- a/DetectionManager.h +++ b/DetectionManager.h @@ -209,12 +209,6 @@ private: \*-----------------------------------------------------*/ std::vector rgb_controllers; - /*-----------------------------------------------------*\ - | List of manually configured RGBController information | - | from stored sizes profile | - \*-----------------------------------------------------*/ - std::vector rgb_controllers_sizes; - /*-----------------------------------------------------*\ | Detectors | \*-----------------------------------------------------*/ @@ -273,7 +267,6 @@ private: unsigned int detection_percent_i2c_pci_count; unsigned int detection_percent_other_count; unsigned int detection_percent_denominator; - std::vector detection_size_entry_used; std::string detection_string; bool dynamic_detectors_processed; bool initial_detection; diff --git a/ProfileManager.cpp b/ProfileManager.cpp index 599723540..29c1b8942 100644 --- a/ProfileManager.cpp +++ b/ProfileManager.cpp @@ -94,6 +94,11 @@ ProfileManager::ProfileManager(const filesystem::path& config_dir) settings_manager->SetSettings("ProfileManager", profilemanager_settings); settings_manager->SaveSettings(); } + + /*-----------------------------------------------------*\ + | Initialize manually configured controllers list | + \*-----------------------------------------------------*/ + manually_configured_rgb_controllers = GetControllerListFromSizes(); } ProfileManager::~ProfileManager() @@ -103,6 +108,20 @@ ProfileManager::~ProfileManager() void ProfileManager::ClearActiveProfile() { + /*-------------------------------------------------*\ + | Clear stored active profile data | + \*-------------------------------------------------*/ + std::vector active_rgb_controllers_copy = active_rgb_controllers; + + active_base_color_enabled = false; + active_base_color = 0; + active_rgb_controllers.clear(); + + for(unsigned int controller_idx = 0; controller_idx < active_rgb_controllers_copy.size(); controller_idx++) + { + delete active_rgb_controllers_copy[controller_idx]; + } + if(ResourceManager::get()->IsLocalClient() && ResourceManager::get()->GetLocalClient()->GetSupportsProfileManagerAPI()) { ResourceManager::get()->GetLocalClient()->ProfileManager_ClearActiveProfile(); @@ -255,7 +274,7 @@ std::string ProfileManager::GetActiveProfile() std::vector ProfileManager::GetControllerListFromProfileJson(nlohmann::json profile_json) { - std::vector temp_controllers; + std::vector profile_controllers; /*-----------------------------------------------------*\ | Read list of controllers from profile | @@ -264,15 +283,15 @@ std::vector ProfileManager::GetControllerListFromProfileJson(nlo { for(std::size_t controller_idx = 0; controller_idx < profile_json["controllers"].size(); controller_idx++) { - RGBController_Dummy * temp_controller = new RGBController_Dummy(); + RGBController_Dummy * profile_controller = new RGBController_Dummy(); - temp_controller->SetDeviceDescriptionJSON(profile_json["controllers"][controller_idx]); + profile_controller->SetDeviceDescriptionJSON(profile_json["controllers"][controller_idx]); - temp_controllers.push_back(temp_controller); + profile_controllers.push_back(profile_controller); } } - return(temp_controllers); + return(profile_controllers); } std::vector ProfileManager::GetControllerListFromProfileName(std::string profile_name) @@ -369,6 +388,16 @@ bool ProfileManager::LoadAutoProfileSuspend() return(LoadAutoProfile("suspend_profile")); } +bool ProfileManager::LoadControllerActiveProfile(RGBController* load_controller) +{ + return(LoadControllerFromListWithOptions(active_rgb_controllers, load_controller, false, true)); +} + +bool ProfileManager::LoadControllerConfiguration(RGBController* load_controller) +{ + return(LoadControllerFromListWithOptions(manually_configured_rgb_controllers, load_controller, true, false)); +} + bool ProfileManager::LoadProfile(std::string profile_name) { if(ResourceManager::get()->IsLocalClient() && (ResourceManager::get()->GetLocalClient()->GetSupportsProfileManagerAPI())) @@ -715,6 +744,11 @@ bool ProfileManager::SaveSizes() \*-----------------------------------------------------*/ controller_file.close(); + /*-----------------------------------------------------*\ + | Initialize manually configured controllers list | + \*-----------------------------------------------------*/ + manually_configured_rgb_controllers = GetControllerListFromSizes(); + return(true); } @@ -863,16 +897,15 @@ bool ProfileManager::LoadAutoProfile(std::string setting_name) bool ProfileManager::LoadControllerFromListWithOptions ( - std::vector& temp_controllers, - std::vector& temp_controller_used, + std::vector& profile_controllers, RGBController* load_controller, bool load_size, bool load_settings ) { - for(std::size_t temp_index = 0; temp_index < temp_controllers.size(); temp_index++) + for(std::size_t temp_index = 0; temp_index < profile_controllers.size(); temp_index++) { - RGBController *temp_controller = temp_controllers[temp_index]; + RGBController *profile_controller = profile_controllers[temp_index]; /*---------------------------------------------------------*\ | Do not compare location string for HID devices, as the | @@ -897,57 +930,51 @@ bool ProfileManager::LoadControllerFromListWithOptions else { std::string i2c_address = load_controller->GetLocation().substr(loc + 2); - location_check = temp_controller->GetLocation().find(i2c_address) != std::string::npos; + location_check = profile_controller->GetLocation().find(i2c_address) != std::string::npos; } } else { - location_check = temp_controller->GetLocation() == load_controller->GetLocation(); + location_check = profile_controller->GetLocation() == load_controller->GetLocation(); } /*-------------------------------------------------*\ | Test if saved controller data matches this | | controller | \*-------------------------------------------------*/ - if((temp_controller_used[temp_index] == false ) - &&(temp_controller->GetDeviceType() == load_controller->GetDeviceType() ) - &&(temp_controller->GetName() == load_controller->GetName() ) - &&(temp_controller->GetDescription() == load_controller->GetDescription()) - &&(temp_controller->GetVersion() == load_controller->GetVersion() ) - &&(temp_controller->GetSerial() == load_controller->GetSerial() ) - &&(location_check == true )) + if((profile_controller->GetDeviceType() == load_controller->GetDeviceType() ) + &&(profile_controller->GetName() == load_controller->GetName() ) + &&(profile_controller->GetDescription() == load_controller->GetDescription()) + &&(profile_controller->GetVersion() == load_controller->GetVersion() ) + &&(profile_controller->GetSerial() == load_controller->GetSerial() ) + &&(location_check == true )) { - /*---------------------------------------------*\ - | Set used flag for this temp device | - \*---------------------------------------------*/ - temp_controller_used[temp_index] = true; - /*---------------------------------------------*\ | Update zone sizes if requested | \*---------------------------------------------*/ if(load_size) { - if(temp_controller->zones.size() == load_controller->zones.size()) + if(profile_controller->zones.size() == load_controller->zones.size()) { - for(std::size_t zone_idx = 0; zone_idx < temp_controller->zones.size(); zone_idx++) + for(std::size_t zone_idx = 0; zone_idx < profile_controller->zones.size(); zone_idx++) { - if((temp_controller->GetZoneName(zone_idx) == load_controller->GetZoneName(zone_idx) ) - &&(temp_controller->GetZoneType(zone_idx) == load_controller->GetZoneType(zone_idx) ) - &&(temp_controller->GetZoneLEDsMin(zone_idx) == load_controller->GetZoneLEDsMin(zone_idx) ) - &&(temp_controller->GetZoneLEDsMax(zone_idx) == load_controller->GetZoneLEDsMax(zone_idx) )) + if((profile_controller->GetZoneName(zone_idx) == load_controller->GetZoneName(zone_idx) ) + &&(profile_controller->GetZoneType(zone_idx) == load_controller->GetZoneType(zone_idx) ) + &&(profile_controller->GetZoneLEDsMin(zone_idx) == load_controller->GetZoneLEDsMin(zone_idx) ) + &&(profile_controller->GetZoneLEDsMax(zone_idx) == load_controller->GetZoneLEDsMax(zone_idx) )) { - if(temp_controller->GetZoneLEDsCount(zone_idx) != load_controller->GetZoneLEDsCount(zone_idx)) + if(profile_controller->GetZoneLEDsCount(zone_idx) != load_controller->GetZoneLEDsCount(zone_idx)) { - load_controller->ResizeZone((int)zone_idx, temp_controller->zones[zone_idx].leds_count); + load_controller->ResizeZone((int)zone_idx, profile_controller->zones[zone_idx].leds_count); } - if(temp_controller->zones[zone_idx].segments.size() != load_controller->zones[zone_idx].segments.size()) + if(profile_controller->zones[zone_idx].segments.size() != load_controller->zones[zone_idx].segments.size()) { load_controller->zones[zone_idx].segments.clear(); - for(std::size_t segment_idx = 0; segment_idx < temp_controller->zones[zone_idx].segments.size(); segment_idx++) + for(std::size_t segment_idx = 0; segment_idx < profile_controller->zones[zone_idx].segments.size(); segment_idx++) { - load_controller->zones[zone_idx].segments.push_back(temp_controller->zones[zone_idx].segments[segment_idx]); + load_controller->zones[zone_idx].segments.push_back(profile_controller->zones[zone_idx].segments[segment_idx]); } } } @@ -963,46 +990,46 @@ bool ProfileManager::LoadControllerFromListWithOptions /*-----------------------------------------*\ | If mode list matches, load all modes | \*-----------------------------------------*/ - if(temp_controller->modes.size() == load_controller->modes.size()) + if(profile_controller->modes.size() == load_controller->modes.size()) { - for(std::size_t mode_index = 0; mode_index < temp_controller->modes.size(); mode_index++) + for(std::size_t mode_index = 0; mode_index < profile_controller->modes.size(); mode_index++) { - if((temp_controller->GetModeName(mode_index) == load_controller->GetModeName(mode_index) ) - &&(temp_controller->GetModeValue(mode_index) == load_controller->GetModeValue(mode_index) ) - &&(temp_controller->GetModeFlags(mode_index) == load_controller->GetModeFlags(mode_index) ) - &&(temp_controller->GetModeSpeedMin(mode_index) == load_controller->GetModeSpeedMin(mode_index) ) - &&(temp_controller->GetModeSpeedMax(mode_index) == load_controller->GetModeSpeedMax(mode_index) ) - &&(temp_controller->GetModeBrightnessMin(mode_index) == load_controller->GetModeBrightnessMin(mode_index)) - &&(temp_controller->GetModeBrightnessMax(mode_index) == load_controller->GetModeBrightnessMax(mode_index)) - &&(temp_controller->GetModeColorsMin(mode_index) == load_controller->GetModeColorsMin(mode_index) ) - &&(temp_controller->GetModeColorsMax(mode_index) == load_controller->GetModeColorsMax(mode_index) )) + if((profile_controller->GetModeName(mode_index) == load_controller->GetModeName(mode_index) ) + &&(profile_controller->GetModeValue(mode_index) == load_controller->GetModeValue(mode_index) ) + &&(profile_controller->GetModeFlags(mode_index) == load_controller->GetModeFlags(mode_index) ) + &&(profile_controller->GetModeSpeedMin(mode_index) == load_controller->GetModeSpeedMin(mode_index) ) + &&(profile_controller->GetModeSpeedMax(mode_index) == load_controller->GetModeSpeedMax(mode_index) ) + &&(profile_controller->GetModeBrightnessMin(mode_index) == load_controller->GetModeBrightnessMin(mode_index)) + &&(profile_controller->GetModeBrightnessMax(mode_index) == load_controller->GetModeBrightnessMax(mode_index)) + &&(profile_controller->GetModeColorsMin(mode_index) == load_controller->GetModeColorsMin(mode_index) ) + &&(profile_controller->GetModeColorsMax(mode_index) == load_controller->GetModeColorsMax(mode_index) )) { - load_controller->modes[mode_index].speed = temp_controller->modes[mode_index].speed; - load_controller->modes[mode_index].brightness = temp_controller->modes[mode_index].brightness; - load_controller->modes[mode_index].direction = temp_controller->modes[mode_index].direction; - load_controller->modes[mode_index].color_mode = temp_controller->modes[mode_index].color_mode; + load_controller->modes[mode_index].speed = profile_controller->modes[mode_index].speed; + load_controller->modes[mode_index].brightness = profile_controller->modes[mode_index].brightness; + load_controller->modes[mode_index].direction = profile_controller->modes[mode_index].direction; + load_controller->modes[mode_index].color_mode = profile_controller->modes[mode_index].color_mode; - load_controller->modes[mode_index].colors.resize(temp_controller->modes[mode_index].colors.size()); + load_controller->modes[mode_index].colors.resize(profile_controller->modes[mode_index].colors.size()); - for(std::size_t mode_color_index = 0; mode_color_index < temp_controller->GetModeColorsCount(mode_index); mode_color_index++) + for(std::size_t mode_color_index = 0; mode_color_index < profile_controller->GetModeColorsCount(mode_index); mode_color_index++) { - load_controller->modes[mode_index].colors[mode_color_index] = temp_controller->modes[mode_index].colors[mode_color_index]; + load_controller->modes[mode_index].colors[mode_color_index] = profile_controller->modes[mode_index].colors[mode_color_index]; } } } - load_controller->active_mode = temp_controller->active_mode; + load_controller->active_mode = profile_controller->active_mode; load_controller->UpdateMode(); } /*-----------------------------------------*\ | If color list matches, load all colors | \*-----------------------------------------*/ - if(temp_controller->colors.size() == load_controller->colors.size()) + if(profile_controller->colors.size() == load_controller->colors.size()) { - for(std::size_t color_index = 0; color_index < temp_controller->colors.size(); color_index++) + for(std::size_t color_index = 0; color_index < profile_controller->colors.size(); color_index++) { - load_controller->colors[color_index] = temp_controller->colors[color_index]; + load_controller->colors[color_index] = profile_controller->colors[color_index]; } load_controller->UpdateLEDs(); @@ -1012,43 +1039,43 @@ bool ProfileManager::LoadControllerFromListWithOptions | If zone mode list matches, load all zone | | modes | \*-----------------------------------------*/ - if(temp_controller->GetZoneCount() == load_controller->GetZoneCount()) + if(profile_controller->GetZoneCount() == load_controller->GetZoneCount()) { - for(std::size_t zone_idx = 0; zone_idx < temp_controller->GetZoneCount(); zone_idx++) + for(std::size_t zone_idx = 0; zone_idx < profile_controller->GetZoneCount(); zone_idx++) { - if((temp_controller->GetZoneName(zone_idx) == load_controller->GetZoneName(zone_idx) ) - &&(temp_controller->GetZoneType(zone_idx) == load_controller->GetZoneType(zone_idx) ) - &&(temp_controller->GetZoneLEDsMin(zone_idx) == load_controller->GetZoneLEDsMin(zone_idx) ) - &&(temp_controller->GetZoneLEDsMax(zone_idx) == load_controller->GetZoneLEDsMax(zone_idx) ) - &&(temp_controller->GetZoneModeCount(zone_idx) == load_controller->GetZoneModeCount(zone_idx))) + if((profile_controller->GetZoneName(zone_idx) == load_controller->GetZoneName(zone_idx) ) + &&(profile_controller->GetZoneType(zone_idx) == load_controller->GetZoneType(zone_idx) ) + &&(profile_controller->GetZoneLEDsMin(zone_idx) == load_controller->GetZoneLEDsMin(zone_idx) ) + &&(profile_controller->GetZoneLEDsMax(zone_idx) == load_controller->GetZoneLEDsMax(zone_idx) ) + &&(profile_controller->GetZoneModeCount(zone_idx) == load_controller->GetZoneModeCount(zone_idx))) { - for(std::size_t mode_index = 0; mode_index < temp_controller->GetZoneModeCount(zone_idx); mode_index++) + for(std::size_t mode_index = 0; mode_index < profile_controller->GetZoneModeCount(zone_idx); mode_index++) { - if((temp_controller->GetZoneModeName(zone_idx, mode_index) == load_controller->GetZoneModeName(zone_idx, mode_index) ) - &&(temp_controller->GetZoneModeValue(zone_idx, mode_index) == load_controller->GetZoneModeValue(zone_idx, mode_index) ) - &&(temp_controller->GetZoneModeFlags(zone_idx, mode_index) == load_controller->GetZoneModeFlags(zone_idx, mode_index) ) - &&(temp_controller->GetZoneModeSpeedMin(zone_idx, mode_index) == load_controller->GetZoneModeSpeedMin(zone_idx, mode_index) ) - &&(temp_controller->GetZoneModeSpeedMax(zone_idx, mode_index) == load_controller->GetZoneModeSpeedMax(zone_idx, mode_index) ) - &&(temp_controller->GetZoneModeBrightnessMin(zone_idx, mode_index) == load_controller->GetZoneModeBrightnessMin(zone_idx, mode_index)) - &&(temp_controller->GetZoneModeBrightnessMax(zone_idx, mode_index) == load_controller->GetZoneModeBrightnessMax(zone_idx, mode_index)) - &&(temp_controller->GetZoneModeColorsMin(zone_idx, mode_index) == load_controller->GetZoneModeColorsMin(zone_idx, mode_index) ) - &&(temp_controller->GetZoneModeColorsMax(zone_idx, mode_index) == load_controller->GetZoneModeColorsMax(zone_idx, mode_index) )) + if((profile_controller->GetZoneModeName(zone_idx, mode_index) == load_controller->GetZoneModeName(zone_idx, mode_index) ) + &&(profile_controller->GetZoneModeValue(zone_idx, mode_index) == load_controller->GetZoneModeValue(zone_idx, mode_index) ) + &&(profile_controller->GetZoneModeFlags(zone_idx, mode_index) == load_controller->GetZoneModeFlags(zone_idx, mode_index) ) + &&(profile_controller->GetZoneModeSpeedMin(zone_idx, mode_index) == load_controller->GetZoneModeSpeedMin(zone_idx, mode_index) ) + &&(profile_controller->GetZoneModeSpeedMax(zone_idx, mode_index) == load_controller->GetZoneModeSpeedMax(zone_idx, mode_index) ) + &&(profile_controller->GetZoneModeBrightnessMin(zone_idx, mode_index) == load_controller->GetZoneModeBrightnessMin(zone_idx, mode_index)) + &&(profile_controller->GetZoneModeBrightnessMax(zone_idx, mode_index) == load_controller->GetZoneModeBrightnessMax(zone_idx, mode_index)) + &&(profile_controller->GetZoneModeColorsMin(zone_idx, mode_index) == load_controller->GetZoneModeColorsMin(zone_idx, mode_index) ) + &&(profile_controller->GetZoneModeColorsMax(zone_idx, mode_index) == load_controller->GetZoneModeColorsMax(zone_idx, mode_index) )) { - load_controller->zones[zone_idx].modes[mode_index].speed = temp_controller->zones[zone_idx].modes[mode_index].speed; - load_controller->zones[zone_idx].modes[mode_index].brightness = temp_controller->zones[zone_idx].modes[mode_index].brightness; - load_controller->zones[zone_idx].modes[mode_index].direction = temp_controller->zones[zone_idx].modes[mode_index].direction; - load_controller->zones[zone_idx].modes[mode_index].color_mode = temp_controller->zones[zone_idx].modes[mode_index].color_mode; + load_controller->zones[zone_idx].modes[mode_index].speed = profile_controller->zones[zone_idx].modes[mode_index].speed; + load_controller->zones[zone_idx].modes[mode_index].brightness = profile_controller->zones[zone_idx].modes[mode_index].brightness; + load_controller->zones[zone_idx].modes[mode_index].direction = profile_controller->zones[zone_idx].modes[mode_index].direction; + load_controller->zones[zone_idx].modes[mode_index].color_mode = profile_controller->zones[zone_idx].modes[mode_index].color_mode; - load_controller->zones[zone_idx].modes[mode_index].colors.resize(temp_controller->zones[zone_idx].modes[mode_index].colors.size()); + load_controller->zones[zone_idx].modes[mode_index].colors.resize(profile_controller->zones[zone_idx].modes[mode_index].colors.size()); - for(std::size_t mode_color_index = 0; mode_color_index < temp_controller->GetZoneModeColorsCount(zone_idx, mode_index); mode_color_index++) + for(std::size_t mode_color_index = 0; mode_color_index < profile_controller->GetZoneModeColorsCount(zone_idx, mode_index); mode_color_index++) { - load_controller->zones[zone_idx].modes[mode_index].colors[mode_color_index] = temp_controller->zones[zone_idx].modes[mode_index].colors[mode_color_index]; + load_controller->zones[zone_idx].modes[mode_index].colors[mode_color_index] = profile_controller->zones[zone_idx].modes[mode_index].colors[mode_color_index]; } } } - load_controller->SetZoneActiveMode(zone_idx, temp_controller->GetZoneActiveMode(zone_idx)); + load_controller->SetZoneActiveMode(zone_idx, profile_controller->GetZoneActiveMode(zone_idx)); load_controller->UpdateZoneMode(zone_idx); } } @@ -1059,6 +1086,27 @@ bool ProfileManager::LoadControllerFromListWithOptions } } + /*-----------------------------------------------------*\ + | If no saved controller state in the profile matched | + | this controller, apply the base color if it is | + | enabled | + \*-----------------------------------------------------*/ + if(load_settings && active_base_color_enabled) + { + load_controller->SetCustomMode(); + + if(load_controller->GetModeColorMode(load_controller->GetActiveMode()) == MODE_COLORS_PER_LED) + { + load_controller->SetAllColors(active_base_color); + load_controller->UpdateLEDs(); + } + else if(load_controller->GetModeColorMode(load_controller->GetActiveMode()) == MODE_COLORS_MODE_SPECIFIC) + { + load_controller->SetModeColor(load_controller->GetActiveMode(), 0, active_base_color); + load_controller->UpdateMode(); + } + } + return(false); } @@ -1069,25 +1117,48 @@ bool ProfileManager::LoadProfileWithOptions bool load_settings ) { - std::vector temp_controllers; - std::vector temp_controller_used; - bool ret_val = false; + /*-------------------------------------------------*\ + | Clear stored active profile data | + \*-------------------------------------------------*/ + std::vector active_rgb_controllers_copy = active_rgb_controllers; + + active_base_color_enabled = false; + active_base_color = 0; + active_rgb_controllers.clear(); + + for(unsigned int controller_idx = 0; controller_idx < active_rgb_controllers_copy.size(); controller_idx++) + { + delete active_rgb_controllers_copy[controller_idx]; + } /*-------------------------------------------------*\ - | Get the list of controllers from the resource | - | manager | + | Get JSON data for given profile name | \*-------------------------------------------------*/ - std::vector controllers = ResourceManager::get()->GetRGBControllers(); - nlohmann::json profile_json = ReadProfileJSON(profile_name); /*-------------------------------------------------*\ - | Open input file in binary mode | + | Load the controller state data for this profile | + | into the active profile data | \*-------------------------------------------------*/ - temp_controllers = GetControllerListFromProfileJson(profile_json); + active_rgb_controllers = GetControllerListFromProfileJson(profile_json); /*-------------------------------------------------*\ - | Signal to plugins that a profile is about to load | + | Load the base color data for this profile into | + | the active profile data | + \*-------------------------------------------------*/ + if(profile_json.contains("base_color")) + { + active_base_color = profile_json["base_color"]; + active_base_color_enabled = true; + } + else + { + active_base_color = 0; + active_base_color_enabled = false; + } + + /*-------------------------------------------------*\ + | Signal that a profile is about to load | \*-------------------------------------------------*/ PluginManagerInterface* plugin_manager = ResourceManager::get()->GetPluginManager(); @@ -1099,38 +1170,10 @@ bool ProfileManager::LoadProfileWithOptions ResourceManager::get()->GetServer()->ProfileManager_ProfileAboutToLoad(); /*-------------------------------------------------*\ - | If profile contains a base color, apply it | + | Get the list of controllers from the resource | + | manager | \*-------------------------------------------------*/ - if(profile_json.contains("base_color")) - { - RGBColor base_color = profile_json["base_color"]; - - for(std::size_t controller_idx = 0; controller_idx < controllers.size(); controller_idx++) - { - controllers[controller_idx]->SetCustomMode(); - - if(controllers[controller_idx]->GetModeColorMode(controllers[controller_idx]->GetActiveMode()) == MODE_COLORS_PER_LED) - { - controllers[controller_idx]->SetAllColors(base_color); - controllers[controller_idx]->UpdateLEDs(); - } - else if(controllers[controller_idx]->GetModeColorMode(controllers[controller_idx]->GetActiveMode()) == MODE_COLORS_MODE_SPECIFIC) - { - controllers[controller_idx]->SetModeColor(controllers[controller_idx]->GetActiveMode(), 0, base_color); - controllers[controller_idx]->UpdateMode(); - } - } - } - - /*-------------------------------------------------*\ - | Set up used flag vector | - \*-------------------------------------------------*/ - temp_controller_used.resize(temp_controllers.size()); - - for(unsigned int controller_idx = 0; controller_idx < temp_controller_used.size(); controller_idx++) - { - temp_controller_used[controller_idx] = false; - } + std::vector controllers = ResourceManager::get()->GetRGBControllers(); /*-------------------------------------------------*\ | Loop through all controllers. For each | @@ -1139,18 +1182,7 @@ bool ProfileManager::LoadProfileWithOptions \*-------------------------------------------------*/ for(std::size_t controller_index = 0; controller_index < controllers.size(); controller_index++) { - bool temp_ret_val = LoadControllerFromListWithOptions(temp_controllers, temp_controller_used, controllers[controller_index], load_size, load_settings); - std::string current_name = controllers[controller_index]->GetName() + " @ " + controllers[controller_index]->GetLocation(); - LOG_INFO("[ProfileManager] Profile loading: %s for %s", ( temp_ret_val ? "Succeeded" : "FAILED!" ), current_name.c_str()); - ret_val |= temp_ret_val; - } - - /*-------------------------------------------------*\ - | Delete all temporary controllers | - \*-------------------------------------------------*/ - for(unsigned int controller_idx = 0; controller_idx < temp_controllers.size(); controller_idx++) - { - delete temp_controllers[controller_idx]; + LoadControllerFromListWithOptions(active_rgb_controllers, controllers[controller_index], load_size, load_settings); } /*-------------------------------------------------*\ @@ -1173,7 +1205,7 @@ bool ProfileManager::LoadProfileWithOptions ResourceManager::get()->GetServer()->SendRequest_ProfileManager_ActiveProfileChanged(active_profile); - return(ret_val); + return(true); } nlohmann::json ProfileManager::ReadProfileFileJSON(filesystem::path profile_filepath) diff --git a/ProfileManager.h b/ProfileManager.h index 2b235f443..519eb68a9 100644 --- a/ProfileManager.h +++ b/ProfileManager.h @@ -46,12 +46,14 @@ public: virtual bool LoadControllerFromListWithOptions ( std::vector& temp_controllers, - std::vector& temp_controller_used, RGBController* load_controller, bool load_size, bool load_settings ) = 0; + virtual bool LoadControllerActiveProfile(RGBController* load_controller) = 0; + virtual bool LoadControllerConfiguration(RGBController* load_controller) = 0; + virtual bool LoadProfile(std::string profile_name) = 0; virtual nlohmann::json ReadProfileJSON(std::string profile_name) = 0; @@ -96,12 +98,14 @@ public: bool LoadControllerFromListWithOptions ( std::vector& temp_controllers, - std::vector& temp_controller_used, RGBController* load_controller, bool load_size, bool load_settings ); + bool LoadControllerActiveProfile(RGBController* load_controller); + bool LoadControllerConfiguration(RGBController* load_controller); + bool LoadProfile(std::string profile_name); void OnProfileAboutToLoad(); @@ -154,6 +158,18 @@ private: std::vector ProfileManagerCallbackArgs; std::mutex ProfileManagerCallbackMutex; + /*-----------------------------------------------------*\ + | Active profile data | + \*-----------------------------------------------------*/ + bool active_base_color_enabled; + RGBColor active_base_color; + std::vector active_rgb_controllers; + + /*-----------------------------------------------------*\ + | Manual controller configuration data | + \*-----------------------------------------------------*/ + std::vector manually_configured_rgb_controllers; + /*-----------------------------------------------------*\ | Private functions | \*-----------------------------------------------------*/