src/gui/torrentoptionsdialog.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2020  thalieht
   4  * Copyright (C) 2011  Christian Kandeler
   5  * Copyright (C) 2011  Christophe Dumez <chris@qbittorrent.org>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  *
  21  * In addition, as a special exception, the copyright holders give permission to
  22  * link this program with the OpenSSL project's "OpenSSL" library (or with
  23  * modified versions of it that use the same license as the "OpenSSL" library),
  24  * and distribute the linked executables. You must obey the GNU General Public
  25  * License in all respects for all of the code used other than "OpenSSL".  If you
  26  * modify file(s), you may extend this exception to your version of the file(s),
  27  * but you are not obligated to do so. If you do not wish to do so, delete this
  28  * exception statement from your version.
  29  */
  30
  31 #include "torrentoptionsdialog.h"
  32
  33 #include <QMessageBox>
  34 #include <QString>
  35
  36 #include "base/bittorrent/infohash.h"
  37 #include "base/bittorrent/session.h"
  38 #include "base/bittorrent/torrent.h"
  39 #include "base/global.h"
  40 #include "base/unicodestrings.h"
  41 #include "ui_torrentoptionsdialog.h"
  42 #include "utils.h"
  43
  44 #define SETTINGS_KEY(name) "TorrentOptionsDialog/" name
  45
  46 namespace
  47 {
  48     const int MIXED_SHARE_LIMITS = -9;
  49
  50     void updateSliderValue(QSlider *slider, const int value)
  51     {
  52         if (value > slider->maximum())
  53             slider->setMaximum(value);
  54         slider->setValue(value);
  55     }
  56 }
  57
  58 TorrentOptionsDialog::TorrentOptionsDialog(QWidget *parent, const QVector<BitTorrent::Torrent *> &torrents)
  59     : QDialog {parent}
  60     , m_ui {new Ui::TorrentOptionsDialog}
  61     , m_storeDialogSize {SETTINGS_KEY("Size")}
  62 {
  63     m_ui->setupUi(this);
  64
  65     Q_ASSERT(!torrents.empty());
  66     const auto *session = BitTorrent::Session::instance();
  67     bool allSameUpLimit = true, allSameDownLimit = true, allSameRatio = true, allSameSeedingTime = true
  68             , allTorrentsArePrivate = true, allSameDHT = true, allSamePEX = true,  allSameLSD = true;
  69
  70     const int firstTorrentUpLimit = qMax(0, torrents[0]->uploadLimit());
  71     const int firstTorrentDownLimit = qMax(0, torrents[0]->downloadLimit());
  72
  73     const qreal firstTorrentRatio = torrents[0]->ratioLimit();
  74     const int firstTorrentSeedingTime = torrents[0]->seedingTimeLimit();
  75
  76     const bool isFirstTorrentDHTDisabled = torrents[0]->isDHTDisabled();
  77     const bool isFirstTorrentPEXDisabled = torrents[0]->isPEXDisabled();
  78     const bool isFirstTorrentLSDDisabled = torrents[0]->isLSDDisabled();
  79
  80     m_torrentIDs.reserve(torrents.size());
  81     for (const BitTorrent::Torrent *torrent : torrents)
  82     {
  83         m_torrentIDs << torrent->id();
  84         if (allSameUpLimit)
  85         {
  86             if (qMax(0, torrent->uploadLimit()) != firstTorrentUpLimit)
  87                 allSameUpLimit = false;
  88         }
  89         if (allSameDownLimit)
  90         {
  91             if (qMax(0, torrent->downloadLimit()) != firstTorrentDownLimit)
  92                 allSameDownLimit = false;
  93         }
  94         if (allSameRatio)
  95         {
  96             if (torrent->ratioLimit() != firstTorrentRatio)
  97                 allSameRatio = false;
  98         }
  99         if (allSameSeedingTime)
 100         {
 101             if (torrent->seedingTimeLimit() != firstTorrentSeedingTime)
 102                 allSameSeedingTime = false;
 103         }
 104         if (allTorrentsArePrivate)
 105         {
 106             if (!torrent->isPrivate())
 107                 allTorrentsArePrivate = false;
 108         }
 109         if (allSameDHT)
 110         {
 111             if (torrent->isDHTDisabled() != isFirstTorrentDHTDisabled)
 112             {
 113                 m_ui->checkDisableDHT->setCheckState(Qt::PartiallyChecked);
 114                 allSameDHT = false;
 115             }
 116         }
 117         if (allSamePEX)
 118         {
 119             if (torrent->isPEXDisabled() != isFirstTorrentPEXDisabled)
 120             {
 121                 m_ui->checkDisablePEX->setCheckState(Qt::PartiallyChecked);
 122                 allSamePEX = false;
 123             }
 124         }
 125         if (allSameLSD)
 126         {
 127             if (torrent->isLSDDisabled() != isFirstTorrentLSDDisabled)
 128             {
 129                 m_ui->checkDisableLSD->setCheckState(Qt::PartiallyChecked);
 130                 allSameLSD = false;
 131             }
 132         }
 133     }
 134
 135     const bool isAltLimitEnabled = session->isAltGlobalSpeedLimitEnabled();
 136     const int globalUploadLimit = isAltLimitEnabled
 137             ? (session->altGlobalUploadSpeedLimit() / 1024)
 138             : (session->globalUploadSpeedLimit() / 1024);
 139     const int globalDownloadLimit = isAltLimitEnabled
 140             ? (session->altGlobalDownloadSpeedLimit() / 1024)
 141             : (session->globalDownloadSpeedLimit() / 1024);
 142
 143     const int uploadVal = qMax(0, (firstTorrentUpLimit / 1024));
 144     const int downloadVal = qMax(0, (firstTorrentDownLimit / 1024));
 145     int maxUpload = (globalUploadLimit <= 0) ? 10000 : globalUploadLimit;
 146     int maxDownload = (globalDownloadLimit <= 0) ? 10000 : globalDownloadLimit;
 147
 148     // This can happen for example if global rate limit is lower than torrent rate limit.
 149     if (uploadVal > maxUpload)
 150         maxUpload = uploadVal;
 151     if (downloadVal > maxDownload)
 152         maxDownload = downloadVal;
 153
 154     m_ui->sliderUploadLimit->setMaximum(maxUpload);
 155     m_ui->sliderUploadLimit->setValue(allSameUpLimit ? uploadVal : (maxUpload / 2));
 156     if (allSameUpLimit)
 157     {
 158         m_ui->spinUploadLimit->setValue(uploadVal);
 159     }
 160     else
 161     {
 162         m_ui->spinUploadLimit->setSpecialValueText(QString::fromUtf8(C_INEQUALITY));
 163         m_ui->spinUploadLimit->setMinimum(-1);
 164         m_ui->spinUploadLimit->setValue(-1);
 165         connect(m_ui->spinUploadLimit, qOverload<int>(&QSpinBox::valueChanged)
 166                            , this, &TorrentOptionsDialog::handleUpSpeedLimitChanged);
 167     }
 168
 169     m_ui->sliderDownloadLimit->setMaximum(maxDownload);
 170     m_ui->sliderDownloadLimit->setValue(allSameDownLimit ? downloadVal : (maxDownload / 2));
 171     if (allSameDownLimit)
 172     {
 173         m_ui->spinDownloadLimit->setValue(downloadVal);
 174     }
 175     else
 176     {
 177         m_ui->spinDownloadLimit->setSpecialValueText(QString::fromUtf8(C_INEQUALITY));
 178         m_ui->spinDownloadLimit->setMinimum(-1);
 179         m_ui->spinDownloadLimit->setValue(-1);
 180         connect(m_ui->spinDownloadLimit, qOverload<int>(&QSpinBox::valueChanged)
 181                            , this, &TorrentOptionsDialog::handleDownSpeedLimitChanged);
 182     }
 183
 184     const bool useGlobalValue = allSameRatio && allSameSeedingTime
 185         && (firstTorrentRatio == BitTorrent::Torrent::USE_GLOBAL_RATIO)
 186         && (firstTorrentSeedingTime == BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME);
 187
 188     if (!allSameRatio || !allSameSeedingTime)
 189     {
 190         m_ui->radioUseGlobalShareLimits->setChecked(false);
 191         m_ui->radioNoLimit->setChecked(false);
 192         m_ui->radioTorrentLimit->setChecked(false);
 193     }
 194     else if (useGlobalValue)
 195     {
 196         m_ui->radioUseGlobalShareLimits->setChecked(true);
 197     }
 198     else if ((firstTorrentRatio == BitTorrent::Torrent::NO_RATIO_LIMIT)
 199              && (firstTorrentSeedingTime == BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT))
 200     {
 201         m_ui->radioNoLimit->setChecked(true);
 202     }
 203     else
 204     {
 205         m_ui->radioTorrentLimit->setChecked(true);
 206         if (firstTorrentRatio >= 0)
 207             m_ui->checkMaxRatio->setChecked(true);
 208         if (firstTorrentSeedingTime >= 0)
 209             m_ui->checkMaxTime->setChecked(true);
 210     }
 211
 212     const qreal maxRatio = (allSameRatio && (firstTorrentRatio >= 0))
 213             ? firstTorrentRatio : session->globalMaxRatio();
 214     const int maxSeedingTime = (allSameSeedingTime && (firstTorrentSeedingTime >= 0))
 215             ? firstTorrentSeedingTime : session->globalMaxSeedingMinutes();
 216     m_ui->spinRatioLimit->setValue(maxRatio);
 217     m_ui->spinTimeLimit->setValue(maxSeedingTime);
 218     handleRatioTypeChanged();
 219
 220     if (!allTorrentsArePrivate)
 221     {
 222         if (m_ui->checkDisableDHT->checkState() != Qt::PartiallyChecked)
 223             m_ui->checkDisableDHT->setChecked(isFirstTorrentDHTDisabled);
 224         if (m_ui->checkDisablePEX->checkState() != Qt::PartiallyChecked)
 225             m_ui->checkDisablePEX->setChecked(isFirstTorrentPEXDisabled);
 226         if (m_ui->checkDisableLSD->checkState() != Qt::PartiallyChecked)
 227             m_ui->checkDisableLSD->setChecked(isFirstTorrentLSDDisabled);
 228     }
 229     else
 230     {
 231         m_ui->checkDisableDHT->setChecked(true);
 232         m_ui->checkDisableDHT->setEnabled(false);
 233         m_ui->checkDisablePEX->setChecked(true);
 234         m_ui->checkDisablePEX->setEnabled(false);
 235         m_ui->checkDisableLSD->setChecked(true);
 236         m_ui->checkDisableLSD->setEnabled(false);
 237     }
 238
 239     const QString privateTorrentsTooltip = tr("Not applicable to private torrents");
 240     m_ui->checkDisableDHT->setToolTip(privateTorrentsTooltip);
 241     m_ui->checkDisablePEX->setToolTip(privateTorrentsTooltip);
 242     m_ui->checkDisableLSD->setToolTip(privateTorrentsTooltip);
 243
 244     m_initialValues =
 245     {
 246         getRatio(),
 247         getSeedingTime(),
 248         m_ui->spinUploadLimit->value(),
 249         m_ui->spinDownloadLimit->value(),
 250         m_ui->checkDisableDHT->checkState(),
 251         m_ui->checkDisablePEX->checkState(),
 252         m_ui->checkDisableLSD->checkState()
 253     };
 254
 255     // Sync up/down speed limit sliders with their corresponding spinboxes
 256     connect(m_ui->sliderUploadLimit, &QSlider::valueChanged, m_ui->spinUploadLimit, &QSpinBox::setValue);
 257     connect(m_ui->sliderDownloadLimit, &QSlider::valueChanged, m_ui->spinDownloadLimit, &QSpinBox::setValue);
 258     connect(m_ui->spinUploadLimit, qOverload<int>(&QSpinBox::valueChanged)
 259             , this, [this](const int value) { updateSliderValue(m_ui->sliderUploadLimit, value); });
 260     connect(m_ui->spinDownloadLimit, qOverload<int>(&QSpinBox::valueChanged)
 261             , this, [this](const int value) { updateSliderValue(m_ui->sliderDownloadLimit, value); });
 262
 263     connect(m_ui->checkMaxRatio, &QCheckBox::toggled, m_ui->spinRatioLimit, &QDoubleSpinBox::setEnabled);
 264     connect(m_ui->checkMaxTime, &QCheckBox::toggled, m_ui->spinTimeLimit, &QSpinBox::setEnabled);
 265
 266     connect(m_ui->buttonGroup, &QButtonGroup::idClicked, this, &TorrentOptionsDialog::handleRatioTypeChanged);
 267
 268     Utils::Gui::resize(this, m_storeDialogSize);
 269 }
 270
 271 TorrentOptionsDialog::~TorrentOptionsDialog()
 272 {
 273     m_storeDialogSize = size();
 274     delete m_ui;
 275 }
 276
 277 void TorrentOptionsDialog::accept()
 278 {
 279     if (m_ui->radioTorrentLimit->isChecked() && !m_ui->checkMaxRatio->isChecked() && !m_ui->checkMaxTime->isChecked())
 280     {
 281         QMessageBox::critical(this, tr("No share limit method selected"), tr("Please select a limit method first"));
 282         return;
 283     }
 284
 285     const auto *session = BitTorrent::Session::instance();
 286     for (const BitTorrent::TorrentID &id : asConst(m_torrentIDs))
 287     {
 288         BitTorrent::Torrent *torrent = session->findTorrent(id);
 289         if (!torrent) continue;
 290
 291         if (m_initialValues.upSpeedLimit != m_ui->spinUploadLimit->value())
 292             torrent->setUploadLimit(m_ui->spinUploadLimit->value() * 1024);
 293         if (m_initialValues.downSpeedLimit != m_ui->spinDownloadLimit->value())
 294             torrent->setDownloadLimit(m_ui->spinDownloadLimit->value() * 1024);
 295
 296         const qreal ratioLimit = getRatio();
 297         if (m_initialValues.ratio != ratioLimit)
 298             torrent->setRatioLimit(ratioLimit);
 299
 300         const int seedingTimeLimit = getSeedingTime();
 301         if (m_initialValues.seedingTime != seedingTimeLimit)
 302             torrent->setSeedingTimeLimit(seedingTimeLimit);
 303
 304         if (!torrent->isPrivate())
 305         {
 306             if (m_initialValues.disableDHT != m_ui->checkDisableDHT->checkState())
 307                 torrent->setDHTDisabled(m_ui->checkDisableDHT->isChecked());
 308             if (m_initialValues.disablePEX != m_ui->checkDisablePEX->checkState())
 309                 torrent->setPEXDisabled(m_ui->checkDisablePEX->isChecked());
 310             if (m_initialValues.disableLSD != m_ui->checkDisableLSD->checkState())
 311                 torrent->setLSDDisabled(m_ui->checkDisableLSD->isChecked());
 312         }
 313     }
 314
 315     QDialog::accept();
 316 }
 317
 318 qreal TorrentOptionsDialog::getRatio() const
 319 {
 320     if (m_ui->buttonGroup->checkedId() == -1) // No radio button is selected
 321         return MIXED_SHARE_LIMITS;
 322
 323     if (m_ui->radioUseGlobalShareLimits->isChecked())
 324         return BitTorrent::Torrent::USE_GLOBAL_RATIO;
 325
 326     if (m_ui->radioNoLimit->isChecked() || !m_ui->checkMaxRatio->isChecked())
 327         return BitTorrent::Torrent::NO_RATIO_LIMIT;
 328
 329     return m_ui->spinRatioLimit->value();
 330 }
 331
 332 int TorrentOptionsDialog::getSeedingTime() const
 333 {
 334     if (m_ui->buttonGroup->checkedId() == -1) // No radio button is selected
 335         return MIXED_SHARE_LIMITS;
 336
 337     if (m_ui->radioUseGlobalShareLimits->isChecked())
 338         return BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME;
 339
 340     if (m_ui->radioNoLimit->isChecked() || !m_ui->checkMaxTime->isChecked())
 341         return  BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT;
 342
 343     return m_ui->spinTimeLimit->value();
 344 }
 345
 346 void TorrentOptionsDialog::handleRatioTypeChanged()
 347 {
 348     m_ui->checkMaxRatio->setEnabled(m_ui->radioTorrentLimit->isChecked());
 349     m_ui->checkMaxTime->setEnabled(m_ui->radioTorrentLimit->isChecked());
 350
 351     m_ui->spinRatioLimit->setEnabled(m_ui->radioTorrentLimit->isChecked() && m_ui->checkMaxRatio->isChecked());
 352     m_ui->spinTimeLimit->setEnabled(m_ui->radioTorrentLimit->isChecked() && m_ui->checkMaxTime->isChecked());
 353 }
 354
 355 void TorrentOptionsDialog::handleUpSpeedLimitChanged()
 356 {
 357     m_ui->spinUploadLimit->setMinimum(0);
 358     m_ui->spinUploadLimit->setSpecialValueText(QString::fromUtf8(C_INFINITY));
 359     disconnect(m_ui->spinUploadLimit, qOverload<int>(&QSpinBox::valueChanged)
 360                    , this, &TorrentOptionsDialog::handleUpSpeedLimitChanged);
 361 }
 362
 363 void TorrentOptionsDialog::handleDownSpeedLimitChanged()
 364 {
 365     m_ui->spinDownloadLimit->setMinimum(0);
 366     m_ui->spinDownloadLimit->setSpecialValueText(QString::fromUtf8(C_INFINITY));
 367     disconnect(m_ui->spinDownloadLimit, qOverload<int>(&QSpinBox::valueChanged)
 368                    , this, &TorrentOptionsDialog::handleDownSpeedLimitChanged);
 369 }