mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-05-24 22:45:55 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
next_rgbcontroller_json_settings
OpenRGB/qt/OpenRGBDialog/OpenRGBDialog.cpp
Adam Honse c0826fbe83 Settings Rework 
* Add JSON string configuration field to RGBController to store device-specific configurations
    * This JSON string holds both configuration and schema
    * Add settings schema tracking to SettingsManager
    * Implement dynamic settings widget that generates a settings UI based on a JSON schema
    * Implement SettingsManager callback for notifying of settings changes and settings schema updates
    * Always enable Entire Device zone option and use it to enable Edit Device
    * Rename SaveSizes to SaveConfiguration in ProfileManager and Sizes.json to Configuration.json
    * Add zone flag for indicating that a zone's geometry may change, informing profile manager to ignore this check
    * Remove Theme setting and Theme Manager, as this didn't work on most setups anyways and Qt6 has proper Windows dark theming
2026-05-04 22:50:47 -05:00

2078 lines
82 KiB
C++
Raw Permalink Blame History

/*---------------------------------------------------------*\
| OpenRGBDialog.cpp |
| |
| User interface for OpenRGB main window |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "AutoStart.h"
#include "OpenRGBDialog.h"
#include "JsonUtils.h"
#include "LogManager.h"
#include "PluginManager.h"
#include "OpenRGBDevicePage.h"
#include "OpenRGBDeviceInfoPage.h"
#include "OpenRGBServerInfoPage.h"
#include "OpenRGBConsolePage.h"
#include "OpenRGBPluginContainer.h"
#include "OpenRGBProfileEditorDialog.h"
#include "OpenRGBProfileListDialog.h"
#include "ResourceManager.h"
#include "SettingsManager.h"
#include "TabLabel.h"
#include "OpenRGBZoneInitializationDialog.h"
#include "OpenRGBFont.h"
#include "ui_OpenRGBDialog.h"
#include <QDirIterator>
#include <QLabel>
#include <QTabBar>
#include <QMessageBox>
#include <QCloseEvent>
#include <QStyleFactory>
#include <QKeyEvent>
#include <QCheckBox>
#include <QScreen>
#include <QSpinBox>
#include <string>
#include <functional>
#ifdef __APPLE__
#include "macutils.h"
#endif
static void OpenRGBDialogProfileManagerCallback(void * this_ptr, unsigned int update_reason)
{
OpenRGBDialog * this_obj = (OpenRGBDialog *)this_ptr;
switch(update_reason)
{
case PROFILEMANAGER_UPDATE_REASON_PROFILE_LIST_UPDATED:
QMetaObject::invokeMethod(this_obj, "UpdateProfileList", Qt::QueuedConnection);
break;
case PROFILEMANAGER_UPDATE_REASON_ACTIVE_PROFILE_CHANGED:
QMetaObject::invokeMethod(this_obj, "UpdateActiveProfile", Qt::QueuedConnection);
break;
}
}
static void OpenRGBDialogSettingsManagerCallback(void * this_ptr, unsigned int update_reason)
{
OpenRGBDialog * this_obj = (OpenRGBDialog *)this_ptr;
switch(update_reason)
{
case SETTINGSMANAGER_UPDATE_REASON_SETTINGS_UPDATED:
QMetaObject::invokeMethod(this_obj, "onSettingsUpdated", Qt::QueuedConnection);
break;
}
}
static void OpenRGBDialogResourceManagerCallback(void * this_ptr, unsigned int update_reason)
{
OpenRGBDialog * this_obj = (OpenRGBDialog *)this_ptr;
switch(update_reason)
{
case RESOURCEMANAGER_UPDATE_REASON_DETECTION_STARTED:
QMetaObject::invokeMethod(this_obj, "onDetectionStarted", Qt::QueuedConnection);
break;
case RESOURCEMANAGER_UPDATE_REASON_DETECTION_PROGRESS_CHANGED:
QMetaObject::invokeMethod(this_obj, "onDetectionProgressUpdated", Qt::QueuedConnection);
break;
case RESOURCEMANAGER_UPDATE_REASON_DETECTION_COMPLETE:
QMetaObject::invokeMethod(this_obj, "onDetectionEnded", Qt::QueuedConnection);
break;
case RESOURCEMANAGER_UPDATE_REASON_DEVICE_LIST_UPDATED:
QMetaObject::invokeMethod(this_obj, "onDeviceListUpdated", Qt::QueuedConnection);
break;
}
}
static void CreatePluginCallback(void * this_ptr, OpenRGBPluginEntry* plugin)
{
OpenRGBDialog * this_obj = (OpenRGBDialog *)this_ptr;
this_obj->AddPlugin(plugin);
}
static void DeletePluginCallback(void * this_ptr, OpenRGBPluginEntry* plugin)
{
OpenRGBDialog * this_obj = (OpenRGBDialog *)this_ptr;
this_obj->RemovePlugin(plugin);
}
static void DialogShowCallback(void * this_ptr, PLogMessage msg)
{
OpenRGBDialog * this_obj = (OpenRGBDialog *)this_ptr;
this_obj->SetDialogMessage(msg);
QMetaObject::invokeMethod(this_obj, "onShowDialogMessage", Qt::QueuedConnection);
}
bool OpenRGBDialog::IsMinimizeOnClose()
{
json ui_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("UserInterface");
if(ui_settings.contains("minimize_on_close"))
{
return ui_settings["minimize_on_close"];
}
return false;
}
OpenRGBDialog::OpenRGBDialog(QWidget *parent) : QMainWindow(parent), ui(new Ui::OpenRGBDialog)
{
ui->setupUi(this);
/*-----------------------------------------------------*\
| Set window icon |
\*-----------------------------------------------------*/
QIcon logo(":org.openrgb.OpenRGB.png");
setWindowIcon(logo);
/*-----------------------------------------------------*\
| Create AutoStart settings schema |
\*-----------------------------------------------------*/
json autostart_settings_schema;
autostart_settings_schema["enabled"]["title"] = QT_TRANSLATE_NOOP("Settings", "Enable Start at Login");
autostart_settings_schema["enabled"]["type"] = "bool";
autostart_settings_schema["enabled"]["description"] = QT_TRANSLATE_NOOP("Settings", "Start OpenRGB on login");
autostart_settings_schema["enabled"]["order"] = 0;
autostart_settings_schema["start_minimized"]["title"] = QT_TRANSLATE_NOOP("Settings", "Start Minimized");
autostart_settings_schema["start_minimized"]["type"] = "bool";
autostart_settings_schema["start_minimized"]["description"] = QT_TRANSLATE_NOOP("Settings", "Start minimized to the system tray");
autostart_settings_schema["start_minimized"]["order"] = 1;
autostart_settings_schema["custom_arguments"]["title"] = QT_TRANSLATE_NOOP("Settings", "Custom Arguments");
autostart_settings_schema["custom_arguments"]["type"] = "string";
autostart_settings_schema["custom_arguments"]["description"] = QT_TRANSLATE_NOOP("Settings", "Additional command line arguments to pass to OpenRGB when starting on login");
autostart_settings_schema["custom_arguments"]["order"] = 2;
ResourceManager::get()->GetSettingsManager()->RegisterSettingsSchema("AutoStart", "Start at Login", autostart_settings_schema, 2);
/*-----------------------------------------------------*\
| Create UserInterface settings schema |
\*-----------------------------------------------------*/
json ui_settings_schema;
ui_settings_schema["language"]["title"] = QT_TRANSLATE_NOOP("Settings", "Language");
ui_settings_schema["language"]["type"] = "language";
ui_settings_schema["language"]["description"] = QT_TRANSLATE_NOOP("Settings", "Language for the user interface");
ui_settings_schema["language"]["order"] = 0;
ui_settings_schema["minimize_on_close"]["title"] = QT_TRANSLATE_NOOP("Settings", "Minimize on Close");
ui_settings_schema["minimize_on_close"]["description"] = QT_TRANSLATE_NOOP("Settings", "Keep OpenRGB active in the system tray when closing the main window");
ui_settings_schema["minimize_on_close"]["type"] = "bool";
ui_settings_schema["minimize_on_close"]["order"] = 1;
ui_settings_schema["monochrome_tray_icon"]["title"] = QT_TRANSLATE_NOOP("Settings", "Monochrome Tray Icon");
ui_settings_schema["monochrome_tray_icon"]["description"] = QT_TRANSLATE_NOOP("Settings", "Use a monochrome icon in the system tray instead of a full color icon");
ui_settings_schema["monochrome_tray_icon"]["type"] = "bool";
ui_settings_schema["monochrome_tray_icon"]["order"] = 2;
ui_settings_schema["hex_format"]["title"] = QT_TRANSLATE_NOOP("Settings", "Hex Format");
ui_settings_schema["hex_format"]["type"] = "string";
ui_settings_schema["hex_format"]["description"] = QT_TRANSLATE_NOOP("Settings", "Select #BBGGRR or #RRGGBB format for hex display and input");
ui_settings_schema["hex_format"]["enum"][0] = "BGR";
ui_settings_schema["hex_format"]["enum"][1] = "RGB";
ui_settings_schema["hex_format"]["order"] = 3;
ui_settings_schema["show_led_view"]["title"] = QT_TRANSLATE_NOOP("Settings", "Show LED View by Default");
ui_settings_schema["show_led_view"]["type"] = "bool";
ui_settings_schema["show_led_view"]["order"] = 4;
ui_settings_schema["numerical_labels"]["title"] = QT_TRANSLATE_NOOP("Settings", "Numerical Labels");
ui_settings_schema["numerical_labels"]["description"] = QT_TRANSLATE_NOOP("Settings", "Display numerical labels for otherwise non-labeled LEDs in the LED view");
ui_settings_schema["numerical_labels"]["type"] = "bool";
ui_settings_schema["numerical_labels"]["order"] = 5;
ui_settings_schema["disable_key_expansion"]["title"] = QT_TRANSLATE_NOOP("Settings", "Disable Key Expansion");
ui_settings_schema["disable_key_expansion"]["type"] = "bool";
ui_settings_schema["disable_key_expansion"]["order"] = 6;
ui_settings_schema["run_zone_checks"]["title"] = QT_TRANSLATE_NOOP("Settings", "Run Zone Checks on Rescan");
ui_settings_schema["run_zone_checks"]["type"] = "bool";
ui_settings_schema["run_zone_checks"]["order"] = 7;
ui_settings_schema["geometry"]["title"] = QT_TRANSLATE_NOOP("Settings", "Window Geometry");
ui_settings_schema["geometry"]["type"] = "object";
ui_settings_schema["geometry"]["order"] = 8;
ui_settings_schema["geometry"]["properties"]["load_geometry"]["title"] = QT_TRANSLATE_NOOP("Settings", "Load Window Geometry");
ui_settings_schema["geometry"]["properties"]["load_geometry"]["type"] = "bool";
ui_settings_schema["geometry"]["properties"]["load_geometry"]["order"] = 0;
ui_settings_schema["geometry"]["properties"]["save_on_exit"]["title"] = QT_TRANSLATE_NOOP("Settings", "Save on Exit");
ui_settings_schema["geometry"]["properties"]["save_on_exit"]["type"] = "bool";
ui_settings_schema["geometry"]["properties"]["save_on_exit"]["description"] = QT_TRANSLATE_NOOP("Settings", "Save window geometry on exit");
ui_settings_schema["geometry"]["properties"]["save_on_exit"]["order"] = 1;
ui_settings_schema["geometry"]["properties"]["x"]["title"] = QT_TRANSLATE_NOOP("Settings", "X");
ui_settings_schema["geometry"]["properties"]["x"]["type"] = "integer";
ui_settings_schema["geometry"]["properties"]["x"]["order"] = 2;
ui_settings_schema["geometry"]["properties"]["y"]["title"] = QT_TRANSLATE_NOOP("Settings", "Y");
ui_settings_schema["geometry"]["properties"]["y"]["type"] = "integer";
ui_settings_schema["geometry"]["properties"]["y"]["order"] = 3;
ui_settings_schema["geometry"]["properties"]["width"]["title"] = QT_TRANSLATE_NOOP("Settings", "Width");
ui_settings_schema["geometry"]["properties"]["width"]["type"] = "integer";
ui_settings_schema["geometry"]["properties"]["width"]["order"] = 4;
ui_settings_schema["geometry"]["properties"]["height"]["title"] = QT_TRANSLATE_NOOP("Settings", "Height");
ui_settings_schema["geometry"]["properties"]["height"]["type"] = "integer";
ui_settings_schema["geometry"]["properties"]["height"]["order"] = 5;
ResourceManager::get()->GetSettingsManager()->RegisterSettingsSchema("UserInterface", "User Interface", ui_settings_schema, 0);
#if defined(_WIN32) || defined(_MACOSX_X86_X64)
/*-----------------------------------------------------*\
| Create Drivers settings schema |
\*-----------------------------------------------------*/
json drivers_settings_schema;
#if defined(_WIN32)
drivers_settings_schema["shared_smbus_acces"]["title"] = QT_TRANSLATE_NOOP("Settings", "Shared SMBus Access (restart required)");
drivers_settings_schema["shared_smbus_acces"]["type"] = "bool";
drivers_settings_schema["smbus_sleep_mode"]["title"] = QT_TRANSLATE_NOOP("Settings", "SMBus Sleep Mode (restart required)");
drivers_settings_schema["smbus_sleep_mode"]["type"] = "integer";
drivers_settings_schema["smbus_sleep_mode"]["enum"][0] = 0;
drivers_settings_schema["smbus_sleep_mode"]["enumNames"][0] = "Always Busy";
drivers_settings_schema["smbus_sleep_mode"]["enum"][1] = 1;
drivers_settings_schema["smbus_sleep_mode"]["enumNames"][1] = "Short Busy";
drivers_settings_schema["smbus_sleep_mode"]["enum"][2] = 2;
drivers_settings_schema["smbus_sleep_mode"]["enumNames"][2] = "Always Sleep";
#else
drivers_settings_schema["amd_smbus_reduce_cpu"]["title"] = QT_TRANSLATE_NOOP("Settings", "AMD SMBus: Reduce CPU Usage (restart required)");
drivers_settings_schema["amd_smbus_reduce_cpu"]["type"] = "bool";
#endif
ResourceManager::get()->GetSettingsManager()->RegisterSettingsSchema("Drivers", "Drivers", drivers_settings_schema);
#endif
/*-----------------------------------------------------*\
| Register resource manager callbacks |
\*-----------------------------------------------------*/
ResourceManager::get()->RegisterResourceManagerCallback(OpenRGBDialogResourceManagerCallback, this);
/*-----------------------------------------------------*\
| Register profile manager callbacks |
\*-----------------------------------------------------*/
ResourceManager::get()->GetProfileManager()->RegisterProfileManagerCallback(OpenRGBDialogProfileManagerCallback, this);
/*-----------------------------------------------------*\
| Register settings manager callbacks |
\*-----------------------------------------------------*/
ResourceManager::get()->GetSettingsManager()->RegisterSettingsManagerCallback(OpenRGBDialogSettingsManagerCallback, this);
/*-----------------------------------------------------*\
| Register dialog show callback with log manager |
\*-----------------------------------------------------*/
LogManager::get()->RegisterDialogShowCallback(DialogShowCallback, this);
/*-----------------------------------------------------*\
| Initialize page pointers |
\*-----------------------------------------------------*/
ClientInfoPage = NULL;
SMBusToolsPage = NULL;
SoftInfoPage = NULL;
onDetectionProgressUpdated();
ui->DetectionProgressBar->setRange(0, 100);
ui->DetectionProgressBar->setValue(0);
ui->DetectionProgressBar->setTextVisible(true);
ui->DetectionProgressBar->setFormat("");
ui->DetectionProgressBar->setAlignment(Qt::AlignCenter);
/*-----------------------------------------------------*\
| Set up Save Profile button action and menu |
\*-----------------------------------------------------*/
QMenu* saveProfileMenu = new QMenu(this);
saveProfileMenu->addAction(ui->ActionSaveProfileAs);
ui->ButtonSaveProfile->setMenu(saveProfileMenu);
ui->ButtonSaveProfile->setDefaultAction(ui->ActionSaveProfile);
/*-----------------------------------------------------*\
| Set up tray icon menu |
\*-----------------------------------------------------*/
trayIconMenu = new QMenu( this );
trayIcon = new QSystemTrayIcon(this);
QAction* actionShowHide = new QAction(tr("Show/Hide"), this);
connect(actionShowHide, SIGNAL(triggered()), this, SLOT(on_ShowHide()));
trayIconMenu->addAction(actionShowHide);
profileMenu = new QMenu(tr("Profiles"), this);
trayIconMenu->addMenu(profileMenu);
QMenu* quickColorsMenu = new QMenu(tr("Quick Colors"), this);
QAction* actionQuickRed = new QAction(tr("Red"), this);
connect(actionQuickRed, SIGNAL(triggered()), this, SLOT(on_QuickRed()));
quickColorsMenu->addAction(actionQuickRed);
QAction* actionQuickYellow = new QAction(tr("Yellow"), this);
connect(actionQuickYellow, SIGNAL(triggered()), this, SLOT(on_QuickYellow()));
quickColorsMenu->addAction(actionQuickYellow);
QAction* actionQuickGreen = new QAction(tr("Green"), this);
connect(actionQuickGreen, SIGNAL(triggered()), this, SLOT(on_QuickGreen()));
quickColorsMenu->addAction(actionQuickGreen);
QAction* actionQuickCyan = new QAction(tr("Cyan"), this);
connect(actionQuickCyan, SIGNAL(triggered()), this, SLOT(on_QuickCyan()));
quickColorsMenu->addAction(actionQuickCyan);
QAction* actionQuickBlue = new QAction(tr("Blue"), this);
connect(actionQuickBlue, SIGNAL(triggered()), this, SLOT(on_QuickBlue()));
quickColorsMenu->addAction(actionQuickBlue);
QAction* actionQuickMagenta = new QAction(tr("Magenta"), this);
connect(actionQuickMagenta, SIGNAL(triggered()), this, SLOT(on_QuickMagenta()));
quickColorsMenu->addAction(actionQuickMagenta);
QAction* actionQuickWhite = new QAction(tr("White"), this);
connect(actionQuickWhite, SIGNAL(triggered()), this, SLOT(on_QuickWhite()));
quickColorsMenu->addAction(actionQuickWhite);
trayIconMenu->addMenu(quickColorsMenu);
QAction* actionLightsOff = new QAction(tr("Lights Off"), this);
actionLightsOff->setObjectName("ActionLightsOff");
connect(actionLightsOff, SIGNAL(triggered()), this, SLOT(on_LightsOff()));
trayIconMenu->addAction(actionLightsOff);
QAction* actionReScan = new QAction(tr("Rescan Devices"), this);
connect(actionReScan, SIGNAL(triggered()), this, SLOT(on_ButtonRescan_clicked()));
trayIconMenu->addAction(actionReScan);
actionExit = new QAction(tr("Exit"), this );
connect( actionExit, SIGNAL( triggered() ), this, SLOT( on_Exit() ));
trayIconMenu->addAction(actionExit);
connect(trayIcon,SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(on_ReShow(QSystemTrayIcon::ActivationReason)));
trayIcon->setToolTip("OpenRGB");
trayIcon->setContextMenu(trayIconMenu);
trayIcon->show();
/*-----------------------------------------------------*\
| Update the profile list |
\*-----------------------------------------------------*/
UpdateProfileList();
/*-----------------------------------------------------*\
| Update the device list and make sure the |
| ProgressBar gets a proper value |
\*-----------------------------------------------------*/
UpdateDevicesList();
/*-----------------------------------------------------*\
| Add Client Tab |
\*-----------------------------------------------------*/
AddClientTab();
/*-----------------------------------------------------*\
| Add Server Tab |
\*-----------------------------------------------------*/
AddServerTab();
/*-----------------------------------------------------*\
| Add the Software Info page |
\*-----------------------------------------------------*/
AddSoftwareInfoPage();
/*-----------------------------------------------------*\
| Add the settings page |
\*-----------------------------------------------------*/
AddSettingsPage();
/*-----------------------------------------------------*\
| Add the Supported Devices page |
\*-----------------------------------------------------*/
AddSupportedDevicesPage();
/*-----------------------------------------------------*\
| Initialize the plugin manager |
\*-----------------------------------------------------*/
plugin_manager = new PluginManager();
ResourceManager::get()->SetPluginManager(plugin_manager);
plugin_manager->RegisterAddPluginCallback(&CreatePluginCallback, this);
plugin_manager->RegisterRemovePluginCallback(&DeletePluginCallback, this);
/*-----------------------------------------------------*\
| Add the Plugins page |
\*-----------------------------------------------------*/
AddPluginsPage();
/*-----------------------------------------------------*\
| Add the Manually Added Devices settings page |
\*-----------------------------------------------------*/
AddManualDevicesSettingsPage();
/*-----------------------------------------------------*\
| Add the SMBus Tools page if enabled |
\*-----------------------------------------------------*/
if(ShowI2CTools)
{
AddI2CToolsPage();
}
/*-----------------------------------------------------*\
| Process Settings |
\*-----------------------------------------------------*/
onSettingsUpdated();
/*-----------------------------------------------------*\
| Connect aboutToQuit signal to handleAboutToQuit |
\*-----------------------------------------------------*/
connect(qApp, &QCoreApplication::aboutToQuit, this, &OpenRGBDialog::handleAboutToQuit);
/*-----------------------------------------------------*\
| Handle the condition where detection ended before we |
| finished initializing/registering detection callback |
\*-----------------------------------------------------*/
if(ResourceManager::get()->GetDetectionPercent() >= 100)
{
onDetectionEnded();
}
}
OpenRGBDialog::~OpenRGBDialog()
{
/*-----------------------------------------------------*\
| Unregister resource manager callbacks |
\*-----------------------------------------------------*/
ResourceManager::get()->UnregisterResourceManagerCallback(OpenRGBDialogResourceManagerCallback, this);
/*-----------------------------------------------------*\
| Unregister profile manager callbacks |
\*-----------------------------------------------------*/
ResourceManager::get()->GetProfileManager()->UnregisterProfileManagerCallback(OpenRGBDialogProfileManagerCallback, this);
delete ui;
}
void OpenRGBDialog::handleAboutToQuit()
{
/*-----------------------------------------------------*\
| Write window geometry to config (if enabled) |
\*-----------------------------------------------------*/
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
std::string ui_string = "UserInterface";
json ui_settings;
ui_settings = settings_manager->GetSettings(ui_string);
if(ui_settings.contains("geometry"))
{
if( ui_settings["geometry"].contains("load_geometry")
&& ui_settings["geometry"].contains("save_on_exit"))
{
if( ui_settings["geometry"]["load_geometry"].get<bool>()
&& ui_settings["geometry"]["save_on_exit"].get<bool>())
{
ui_settings["geometry"]["x"] = geometry().x();
ui_settings["geometry"]["y"] = geometry().y();
ui_settings["geometry"]["width"] = geometry().width();
ui_settings["geometry"]["height"] = geometry().height();
settings_manager->SetSettings(ui_string, ui_settings);
settings_manager->SaveSettings();
}
}
}
disconnect(qApp, &QCoreApplication::aboutToQuit, this, &OpenRGBDialog::handleAboutToQuit);
QCloseEvent* closeEvent = new QCloseEvent;
this->closeEvent(closeEvent);
delete closeEvent;
}
void OpenRGBDialog::changeEvent(QEvent *event)
{
if(event->type() == QEvent::LanguageChange)
{
ui->retranslateUi(this);
for(int i = 0; i < ui->MainTabBar->count(); i++)
{
/*---------------------------------------------*\
| If the objectName is either of the SDK tabs |
| then translate tab text (TODO: improve |
| workaround) |
\*---------------------------------------------*/
std::string label = ui->MainTabBar->widget(i)->objectName().toStdString();
if(label.substr(0,3) == "SDK")
{
ui->MainTabBar->setTabText(i, tr(label.c_str()));
}
}
}
}
void OpenRGBDialog::closeEvent(QCloseEvent *event)
{
ResourceManager::get()->WaitForDetection();
if (IsMinimizeOnClose() && !this->isHidden() && event->spontaneous())
{
#ifdef __APPLE__
MacUtils::ToggleApplicationDocklessState(false);
#endif
hide();
event->ignore();
}
else
{
plugin_manager->UnloadPlugins();
if(ResourceManager::get()->GetProfileManager()->LoadAutoProfileExit())
{
/*---------------------------------------------*\
| Pause briefly to ensure that all profiles are |
| loaded. |
\*---------------------------------------------*/
std::this_thread::sleep_for(std::chrono::milliseconds(250));
}
event->accept();
QApplication::exit(0);
}
}
void OpenRGBDialog::keyPressEvent(QKeyEvent *event)
{
if(event->key() == Qt::Key_F11)
{
if(isFullScreen())
{
showNormal();
}
else
{
showFullScreen();
}
event->accept();
}
else
{
QMainWindow::keyPressEvent(event);
}
}
bool OpenRGBDialog::isCompactTabMode()
{
QScreen* screen = QGuiApplication::primaryScreen();
qreal scale = screen->devicePixelRatio();
return (width() < (700 * scale));
}
void OpenRGBDialog::resizeEvent(QResizeEvent *event)
{
bool compact_mode = isCompactTabMode();
for(int i = 0; i < ui->DevicesTabBar->count(); i++)
{
((TabLabel *)ui->DevicesTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->blockSignals(true);
((TabLabel *)ui->DevicesTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->SetTextHidden(compact_mode);
((TabLabel *)ui->DevicesTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->blockSignals(false);
}
for(int i = 0; i < ui->InformationTabBar->count(); i++)
{
((TabLabel *)ui->InformationTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->blockSignals(true);
((TabLabel *)ui->InformationTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->SetTextHidden(compact_mode);
((TabLabel *)ui->InformationTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->blockSignals(false);
}
for(int i = 0; i < ui->SettingsTabBar->count(); i++)
{
((TabLabel *)ui->SettingsTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->blockSignals(true);
((TabLabel *)ui->SettingsTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->SetTextHidden(compact_mode);
((TabLabel *)ui->SettingsTabBar->tabBar()->tabButton(i, QTabBar::LeftSide))->blockSignals(false);
}
ui->DevicesTabBar->tabBar()->setIconSize(ui->DevicesTabBar->tabBar()->iconSize());
ui->InformationTabBar->tabBar()->setIconSize(ui->InformationTabBar->tabBar()->iconSize());
ui->SettingsTabBar->tabBar()->setIconSize(ui->SettingsTabBar->tabBar()->iconSize());
QWidget::resizeEvent(event);
}
void OpenRGBDialog::AddPluginsPage()
{
/*-----------------------------------------------------*\
| Create the Plugins page |
\*-----------------------------------------------------*/
PluginsPage = new OpenRGBPluginsPage(plugin_manager);
ui->SettingsTabBar->addTab(PluginsPage, "");
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* PluginTabLabel = new TabLabel(OpenRGBFont::extension, (char *)"Plugins", (char *)context, true);
ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, PluginTabLabel);
}
void OpenRGBDialog::AddSoftwareInfoPage()
{
/*-----------------------------------------------------*\
| Create the Software Information page |
\*-----------------------------------------------------*/
SoftInfoPage = new OpenRGBSoftwareInfoPage();
ui->InformationTabBar->addTab(SoftInfoPage, "");
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* SoftwareTabLabel = new TabLabel(OpenRGBFont::info, (char *)"About OpenRGB", (char *)context, true);
ui->InformationTabBar->tabBar()->setTabButton(ui->InformationTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SoftwareTabLabel);
}
void OpenRGBDialog::AddSupportedDevicesPage()
{
/*-----------------------------------------------------*\
| Create the Supported Devices page |
\*-----------------------------------------------------*/
SupportedPage = new OpenRGBSupportedDevicesPage();
ui->SettingsTabBar->addTab(SupportedPage, "");
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* SupportedTabLabel = new TabLabel(OpenRGBFont::controller, (char *)"Supported Devices", (char *)context, true);
ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SupportedTabLabel);
}
void OpenRGBDialog::AddSettingsPage()
{
/*-----------------------------------------------------*\
| Create the Settings page |
\*-----------------------------------------------------*/
SettingsPage = new OpenRGBSettingsPage();
ui->SettingsTabBar->addTab(SettingsPage, "");
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* SettingsTabLabel = new TabLabel(OpenRGBFont::options, (char *)"General Settings", (char *)context, true);
ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SettingsTabLabel);
}
void OpenRGBDialog::AddManualDevicesSettingsPage()
{
/*-----------------------------------------------------*\
| Create the Settings page |
\*-----------------------------------------------------*/
manualDevicesPage = new ManualDevicesSettingsPage();
ui->SettingsTabBar->addTab(manualDevicesPage, "");
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* SettingsTabLabel = new TabLabel(OpenRGBFont::bulb, (char *)"Manually Added Devices", (char *)context, true);
ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SettingsTabLabel);
}
void OpenRGBDialog::AddPlugin(OpenRGBPluginEntry* plugin)
{
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* PluginTabLabel = new TabLabel(OpenRGBFont::extension, (char *)plugin->info.Label.c_str(), (char *)context, false);
/*-----------------------------------------------------*\
| Place plugin as its own top level tab |
\*-----------------------------------------------------*/
if(plugin->info.Location == OPENRGB_PLUGIN_LOCATION_TOP)
{
QWidget* NewPluginTab = plugin->plugin->GetWidget();
plugin->widget = NewPluginTab;
OpenRGBPluginContainer* NewPluginContainer = new OpenRGBPluginContainer(NewPluginTab, this);
ui->MainTabBar->addTab(NewPluginContainer,QString().fromStdString(plugin->info.Label));
}
/*-----------------------------------------------------*\
| Place plugin in the Devices tab |
\*-----------------------------------------------------*/
else if(plugin->info.Location == OPENRGB_PLUGIN_LOCATION_DEVICES)
{
QWidget* NewPluginTab = plugin->plugin->GetWidget();
plugin->widget = NewPluginTab;
OpenRGBPluginContainer* NewPluginContainer = new OpenRGBPluginContainer(NewPluginTab, this);
ui->DevicesTabBar->addTab(NewPluginContainer," ");
ui->DevicesTabBar->tabBar()->setTabButton((ui->DevicesTabBar->count() - 1),QTabBar::LeftSide , PluginTabLabel);
}
/*-----------------------------------------------------*\
| Place plugin in the Information tab |
\*-----------------------------------------------------*/
else if(plugin->info.Location == OPENRGB_PLUGIN_LOCATION_INFORMATION)
{
QWidget* NewPluginTab = plugin->plugin->GetWidget();
plugin->widget = NewPluginTab;
OpenRGBPluginContainer* NewPluginContainer = new OpenRGBPluginContainer(NewPluginTab, this);
ui->InformationTabBar->addTab(NewPluginContainer," ");
ui->InformationTabBar->tabBar()->setTabButton((ui->InformationTabBar->count() - 1),QTabBar::LeftSide , PluginTabLabel);
}
/*-----------------------------------------------------*\
| Place plugin in the Settings tab |
\*-----------------------------------------------------*/
else if(plugin->info.Location == OPENRGB_PLUGIN_LOCATION_SETTINGS)
{
QWidget* NewPluginTab = plugin->plugin->GetWidget();
plugin->widget = NewPluginTab;
OpenRGBPluginContainer* NewPluginContainer = new OpenRGBPluginContainer(NewPluginTab, this);
ui->SettingsTabBar->addTab(NewPluginContainer," ");
ui->SettingsTabBar->tabBar()->setTabButton((ui->SettingsTabBar->count() - 1),QTabBar::LeftSide , PluginTabLabel);
}
/*-----------------------------------------------------*\
| Display an error message if the plugin does not |
| specify a valid location |
\*-----------------------------------------------------*/
else
{
std::cout << ("Cannot load plugin '" + plugin->info.Name + "' as it does not specify a valid location.\n");
}
QMenu* NewTrayMenu = plugin->plugin->GetTrayMenu();
plugin->traymenu = NewTrayMenu;
if(NewTrayMenu)
{
trayIconMenu->insertMenu(actionExit, NewTrayMenu);
}
}
void OpenRGBDialog::RemovePlugin(OpenRGBPluginEntry* plugin)
{
/*-----------------------------------------------------*\
| Remove plugin's tray menu |
\*-----------------------------------------------------*/
if(plugin->traymenu)
{
QWidget* plugin_tray_entry = trayIconMenu->find(plugin->traymenu->winId());
if(plugin_tray_entry)
{
trayIconMenu->removeAction(plugin->traymenu->menuAction());
}
}
/*-----------------------------------------------------*\
| Find plugin's container |
\*-----------------------------------------------------*/
QTabWidget *plugin_parent_widget = nullptr;
switch(plugin->info.Location)
{
case OPENRGB_PLUGIN_LOCATION_TOP:
plugin_parent_widget = ui->MainTabBar;
break;
case OPENRGB_PLUGIN_LOCATION_DEVICES:
plugin_parent_widget = ui->DevicesTabBar;
break;
case OPENRGB_PLUGIN_LOCATION_INFORMATION:
plugin_parent_widget = ui->InformationTabBar;
break;
case OPENRGB_PLUGIN_LOCATION_SETTINGS:
plugin_parent_widget = ui->InformationTabBar;
break;
default:
break;
}
/*-----------------------------------------------------*\
| Remove plugin from its container |
\*-----------------------------------------------------*/
if(plugin_parent_widget != nullptr)
{
for(int tab_idx = 0; tab_idx < plugin_parent_widget->count(); tab_idx++)
{
if(dynamic_cast<OpenRGBPluginContainer*>(plugin_parent_widget->widget(tab_idx)) != nullptr)
{
if(dynamic_cast<OpenRGBPluginContainer*>(plugin_parent_widget->widget(tab_idx))->plugin_widget == plugin->widget)
{
plugin_parent_widget->removeTab(tab_idx);
break;
}
}
}
}
}
void OpenRGBDialog::AddI2CToolsPage()
{
ShowI2CTools = true;
/*-----------------------------------------------------*\
| Create the I2C Tools page if it doesn't exist yet |
\*-----------------------------------------------------*/
SMBusToolsPage = new OpenRGBSystemInfoPage(ResourceManager::get()->GetI2CBuses());
/*-----------------------------------------------------*\
| Create the I2C Tools tab in the Information bar |
\*-----------------------------------------------------*/
ui->InformationTabBar->addTab(SMBusToolsPage, "");
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* SMBusToolsTabLabel = new TabLabel(OpenRGBFont::toolbox, (char *)"SMBus Tools", (char *)context, true);
ui->InformationTabBar->tabBar()->setTabButton(ui->InformationTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SMBusToolsTabLabel);
}
void OpenRGBDialog::AddClientTab()
{
/*-----------------------------------------------------*\
| Add client information tab if it doesn't exist yet |
\*-----------------------------------------------------*/
if(ClientInfoPage == NULL)
{
ClientInfoPage = new OpenRGBClientInfoPage();
ClientInfoPage->setObjectName(QString("SDK Client"));
ui->MainTabBar->insertTab(2, ClientInfoPage, tr("SDK Client"));
}
}
void OpenRGBDialog::AddServerTab()
{
/*-----------------------------------------------------*\
| Add server information tab if there is a server |
\*-----------------------------------------------------*/
if(!ResourceManager::get()->IsLocalClient())
{
OpenRGBServerInfoPage *ServerInfoPage = new OpenRGBServerInfoPage();
ServerInfoPage->setObjectName(QString("SDK Server"));
ui->MainTabBar->insertTab(2, ServerInfoPage, tr("SDK Server"));
}
}
void OpenRGBDialog::ClearDevicesList()
{
for(int tab_idx = 0; tab_idx < ui->DevicesTabBar->count(); tab_idx++)
{
if(dynamic_cast<OpenRGBPluginContainer*>(ui->DevicesTabBar->widget(tab_idx)) == nullptr)
{
delete ui->DevicesTabBar->widget(tab_idx);
ui->DevicesTabBar->removeTab(tab_idx);
}
}
for(int tab_idx = 0; tab_idx < ui->InformationTabBar->count(); tab_idx++)
{
if(dynamic_cast<OpenRGBPluginContainer*>(ui->InformationTabBar->widget(tab_idx)) == nullptr)
{
delete ui->InformationTabBar->widget(tab_idx);
ui->InformationTabBar->removeTab(tab_idx);
}
}
}
void OpenRGBDialog::UpdateDevicesList()
{
std::vector<RGBController *> controllers = ResourceManager::get()->GetRGBControllers();
/*-----------------------------------------------------*\
| Keep track of the number of controllers added/kept in |
| the tab list |
\*-----------------------------------------------------*/
unsigned int controller_tab_count = 0;
/*-----------------------------------------------------*\
| Loop through each controller in the list. |
\*-----------------------------------------------------*/
for(unsigned int controller_idx = 0; controller_idx < controllers.size(); controller_idx++)
{
/*-------------------------------------------------*\
| Search for this controller in existing pages |
\*-------------------------------------------------*/
bool found = false;
/*-------------------------------------------------*\
| First, search for the controller page in the tab |
| bar |
\*-------------------------------------------------*/
for(int tab_idx = 0; tab_idx < ui->DevicesTabBar->count(); tab_idx++)
{
/*---------------------------------------------*\
| Get a pointer to the page at this index in |
| the tab bar |
\*---------------------------------------------*/
QWidget* page = ui->DevicesTabBar->widget(tab_idx);
/*---------------------------------------------*\
| Verify this page is an OpenRGBDevicePage |
\*---------------------------------------------*/
if(dynamic_cast<OpenRGBDevicePage*>(page) != nullptr)
{
/*-----------------------------------------*\
| If the current tab matches the current |
| controller, check if it is hidden |
\*-----------------------------------------*/
if(controllers[controller_idx] == ((OpenRGBDevicePage*)page)->GetController())
{
/*-------------------------------------*\
| Set the found flag indicating that a |
| page for this controller has been |
| found in the tab bar |
\*-------------------------------------*/
found = true;
/*-------------------------------------*\
| If the controller for this page is |
| hidden, remove the page from the tab |
| bar and store it in the hidden pages |
| vector |
\*-------------------------------------*/
if(controllers[controller_idx]->GetHidden())
{
hidden_pages.push_back((OpenRGBDevicePage*)page);
ui->DevicesTabBar->removeTab(tab_idx);
/*---------------------------------*\
| Decrement tab index to account |
| for removing tab |
\*---------------------------------*/
tab_idx--;
}
/*-------------------------------------*\
| Otherwise, move the tab to the |
| current index |
\*-------------------------------------*/
else
{
controller_tab_count++;
ui->DevicesTabBar->tabBar()->moveTab(tab_idx, controller_idx);
}
break;
}
}
}
/*-------------------------------------------------*\
| Next, if it wasn't found in the tab bar, search |
| for the controller page in hidden pages vector |
\*-------------------------------------------------*/
if(!found)
{
for(std::size_t page_idx = 0; page_idx < hidden_pages.size(); page_idx++)
{
/*-----------------------------------------*\
| Get a pointer to the page at this index |
| in the hidden pages vector |
\*-----------------------------------------*/
QWidget* page = hidden_pages[page_idx];
/*-----------------------------------------*\
| If the current tab matches the current |
| controller, check if it is hidden |
\*-----------------------------------------*/
if(controllers[controller_idx] == ((OpenRGBDevicePage*)page)->GetController())
{
/*-------------------------------------*\
| Set the found flag indicating that a |
| page for this controller has been |
| found in the hidden pages vector |
\*-------------------------------------*/
found = true;
/*-------------------------------------*\
| If the controller for this page is |
| not hidden, remove the page from the |
| hidden pages vector and add it to the |
| tab bar |
\*-------------------------------------*/
if(!(controllers[controller_idx]->GetHidden()))
{
ui->DevicesTabBar->addTab(page, "");
/*---------------------------------*\
| Create the tab label |
\*---------------------------------*/
TabLabel* NewTabLabel = new TabLabel(OpenRGBFont::GetIconIDFromDeviceType(controllers[controller_idx]->GetDeviceType()), (char *)controllers[controller_idx]->GetName().c_str(), (char *)context, false);
ui->DevicesTabBar->tabBar()->setTabButton(ui->DevicesTabBar->count() - 1, QTabBar::LeftSide, NewTabLabel);
/*---------------------------------*\
| Now move the new tab to the |
| correct position |
\*---------------------------------*/
ui->DevicesTabBar->tabBar()->moveTab(ui->DevicesTabBar->count() - 1, controller_tab_count);
/*---------------------------------*\
| Increment tab counter |
\*---------------------------------*/
controller_tab_count++;
hidden_pages.erase(hidden_pages.begin() + page_idx);
/*---------------------------------*\
| Decrement page index to account |
| for removing page |
\*---------------------------------*/
page_idx--;
}
}
}
}
/*-------------------------------------------------*\
| If the controller still has not been found, |
| create a new page for it |
\*-------------------------------------------------*/
if(!found)
{
/*---------------------------------------------*\
| Create a new OpenRGBDevicePage |
\*---------------------------------------------*/
OpenRGBDevicePage *NewPage = new OpenRGBDevicePage(controllers[controller_idx]);
/*---------------------------------------------*\
| Connect the page's Set All button to the Set |
| All slot |
\*---------------------------------------------*/
connect(NewPage,
SIGNAL(SetAllDevices(unsigned char, unsigned char, unsigned char)),
this,
SLOT(on_SetAllDevices(unsigned char, unsigned char, unsigned char)));
/*---------------------------------------------*\
| Connect the page's Refresh List signal to the |
| Refresh List slot |
\*---------------------------------------------*/
connect(NewPage,
SIGNAL(RefreshList()),
this,
SLOT(onDeviceListUpdated()));
if(controllers[controller_idx]->GetHidden())
{
hidden_pages.push_back(NewPage);
}
else
{
ui->DevicesTabBar->addTab(NewPage, "");
/*-----------------------------------------*\
| Create the tab label |
\*-----------------------------------------*/
TabLabel* NewTabLabel = new TabLabel(OpenRGBFont::GetIconIDFromDeviceType(controllers[controller_idx]->GetDeviceType()), (char *)controllers[controller_idx]->GetName().c_str(), (char *)context, false);
NewTabLabel->SetTextHidden(isCompactTabMode());
ui->DevicesTabBar->tabBar()->setTabButton(ui->DevicesTabBar->count() - 1, QTabBar::LeftSide, NewTabLabel);
/*-----------------------------------------*\
| Now move the new tab to the correct |
| position |
\*-----------------------------------------*/
ui->DevicesTabBar->tabBar()->moveTab(ui->DevicesTabBar->count() - 1, controller_tab_count);
/*-----------------------------------------*\
| Increment tab counter |
\*-----------------------------------------*/
controller_tab_count++;
}
}
/*-------------------------------------------------*\
| Loop through each tab in the information tab bar |
\*-------------------------------------------------*/
found = false;
for(int tab_idx = 0; tab_idx < ui->InformationTabBar->count(); tab_idx++)
{
/*---------------------------------------------*\
| If type is a device info page, check it |
\*---------------------------------------------*/
std::string type_str = ui->InformationTabBar->widget(tab_idx)->metaObject()->className();
if(type_str == "OpenRGBDeviceInfoPage")
{
OpenRGBDeviceInfoPage* page = (OpenRGBDeviceInfoPage*) ui->InformationTabBar->widget(tab_idx);
/*-----------------------------------------*\
| If the current tab matches the current |
| controller, move the tab to the correct |
| position |
\*-----------------------------------------*/
if(controllers[controller_idx] == page->GetController())
{
found = true;
ui->InformationTabBar->tabBar()->moveTab(tab_idx, controller_idx);
break;
}
}
}
if(!found)
{
/*---------------------------------------------*\
| The controller does not have a tab already |
| created. Create a new tab and move it to |
| the correct position. |
\*---------------------------------------------*/
OpenRGBDeviceInfoPage *NewPage = new OpenRGBDeviceInfoPage(controllers[controller_idx]);
ui->InformationTabBar->addTab(NewPage, "");
/*---------------------------------------------*\
| Create the tab label |
\*---------------------------------------------*/
TabLabel* NewTabLabel = new TabLabel(OpenRGBFont::GetIconIDFromDeviceType(controllers[controller_idx]->GetDeviceType()), (char *)controllers[controller_idx]->GetName().c_str(), (char *)context, false);
NewTabLabel->SetTextHidden(isCompactTabMode());
ui->InformationTabBar->tabBar()->setTabButton(ui->InformationTabBar->count() - 1, QTabBar::LeftSide, NewTabLabel);
ui->InformationTabBar->tabBar()->setTabToolTip(ui->InformationTabBar->count() - 1, QString::fromStdString(controllers[controller_idx]->GetName()));
/*---------------------------------------------*\
| Now move the new tab to the correct position |
\*---------------------------------------------*/
ui->InformationTabBar->tabBar()->moveTab(ui->InformationTabBar->count() - 1, controller_idx);
}
}
/*-----------------------------------------------------*\
| Remove all remaining device tabs |
\*-----------------------------------------------------*/
unsigned int tab_count = ui->DevicesTabBar->count();
unsigned int base_tab = controller_tab_count;
for(std::size_t tab_idx = base_tab; tab_idx < tab_count; tab_idx++)
{
QWidget* tab_widget = ui->DevicesTabBar->widget(base_tab);
if(dynamic_cast<OpenRGBPluginContainer*>(tab_widget) == nullptr)
{
ui->DevicesTabBar->removeTab(base_tab);
delete tab_widget;
}
}
bool found = true;
while(found)
{
found = false;
/*-------------------------------------------------*\
| Remove all remaining device information tabs, |
| leaving other information tabs alone |
\*-------------------------------------------------*/
for(std::size_t tab_idx = controllers.size(); tab_idx < (std::size_t)ui->InformationTabBar->count(); tab_idx++)
{
std::string type_str = ui->InformationTabBar->widget(base_tab)->metaObject()->className();
if(type_str == "OpenRGBDeviceInfoPage")
{
found = true;
QWidget* tab_widget = ui->InformationTabBar->widget(base_tab);
ui->InformationTabBar->removeTab(base_tab);
delete tab_widget;
break;
}
base_tab += 1;
}
}
if(device_view_showing)
{
ShowLEDView();
}
}
void OpenRGBDialog::SetDialogMessage(PLogMessage msg)
{
dialog_message = QString::fromStdString(msg->buffer);
}
void OpenRGBDialog::SetLanguage(std::string language)
{
QApplication* app = static_cast<QApplication *>(QApplication::instance());
QMap<QString, QString> language_map;
QDirIterator language_files(":/i18n/", QDirIterator::Subdirectories);
bool loaded = false;
while(language_files.hasNext())
{
if(translator.load(language_files.next()))
{
language_map.insert(translator.translate("Settings", "English - US"), language_files.filePath());
}
}
QString language_file = language_map[QString::fromStdString(language)];
app->removeTranslator(&translator);
if(language == "System Default")
{
QLocale locale = QLocale(QLocale::system());
QLocale::setDefault(locale);
loaded = translator.load(":/i18n/" + QString("OpenRGB_%1.qm").arg(locale.name()));
}
else
{
loaded = translator.load(language_file);
}
if(loaded)
{
app->installTranslator(&translator);
LOG_DEBUG("[OpenRGBDialog] Changed Language to %s from the %s file\n", language.c_str(), language_file.toStdString().c_str());
}
}
void OpenRGBDialog::UpdateActiveProfile()
{
ProfileManager* profile_manager = ResourceManager::get()->GetProfileManager();
int profile_index = ui->ProfileBox->findText(QString::fromStdString(profile_manager->GetActiveProfile()));
if(profile_index < 1)
{
profile_index = 0;
}
ui->ProfileBox->blockSignals(true);
ui->ProfileBox->setCurrentIndex(profile_index);
ui->ProfileBox->blockSignals(false);
}
void OpenRGBDialog::UpdateProfileList()
{
ProfileManager* profile_manager = ResourceManager::get()->GetProfileManager();
if(profile_manager != NULL)
{
ui->ProfileBox->blockSignals(true);
/*-------------------------------------------------*\
| Clear profile combo box and tray icon menu |
\*-------------------------------------------------*/
ui->ProfileBox->clear();
profileMenu->clear();
ui->ProfileBox->addItem("No Active Profile");
for(std::size_t profile_index = 0; profile_index < profile_manager->GetProfileList().size(); profile_index++)
{
/*---------------------------------------------*\
| Fill in profile combo box |
\*---------------------------------------------*/
ui->ProfileBox->addItem(profile_manager->GetProfileList()[profile_index].c_str());
/*---------------------------------------------*\
| Fill in profile tray icon menu |
\*---------------------------------------------*/
QAction* actionProfileSelected = new QAction(profile_manager->GetProfileList()[profile_index].c_str(), this);
actionProfileSelected->setObjectName(profile_manager->GetProfileList()[profile_index].c_str());
connect(actionProfileSelected, SIGNAL(triggered()), this, SLOT(on_ProfileSelected()));
profileMenu->addAction(actionProfileSelected);
}
ui->ProfileBox->blockSignals(false);
}
UpdateActiveProfile();
emit ProfileListChanged();
}
void OpenRGBDialog::OnSuspend()
{
if(ResourceManager::get()->GetProfileManager()->LoadAutoProfileSuspend())
{
plugin_manager->UnloadPlugins();
}
}
void OpenRGBDialog::OnResume()
{
plugin_manager->LoadPlugins();
ResourceManager::get()->GetProfileManager()->LoadAutoProfileResume();
}
void OpenRGBDialog::on_Exit()
{
/*-----------------------------------------------------*\
| This is the exit from the tray icon NOT the main exit |
| button (top right on Windows) |
| |
| The hide is important, otherwise it won't close when |
| minimize on close is enabled |
\*-----------------------------------------------------*/
this->hide();
trayIcon->hide();
close();
}
void OpenRGBDialog::on_LightsOff()
{
on_SetAllDevices(0x00, 0x00, 0x00);
}
void OpenRGBDialog::on_QuickRed()
{
on_SetAllDevices(0xFF, 0x00, 0x00);
}
void OpenRGBDialog::on_QuickYellow()
{
on_SetAllDevices(0xFF, 0xFF, 0x00);
}
void OpenRGBDialog::on_QuickGreen()
{
on_SetAllDevices(0x00, 0xFF, 0x00);
}
void OpenRGBDialog::on_QuickCyan()
{
on_SetAllDevices(0x00, 0xFF, 0xFF);
}
void OpenRGBDialog::on_QuickBlue()
{
on_SetAllDevices(0x00, 0x00, 0xFF);
}
void OpenRGBDialog::on_QuickMagenta()
{
on_SetAllDevices(0xFF, 0x00, 0xFF);
}
void OpenRGBDialog::on_QuickWhite()
{
on_SetAllDevices(0xFF, 0xFF, 0xFF);
}
void OpenRGBDialog::onDeviceListUpdated()
{
UpdateDevicesList();
}
void OpenRGBDialog::onDetectionProgressUpdated()
{
ui->DetectionProgressBar->setValue(ResourceManager::get()->GetDetectionPercent());
ui->DetectionProgressBar->setFormat(QString::fromStdString(ResourceManager::get()->GetDetectionString()));
if(ResourceManager::get()->GetDetectionPercent() == 100)
{
SetDetectionViewState(false);
}
else
{
SetDetectionViewState(true);
}
}
void OpenRGBDialog::onDetectionStarted()
{
/*-----------------------------------------------------*\
| Hide devices view on rescan so it stops handling |
| paint events. |
| Memorize previous value of device_view_showing and |
| restore it. |
\*-----------------------------------------------------*/
bool device_view_showing_prev = device_view_showing;
HideLEDView();
device_view_showing = device_view_showing_prev;
/*-----------------------------------------------------*\
| Show the detection progress bar. |
\*-----------------------------------------------------*/
SetDetectionViewState(true);
}
void OpenRGBDialog::onDetectionEnded()
{
/*-----------------------------------------------------*\
| Detect unconfigured zones and prompt for resizing |
\*-----------------------------------------------------*/
OpenRGBZoneInitializationDialog::RunChecks(this);
/*-----------------------------------------------------*\
| Load plugins after the first detection (ONLY the |
| first) |
\*-----------------------------------------------------*/
if(!plugins_loaded)
{
plugin_manager->ScanAndLoadPlugins();
plugins_loaded = true;
PluginsPage->RefreshList();
}
if(device_view_showing)
{
ShowLEDView();
}
/*-----------------------------------------------------*\
| Load the on open automatic profile |
\*-----------------------------------------------------*/
ResourceManager::get()->GetProfileManager()->LoadAutoProfileOpen();
}
void OpenRGBDialog::onSettingsUpdated()
{
/*-----------------------------------------------------*\
| Get SettingsManager pointer |
\*-----------------------------------------------------*/
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
/*-----------------------------------------------------*\
| Read UserInterface settings |
\*-----------------------------------------------------*/
json ui_settings = settings_manager->GetSettings("UserInterface");
if(JsonUtils::JsonGetBool(ui_settings, "show_led_view"))
{
ShowLEDView();
}
/*-----------------------------------------------------*\
| If geometry information exists in settings, apply it |
\*-----------------------------------------------------*/
if(ui_settings.contains("geometry"))
{
bool load_geometry = JsonUtils::JsonGetBool(ui_settings["geometry"], "load_geometry");
if(load_geometry)
{
QRect set_window;
/*---------------------------------------------*\
| x and y can be set independent of width and |
| height. QT attempts to clamp these values in |
| case the user enters invalid numbers. |
\*---------------------------------------------*/
if( ui_settings["geometry"].contains("x")
&& ui_settings["geometry"].contains("y"))
{
set_window.setX(ui_settings["geometry"]["x"].get<int>());
set_window.setY(ui_settings["geometry"]["y"].get<int>());
}
if( ui_settings["geometry"].contains("width")
&& ui_settings["geometry"].contains("height"))
{
set_window.setWidth(ui_settings["geometry"]["width"].get<int>());
set_window.setHeight(ui_settings["geometry"]["height"].get<int>());
}
setGeometry(set_window);
}
}
/*-----------------------------------------------------*\
| If monochrome tray icon exists in settings, apply it |
| or else set the icon to the default window logo |
\*-----------------------------------------------------*/
SetTrayIcon(JsonUtils::JsonGetBool(ui_settings, "monochrome_tray_icon"));
if(ui_settings.contains("language"))
{
std::string language = ui_settings["language"];
SetLanguage(language);
}
/*-----------------------------------------------------*\
| Read LogManager settings |
\*-----------------------------------------------------*/
json log_manager_settings = settings_manager->GetSettings("LogManager");
bool log_console_enabled = JsonUtils::JsonGetBool(log_manager_settings, "log_console");
/*-----------------------------------------------------*\
| Add the log console page |
\*-----------------------------------------------------*/
if(log_console_enabled)
{
AddConsolePage();
}
else
{
RemoveConsolePage();
}
/*-----------------------------------------------------*\
| Read AutoStart settings |
\*-----------------------------------------------------*/
json autostart_settings = settings_manager->GetSettings("AutoStart");
std::string autostart_arguments = JsonUtils::JsonGetString(autostart_settings, "custom_arguments");
bool autostart_enabled = JsonUtils::JsonGetBool(autostart_settings, "enabled");
bool autostart_minimized = JsonUtils::JsonGetBool(autostart_settings, "start_minimized");
AutoStart auto_start("OpenRGB");
if(autostart_minimized)
{
autostart_arguments = "--startminimized " + autostart_arguments;
}
if(autostart_enabled)
{
AutoStartInfo auto_start_info;
auto_start_info.args = autostart_arguments;
auto_start_info.category = "Utility;";
auto_start_info.desc = std::string("OpenRGB ") + std::string(VERSION_STRING);
auto_start_info.icon = "OpenRGB";
auto_start_info.path = auto_start.GetExePath();
auto_start.EnableAutoStart(auto_start_info);
}
else
{
auto_start.DisableAutoStart();
}
}
void OpenRGBDialog::on_SetAllDevices(unsigned char red, unsigned char green, unsigned char blue)
{
ResourceManager::get()->GetProfileManager()->ClearActiveProfile();
/*-----------------------------------------------------*\
| Send the about to load profile signal to plugins |
\*-----------------------------------------------------*/
plugin_manager->OnProfileAboutToLoad();
/*-----------------------------------------------------*\
| Apply the color to all device pages |
\*-----------------------------------------------------*/
for(int device = 0; device < ui->DevicesTabBar->count(); device++)
{
qobject_cast<OpenRGBDevicePage *>(ui->DevicesTabBar->widget(device))->SetCustomMode(red, green, blue);
}
}
void OpenRGBDialog::on_ShowHide()
{
if(isHidden())
{
#ifdef __APPLE__
MacUtils::ToggleApplicationDocklessState(true);
#endif
show();
if(isMinimized())
{
bool maximize = isMaximized();
showNormal();
if(maximize)
{
showMaximized();
}
}
}
else
{
#ifdef __APPLE__
MacUtils::ToggleApplicationDocklessState(false);
#endif
hide();
}
}
void OpenRGBDialog::onShowDialogMessage()
{
std::size_t hash = std::hash<std::string>{}(dialog_message.toStdString());
/*-----------------------------------------------------*\
| Load the LogManager settings and check if the hash of |
| this message is in the no-show list |
\*-----------------------------------------------------*/
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
std::string log_manager_string = "LogManager";
json log_manager_settings;
log_manager_settings = settings_manager->GetSettings(log_manager_string);
/*-----------------------------------------------------*\
| If in the no-show list, clear the message string and |
| return without displaying message box |
\*-----------------------------------------------------*/
if(log_manager_settings.contains("dialog_no_show_hashes"))
{
for(unsigned int list_idx = 0; list_idx < log_manager_settings["dialog_no_show_hashes"].size(); list_idx++)
{
if(log_manager_settings["dialog_no_show_hashes"][list_idx] == hash)
{
dialog_message.clear();
return;
}
}
}
QMessageBox box;
box.setInformativeText(QCoreApplication::translate("ResourceManager", dialog_message.toUtf8()));
QCheckBox* CheckBox_DontShowAgain = new QCheckBox("Don't show this message again");
DontShowAgain = false;
#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
QObject::connect(CheckBox_DontShowAgain, &QCheckBox::checkStateChanged, [this](Qt::CheckState state)
#else
QObject::connect(CheckBox_DontShowAgain, &QCheckBox::stateChanged, [this](int state)
#endif
{
if(static_cast<Qt::CheckState>(state) == Qt::CheckState::Checked)
{
this->DontShowAgain = true;
}
});
box.setCheckBox(CheckBox_DontShowAgain);
box.setTextFormat(Qt::RichText);
box.setTextInteractionFlags(Qt::TextSelectableByMouse|Qt::TextBrowserInteraction);
box.exec();
if(DontShowAgain)
{
/*-------------------------------------------------*\
| Add hash of dialog text to no-show list in |
| LogManager settings |
\*-------------------------------------------------*/
log_manager_settings["dialog_no_show_hashes"].push_back(hash);
settings_manager->SetSettings(log_manager_string, log_manager_settings);
settings_manager->SaveSettings();
}
DontShowAgain = false;
dialog_message.clear();
}
void OpenRGBDialog::on_ReShow(QSystemTrayIcon::ActivationReason reason)
{
if (reason == QSystemTrayIcon::DoubleClick)
{
if (isHidden())
{
show();
if(isMinimized())
{
bool maximize = isMaximized();
showNormal();
if(maximize)
{
showMaximized();
}
}
}
}
}
void OpenRGBDialog::on_ProfileSelected()
{
ProfileManager* profile_manager = ResourceManager::get()->GetProfileManager();
if(profile_manager != NULL)
{
/*-------------------------------------------------*\
| Get the profile filename from the selected object |
\*-------------------------------------------------*/
std::string profile_name = QObject::sender()->objectName().toStdString();
/*-------------------------------------------------*\
| Load the profile |
\*-------------------------------------------------*/
profile_manager->LoadProfile(profile_name);
UpdateActiveProfile();
}
}
void OpenRGBDialog::on_ProfileBox_currentIndexChanged(int index)
{
ProfileManager* profile_manager = ResourceManager::get()->GetProfileManager();
if(profile_manager != NULL)
{
if(index > 0)
{
/*---------------------------------------------*\
| Get the profile filename from the profiles |
| list |
\*---------------------------------------------*/
std::string profile_name = ui->ProfileBox->currentText().toStdString();
/*---------------------------------------------*\
| Load the profile |
\*---------------------------------------------*/
profile_manager->LoadProfile(profile_name);
}
else
{
profile_manager->ClearActiveProfile();
}
}
}
void OpenRGBDialog::on_ButtonDeleteProfile_clicked()
{
ProfileManager* profile_manager = ResourceManager::get()->GetProfileManager();
if(profile_manager != NULL)
{
std::string profile_name = "";
if(ui->ProfileBox->currentIndex() == 0)
{
OpenRGBProfileListDialog dialog(false);
/*---------------------------------------------*\
| Open Profile Name Dialog |
\*---------------------------------------------*/
profile_name = dialog.show();
}
else
{
/*---------------------------------------------*\
| Get the profile filename from the profiles |
| list |
\*---------------------------------------------*/
profile_name = ui->ProfileBox->currentText().toStdString();
}
if(profile_name != "")
{
/*---------------------------------------------*\
| Confirm we want to delete the profile |
\*---------------------------------------------*/
QMessageBox::StandardButton reply;
reply = QMessageBox::question(this, tr("Delete Profile"), tr("Do you really want to delete this profile?"), QMessageBox::Yes|QMessageBox::No);
/*---------------------------------------------*\
| Delete the profile |
\*---------------------------------------------*/
if(reply == QMessageBox::Yes)
{
profile_manager->DeleteProfile(profile_name);
}
}
}
}
void OpenRGBDialog::on_ButtonToggleDeviceView_clicked()
{
if(device_view_showing)
{
HideLEDView();
}
else
{
ShowLEDView();
}
}
void OpenRGBDialog::ShowLEDView()
{
for(int device = 0; device < ui->DevicesTabBar->count(); device++)
{
OpenRGBDevicePage* device_page = qobject_cast<OpenRGBDevicePage *>(ui->DevicesTabBar->widget(device));
/*-------------------------------------------------*\
| Check the cast to make sure it is a device and |
| not plugin |
\*-------------------------------------------------*/
if(device_page)
{
device_page->ShowDeviceView();
}
}
device_view_showing = true;
}
void OpenRGBDialog::HideLEDView()
{
for(int device = 0; device < ui->DevicesTabBar->count(); device++)
{
qobject_cast<OpenRGBDevicePage *>(ui->DevicesTabBar->widget(device))->HideDeviceView();
}
device_view_showing = false;
}
void OpenRGBDialog::on_ButtonStopDetection_clicked()
{
/*-----------------------------------------------------*\
| Notify the detection thread that it has to die |
\*-----------------------------------------------------*/
ResourceManager::get()->StopDeviceDetection();
/*-----------------------------------------------------*\
| Pretend we're done already by hiding the progress bar |
\*-----------------------------------------------------*/
SetDetectionViewState(false);
}
void OpenRGBDialog::SetDetectionViewState(bool detection_showing)
{
if(detection_showing)
{
/*-------------------------------------------------*\
| Show the detection progress and hide the normal |
| buttons |
\*-------------------------------------------------*/
ui->ActiveProfileLabel->setVisible(false);
ui->ButtonToggleDeviceView->setVisible(false);
ui->ButtonRescan->setVisible(false);
ui->ButtonSaveProfile->setVisible(false);
ui->ButtonDeleteProfile->setVisible(false);
ui->ProfileBox->setVisible(false);
ui->DetectionProgressBar->setVisible(true);
ui->DetectionProgressLabel->setVisible(true);
ui->ButtonStopDetection->setVisible(true);
}
else
{
/*-------------------------------------------------*\
| Hide the detection progress and show the normal |
| buttons |
\*-------------------------------------------------*/
ui->DetectionProgressBar->setVisible(false);
ui->DetectionProgressLabel->setVisible(false);
ui->ButtonStopDetection->setVisible(false);
ui->ActiveProfileLabel->setVisible(true);
ui->ButtonToggleDeviceView->setVisible(true);
ui->ButtonRescan->setVisible(true);
ui->ButtonSaveProfile->setVisible(true);
ui->ButtonDeleteProfile->setVisible(true);
ui->ProfileBox->setVisible(true);
}
}
void OpenRGBDialog::SetTrayIcon(bool tray_icon)
{
if(tray_icon)
{
trayIcon->setIcon(QIcon(":OpenRGBMonochrome.png"));
}
else
{
trayIcon->setIcon(QIcon(":org.openrgb.OpenRGB.png"));
}
}
void OpenRGBDialog::SaveProfile()
{
ProfileManager* profile_manager = ResourceManager::get()->GetProfileManager();
if(profile_manager != NULL)
{
/*-------------------------------------------------*\
| Get the profile filename from the profiles list |
\*-------------------------------------------------*/
std::string filename = ui->ProfileBox->currentText().toStdString();
/*-------------------------------------------------*\
| Save the profile |
\*-------------------------------------------------*/
OpenRGBProfileEditorDialog editor(filename);
editor.show();
}
}
void OpenRGBDialog::SaveProfileAs()
{
ProfileManager* profile_manager = ResourceManager::get()->GetProfileManager();
if(profile_manager != NULL)
{
OpenRGBProfileListDialog dialog;
/*-------------------------------------------------*\
| Open Profile Name Dialog |
\*-------------------------------------------------*/
std::string profile_name = dialog.show();
if(!profile_name.empty())
{
/*---------------------------------------------*\
| Extension .orp - OpenRgb Profile |
\*---------------------------------------------*/
std::string filename = profile_name;
/*---------------------------------------------*\
| Save the profile |
\*---------------------------------------------*/
OpenRGBProfileEditorDialog editor(filename);
editor.show();
}
}
}
void OpenRGBDialog::on_ButtonRescan_clicked()
{
/*-----------------------------------------------------*\
| Rescan devices in ResourceManager |
\*-----------------------------------------------------*/
ResourceManager::get()->RescanDevices();
}
void OpenRGBDialog::on_ActionSaveProfile_triggered()
{
if(ui->ProfileBox->currentIndex() > 0)
{
SaveProfile();
}
else
{
SaveProfileAs();
}
}
void OpenRGBDialog::on_ActionSaveProfileAs_triggered()
{
SaveProfileAs();
}
void OpenRGBDialog::on_InformationTabBar_currentChanged(int tab_idx)
{
TogglePluginsVisibility(tab_idx, ui->InformationTabBar);
}
void OpenRGBDialog::on_DevicesTabBar_currentChanged(int tab_idx)
{
TogglePluginsVisibility(tab_idx, ui->DevicesTabBar);
}
void OpenRGBDialog::on_MainTabBar_currentChanged(int tab_idx)
{
TogglePluginsVisibility(tab_idx, ui->MainTabBar);
}
void OpenRGBDialog::on_SettingsTabBar_currentChanged(int tab_idx)
{
TogglePluginsVisibility(tab_idx, ui->SettingsTabBar);
}
void OpenRGBDialog::TogglePluginsVisibility(int tab_idx, QTabWidget* tabBar)
{
/*-----------------------------------------------------*\
| Hide all plugins |
\*-----------------------------------------------------*/
for(int i = 0; i < (tabBar->count()); i++)
{
QWidget* tab = tabBar->widget(i);
/*-------------------------------------------------*\
| Dynamic cast is essential in this check to ensure |
| the tab is actually a plugin container |
\*-------------------------------------------------*/
if((i != tab_idx) && (dynamic_cast<OpenRGBPluginContainer*>(tab) != nullptr))
{
((OpenRGBPluginContainer*) tab)->Hide();
ui->MainButtonsFrame->setVisible(true);
}
}
/*-----------------------------------------------------*\
| Show plugin if needed |
\*-----------------------------------------------------*/
QWidget* tab = tabBar->widget(tab_idx);
/*-----------------------------------------------------*\
| Dynamic cast is essential in this check to ensure the |
| tab is actually a plugin container |
\*-----------------------------------------------------*/
if(dynamic_cast<OpenRGBPluginContainer*>(tab) != nullptr)
{
((OpenRGBPluginContainer*) tab)->Show();
ui->MainButtonsFrame->setVisible(false);
}
}
void OpenRGBDialog::AddConsolePage()
{
bool found = false;
int index = (ui->InformationTabBar->tabBar()->count() - 1);
QWidget* tab = ui->InformationTabBar->widget(index);
if(dynamic_cast<OpenRGBConsolePage*>(tab) != nullptr)
{
found = true;
}
if(!found)
{
OpenRGBConsolePage* page = new OpenRGBConsolePage();
ui->InformationTabBar->addTab(page, "");
/*-----------------------------------------------------*\
| Create the tab label |
\*-----------------------------------------------------*/
TabLabel* ConsoleTabLabel = new TabLabel(OpenRGBFont::terminal, (char *)"Log Console", (char *)context, true);
ui->InformationTabBar->tabBar()->setTabButton(ui->InformationTabBar->tabBar()->count() - 1, QTabBar::LeftSide, ConsoleTabLabel);
}
}
void OpenRGBDialog::RemoveConsolePage()
{
int index = (ui->InformationTabBar->tabBar()->count() - 1);
QWidget* tab = ui->InformationTabBar->widget(index);
if(dynamic_cast<OpenRGBConsolePage*>(tab) != nullptr)
{
ui->InformationTabBar->removeTab(index);
delete tab;
}
}
Reference in New Issue View Git Blame Copy Permalink