699 lines
21 KiB
C++
699 lines
21 KiB
C++
/*
|
|
* This file Copyright (C) 2009-2015 Mnemosyne LLC
|
|
*
|
|
* It may be used under the GNU GPL versions 2 or 3
|
|
* or any future license endorsed by Mnemosyne LLC.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
#ifdef _WIN32
|
|
#include <winsock2.h> // FD_SETSIZE
|
|
#else
|
|
#include <sys/select.h> // FD_SETSIZE
|
|
#endif
|
|
|
|
#include <cassert>
|
|
|
|
#include <QCheckBox>
|
|
#include <QComboBox>
|
|
#include <QCoreApplication>
|
|
#include <QDialogButtonBox>
|
|
#include <QDoubleSpinBox>
|
|
#include <QFileIconProvider>
|
|
#include <QFileInfo>
|
|
#include <QHBoxLayout>
|
|
#include <QIcon>
|
|
#include <QLabel>
|
|
#include <QLineEdit>
|
|
#include <QList>
|
|
#include <QMessageBox>
|
|
#include <QPushButton>
|
|
#include <QSpinBox>
|
|
#include <QStyle>
|
|
#include <QTabWidget>
|
|
#include <QTime>
|
|
#include <QTimeEdit>
|
|
#include <QTimer>
|
|
#include <QVBoxLayout>
|
|
|
|
#include "ColumnResizer.h"
|
|
#include "FreeSpaceLabel.h"
|
|
#include "Formatter.h"
|
|
#include "Prefs.h"
|
|
#include "PrefsDialog.h"
|
|
#include "Session.h"
|
|
#include "Utils.h"
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
namespace
|
|
{
|
|
const char * PREF_KEY ("pref-key");
|
|
|
|
void
|
|
setPrefKey (QObject * object, int key)
|
|
{
|
|
object->setProperty (PREF_KEY, key);
|
|
}
|
|
|
|
int
|
|
getPrefKey (const QObject * object)
|
|
{
|
|
return object->property (PREF_KEY).toInt ();
|
|
}
|
|
|
|
int
|
|
qtDayToTrDay (int day)
|
|
{
|
|
switch (day)
|
|
{
|
|
case Qt::Monday:
|
|
return TR_SCHED_MON;
|
|
case Qt::Tuesday:
|
|
return TR_SCHED_TUES;
|
|
case Qt::Wednesday:
|
|
return TR_SCHED_WED;
|
|
case Qt::Thursday:
|
|
return TR_SCHED_THURS;
|
|
case Qt::Friday:
|
|
return TR_SCHED_FRI;
|
|
case Qt::Saturday:
|
|
return TR_SCHED_SAT;
|
|
case Qt::Sunday:
|
|
return TR_SCHED_SUN;
|
|
default:
|
|
assert (0 && "Invalid day of week");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
QString
|
|
qtDayName (int day)
|
|
{
|
|
switch (day)
|
|
{
|
|
case Qt::Monday:
|
|
return PrefsDialog::tr ("Monday");
|
|
case Qt::Tuesday:
|
|
return PrefsDialog::tr ("Tuesday");
|
|
case Qt::Wednesday:
|
|
return PrefsDialog::tr ("Wednesday");
|
|
case Qt::Thursday:
|
|
return PrefsDialog::tr ("Thursday");
|
|
case Qt::Friday:
|
|
return PrefsDialog::tr ("Friday");
|
|
case Qt::Saturday:
|
|
return PrefsDialog::tr ("Saturday");
|
|
case Qt::Sunday:
|
|
return PrefsDialog::tr ("Sunday");
|
|
default:
|
|
assert (0 && "Invalid day of week");
|
|
return QString ();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
PrefsDialog::updateWidgetValue (QWidget * widget, int prefKey)
|
|
{
|
|
if (auto w = qobject_cast<QCheckBox*> (widget))
|
|
w->setChecked (myPrefs.getBool (prefKey));
|
|
else if (auto w = qobject_cast<QSpinBox*> (widget))
|
|
w->setValue (myPrefs.getInt (prefKey));
|
|
else if (auto w = qobject_cast<QDoubleSpinBox*> (widget))
|
|
w->setValue (myPrefs.getDouble (prefKey));
|
|
else if (auto w = qobject_cast<QTimeEdit*> (widget))
|
|
w->setTime (QTime (0, 0).addSecs (myPrefs.getInt(prefKey) * 60));
|
|
else if (auto w = qobject_cast<QLineEdit*> (widget))
|
|
w->setText (myPrefs.getString (prefKey));
|
|
else if (auto w = qobject_cast<PathButton*> (widget))
|
|
w->setPath (myPrefs.getString (prefKey));
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
PrefsDialog::linkWidgetToPref (QWidget * widget, int prefKey)
|
|
{
|
|
setPrefKey (widget, prefKey);
|
|
updateWidgetValue (widget, prefKey);
|
|
myWidgets.insert (prefKey, widget);
|
|
|
|
if (widget->inherits ("QCheckBox"))
|
|
connect (widget, SIGNAL (toggled (bool)), SLOT (checkBoxToggled (bool)));
|
|
else if (widget->inherits ("QTimeEdit"))
|
|
connect (widget, SIGNAL (editingFinished ()), SLOT (timeEditingFinished ()));
|
|
else if (widget->inherits ("QLineEdit"))
|
|
connect (widget, SIGNAL (editingFinished ()), SLOT (lineEditingFinished ()));
|
|
else if (widget->inherits ("PathButton"))
|
|
connect (widget, SIGNAL (pathChanged (QString)), SLOT (pathChanged (QString)));
|
|
else if (widget->inherits ("QAbstractSpinBox"))
|
|
connect (widget, SIGNAL (editingFinished ()), SLOT (spinBoxEditingFinished ()));
|
|
}
|
|
|
|
void
|
|
PrefsDialog::checkBoxToggled (bool checked)
|
|
{
|
|
if (auto c = qobject_cast<QCheckBox*> (sender ()))
|
|
setPref (getPrefKey (c), checked);
|
|
}
|
|
|
|
void
|
|
PrefsDialog::spinBoxEditingFinished ()
|
|
{
|
|
const QObject * spin = sender();
|
|
const int key = getPrefKey (spin);
|
|
|
|
if (auto e = qobject_cast<const QDoubleSpinBox*> (spin))
|
|
setPref (key, e->value ());
|
|
else if (auto e = qobject_cast<const QSpinBox*> (spin))
|
|
setPref (key, e->value ());
|
|
}
|
|
|
|
void
|
|
PrefsDialog::timeEditingFinished ()
|
|
{
|
|
if (auto e = qobject_cast<const QTimeEdit*> (sender ()))
|
|
setPref(getPrefKey (e), QTime (0, 0).secsTo (e->time()) / 60);
|
|
}
|
|
|
|
void
|
|
PrefsDialog::lineEditingFinished ()
|
|
{
|
|
if (auto e = qobject_cast<const QLineEdit*> (sender ()))
|
|
{
|
|
if (e->isModified ())
|
|
setPref (getPrefKey (e), e->text());
|
|
}
|
|
}
|
|
|
|
void
|
|
PrefsDialog::pathChanged (const QString& path)
|
|
{
|
|
if (auto b = qobject_cast<const PathButton*> (sender ()))
|
|
setPref(getPrefKey (b), path);
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
PrefsDialog::initRemoteTab ()
|
|
{
|
|
linkWidgetToPref (ui.enableRpcCheck, Prefs::RPC_ENABLED);
|
|
linkWidgetToPref (ui.rpcPortSpin, Prefs::RPC_PORT);
|
|
linkWidgetToPref (ui.requireRpcAuthCheck, Prefs::RPC_AUTH_REQUIRED);
|
|
linkWidgetToPref (ui.rpcUsernameEdit, Prefs::RPC_USERNAME);
|
|
linkWidgetToPref (ui.rpcPasswordEdit, Prefs::RPC_PASSWORD);
|
|
linkWidgetToPref (ui.enableRpcWhitelistCheck, Prefs::RPC_WHITELIST_ENABLED);
|
|
linkWidgetToPref (ui.rpcWhitelistEdit, Prefs::RPC_WHITELIST);
|
|
|
|
myWebWidgets <<
|
|
ui.rpcPortLabel <<
|
|
ui.rpcPortSpin <<
|
|
ui.requireRpcAuthCheck <<
|
|
ui.enableRpcWhitelistCheck;
|
|
myWebAuthWidgets <<
|
|
ui.rpcUsernameLabel <<
|
|
ui.rpcUsernameEdit <<
|
|
ui.rpcPasswordLabel <<
|
|
ui.rpcPasswordEdit;
|
|
myWebWhitelistWidgets <<
|
|
ui.rpcWhitelistLabel <<
|
|
ui.rpcWhitelistEdit;
|
|
myUnsupportedWhenRemote <<
|
|
ui.enableRpcCheck <<
|
|
myWebWidgets <<
|
|
myWebAuthWidgets <<
|
|
myWebWhitelistWidgets;
|
|
|
|
connect (ui.openWebClientButton, SIGNAL (clicked ()), &mySession, SLOT (launchWebInterface ()));
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
PrefsDialog::altSpeedDaysEdited (int i)
|
|
{
|
|
const int value = qobject_cast<QComboBox*>(sender())->itemData(i).toInt();
|
|
setPref (Prefs::ALT_SPEED_LIMIT_TIME_DAY, value);
|
|
}
|
|
|
|
void
|
|
PrefsDialog::initSpeedTab ()
|
|
{
|
|
const QString speed_K_str = Formatter::unitStr (Formatter::SPEED, Formatter::KB);
|
|
const QLocale locale;
|
|
|
|
ui.uploadSpeedLimitSpin->setSuffix (QString::fromLatin1 (" %1").arg (speed_K_str));
|
|
ui.downloadSpeedLimitSpin->setSuffix (QString::fromLatin1 (" %1").arg (speed_K_str));
|
|
ui.altUploadSpeedLimitSpin->setSuffix (QString::fromLatin1 (" %1").arg (speed_K_str));
|
|
ui.altDownloadSpeedLimitSpin->setSuffix (QString::fromLatin1 (" %1").arg (speed_K_str));
|
|
|
|
ui.altSpeedLimitDaysCombo->addItem (tr ("Every Day"), QVariant (TR_SCHED_ALL));
|
|
ui.altSpeedLimitDaysCombo->addItem (tr ("Weekdays"), QVariant (TR_SCHED_WEEKDAY));
|
|
ui.altSpeedLimitDaysCombo->addItem (tr ("Weekends"), QVariant (TR_SCHED_WEEKEND));
|
|
ui.altSpeedLimitDaysCombo->insertSeparator (ui.altSpeedLimitDaysCombo->count ());
|
|
for (int i = locale.firstDayOfWeek (); i <= Qt::Sunday; ++i)
|
|
ui.altSpeedLimitDaysCombo->addItem (qtDayName (i), qtDayToTrDay (i));
|
|
for (int i = Qt::Monday; i < locale.firstDayOfWeek (); ++i)
|
|
ui.altSpeedLimitDaysCombo->addItem (qtDayName (i), qtDayToTrDay (i));
|
|
ui.altSpeedLimitDaysCombo->setCurrentIndex (ui.altSpeedLimitDaysCombo->findData (myPrefs.getInt (Prefs::ALT_SPEED_LIMIT_TIME_DAY)));
|
|
|
|
linkWidgetToPref (ui.uploadSpeedLimitCheck, Prefs::USPEED_ENABLED);
|
|
linkWidgetToPref (ui.uploadSpeedLimitSpin, Prefs::USPEED);
|
|
linkWidgetToPref (ui.downloadSpeedLimitCheck, Prefs::DSPEED_ENABLED);
|
|
linkWidgetToPref (ui.downloadSpeedLimitSpin, Prefs::DSPEED);
|
|
linkWidgetToPref (ui.altUploadSpeedLimitSpin, Prefs::ALT_SPEED_LIMIT_UP);
|
|
linkWidgetToPref (ui.altDownloadSpeedLimitSpin, Prefs::ALT_SPEED_LIMIT_DOWN);
|
|
linkWidgetToPref (ui.altSpeedLimitScheduleCheck, Prefs::ALT_SPEED_LIMIT_TIME_ENABLED);
|
|
linkWidgetToPref (ui.altSpeedLimitStartTimeEdit, Prefs::ALT_SPEED_LIMIT_TIME_BEGIN);
|
|
linkWidgetToPref (ui.altSpeedLimitEndTimeEdit, Prefs::ALT_SPEED_LIMIT_TIME_END);
|
|
|
|
mySchedWidgets <<
|
|
ui.altSpeedLimitStartTimeEdit <<
|
|
ui.altSpeedLimitToLabel <<
|
|
ui.altSpeedLimitEndTimeEdit <<
|
|
ui.altSpeedLimitDaysLabel <<
|
|
ui.altSpeedLimitDaysCombo;
|
|
|
|
ColumnResizer * cr (new ColumnResizer (this));
|
|
cr->addLayout (ui.speedLimitsSectionLayout);
|
|
cr->addLayout (ui.altSpeedLimitsSectionLayout);
|
|
cr->update ();
|
|
|
|
connect (ui.altSpeedLimitDaysCombo, SIGNAL (activated (int)), SLOT (altSpeedDaysEdited (int)));
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
PrefsDialog::initDesktopTab ()
|
|
{
|
|
linkWidgetToPref (ui.showTrayIconCheck, Prefs::SHOW_TRAY_ICON);
|
|
linkWidgetToPref (ui.startMinimizedCheck, Prefs::START_MINIMIZED);
|
|
linkWidgetToPref (ui.notifyOnTorrentAddedCheck, Prefs::SHOW_NOTIFICATION_ON_ADD);
|
|
linkWidgetToPref (ui.notifyOnTorrentCompletedCheck, Prefs::SHOW_NOTIFICATION_ON_COMPLETE);
|
|
linkWidgetToPref (ui.playSoundOnTorrentCompletedCheck, Prefs::COMPLETE_SOUND_ENABLED);
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
PrefsDialog::onPortTested (bool isOpen)
|
|
{
|
|
ui.testPeerPortButton->setEnabled (true);
|
|
myWidgets[Prefs::PEER_PORT]->setEnabled (true);
|
|
ui.peerPortStatusLabel->setText (isOpen ? tr ("Port is <b>open</b>")
|
|
: tr ("Port is <b>closed</b>"));
|
|
}
|
|
|
|
void
|
|
PrefsDialog::onPortTest ()
|
|
{
|
|
ui.peerPortStatusLabel->setText (tr ("Testing TCP Port..."));
|
|
ui.testPeerPortButton->setEnabled (false);
|
|
myWidgets[Prefs::PEER_PORT]->setEnabled (false);
|
|
mySession.portTest ();
|
|
}
|
|
|
|
void
|
|
PrefsDialog::initNetworkTab ()
|
|
{
|
|
ui.torrentPeerLimitSpin->setRange (1, FD_SETSIZE);
|
|
ui.globalPeerLimitSpin->setRange (1, FD_SETSIZE);
|
|
|
|
linkWidgetToPref (ui.peerPortSpin, Prefs::PEER_PORT);
|
|
linkWidgetToPref (ui.randomPeerPortCheck, Prefs::PEER_PORT_RANDOM_ON_START);
|
|
linkWidgetToPref (ui.enablePortForwardingCheck, Prefs::PORT_FORWARDING);
|
|
linkWidgetToPref (ui.torrentPeerLimitSpin, Prefs::PEER_LIMIT_TORRENT);
|
|
linkWidgetToPref (ui.globalPeerLimitSpin, Prefs::PEER_LIMIT_GLOBAL);
|
|
linkWidgetToPref (ui.enableUtpCheck, Prefs::UTP_ENABLED);
|
|
linkWidgetToPref (ui.enablePexCheck, Prefs::PEX_ENABLED);
|
|
linkWidgetToPref (ui.enableDhtCheck, Prefs::DHT_ENABLED);
|
|
linkWidgetToPref (ui.enableLpdCheck, Prefs::LPD_ENABLED);
|
|
|
|
ColumnResizer * cr (new ColumnResizer (this));
|
|
cr->addLayout (ui.incomingPeersSectionLayout);
|
|
cr->addLayout (ui.peerLimitsSectionLayout);
|
|
cr->update ();
|
|
|
|
connect (ui.testPeerPortButton, SIGNAL (clicked ()), SLOT (onPortTest ()));
|
|
connect (&mySession, SIGNAL (portTested (bool)), SLOT (onPortTested (bool)));
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
PrefsDialog::onBlocklistDialogDestroyed (QObject * o)
|
|
{
|
|
Q_UNUSED (o);
|
|
|
|
myBlocklistDialog = 0;
|
|
}
|
|
|
|
void
|
|
PrefsDialog::onUpdateBlocklistCancelled ()
|
|
{
|
|
disconnect (&mySession, SIGNAL(blocklistUpdated(int)), this, SLOT(onBlocklistUpdated(int)));
|
|
myBlocklistDialog->deleteLater ();
|
|
}
|
|
|
|
void
|
|
PrefsDialog::onBlocklistUpdated (int n)
|
|
{
|
|
myBlocklistDialog->setText (tr ("<b>Update succeeded!</b><p>Blocklist now has %Ln rule(s).", 0, n));
|
|
myBlocklistDialog->setTextFormat (Qt::RichText);
|
|
}
|
|
|
|
void
|
|
PrefsDialog::onUpdateBlocklistClicked ()
|
|
{
|
|
myBlocklistDialog = new QMessageBox (QMessageBox::Information,
|
|
QString(),
|
|
tr ("<b>Update Blocklist</b><p>Getting new blocklist..."),
|
|
QMessageBox::Close,
|
|
this);
|
|
connect (myBlocklistDialog, SIGNAL(rejected()), this, SLOT(onUpdateBlocklistCancelled()));
|
|
connect (&mySession, SIGNAL(blocklistUpdated(int)), this, SLOT(onBlocklistUpdated(int)));
|
|
myBlocklistDialog->show ();
|
|
mySession.updateBlocklist ();
|
|
}
|
|
|
|
void
|
|
PrefsDialog::encryptionEdited (int i)
|
|
{
|
|
const int value (qobject_cast<QComboBox*>(sender())->itemData(i).toInt ());
|
|
setPref (Prefs::ENCRYPTION, value);
|
|
}
|
|
|
|
void
|
|
PrefsDialog::initPrivacyTab ()
|
|
{
|
|
ui.encryptionModeCombo->addItem (tr ("Allow encryption"), 0);
|
|
ui.encryptionModeCombo->addItem (tr ("Prefer encryption"), 1);
|
|
ui.encryptionModeCombo->addItem (tr ("Require encryption"), 2);
|
|
|
|
linkWidgetToPref (ui.encryptionModeCombo, Prefs::ENCRYPTION);
|
|
linkWidgetToPref (ui.blocklistCheck, Prefs::BLOCKLIST_ENABLED);
|
|
linkWidgetToPref (ui.blocklistEdit, Prefs::BLOCKLIST_URL);
|
|
linkWidgetToPref (ui.autoUpdateBlocklistCheck, Prefs::BLOCKLIST_UPDATES_ENABLED);
|
|
|
|
myBlockWidgets <<
|
|
ui.blocklistEdit <<
|
|
ui.blocklistStatusLabel <<
|
|
ui.updateBlocklistButton <<
|
|
ui.autoUpdateBlocklistCheck;
|
|
|
|
ColumnResizer * cr (new ColumnResizer (this));
|
|
cr->addLayout (ui.encryptionSectionLayout);
|
|
cr->addLayout (ui.blocklistSectionLayout);
|
|
cr->update ();
|
|
|
|
connect (ui.encryptionModeCombo, SIGNAL (activated (int)), SLOT (encryptionEdited (int)));
|
|
connect (ui.updateBlocklistButton, SIGNAL (clicked ()), SLOT (onUpdateBlocklistClicked ()));
|
|
|
|
updateBlocklistLabel ();
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
PrefsDialog::onIdleLimitChanged ()
|
|
{
|
|
//: Spin box suffix, "Stop seeding if idle for: [ 5 minutes ]" (includes leading space after the number, if needed)
|
|
const QString unitsSuffix = tr (" minute(s)", 0, ui.idleLimitSpin->value ());
|
|
if (ui.idleLimitSpin->suffix () != unitsSuffix)
|
|
ui.idleLimitSpin->setSuffix (unitsSuffix);
|
|
}
|
|
|
|
void
|
|
PrefsDialog::initSeedingTab ()
|
|
{
|
|
linkWidgetToPref (ui.ratioLimitCheck, Prefs::RATIO_ENABLED);
|
|
linkWidgetToPref (ui.ratioLimitSpin, Prefs::RATIO);
|
|
linkWidgetToPref (ui.idleLimitCheck, Prefs::IDLE_LIMIT_ENABLED);
|
|
linkWidgetToPref (ui.idleLimitSpin, Prefs::IDLE_LIMIT);
|
|
|
|
connect (ui.idleLimitSpin, SIGNAL (valueChanged (int)), SLOT (onIdleLimitChanged ()));
|
|
|
|
onIdleLimitChanged ();
|
|
}
|
|
|
|
void
|
|
PrefsDialog::onQueueStalledMinutesChanged ()
|
|
{
|
|
//: Spin box suffix, "Download is inactive if data sharing stopped: [ 5 minutes ago ]" (includes leading space after the number, if needed)
|
|
const QString unitsSuffix = tr (" minute(s) ago", 0, ui.queueStalledMinutesSpin->value ());
|
|
if (ui.queueStalledMinutesSpin->suffix () != unitsSuffix)
|
|
ui.queueStalledMinutesSpin->setSuffix (unitsSuffix);
|
|
}
|
|
|
|
void
|
|
PrefsDialog::initDownloadingTab ()
|
|
{
|
|
if (mySession.isLocal ())
|
|
{
|
|
ui.watchDirStack->setCurrentWidget (ui.watchDirButton);
|
|
ui.downloadDirStack->setCurrentWidget (ui.downloadDirButton);
|
|
ui.incompleteDirStack->setCurrentWidget (ui.incompleteDirButton);
|
|
ui.completionScriptStack->setCurrentWidget (ui.completionScriptButton);
|
|
|
|
ui.watchDirButton->setMode (PathButton::DirectoryMode);
|
|
ui.downloadDirButton->setMode (PathButton::DirectoryMode);
|
|
ui.incompleteDirButton->setMode (PathButton::DirectoryMode);
|
|
ui.completionScriptButton->setMode (PathButton::FileMode);
|
|
|
|
ui.watchDirButton->setTitle (tr ("Select Watch Directory"));
|
|
ui.downloadDirButton->setTitle (tr ("Select Destination"));
|
|
ui.incompleteDirButton->setTitle (tr ("Select Incomplete Directory"));
|
|
ui.completionScriptButton->setTitle (tr ("Select \"Torrent Done\" Script"));
|
|
}
|
|
else
|
|
{
|
|
ui.watchDirStack->setCurrentWidget (ui.watchDirEdit);
|
|
ui.downloadDirStack->setCurrentWidget (ui.downloadDirEdit);
|
|
ui.incompleteDirStack->setCurrentWidget (ui.incompleteDirEdit);
|
|
ui.completionScriptStack->setCurrentWidget (ui.completionScriptEdit);
|
|
}
|
|
|
|
ui.watchDirStack->setFixedHeight (ui.watchDirStack->currentWidget ()->sizeHint ().height ());
|
|
ui.downloadDirStack->setFixedHeight (ui.downloadDirStack->currentWidget ()->sizeHint ().height ());
|
|
ui.incompleteDirStack->setFixedHeight (ui.incompleteDirStack->currentWidget ()->sizeHint ().height ());
|
|
ui.completionScriptStack->setFixedHeight (ui.completionScriptStack->currentWidget ()->sizeHint ().height ());
|
|
|
|
ui.watchDirStack->setMinimumWidth (200);
|
|
|
|
ui.downloadDirLabel->setBuddy (ui.downloadDirStack->currentWidget ());
|
|
|
|
ui.downloadDirFreeSpaceLabel->setSession (mySession);
|
|
ui.downloadDirFreeSpaceLabel->setPath (myPrefs.getString (Prefs::DOWNLOAD_DIR));
|
|
|
|
linkWidgetToPref (ui.watchDirCheck, Prefs::DIR_WATCH_ENABLED);
|
|
linkWidgetToPref (ui.watchDirStack->currentWidget (), Prefs::DIR_WATCH);
|
|
linkWidgetToPref (ui.showTorrentOptionsDialogCheck, Prefs::OPTIONS_PROMPT);
|
|
linkWidgetToPref (ui.startAddedTorrentsCheck, Prefs::START);
|
|
linkWidgetToPref (ui.trashTorrentFileCheck, Prefs::TRASH_ORIGINAL);
|
|
linkWidgetToPref (ui.downloadDirStack->currentWidget (), Prefs::DOWNLOAD_DIR);
|
|
linkWidgetToPref (ui.downloadQueueSizeSpin, Prefs::DOWNLOAD_QUEUE_SIZE);
|
|
linkWidgetToPref (ui.queueStalledMinutesSpin, Prefs::QUEUE_STALLED_MINUTES);
|
|
linkWidgetToPref (ui.renamePartialFilesCheck, Prefs::RENAME_PARTIAL_FILES);
|
|
linkWidgetToPref (ui.incompleteDirCheck, Prefs::INCOMPLETE_DIR_ENABLED);
|
|
linkWidgetToPref (ui.incompleteDirStack->currentWidget (), Prefs::INCOMPLETE_DIR);
|
|
linkWidgetToPref (ui.completionScriptCheck, Prefs::SCRIPT_TORRENT_DONE_ENABLED);
|
|
linkWidgetToPref (ui.completionScriptStack->currentWidget (), Prefs::SCRIPT_TORRENT_DONE_FILENAME);
|
|
|
|
ColumnResizer * cr (new ColumnResizer (this));
|
|
cr->addLayout (ui.addingSectionLayout);
|
|
cr->addLayout (ui.downloadQueueSectionLayout);
|
|
cr->addLayout (ui.incompleteSectionLayout);
|
|
cr->update ();
|
|
|
|
connect (ui.queueStalledMinutesSpin, SIGNAL (valueChanged (int)), SLOT (onQueueStalledMinutesChanged ()));
|
|
|
|
onQueueStalledMinutesChanged ();
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
PrefsDialog::PrefsDialog (Session& session, Prefs& prefs, QWidget * parent):
|
|
BaseDialog (parent),
|
|
mySession (session),
|
|
myPrefs (prefs),
|
|
myIsServer (session.isServer ())
|
|
{
|
|
ui.setupUi (this);
|
|
|
|
initSpeedTab ();
|
|
initDownloadingTab ();
|
|
initSeedingTab ();
|
|
initPrivacyTab ();
|
|
initNetworkTab ();
|
|
initDesktopTab ();
|
|
initRemoteTab ();
|
|
|
|
connect (&mySession, SIGNAL (sessionUpdated ()), SLOT (sessionUpdated ()));
|
|
|
|
QList<int> keys;
|
|
keys << Prefs::RPC_ENABLED
|
|
<< Prefs::ALT_SPEED_LIMIT_ENABLED
|
|
<< Prefs::ALT_SPEED_LIMIT_TIME_ENABLED
|
|
<< Prefs::ENCRYPTION
|
|
<< Prefs::BLOCKLIST_ENABLED
|
|
<< Prefs::DIR_WATCH
|
|
<< Prefs::DOWNLOAD_DIR
|
|
<< Prefs::INCOMPLETE_DIR
|
|
<< Prefs::INCOMPLETE_DIR_ENABLED
|
|
<< Prefs::SCRIPT_TORRENT_DONE_FILENAME;
|
|
for (const int key: keys)
|
|
refreshPref (key);
|
|
|
|
// if it's a remote session, disable the preferences
|
|
// that don't work in remote sessions
|
|
if (!myIsServer)
|
|
{
|
|
for (QWidget * const w: myUnsupportedWhenRemote)
|
|
{
|
|
w->setToolTip (tr ("Not supported by remote sessions"));
|
|
w->setEnabled (false);
|
|
}
|
|
}
|
|
|
|
adjustSize ();
|
|
}
|
|
|
|
PrefsDialog::~PrefsDialog ()
|
|
{
|
|
}
|
|
|
|
void
|
|
PrefsDialog::setPref (int key, const QVariant& v)
|
|
{
|
|
myPrefs.set (key, v);
|
|
refreshPref (key);
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
PrefsDialog::sessionUpdated ()
|
|
{
|
|
updateBlocklistLabel ();
|
|
}
|
|
|
|
void
|
|
PrefsDialog::updateBlocklistLabel ()
|
|
{
|
|
const int n = mySession.blocklistSize ();
|
|
ui.blocklistStatusLabel->setText (tr ("<i>Blocklist contains %Ln rule(s)</i>", 0, n));
|
|
}
|
|
|
|
void
|
|
PrefsDialog::refreshPref (int key)
|
|
{
|
|
switch (key)
|
|
{
|
|
case Prefs::RPC_ENABLED:
|
|
case Prefs::RPC_WHITELIST_ENABLED:
|
|
case Prefs::RPC_AUTH_REQUIRED:
|
|
{
|
|
const bool enabled (myPrefs.getBool (Prefs::RPC_ENABLED));
|
|
const bool whitelist (myPrefs.getBool (Prefs::RPC_WHITELIST_ENABLED));
|
|
const bool auth (myPrefs.getBool (Prefs::RPC_AUTH_REQUIRED));
|
|
for (QWidget * const w: myWebWhitelistWidgets)
|
|
w->setEnabled (enabled && whitelist);
|
|
for (QWidget * const w: myWebAuthWidgets)
|
|
w->setEnabled (enabled && auth);
|
|
for (QWidget * const w: myWebWidgets)
|
|
w->setEnabled (enabled);
|
|
break;
|
|
}
|
|
|
|
case Prefs::ALT_SPEED_LIMIT_TIME_ENABLED:
|
|
{
|
|
const bool enabled = myPrefs.getBool (key);
|
|
for (QWidget * const w: mySchedWidgets)
|
|
w->setEnabled (enabled);
|
|
break;
|
|
}
|
|
|
|
case Prefs::BLOCKLIST_ENABLED:
|
|
{
|
|
const bool enabled = myPrefs.getBool (key);
|
|
for (QWidget * const w: myBlockWidgets)
|
|
w->setEnabled (enabled);
|
|
break;
|
|
}
|
|
|
|
case Prefs::DIR_WATCH:
|
|
ui.watchDirButton->setText (QFileInfo (myPrefs.getString (Prefs::DIR_WATCH)).fileName ());
|
|
break;
|
|
|
|
case Prefs::SCRIPT_TORRENT_DONE_FILENAME:
|
|
{
|
|
const QString path (myPrefs.getString (key));
|
|
ui.completionScriptButton->setText (QFileInfo (path).fileName ());
|
|
break;
|
|
}
|
|
|
|
case Prefs::PEER_PORT:
|
|
ui.peerPortStatusLabel->setText (tr ("Status unknown"));
|
|
ui.testPeerPortButton->setEnabled (true);
|
|
break;
|
|
|
|
case Prefs::DOWNLOAD_DIR:
|
|
{
|
|
const QString path (myPrefs.getString (key));
|
|
ui.downloadDirButton->setText (QFileInfo (path).fileName ());
|
|
ui.downloadDirFreeSpaceLabel->setPath (path);
|
|
break;
|
|
}
|
|
|
|
case Prefs::INCOMPLETE_DIR:
|
|
{
|
|
QString path (myPrefs.getString (key));
|
|
ui.incompleteDirButton->setText (QFileInfo (path).fileName ());
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
key2widget_t::iterator it (myWidgets.find (key));
|
|
if (it != myWidgets.end ())
|
|
{
|
|
QWidget * w (it.value ());
|
|
|
|
if (!updateWidgetValue (w, key))
|
|
{
|
|
if (key == Prefs::ENCRYPTION)
|
|
{
|
|
QComboBox * comboBox (qobject_cast<QComboBox*> (w));
|
|
const int index = comboBox->findData (myPrefs.getInt (key));
|
|
comboBox->setCurrentIndex (index);
|
|
}
|
|
}
|
|
}
|
|
}
|