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 <chrono>
  33
  34 #ifdef Q_OS_MACOS
  35 #include <CoreServices/CoreServices.h>
  36 #endif
  37 #ifdef Q_OS_WIN
  38 #include <shlobj.h>
  39 #endif
  40
  41 #include <QCoreApplication>
  42 #include <QDateTime>
  43 #include <QDir>
  44 #include <QList>
  45 #include <QLocale>
  46 #include <QNetworkCookie>
  47 #include <QSettings>
  48 #include <QSize>
  49 #include <QTime>
  50 #include <QVariant>
  51
  52 #ifdef Q_OS_WIN
  53 #include <QRegularExpression>
  54 #endif
  55
  56 #include "algorithm.h"
  57 #include "global.h"
  58 #include "profile.h"
  59 #include "settingsstorage.h"
  60 #include "utils/fs.h"
  61
  62 namespace
  63 {
  64 #ifdef Q_OS_WIN
  65     QString makeProfileID(const QString &profilePath, const QString &profileName)
  66     {
  67         return profilePath.isEmpty()
  68                 ? profileName
  69                 : profileName + QLatin1Char('@') + Utils::Fs::toValidFileSystemName(profilePath, false, {});
  70     }
  71 #endif
  72 }
  73
  74 Preferences *Preferences::m_instance = nullptr;
  75
  76 Preferences::Preferences() = default;
  77
  78 Preferences *Preferences::instance()
  79 {
  80     return m_instance;
  81 }
  82
  83 void Preferences::initInstance()
  84 {
  85     if (!m_instance)
  86         m_instance = new Preferences;
  87 }
  88
  89 void Preferences::freeInstance()
  90 {
  91     delete m_instance;
  92     m_instance = nullptr;
  93 }
  94
  95 QVariant Preferences::value(const QString &key, const QVariant &defaultValue) const
  96 {
  97     return SettingsStorage::instance()->loadValue(key, defaultValue);
  98 }
  99
 100 void Preferences::setValue(const QString &key, const QVariant &value)
 101 {
 102     SettingsStorage::instance()->storeValue(key, value);
 103 }
 104
 105 // General options
 106 QString Preferences::getLocale() const
 107 {
 108     const QString localeName = value("Preferences/General/Locale").toString();
 109     return (localeName.isEmpty() ? QLocale::system().name() : localeName);
 110 }
 111
 112 void Preferences::setLocale(const QString &locale)
 113 {
 114     setValue("Preferences/General/Locale", locale);
 115 }
 116
 117 bool Preferences::useCustomUITheme() const
 118 {
 119     return value("Preferences/General/UseCustomUITheme", false).toBool()
 120            && !customUIThemePath().isEmpty();
 121 }
 122
 123 void Preferences::setUseCustomUITheme(const bool use)
 124 {
 125     setValue("Preferences/General/UseCustomUITheme", use);
 126 }
 127
 128 QString Preferences::customUIThemePath() const
 129 {
 130     return value("Preferences/General/CustomUIThemePath").toString();
 131 }
 132
 133 void Preferences::setCustomUIThemePath(const QString &path)
 134 {
 135     setValue("Preferences/General/CustomUIThemePath", path);
 136 }
 137
 138 bool Preferences::deleteTorrentFilesAsDefault() const
 139 {
 140     return value("Preferences/General/DeleteTorrentsFilesAsDefault", false).toBool();
 141 }
 142
 143 void Preferences::setDeleteTorrentFilesAsDefault(const bool del)
 144 {
 145     setValue("Preferences/General/DeleteTorrentsFilesAsDefault", del);
 146 }
 147
 148 bool Preferences::confirmOnExit() const
 149 {
 150     return value("Preferences/General/ExitConfirm", true).toBool();
 151 }
 152
 153 void Preferences::setConfirmOnExit(const bool confirm)
 154 {
 155     setValue("Preferences/General/ExitConfirm", confirm);
 156 }
 157
 158 bool Preferences::speedInTitleBar() const
 159 {
 160     return value("Preferences/General/SpeedInTitleBar", false).toBool();
 161 }
 162
 163 void Preferences::showSpeedInTitleBar(const bool show)
 164 {
 165     setValue("Preferences/General/SpeedInTitleBar", show);
 166 }
 167
 168 bool Preferences::useAlternatingRowColors() const
 169 {
 170     return value("Preferences/General/AlternatingRowColors", true).toBool();
 171 }
 172
 173 void Preferences::setAlternatingRowColors(const bool b)
 174 {
 175     setValue("Preferences/General/AlternatingRowColors", b);
 176 }
 177
 178 bool Preferences::getHideZeroValues() const
 179 {
 180     return value("Preferences/General/HideZeroValues", false).toBool();
 181 }
 182
 183 void Preferences::setHideZeroValues(const bool b)
 184 {
 185     setValue("Preferences/General/HideZeroValues", b);
 186 }
 187
 188 int Preferences::getHideZeroComboValues() const
 189 {
 190     return value("Preferences/General/HideZeroComboValues", 0).toInt();
 191 }
 192
 193 void Preferences::setHideZeroComboValues(const int n)
 194 {
 195     setValue("Preferences/General/HideZeroComboValues", n);
 196 }
 197
 198 // In Mac OS X the dock is sufficient for our needs so we disable the sys tray functionality.
 199 // See extensive discussion in https://github.com/qbittorrent/qBittorrent/pull/3018
 200 #ifndef Q_OS_MACOS
 201 bool Preferences::systrayIntegration() const
 202 {
 203     return value("Preferences/General/SystrayEnabled", true).toBool();
 204 }
 205
 206 void Preferences::setSystrayIntegration(const bool enabled)
 207 {
 208     setValue("Preferences/General/SystrayEnabled", enabled);
 209 }
 210
 211 bool Preferences::minimizeToTray() const
 212 {
 213     return value("Preferences/General/MinimizeToTray", false).toBool();
 214 }
 215
 216 void Preferences::setMinimizeToTray(const bool b)
 217 {
 218     setValue("Preferences/General/MinimizeToTray", b);
 219 }
 220
 221 bool Preferences::minimizeToTrayNotified() const
 222 {
 223     return value("Preferences/General/MinimizeToTrayNotified", false).toBool();
 224 }
 225
 226 void Preferences::setMinimizeToTrayNotified(const bool b)
 227 {
 228     setValue("Preferences/General/MinimizeToTrayNotified", b);
 229 }
 230
 231 bool Preferences::closeToTray() const
 232 {
 233     return value("Preferences/General/CloseToTray", true).toBool();
 234 }
 235
 236 void Preferences::setCloseToTray(const bool b)
 237 {
 238     setValue("Preferences/General/CloseToTray", b);
 239 }
 240
 241 bool Preferences::closeToTrayNotified() const
 242 {
 243     return value("Preferences/General/CloseToTrayNotified", false).toBool();
 244 }
 245
 246 void Preferences::setCloseToTrayNotified(const bool b)
 247 {
 248     setValue("Preferences/General/CloseToTrayNotified", b);
 249 }
 250
 251 bool Preferences::iconsInMenusEnabled() const
 252 {
 253     return value("Preferences/Advanced/EnableIconsInMenus", true).toBool();
 254 }
 255
 256 void Preferences::setIconsInMenusEnabled(const bool enable)
 257 {
 258     setValue("Preferences/Advanced/EnableIconsInMenus", enable);
 259 }
 260 #endif // Q_OS_MACOS
 261
 262 bool Preferences::isToolbarDisplayed() const
 263 {
 264     return value("Preferences/General/ToolbarDisplayed", true).toBool();
 265 }
 266
 267 void Preferences::setToolbarDisplayed(const bool displayed)
 268 {
 269     setValue("Preferences/General/ToolbarDisplayed", displayed);
 270 }
 271
 272 bool Preferences::isStatusbarDisplayed() const
 273 {
 274     return value("Preferences/General/StatusbarDisplayed", true).toBool();
 275 }
 276
 277 void Preferences::setStatusbarDisplayed(const bool displayed)
 278 {
 279     setValue("Preferences/General/StatusbarDisplayed", displayed);
 280 }
 281
 282 bool Preferences::startMinimized() const
 283 {
 284     return value("Preferences/General/StartMinimized", false).toBool();
 285 }
 286
 287 void Preferences::setStartMinimized(const bool b)
 288 {
 289     setValue("Preferences/General/StartMinimized", b);
 290 }
 291
 292 bool Preferences::isSplashScreenDisabled() const
 293 {
 294     return value("Preferences/General/NoSplashScreen", true).toBool();
 295 }
 296
 297 void Preferences::setSplashScreenDisabled(const bool b)
 298 {
 299     setValue("Preferences/General/NoSplashScreen", b);
 300 }
 301
 302 // Preventing from system suspend while active torrents are presented.
 303 bool Preferences::preventFromSuspendWhenDownloading() const
 304 {
 305     return value("Preferences/General/PreventFromSuspendWhenDownloading", false).toBool();
 306 }
 307
 308 void Preferences::setPreventFromSuspendWhenDownloading(const bool b)
 309 {
 310     setValue("Preferences/General/PreventFromSuspendWhenDownloading", b);
 311 }
 312
 313 bool Preferences::preventFromSuspendWhenSeeding() const
 314 {
 315     return value("Preferences/General/PreventFromSuspendWhenSeeding", false).toBool();
 316 }
 317
 318 void Preferences::setPreventFromSuspendWhenSeeding(const bool b)
 319 {
 320     setValue("Preferences/General/PreventFromSuspendWhenSeeding", b);
 321 }
 322
 323 #ifdef Q_OS_WIN
 324 bool Preferences::WinStartup() const
 325 {
 326     const QString profileName = Profile::instance()->profileName();
 327     const QString profilePath = Profile::instance()->rootPath();
 328     const QString profileID = makeProfileID(profilePath, profileName);
 329     const QSettings settings {"HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run", QSettings::NativeFormat};
 330
 331     return settings.contains(profileID);
 332 }
 333
 334 void Preferences::setWinStartup(const bool b)
 335 {
 336     const QString profileName = Profile::instance()->profileName();
 337     const QString profilePath = Profile::instance()->rootPath();
 338     const QString profileID = makeProfileID(profilePath, profileName);
 339     QSettings settings {"HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run", QSettings::NativeFormat};
 340     if (b)
 341     {
 342         const QString configuration = Profile::instance()->configurationName();
 343
 344         const auto cmd = QString::fromLatin1(R"("%1" "--profile=%2" "--configuration=%3")")
 345                 .arg(Utils::Fs::toNativePath(qApp->applicationFilePath()), profilePath, configuration);
 346         settings.setValue(profileID, cmd);
 347     }
 348     else
 349     {
 350         settings.remove(profileID);
 351     }
 352 }
 353 #endif // Q_OS_WIN
 354
 355 // Downloads
 356 QString Preferences::lastLocationPath() const
 357 {
 358     return Utils::Fs::toUniformPath(value("Preferences/Downloads/LastLocationPath").toString());
 359 }
 360
 361 void Preferences::setLastLocationPath(const QString &path)
 362 {
 363     setValue("Preferences/Downloads/LastLocationPath", Utils::Fs::toUniformPath(path));
 364 }
 365
 366 QString Preferences::getScanDirsLastPath() const
 367 {
 368     return Utils::Fs::toUniformPath(value("Preferences/Downloads/ScanDirsLastPath").toString());
 369 }
 370
 371 void Preferences::setScanDirsLastPath(const QString &path)
 372 {
 373     setValue("Preferences/Downloads/ScanDirsLastPath", Utils::Fs::toUniformPath(path));
 374 }
 375
 376 bool Preferences::isMailNotificationEnabled() const
 377 {
 378     return value("Preferences/MailNotification/enabled", false).toBool();
 379 }
 380
 381 void Preferences::setMailNotificationEnabled(const bool enabled)
 382 {
 383     setValue("Preferences/MailNotification/enabled", enabled);
 384 }
 385
 386 QString Preferences::getMailNotificationSender() const
 387 {
 388     return value("Preferences/MailNotification/sender", "qBittorrent_notification@example.com").toString();
 389 }
 390
 391 void Preferences::setMailNotificationSender(const QString &mail)
 392 {
 393     setValue("Preferences/MailNotification/sender", mail);
 394 }
 395
 396 QString Preferences::getMailNotificationEmail() const
 397 {
 398     return value("Preferences/MailNotification/email").toString();
 399 }
 400
 401 void Preferences::setMailNotificationEmail(const QString &mail)
 402 {
 403     setValue("Preferences/MailNotification/email", mail);
 404 }
 405
 406 QString Preferences::getMailNotificationSMTP() const
 407 {
 408     return value("Preferences/MailNotification/smtp_server", "smtp.changeme.com").toString();
 409 }
 410
 411 void Preferences::setMailNotificationSMTP(const QString &smtp_server)
 412 {
 413     setValue("Preferences/MailNotification/smtp_server", smtp_server);
 414 }
 415
 416 bool Preferences::getMailNotificationSMTPSSL() const
 417 {
 418     return value("Preferences/MailNotification/req_ssl", false).toBool();
 419 }
 420
 421 void Preferences::setMailNotificationSMTPSSL(const bool use)
 422 {
 423     setValue("Preferences/MailNotification/req_ssl", use);
 424 }
 425
 426 bool Preferences::getMailNotificationSMTPAuth() const
 427 {
 428     return value("Preferences/MailNotification/req_auth", false).toBool();
 429 }
 430
 431 void Preferences::setMailNotificationSMTPAuth(const bool use)
 432 {
 433     setValue("Preferences/MailNotification/req_auth", use);
 434 }
 435
 436 QString Preferences::getMailNotificationSMTPUsername() const
 437 {
 438     return value("Preferences/MailNotification/username").toString();
 439 }
 440
 441 void Preferences::setMailNotificationSMTPUsername(const QString &username)
 442 {
 443     setValue("Preferences/MailNotification/username", username);
 444 }
 445
 446 QString Preferences::getMailNotificationSMTPPassword() const
 447 {
 448     return value("Preferences/MailNotification/password").toString();
 449 }
 450
 451 void Preferences::setMailNotificationSMTPPassword(const QString &password)
 452 {
 453     setValue("Preferences/MailNotification/password", password);
 454 }
 455
 456 int Preferences::getActionOnDblClOnTorrentDl() const
 457 {
 458     return value("Preferences/Downloads/DblClOnTorDl", 0).toInt();
 459 }
 460
 461 void Preferences::setActionOnDblClOnTorrentDl(const int act)
 462 {
 463     setValue("Preferences/Downloads/DblClOnTorDl", act);
 464 }
 465
 466 int Preferences::getActionOnDblClOnTorrentFn() const
 467 {
 468     return value("Preferences/Downloads/DblClOnTorFn", 1).toInt();
 469 }
 470
 471 void Preferences::setActionOnDblClOnTorrentFn(const int act)
 472 {
 473     setValue("Preferences/Downloads/DblClOnTorFn", act);
 474 }
 475
 476 QTime Preferences::getSchedulerStartTime() const
 477 {
 478     return value("Preferences/Scheduler/start_time", QTime(8,0)).toTime();
 479 }
 480
 481 void Preferences::setSchedulerStartTime(const QTime &time)
 482 {
 483     setValue("Preferences/Scheduler/start_time", time);
 484 }
 485
 486 QTime Preferences::getSchedulerEndTime() const
 487 {
 488     return value("Preferences/Scheduler/end_time", QTime(20,0)).toTime();
 489 }
 490
 491 void Preferences::setSchedulerEndTime(const QTime &time)
 492 {
 493     setValue("Preferences/Scheduler/end_time", time);
 494 }
 495
 496 SchedulerDays Preferences::getSchedulerDays() const
 497 {
 498     return static_cast<SchedulerDays>(value("Preferences/Scheduler/days", EVERY_DAY).toInt());
 499 }
 500
 501 void Preferences::setSchedulerDays(const SchedulerDays days)
 502 {
 503     setValue("Preferences/Scheduler/days", static_cast<int>(days));
 504 }
 505
 506 // Search
 507 bool Preferences::isSearchEnabled() const
 508 {
 509     return value("Preferences/Search/SearchEnabled", false).toBool();
 510 }
 511
 512 void Preferences::setSearchEnabled(const bool enabled)
 513 {
 514     setValue("Preferences/Search/SearchEnabled", enabled);
 515 }
 516
 517 bool Preferences::isWebUiEnabled() const
 518 {
 519 #ifdef DISABLE_GUI
 520     return true;
 521 #else
 522     return value("Preferences/WebUI/Enabled", false).toBool();
 523 #endif
 524 }
 525
 526 void Preferences::setWebUiEnabled(const bool enabled)
 527 {
 528     setValue("Preferences/WebUI/Enabled", enabled);
 529 }
 530
 531 bool Preferences::isWebUiLocalAuthEnabled() const
 532 {
 533     return value("Preferences/WebUI/LocalHostAuth", true).toBool();
 534 }
 535
 536 void Preferences::setWebUiLocalAuthEnabled(const bool enabled)
 537 {
 538     setValue("Preferences/WebUI/LocalHostAuth", enabled);
 539 }
 540
 541 bool Preferences::isWebUiAuthSubnetWhitelistEnabled() const
 542 {
 543     return value("Preferences/WebUI/AuthSubnetWhitelistEnabled", false).toBool();
 544 }
 545
 546 void Preferences::setWebUiAuthSubnetWhitelistEnabled(const bool enabled)
 547 {
 548     setValue("Preferences/WebUI/AuthSubnetWhitelistEnabled", enabled);
 549 }
 550
 551 QVector<Utils::Net::Subnet> Preferences::getWebUiAuthSubnetWhitelist() const
 552 {
 553     const QStringList subnets = value("Preferences/WebUI/AuthSubnetWhitelist").toStringList();
 554
 555     QVector<Utils::Net::Subnet> ret;
 556     ret.reserve(subnets.size());
 557
 558     for (const QString &rawSubnet : subnets)
 559     {
 560         bool ok = false;
 561         const Utils::Net::Subnet subnet = Utils::Net::parseSubnet(rawSubnet.trimmed(), &ok);
 562         if (ok)
 563             ret.append(subnet);
 564     }
 565
 566     return ret;
 567 }
 568
 569 void Preferences::setWebUiAuthSubnetWhitelist(QStringList subnets)
 570 {
 571     Algorithm::removeIf(subnets, [](const QString &subnet)
 572     {
 573         bool ok = false;
 574         Utils::Net::parseSubnet(subnet.trimmed(), &ok);
 575         return !ok;
 576     });
 577
 578     setValue("Preferences/WebUI/AuthSubnetWhitelist", subnets);
 579 }
 580
 581 QString Preferences::getServerDomains() const
 582 {
 583     return value("Preferences/WebUI/ServerDomains", QChar('*')).toString();
 584 }
 585
 586 void Preferences::setServerDomains(const QString &str)
 587 {
 588     setValue("Preferences/WebUI/ServerDomains", str);
 589 }
 590
 591 QString Preferences::getWebUiAddress() const
 592 {
 593     return value("Preferences/WebUI/Address", QChar('*')).toString().trimmed();
 594 }
 595
 596 void Preferences::setWebUiAddress(const QString &addr)
 597 {
 598     setValue("Preferences/WebUI/Address", addr.trimmed());
 599 }
 600
 601 quint16 Preferences::getWebUiPort() const
 602 {
 603     return value("Preferences/WebUI/Port", 8080).toInt();
 604 }
 605
 606 void Preferences::setWebUiPort(const quint16 port)
 607 {
 608     setValue("Preferences/WebUI/Port", port);
 609 }
 610
 611 bool Preferences::useUPnPForWebUIPort() const
 612 {
 613 #ifdef DISABLE_GUI
 614     return value("Preferences/WebUI/UseUPnP", true).toBool();
 615 #else
 616     return value("Preferences/WebUI/UseUPnP", false).toBool();
 617 #endif
 618 }
 619
 620 void Preferences::setUPnPForWebUIPort(const bool enabled)
 621 {
 622     setValue("Preferences/WebUI/UseUPnP", enabled);
 623 }
 624
 625 QString Preferences::getWebUiUsername() const
 626 {
 627     return value("Preferences/WebUI/Username", "admin").toString();
 628 }
 629
 630 void Preferences::setWebUiUsername(const QString &username)
 631 {
 632     setValue("Preferences/WebUI/Username", username);
 633 }
 634
 635 QByteArray Preferences::getWebUIPassword() const
 636 {
 637     // default: adminadmin
 638     const QByteArray defaultValue = "ARQ77eY1NUZaQsuDHbIMCA==:0WMRkYTUWVT9wVvdDtHAjU9b3b7uB8NR1Gur2hmQCvCDpm39Q+PsJRJPaCU51dEiz+dTzh8qbPsL8WkFljQYFQ==";
 639     return value("Preferences/WebUI/Password_PBKDF2", defaultValue).toByteArray();
 640 }
 641
 642 void Preferences::setWebUIPassword(const QByteArray &password)
 643 {
 644     setValue("Preferences/WebUI/Password_PBKDF2", password);
 645 }
 646
 647 int Preferences::getWebUIMaxAuthFailCount() const
 648 {
 649     return value("Preferences/WebUI/MaxAuthenticationFailCount", 5).toInt();
 650 }
 651
 652 void Preferences::setWebUIMaxAuthFailCount(const int count)
 653 {
 654     setValue("Preferences/WebUI/MaxAuthenticationFailCount", count);
 655 }
 656
 657 std::chrono::seconds Preferences::getWebUIBanDuration() const
 658 {
 659     return std::chrono::seconds {value("Preferences/WebUI/BanDuration", 3600).toInt()};
 660 }
 661
 662 void Preferences::setWebUIBanDuration(const std::chrono::seconds duration)
 663 {
 664     setValue("Preferences/WebUI/BanDuration", static_cast<int>(duration.count()));
 665 }
 666
 667 int Preferences::getWebUISessionTimeout() const
 668 {
 669     return value("Preferences/WebUI/SessionTimeout", 3600).toInt();
 670 }
 671
 672 void Preferences::setWebUISessionTimeout(const int timeout)
 673 {
 674     setValue("Preferences/WebUI/SessionTimeout", timeout);
 675 }
 676
 677 bool Preferences::isWebUiClickjackingProtectionEnabled() const
 678 {
 679     return value("Preferences/WebUI/ClickjackingProtection", true).toBool();
 680 }
 681
 682 void Preferences::setWebUiClickjackingProtectionEnabled(const bool enabled)
 683 {
 684     setValue("Preferences/WebUI/ClickjackingProtection", enabled);
 685 }
 686
 687 bool Preferences::isWebUiCSRFProtectionEnabled() const
 688 {
 689     return value("Preferences/WebUI/CSRFProtection", true).toBool();
 690 }
 691
 692 void Preferences::setWebUiCSRFProtectionEnabled(const bool enabled)
 693 {
 694     setValue("Preferences/WebUI/CSRFProtection", enabled);
 695 }
 696
 697 bool Preferences::isWebUiSecureCookieEnabled() const
 698 {
 699     return value("Preferences/WebUI/SecureCookie", true).toBool();
 700 }
 701
 702 void Preferences::setWebUiSecureCookieEnabled(const bool enabled)
 703 {
 704     setValue("Preferences/WebUI/SecureCookie", enabled);
 705 }
 706
 707 bool Preferences::isWebUIHostHeaderValidationEnabled() const
 708 {
 709     return value("Preferences/WebUI/HostHeaderValidation", true).toBool();
 710 }
 711
 712 void Preferences::setWebUIHostHeaderValidationEnabled(const bool enabled)
 713 {
 714     setValue("Preferences/WebUI/HostHeaderValidation", enabled);
 715 }
 716
 717 bool Preferences::isWebUiHttpsEnabled() const
 718 {
 719     return value("Preferences/WebUI/HTTPS/Enabled", false).toBool();
 720 }
 721
 722 void Preferences::setWebUiHttpsEnabled(const bool enabled)
 723 {
 724     setValue("Preferences/WebUI/HTTPS/Enabled", enabled);
 725 }
 726
 727 QString Preferences::getWebUIHttpsCertificatePath() const
 728 {
 729     return value("Preferences/WebUI/HTTPS/CertificatePath").toString();
 730 }
 731
 732 void Preferences::setWebUIHttpsCertificatePath(const QString &path)
 733 {
 734     setValue("Preferences/WebUI/HTTPS/CertificatePath", path);
 735 }
 736
 737 QString Preferences::getWebUIHttpsKeyPath() const
 738 {
 739     return value("Preferences/WebUI/HTTPS/KeyPath").toString();
 740 }
 741
 742 void Preferences::setWebUIHttpsKeyPath(const QString &path)
 743 {
 744     setValue("Preferences/WebUI/HTTPS/KeyPath", path);
 745 }
 746
 747 bool Preferences::isAltWebUiEnabled() const
 748 {
 749     return value("Preferences/WebUI/AlternativeUIEnabled", false).toBool();
 750 }
 751
 752 void Preferences::setAltWebUiEnabled(const bool enabled)
 753 {
 754     setValue("Preferences/WebUI/AlternativeUIEnabled", enabled);
 755 }
 756
 757 QString Preferences::getWebUiRootFolder() const
 758 {
 759     return value("Preferences/WebUI/RootFolder").toString();
 760 }
 761
 762 void Preferences::setWebUiRootFolder(const QString &path)
 763 {
 764     setValue("Preferences/WebUI/RootFolder", path);
 765 }
 766
 767 bool Preferences::isWebUICustomHTTPHeadersEnabled() const
 768 {
 769     return value("Preferences/WebUI/CustomHTTPHeadersEnabled", false).toBool();
 770 }
 771
 772 void Preferences::setWebUICustomHTTPHeadersEnabled(const bool enabled)
 773 {
 774     setValue("Preferences/WebUI/CustomHTTPHeadersEnabled", enabled);
 775 }
 776
 777 QString Preferences::getWebUICustomHTTPHeaders() const
 778 {
 779     return value("Preferences/WebUI/CustomHTTPHeaders").toString();
 780 }
 781
 782 void Preferences::setWebUICustomHTTPHeaders(const QString &headers)
 783 {
 784     setValue("Preferences/WebUI/CustomHTTPHeaders", headers);
 785 }
 786
 787 bool Preferences::isWebUIReverseProxySupportEnabled() const
 788 {
 789     return value("Preferences/WebUI/ReverseProxySupportEnabled", false).toBool();
 790 }
 791
 792 void Preferences::setWebUIReverseProxySupportEnabled(const bool enabled)
 793 {
 794     setValue("Preferences/WebUI/ReverseProxySupportEnabled", enabled);
 795 }
 796
 797 QString Preferences::getWebUITrustedReverseProxiesList() const
 798 {
 799     return value("Preferences/WebUI/TrustedReverseProxiesList").toString();
 800 }
 801
 802 void Preferences::setWebUITrustedReverseProxiesList(const QString &addr)
 803 {
 804     setValue("Preferences/WebUI/TrustedReverseProxiesList", addr);
 805 }
 806
 807 bool Preferences::isDynDNSEnabled() const
 808 {
 809     return value("Preferences/DynDNS/Enabled", false).toBool();
 810 }
 811
 812 void Preferences::setDynDNSEnabled(const bool enabled)
 813 {
 814     setValue("Preferences/DynDNS/Enabled", enabled);
 815 }
 816
 817 DNS::Service Preferences::getDynDNSService() const
 818 {
 819     return DNS::Service(value("Preferences/DynDNS/Service", DNS::DYNDNS).toInt());
 820 }
 821
 822 void Preferences::setDynDNSService(const int service)
 823 {
 824     setValue("Preferences/DynDNS/Service", service);
 825 }
 826
 827 QString Preferences::getDynDomainName() const
 828 {
 829     return value("Preferences/DynDNS/DomainName", "changeme.dyndns.org").toString();
 830 }
 831
 832 void Preferences::setDynDomainName(const QString &name)
 833 {
 834     setValue("Preferences/DynDNS/DomainName", name);
 835 }
 836
 837 QString Preferences::getDynDNSUsername() const
 838 {
 839     return value("Preferences/DynDNS/Username").toString();
 840 }
 841
 842 void Preferences::setDynDNSUsername(const QString &username)
 843 {
 844     setValue("Preferences/DynDNS/Username", username);
 845 }
 846
 847 QString Preferences::getDynDNSPassword() const
 848 {
 849     return value("Preferences/DynDNS/Password").toString();
 850 }
 851
 852 void Preferences::setDynDNSPassword(const QString &password)
 853 {
 854     setValue("Preferences/DynDNS/Password", password);
 855 }
 856
 857 // Advanced settings
 858 QByteArray Preferences::getUILockPassword() const
 859 {
 860     return value("Locking/password_PBKDF2").toByteArray();
 861 }
 862
 863 void Preferences::setUILockPassword(const QByteArray &password)
 864 {
 865     setValue("Locking/password_PBKDF2", password);
 866 }
 867
 868 bool Preferences::isUILocked() const
 869 {
 870     return value("Locking/locked", false).toBool();
 871 }
 872
 873 void Preferences::setUILocked(const bool locked)
 874 {
 875     setValue("Locking/locked", locked);
 876 }
 877
 878 bool Preferences::isAutoRunEnabled() const
 879 {
 880     return value("AutoRun/enabled", false).toBool();
 881 }
 882
 883 void Preferences::setAutoRunEnabled(const bool enabled)
 884 {
 885     setValue("AutoRun/enabled", enabled);
 886 }
 887
 888 QString Preferences::getAutoRunProgram() const
 889 {
 890     return value("AutoRun/program").toString();
 891 }
 892
 893 void Preferences::setAutoRunProgram(const QString &program)
 894 {
 895     setValue("AutoRun/program", program);
 896 }
 897
 898 #if defined(Q_OS_WIN)
 899 bool Preferences::isAutoRunConsoleEnabled() const
 900 {
 901     return value("AutoRun/ConsoleEnabled", false).toBool();
 902 }
 903
 904 void Preferences::setAutoRunConsoleEnabled(const bool enabled)
 905 {
 906     setValue("AutoRun/ConsoleEnabled", enabled);
 907 }
 908 #endif
 909
 910 bool Preferences::shutdownWhenDownloadsComplete() const
 911 {
 912     return value("Preferences/Downloads/AutoShutDownOnCompletion", false).toBool();
 913 }
 914
 915 void Preferences::setShutdownWhenDownloadsComplete(const bool shutdown)
 916 {
 917     setValue("Preferences/Downloads/AutoShutDownOnCompletion", shutdown);
 918 }
 919
 920 bool Preferences::suspendWhenDownloadsComplete() const
 921 {
 922     return value("Preferences/Downloads/AutoSuspendOnCompletion", false).toBool();
 923 }
 924
 925 void Preferences::setSuspendWhenDownloadsComplete(const bool suspend)
 926 {
 927     setValue("Preferences/Downloads/AutoSuspendOnCompletion", suspend);
 928 }
 929
 930 bool Preferences::hibernateWhenDownloadsComplete() const
 931 {
 932     return value("Preferences/Downloads/AutoHibernateOnCompletion", false).toBool();
 933 }
 934
 935 void Preferences::setHibernateWhenDownloadsComplete(const bool hibernate)
 936 {
 937     setValue("Preferences/Downloads/AutoHibernateOnCompletion", hibernate);
 938 }
 939
 940 bool Preferences::shutdownqBTWhenDownloadsComplete() const
 941 {
 942     return value("Preferences/Downloads/AutoShutDownqBTOnCompletion", false).toBool();
 943 }
 944
 945 void Preferences::setShutdownqBTWhenDownloadsComplete(const bool shutdown)
 946 {
 947     setValue("Preferences/Downloads/AutoShutDownqBTOnCompletion", shutdown);
 948 }
 949
 950 bool Preferences::dontConfirmAutoExit() const
 951 {
 952     return value("ShutdownConfirmDlg/DontConfirmAutoExit", false).toBool();
 953 }
 954
 955 void Preferences::setDontConfirmAutoExit(const bool dontConfirmAutoExit)
 956 {
 957     setValue("ShutdownConfirmDlg/DontConfirmAutoExit", dontConfirmAutoExit);
 958 }
 959
 960 bool Preferences::recheckTorrentsOnCompletion() const
 961 {
 962     return value("Preferences/Advanced/RecheckOnCompletion", false).toBool();
 963 }
 964
 965 void Preferences::recheckTorrentsOnCompletion(const bool recheck)
 966 {
 967     setValue("Preferences/Advanced/RecheckOnCompletion", recheck);
 968 }
 969
 970 bool Preferences::resolvePeerCountries() const
 971 {
 972     return value("Preferences/Connection/ResolvePeerCountries", true).toBool();
 973 }
 974
 975 void Preferences::resolvePeerCountries(const bool resolve)
 976 {
 977     setValue("Preferences/Connection/ResolvePeerCountries", resolve);
 978 }
 979
 980 bool Preferences::resolvePeerHostNames() const
 981 {
 982     return value("Preferences/Connection/ResolvePeerHostNames", false).toBool();
 983 }
 984
 985 void Preferences::resolvePeerHostNames(const bool resolve)
 986 {
 987     setValue("Preferences/Connection/ResolvePeerHostNames", resolve);
 988 }
 989
 990 #if (defined(Q_OS_UNIX) && !defined(Q_OS_MACOS))
 991 bool Preferences::useSystemIconTheme() const
 992 {
 993     return value("Preferences/Advanced/useSystemIconTheme", true).toBool();
 994 }
 995
 996 void Preferences::useSystemIconTheme(const bool enabled)
 997 {
 998     setValue("Preferences/Advanced/useSystemIconTheme", enabled);
 999 }
