Martchus
/
syncthingtray
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor settings

This commit is contained in:
Martchus 2016-11-02 20:03:38 +01:00
parent 1abb39ec68
commit 7149f90821
8 changed files with 197 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
tray/application/main.cpp
View File

@ -30,9 +30,10 @@ using namespace Data;
int initSyncthingTray(bool windowed, bool waitForTray)
{
auto &v = Settings::values();
if(windowed) {
if(Settings::launchSynchting()) {
syncthingProcess().startSyncthing(Settings::syncthingCmd());
if(v.launcher.enabled) {
syncthingProcess().startSyncthing(v.launcher.syncthingCmd());
}
auto *trayWidget = new TrayWidget;
trayWidget->setAttribute(Qt::WA_DeleteOnClose);
@ -40,12 +41,12 @@ int initSyncthingTray(bool windowed, bool waitForTray)
} else {
#ifndef QT_NO_SYSTEMTRAYICON
if(QSystemTrayIcon::isSystemTrayAvailable() || waitForTray) {
if(Settings::launchSynchting()) {
syncthingProcess().startSyncthing(Settings::syncthingCmd());
if(v.launcher.enabled) {
syncthingProcess().startSyncthing(v.launcher.syncthingCmd());
}
auto *trayIcon = new TrayIcon;
trayIcon->show();
if(Settings::firstLaunch()) {
if(v.firstLaunch) {
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Information);
msgBox.setText(QCoreApplication::translate("main", "You must configure how to connect to Syncthing when using Syncthing Tray the first time."));
@ -99,7 +100,7 @@ int runApplication(int argc, const char *const *argv)
QObject::connect(&singleInstance, &SingleInstance::newInstance, &runApplication);
Settings::restore();
Settings::qtSettings().apply();
Settings::values().qt.apply();
qtConfigArgs.applySettings(true);
LOAD_QT_TRANSLATIONS;

219
tray/application/settings.cpp
View File

@ -2,158 +2,48 @@
#include <qtutilities/settingsdialog/qtsettings.h>
#include <QString>
#include <QStringBuilder>
#include <QByteArray>
#include <QApplication>
#include <QSettings>
#include <QFrame>
#include <QSslCertificate>
#include <QSslError>
#include <QMessageBox>
#include <QTabWidget>
using namespace std;
using namespace Data;
namespace Settings {
bool &firstLaunch()
QString Launcher::syncthingCmd() const
{
static bool v = false;
return v;
return syncthingPath % QChar(' ') % syncthingArgs;
}
// connection
SyncthingConnectionSettings &primaryConnectionSettings()
Settings &values()
{
static SyncthingConnectionSettings v;
return v;
}
std::vector<SyncthingConnectionSettings> &secondaryConnectionSettings()
{
static vector<SyncthingConnectionSettings> v;
return v;
}
// notifications
bool &notifyOnDisconnect()
{
static bool v = true;
return v;
}
bool &notifyOnInternalErrors()
{
static bool v = true;
return v;
}
bool &notifyOnSyncComplete()
{
static bool v = true;
return v;
}
bool &showSyncthingNotifications()
{
static bool v = true;
return v;
}
// appearance
bool &showTraffic()
{
static bool v = true;
return v;
}
QSize &trayMenuSize()
{
static QSize v(450, 400);
return v;
}
int &frameStyle()
{
static int v = QFrame::StyledPanel | QFrame::Sunken;
return v;
}
int &tabPosition()
{
static int v = QTabWidget::South;
return v;
}
// autostart/launcher
bool &launchSynchting()
{
static bool v = false;
return v;
}
QString &syncthingPath()
{
#ifdef PLATFORM_WINDOWS
static QString v(QStringLiteral("syncthing.exe"));
#else
static QString v(QStringLiteral("syncthing"));
#endif
return v;
}
QString &syncthingArgs()
{
static QString v;
return v;
}
QString syncthingCmd()
{
return syncthingPath() % QChar(' ') % syncthingArgs();
}
// web view
#if defined(SYNCTHINGTRAY_USE_WEBENGINE) || defined(SYNCTHINGTRAY_USE_WEBKIT)
bool &webViewDisabled()
{
static bool v = false;
return v;
}
double &webViewZoomFactor()
{
static double v = 1.0;
return v;
}
QByteArray &webViewGeometry()
{
static QByteArray v;
return v;
}
bool &webViewKeepRunning()
{
static bool v = true;
return v;
}
#endif
// Qt settings
Dialogs::QtSettings &qtSettings()
{
static Dialogs::QtSettings v;
return v;
static Settings settings;
return settings;
}
void restore()
{
QSettings settings(QSettings::IniFormat, QSettings::UserScope, QApplication::organizationName(), QApplication::applicationName());
Settings &v = values();
settings.beginGroup(QStringLiteral("tray"));
const int connectionCount = settings.beginReadArray(QStringLiteral("connections"));
auto &primaryConnectionSettings = v.connection.primary;
if(connectionCount > 0) {
secondaryConnectionSettings().clear();
secondaryConnectionSettings().reserve(static_cast<size_t>(connectionCount));
auto &secondaryConnectionSettings = v.connection.secondary;
secondaryConnectionSettings.clear();
secondaryConnectionSettings.reserve(static_cast<size_t>(connectionCount));
for(int i = 0; i < connectionCount; ++i) {
SyncthingConnectionSettings *connectionSettings;
if(i == 0) {
connectionSettings = &primaryConnectionSettings();
connectionSettings = &primaryConnectionSettings;
} else {
secondaryConnectionSettings().emplace_back();
connectionSettings = &secondaryConnectionSettings().back();
secondaryConnectionSettings.emplace_back();
connectionSettings = &secondaryConnectionSettings.back();
}
settings.setArrayIndex(i);
connectionSettings->label = settings.value(QStringLiteral("label")).toString();
@ -174,48 +64,55 @@ void restore()
}
}
} else {
firstLaunch() = true;
primaryConnectionSettings().label = QStringLiteral("Primary instance");
v.firstLaunch = true;
primaryConnectionSettings.label = QStringLiteral("Primary instance");
}
settings.endArray();
notifyOnDisconnect() = settings.value(QStringLiteral("notifyOnDisconnect"), notifyOnDisconnect()).toBool();
notifyOnInternalErrors() = settings.value(QStringLiteral("notifyOnErrors"), notifyOnInternalErrors()).toBool();
notifyOnSyncComplete() = settings.value(QStringLiteral("notifyOnSyncComplete"), notifyOnSyncComplete()).toBool();
showSyncthingNotifications() = settings.value(QStringLiteral("showSyncthingNotifications"), showSyncthingNotifications()).toBool();
showTraffic() = settings.value(QStringLiteral("showTraffic"), showTraffic()).toBool();
trayMenuSize() = settings.value(QStringLiteral("trayMenuSize"), trayMenuSize()).toSize();
frameStyle() = settings.value(QStringLiteral("frameStyle"), frameStyle()).toInt();
tabPosition() = settings.value(QStringLiteral("tabPos"), tabPosition()).toInt();
auto &notifyOn = v.notifyOn;
notifyOn.disconnect = settings.value(QStringLiteral("notifyOnDisconnect"), notifyOn.disconnect).toBool();
notifyOn.internalErrors = settings.value(QStringLiteral("notifyOnErrors"), notifyOn.internalErrors).toBool();
notifyOn.syncComplete = settings.value(QStringLiteral("notifyOnSyncComplete"), notifyOn.syncComplete).toBool();
notifyOn.syncthingErrors = settings.value(QStringLiteral("showSyncthingNotifications"), notifyOn.syncthingErrors).toBool();
auto &appearance = v.appearance;
appearance.showTraffic = settings.value(QStringLiteral("showTraffic"), appearance.showTraffic).toBool();
appearance.trayMenuSize = settings.value(QStringLiteral("trayMenuSize"), appearance.trayMenuSize).toSize();
appearance.frameStyle = settings.value(QStringLiteral("frameStyle"), appearance.frameStyle).toInt();
appearance.tabPosition = settings.value(QStringLiteral("tabPos"), appearance.tabPosition).toInt();
settings.endGroup();
settings.beginGroup(QStringLiteral("startup"));
launchSynchting() = settings.value(QStringLiteral("launchSynchting"), false).toBool();
syncthingPath() = settings.value(QStringLiteral("syncthingPath"), syncthingPath()).toString();
syncthingArgs() = settings.value(QStringLiteral("syncthingArgs"), syncthingArgs()).toString();
auto &launcher = v.launcher;
launcher.enabled = settings.value(QStringLiteral("launchSynchting"), launcher.enabled).toBool();
launcher.syncthingPath = settings.value(QStringLiteral("syncthingPath"), launcher.syncthingPath).toString();
launcher.syncthingArgs = settings.value(QStringLiteral("syncthingArgs"), launcher.syncthingArgs).toString();
settings.endGroup();
#if defined(SYNCTHINGTRAY_USE_WEBENGINE) || defined(SYNCTHINGTRAY_USE_WEBKIT)
settings.beginGroup(QStringLiteral("webview"));
webViewDisabled() = settings.value(QStringLiteral("isabled"), false).toBool();
webViewZoomFactor() = settings.value(QStringLiteral("zoomFactor"), 1.0).toDouble();
webViewGeometry() = settings.value(QStringLiteral("geometry")).toByteArray();
webViewKeepRunning() = settings.value(QStringLiteral("keepRunning"), true).toBool();
auto &webView = v.webView;
webView.disabled = settings.value(QStringLiteral("isabled"), webView.disabled).toBool();
webView.zoomFactor = settings.value(QStringLiteral("zoomFactor"), webView.zoomFactor).toDouble();
webView.geometry = settings.value(QStringLiteral("geometry")).toByteArray();
webView.keepRunning = settings.value(QStringLiteral("keepRunning"), webView.keepRunning).toBool();
settings.endGroup();
#endif
qtSettings().restore(settings);
v.qt.restore(settings);
}
void save()
{
QSettings settings(QSettings::IniFormat, QSettings::UserScope, QApplication::organizationName(), QApplication::applicationName());
const Settings &v = values();
settings.beginGroup(QStringLiteral("tray"));
const int connectionCount = static_cast<int>(1 + secondaryConnectionSettings().size());
const auto &primaryConnectionSettings = v.connection.primary;
const auto &secondaryConnectionSettings = v.connection.secondary;
const int connectionCount = static_cast<int>(1 + secondaryConnectionSettings.size());
settings.beginWriteArray(QStringLiteral("connections"), connectionCount);
for(int i = 0; i < connectionCount; ++i) {
const SyncthingConnectionSettings *connectionSettings = (i == 0 ? &primaryConnectionSettings() : &secondaryConnectionSettings()[static_cast<size_t>(i - 1)]);
const SyncthingConnectionSettings *connectionSettings = (i == 0 ? &primaryConnectionSettings : &secondaryConnectionSettings[static_cast<size_t>(i - 1)]);
settings.setArrayIndex(i);
settings.setValue(QStringLiteral("label"), connectionSettings->label);
settings.setValue(QStringLiteral("syncthingUrl"), connectionSettings->syncthingUrl);
@ -230,32 +127,36 @@ void save()
}
settings.endArray();
settings.setValue(QStringLiteral("notifyOnDisconnect"), notifyOnDisconnect());
settings.setValue(QStringLiteral("notifyOnErrors"), notifyOnInternalErrors());
settings.setValue(QStringLiteral("notifyOnSyncComplete"), notifyOnSyncComplete());
settings.setValue(QStringLiteral("showSyncthingNotifications"), showSyncthingNotifications());
settings.setValue(QStringLiteral("showTraffic"), showTraffic());
settings.setValue(QStringLiteral("trayMenuSize"), trayMenuSize());
settings.setValue(QStringLiteral("frameStyle"), frameStyle());
settings.setValue(QStringLiteral("tabPos"), tabPosition());
const auto &notifyOn = v.notifyOn;
settings.setValue(QStringLiteral("notifyOnDisconnect"), notifyOn.disconnect);
settings.setValue(QStringLiteral("notifyOnErrors"), notifyOn.internalErrors);
settings.setValue(QStringLiteral("notifyOnSyncComplete"), notifyOn.syncComplete);
settings.setValue(QStringLiteral("showSyncthingNotifications"), notifyOn.syncthingErrors);
const auto &appearance = v.appearance;
settings.setValue(QStringLiteral("showTraffic"), appearance.showTraffic);
settings.setValue(QStringLiteral("trayMenuSize"), appearance.trayMenuSize);
settings.setValue(QStringLiteral("frameStyle"), appearance.frameStyle);
settings.setValue(QStringLiteral("tabPos"), appearance.tabPosition);
settings.endGroup();
settings.beginGroup(QStringLiteral("startup"));
settings.setValue(QStringLiteral("launchSynchting"), launchSynchting());
settings.setValue(QStringLiteral("syncthingPath"), syncthingPath());
settings.setValue(QStringLiteral("syncthingArgs"), syncthingArgs());
const auto &launcher = v.launcher;
settings.setValue(QStringLiteral("launchSynchting"), launcher.enabled);
settings.setValue(QStringLiteral("syncthingPath"), launcher.syncthingPath);
settings.setValue(QStringLiteral("syncthingArgs"), launcher.syncthingArgs);
settings.endGroup();
#if defined(SYNCTHINGTRAY_USE_WEBENGINE) || defined(SYNCTHINGTRAY_USE_WEBKIT)
settings.beginGroup(QStringLiteral("webview"));
settings.setValue(QStringLiteral("disabled"), webViewDisabled());
settings.setValue(QStringLiteral("zoomFactor"), webViewZoomFactor());
settings.setValue(QStringLiteral("geometry"), webViewGeometry());
settings.setValue(QStringLiteral("keepRunning"), webViewKeepRunning());
const auto &webView = v.webView;
settings.setValue(QStringLiteral("disabled"), webView.disabled);
settings.setValue(QStringLiteral("zoomFactor"), webView.zoomFactor);
settings.setValue(QStringLiteral("geometry"), webView.geometry);
settings.setValue(QStringLiteral("keepRunning"), webView.keepRunning);
settings.endGroup();
#endif
qtSettings().save(settings);
v.qt.save(settings);
}
}

85
tray/application/settings.h
View File

@ -3,15 +3,18 @@
#include "../../connector/syncthingconnectionsettings.h"
#include <qtutilities/settingsdialog/qtsettings.h>
#include <c++utilities/conversion/types.h>
#include <QString>
#include <QByteArray>
#include <QSize>
#include <QFrame>
#include <QTabWidget>
#include <vector>
QT_FORWARD_DECLARE_CLASS(QSize)
namespace Media {
enum class TagUsage;
enum class ElementPosition;
@ -23,41 +26,65 @@ class QtSettings;
namespace Settings {
bool &firstLaunch();
struct Connection
{
Data::SyncthingConnectionSettings primary;
std::vector<Data::SyncthingConnectionSettings> secondary;
};
// connection
Data::SyncthingConnectionSettings &primaryConnectionSettings();
std::vector<Data::SyncthingConnectionSettings> &secondaryConnectionSettings();
struct NotifyOn
{
bool disconnect = true;
bool internalErrors = true;
bool syncComplete = true;
bool syncthingErrors = true;
};
// notifications
bool &notifyOnDisconnect();
bool &notifyOnInternalErrors();
bool &notifyOnSyncComplete();
bool &showSyncthingNotifications();
struct Appearance
{
bool showTraffic = true;
QSize trayMenuSize = QSize(450, 400);
int frameStyle = QFrame::StyledPanel | QFrame::Sunken;
int tabPosition = QTabWidget::South;
};
// apprearance
bool &showTraffic();
QSize &trayMenuSize();
int &frameStyle();
int &tabPosition();
struct Launcher
{
bool enabled = false;
QString syncthingPath =
#ifdef PLATFORM_WINDOWS
QStringLiteral("syncthing.exe");
#else
QStringLiteral("syncthing");
#endif
QString syncthingArgs;
QString syncthingCmd() const;
};
// autostart/launcher
bool &launchSynchting();
QString &syncthingPath();
QString &syncthingArgs();
QString syncthingCmd();
// web view
#if defined(SYNCTHINGTRAY_USE_WEBENGINE) || defined(SYNCTHINGTRAY_USE_WEBKIT)
bool &webViewDisabled();
double &webViewZoomFactor();
QByteArray &webViewGeometry();
bool &webViewKeepRunning();
struct WebView
{
bool disabled = false;
double zoomFactor = 1.0;
QByteArray geometry;
bool keepRunning = true;
};
#endif
// Qt settings
Dialogs::QtSettings &qtSettings();
struct Settings
{
bool firstLaunch = false;
Connection connection;
NotifyOn notifyOn;
Appearance appearance;
Launcher launcher;
#if defined(SYNCTHINGTRAY_USE_WEBENGINE) || defined(SYNCTHINGTRAY_USE_WEBKIT)
WebView webView;
#endif
Dialogs::QtSettings qt;
};
Settings &values();
void restore();
void save();

82
tray/gui/settingsdialog.cpp
View File

@ -189,8 +189,8 @@ bool ConnectionOptionPage::apply()
bool ok = true;
if(hasBeenShown()) {
ok = cacheCurrentSettings(true);
Settings::primaryConnectionSettings() = m_primarySettings;
Settings::secondaryConnectionSettings() = m_secondarySettings;
values().connection.primary = m_primarySettings;
values().connection.secondary = m_secondarySettings;
}
return ok;
}
@ -198,8 +198,8 @@ bool ConnectionOptionPage::apply()
void ConnectionOptionPage::reset()
{
if(hasBeenShown()) {
m_primarySettings = primaryConnectionSettings();
m_secondarySettings = secondaryConnectionSettings();
m_primarySettings = values().connection.primary;
m_secondarySettings = values().connection.secondary;
m_currentIndex = -1;
QStringList itemTexts;
@ -233,10 +233,11 @@ NotificationsOptionPage::~NotificationsOptionPage()
bool NotificationsOptionPage::apply()
{
if(hasBeenShown()) {
notifyOnDisconnect() = ui()->notifyOnDisconnectCheckBox->isChecked();
notifyOnInternalErrors() = ui()->notifyOnErrorsCheckBox->isChecked();
notifyOnSyncComplete() = ui()->notifyOnSyncCompleteCheckBox->isChecked();
showSyncthingNotifications() = ui()->showSyncthingNotificationsCheckBox->isChecked();
auto &notifyOn = values().notifyOn;
notifyOn.disconnect = ui()->notifyOnDisconnectCheckBox->isChecked();
notifyOn.internalErrors = ui()->notifyOnErrorsCheckBox->isChecked();
notifyOn.syncComplete = ui()->notifyOnSyncCompleteCheckBox->isChecked();
notifyOn.syncthingErrors = ui()->showSyncthingNotificationsCheckBox->isChecked();
}
return true;
}
@ -244,10 +245,11 @@ bool NotificationsOptionPage::apply()
void NotificationsOptionPage::reset()
{
if(hasBeenShown()) {
ui()->notifyOnDisconnectCheckBox->setChecked(notifyOnDisconnect());
ui()->notifyOnErrorsCheckBox->setChecked(notifyOnInternalErrors());
ui()->notifyOnSyncCompleteCheckBox->setChecked(notifyOnSyncComplete());
ui()->showSyncthingNotificationsCheckBox->setChecked(showSyncthingNotifications());
const auto &notifyOn = values().notifyOn;
ui()->notifyOnDisconnectCheckBox->setChecked(notifyOn.disconnect);
ui()->notifyOnErrorsCheckBox->setChecked(notifyOn.internalErrors);
ui()->notifyOnSyncCompleteCheckBox->setChecked(notifyOn.syncComplete);
ui()->showSyncthingNotificationsCheckBox->setChecked(notifyOn.syncthingErrors);
}
}
@ -262,9 +264,10 @@ AppearanceOptionPage::~AppearanceOptionPage()
bool AppearanceOptionPage::apply()
{
if(hasBeenShown()) {
trayMenuSize().setWidth(ui()->widthSpinBox->value());
trayMenuSize().setHeight(ui()->heightSpinBox->value());
showTraffic() = ui()->showTrafficCheckBox->isChecked();
auto &settings = values().appearance;
settings.trayMenuSize.setWidth(ui()->widthSpinBox->value());
settings.trayMenuSize.setHeight(ui()->heightSpinBox->value());
settings.showTraffic = ui()->showTrafficCheckBox->isChecked();
int style;
switch(ui()->frameShapeComboBox->currentIndex()) {
case 0: style = QFrame::NoFrame; break;
@ -277,8 +280,8 @@ bool AppearanceOptionPage::apply()
case 1: style |= QFrame::Raised; break;
default: style |= QFrame::Sunken;
}
frameStyle() = style;
tabPosition() = ui()->tabPosComboBox->currentIndex();
settings.frameStyle = style;
settings.tabPosition = ui()->tabPosComboBox->currentIndex();
}
return true;
}
@ -286,24 +289,25 @@ bool AppearanceOptionPage::apply()
void AppearanceOptionPage::reset()
{
if(hasBeenShown()) {
ui()->widthSpinBox->setValue(trayMenuSize().width());
ui()->heightSpinBox->setValue(trayMenuSize().height());
ui()->showTrafficCheckBox->setChecked(showTraffic());
const auto &settings = values().appearance;
ui()->widthSpinBox->setValue(settings.trayMenuSize.width());
ui()->heightSpinBox->setValue(settings.trayMenuSize.height());
ui()->showTrafficCheckBox->setChecked(settings.showTraffic);
int index;
switch(frameStyle() & QFrame::Shape_Mask) {
switch(settings.frameStyle & QFrame::Shape_Mask) {
case QFrame::NoFrame: index = 0; break;
case QFrame::Box: index = 1; break;
case QFrame::Panel: index = 2; break;
default: index = 3;
}
ui()->frameShapeComboBox->setCurrentIndex(index);
switch(frameStyle() & QFrame::Shadow_Mask) {
switch(settings.frameStyle & QFrame::Shadow_Mask) {
case QFrame::Plain: index = 0; break;
case QFrame::Raised: index = 1; break;
default: index = 2;
}
ui()->frameShadowComboBox->setCurrentIndex(index);
ui()->tabPosComboBox->setCurrentIndex(tabPosition());
ui()->tabPosComboBox->setCurrentIndex(settings.tabPosition);
}
}
@ -456,9 +460,10 @@ QWidget *LauncherOptionPage::setupWidget()
bool LauncherOptionPage::apply()
{
if(hasBeenShown()) {
Settings::launchSynchting() = ui()->enabledCheckBox->isChecked(),
Settings::syncthingPath() = ui()->syncthingPathSelection->lineEdit()->text(),
Settings::syncthingArgs() = ui()->argumentsLineEdit->text();
auto &settings = values().launcher;
settings.enabled = ui()->enabledCheckBox->isChecked();
settings.syncthingPath = ui()->syncthingPathSelection->lineEdit()->text();
settings.syncthingArgs = ui()->argumentsLineEdit->text();
}
return true;
}
@ -466,9 +471,10 @@ bool LauncherOptionPage::apply()
void LauncherOptionPage::reset()
{
if(hasBeenShown()) {
ui()->enabledCheckBox->setChecked(Settings::launchSynchting());
ui()->syncthingPathSelection->lineEdit()->setText(Settings::syncthingPath());
ui()->argumentsLineEdit->setText(Settings::syncthingArgs());
const auto &settings = values().launcher;
ui()->enabledCheckBox->setChecked(settings.enabled);
ui()->syncthingPathSelection->lineEdit()->setText(settings.syncthingPath);
ui()->argumentsLineEdit->setText(settings.syncthingArgs);
}
}
@ -510,7 +516,7 @@ void LauncherOptionPage::launch()
ui()->launchNowPushButton->hide();
ui()->stopPushButton->show();
m_kill = false;
syncthingProcess().startSyncthing(Settings::syncthingCmd());
syncthingProcess().startSyncthing(values().launcher.syncthingCmd());
}
}
}
@ -552,9 +558,10 @@ bool WebViewOptionPage::apply()
{
#ifndef SYNCTHINGTRAY_NO_WEBVIEW
if(hasBeenShown()) {
webViewDisabled() = ui()->disableCheckBox->isChecked();
webViewZoomFactor() = ui()->zoomDoubleSpinBox->value();
webViewKeepRunning() = ui()->keepRunningCheckBox->isChecked();
auto &webView = values().webView;
webView.disabled = ui()->disableCheckBox->isChecked();
webView.zoomFactor = ui()->zoomDoubleSpinBox->value();
webView.keepRunning = ui()->keepRunningCheckBox->isChecked();
}
#endif
return true;
@ -564,9 +571,10 @@ void WebViewOptionPage::reset()
{
#ifndef SYNCTHINGTRAY_NO_WEBVIEW
if(hasBeenShown()) {
ui()->disableCheckBox->setChecked(webViewDisabled());
ui()->zoomDoubleSpinBox->setValue(webViewZoomFactor());
ui()->keepRunningCheckBox->setChecked(webViewKeepRunning());
const auto &webView = values().webView;
ui()->disableCheckBox->setChecked(webView.disabled);
ui()->zoomDoubleSpinBox->setValue(webView.zoomFactor);
ui()->keepRunningCheckBox->setChecked(webView.keepRunning);
}
#endif
}
@ -596,7 +604,7 @@ SettingsDialog::SettingsDialog(Data::SyncthingConnection *connection, QWidget *p
category->setIcon(QIcon::fromTheme(QStringLiteral("system-run"), QIcon(QStringLiteral(":/icons/hicolor/scalable/apps/system-run.svg"))));
categories << category;
categories << Settings::qtSettings().category();
categories << values().qt.category();
categoryModel()->setCategories(categories);

9
tray/gui/trayicon.cpp
View File

@ -85,14 +85,15 @@ void TrayIcon::handleMessageClicked()
void TrayIcon::showInternalError(const QString &errorMsg)
{
if(Settings::notifyOnInternalErrors()) {
if(Settings::values().notifyOn.internalErrors) {
showMessage(tr("Error"), errorMsg, QSystemTrayIcon::Critical);
}
}
void TrayIcon::showSyncthingNotification(ChronoUtilities::DateTime when, const QString &message)
{
if(Settings::showSyncthingNotifications()) {
Q_UNUSED(when)
if(Settings::values().notifyOn.syncthingErrors) {
showMessage(tr("Syncthing notification - click to dismiss"), message, QSystemTrayIcon::Warning);
}
}
@ -104,7 +105,7 @@ void TrayIcon::updateStatusIconAndText(SyncthingStatus status)
case SyncthingStatus::Disconnected:
setIcon(m_statusIconDisconnected);
setToolTip(tr("Not connected to Syncthing"));
if(Settings::notifyOnDisconnect()) {
if(Settings::values().notifyOn.disconnect) {
showMessage(QCoreApplication::applicationName(), tr("Disconnected from Syncthing"), QSystemTrayIcon::Warning);
}
break;
@ -153,7 +154,7 @@ void TrayIcon::updateStatusIconAndText(SyncthingStatus status)
case SyncthingStatus::Synchronizing:
break;
default:
if(m_status == SyncthingStatus::Synchronizing && Settings::notifyOnSyncComplete()) {
if(m_status == SyncthingStatus::Synchronizing && Settings::values().notifyOn.syncComplete) {
showMessage(QCoreApplication::applicationName(), tr("Synchronization complete"), QSystemTrayIcon::Information);
}
}

2
tray/gui/traymenu.cpp
View File

@ -27,7 +27,7 @@ TrayMenu::TrayMenu(QWidget *parent) :
QSize TrayMenu::sizeHint() const
{
return Settings::trayMenuSize();
return Settings::values().appearance.trayMenuSize;
}
}

33
tray/gui/traywidget.cpp
View File

@ -99,7 +99,7 @@ TrayWidget::TrayWidget(TrayMenu *parent) :
// setup connection menu
m_connectionsActionGroup = new QActionGroup(m_connectionsMenu = new QMenu(tr("Connection"), this));
m_connectionsMenu->setIcon(QIcon::fromTheme(QStringLiteral("network-connect"), QIcon(QStringLiteral(":/icons/hicolor/scalable/actions/network-connect.svg"))));
m_ui->connectionsPushButton->setText(Settings::primaryConnectionSettings().label);
m_ui->connectionsPushButton->setText(Settings::values().connection.primary.label);
m_ui->connectionsPushButton->setMenu(m_connectionsMenu);
// apply settings, this also establishes the connection to Syncthing
@ -166,7 +166,7 @@ void TrayWidget::showAboutDialog()
void TrayWidget::showWebUi()
{
#ifndef SYNCTHINGTRAY_NO_WEBVIEW
if(Settings::webViewDisabled()) {
if(Settings::values().webView.disabled) {
#endif
QDesktopServices::openUrl(m_connection.syncthingUrl());
#ifndef SYNCTHINGTRAY_NO_WEBVIEW
@ -304,11 +304,14 @@ void TrayWidget::applySettings()
for(TrayWidget *instance : m_instances) {
// update connections menu
int connectionIndex = 0;
const int connectionCount = static_cast<int>(1 + Settings::secondaryConnectionSettings().size());
auto &settings = Settings::values();
auto &primaryConnectionSettings = settings.connection.primary;
auto &secondaryConnectionSettings = settings.connection.secondary;
const int connectionCount = static_cast<int>(1 + secondaryConnectionSettings.size());
const QList<QAction *> connectionActions = instance->m_connectionsActionGroup->actions();
instance->m_selectedConnection = nullptr;
for(; connectionIndex < connectionCount; ++connectionIndex) {
SyncthingConnectionSettings &connectionSettings = (connectionIndex == 0 ? Settings::primaryConnectionSettings() : Settings::secondaryConnectionSettings()[static_cast<size_t>(connectionIndex - 1)]);
SyncthingConnectionSettings &connectionSettings = (connectionIndex == 0 ? primaryConnectionSettings : secondaryConnectionSettings[static_cast<size_t>(connectionIndex - 1)]);
if(connectionIndex < connectionActions.size()) {
QAction *action = connectionActions.at(connectionIndex);
action->setText(connectionSettings.label);
@ -325,7 +328,7 @@ void TrayWidget::applySettings()
delete connectionActions.at(connectionIndex);
}
if(!instance->m_selectedConnection) {
instance->m_selectedConnection = &Settings::primaryConnectionSettings();
instance->m_selectedConnection = &primaryConnectionSettings;
instance->m_connectionsMenu->actions().at(0)->setChecked(true);
}
instance->m_ui->connectionsPushButton->setText(instance->m_selectedConnection->label);
@ -340,20 +343,20 @@ void TrayWidget::applySettings()
#endif
// update visual appearance
instance->m_ui->trafficFormWidget->setVisible(Settings::showTraffic());
instance->m_ui->trafficIconLabel->setVisible(Settings::showTraffic());
if(Settings::showTraffic()) {
instance->m_ui->trafficFormWidget->setVisible(settings.appearance.showTraffic);
instance->m_ui->trafficIconLabel->setVisible(settings.appearance.showTraffic);
if(settings.appearance.showTraffic) {
instance->updateTraffic();
}
instance->m_ui->infoFrame->setFrameStyle(Settings::frameStyle());
instance->m_ui->buttonsFrame->setFrameStyle(Settings::frameStyle());
instance->m_ui->infoFrame->setFrameStyle(settings.appearance.frameStyle);
instance->m_ui->buttonsFrame->setFrameStyle(settings.appearance.frameStyle);
if(QApplication::style() && !QApplication::style()->objectName().compare(QLatin1String("adwaita"), Qt::CaseInsensitive)) {
instance->m_cornerFrame->setFrameStyle(QFrame::NoFrame);
} else {
instance->m_cornerFrame->setFrameStyle(Settings::frameStyle());
instance->m_cornerFrame->setFrameStyle(settings.appearance.frameStyle);
}
if(Settings::tabPosition() >= QTabWidget::North && Settings::tabPosition() <= QTabWidget::East) {
instance->m_ui->tabWidget->setTabPosition(static_cast<QTabWidget::TabPosition>(Settings::tabPosition()));
if(settings.appearance.tabPosition >= QTabWidget::North && settings.appearance.tabPosition <= QTabWidget::East) {
instance->m_ui->tabWidget->setTabPosition(static_cast<QTabWidget::TabPosition>(settings.appearance.tabPosition));
}
}
}
@ -457,8 +460,8 @@ void TrayWidget::handleConnectionSelected(QAction *connectionAction)
int index = m_connectionsMenu->actions().indexOf(connectionAction);
if(index >= 0) {
m_selectedConnection = (index == 0)
? &Settings::primaryConnectionSettings()
: &Settings::secondaryConnectionSettings()[static_cast<size_t>(index - 1)];
? &Settings::values().connection.primary
: &Settings::values().connection.secondary[static_cast<size_t>(index - 1)];
m_ui->connectionsPushButton->setText(m_selectedConnection->label);
m_connection.reconnect(*m_selectedConnection);
#ifndef SYNCTHINGTRAY_NO_WEBVIEW

10
tray/gui/webviewdialog.cpp
View File

@ -30,29 +30,29 @@ WebViewDialog::WebViewDialog(QWidget *parent) :
m_view->setPage(new WebPage(this, m_view));
connect(m_view, &WEB_VIEW_PROVIDER::titleChanged, this, &WebViewDialog::setWindowTitle);
if(Settings::webViewGeometry().isEmpty()) {
if(Settings::values().webView.geometry.isEmpty()) {
resize(1200, 800);
centerWidget(this);
} else {
restoreGeometry(Settings::webViewGeometry());
restoreGeometry(Settings::values().webView.geometry);
}
}
QtGui::WebViewDialog::~WebViewDialog()
{
Settings::webViewGeometry() = saveGeometry();
Settings::values().webView.geometry = saveGeometry();
}
void QtGui::WebViewDialog::applySettings(const Data::SyncthingConnectionSettings &connectionSettings)
{
m_settings = connectionSettings;
m_view->setUrl(connectionSettings.syncthingUrl);
m_view->setZoomFactor(Settings::webViewZoomFactor());
m_view->setZoomFactor(Settings::values().webView.zoomFactor);
}
void QtGui::WebViewDialog::closeEvent(QCloseEvent *event)
{
if(!Settings::webViewKeepRunning()) {
if(!Settings::values().webView.keepRunning) {
deleteLater();
}
event->accept();