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