src/gui/torrentsharelimitswidget.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2024  Vladimir Golovnev <glassez@yandex.ru>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  *
  19  * In addition, as a special exception, the copyright holders give permission to
  20  * link this program with the OpenSSL project's "OpenSSL" library (or with
  21  * modified versions of it that use the same license as the "OpenSSL" library),
  22  * and distribute the linked executables. You must obey the GNU General Public
  23  * License in all respects for all of the code used other than "OpenSSL".  If you
  24  * modify file(s), you may extend this exception to your version of the file(s),
  25  * but you are not obligated to do so. If you do not wish to do so, delete this
  26  * exception statement from your version.
  27  */
  28
  29 #include "torrentsharelimitswidget.h"
  30
  31 #include "base/bittorrent/torrent.h"
  32 #include "ui_torrentsharelimitswidget.h"
  33
  34 namespace
  35 {
  36     enum ShareLimitModeIndex
  37     {
  38         UninitializedModeIndex = -1,
  39         DefaultModeIndex,
  40         UnlimitedModeIndex,
  41         AssignedModeIndex
  42     };
  43 }
  44
  45 TorrentShareLimitsWidget::TorrentShareLimitsWidget(QWidget *parent)
  46     : QWidget(parent)
  47     , m_ui {new Ui::TorrentShareLimitsWidget}
  48 {
  49     m_ui->setupUi(this);
  50
  51     m_ui->spinBoxRatioValue->setEnabled(false);
  52     m_ui->spinBoxRatioValue->setSuffix({});
  53     m_ui->spinBoxRatioValue->clear();
  54     m_ui->spinBoxSeedingTimeValue->setEnabled(false);
  55     m_ui->spinBoxSeedingTimeValue->setSuffix({});
  56     m_ui->spinBoxSeedingTimeValue->clear();
  57     m_ui->spinBoxInactiveSeedingTimeValue->setEnabled(false);
  58     m_ui->spinBoxInactiveSeedingTimeValue->setSuffix({});
  59     m_ui->spinBoxInactiveSeedingTimeValue->clear();
  60
  61     connect(m_ui->comboBoxRatioMode, &QComboBox::currentIndexChanged, this, &TorrentShareLimitsWidget::refreshRatioLimitControls);
  62     connect(m_ui->comboBoxSeedingTimeMode, &QComboBox::currentIndexChanged, this, &TorrentShareLimitsWidget::refreshSeedingTimeLimitControls);
  63     connect(m_ui->comboBoxInactiveSeedingTimeMode, &QComboBox::currentIndexChanged, this, &TorrentShareLimitsWidget::refreshInactiveSeedingTimeLimitControls);
  64 }
  65
  66 TorrentShareLimitsWidget::~TorrentShareLimitsWidget()
  67 {
  68     delete m_ui;
  69 }
  70
  71 void TorrentShareLimitsWidget::setRatioLimit(const qreal ratioLimit)
  72 {
  73     if (ratioLimit == BitTorrent::Torrent::USE_GLOBAL_RATIO)
  74     {
  75         m_ui->comboBoxRatioMode->setCurrentIndex(DefaultModeIndex);
  76     }
  77     else if (ratioLimit == BitTorrent::Torrent::NO_RATIO_LIMIT)
  78     {
  79         m_ui->comboBoxRatioMode->setCurrentIndex(UnlimitedModeIndex);
  80     }
  81     else
  82     {
  83         m_ui->comboBoxRatioMode->setCurrentIndex(AssignedModeIndex);
  84         m_ui->spinBoxRatioValue->setValue(ratioLimit);
  85     }
  86 }
  87
  88 void TorrentShareLimitsWidget::setSeedingTimeLimit(const int seedingTimeLimit)
  89 {
  90     if (seedingTimeLimit == BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME)
  91     {
  92         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(DefaultModeIndex);
  93     }
  94     else if (seedingTimeLimit == BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT)
  95     {
  96         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(UnlimitedModeIndex);
  97     }
  98     else
  99     {
 100         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(AssignedModeIndex);
 101         m_ui->spinBoxSeedingTimeValue->setValue(seedingTimeLimit);
 102     }
 103 }
 104
 105 void TorrentShareLimitsWidget::setInactiveSeedingTimeLimit(const int inactiveSeedingTimeLimit)
 106 {
 107     if (inactiveSeedingTimeLimit == BitTorrent::Torrent::USE_GLOBAL_INACTIVE_SEEDING_TIME)
 108     {
 109         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(DefaultModeIndex);
 110     }
 111     else if (inactiveSeedingTimeLimit == BitTorrent::Torrent::NO_INACTIVE_SEEDING_TIME_LIMIT)
 112     {
 113         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(UnlimitedModeIndex);
 114     }
 115     else
 116     {
 117         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(AssignedModeIndex);
 118         m_ui->spinBoxInactiveSeedingTimeValue->setValue(inactiveSeedingTimeLimit);
 119     }
 120 }
 121
 122 void TorrentShareLimitsWidget::setDefaultLimits(const qreal ratioLimit, const int seedingTimeLimit, const int inactiveSeedingTimeLimit)
 123 {
 124     if (m_defaultRatioLimit != ratioLimit)
 125     {
 126         m_defaultRatioLimit = ratioLimit;
 127         refreshRatioLimitControls();
 128     }
 129
 130     if (m_defaultSeedingTimeLimit != seedingTimeLimit)
 131     {
 132         m_defaultSeedingTimeLimit = seedingTimeLimit;
 133         refreshSeedingTimeLimitControls();
 134     }
 135
 136     if (m_defaultInactiveSeedingTimeLimit != inactiveSeedingTimeLimit)
 137     {
 138         m_defaultInactiveSeedingTimeLimit = inactiveSeedingTimeLimit;
 139         refreshInactiveSeedingTimeLimitControls();
 140     }
 141 }
 142
 143 std::optional<qreal> TorrentShareLimitsWidget::ratioLimit() const
 144 {
 145     switch (m_ui->comboBoxRatioMode->currentIndex())
 146     {
 147     case DefaultModeIndex:
 148         return BitTorrent::Torrent::USE_GLOBAL_RATIO;
 149     case UnlimitedModeIndex:
 150         return BitTorrent::Torrent::NO_RATIO_LIMIT;
 151     case AssignedModeIndex:
 152         return m_ui->spinBoxRatioValue->value();
 153     default:
 154         return std::nullopt;
 155     }
 156 }
 157
 158 std::optional<int> TorrentShareLimitsWidget::seedingTimeLimit() const
 159 {
 160     switch (m_ui->comboBoxSeedingTimeMode->currentIndex())
 161     {
 162     case DefaultModeIndex:
 163         return BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME;
 164     case UnlimitedModeIndex:
 165         return BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT;
 166     case AssignedModeIndex:
 167         return m_ui->spinBoxSeedingTimeValue->value();
 168     default:
 169         return std::nullopt;
 170     }
 171 }
 172
 173 std::optional<int> TorrentShareLimitsWidget::inactiveSeedingTimeLimit() const
 174 {
 175     switch (m_ui->comboBoxInactiveSeedingTimeMode->currentIndex())
 176     {
 177     case DefaultModeIndex:
 178         return BitTorrent::Torrent::USE_GLOBAL_INACTIVE_SEEDING_TIME;
 179     case UnlimitedModeIndex:
 180         return BitTorrent::Torrent::NO_INACTIVE_SEEDING_TIME_LIMIT;
 181     case AssignedModeIndex:
 182         return m_ui->spinBoxInactiveSeedingTimeValue->value();
 183     default:
 184         return std::nullopt;
 185     }
 186 }
 187
 188 void TorrentShareLimitsWidget::refreshRatioLimitControls()
 189 {
 190     const auto index = m_ui->comboBoxRatioMode->currentIndex();
 191
 192     m_ui->spinBoxRatioValue->setEnabled(index == AssignedModeIndex);
 193     if (index == AssignedModeIndex)
 194     {
 195         m_ui->spinBoxRatioValue->setValue(m_ratioLimit);
 196     }
 197     else if ((index == DefaultModeIndex) && (m_defaultRatioLimit >= 0))
 198     {
 199         m_ui->spinBoxRatioValue->setValue(m_defaultRatioLimit);
 200     }
 201     else
 202     {
 203         m_ratioLimit = m_ui->spinBoxRatioValue->value();
 204         m_ui->spinBoxRatioValue->clear();
 205     }
 206 }
 207
 208 void TorrentShareLimitsWidget::refreshSeedingTimeLimitControls()
 209 {
 210     const auto index = m_ui->comboBoxSeedingTimeMode->currentIndex();
 211
 212     m_ui->spinBoxSeedingTimeValue->setEnabled(index == AssignedModeIndex);
 213     if (index == AssignedModeIndex)
 214     {
 215         m_ui->spinBoxSeedingTimeValue->setValue(m_seedingTimeLimit);
 216         m_ui->spinBoxSeedingTimeValue->setSuffix(tr(" min"));
 217     }
 218     else if ((index == DefaultModeIndex) && (m_defaultSeedingTimeLimit >= 0))
 219     {
 220         m_ui->spinBoxSeedingTimeValue->setValue(m_defaultSeedingTimeLimit);
 221         m_ui->spinBoxSeedingTimeValue->setSuffix(tr(" min"));
 222     }
 223     else
 224     {
 225         m_seedingTimeLimit = m_ui->spinBoxSeedingTimeValue->value();
 226         m_ui->spinBoxSeedingTimeValue->setSuffix({});
 227         m_ui->spinBoxSeedingTimeValue->clear();
 228     }
 229 }
 230
 231 void TorrentShareLimitsWidget::refreshInactiveSeedingTimeLimitControls()
 232 {
 233     const auto index = m_ui->comboBoxInactiveSeedingTimeMode->currentIndex();
 234
 235     m_ui->spinBoxInactiveSeedingTimeValue->setEnabled(index == AssignedModeIndex);
 236     if (index == AssignedModeIndex)
 237     {
 238         m_ui->spinBoxInactiveSeedingTimeValue->setValue(m_inactiveSeedingTimeLimit);
 239         m_ui->spinBoxInactiveSeedingTimeValue->setSuffix(tr(" min"));
 240     }
 241     else if ((index == DefaultModeIndex) && (m_defaultInactiveSeedingTimeLimit >= 0))
 242     {
 243         m_ui->spinBoxInactiveSeedingTimeValue->setValue(m_defaultInactiveSeedingTimeLimit);
 244         m_ui->spinBoxInactiveSeedingTimeValue->setSuffix(tr(" min"));
 245     }
 246     else
 247     {
 248         m_inactiveSeedingTimeLimit = m_ui->spinBoxInactiveSeedingTimeValue->value();
 249         m_ui->spinBoxInactiveSeedingTimeValue->setSuffix({});
 250         m_ui->spinBoxInactiveSeedingTimeValue->clear();
 251     }
 252 }