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 "ui_torrentsharelimitswidget.h"
  32
  33 namespace
  34 {
  35     enum ShareLimitModeIndex
  36     {
  37         DefaultModeIndex,
  38         UnlimitedModeIndex,
  39         AssignedModeIndex
  40     };
  41 }
  42
  43 TorrentShareLimitsWidget::TorrentShareLimitsWidget(QWidget *parent, const qreal ratioLimit
  44         , const int seedingTimeLimit, const int inactiveSeedingTimeLimit)
  45     : QWidget(parent)
  46     , m_ui {new Ui::TorrentShareLimitsWidget}
  47 {
  48     m_ui->setupUi(this);
  49
  50     connect(m_ui->comboBoxRatioMode, &QComboBox::currentIndexChanged, this, [this](const int index)
  51     {
  52         m_ui->spinBoxRatioValue->setEnabled(index == AssignedModeIndex);
  53         if (index == AssignedModeIndex)
  54         {
  55             m_ui->spinBoxRatioValue->setValue(m_ratioLimit);
  56         }
  57         else
  58         {
  59             m_ratioLimit = m_ui->spinBoxRatioValue->value();
  60             m_ui->spinBoxRatioValue->clear();
  61         }
  62     });
  63     connect(m_ui->comboBoxSeedingTimeMode, &QComboBox::currentIndexChanged, this, [this](const int index)
  64     {
  65         m_ui->spinBoxSeedingTimeValue->setEnabled(index == AssignedModeIndex);
  66         if (index == AssignedModeIndex)
  67         {
  68             m_ui->spinBoxSeedingTimeValue->setValue(m_seedingTimeLimit);
  69             m_ui->spinBoxSeedingTimeValue->setSuffix(tr(" min"));
  70         }
  71         else
  72         {
  73             m_seedingTimeLimit = m_ui->spinBoxSeedingTimeValue->value();
  74             m_ui->spinBoxSeedingTimeValue->setSuffix({});
  75             m_ui->spinBoxSeedingTimeValue->clear();
  76         }
  77     });
  78     connect(m_ui->comboBoxInactiveSeedingTimeMode, &QComboBox::currentIndexChanged, this, [this](const int index)
  79     {
  80         m_ui->spinBoxInactiveSeedingTimeValue->setEnabled(index == AssignedModeIndex);
  81         if (index == AssignedModeIndex)
  82         {
  83             m_ui->spinBoxInactiveSeedingTimeValue->setValue(m_inactiveSeedingTimeLimit);
  84             m_ui->spinBoxInactiveSeedingTimeValue->setSuffix(tr(" min"));
  85         }
  86         else
  87         {
  88             m_inactiveSeedingTimeLimit = m_ui->spinBoxInactiveSeedingTimeValue->value();
  89             m_ui->spinBoxInactiveSeedingTimeValue->setSuffix({});
  90             m_ui->spinBoxInactiveSeedingTimeValue->clear();
  91         }
  92     });
  93
  94     setTorrentShareLimits(ratioLimit, seedingTimeLimit, inactiveSeedingTimeLimit);
  95 }
  96
  97 TorrentShareLimitsWidget::~TorrentShareLimitsWidget()
  98 {
  99     delete m_ui;
 100 }
 101
 102 void TorrentShareLimitsWidget::setTorrentShareLimits(const qreal ratioLimit, const int seedingTimeLimit, const int inactiveSeedingTimeLimit)
 103 {
 104     if (ratioLimit == BitTorrent::Torrent::USE_GLOBAL_RATIO)
 105     {
 106         m_ui->comboBoxRatioMode->setCurrentIndex(DefaultModeIndex);
 107     }
 108     else if (ratioLimit == BitTorrent::Torrent::NO_RATIO_LIMIT)
 109     {
 110         m_ui->comboBoxRatioMode->setCurrentIndex(UnlimitedModeIndex);
 111     }
 112     else
 113     {
 114         m_ui->comboBoxRatioMode->setCurrentIndex(AssignedModeIndex);
 115         m_ui->spinBoxRatioValue->setValue(ratioLimit);
 116     }
 117
 118     if (seedingTimeLimit == BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME)
 119     {
 120         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(DefaultModeIndex);
 121     }
 122     else if (seedingTimeLimit == BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT)
 123     {
 124         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(UnlimitedModeIndex);
 125     }
 126     else
 127     {
 128         m_ui->comboBoxSeedingTimeMode->setCurrentIndex(AssignedModeIndex);
 129         m_ui->spinBoxSeedingTimeValue->setValue(seedingTimeLimit);
 130     }
 131
 132     if (inactiveSeedingTimeLimit == BitTorrent::Torrent::USE_GLOBAL_INACTIVE_SEEDING_TIME)
 133     {
 134         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(DefaultModeIndex);
 135     }
 136     else if (inactiveSeedingTimeLimit == BitTorrent::Torrent::NO_INACTIVE_SEEDING_TIME_LIMIT)
 137     {
 138         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(UnlimitedModeIndex);
 139     }
 140     else
 141     {
 142         m_ui->comboBoxInactiveSeedingTimeMode->setCurrentIndex(AssignedModeIndex);
 143         m_ui->spinBoxInactiveSeedingTimeValue->setValue(inactiveSeedingTimeLimit);
 144     }
 145 }
 146
 147 qreal TorrentShareLimitsWidget::ratioLimit() const
 148 {
 149     switch (m_ui->comboBoxRatioMode->currentIndex())
 150     {
 151     case DefaultModeIndex:
 152     default:
 153         return BitTorrent::Torrent::USE_GLOBAL_RATIO;
 154     case UnlimitedModeIndex:
 155         return BitTorrent::Torrent::NO_RATIO_LIMIT;
 156     case AssignedModeIndex:
 157         return m_ui->spinBoxRatioValue->value();
 158     }
 159 }
 160
 161 int TorrentShareLimitsWidget::seedingTimeLimit() const
 162 {
 163     switch (m_ui->comboBoxSeedingTimeMode->currentIndex())
 164     {
 165     case DefaultModeIndex:
 166     default:
 167         return BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME;
 168     case UnlimitedModeIndex:
 169         return BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT;
 170     case AssignedModeIndex:
 171         return m_ui->spinBoxSeedingTimeValue->value();
 172     }
 173 }
 174
 175 int TorrentShareLimitsWidget::inactiveSeedingTimeLimit() const
 176 {
 177     switch (m_ui->comboBoxInactiveSeedingTimeMode->currentIndex())
 178     {
 179     case DefaultModeIndex:
 180     default:
 181         return BitTorrent::Torrent::USE_GLOBAL_INACTIVE_SEEDING_TIME;
 182     case UnlimitedModeIndex:
 183         return BitTorrent::Torrent::NO_INACTIVE_SEEDING_TIME_LIMIT;
 184     case AssignedModeIndex:
 185         return m_ui->spinBoxInactiveSeedingTimeValue->value();
 186     }
 187 }