mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-06-14 00:44:47 -04:00
Code Issues Packages Projects Releases Wiki Activity

Move CompareControllers to RGBController

Browse Source
This commit is contained in:
Adam Honse
2026-06-07 18:08:14 -05:00
parent b8b297f675
commit 9528dd327f
5 changed files with 173 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
ProfileManager.cpp
View File

@@ -154,144 +154,6 @@ void ProfileManager::ClearActiveProfile()
SetActiveProfile("");
}
bool ProfileManager::CompareControllers(RGBController* controller_1, RGBController* controller_2)
{
/*-----------------------------------------------------*\
| Do not compare location string for HID devices, as |
| the location string may change between runs as |
| devices are connected and disconnected. Also do not |
| compare the I2C bus number, since it is not |
| persistent across reboots on Linux - strip the I2C |
| number and compare only address. |
\*-----------------------------------------------------*/
bool location_check;
if(controller_1->GetLocation().find("HID: ") == 0)
{
location_check = true;
}
else if(controller_1->GetLocation().find("I2C: ") == 0)
{
std::size_t loc = controller_1->GetLocation().rfind(", ");
if(loc == std::string::npos)
{
location_check = false;
}
else
{
std::string i2c_address = controller_1->GetLocation().substr(loc + 2);
location_check = controller_2->GetLocation().find(i2c_address) != std::string::npos;
}
}
else
{
location_check = controller_2->GetLocation() == controller_1->GetLocation();
}
/*-----------------------------------------------------*\
| Compare top-level controller information |
\*-----------------------------------------------------*/
if((controller_1->GetDeviceType() != controller_2->GetDeviceType() )
|| (controller_1->GetName() != controller_2->GetName() )
|| (controller_1->GetDescription() != controller_2->GetDescription())
|| (controller_1->GetVersion() != controller_2->GetVersion() )
|| (controller_1->GetSerial() != controller_2->GetSerial() )
|| (location_check != true ))
{
return(false);
}
/*-----------------------------------------------------*\
| Compare modes |
\*-----------------------------------------------------*/
if(controller_1->modes.size() != controller_2->modes.size())
{
return(false);
}
else
{
for(std::size_t mode_index = 0; mode_index < controller_1->modes.size(); mode_index++)
{
if((controller_1->GetModeName(mode_index) != controller_2->GetModeName(mode_index) )
|| (controller_1->GetModeValue(mode_index) != controller_2->GetModeValue(mode_index) )
|| (controller_1->GetModeFlags(mode_index) != controller_2->GetModeFlags(mode_index) )
|| (controller_1->GetModeSpeedMin(mode_index) != controller_2->GetModeSpeedMin(mode_index) )
|| (controller_1->GetModeSpeedMax(mode_index) != controller_2->GetModeSpeedMax(mode_index) )
|| (controller_1->GetModeBrightnessMin(mode_index) != controller_2->GetModeBrightnessMin(mode_index))
|| (controller_1->GetModeBrightnessMax(mode_index) != controller_2->GetModeBrightnessMax(mode_index))
|| (controller_1->GetModeColorsMin(mode_index) != controller_2->GetModeColorsMin(mode_index) )
|| (controller_1->GetModeColorsMax(mode_index) != controller_2->GetModeColorsMax(mode_index) ))
{
return(false);
}
}
}
/*-----------------------------------------------------*\
| Compare zones |
\*-----------------------------------------------------*/
if(controller_1->zones.size() != controller_2->zones.size())
{
return(false);
}
else
{
for(std::size_t zone_index = 0; zone_index < controller_1->zones.size(); zone_index++)
{
bool check_zone_geometry = true;
bool check_zone_type = true;
/*---------------------------------------------*\
| Do not check zone type if manually configured |
\*---------------------------------------------*/
if((controller_1->GetZoneFlags(zone_index) & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE)
|| (controller_2->GetZoneFlags(zone_index) & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
{
check_zone_type = false;
}
if((controller_1->GetZoneFlags(zone_index) & ZONE_FLAG_ZONE_GEOMETRY_MAY_CHANGE)
|| (controller_2->GetZoneFlags(zone_index) & ZONE_FLAG_ZONE_GEOMETRY_MAY_CHANGE))
{
check_zone_geometry = false;
}
if(( (controller_1->GetZoneName(zone_index) != controller_2->GetZoneName(zone_index) ))
|| (check_zone_type && (controller_1->GetZoneType(zone_index) != controller_2->GetZoneType(zone_index) ))
|| (check_zone_geometry && ((controller_1->GetZoneLEDsMin(zone_index) != controller_2->GetZoneLEDsMin(zone_index) )
|| (controller_1->GetZoneLEDsMax(zone_index) != controller_2->GetZoneLEDsMax(zone_index) )))
|| (controller_1->GetZoneModeCount(zone_index) != controller_2->GetZoneModeCount(zone_index)))
{
return(false);
}
if(controller_1->GetZoneModeCount(zone_index) != controller_2->GetZoneModeCount(zone_index))
{
return(false);
}
else
{
for(std::size_t mode_index = 0; mode_index < controller_1->GetZoneModeCount(zone_index); mode_index++)
{
if((controller_1->GetZoneModeName(zone_index, mode_index) != controller_2->GetZoneModeName(zone_index, mode_index) )
|| (controller_1->GetZoneModeValue(zone_index, mode_index) != controller_2->GetZoneModeValue(zone_index, mode_index) )
|| (controller_1->GetZoneModeFlags(zone_index, mode_index) != controller_2->GetZoneModeFlags(zone_index, mode_index) )
|| (controller_1->GetZoneModeSpeedMin(zone_index, mode_index) != controller_2->GetZoneModeSpeedMin(zone_index, mode_index) )
|| (controller_1->GetZoneModeSpeedMax(zone_index, mode_index) != controller_2->GetZoneModeSpeedMax(zone_index, mode_index) )
|| (controller_1->GetZoneModeBrightnessMin(zone_index, mode_index) != controller_2->GetZoneModeBrightnessMin(zone_index, mode_index))
|| (controller_1->GetZoneModeBrightnessMax(zone_index, mode_index) != controller_2->GetZoneModeBrightnessMax(zone_index, mode_index))
|| (controller_1->GetZoneModeColorsMin(zone_index, mode_index) != controller_2->GetZoneModeColorsMin(zone_index, mode_index) )
|| (controller_1->GetZoneModeColorsMax(zone_index, mode_index) != controller_2->GetZoneModeColorsMax(zone_index, mode_index) ))
{
return(false);
}
}
}
}
}
return(true);
}
void ProfileManager::DeleteProfile(std::string profile_name)
{
if(ResourceManager::get()->IsLocalClient() && (ResourceManager::get()->GetLocalClient()->GetSupportsProfileManagerAPI()))
@@ -646,7 +508,7 @@ bool ProfileManager::SaveProfile(std::string profile_name)
for(std::size_t controller_index = 0; controller_index < controllers.size(); controller_index++)
{
if(ProfileManager::CompareControllers(existing_controllers[existing_controller_index], controllers[controller_index]))
if(RGBController::CompareControllers(existing_controllers[existing_controller_index], controllers[controller_index]))
{
found = true;
break;
@@ -905,7 +767,7 @@ bool ProfileManager::SaveConfiguration()
for(std::size_t controller_index = 0; controller_index < controllers.size(); controller_index++)
{
if(ProfileManager::CompareControllers(manually_configured_rgb_controllers[old_saved_controller_index], controllers[controller_index]))
if(RGBController::CompareControllers(manually_configured_rgb_controllers[old_saved_controller_index], controllers[controller_index]))
{
found = true;
break;