1000 #endif
1001
1002 bool Preferences::recursiveDownloadDisabled() const
1003 {
1004     return value("Preferences/Advanced/DisableRecursiveDownload", false).toBool();
1005 }
1006
1007 void Preferences::disableRecursiveDownload(const bool disable)
1008 {
1009     setValue("Preferences/Advanced/DisableRecursiveDownload", disable);
1010 }
1011
1012 #ifdef Q_OS_WIN
1013 bool Preferences::neverCheckFileAssoc() const
1014 {
1015     return value("Preferences/Win32/NeverCheckFileAssocation", false).toBool();
1016 }
1017
1018 void Preferences::setNeverCheckFileAssoc(const bool check)
1019 {
1020     setValue("Preferences/Win32/NeverCheckFileAssocation", check);
1021 }
1022
1023 bool Preferences::isTorrentFileAssocSet()
1024 {
1025     const QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
1026     if (settings.value(".torrent/Default").toString() != "qBittorrent")
1027     {
1028         qDebug(".torrent != qBittorrent");
1029         return false;
1030     }
1031
1032     return true;
1033 }
1034
1035 bool Preferences::isMagnetLinkAssocSet()
1036 {
1037     const QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
1038
1039     // Check magnet link assoc
1040     const QString shellCommand = Utils::Fs::toNativePath(settings.value("magnet/shell/open/command/Default", "").toString());
1041
1042     const QRegularExpressionMatch exeRegMatch = QRegularExpression("\"([^\"]+)\".*").match(shellCommand);
1043     if (!exeRegMatch.hasMatch())
1044         return false;
1045
1046     const QString assocExe = exeRegMatch.captured(1);
1047     if (assocExe.compare(Utils::Fs::toNativePath(qApp->applicationFilePath()), Qt::CaseInsensitive) != 0)
1048         return false;
1049
1050     return true;
1051 }
1052
1053 void Preferences::setTorrentFileAssoc(const bool set)
1054 {
1055     QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
1056
1057     // .Torrent association
1058     if (set)
1059     {
1060         const QString oldProgId = settings.value(".torrent/Default").toString();
1061         if (!oldProgId.isEmpty() && (oldProgId != "qBittorrent"))
1062             settings.setValue(".torrent/OpenWithProgids/" + oldProgId, "");
1063         settings.setValue(".torrent/Default", "qBittorrent");
1064     }
1065     else if (isTorrentFileAssocSet())
1066     {
1067         settings.setValue(".torrent/Default", "");
1068     }
1069
1070     SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, 0, 0);
1071 }
1072
1073 void Preferences::setMagnetLinkAssoc(const bool set)
1074 {
1075     QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
1076
1077     // Magnet association
1078     if (set)
1079     {
1080         const QString commandStr = '"' + qApp->applicationFilePath() + "\" \"%1\"";
1081         const QString iconStr = '"' + qApp->applicationFilePath() + "\",1";
1082
1083         settings.setValue("magnet/Default", "URL:Magnet link");
1084         settings.setValue("magnet/Content Type", "application/x-magnet");
1085         settings.setValue("magnet/URL Protocol", "");
1086         settings.setValue("magnet/DefaultIcon/Default", Utils::Fs::toNativePath(iconStr));
1087         settings.setValue("magnet/shell/Default", "open");
1088         settings.setValue("magnet/shell/open/command/Default", Utils::Fs::toNativePath(commandStr));
1089     }
1090     else if (isMagnetLinkAssocSet())
1091     {
1092         settings.remove("magnet");
1093     }
1094
1095     SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, 0, 0);
1096 }
1097 #endif // Q_OS_WIN
1098
1099 #ifdef Q_OS_MACOS
1100 namespace
1101 {
1102     const CFStringRef torrentExtension = CFSTR("torrent");
1103     const CFStringRef magnetUrlScheme = CFSTR("magnet");
1104 }
1105
1106 bool Preferences::isTorrentFileAssocSet()
1107 {
1108     bool isSet = false;
1109     const CFStringRef torrentId = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, torrentExtension, NULL);
1110     if (torrentId != NULL)
1111     {
1112         const CFStringRef defaultHandlerId = LSCopyDefaultRoleHandlerForContentType(torrentId, kLSRolesViewer);
1113         if (defaultHandlerId != NULL)
1114         {
1115             const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1116             isSet = CFStringCompare(myBundleId, defaultHandlerId, 0) == kCFCompareEqualTo;
1117             CFRelease(defaultHandlerId);
1118         }
1119         CFRelease(torrentId);
1120     }
1121     return isSet;
1122 }
1123
1124 bool Preferences::isMagnetLinkAssocSet()
1125 {
1126     bool isSet = false;
1127     const CFStringRef defaultHandlerId = LSCopyDefaultHandlerForURLScheme(magnetUrlScheme);
1128     if (defaultHandlerId != NULL)
1129     {
1130         const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1131         isSet = CFStringCompare(myBundleId, defaultHandlerId, 0) == kCFCompareEqualTo;
1132         CFRelease(defaultHandlerId);
1133     }
1134     return isSet;
1135 }
1136
1137 void Preferences::setTorrentFileAssoc()
1138 {
1139     if (isTorrentFileAssocSet())
1140         return;
1141     const CFStringRef torrentId = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, torrentExtension, NULL);
1142     if (torrentId != NULL)
1143     {
1144         const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1145         LSSetDefaultRoleHandlerForContentType(torrentId, kLSRolesViewer, myBundleId);
1146         CFRelease(torrentId);
1147     }
1148 }
1149
1150 void Preferences::setMagnetLinkAssoc()
1151 {
1152     if (isMagnetLinkAssocSet())
1153         return;
1154     const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1155     LSSetDefaultHandlerForURLScheme(magnetUrlScheme, myBundleId);
1156 }
1157 #endif // Q_OS_MACOS
1158
1159 int Preferences::getTrackerPort() const
1160 {
1161     return value("Preferences/Advanced/trackerPort", 9000).toInt();
1162 }
1163
1164 void Preferences::setTrackerPort(const int port)
1165 {
1166     setValue("Preferences/Advanced/trackerPort", port);
1167 }
1168
1169 #if defined(Q_OS_WIN) || defined(Q_OS_MACOS)
1170 bool Preferences::isUpdateCheckEnabled() const
1171 {
1172     return value("Preferences/Advanced/updateCheck", true).toBool();
1173 }
1174
1175 void Preferences::setUpdateCheckEnabled(const bool enabled)
1176 {
1177     setValue("Preferences/Advanced/updateCheck", enabled);
1178 }
1179 #endif
1180
1181 bool Preferences::confirmTorrentDeletion() const
1182 {
1183     return value("Preferences/Advanced/confirmTorrentDeletion", true).toBool();
1184 }
1185
1186 void Preferences::setConfirmTorrentDeletion(const bool enabled)
1187 {
1188     setValue("Preferences/Advanced/confirmTorrentDeletion", enabled);
1189 }
1190
1191 bool Preferences::confirmTorrentRecheck() const
1192 {
1193     return value("Preferences/Advanced/confirmTorrentRecheck", true).toBool();
1194 }
1195
1196 void Preferences::setConfirmTorrentRecheck(const bool enabled)
1197 {
1198     setValue("Preferences/Advanced/confirmTorrentRecheck", enabled);
1199 }
1200
1201 bool Preferences::confirmRemoveAllTags() const
1202 {
1203     return value("Preferences/Advanced/confirmRemoveAllTags", true).toBool();
1204 }
1205
1206 void Preferences::setConfirmRemoveAllTags(const bool enabled)
1207 {
1208     setValue("Preferences/Advanced/confirmRemoveAllTags", enabled);
1209 }
1210
1211 #ifndef Q_OS_MACOS
1212 TrayIcon::Style Preferences::trayIconStyle() const
1213 {
1214     return TrayIcon::Style(value("Preferences/Advanced/TrayIconStyle", TrayIcon::NORMAL).toInt());
1215 }
1216
1217 void Preferences::setTrayIconStyle(const TrayIcon::Style style)
1218 {
1219     setValue("Preferences/Advanced/TrayIconStyle", style);
1220 }
1221 #endif
1222
1223 // Stuff that don't appear in the Options GUI but are saved
1224 // in the same file.
1225
1226 QDateTime Preferences::getDNSLastUpd() const
1227 {
1228     return value("DNSUpdater/lastUpdateTime").toDateTime();
1229 }
1230
1231 void Preferences::setDNSLastUpd(const QDateTime &date)
1232 {
1233     setValue("DNSUpdater/lastUpdateTime", date);
1234 }
1235
1236 QString Preferences::getDNSLastIP() const
1237 {
1238     return value("DNSUpdater/lastIP").toString();
1239 }
1240
1241 void Preferences::setDNSLastIP(const QString &ip)
1242 {
1243     setValue("DNSUpdater/lastIP", ip);
1244 }
1245
1246 bool Preferences::getAcceptedLegal() const
1247 {
1248     return value("LegalNotice/Accepted", false).toBool();
1249 }
1250
1251 void Preferences::setAcceptedLegal(const bool accepted)
1252 {
1253     setValue("LegalNotice/Accepted", accepted);
1254 }
1255
1256 QByteArray Preferences::getMainGeometry() const
1257 {
1258     return value("MainWindow/geometry").toByteArray();
1259 }
1260
1261 void Preferences::setMainGeometry(const QByteArray &geometry)
1262 {
1263     setValue("MainWindow/geometry", geometry);
1264 }
1265
1266 QByteArray Preferences::getMainVSplitterState() const
1267 {
1268 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1269     return value("GUI/Qt6/MainWindow/VSplitterState").toByteArray();
1270 #else
1271     return value("MainWindow/qt5/vsplitterState").toByteArray();
1272 #endif
1273 }
1274
1275 void Preferences::setMainVSplitterState(const QByteArray &state)
1276 {
1277 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1278     setValue("GUI/Qt6/MainWindow/VSplitterState", state);
1279 #else
1280     setValue("MainWindow/qt5/vsplitterState", state);
1281 #endif
1282 }
1283
1284 QString Preferences::getMainLastDir() const
1285 {
1286     return value("MainWindowLastDir", QDir::homePath()).toString();
1287 }
1288
1289 void Preferences::setMainLastDir(const QString &path)
1290 {
1291     setValue("MainWindowLastDir", path);
1292 }
1293
1294 QByteArray Preferences::getPeerListState() const
1295 {
1296 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1297     return value("GUI/Qt6/TorrentProperties/PeerListState").toByteArray();
1298 #else
1299     return value("TorrentProperties/Peers/qt5/PeerListState").toByteArray();
1300 #endif
1301 }
1302
1303 void Preferences::setPeerListState(const QByteArray &state)
1304 {
1305 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1306     setValue("GUI/Qt6/TorrentProperties/PeerListState", state);
1307 #else
1308     setValue("TorrentProperties/Peers/qt5/PeerListState", state);
1309 #endif
1310 }
1311
1312 QString Preferences::getPropSplitterSizes() const
1313 {
1314     return value("TorrentProperties/SplitterSizes").toString();
1315 }
1316
1317 void Preferences::setPropSplitterSizes(const QString &sizes)
1318 {
1319     setValue("TorrentProperties/SplitterSizes", sizes);
1320 }
1321
1322 QByteArray Preferences::getPropFileListState() const
1323 {
1324 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1325     return value("GUI/Qt6/TorrentProperties/FilesListState").toByteArray();
1326 #else
1327     return value("TorrentProperties/qt5/FilesListState").toByteArray();
1328 #endif
1329 }
1330
1331 void Preferences::setPropFileListState(const QByteArray &state)
1332 {
1333 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1334     setValue("GUI/Qt6/TorrentProperties/FilesListState", state);
1335 #else
1336     setValue("TorrentProperties/qt5/FilesListState", state);
1337 #endif
1338 }
1339
1340 int Preferences::getPropCurTab() const
1341 {
1342     return value("TorrentProperties/CurrentTab", -1).toInt();
1343 }
1344
1345 void Preferences::setPropCurTab(const int tab)
1346 {
1347     setValue("TorrentProperties/CurrentTab", tab);
1348 }
1349
1350 bool Preferences::getPropVisible() const
1351 {
1352     return value("TorrentProperties/Visible", false).toBool();
1353 }
1354
1355 void Preferences::setPropVisible(const bool visible)
1356 {
1357     setValue("TorrentProperties/Visible", visible);
1358 }
1359
1360 QByteArray Preferences::getPropTrackerListState() const
1361 {
1362 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1363     return value("GUI/Qt6/TorrentProperties/TrackerListState").toByteArray();
1364 #else
1365     return value("TorrentProperties/Trackers/qt5/TrackerListState").toByteArray();
1366 #endif
1367 }
1368
1369 void Preferences::setPropTrackerListState(const QByteArray &state)
1370 {
1371 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1372     setValue("GUI/Qt6/TorrentProperties/TrackerListState", state);
1373 #else
1374     setValue("TorrentProperties/Trackers/qt5/TrackerListState", state);
1375 #endif
1376 }
1377
1378 QSize Preferences::getRssGeometrySize() const
1379 {
1380     return value("RssFeedDownloader/geometrySize").toSize();
1381 }
1382
1383 void Preferences::setRssGeometrySize(const QSize &geometry)
1384 {
1385     setValue("RssFeedDownloader/geometrySize", geometry);
1386 }
1387
1388 QByteArray Preferences::getRssHSplitterSizes() const
1389 {
1390 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1391     return value("GUI/Qt6/RSSFeedDownloader/HSplitterSizes").toByteArray();
1392 #else
1393     return value("RssFeedDownloader/qt5/hsplitterSizes").toByteArray();
1394 #endif
1395 }
1396
1397 void Preferences::setRssHSplitterSizes(const QByteArray &sizes)
1398 {
1399 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1400     setValue("GUI/Qt6/RSSFeedDownloader/HSplitterSizes", sizes);
1401 #else
1402     setValue("RssFeedDownloader/qt5/hsplitterSizes", sizes);
1403 #endif
1404 }
1405
1406 QStringList Preferences::getRssOpenFolders() const
1407 {
1408     return value("GUI/RSSWidget/OpenedFolders").toStringList();
1409 }
1410
1411 void Preferences::setRssOpenFolders(const QStringList &folders)
1412 {
1413     setValue("GUI/RSSWidget/OpenedFolders", folders);
1414 }
1415
1416 QByteArray Preferences::getRssSideSplitterState() const
1417 {
1418 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1419     return value("GUI/Qt6/RSSWidget/SideSplitterState").toByteArray();
1420 #else
1421     return value("GUI/RSSWidget/qt5/splitter_h").toByteArray();
1422 #endif
1423 }
1424
1425 void Preferences::setRssSideSplitterState(const QByteArray &state)
1426 {
1427 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1428     setValue("GUI/Qt6/RSSWidget/SideSplitterState", state);
1429 #else
1430     setValue("GUI/RSSWidget/qt5/splitter_h", state);
1431 #endif
1432 }
1433
1434 QByteArray Preferences::getRssMainSplitterState() const
1435 {
1436 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1437     return value("GUI/Qt6/RSSWidget/MainSplitterState").toByteArray();
1438 #else
1439     return value("GUI/RSSWidget/qt5/splitterMain").toByteArray();
1440 #endif
1441 }
1442
1443 void Preferences::setRssMainSplitterState(const QByteArray &state)
1444 {
1445 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1446     setValue("GUI/Qt6/RSSWidget/MainSplitterState", state);
1447 #else
1448     setValue("GUI/RSSWidget/qt5/splitterMain", state);
1449 #endif
1450 }
1451
1452 QByteArray Preferences::getSearchTabHeaderState() const
1453 {
1454 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1455     return value("GUI/Qt6/SearchTab/HeaderState").toByteArray();
1456 #else
1457     return value("SearchTab/qt5/HeaderState").toByteArray();
1458 #endif
1459 }
1460
1461 void Preferences::setSearchTabHeaderState(const QByteArray &state)
1462 {
1463 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1464     setValue("GUI/Qt6/SearchTab/HeaderState", state);
1465 #else
1466     setValue("SearchTab/qt5/HeaderState", state);
1467 #endif
1468 }
1469
1470 bool Preferences::getRegexAsFilteringPatternForSearchJob() const
1471 {
1472     return value("SearchTab/UseRegexAsFilteringPattern", false).toBool();
1473 }
1474
1475 void Preferences::setRegexAsFilteringPatternForSearchJob(const bool checked)
1476 {
1477     setValue("SearchTab/UseRegexAsFilteringPattern", checked);
1478 }
1479
1480 QStringList Preferences::getSearchEngDisabled() const
1481 {
1482     return value("SearchEngines/disabledEngines").toStringList();
1483 }
1484
1485 void Preferences::setSearchEngDisabled(const QStringList &engines)
1486 {
1487     setValue("SearchEngines/disabledEngines", engines);
1488 }
1489
1490 QString Preferences::getTorImportLastContentDir() const
1491 {
1492     return value("TorrentImport/LastContentDir", QDir::homePath()).toString();
1493 }
1494
1495 void Preferences::setTorImportLastContentDir(const QString &path)
1496 {
1497     setValue("TorrentImport/LastContentDir", path);
1498 }
1499
1500 QByteArray Preferences::getTorImportGeometry() const
1501 {
1502     return value("TorrentImportDlg/dimensions").toByteArray();
1503 }
1504
1505 void Preferences::setTorImportGeometry(const QByteArray &geometry)
1506 {
1507     setValue("TorrentImportDlg/dimensions", geometry);
1508 }
1509
1510 bool Preferences::getStatusFilterState() const
1511 {
1512     return value("TransferListFilters/statusFilterState", true).toBool();
1513 }
1514
1515 void Preferences::setStatusFilterState(const bool checked)
1516 {
1517     setValue("TransferListFilters/statusFilterState", checked);
1518 }
1519
1520 bool Preferences::getCategoryFilterState() const
1521 {
1522     return value("TransferListFilters/CategoryFilterState", true).toBool();
1523 }
1524
1525 void Preferences::setCategoryFilterState(const bool checked)
1526 {
1527     setValue("TransferListFilters/CategoryFilterState", checked);
1528 }
1529
1530 bool Preferences::getTagFilterState() const
1531 {
1532     return value("TransferListFilters/TagFilterState", true).toBool();
1533 }
1534
1535 void Preferences::setTagFilterState(const bool checked)
1536 {
1537     setValue("TransferListFilters/TagFilterState", checked);
1538 }
1539
1540 bool Preferences::getTrackerFilterState() const
1541 {
1542     return value("TransferListFilters/trackerFilterState", true).toBool();
1543 }
1544
1545 void Preferences::setTrackerFilterState(const bool checked)
1546 {
1547     setValue("TransferListFilters/trackerFilterState", checked);
1548 }
1549
1550 int Preferences::getTransSelFilter() const
1551 {
1552     return value("TransferListFilters/selectedFilterIndex", 0).toInt();
1553 }
1554
1555 void Preferences::setTransSelFilter(const int index)
1556 {
1557     setValue("TransferListFilters/selectedFilterIndex", index);
1558 }
1559
1560 QByteArray Preferences::getTransHeaderState() const
1561 {
1562 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1563     return value("GUI/Qt6/TransferList/HeaderState").toByteArray();
1564 #else
1565     return value("TransferList/qt5/HeaderState").toByteArray();
1566 #endif
1567 }
1568
1569 void Preferences::setTransHeaderState(const QByteArray &state)
1570 {
1571 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
1572     setValue("GUI/Qt6/TransferList/HeaderState", state);
1573 #else
1574     setValue("TransferList/qt5/HeaderState", state);
1575 #endif
1576 }
1577
1578 bool Preferences::getRegexAsFilteringPatternForTransferList() const
1579 {
1580     return value("TransferList/UseRegexAsFilteringPattern", false).toBool();
1581 }
1582
1583 void Preferences::setRegexAsFilteringPatternForTransferList(const bool checked)
1584 {
1585     setValue("TransferList/UseRegexAsFilteringPattern", checked);
1586 }
1587
1588 // From old RssSettings class
1589 bool Preferences::isRSSWidgetEnabled() const
1590 {
1591     return value("GUI/RSSWidget/Enabled", false).toBool();
1592 }
1593
1594 void Preferences::setRSSWidgetVisible(const bool enabled)
1595 {
1596     setValue("GUI/RSSWidget/Enabled", enabled);
1597 }
1598
1599 int Preferences::getToolbarTextPosition() const
1600 {
1601     return value("Toolbar/textPosition", -1).toInt();
1602 }
1603
1604 void Preferences::setToolbarTextPosition(const int position)
1605 {
1606     setValue("Toolbar/textPosition", position);
1607 }
1608
1609 QList<QNetworkCookie> Preferences::getNetworkCookies() const
1610 {
1611     QList<QNetworkCookie> cookies;
1612     const QStringList rawCookies = value("Network/Cookies").toStringList();
1613     for (const QString &rawCookie : rawCookies)
1614         cookies << QNetworkCookie::parseCookies(rawCookie.toUtf8());
1615
1616     return cookies;
1617 }
1618
1619 void Preferences::setNetworkCookies(const QList<QNetworkCookie> &cookies)
1620 {
1621     QStringList rawCookies;
1622     for (const QNetworkCookie &cookie : cookies)
1623         rawCookies << cookie.toRawForm();
1624
1625     setValue("Network/Cookies", rawCookies);
1626 }
1627
1628 bool Preferences::isSpeedWidgetEnabled() const
1629 {
1630     return value("SpeedWidget/Enabled", true).toBool();
1631 }
1632
1633 void Preferences::setSpeedWidgetEnabled(const bool enabled)
1634 {
1635     setValue("SpeedWidget/Enabled", enabled);
1636 }
1637
1638 int Preferences::getSpeedWidgetPeriod() const
1639 {
1640     return value("SpeedWidget/period", 1).toInt();
1641 }
1642
1643 void Preferences::setSpeedWidgetPeriod(const int period)
1644 {
1645     setValue("SpeedWidget/period", period);
1646 }
1647
1648 bool Preferences::getSpeedWidgetGraphEnable(const int id) const
1649 {
1650     // UP and DOWN graphs enabled by default
1651     return value("SpeedWidget/graph_enable_" + QString::number(id), (id == 0 || id == 1)).toBool();
1652 }
1653
1654 void Preferences::setSpeedWidgetGraphEnable(const int id, const bool enable)
1655 {
1656     setValue("SpeedWidget/graph_enable_" + QString::number(id), enable);
1657 }
1658
1659 void Preferences::apply()
1660 {
1661     if (SettingsStorage::instance()->save())
1662         emit changed();
1663 }