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 <QLocale>
  45 #include <QNetworkCookie>
  46 #include <QSettings>
  47 #include <QSize>
  48 #include <QTime>
  49 #include <QVariant>
  50
  51 #ifdef Q_OS_WIN
  52 #include <QRegularExpression>
  53 #endif
  54
  55 #include "algorithm.h"
  56 #include "global.h"
  57 #include "settingsstorage.h"
  58 #include "utils/fs.h"
  59
  60 Preferences *Preferences::m_instance = nullptr;
  61
  62 Preferences::Preferences() = default;
  63
  64 Preferences *Preferences::instance()
  65 {
  66     return m_instance;
  67 }
  68
  69 void Preferences::initInstance()
  70 {
  71     if (!m_instance)
  72         m_instance = new Preferences;
  73 }
  74
  75 void Preferences::freeInstance()
  76 {
  77     delete m_instance;
  78     m_instance = nullptr;
  79 }
  80
  81 const QVariant Preferences::value(const QString &key, const QVariant &defaultValue) const
  82 {
  83     return SettingsStorage::instance()->loadValue(key, defaultValue);
  84 }
  85
  86 void Preferences::setValue(const QString &key, const QVariant &value)
  87 {
  88     SettingsStorage::instance()->storeValue(key, value);
  89 }
  90
  91 // General options
  92 QString Preferences::getLocale() const
  93 {
  94     const QString localeName = value("Preferences/General/Locale").toString();
  95     return (localeName.isEmpty() ? QLocale::system().name() : localeName);
  96 }
  97
  98 void Preferences::setLocale(const QString &locale)
  99 {
 100     setValue("Preferences/General/Locale", locale);
 101 }
 102
 103 bool Preferences::useCustomUITheme() const
 104 {
 105     return value("Preferences/General/UseCustomUITheme", false).toBool()
 106            && !customUIThemePath().isEmpty();
 107 }
 108
 109 void Preferences::setUseCustomUITheme(const bool use)
 110 {
 111     setValue("Preferences/General/UseCustomUITheme", use);
 112 }
 113
 114 QString Preferences::customUIThemePath() const
 115 {
 116     return value("Preferences/General/CustomUIThemePath").toString();
 117 }
 118
 119 void Preferences::setCustomUIThemePath(const QString &path)
 120 {
 121     setValue("Preferences/General/CustomUIThemePath", path);
 122 }
 123
 124 bool Preferences::deleteTorrentFilesAsDefault() const
 125 {
 126     return value("Preferences/General/DeleteTorrentsFilesAsDefault", false).toBool();
 127 }
 128
 129 void Preferences::setDeleteTorrentFilesAsDefault(const bool del)
 130 {
 131     setValue("Preferences/General/DeleteTorrentsFilesAsDefault", del);
 132 }
 133
 134 bool Preferences::confirmOnExit() const
 135 {
 136     return value("Preferences/General/ExitConfirm", true).toBool();
 137 }
 138
 139 void Preferences::setConfirmOnExit(const bool confirm)
 140 {
 141     setValue("Preferences/General/ExitConfirm", confirm);
 142 }
 143
 144 bool Preferences::speedInTitleBar() const
 145 {
 146     return value("Preferences/General/SpeedInTitleBar", false).toBool();
 147 }
 148
 149 void Preferences::showSpeedInTitleBar(const bool show)
 150 {
 151     setValue("Preferences/General/SpeedInTitleBar", show);
 152 }
 153
 154 bool Preferences::useAlternatingRowColors() const
 155 {
 156     return value("Preferences/General/AlternatingRowColors", true).toBool();
 157 }
 158
 159 void Preferences::setAlternatingRowColors(const bool b)
 160 {
 161     setValue("Preferences/General/AlternatingRowColors", b);
 162 }
 163
 164 bool Preferences::getHideZeroValues() const
 165 {
 166     return value("Preferences/General/HideZeroValues", false).toBool();
 167 }
 168
 169 void Preferences::setHideZeroValues(const bool b)
 170 {
 171     setValue("Preferences/General/HideZeroValues", b);
 172 }
 173
 174 int Preferences::getHideZeroComboValues() const
 175 {
 176     return value("Preferences/General/HideZeroComboValues", 0).toInt();
 177 }
 178
 179 void Preferences::setHideZeroComboValues(const int n)
 180 {
 181     setValue("Preferences/General/HideZeroComboValues", n);
 182 }
 183
 184 // In Mac OS X the dock is sufficient for our needs so we disable the sys tray functionality.
 185 // See extensive discussion in https://github.com/qbittorrent/qBittorrent/pull/3018
 186 #ifndef Q_OS_MACOS
 187 bool Preferences::systrayIntegration() const
 188 {
 189     return value("Preferences/General/SystrayEnabled", true).toBool();
 190 }
 191
 192 void Preferences::setSystrayIntegration(const bool enabled)
 193 {
 194     setValue("Preferences/General/SystrayEnabled", enabled);
 195 }
 196
 197 bool Preferences::minimizeToTray() const
 198 {
 199     return value("Preferences/General/MinimizeToTray", false).toBool();
 200 }
 201
 202 void Preferences::setMinimizeToTray(const bool b)
 203 {
 204     setValue("Preferences/General/MinimizeToTray", b);
 205 }
 206
 207 bool Preferences::minimizeToTrayNotified() const
 208 {
 209     return value("Preferences/General/MinimizeToTrayNotified", false).toBool();
 210 }
 211
 212 void Preferences::setMinimizeToTrayNotified(const bool b)
 213 {
 214     setValue("Preferences/General/MinimizeToTrayNotified", b);
 215 }
 216
 217 bool Preferences::closeToTray() const
 218 {
 219     return value("Preferences/General/CloseToTray", true).toBool();
 220 }
 221
 222 void Preferences::setCloseToTray(const bool b)
 223 {
 224     setValue("Preferences/General/CloseToTray", b);
 225 }
 226
 227 bool Preferences::closeToTrayNotified() const
 228 {
 229     return value("Preferences/General/CloseToTrayNotified", false).toBool();
 230 }
 231
 232 void Preferences::setCloseToTrayNotified(const bool b)
 233 {
 234     setValue("Preferences/General/CloseToTrayNotified", b);
 235 }
 236 #endif // Q_OS_MACOS
 237
 238 bool Preferences::isToolbarDisplayed() const
 239 {
 240     return value("Preferences/General/ToolbarDisplayed", true).toBool();
 241 }
 242
 243 void Preferences::setToolbarDisplayed(const bool displayed)
 244 {
 245     setValue("Preferences/General/ToolbarDisplayed", displayed);
 246 }
 247
 248 bool Preferences::isStatusbarDisplayed() const
 249 {
 250     return value("Preferences/General/StatusbarDisplayed", true).toBool();
 251 }
 252
 253 void Preferences::setStatusbarDisplayed(const bool displayed)
 254 {
 255     setValue("Preferences/General/StatusbarDisplayed", displayed);
 256 }
 257
 258 bool Preferences::startMinimized() const
 259 {
 260     return value("Preferences/General/StartMinimized", false).toBool();
 261 }
 262
 263 void Preferences::setStartMinimized(const bool b)
 264 {
 265     setValue("Preferences/General/StartMinimized", b);
 266 }
 267
 268 bool Preferences::isSplashScreenDisabled() const
 269 {
 270     return value("Preferences/General/NoSplashScreen", true).toBool();
 271 }
 272
 273 void Preferences::setSplashScreenDisabled(const bool b)
 274 {
 275     setValue("Preferences/General/NoSplashScreen", b);
 276 }
 277
 278 // Preventing from system suspend while active torrents are presented.
 279 bool Preferences::preventFromSuspendWhenDownloading() const
 280 {
 281     return value("Preferences/General/PreventFromSuspendWhenDownloading", false).toBool();
 282 }
 283
 284 void Preferences::setPreventFromSuspendWhenDownloading(const bool b)
 285 {
 286     setValue("Preferences/General/PreventFromSuspendWhenDownloading", b);
 287 }
 288
 289 bool Preferences::preventFromSuspendWhenSeeding() const
 290 {
 291     return value("Preferences/General/PreventFromSuspendWhenSeeding", false).toBool();
 292 }
 293
 294 void Preferences::setPreventFromSuspendWhenSeeding(const bool b)
 295 {
 296     setValue("Preferences/General/PreventFromSuspendWhenSeeding", b);
 297 }
 298
 299 #ifdef Q_OS_WIN
 300 bool Preferences::WinStartup() const
 301 {
 302     QSettings settings("HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run", QSettings::NativeFormat);
 303     return settings.contains("qBittorrent");
 304 }
 305
 306 void Preferences::setWinStartup(const bool b)
 307 {
 308     QSettings settings("HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run", QSettings::NativeFormat);
 309     if (b)
 310     {
 311         const QString binPath = '"' + Utils::Fs::toNativePath(qApp->applicationFilePath()) + '"';
 312         settings.setValue("qBittorrent", binPath);
 313     }
 314     else
 315     {
 316         settings.remove("qBittorrent");
 317     }
 318 }
 319 #endif // Q_OS_WIN
 320
 321 // Downloads
 322 QString Preferences::lastLocationPath() const
 323 {
 324     return Utils::Fs::toUniformPath(value("Preferences/Downloads/LastLocationPath").toString());
 325 }
 326
 327 void Preferences::setLastLocationPath(const QString &path)
 328 {
 329     setValue("Preferences/Downloads/LastLocationPath", Utils::Fs::toUniformPath(path));
 330 }
 331
 332 QVariantHash Preferences::getScanDirs() const
 333 {
 334     return value("Preferences/Downloads/ScanDirsV2").toHash();
 335 }
 336
 337 // This must be called somewhere with data from the model
 338 void Preferences::setScanDirs(const QVariantHash &dirs)
 339 {
 340     setValue("Preferences/Downloads/ScanDirsV2", dirs);
 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::isDynDNSEnabled() const
 765 {
 766     return value("Preferences/DynDNS/Enabled", false).toBool();
 767 }
 768
 769 void Preferences::setDynDNSEnabled(const bool enabled)
 770 {
 771     setValue("Preferences/DynDNS/Enabled", enabled);
 772 }
 773
 774 DNS::Service Preferences::getDynDNSService() const
 775 {
 776     return DNS::Service(value("Preferences/DynDNS/Service", DNS::DYNDNS).toInt());
 777 }
 778
 779 void Preferences::setDynDNSService(const int service)
 780 {
 781     setValue("Preferences/DynDNS/Service", service);
 782 }
 783
 784 QString Preferences::getDynDomainName() const
 785 {
 786     return value("Preferences/DynDNS/DomainName", "changeme.dyndns.org").toString();
 787 }
 788
 789 void Preferences::setDynDomainName(const QString &name)
 790 {
 791     setValue("Preferences/DynDNS/DomainName", name);
 792 }
 793
 794 QString Preferences::getDynDNSUsername() const
 795 {
 796     return value("Preferences/DynDNS/Username").toString();
 797 }
 798
 799 void Preferences::setDynDNSUsername(const QString &username)
 800 {
 801     setValue("Preferences/DynDNS/Username", username);
 802 }
 803
 804 QString Preferences::getDynDNSPassword() const
 805 {
 806     return value("Preferences/DynDNS/Password").toString();
 807 }
 808
 809 void Preferences::setDynDNSPassword(const QString &password)
 810 {
 811     setValue("Preferences/DynDNS/Password", password);
 812 }
 813
 814 // Advanced settings
 815 QByteArray Preferences::getUILockPassword() const
 816 {
 817     return value("Locking/password_PBKDF2").toByteArray();
 818 }
 819
 820 void Preferences::setUILockPassword(const QByteArray &password)
 821 {
 822     setValue("Locking/password_PBKDF2", password);
 823 }
 824
 825 bool Preferences::isUILocked() const
 826 {
 827     return value("Locking/locked", false).toBool();
 828 }
 829
 830 void Preferences::setUILocked(const bool locked)
 831 {
 832     setValue("Locking/locked", locked);
 833 }
 834
 835 bool Preferences::isAutoRunEnabled() const
 836 {
 837     return value("AutoRun/enabled", false).toBool();
 838 }
 839
 840 void Preferences::setAutoRunEnabled(const bool enabled)
 841 {
 842     setValue("AutoRun/enabled", enabled);
 843 }
 844
 845 QString Preferences::getAutoRunProgram() const
 846 {
 847     return value("AutoRun/program").toString();
 848 }
 849
 850 void Preferences::setAutoRunProgram(const QString &program)
 851 {
 852     setValue("AutoRun/program", program);
 853 }
 854
 855 #if defined(Q_OS_WIN) && (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
 856 bool Preferences::isAutoRunConsoleEnabled() const
 857 {
 858     return value("AutoRun/ConsoleEnabled", false).toBool();
 859 }
 860
 861 void Preferences::setAutoRunConsoleEnabled(const bool enabled)
 862 {
 863     setValue("AutoRun/ConsoleEnabled", enabled);
 864 }
 865 #endif
 866
 867 bool Preferences::shutdownWhenDownloadsComplete() const
 868 {
 869     return value("Preferences/Downloads/AutoShutDownOnCompletion", false).toBool();
 870 }
 871
 872 void Preferences::setShutdownWhenDownloadsComplete(const bool shutdown)
 873 {
 874     setValue("Preferences/Downloads/AutoShutDownOnCompletion", shutdown);
 875 }
 876
 877 bool Preferences::suspendWhenDownloadsComplete() const
 878 {
 879     return value("Preferences/Downloads/AutoSuspendOnCompletion", false).toBool();
 880 }
 881
 882 void Preferences::setSuspendWhenDownloadsComplete(const bool suspend)
 883 {
 884     setValue("Preferences/Downloads/AutoSuspendOnCompletion", suspend);
 885 }
 886
 887 bool Preferences::hibernateWhenDownloadsComplete() const
 888 {
 889     return value("Preferences/Downloads/AutoHibernateOnCompletion", false).toBool();
 890 }
 891
 892 void Preferences::setHibernateWhenDownloadsComplete(const bool hibernate)
 893 {
 894     setValue("Preferences/Downloads/AutoHibernateOnCompletion", hibernate);
 895 }
 896
 897 bool Preferences::shutdownqBTWhenDownloadsComplete() const
 898 {
 899     return value("Preferences/Downloads/AutoShutDownqBTOnCompletion", false).toBool();
 900 }
 901
 902 void Preferences::setShutdownqBTWhenDownloadsComplete(const bool shutdown)
 903 {
 904     setValue("Preferences/Downloads/AutoShutDownqBTOnCompletion", shutdown);
 905 }
 906
 907 bool Preferences::dontConfirmAutoExit() const
 908 {
 909     return value("ShutdownConfirmDlg/DontConfirmAutoExit", false).toBool();
 910 }
 911
 912 void Preferences::setDontConfirmAutoExit(const bool dontConfirmAutoExit)
 913 {
 914     setValue("ShutdownConfirmDlg/DontConfirmAutoExit", dontConfirmAutoExit);
 915 }
 916
 917 bool Preferences::recheckTorrentsOnCompletion() const
 918 {
 919     return value("Preferences/Advanced/RecheckOnCompletion", false).toBool();
 920 }
 921
 922 void Preferences::recheckTorrentsOnCompletion(const bool recheck)
 923 {
 924     setValue("Preferences/Advanced/RecheckOnCompletion", recheck);
 925 }
 926
 927 bool Preferences::resolvePeerCountries() const
 928 {
 929     return value("Preferences/Connection/ResolvePeerCountries", true).toBool();
 930 }
 931
 932 void Preferences::resolvePeerCountries(const bool resolve)
 933 {
 934     setValue("Preferences/Connection/ResolvePeerCountries", resolve);
 935 }
 936
 937 bool Preferences::resolvePeerHostNames() const
 938 {
 939     return value("Preferences/Connection/ResolvePeerHostNames", false).toBool();
 940 }
 941
 942 void Preferences::resolvePeerHostNames(const bool resolve)
 943 {
 944     setValue("Preferences/Connection/ResolvePeerHostNames", resolve);
 945 }
 946
 947 #if (defined(Q_OS_UNIX) && !defined(Q_OS_MACOS))
 948 bool Preferences::useSystemIconTheme() const
 949 {
 950     return value("Preferences/Advanced/useSystemIconTheme", true).toBool();
 951 }
 952
 953 void Preferences::useSystemIconTheme(const bool enabled)
 954 {
 955     setValue("Preferences/Advanced/useSystemIconTheme", enabled);
 956 }
 957 #endif
 958
 959 bool Preferences::recursiveDownloadDisabled() const
 960 {
 961     return value("Preferences/Advanced/DisableRecursiveDownload", false).toBool();
 962 }
 963
 964 void Preferences::disableRecursiveDownload(const bool disable)
 965 {
 966     setValue("Preferences/Advanced/DisableRecursiveDownload", disable);
 967 }
 968
 969 #ifdef Q_OS_WIN
 970 bool Preferences::neverCheckFileAssoc() const
 971 {
 972     return value("Preferences/Win32/NeverCheckFileAssocation", false).toBool();
 973 }
 974
 975 void Preferences::setNeverCheckFileAssoc(const bool check)
 976 {
 977     setValue("Preferences/Win32/NeverCheckFileAssocation", check);
 978 }
 979
 980 bool Preferences::isTorrentFileAssocSet()
 981 {
 982     const QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
 983     if (settings.value(".torrent/Default").toString() != "qBittorrent")
 984     {
 985         qDebug(".torrent != qBittorrent");
 986         return false;
 987     }
 988
 989     return true;
 990 }
 991
 992 bool Preferences::isMagnetLinkAssocSet()
 993 {
 994     const QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
 995
 996     // Check magnet link assoc
 997     const QString shellCommand = Utils::Fs::toNativePath(settings.value("magnet/shell/open/command/Default", "").toString());
 998
 999     const QRegularExpressionMatch exeRegMatch = QRegularExpression("\"([^\"]+)\".*").match(shellCommand);
1000     if (!exeRegMatch.hasMatch())
1001         return false;
1002
1003     const QString assocExe = exeRegMatch.captured(1);
1004     if (assocExe.compare(Utils::Fs::toNativePath(qApp->applicationFilePath()), Qt::CaseInsensitive) != 0)
1005         return false;
1006
1007     return true;
1008 }
1009
1010 void Preferences::setTorrentFileAssoc(const bool set)
1011 {
1012     QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
1013
1014     // .Torrent association
1015     if (set)
1016     {
1017         const QString oldProgId = settings.value(".torrent/Default").toString();
1018         if (!oldProgId.isEmpty() && (oldProgId != "qBittorrent"))
1019             settings.setValue(".torrent/OpenWithProgids/" + oldProgId, "");
1020         settings.setValue(".torrent/Default", "qBittorrent");
1021     }
1022     else if (isTorrentFileAssocSet())
1023     {
1024         settings.setValue(".torrent/Default", "");
1025     }
1026
1027     SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, 0, 0);
1028 }
1029
1030 void Preferences::setMagnetLinkAssoc(const bool set)
1031 {
1032     QSettings settings("HKEY_CURRENT_USER\\Software\\Classes", QSettings::NativeFormat);
1033
1034     // Magnet association
1035     if (set)
1036     {
1037         const QString commandStr = '"' + qApp->applicationFilePath() + "\" \"%1\"";
1038         const QString iconStr = '"' + qApp->applicationFilePath() + "\",1";
1039
1040         settings.setValue("magnet/Default", "URL:Magnet link");
1041         settings.setValue("magnet/Content Type", "application/x-magnet");
1042         settings.setValue("magnet/URL Protocol", "");
1043         settings.setValue("magnet/DefaultIcon/Default", Utils::Fs::toNativePath(iconStr));
1044         settings.setValue("magnet/shell/Default", "open");
1045         settings.setValue("magnet/shell/open/command/Default", Utils::Fs::toNativePath(commandStr));
1046     }
1047     else if (isMagnetLinkAssocSet())
1048     {
1049         settings.remove("magnet");
1050     }
1051
1052     SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, 0, 0);
1053 }
1054 #endif // Q_OS_WIN
1055
1056 #ifdef Q_OS_MACOS
1057 namespace
1058 {
1059     const CFStringRef torrentExtension = CFSTR("torrent");
1060     const CFStringRef magnetUrlScheme = CFSTR("magnet");
1061 }
1062
1063 bool Preferences::isTorrentFileAssocSet()
1064 {
1065     bool isSet = false;
1066     const CFStringRef torrentId = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, torrentExtension, NULL);
1067     if (torrentId != NULL)
1068     {
1069         const CFStringRef defaultHandlerId = LSCopyDefaultRoleHandlerForContentType(torrentId, kLSRolesViewer);
1070         if (defaultHandlerId != NULL)
1071         {
1072             const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1073             isSet = CFStringCompare(myBundleId, defaultHandlerId, 0) == kCFCompareEqualTo;
1074             CFRelease(defaultHandlerId);
1075         }
1076         CFRelease(torrentId);
1077     }
1078     return isSet;
1079 }
1080
1081 bool Preferences::isMagnetLinkAssocSet()
1082 {
1083     bool isSet = false;
1084     const CFStringRef defaultHandlerId = LSCopyDefaultHandlerForURLScheme(magnetUrlScheme);
1085     if (defaultHandlerId != NULL)
1086     {
1087         const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1088         isSet = CFStringCompare(myBundleId, defaultHandlerId, 0) == kCFCompareEqualTo;
1089         CFRelease(defaultHandlerId);
1090     }
1091     return isSet;
1092 }
1093
1094 void Preferences::setTorrentFileAssoc()
1095 {
1096     if (isTorrentFileAssocSet())
1097         return;
1098     const CFStringRef torrentId = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, torrentExtension, NULL);
1099     if (torrentId != NULL)
1100     {
1101         const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1102         LSSetDefaultRoleHandlerForContentType(torrentId, kLSRolesViewer, myBundleId);
1103         CFRelease(torrentId);
1104     }
1105 }
1106
1107 void Preferences::setMagnetLinkAssoc()
1108 {
1109     if (isMagnetLinkAssocSet())
1110         return;
1111     const CFStringRef myBundleId = CFBundleGetIdentifier(CFBundleGetMainBundle());
1112     LSSetDefaultHandlerForURLScheme(magnetUrlScheme, myBundleId);
1113 }
1114 #endif // Q_OS_MACOS
1115
1116 int Preferences::getTrackerPort() const
1117 {
1118     return value("Preferences/Advanced/trackerPort", 9000).toInt();
1119 }
1120
1121 void Preferences::setTrackerPort(const int port)
1122 {
1123     setValue("Preferences/Advanced/trackerPort", port);
1124 }
1125
1126 #if defined(Q_OS_WIN) || defined(Q_OS_MACOS)
1127 bool Preferences::isUpdateCheckEnabled() const
1128 {
1129     return value("Preferences/Advanced/updateCheck", true).toBool();
1130 }
1131
1132 void Preferences::setUpdateCheckEnabled(const bool enabled)
1133 {
1134     setValue("Preferences/Advanced/updateCheck", enabled);
1135 }
1136 #endif
1137
1138 bool Preferences::confirmTorrentDeletion() const
1139 {
1140     return value("Preferences/Advanced/confirmTorrentDeletion", true).toBool();
1141 }
1142
1143 void Preferences::setConfirmTorrentDeletion(const bool enabled)
1144 {
1145     setValue("Preferences/Advanced/confirmTorrentDeletion", enabled);
1146 }
1147
1148 bool Preferences::confirmTorrentRecheck() const
1149 {
1150     return value("Preferences/Advanced/confirmTorrentRecheck", true).toBool();
1151 }
1152
1153 void Preferences::setConfirmTorrentRecheck(const bool enabled)
1154 {
1155     setValue("Preferences/Advanced/confirmTorrentRecheck", enabled);
1156 }
1157
1158 bool Preferences::confirmRemoveAllTags() const
1159 {
1160     return value("Preferences/Advanced/confirmRemoveAllTags", true).toBool();
1161 }
1162
1163 void Preferences::setConfirmRemoveAllTags(const bool enabled)
1164 {
1165     setValue("Preferences/Advanced/confirmRemoveAllTags", enabled);
1166 }
1167
1168 #ifndef Q_OS_MACOS
1169 TrayIcon::Style Preferences::trayIconStyle() const
1170 {
1171     return TrayIcon::Style(value("Preferences/Advanced/TrayIconStyle", TrayIcon::NORMAL).toInt());
1172 }
1173
1174 void Preferences::setTrayIconStyle(const TrayIcon::Style style)
1175 {
1176     setValue("Preferences/Advanced/TrayIconStyle", style);
1177 }
1178 #endif
1179
1180 // Stuff that don't appear in the Options GUI but are saved
1181 // in the same file.
1182
1183 QDateTime Preferences::getDNSLastUpd() const
1184 {
1185     return value("DNSUpdater/lastUpdateTime").toDateTime();
1186 }
1187
1188 void Preferences::setDNSLastUpd(const QDateTime &date)
1189 {
1190     setValue("DNSUpdater/lastUpdateTime", date);
1191 }
1192
1193 QString Preferences::getDNSLastIP() const
1194 {
1195     return value("DNSUpdater/lastIP").toString();
1196 }
1197
1198 void Preferences::setDNSLastIP(const QString &ip)
1199 {
1200     setValue("DNSUpdater/lastIP", ip);
1201 }
1202
1203 bool Preferences::getAcceptedLegal() const
1204 {
1205     return value("LegalNotice/Accepted", false).toBool();
1206 }
1207
1208 void Preferences::setAcceptedLegal(const bool accepted)
1209 {
1210     setValue("LegalNotice/Accepted", accepted);
1211 }
1212
1213 QByteArray Preferences::getMainGeometry() const
1214 {
1215     return value("MainWindow/geometry").toByteArray();
1216 }
1217
1218 void Preferences::setMainGeometry(const QByteArray &geometry)
1219 {
1220     setValue("MainWindow/geometry", geometry);
1221 }
1222
1223 QByteArray Preferences::getMainVSplitterState() const
1224 {
1225     return value("MainWindow/qt5/vsplitterState").toByteArray();
1226 }
1227
1228 void Preferences::setMainVSplitterState(const QByteArray &state)
1229 {
1230     setValue("MainWindow/qt5/vsplitterState", state);
1231 }
1232
1233 QString Preferences::getMainLastDir() const
1234 {
1235     return value("MainWindowLastDir", QDir::homePath()).toString();
1236 }
1237
1238 void Preferences::setMainLastDir(const QString &path)
1239 {
1240     setValue("MainWindowLastDir", path);
1241 }
1242
1243 QSize Preferences::getPrefSize() const
1244 {
1245     return value("Preferences/State/size").toSize();
1246 }
1247
1248 void Preferences::setPrefSize(const QSize &size)
1249 {
1250     setValue("Preferences/State/size", size);
1251 }
1252
1253 QStringList Preferences::getPrefHSplitterSizes() const
1254 {
1255     return value("Preferences/State/hSplitterSizes").toStringList();
1256 }
1257
1258 void Preferences::setPrefHSplitterSizes(const QStringList &sizes)
1259 {
1260     setValue("Preferences/State/hSplitterSizes", sizes);
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 }