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     enum ShareLimitActionIndex
  45     {
  46         UninitializedActionIndex = -1,
  47         DefaultActionIndex,
  48         StopActionIndex,
  49         RemoveActionIndex,
  50         RemoveWithContentActionIndex,
  51         SuperSeedingActionIndex
  52     };
  53 }
  54
  55 TorrentShareLimitsWidget::TorrentShareLimitsWidget(QWidget *parent)
  56     : QWidget(parent)
  57     , m_ui {new Ui::TorrentShareLimitsWidget}
  58 {
  59     m_ui->setupUi(this);
  60
  61     m_ui->spinBoxRatioValue->setEnabled(false);
  62     m_ui->spinBoxRatioValue->setSuffix({});
  63     m_ui->spinBoxRatioValue->clear();
  64     m_ui->spinBoxSeedingTimeValue->setEnabled(false);
  65     m_ui->spinBoxSeedingTimeValue->setSuffix({});
  66     m_ui->spinBoxSeedingTimeValue->clear();
  67     m_ui->spinBoxInactiveSeedingTimeValue->setEnabled(false);
  68     m_ui->spinBoxInactiveSeedingTimeValue->setSuffix({});
  69     m_ui->spinBoxInactiveSeedingTimeValue->clear();
  70
  71     connect(m_ui->comboBoxRatioMode, &QComboBox::currentIndexChanged, this, &TorrentShareLimitsWidget::refreshRatioLimitControls);
  72     connect(m_ui->comboBoxSeedingTimeMode, &QComboBox::currentIndexChanged, this, &TorrentShareLimitsWidget::refreshSeedingTimeLimitControls);
  73     connect(m_ui->comboBoxInactiveSeedingTimeMode, &QComboBox::currentIndexChanged, this, &TorrentShareLimitsWidget::refreshInactiveSeedingTimeLimitControls);
  74 }
  75
  76 TorrentShareLimitsWidget::~TorrentShareLimitsWidget()
  77 {
  78     delete m_ui;
  79 }
  80
  81 void TorrentShareLimitsWidget::setRatioLimit(const qreal ratioLimit)
  82 {
  83     if (ratioLimit == BitTorrent::Torrent::USE_GLOBAL_RATIO)
  84     {
  85         m_ui->comboBoxRatioMode->setCurrentIndex(DefaultModeIndex);
  86     }
  87     else if (ratioLimit == BitTorrent::Torrent::NO_RATIO_LIMIT)
  88     {
  89         m_ui->comboBoxRatioMode->setCurrentIndex(UnlimitedModeIndex);
  90     }
  91     else
  92     {
  93         m_ui->comboBoxRatioMode->setCurrentIndex(AssignedModeIndex);
  94         m_ui->spinBoxRatioValue->setValue(ratioLimit);
  95     }
  96 }
  97
  98 void TorrentShareLimitsWidget::setSeedingTimeLimit(const int seedingTimeLimit)
  99 {
 100     if (seedingTimeLimit == BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME)
 101     {
 102         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(DefaultModeIndex);
 103     }
 104     else if (seedingTimeLimit == BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT)
 105     {
 106         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(UnlimitedModeIndex);
 107     }
 108     else
 109     {
 110         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(AssignedModeIndex);
 111         m_ui->spinBoxSeedingTimeValue->setValue(seedingTimeLimit);
 112     }
 113 }
 114
 115 void TorrentShareLimitsWidget::setInactiveSeedingTimeLimit(const int inactiveSeedingTimeLimit)
 116 {
 117     if (inactiveSeedingTimeLimit == BitTorrent::Torrent::USE_GLOBAL_INACTIVE_SEEDING_TIME)
 118     {
 119         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(DefaultModeIndex);
 120     }
 121     else if (inactiveSeedingTimeLimit == BitTorrent::Torrent::NO_INACTIVE_SEEDING_TIME_LIMIT)
 122     {
 123         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(UnlimitedModeIndex);
 124     }
 125     else
 126     {
 127         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(AssignedModeIndex);
 128         m_ui->spinBoxInactiveSeedingTimeValue->setValue(inactiveSeedingTimeLimit);
 129     }
 130 }
 131
 132 void TorrentShareLimitsWidget::setShareLimitAction(const BitTorrent::ShareLimitAction action)
 133 {
 134     switch (action)
 135     {
 136     case BitTorrent::ShareLimitAction::Default:
 137     default:
 138         m_ui->comboBoxAction->setCurrentIndex(DefaultActionIndex);
 139         break;
 140     case BitTorrent::ShareLimitAction::Stop:
 141         m_ui->comboBoxAction->setCurrentIndex(StopActionIndex);
 142         break;
 143     case BitTorrent::ShareLimitAction::Remove:
 144         m_ui->comboBoxAction->setCurrentIndex(RemoveActionIndex);
 145         break;
 146     case BitTorrent::ShareLimitAction::RemoveWithContent:
 147         m_ui->comboBoxAction->setCurrentIndex(RemoveWithContentActionIndex);
 148         break;
 149     case BitTorrent::ShareLimitAction::EnableSuperSeeding:
 150         m_ui->comboBoxAction->setCurrentIndex(SuperSeedingActionIndex);
 151         break;
 152     }
 153 }
 154
 155 void TorrentShareLimitsWidget::setDefaultLimits(const qreal ratioLimit, const int seedingTimeLimit, const int inactiveSeedingTimeLimit)
 156 {
 157     if (m_defaultRatioLimit != ratioLimit)
 158     {
 159         m_defaultRatioLimit = ratioLimit;
 160         refreshRatioLimitControls();
 161     }
 162
 163     if (m_defaultSeedingTimeLimit != seedingTimeLimit)
 164     {
 165         m_defaultSeedingTimeLimit = seedingTimeLimit;
 166         refreshSeedingTimeLimitControls();
 167     }
 168
 169     if (m_defaultInactiveSeedingTimeLimit != inactiveSeedingTimeLimit)
 170     {
 171         m_defaultInactiveSeedingTimeLimit = inactiveSeedingTimeLimit;
 172         refreshInactiveSeedingTimeLimitControls();
 173     }
 174 }
 175
 176 std::optional<qreal> TorrentShareLimitsWidget::ratioLimit() const
 177 {
 178     switch (m_ui->comboBoxRatioMode->currentIndex())
 179     {
 180     case DefaultModeIndex:
 181         return BitTorrent::Torrent::USE_GLOBAL_RATIO;
 182     case UnlimitedModeIndex:
 183         return BitTorrent::Torrent::NO_RATIO_LIMIT;
 184     case AssignedModeIndex:
 185         return m_ui->spinBoxRatioValue->value();
 186     default:
 187         return std::nullopt;
 188     }
 189 }
 190
 191 std::optional<int> TorrentShareLimitsWidget::seedingTimeLimit() const
 192 {
 193     switch (m_ui->comboBoxSeedingTimeMode->currentIndex())
 194     {
 195     case DefaultModeIndex:
 196         return BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME;
 197     case UnlimitedModeIndex:
 198         return BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT;
 199     case AssignedModeIndex:
 200         return m_ui->spinBoxSeedingTimeValue->value();
 201     default:
 202         return std::nullopt;
 203     }
 204 }
 205
 206 std::optional<int> TorrentShareLimitsWidget::inactiveSeedingTimeLimit() const
 207 {
 208     switch (m_ui->comboBoxInactiveSeedingTimeMode->currentIndex())
 209     {
 210     case DefaultModeIndex:
 211         return BitTorrent::Torrent::USE_GLOBAL_INACTIVE_SEEDING_TIME;
 212     case UnlimitedModeIndex:
 213         return BitTorrent::Torrent::NO_INACTIVE_SEEDING_TIME_LIMIT;
 214     case AssignedModeIndex:
 215         return m_ui->spinBoxInactiveSeedingTimeValue->value();
 216     default:
 217         return std::nullopt;
 218     }
 219 }
 220
 221 std::optional<BitTorrent::ShareLimitAction> TorrentShareLimitsWidget::shareLimitAction() const
 222 {
 223     switch (m_ui->comboBoxAction->currentIndex())
 224     {
 225     case DefaultActionIndex:
 226         return BitTorrent::ShareLimitAction::Default;
 227     case StopActionIndex:
 228         return BitTorrent::ShareLimitAction::Stop;
 229     case RemoveActionIndex:
 230         return BitTorrent::ShareLimitAction::Remove;
 231     case RemoveWithContentActionIndex:
 232         return BitTorrent::ShareLimitAction::RemoveWithContent;
 233     case SuperSeedingActionIndex:
 234         return BitTorrent::ShareLimitAction::EnableSuperSeeding;
 235     default:
 236         return std::nullopt;
 237     }
 238 }
 239
 240 void TorrentShareLimitsWidget::refreshRatioLimitControls()
 241 {
 242     const auto index = m_ui->comboBoxRatioMode->currentIndex();
 243
 244     m_ui->spinBoxRatioValue->setEnabled(index == AssignedModeIndex);
 245     if (index == AssignedModeIndex)
 246     {
 247         m_ui->spinBoxRatioValue->setValue(m_ratioLimit);
 248     }
 249     else if ((index == DefaultModeIndex) && (m_defaultRatioLimit >= 0))
 250     {
 251         m_ui->spinBoxRatioValue->setValue(m_defaultRatioLimit);
 252     }
 253     else
 254     {
 255         m_ratioLimit = m_ui->spinBoxRatioValue->value();
 256         m_ui->spinBoxRatioValue->clear();
 257     }
 258 }
 259
 260 void TorrentShareLimitsWidget::refreshSeedingTimeLimitControls()
 261 {
 262     const auto index = m_ui->comboBoxSeedingTimeMode->currentIndex();
 263
 264     m_ui->spinBoxSeedingTimeValue->setEnabled(index == AssignedModeIndex);
 265     if (index == AssignedModeIndex)
 266     {
 267         m_ui->spinBoxSeedingTimeValue->setValue(m_seedingTimeLimit);
 268         m_ui->spinBoxSeedingTimeValue->setSuffix(tr(" min"));
 269     }
 270     else if ((index == DefaultModeIndex) && (m_defaultSeedingTimeLimit >= 0))
 271     {
 272         m_ui->spinBoxSeedingTimeValue->setValue(m_defaultSeedingTimeLimit);
 273         m_ui->spinBoxSeedingTimeValue->setSuffix(tr(" min"));
 274     }
 275     else
 276     {
 277         m_seedingTimeLimit = m_ui->spinBoxSeedingTimeValue->value();
 278         m_ui->spinBoxSeedingTimeValue->setSuffix({});
 279         m_ui->spinBoxSeedingTimeValue->clear();
 280     }
 281 }
 282
 283 void TorrentShareLimitsWidget::refreshInactiveSeedingTimeLimitControls()
 284 {
 285     const auto index = m_ui->comboBoxInactiveSeedingTimeMode->currentIndex();
 286
 287     m_ui->spinBoxInactiveSeedingTimeValue->setEnabled(index == AssignedModeIndex);
 288     if (index == AssignedModeIndex)
 289     {
 290         m_ui->spinBoxInactiveSeedingTimeValue->setValue(m_inactiveSeedingTimeLimit);
 291         m_ui->spinBoxInactiveSeedingTimeValue->setSuffix(tr(" min"));
 292     }
 293     else if ((index == DefaultModeIndex) && (m_defaultInactiveSeedingTimeLimit >= 0))
 294     {
 295         m_ui->spinBoxInactiveSeedingTimeValue->setValue(m_defaultInactiveSeedingTimeLimit);
 296         m_ui->spinBoxInactiveSeedingTimeValue->setSuffix(tr(" min"));
 297     }
 298     else
 299     {
 300         m_inactiveSeedingTimeLimit = m_ui->spinBoxInactiveSeedingTimeValue->value();
 301         m_ui->spinBoxInactiveSeedingTimeValue->setSuffix({});
 302         m_ui->spinBoxInactiveSeedingTimeValue->clear();
 303     }
 304 }