src/base/preferences.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2014  sledgehammer999 <hammered999@gmail.com>
   4  * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "preferences.h"
  31
  32 #include <algorithm>
  33 #include <chrono>
  34
  35 #include <QCoreApplication>
  36 #include <QDateTime>
  37 #include <QDir>
  38 #include <QList>
  39 #include <QLocale>
  40 #include <QNetworkCookie>
  41 #include <QSettings>
  42 #include <QTime>
  43
  44 #include "algorithm.h"
  45 #include "global.h"
  46 #include "path.h"
  47 #include "profile.h"
  48 #include "settingsstorage.h"
  49 #include "utils/fs.h"
  50
  51 namespace
  52 {
  53     template <typename T>
  54     T value(const QString &key, const T &defaultValue = {})
  55     {
  56         return SettingsStorage::instance()->loadValue(key, defaultValue);
  57     }
  58
  59     template <typename T>
  60     void setValue(const QString &key, const T &value)
  61     {
  62         SettingsStorage::instance()->storeValue(key, value);
  63     }
  64
  65 #ifdef Q_OS_WIN
  66     QString makeProfileID(const Path &profilePath, const QString &profileName)
  67     {
  68         return profilePath.isEmpty()
  69                 ? profileName
  70                 : profileName + u'@' + Utils::Fs::toValidFileName(profilePath.data(), {});
  71     }
  72 #endif
  73 }
  74
  75 Preferences *Preferences::m_instance = nullptr;
  76
  77 Preferences::Preferences() = default;
  78
  79 Preferences *Preferences::instance()
  80 {
  81     return m_instance;
  82 }
  83
  84 void Preferences::initInstance()
  85 {
  86     if (!m_instance)
  87         m_instance = new Preferences;
  88 }
  89
  90 void Preferences::freeInstance()
  91 {
  92     delete m_instance;
  93     m_instance = nullptr;
  94 }
  95
  96 // General options
  97 QString Preferences::getLocale() const
  98 {
  99     const auto localeName = value<QString>(u"Preferences/General/Locale"_s);
 100     return (localeName.isEmpty() ? QLocale::system().name() : localeName);
 101 }
 102
 103 void Preferences::setLocale(const QString &locale)
 104 {
 105     if (locale == getLocale())
 106         return;
 107
 108     setValue(u"Preferences/General/Locale"_s, locale);
 109 }
 110
 111 bool Preferences::useCustomUITheme() const
 112 {
 113     return value(u"Preferences/General/UseCustomUITheme"_s, false) && !customUIThemePath().isEmpty();
 114 }
 115
 116 void Preferences::setUseCustomUITheme(const bool use)
 117 {
 118     if (use == useCustomUITheme())
 119         return;
 120
 121     setValue(u"Preferences/General/UseCustomUITheme"_s, use);
 122 }
 123
 124 Path Preferences::customUIThemePath() const
 125 {
 126     return value<Path>(u"Preferences/General/CustomUIThemePath"_s);
 127 }
 128
 129 void Preferences::setCustomUIThemePath(const Path &path)
 130 {
 131     if (path == customUIThemePath())
 132         return;
 133
 134     setValue(u"Preferences/General/CustomUIThemePath"_s, path);
 135 }
 136
 137 bool Preferences::removeTorrentContent() const
 138 {
 139     return value(u"Preferences/General/DeleteTorrentsFilesAsDefault"_s, false);
 140 }
 141
 142 void Preferences::setRemoveTorrentContent(const bool remove)
 143 {
 144     if (remove == removeTorrentContent())
 145         return;
 146
 147     setValue(u"Preferences/General/DeleteTorrentsFilesAsDefault"_s, remove);
 148 }
 149
 150 bool Preferences::confirmOnExit() const
 151 {
 152     return value(u"Preferences/General/ExitConfirm"_s, true);
 153 }
 154
 155 void Preferences::setConfirmOnExit(const bool confirm)
 156 {
 157     if (confirm == confirmOnExit())
 158         return;
 159
 160     setValue(u"Preferences/General/ExitConfirm"_s, confirm);
 161 }
 162
 163 bool Preferences::speedInTitleBar() const
 164 {
 165     return value(u"Preferences/General/SpeedInTitleBar"_s, false);
 166 }
 167
 168 void Preferences::showSpeedInTitleBar(const bool show)
 169 {
 170     if (show == speedInTitleBar())
 171         return;
 172
 173     setValue(u"Preferences/General/SpeedInTitleBar"_s, show);
 174 }
 175
 176 bool Preferences::useAlternatingRowColors() const
 177 {
 178     return value(u"Preferences/General/AlternatingRowColors"_s, true);
 179 }
 180
 181 void Preferences::setAlternatingRowColors(const bool b)
 182 {
 183     if (b == useAlternatingRowColors())
 184         return;
 185
 186     setValue(u"Preferences/General/AlternatingRowColors"_s, b);
 187 }
 188
 189 bool Preferences::getHideZeroValues() const
 190 {
 191     return value(u"Preferences/General/HideZeroValues"_s, false);
 192 }
 193
 194 void Preferences::setHideZeroValues(const bool b)
 195 {
 196     if (b == getHideZeroValues())
 197         return;
 198
 199     setValue(u"Preferences/General/HideZeroValues"_s, b);
 200 }
 201
 202 int Preferences::getHideZeroComboValues() const
 203 {
 204     return value<int>(u"Preferences/General/HideZeroComboValues"_s, 0);
 205 }
 206
 207 void Preferences::setHideZeroComboValues(const int n)
 208 {
 209     if (n == getHideZeroComboValues())
 210         return;
 211
 212     setValue(u"Preferences/General/HideZeroComboValues"_s, n);
 213 }
 214
 215 // In Mac OS X the dock is sufficient for our needs so we disable the sys tray functionality.
 216 // See extensive discussion in https://github.com/qbittorrent/qBittorrent/pull/3018
 217 #ifndef Q_OS_MACOS
 218 bool Preferences::systemTrayEnabled() const
 219 {
 220     return value(u"Preferences/General/SystrayEnabled"_s, true);
 221 }
 222
 223 void Preferences::setSystemTrayEnabled(const bool enabled)
 224 {
 225     if (enabled == systemTrayEnabled())
 226         return;
 227
 228     setValue(u"Preferences/General/SystrayEnabled"_s, enabled);
 229 }
 230
 231 bool Preferences::minimizeToTray() const
 232 {
 233     return value(u"Preferences/General/MinimizeToTray"_s, false);
 234 }
 235
 236 void Preferences::setMinimizeToTray(const bool b)
 237 {
 238     if (b == minimizeToTray())
 239         return;
 240
 241     setValue(u"Preferences/General/MinimizeToTray"_s, b);
 242 }
 243
 244 bool Preferences::minimizeToTrayNotified() const
 245 {
 246     return value(u"Preferences/General/MinimizeToTrayNotified"_s, false);
 247 }
 248
 249 void Preferences::setMinimizeToTrayNotified(const bool b)
 250 {
 251     if (b == minimizeToTrayNotified())
 252         return;
 253
 254     setValue(u"Preferences/General/MinimizeToTrayNotified"_s, b);
 255 }
 256
 257 bool Preferences::closeToTray() const
 258 {
 259     return value(u"Preferences/General/CloseToTray"_s, true);
 260 }
 261
 262 void Preferences::setCloseToTray(const bool b)
 263 {
 264     if (b == closeToTray())
 265         return;
 266
 267     setValue(u"Preferences/General/CloseToTray"_s, b);
 268 }
 269
 270 bool Preferences::closeToTrayNotified() const
 271 {
 272     return value(u"Preferences/General/CloseToTrayNotified"_s, false);
 273 }
 274
 275 void Preferences::setCloseToTrayNotified(const bool b)
 276 {
 277     if (b == closeToTrayNotified())
 278         return;
 279
 280     setValue(u"Preferences/General/CloseToTrayNotified"_s, b);
 281 }
 282
 283 bool Preferences::iconsInMenusEnabled() const
 284 {
 285     return value(u"Preferences/Advanced/EnableIconsInMenus"_s, true);
 286 }
 287
 288 void Preferences::setIconsInMenusEnabled(const bool enable)
 289 {
 290     if (enable == iconsInMenusEnabled())
 291         return;
 292
 293     setValue(u"Preferences/Advanced/EnableIconsInMenus"_s, enable);
 294 }
 295 #endif // Q_OS_MACOS
 296
 297 qint64 Preferences::getTorrentFileSizeLimit() const
 298 {
 299     return value(u"BitTorrent/TorrentFileSizeLimit"_s, (100 * 1024 * 1024));
 300 }
 301
 302 void Preferences::setTorrentFileSizeLimit(const qint64 value)
 303 {
 304     if (value == getTorrentFileSizeLimit())
 305         return;
 306
 307     setValue(u"BitTorrent/TorrentFileSizeLimit"_s, value);
 308 }
 309
 310 int Preferences::getBdecodeDepthLimit() const
 311 {
 312     return value(u"BitTorrent/BdecodeDepthLimit"_s, 100);
 313 }
 314
 315 void Preferences::setBdecodeDepthLimit(const int value)
 316 {
 317     if (value == getBdecodeDepthLimit())
 318         return;
 319
 320     setValue(u"BitTorrent/BdecodeDepthLimit"_s, value);
 321 }
 322
 323 int Preferences::getBdecodeTokenLimit() const
 324 {
 325     return value(u"BitTorrent/BdecodeTokenLimit"_s, 10'000'000);
 326 }
 327
 328 void Preferences::setBdecodeTokenLimit(const int value)
 329 {
 330     if (value == getBdecodeTokenLimit())
 331         return;
 332
 333     setValue(u"BitTorrent/BdecodeTokenLimit"_s, value);
 334 }
 335
 336 bool Preferences::isToolbarDisplayed() const
 337 {
 338     return value(u"Preferences/General/ToolbarDisplayed"_s, true);
 339 }
 340
 341 void Preferences::setToolbarDisplayed(const bool displayed)
 342 {
 343     if (displayed == isToolbarDisplayed())
 344         return;
 345
 346     setValue(u"Preferences/General/ToolbarDisplayed"_s, displayed);
 347 }
 348
 349 bool Preferences::isStatusbarDisplayed() const
 350 {
 351     return value(u"Preferences/General/StatusbarDisplayed"_s, true);
 352 }
 353
 354 void Preferences::setStatusbarDisplayed(const bool displayed)
 355 {
 356     if (displayed == isStatusbarDisplayed())
 357         return;
 358
 359     setValue(u"Preferences/General/StatusbarDisplayed"_s, displayed);
 360 }
 361
 362 bool Preferences::isStatusbarExternalIPDisplayed() const
 363 {
 364     return value(u"Preferences/General/StatusbarExternalIPDisplayed"_s, false);
 365 }
 366
 367 void Preferences::setStatusbarExternalIPDisplayed(const bool displayed)
 368 {
 369     if (displayed == isStatusbarExternalIPDisplayed())
 370         return;
 371
 372     setValue(u"Preferences/General/StatusbarExternalIPDisplayed"_s, displayed);
 373 }
 374
 375 bool Preferences::isSplashScreenDisabled() const
 376 {
 377     return value(u"Preferences/General/NoSplashScreen"_s, true);
 378 }
 379
 380 void Preferences::setSplashScreenDisabled(const bool b)
 381 {
 382     if (b == isSplashScreenDisabled())
 383         return;
 384
 385     setValue(u"Preferences/General/NoSplashScreen"_s, b);
 386 }
 387
 388 // Preventing from system suspend while active torrents are presented.
 389 bool Preferences::preventFromSuspendWhenDownloading() const
 390 {
 391     return value(u"Preferences/General/PreventFromSuspendWhenDownloading"_s, false);
 392 }
 393
 394 void Preferences::setPreventFromSuspendWhenDownloading(const bool b)
 395 {
 396     if (b == preventFromSuspendWhenDownloading())
 397         return;
 398
 399     setValue(u"Preferences/General/PreventFromSuspendWhenDownloading"_s, b);
 400 }
 401
 402 bool Preferences::preventFromSuspendWhenSeeding() const
 403 {
 404     return value(u"Preferences/General/PreventFromSuspendWhenSeeding"_s, false);
 405 }
 406
 407 void Preferences::setPreventFromSuspendWhenSeeding(const bool b)
 408 {
 409     if (b == preventFromSuspendWhenSeeding())
 410         return;
 411
 412     setValue(u"Preferences/General/PreventFromSuspendWhenSeeding"_s, b);
 413 }
 414
 415 #ifdef Q_OS_WIN
 416 bool Preferences::WinStartup() const
 417 {
 418     const QString profileName = Profile::instance()->profileName();
 419     const Path profilePath = Profile::instance()->rootPath();
 420     const QString profileID = makeProfileID(profilePath, profileName);
 421     const QSettings settings {u"HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run"_s, QSettings::NativeFormat};
 422
 423     return settings.contains(profileID);
 424 }
 425
 426 void Preferences::setWinStartup(const bool b)
 427 {
 428     const QString profileName = Profile::instance()->profileName();
 429     const Path profilePath = Profile::instance()->rootPath();
 430     const QString profileID = makeProfileID(profilePath, profileName);
 431     QSettings settings {u"HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run"_s, QSettings::NativeFormat};
 432     if (b)
 433     {
 434         const QString configuration = Profile::instance()->configurationName();
 435
 436         const auto cmd = uR"("%1" "--profile=%2" "--configuration=%3")"_s
 437                 .arg(Path(qApp->applicationFilePath()).toString(), profilePath.toString(), configuration);
 438         settings.setValue(profileID, cmd);
 439     }
 440     else
 441     {
 442         settings.remove(profileID);
 443     }
 444 }
 445
 446 QString Preferences::getStyle() const
 447 {
 448     return value<QString>(u"Appearance/Style"_s);
 449 }
 450
 451 void Preferences::setStyle(const QString &styleName)
 452 {
 453     if (styleName == getStyle())
 454         return;
 455
 456     setValue(u"Appearance/Style"_s, styleName);
 457 }
 458 #endif // Q_OS_WIN
 459
 460 // Downloads
 461 Path Preferences::getScanDirsLastPath() const
 462 {
 463     return value<Path>(u"Preferences/Downloads/ScanDirsLastPath"_s);
 464 }
 465
 466 void Preferences::setScanDirsLastPath(const Path &path)
 467 {
 468     if (path == getScanDirsLastPath())
 469         return;
 470
 471     setValue(u"Preferences/Downloads/ScanDirsLastPath"_s, path);
 472 }
 473
 474 bool Preferences::isMailNotificationEnabled() const
 475 {
 476     return value(u"Preferences/MailNotification/enabled"_s, false);
 477 }
 478
 479 void Preferences::setMailNotificationEnabled(const bool enabled)
 480 {
 481     if (enabled == isMailNotificationEnabled())
 482         return;
 483
 484     setValue(u"Preferences/MailNotification/enabled"_s, enabled);
 485 }
 486
 487 QString Preferences::getMailNotificationSender() const
 488 {
 489     return value<QString>(u"Preferences/MailNotification/sender"_s
 490         , u"qBittorrent_notification@example.com"_s);
 491 }
 492
 493 void Preferences::setMailNotificationSender(const QString &mail)
 494 {
 495     if (mail == getMailNotificationSender())
 496         return;
 497
 498     setValue(u"Preferences/MailNotification/sender"_s, mail);
 499 }
 500
 501 QString Preferences::getMailNotificationEmail() const
 502 {
 503     return value<QString>(u"Preferences/MailNotification/email"_s);
 504 }
 505
 506 void Preferences::setMailNotificationEmail(const QString &mail)
 507 {
 508     if (mail == getMailNotificationEmail())
 509         return;
 510
 511     setValue(u"Preferences/MailNotification/email"_s, mail);
 512 }
 513
 514 QString Preferences::getMailNotificationSMTP() const
 515 {
 516     return value<QString>(u"Preferences/MailNotification/smtp_server"_s, u"smtp.changeme.com"_s);
 517 }
 518
 519 void Preferences::setMailNotificationSMTP(const QString &smtpServer)
 520 {
 521     if (smtpServer == getMailNotificationSMTP())
 522         return;
 523
 524     setValue(u"Preferences/MailNotification/smtp_server"_s, smtpServer);
 525 }
 526
 527 bool Preferences::getMailNotificationSMTPSSL() const
 528 {
 529     return value(u"Preferences/MailNotification/req_ssl"_s, false);
 530 }
 531
 532 void Preferences::setMailNotificationSMTPSSL(const bool use)
 533 {
 534     if (use == getMailNotificationSMTPSSL())
 535         return;
 536
 537     setValue(u"Preferences/MailNotification/req_ssl"_s, use);
 538 }
 539
 540 bool Preferences::getMailNotificationSMTPAuth() const
 541 {
 542     return value(u"Preferences/MailNotification/req_auth"_s, false);
 543 }
 544
 545 void Preferences::setMailNotificationSMTPAuth(const bool use)
 546 {
 547     if (use == getMailNotificationSMTPAuth())
 548         return;
 549
 550     setValue(u"Preferences/MailNotification/req_auth"_s, use);
 551 }
 552
 553 QString Preferences::getMailNotificationSMTPUsername() const
 554 {
 555     return value<QString>(u"Preferences/MailNotification/username"_s);
 556 }
 557
 558 void Preferences::setMailNotificationSMTPUsername(const QString &username)
 559 {
 560     if (username == getMailNotificationSMTPUsername())
 561         return;
 562
 563     setValue(u"Preferences/MailNotification/username"_s, username);
 564 }
 565
 566 QString Preferences::getMailNotificationSMTPPassword() const
 567 {
 568     return value<QString>(u"Preferences/MailNotification/password"_s);
 569 }
 570
 571 void Preferences::setMailNotificationSMTPPassword(const QString &password)
 572 {
 573     if (password == getMailNotificationSMTPPassword())
 574         return;
 575
 576     setValue(u"Preferences/MailNotification/password"_s, password);
 577 }
 578
 579 int Preferences::getActionOnDblClOnTorrentDl() const
 580 {
 581     return value<int>(u"Preferences/Downloads/DblClOnTorDl"_s, 0);
 582 }
 583
 584 void Preferences::setActionOnDblClOnTorrentDl(const int act)
 585 {
 586     if (act == getActionOnDblClOnTorrentDl())
 587         return;
 588
 589     setValue(u"Preferences/Downloads/DblClOnTorDl"_s, act);
 590 }
 591
 592 int Preferences::getActionOnDblClOnTorrentFn() const
 593 {
 594     return value<int>(u"Preferences/Downloads/DblClOnTorFn"_s, 1);
 595 }
 596
 597 void Preferences::setActionOnDblClOnTorrentFn(const int act)
 598 {
 599     if (act == getActionOnDblClOnTorrentFn())
 600         return;
 601
 602     setValue(u"Preferences/Downloads/DblClOnTorFn"_s, act);
 603 }
 604
 605 QTime Preferences::getSchedulerStartTime() const
 606 {
 607     return value(u"Preferences/Scheduler/start_time"_s, QTime(8, 0));
 608 }
 609
 610 void Preferences::setSchedulerStartTime(const QTime &time)
 611 {
 612     if (time == getSchedulerStartTime())
 613         return;
 614
 615     setValue(u"Preferences/Scheduler/start_time"_s, time);
 616 }
 617
 618 QTime Preferences::getSchedulerEndTime() const
 619 {
 620     return value(u"Preferences/Scheduler/end_time"_s, QTime(20, 0));
 621 }
 622
 623 void Preferences::setSchedulerEndTime(const QTime &time)
 624 {
 625     if (time == getSchedulerEndTime())
 626         return;
 627
 628     setValue(u"Preferences/Scheduler/end_time"_s, time);
 629 }
 630
 631 Scheduler::Days Preferences::getSchedulerDays() const
 632 {
 633     return value(u"Preferences/Scheduler/days"_s, Scheduler::Days::EveryDay);
 634 }
 635
 636 void Preferences::setSchedulerDays(const Scheduler::Days days)
 637 {
 638     if (days == getSchedulerDays())
 639         return;
 640
 641     setValue(u"Preferences/Scheduler/days"_s, days);
 642 }
 643
 644 // Search
 645 bool Preferences::isSearchEnabled() const
 646 {
 647     return value(u"Preferences/Search/SearchEnabled"_s, false);
 648 }
 649
 650 void Preferences::setSearchEnabled(const bool enabled)
 651 {
 652     if (enabled == isSearchEnabled())
 653         return;
 654
 655     setValue(u"Preferences/Search/SearchEnabled"_s, enabled);
 656 }
 657
 658 bool Preferences::isWebUIEnabled() const
 659 {
 660 #ifdef DISABLE_GUI
 661     const bool defaultValue = true;
 662 #else
 663     const bool defaultValue = false;
 664 #endif
 665     return value(u"Preferences/WebUI/Enabled"_s, defaultValue);
 666 }
 667
 668 void Preferences::setWebUIEnabled(const bool enabled)
 669 {
 670     if (enabled == isWebUIEnabled())
 671         return;
 672
 673     setValue(u"Preferences/WebUI/Enabled"_s, enabled);
 674 }
 675
 676 bool Preferences::isWebUILocalAuthEnabled() const
 677 {
 678     return value(u"Preferences/WebUI/LocalHostAuth"_s, true);
 679 }
 680
 681 void Preferences::setWebUILocalAuthEnabled(const bool enabled)
 682 {
 683     if (enabled == isWebUILocalAuthEnabled())
 684         return;
 685
 686     setValue(u"Preferences/WebUI/LocalHostAuth"_s, enabled);
 687 }
 688
 689 bool Preferences::isWebUIAuthSubnetWhitelistEnabled() const
 690 {
 691     return value(u"Preferences/WebUI/AuthSubnetWhitelistEnabled"_s, false);
 692 }
 693
 694 void Preferences::setWebUIAuthSubnetWhitelistEnabled(const bool enabled)
 695 {
 696     if (enabled == isWebUIAuthSubnetWhitelistEnabled())
 697         return;
 698
 699     setValue(u"Preferences/WebUI/AuthSubnetWhitelistEnabled"_s, enabled);
 700 }
 701
 702 QList<Utils::Net::Subnet> Preferences::getWebUIAuthSubnetWhitelist() const
 703 {
 704     const auto subnets = value<QStringList>(u"Preferences/WebUI/AuthSubnetWhitelist"_s);
 705
 706     QList<Utils::Net::Subnet> ret;
 707     ret.reserve(subnets.size());
 708
 709     for (const QString &rawSubnet : subnets)
 710     {
 711         const std::optional<Utils::Net::Subnet> subnet = Utils::Net::parseSubnet(rawSubnet.trimmed());
 712         if (subnet)
 713             ret.append(subnet.value());
 714     }
 715
 716     return ret;
 717 }
 718
 719 void Preferences::setWebUIAuthSubnetWhitelist(QStringList subnets)
 720 {
 721     subnets.removeIf([](const QString &subnet)
 722     {
 723         return !Utils::Net::parseSubnet(subnet.trimmed()).has_value();
 724     });
 725
 726     setValue(u"Preferences/WebUI/AuthSubnetWhitelist"_s, subnets);
 727 }
 728
 729 QString Preferences::getServerDomains() const
 730 {
 731     return value<QString>(u"Preferences/WebUI/ServerDomains"_s, u"*"_s);
 732 }
 733
 734 void Preferences::setServerDomains(const QString &str)
 735 {
 736     if (str == getServerDomains())
 737         return;
 738
 739     setValue(u"Preferences/WebUI/ServerDomains"_s, str);
 740 }
 741
 742 QString Preferences::getWebUIAddress() const
 743 {
 744     return value<QString>(u"Preferences/WebUI/Address"_s, u"*"_s).trimmed();
 745 }
 746
 747 void Preferences::setWebUIAddress(const QString &addr)
 748 {
 749     if (addr == getWebUIAddress())
 750         return;
 751
 752     setValue(u"Preferences/WebUI/Address"_s, addr.trimmed());
 753 }
 754
 755 quint16 Preferences::getWebUIPort() const
 756 {
 757     return value<quint16>(u"Preferences/WebUI/Port"_s, 8080);
 758 }
 759
 760 void Preferences::setWebUIPort(const quint16 port)
 761 {
 762     if (port == getWebUIPort())
 763         return;
 764
 765     // cast to `int` type so it will show human readable unit in configuration file
 766     setValue(u"Preferences/WebUI/Port"_s, static_cast<int>(port));
 767 }
 768
 769 bool Preferences::useUPnPForWebUIPort() const
 770 {
 771     return value(u"Preferences/WebUI/UseUPnP"_s, false);
 772 }
 773
 774 void Preferences::setUPnPForWebUIPort(const bool enabled)
 775 {
 776     if (enabled == useUPnPForWebUIPort())
 777         return;
 778
 779     setValue(u"Preferences/WebUI/UseUPnP"_s, enabled);
 780 }
 781
 782 QString Preferences::getWebUIUsername() const
 783 {
 784     return value<QString>(u"Preferences/WebUI/Username"_s, u"admin"_s);
 785 }
 786
 787 void Preferences::setWebUIUsername(const QString &username)
 788 {
 789     if (username == getWebUIUsername())
 790         return;
 791
 792     setValue(u"Preferences/WebUI/Username"_s, username);
 793 }
 794
 795 QByteArray Preferences::getWebUIPassword() const
 796 {
 797     return value<QByteArray>(u"Preferences/WebUI/Password_PBKDF2"_s);
 798 }
 799
 800 void Preferences::setWebUIPassword(const QByteArray &password)
 801 {
 802     if (password == getWebUIPassword())
 803         return;
 804
 805     setValue(u"Preferences/WebUI/Password_PBKDF2"_s, password);
 806 }
 807
 808 int Preferences::getWebUIMaxAuthFailCount() const
 809 {
 810     return value<int>(u"Preferences/WebUI/MaxAuthenticationFailCount"_s, 5);
 811 }
 812
 813 void Preferences::setWebUIMaxAuthFailCount(const int count)
 814 {
 815     if (count == getWebUIMaxAuthFailCount())
 816         return;
 817
 818     setValue(u"Preferences/WebUI/MaxAuthenticationFailCount"_s, count);
 819 }
 820
 821 std::chrono::seconds Preferences::getWebUIBanDuration() const
 822 {
 823     return std::chrono::seconds(value<int>(u"Preferences/WebUI/BanDuration"_s, 3600));
 824 }
 825
 826 void Preferences::setWebUIBanDuration(const std::chrono::seconds duration)
 827 {
 828     if (duration == getWebUIBanDuration())
 829         return;
 830
 831     setValue(u"Preferences/WebUI/BanDuration"_s, static_cast<int>(duration.count()));
 832 }
 833
 834 int Preferences::getWebUISessionTimeout() const
 835 {
 836     return value<int>(u"Preferences/WebUI/SessionTimeout"_s, 3600);
 837 }
 838
 839 void Preferences::setWebUISessionTimeout(const int timeout)
 840 {
 841     if (timeout == getWebUISessionTimeout())
 842         return;
 843
 844     setValue(u"Preferences/WebUI/SessionTimeout"_s, timeout);
 845 }
 846
 847 QString Preferences::getWebAPISessionCookieName() const
 848 {
 849     return value<QString>(u"WebAPI/SessionCookieName"_s);
 850 }
 851
 852 void Preferences::setWebAPISessionCookieName(const QString &cookieName)
 853 {
 854     if (cookieName == getWebAPISessionCookieName())
 855         return;
 856
 857     setValue(u"WebAPI/SessionCookieName"_s, cookieName);
 858 }
 859
 860 bool Preferences::isWebUIClickjackingProtectionEnabled() const
 861 {
 862     return value(u"Preferences/WebUI/ClickjackingProtection"_s, true);
 863 }
 864
 865 void Preferences::setWebUIClickjackingProtectionEnabled(const bool enabled)
 866 {
 867     if (enabled == isWebUIClickjackingProtectionEnabled())
 868         return;
 869
 870     setValue(u"Preferences/WebUI/ClickjackingProtection"_s, enabled);
 871 }
 872
 873 bool Preferences::isWebUICSRFProtectionEnabled() const
 874 {
 875     return value(u"Preferences/WebUI/CSRFProtection"_s, true);
 876 }
 877
 878 void Preferences::setWebUICSRFProtectionEnabled(const bool enabled)
 879 {
 880     if (enabled == isWebUICSRFProtectionEnabled())
 881         return;
 882
 883     setValue(u"Preferences/WebUI/CSRFProtection"_s, enabled);
 884 }
 885
 886 bool Preferences::isWebUISecureCookieEnabled() const
 887 {
 888     return value(u"Preferences/WebUI/SecureCookie"_s, true);
 889 }
 890
 891 void Preferences::setWebUISecureCookieEnabled(const bool enabled)
 892 {
 893     if (enabled == isWebUISecureCookieEnabled())
 894         return;
 895
 896     setValue(u"Preferences/WebUI/SecureCookie"_s, enabled);
 897 }
 898
 899 bool Preferences::isWebUIHostHeaderValidationEnabled() const
 900 {
 901     return value(u"Preferences/WebUI/HostHeaderValidation"_s, true);
 902 }
 903
 904 void Preferences::setWebUIHostHeaderValidationEnabled(const bool enabled)
 905 {
 906     if (enabled == isWebUIHostHeaderValidationEnabled())
 907         return;
 908
 909     setValue(u"Preferences/WebUI/HostHeaderValidation"_s, enabled);
 910 }
 911
 912 bool Preferences::isWebUIHttpsEnabled() const
 913 {
 914     return value(u"Preferences/WebUI/HTTPS/Enabled"_s, false);
 915 }
 916
 917 void Preferences::setWebUIHttpsEnabled(const bool enabled)
 918 {
 919     if (enabled == isWebUIHttpsEnabled())
 920         return;
 921
 922     setValue(u"Preferences/WebUI/HTTPS/Enabled"_s, enabled);
 923 }
 924
 925 Path Preferences::getWebUIHttpsCertificatePath() const
 926 {
 927     return value<Path>(u"Preferences/WebUI/HTTPS/CertificatePath"_s);
 928 }
 929
 930 void Preferences::setWebUIHttpsCertificatePath(const Path &path)
 931 {
 932     if (path == getWebUIHttpsCertificatePath())
 933         return;
 934
 935     setValue(u"Preferences/WebUI/HTTPS/CertificatePath"_s, path);
 936 }
 937
 938 Path Preferences::getWebUIHttpsKeyPath() const
 939 {
 940     return value<Path>(u"Preferences/WebUI/HTTPS/KeyPath"_s);
 941 }
 942
 943 void Preferences::setWebUIHttpsKeyPath(const Path &path)
 944 {
 945     if (path == getWebUIHttpsKeyPath())
 946         return;
 947
 948     setValue(u"Preferences/WebUI/HTTPS/KeyPath"_s, path);
 949 }
 950
 951 bool Preferences::isAltWebUIEnabled() const
 952 {
 953     return value(u"Preferences/WebUI/AlternativeUIEnabled"_s, false);
 954 }
 955
 956 void Preferences::setAltWebUIEnabled(const bool enabled)
 957 {
 958     if (enabled == isAltWebUIEnabled())
 959         return;
 960
 961     setValue(u"Preferences/WebUI/AlternativeUIEnabled"_s, enabled);
 962 }
 963
 964 Path Preferences::getWebUIRootFolder() const
 965 {
 966     return value<Path>(u"Preferences/WebUI/RootFolder"_s);
 967 }
 968
 969 void Preferences::setWebUIRootFolder(const Path &path)
 970 {
 971     if (path == getWebUIRootFolder())
 972         return;
 973
 974     setValue(u"Preferences/WebUI/RootFolder"_s, path);
 975 }
 976
 977 bool Preferences::isWebUICustomHTTPHeadersEnabled() const
 978 {
 979     return value(u"Preferences/WebUI/CustomHTTPHeadersEnabled"_s, false);
 980 }
 981
 982 void Preferences::setWebUICustomHTTPHeadersEnabled(const bool enabled)
 983 {
 984     if (enabled == isWebUICustomHTTPHeadersEnabled())
 985         return;
 986
 987     setValue(u"Preferences/WebUI/CustomHTTPHeadersEnabled"_s, enabled);
 988 }
 989
 990 QString Preferences::getWebUICustomHTTPHeaders() const
 991 {
 992     return value<QString>(u"Preferences/WebUI/CustomHTTPHeaders"_s);
 993 }
 994
 995 void Preferences::setWebUICustomHTTPHeaders(const QString &headers)
 996 {
 997     if (headers == getWebUICustomHTTPHeaders())
 998         return;
 999
1000     setValue(u"Preferences/WebUI/CustomHTTPHeaders"_s, headers);
1001 }
1002
1003 bool Preferences::isWebUIReverseProxySupportEnabled() const
1004 {
1005     return value(u"Preferences/WebUI/ReverseProxySupportEnabled"_s, false);
1006 }
1007
1008 void Preferences::setWebUIReverseProxySupportEnabled(const bool enabled)
1009 {
1010     if (enabled == isWebUIReverseProxySupportEnabled())
1011         return;
1012
1013     setValue(u"Preferences/WebUI/ReverseProxySupportEnabled"_s, enabled);
1014 }
1015
1016 QString Preferences::getWebUITrustedReverseProxiesList() const
1017 {
1018     return value<QString>(u"Preferences/WebUI/TrustedReverseProxiesList"_s);
1019 }
1020
1021 void Preferences::setWebUITrustedReverseProxiesList(const QString &addr)
1022 {
1023     if (addr == getWebUITrustedReverseProxiesList())
1024         return;
1025
1026     setValue(u"Preferences/WebUI/TrustedReverseProxiesList"_s, addr);
1027 }
1028
1029 bool Preferences::isDynDNSEnabled() const
1030 {
1031     return value(u"Preferences/DynDNS/Enabled"_s, false);
1032 }
1033
1034 void Preferences::setDynDNSEnabled(const bool enabled)
1035 {
1036     if (enabled == isDynDNSEnabled())
1037         return;
1038
1039     setValue(u"Preferences/DynDNS/Enabled"_s, enabled);
1040 }
1041
1042 DNS::Service Preferences::getDynDNSService() const
1043 {
1044     return value(u"Preferences/DynDNS/Service"_s, DNS::Service::DynDNS);
1045 }
1046
1047 void Preferences::setDynDNSService(const DNS::Service service)
1048 {
1049     if (service == getDynDNSService())
1050         return;
1051
1052     setValue(u"Preferences/DynDNS/Service"_s, service);
1053 }
1054
1055 QString Preferences::getDynDomainName() const
1056 {
1057     return value<QString>(u"Preferences/DynDNS/DomainName"_s, u"changeme.dyndns.org"_s);
1058 }
1059
1060 void Preferences::setDynDomainName(const QString &name)
1061 {
1062     if (name == getDynDomainName())
1063         return;
1064
1065     setValue(u"Preferences/DynDNS/DomainName"_s, name);
1066 }
1067
1068 QString Preferences::getDynDNSUsername() const
1069 {
1070     return value<QString>(u"Preferences/DynDNS/Username"_s);
1071 }
1072
1073 void Preferences::setDynDNSUsername(const QString &username)
1074 {
1075     if (username == getDynDNSUsername())
1076         return;
1077
1078     setValue(u"Preferences/DynDNS/Username"_s, username);
1079 }
1080
1081 QString Preferences::getDynDNSPassword() const
1082 {
1083     return value<QString>(u"Preferences/DynDNS/Password"_s);
1084 }
1085
1086 void Preferences::setDynDNSPassword(const QString &password)
1087 {
1088     if (password == getDynDNSPassword())
1089         return;
1090
1091     setValue(u"Preferences/DynDNS/Password"_s, password);
1092 }
1093
1094 // Advanced settings
1095 QByteArray Preferences::getUILockPassword() const
1096 {
1097     return value<QByteArray>(u"Locking/password_PBKDF2"_s);
1098 }
1099
1100 void Preferences::setUILockPassword(const QByteArray &password)
1101 {
1102     if (password == getUILockPassword())
1103         return;
1104
1105     setValue(u"Locking/password_PBKDF2"_s, password);
1106 }
1107
1108 bool Preferences::isUILocked() const
1109 {
1110     return value(u"Locking/locked"_s, false);
1111 }
1112
1113 void Preferences::setUILocked(const bool locked)
1114 {
1115     if (locked == isUILocked())
1116         return;
1117
1118     setValue(u"Locking/locked"_s, locked);
1119 }
1120
1121 bool Preferences::isAutoRunOnTorrentAddedEnabled() const
1122 {
1123     return value(u"AutoRun/OnTorrentAdded/Enabled"_s, false);
1124 }
1125
1126 void Preferences::setAutoRunOnTorrentAddedEnabled(const bool enabled)
1127 {
1128     if (enabled == isAutoRunOnTorrentAddedEnabled())
1129         return;
1130
1131     setValue(u"AutoRun/OnTorrentAdded/Enabled"_s, enabled);
1132 }
1133
1134 QString Preferences::getAutoRunOnTorrentAddedProgram() const
1135 {
1136     return value<QString>(u"AutoRun/OnTorrentAdded/Program"_s);
1137 }
1138
1139 void Preferences::setAutoRunOnTorrentAddedProgram(const QString &program)
1140 {
1141     if (program == getAutoRunOnTorrentAddedProgram())
1142         return;
1143
1144     setValue(u"AutoRun/OnTorrentAdded/Program"_s, program);
1145 }
1146
1147 bool Preferences::isAutoRunOnTorrentFinishedEnabled() const
1148 {
1149     return value(u"AutoRun/enabled"_s, false);
1150 }
1151
1152 void Preferences::setAutoRunOnTorrentFinishedEnabled(const bool enabled)
1153 {
1154     if (enabled == isAutoRunOnTorrentFinishedEnabled())
1155         return;
1156
1157     setValue(u"AutoRun/enabled"_s, enabled);
1158 }
1159
1160 QString Preferences::getAutoRunOnTorrentFinishedProgram() const
1161 {
1162     return value<QString>(u"AutoRun/program"_s);
1163 }
1164
1165 void Preferences::setAutoRunOnTorrentFinishedProgram(const QString &program)
1166 {
1167     if (program == getAutoRunOnTorrentFinishedProgram())
1168         return;
1169
1170     setValue(u"AutoRun/program"_s, program);
1171 }
1172
1173 #if defined(Q_OS_WIN)
1174 bool Preferences::isAutoRunConsoleEnabled() const
1175 {
1176     return value(u"AutoRun/ConsoleEnabled"_s, false);
1177 }
1178
1179 void Preferences::setAutoRunConsoleEnabled(const bool enabled)
1180 {
1181     if (enabled == isAutoRunConsoleEnabled())
1182         return;
1183
1184     setValue(u"AutoRun/ConsoleEnabled"_s, enabled);
1185 }
1186 #endif
1187
1188 bool Preferences::shutdownWhenDownloadsComplete() const
1189 {
1190     return value(u"Preferences/Downloads/AutoShutDownOnCompletion"_s, false);
1191 }
1192
1193 void Preferences::setShutdownWhenDownloadsComplete(const bool shutdown)
1194 {
1195     if (shutdown == shutdownWhenDownloadsComplete())
1196         return;
1197
1198     setValue(u"Preferences/Downloads/AutoShutDownOnCompletion"_s, shutdown);
1199 }
1200
1201 bool Preferences::suspendWhenDownloadsComplete() const
1202 {
1203     return value(u"Preferences/Downloads/AutoSuspendOnCompletion"_s, false);
1204 }
1205
1206 void Preferences::setSuspendWhenDownloadsComplete(const bool suspend)
1207 {
1208     if (suspend == suspendWhenDownloadsComplete())
1209         return;
1210
1211     setValue(u"Preferences/Downloads/AutoSuspendOnCompletion"_s, suspend);
1212 }
1213
1214 bool Preferences::hibernateWhenDownloadsComplete() const
1215 {
1216     return value(u"Preferences/Downloads/AutoHibernateOnCompletion"_s, false);
1217 }
1218
1219 void Preferences::setHibernateWhenDownloadsComplete(const bool hibernate)
1220 {
1221     if (hibernate == hibernateWhenDownloadsComplete())
1222         return;
1223
1224     setValue(u"Preferences/Downloads/AutoHibernateOnCompletion"_s, hibernate);
1225 }
1226
1227 bool Preferences::shutdownqBTWhenDownloadsComplete() const
1228 {
1229     return value(u"Preferences/Downloads/AutoShutDownqBTOnCompletion"_s, false);
1230 }
1231
1232 void Preferences::setShutdownqBTWhenDownloadsComplete(const bool shutdown)
1233 {
1234     if (shutdown == shutdownqBTWhenDownloadsComplete())
1235         return;
1236
1237     setValue(u"Preferences/Downloads/AutoShutDownqBTOnCompletion"_s, shutdown);
1238 }
1239
1240 bool Preferences::dontConfirmAutoExit() const
1241 {
1242     return value(u"ShutdownConfirmDlg/DontConfirmAutoExit"_s, false);
1243 }
1244
1245 void Preferences::setDontConfirmAutoExit(const bool dontConfirmAutoExit)
1246 {
1247     if (dontConfirmAutoExit == this->dontConfirmAutoExit())
1248         return;
1249
1250     setValue(u"ShutdownConfirmDlg/DontConfirmAutoExit"_s, dontConfirmAutoExit);
1251 }
1252
1253 bool Preferences::recheckTorrentsOnCompletion() const
1254 {
1255     return value(u"Preferences/Advanced/RecheckOnCompletion"_s, false);
1256 }
1257
1258 void Preferences::recheckTorrentsOnCompletion(const bool recheck)
1259 {
1260     if (recheck == recheckTorrentsOnCompletion())
1261         return;
1262
1263     setValue(u"Preferences/Advanced/RecheckOnCompletion"_s, recheck);
1264 }
1265
1266 bool Preferences::resolvePeerCountries() const
1267 {
1268     return value(u"Preferences/Connection/ResolvePeerCountries"_s, true);
1269 }
1270
1271 void Preferences::resolvePeerCountries(const bool resolve)
1272 {
1273     if (resolve == resolvePeerCountries())
1274         return;
1275
1276     setValue(u"Preferences/Connection/ResolvePeerCountries"_s, resolve);
1277 }
1278
1279 bool Preferences::resolvePeerHostNames() const
1280 {
1281     return value(u"Preferences/Connection/ResolvePeerHostNames"_s, false);
1282 }
1283
1284 void Preferences::resolvePeerHostNames(const bool resolve)
1285 {
1286     if (resolve == resolvePeerHostNames())
1287         return;
1288
1289     setValue(u"Preferences/Connection/ResolvePeerHostNames"_s, resolve);
1290 }
1291
1292 #if (defined(Q_OS_UNIX) && !defined(Q_OS_MACOS))
1293 bool Preferences::useSystemIcons() const
1294 {
1295     return value(u"Preferences/Advanced/useSystemIconTheme"_s, false);
1296 }
1297
1298 void Preferences::useSystemIcons(const bool enabled)
1299 {
1300     if (enabled == useSystemIcons())
1301         return;
1302
1303     setValue(u"Preferences/Advanced/useSystemIconTheme"_s, enabled);
1304 }
1305 #endif
1306
1307 bool Preferences::isRecursiveDownloadEnabled() const
1308 {
1309     return !value(u"Preferences/Advanced/DisableRecursiveDownload"_s, false);
1310 }
1311
1312 void Preferences::setRecursiveDownloadEnabled(const bool enable)
1313 {
1314     if (enable == isRecursiveDownloadEnabled())
1315         return;
1316
1317     setValue(u"Preferences/Advanced/DisableRecursiveDownload"_s, !enable);
1318 }
1319
1320 int Preferences::getTrackerPort() const
1321 {
1322     return value<int>(u"Preferences/Advanced/trackerPort"_s, 9000);
1323 }
1324
1325 void Preferences::setTrackerPort(const int port)
1326 {
1327     if (port == getTrackerPort())
1328         return;
1329
1330     setValue(u"Preferences/Advanced/trackerPort"_s, port);
1331 }
1332
1333 bool Preferences::isTrackerPortForwardingEnabled() const
1334 {
1335     return value(u"Preferences/Advanced/trackerPortForwarding"_s, false);
1336 }
1337
1338 void Preferences::setTrackerPortForwardingEnabled(const bool enabled)
1339 {
1340     if (enabled == isTrackerPortForwardingEnabled())
1341         return;
1342
1343     setValue(u"Preferences/Advanced/trackerPortForwarding"_s, enabled);
1344 }
1345
1346 bool Preferences::isMarkOfTheWebEnabled() const
1347 {
1348     return value(u"Preferences/Advanced/markOfTheWeb"_s, true);
1349 }
1350
1351 void Preferences::setMarkOfTheWebEnabled(const bool enabled)
1352 {
1353     if (enabled == isMarkOfTheWebEnabled())
1354         return;
1355
1356     setValue(u"Preferences/Advanced/markOfTheWeb"_s, enabled);
1357 }
1358
1359 bool Preferences::isIgnoreSSLErrors() const
1360 {
1361     return value(u"Preferences/Advanced/IgnoreSSLErrors"_s, false);
1362 }
1363
1364 void Preferences::setIgnoreSSLErrors(const bool enabled)
1365 {
1366     if (enabled == isIgnoreSSLErrors())
1367         return;
1368
1369     setValue(u"Preferences/Advanced/IgnoreSSLErrors"_s, enabled);
1370 }
1371
1372 Path Preferences::getPythonExecutablePath() const
1373 {
1374     return value(u"Preferences/Search/pythonExecutablePath"_s, Path());
1375 }
1376
1377 void Preferences::setPythonExecutablePath(const Path &path)
1378 {
1379     if (path == getPythonExecutablePath())
1380         return;
1381
1382     setValue(u"Preferences/Search/pythonExecutablePath"_s, path);
1383 }
1384
1385 #if defined(Q_OS_WIN) || defined(Q_OS_MACOS)
1386 bool Preferences::isUpdateCheckEnabled() const
1387 {
1388     return value(u"Preferences/Advanced/updateCheck"_s, true);
1389 }
1390
1391 void Preferences::setUpdateCheckEnabled(const bool enabled)
1392 {
1393     if (enabled == isUpdateCheckEnabled())
1394         return;
1395
1396     setValue(u"Preferences/Advanced/updateCheck"_s, enabled);
1397 }
1398 #endif
1399
1400 bool Preferences::confirmTorrentDeletion() const
1401 {
1402     return value(u"Preferences/Advanced/confirmTorrentDeletion"_s, true);
1403 }
1404
1405 void Preferences::setConfirmTorrentDeletion(const bool enabled)
1406 {
1407     if (enabled == confirmTorrentDeletion())
1408         return;
1409
1410     setValue(u"Preferences/Advanced/confirmTorrentDeletion"_s, enabled);
1411 }
1412
1413 bool Preferences::confirmTorrentRecheck() const
1414 {
1415     return value(u"Preferences/Advanced/confirmTorrentRecheck"_s, true);
1416 }
1417
1418 void Preferences::setConfirmTorrentRecheck(const bool enabled)
1419 {
1420     if (enabled == confirmTorrentRecheck())
1421         return;
1422
1423     setValue(u"Preferences/Advanced/confirmTorrentRecheck"_s, enabled);
1424 }
1425
1426 bool Preferences::confirmRemoveAllTags() const
1427 {
1428     return value(u"Preferences/Advanced/confirmRemoveAllTags"_s, true);
1429 }
1430
1431 void Preferences::setConfirmRemoveAllTags(const bool enabled)
1432 {
1433     if (enabled == confirmRemoveAllTags())
1434         return;
1435
1436     setValue(u"Preferences/Advanced/confirmRemoveAllTags"_s, enabled);
1437 }
1438
1439 bool Preferences::confirmMergeTrackers() const
1440 {
1441     return value(u"GUI/ConfirmActions/MergeTrackers"_s, true);
1442 }
1443
1444 void Preferences::setConfirmMergeTrackers(const bool enabled)
1445 {
1446     if (enabled == confirmMergeTrackers())
1447         return;
1448
1449     setValue(u"GUI/ConfirmActions/MergeTrackers"_s, enabled);
1450 }
1451
1452 bool Preferences::confirmRemoveTrackerFromAllTorrents() const
1453 {
1454     return value(u"GUI/ConfirmActions/RemoveTrackerFromAllTorrents"_s, true);
1455 }
1456
1457 void Preferences::setConfirmRemoveTrackerFromAllTorrents(const bool enabled)
1458 {
1459     if (enabled == confirmRemoveTrackerFromAllTorrents())
1460         return;
1461
1462     setValue(u"GUI/ConfirmActions/RemoveTrackerFromAllTorrents"_s, enabled);
1463 }
1464
1465 #ifndef Q_OS_MACOS
1466 TrayIcon::Style Preferences::trayIconStyle() const
1467 {
1468     return value(u"Preferences/Advanced/TrayIconStyle"_s, TrayIcon::Style::Normal);
1469 }
1470
1471 void Preferences::setTrayIconStyle(const TrayIcon::Style style)
1472 {
1473     if (style == trayIconStyle())
1474         return;
1475
1476     setValue(u"Preferences/Advanced/TrayIconStyle"_s, style);
1477 }
1478 #endif
1479
1480 // Stuff that don't appear in the Options GUI but are saved
1481 // in the same file.
1482
1483 QDateTime Preferences::getDNSLastUpd() const
1484 {
1485     return value<QDateTime>(u"DNSUpdater/lastUpdateTime"_s);
1486 }
1487
1488 void Preferences::setDNSLastUpd(const QDateTime &date)
1489 {
1490     if (date == getDNSLastUpd())
1491         return;
1492
1493     setValue(u"DNSUpdater/lastUpdateTime"_s, date);
1494 }
1495
1496 QString Preferences::getDNSLastIP() const
1497 {
1498     return value<QString>(u"DNSUpdater/lastIP"_s);
1499 }
1500
1501 void Preferences::setDNSLastIP(const QString &ip)
1502 {
1503     if (ip == getDNSLastIP())
1504         return;
1505
1506     setValue(u"DNSUpdater/lastIP"_s, ip);
1507 }
1508
1509 QByteArray Preferences::getMainGeometry() const
1510 {
1511     return value<QByteArray>(u"MainWindow/geometry"_s);
1512 }
1513
1514 void Preferences::setMainGeometry(const QByteArray &geometry)
1515 {
1516     if (geometry == getMainGeometry())
1517         return;
1518
1519     setValue(u"MainWindow/geometry"_s, geometry);
1520 }
1521
1522 bool Preferences::isFiltersSidebarVisible() const
1523 {
1524     return value(u"GUI/MainWindow/FiltersSidebarVisible"_s, true);
1525 }
1526
1527 void Preferences::setFiltersSidebarVisible(const bool value)
1528 {
1529     if (value == isFiltersSidebarVisible())
1530         return;
1531
1532     setValue(u"GUI/MainWindow/FiltersSidebarVisible"_s, value);
1533 }
1534
1535 int Preferences::getFiltersSidebarWidth() const
1536 {
1537     return value(u"GUI/MainWindow/FiltersSidebarWidth"_s, 120);
1538 }
1539
1540 void Preferences::setFiltersSidebarWidth(const int value)
1541 {
1542     if (value == getFiltersSidebarWidth())
1543         return;
1544
1545     setValue(u"GUI/MainWindow/FiltersSidebarWidth"_s, value);
1546 }
1547
1548 Path Preferences::getMainLastDir() const
1549 {
1550     return value(u"MainWindow/LastDir"_s, Utils::Fs::homePath());
1551 }
1552
1553 void Preferences::setMainLastDir(const Path &path)
1554 {
1555     if (path == getMainLastDir())
1556         return;
1557
1558     setValue(u"MainWindow/LastDir"_s, path);
1559 }
1560
1561 QByteArray Preferences::getPeerListState() const
1562 {
1563     return value<QByteArray>(u"GUI/Qt6/TorrentProperties/PeerListState"_s);
1564 }
1565
1566 void Preferences::setPeerListState(const QByteArray &state)
1567 {
1568     if (state == getPeerListState())
1569         return;
1570
1571     setValue(u"GUI/Qt6/TorrentProperties/PeerListState"_s, state);
1572 }
1573
1574 QString Preferences::getPropSplitterSizes() const
1575 {
1576     return value<QString>(u"TorrentProperties/SplitterSizes"_s);
1577 }
1578
1579 void Preferences::setPropSplitterSizes(const QString &sizes)
1580 {
1581     if (sizes == getPropSplitterSizes())
1582         return;
1583
1584     setValue(u"TorrentProperties/SplitterSizes"_s, sizes);
1585 }
1586
1587 QByteArray Preferences::getPropFileListState() const
1588 {
1589     return value<QByteArray>(u"GUI/Qt6/TorrentProperties/FilesListState"_s);
1590 }
1591
1592 void Preferences::setPropFileListState(const QByteArray &state)
1593 {
1594     if (state == getPropFileListState())
1595         return;
1596
1597     setValue(u"GUI/Qt6/TorrentProperties/FilesListState"_s, state);
1598 }
1599
1600 int Preferences::getPropCurTab() const
1601 {
1602     return value<int>(u"TorrentProperties/CurrentTab"_s, -1);
1603 }
1604
1605 void Preferences::setPropCurTab(const int tab)
1606 {
1607     if (tab == getPropCurTab())
1608         return;
1609
1610     setValue(u"TorrentProperties/CurrentTab"_s, tab);
1611 }
1612
1613 bool Preferences::getPropVisible() const
1614 {
1615     return value(u"TorrentProperties/Visible"_s, false);
1616 }
1617
1618 void Preferences::setPropVisible(const bool visible)
1619 {
1620     if (visible == getPropVisible())
1621         return;
1622
1623     setValue(u"TorrentProperties/Visible"_s, visible);
1624 }
1625
1626 QByteArray Preferences::getTrackerListState() const
1627 {
1628     return value<QByteArray>(u"GUI/Qt6/TorrentProperties/TrackerListState"_s);
1629 }
1630
1631 void Preferences::setTrackerListState(const QByteArray &state)
1632 {
1633     if (state == getTrackerListState())
1634         return;
1635
1636     setValue(u"GUI/Qt6/TorrentProperties/TrackerListState"_s, state);
1637 }
1638
1639 QStringList Preferences::getRssOpenFolders() const
1640 {
1641     return value<QStringList>(u"GUI/RSSWidget/OpenedFolders"_s);
1642 }
1643
1644 void Preferences::setRssOpenFolders(const QStringList &folders)
1645 {
1646     if (folders == getRssOpenFolders())
1647         return;
1648
1649     setValue(u"GUI/RSSWidget/OpenedFolders"_s, folders);
1650 }
1651
1652 QByteArray Preferences::getRssSideSplitterState() const
1653 {
1654     return value<QByteArray>(u"GUI/Qt6/RSSWidget/SideSplitterState"_s);
1655 }
1656
1657 void Preferences::setRssSideSplitterState(const QByteArray &state)
1658 {
1659     if (state == getRssSideSplitterState())
1660         return;
1661
1662     setValue(u"GUI/Qt6/RSSWidget/SideSplitterState"_s, state);
1663 }
1664
1665 QByteArray Preferences::getRssMainSplitterState() const
1666 {
1667     return value<QByteArray>(u"GUI/Qt6/RSSWidget/MainSplitterState"_s);
1668 }
1669
1670 void Preferences::setRssMainSplitterState(const QByteArray &state)
1671 {
1672     if (state == getRssMainSplitterState())
1673         return;
1674
1675     setValue(u"GUI/Qt6/RSSWidget/MainSplitterState"_s, state);
1676 }
1677
1678 QByteArray Preferences::getSearchTabHeaderState() const
1679 {
1680     return value<QByteArray>(u"GUI/Qt6/SearchTab/HeaderState"_s);
1681 }
1682
1683 void Preferences::setSearchTabHeaderState(const QByteArray &state)
1684 {
1685     if (state == getSearchTabHeaderState())
1686         return;
1687
1688     setValue(u"GUI/Qt6/SearchTab/HeaderState"_s, state);
1689 }
1690
1691 bool Preferences::getRegexAsFilteringPatternForSearchJob() const
1692 {
1693     return value(u"SearchTab/UseRegexAsFilteringPattern"_s, false);
1694 }
1695
1696 void Preferences::setRegexAsFilteringPatternForSearchJob(const bool checked)
1697 {
1698     if (checked == getRegexAsFilteringPatternForSearchJob())
1699         return;
1700
1701     setValue(u"SearchTab/UseRegexAsFilteringPattern"_s, checked);
1702 }
1703
1704 QStringList Preferences::getSearchEngDisabled() const
1705 {
1706     return value<QStringList>(u"SearchEngines/disabledEngines"_s);
1707 }
1708
1709 void Preferences::setSearchEngDisabled(const QStringList &engines)
1710 {
1711     if (engines == getSearchEngDisabled())
1712         return;
1713
1714     setValue(u"SearchEngines/disabledEngines"_s, engines);
1715 }
1716
1717 QString Preferences::getTorImportLastContentDir() const
1718 {
1719     return value(u"TorrentImport/LastContentDir"_s, QDir::homePath());
1720 }
1721
1722 void Preferences::setTorImportLastContentDir(const QString &path)
1723 {
1724     if (path == getTorImportLastContentDir())
1725         return;
1726
1727     setValue(u"TorrentImport/LastContentDir"_s, path);
1728 }
1729
1730 QByteArray Preferences::getTorImportGeometry() const
1731 {
1732     return value<QByteArray>(u"TorrentImportDlg/dimensions"_s);
1733 }
1734
1735 void Preferences::setTorImportGeometry(const QByteArray &geometry)
1736 {
1737     if (geometry == getTorImportGeometry())
1738         return;
1739
1740     setValue(u"TorrentImportDlg/dimensions"_s, geometry);
1741 }
1742
1743 bool Preferences::getStatusFilterState() const
1744 {
1745     return value(u"TransferListFilters/statusFilterState"_s, true);
1746 }
1747
1748 void Preferences::setStatusFilterState(const bool checked)
1749 {
1750     if (checked == getStatusFilterState())
1751         return;
1752
1753     setValue(u"TransferListFilters/statusFilterState"_s, checked);
1754 }
1755
1756 bool Preferences::getCategoryFilterState() const
1757 {
1758     return value(u"TransferListFilters/CategoryFilterState"_s, true);
1759 }
1760
1761 void Preferences::setCategoryFilterState(const bool checked)
1762 {
1763     if (checked == getCategoryFilterState())
1764         return;
1765
1766     setValue(u"TransferListFilters/CategoryFilterState"_s, checked);
1767 }
1768
1769 bool Preferences::getTagFilterState() const
1770 {
1771     return value(u"TransferListFilters/TagFilterState"_s, true);
1772 }
1773
1774 void Preferences::setTagFilterState(const bool checked)
1775 {
1776     if (checked == getTagFilterState())
1777         return;
1778
1779     setValue(u"TransferListFilters/TagFilterState"_s, checked);
1780 }
1781
1782 bool Preferences::getTrackerFilterState() const
1783 {
1784     return value(u"TransferListFilters/trackerFilterState"_s, true);
1785 }
1786
1787 void Preferences::setTrackerFilterState(const bool checked)
1788 {
1789     if (checked == getTrackerFilterState())
1790         return;
1791
1792     setValue(u"TransferListFilters/trackerFilterState"_s, checked);
1793 }
1794
1795 int Preferences::getTransSelFilter() const
1796 {
1797     return value<int>(u"TransferListFilters/selectedFilterIndex"_s, 0);
1798 }
1799
1800 void Preferences::setTransSelFilter(const int index)
1801 {
1802     if (index == getTransSelFilter())
1803         return;
1804
1805     setValue(u"TransferListFilters/selectedFilterIndex"_s, index);
1806 }
1807
1808 bool Preferences::getHideZeroStatusFilters() const
1809 {
1810     return value<bool>(u"TransferListFilters/HideZeroStatusFilters"_s, false);
1811 }
1812
1813 void Preferences::setHideZeroStatusFilters(const bool hide)
1814 {
1815     if (hide == getHideZeroStatusFilters())
1816         return;
1817
1818     setValue(u"TransferListFilters/HideZeroStatusFilters"_s, hide);
1819 }
1820
1821 QByteArray Preferences::getTransHeaderState() const
1822 {
1823     return value<QByteArray>(u"GUI/Qt6/TransferList/HeaderState"_s);
1824 }
1825
1826 void Preferences::setTransHeaderState(const QByteArray &state)
1827 {
1828     if (state == getTransHeaderState())
1829         return;
1830
1831     setValue(u"GUI/Qt6/TransferList/HeaderState"_s, state);
1832 }
1833
1834 bool Preferences::getRegexAsFilteringPatternForTransferList() const
1835 {
1836     return value(u"TransferList/UseRegexAsFilteringPattern"_s, false);
1837 }
1838
1839 void Preferences::setRegexAsFilteringPatternForTransferList(const bool checked)
1840 {
1841     if (checked == getRegexAsFilteringPatternForTransferList())
1842         return;
1843
1844     setValue(u"TransferList/UseRegexAsFilteringPattern"_s, checked);
1845 }
1846
1847 // From old RssSettings class
1848 bool Preferences::isRSSWidgetEnabled() const
1849 {
1850     return value(u"GUI/RSSWidget/Enabled"_s, false);
1851 }
1852
1853 void Preferences::setRSSWidgetVisible(const bool enabled)
1854 {
1855     if (enabled == isRSSWidgetEnabled())
1856         return;
1857
1858     setValue(u"GUI/RSSWidget/Enabled"_s, enabled);
1859 }
1860
1861 int Preferences::getToolbarTextPosition() const
1862 {
1863     return value<int>(u"Toolbar/textPosition"_s, -1);
1864 }
1865
1866 void Preferences::setToolbarTextPosition(const int position)
1867 {
1868     if (position == getToolbarTextPosition())
1869         return;
1870
1871     setValue(u"Toolbar/textPosition"_s, position);
1872 }
1873
1874 QList<QNetworkCookie> Preferences::getNetworkCookies() const
1875 {
1876     const auto rawCookies = value<QStringList>(u"Network/Cookies"_s);
1877     QList<QNetworkCookie> cookies;
1878     cookies.reserve(rawCookies.size());
1879     for (const QString &rawCookie : rawCookies)
1880         cookies << QNetworkCookie::parseCookies(rawCookie.toUtf8());
1881     return cookies;
1882 }
1883
1884 void Preferences::setNetworkCookies(const QList<QNetworkCookie> &cookies)
1885 {
1886     QStringList rawCookies;
1887     rawCookies.reserve(cookies.size());
1888     for (const QNetworkCookie &cookie : cookies)
1889         rawCookies << QString::fromLatin1(cookie.toRawForm());
1890     setValue(u"Network/Cookies"_s, rawCookies);
1891 }
1892
1893 bool Preferences::useProxyForBT() const
1894 {
1895     return value<bool>(u"Network/Proxy/Profiles/BitTorrent"_s);
1896 }
1897
1898 void Preferences::setUseProxyForBT(const bool value)
1899 {
1900     if (value == useProxyForBT())
1901         return;
1902
1903     setValue(u"Network/Proxy/Profiles/BitTorrent"_s, value);
1904 }
1905
1906 bool Preferences::useProxyForRSS() const
1907 {
1908     return value<bool>(u"Network/Proxy/Profiles/RSS"_s);
1909 }
1910
1911 void Preferences::setUseProxyForRSS(const bool value)
1912 {
1913     if (value == useProxyForRSS())
1914         return;
1915
1916     setValue(u"Network/Proxy/Profiles/RSS"_s, value);
1917 }
1918
1919 bool Preferences::useProxyForGeneralPurposes() const
1920 {
1921     return value<bool>(u"Network/Proxy/Profiles/Misc"_s);
1922 }
1923
1924 void Preferences::setUseProxyForGeneralPurposes(const bool value)
1925 {
1926     if (value == useProxyForGeneralPurposes())
1927         return;
1928
1929     setValue(u"Network/Proxy/Profiles/Misc"_s, value);
1930 }
1931
1932 bool Preferences::isSpeedWidgetEnabled() const
1933 {
1934     return value(u"SpeedWidget/Enabled"_s, true);
1935 }
1936
1937 void Preferences::setSpeedWidgetEnabled(const bool enabled)
1938 {
1939     if (enabled == isSpeedWidgetEnabled())
1940         return;
1941
1942     setValue(u"SpeedWidget/Enabled"_s, enabled);
1943 }
1944
1945 int Preferences::getSpeedWidgetPeriod() const
1946 {
1947     return value<int>(u"SpeedWidget/period"_s, 1);
1948 }
1949
1950 void Preferences::setSpeedWidgetPeriod(const int period)
1951 {
1952     if (period == getSpeedWidgetPeriod())
1953         return;
1954
1955     setValue(u"SpeedWidget/period"_s, period);
1956 }
1957
1958 bool Preferences::getSpeedWidgetGraphEnable(const int id) const
1959 {
1960     // UP and DOWN graphs enabled by default
1961     return value(u"SpeedWidget/graph_enable_%1"_s.arg(id), ((id == 0) || (id == 1)));
1962 }
1963
1964 void Preferences::setSpeedWidgetGraphEnable(const int id, const bool enable)
1965 {
1966     if (enable == getSpeedWidgetGraphEnable(id))
1967         return;
1968
1969     setValue(u"SpeedWidget/graph_enable_%1"_s.arg(id), enable);
1970 }
1971
1972 bool Preferences::isAddNewTorrentDialogEnabled() const
1973 {
1974     return value(u"AddNewTorrentDialog/Enabled"_s, true);
1975 }
1976
1977 void Preferences::setAddNewTorrentDialogEnabled(const bool value)
1978 {
1979     if (value == isAddNewTorrentDialogEnabled())
1980         return;
1981
1982     setValue(u"AddNewTorrentDialog/Enabled"_s, value);
1983 }
1984
1985 bool Preferences::isAddNewTorrentDialogTopLevel() const
1986 {
1987     return value(u"AddNewTorrentDialog/TopLevel"_s, true);
1988 }
1989
1990 void Preferences::setAddNewTorrentDialogTopLevel(const bool value)
1991 {
1992     if (value == isAddNewTorrentDialogTopLevel())
1993         return;
1994
1995     setValue(u"AddNewTorrentDialog/TopLevel"_s, value);
1996 }
1997
1998 int Preferences::addNewTorrentDialogSavePathHistoryLength() const
1999 {
2000     const int defaultHistoryLength = 8;
2001
2002     const int val = value(u"AddNewTorrentDialog/SavePathHistoryLength"_s, defaultHistoryLength);
2003     return std::clamp(val, 0, 99);
2004 }
2005
2006 void Preferences::setAddNewTorrentDialogSavePathHistoryLength(const int value)
2007 {
2008     const int clampedValue = std::clamp(value, 0, 99);
2009     const int oldValue = addNewTorrentDialogSavePathHistoryLength();
2010     if (clampedValue == oldValue)
2011         return;
2012
2013     setValue(u"AddNewTorrentDialog/SavePathHistoryLength"_s, clampedValue);
2014 }
2015
2016 void Preferences::apply()
2017 {
2018     if (SettingsStorage::instance()->save())
2019         emit changed();
2020 }