TorrentOptionsDialog Class Reference

#include <torrentoptionsdialog.h>

Inheritance diagram for TorrentOptionsDialog:

Collaboration diagram for TorrentOptionsDialog:

Public Slots
void	accept () override

Public Member Functions
	TorrentOptionsDialog (QWidget *parent, const QVector< BitTorrent::Torrent * > &torrents)
	~TorrentOptionsDialog () override

Private Slots
void	handleCategoryChanged (int index)
void	handleTMMChanged ()
void	handleUseDownloadPathChanged ()
void	handleUpSpeedLimitChanged ()
void	handleDownSpeedLimitChanged ()
void	handleRatioTypeChanged ()

Private Member Functions
qreal	getRatio () const
int	getSeedingTime () const

Private Attributes
QVector< BitTorrent::TorrentID >	m_torrentIDs
Ui::TorrentOptionsDialog *	m_ui
SettingValue< QSize >	m_storeDialogSize
QStringList	m_categories
QString	m_currentCategoriesString
bool	m_allSameCategory = true
QAbstractButton *	m_previousRadio = nullptr
struct {
QString   savePath
QString   downloadPath
QString   category
qreal   ratio
int   seedingTime
int   upSpeedLimit
int   downSpeedLimit
Qt::CheckState   autoTMM
Qt::CheckState   useDownloadPath
Qt::CheckState   disableDHT
Qt::CheckState   disablePEX
Qt::CheckState   disableLSD
Qt::CheckState   sequential
Qt::CheckState   firstLastPieces
}	m_initialValues

Detailed Description

Definition at line 50 of file torrentoptionsdialog.h.

Constructor & Destructor Documentation

TorrentOptionsDialog()

TorrentOptionsDialog::TorrentOptionsDialog ( QWidget *  parent, const QVector< BitTorrent::Torrent * > &  torrents  )

explicit

Definition at line 62 of file torrentoptionsdialog.cpp.

    : QDialog {parent}
    , m_ui {new Ui::TorrentOptionsDialog}
    , m_storeDialogSize {SETTINGS_KEY("Size")}
    , m_currentCategoriesString {QString::fromLatin1("--%1--").arg(tr("Currently used categories"))}
{
    Q_ASSERT(!torrents.empty());
 
    m_ui->setupUi(this);
 
    m_ui->savePath->setMode(FileSystemPathEdit::Mode::DirectorySave);
    m_ui->savePath->setDialogCaption(tr("Choose save path"));
    m_ui->downloadPath->setMode(FileSystemPathEdit::Mode::DirectorySave);
    m_ui->downloadPath->setDialogCaption(tr("Choose save path"));
 
    const auto *session = BitTorrent::Session::instance();
    bool allSameUpLimit = true;
    bool allSameDownLimit = true;
    bool allSameRatio = true;
    bool allSameSeedingTime = true;
    bool allTorrentsArePrivate = true;
    bool allSameDHT = true;
    bool allSamePEX = true;
    bool allSameLSD = true;
    bool allSameSequential = true;
    bool allSameFirstLastPieces = true;
    bool allSameAutoTMM = true;
    bool allSameSavePath = true;
    bool allSameDownloadPath = true;
 
    const bool isFirstTorrentAutoTMMEnabled = torrents[0]->isAutoTMMEnabled();
    const QString firstTorrentSavePath = torrents[0]->savePath();
    const QString firstTorrentDownloadPath = torrents[0]->downloadPath();
    const QString firstTorrentCategory = torrents[0]->category();
 
    const int firstTorrentUpLimit = std::max(0, torrents[0]->uploadLimit());
    const int firstTorrentDownLimit = std::max(0, torrents[0]->downloadLimit());
 
    const qreal firstTorrentRatio = torrents[0]->ratioLimit();
    const int firstTorrentSeedingTime = torrents[0]->seedingTimeLimit();
 
    const bool isFirstTorrentDHTDisabled = torrents[0]->isDHTDisabled();
    const bool isFirstTorrentPEXDisabled = torrents[0]->isPEXDisabled();
    const bool isFirstTorrentLSDDisabled = torrents[0]->isLSDDisabled();
    const bool isFirstTorrentSequentialEnabled = torrents[0]->isSequentialDownload();
    const bool isFirstTorrentFirstLastPiecesEnabled = torrents[0]->hasFirstLastPiecePriority();
 
    m_torrentIDs.reserve(torrents.size());
    for (const BitTorrent::Torrent *torrent : torrents)
    {
        m_torrentIDs << torrent->id();
 
        if (allSameAutoTMM)
        {
            if (torrent->isAutoTMMEnabled() != isFirstTorrentAutoTMMEnabled)
                allSameAutoTMM = false;
        }
        if (allSameSavePath)
        {
            if (torrent->savePath() != firstTorrentSavePath)
                allSameSavePath = false;
        }
        if (allSameDownloadPath)
        {
            if (torrent->downloadPath() != firstTorrentDownloadPath)
                allSameDownloadPath = false;
        }
        if (m_allSameCategory)
        {
            if (torrent->category() != firstTorrentCategory)
                m_allSameCategory = false;
        }
        if (allSameUpLimit)
        {
            if (std::max(0, torrent->uploadLimit()) != firstTorrentUpLimit)
                allSameUpLimit = false;
        }
        if (allSameDownLimit)
        {
            if (std::max(0, torrent->downloadLimit()) != firstTorrentDownLimit)
                allSameDownLimit = false;
        }
        if (allSameRatio)
        {
            if (torrent->ratioLimit() != firstTorrentRatio)
                allSameRatio = false;
        }
        if (allSameSeedingTime)
        {
            if (torrent->seedingTimeLimit() != firstTorrentSeedingTime)
                allSameSeedingTime = false;
        }
        if (allTorrentsArePrivate)
        {
            if (!torrent->isPrivate())
                allTorrentsArePrivate = false;
        }
        if (allSameDHT)
        {
            if (torrent->isDHTDisabled() != isFirstTorrentDHTDisabled)
                allSameDHT = false;
        }
        if (allSamePEX)
        {
            if (torrent->isPEXDisabled() != isFirstTorrentPEXDisabled)
                allSamePEX = false;
        }
        if (allSameLSD)
        {
            if (torrent->isLSDDisabled() != isFirstTorrentLSDDisabled)
                allSameLSD = false;
        }
        if (allSameSequential)
        {
            if (torrent->isSequentialDownload() != isFirstTorrentSequentialEnabled)
                allSameSequential = false;
        }
        if (allSameFirstLastPieces)
        {
            if (torrent->hasFirstLastPiecePriority() != isFirstTorrentFirstLastPiecesEnabled)
                allSameFirstLastPieces = false;
        }
    }
 
    if (allSameAutoTMM)
        m_ui->checkAutoTMM->setChecked(isFirstTorrentAutoTMMEnabled);
    else
        m_ui->checkAutoTMM->setCheckState(Qt::PartiallyChecked);
 
    if (allSameSavePath)
        m_ui->savePath->setSelectedPath(firstTorrentSavePath);
 
    if (allSameDownloadPath)
    {
        m_ui->downloadPath->setSelectedPath(firstTorrentDownloadPath);
        m_ui->checkUseDownloadPath->setChecked(!firstTorrentDownloadPath.isEmpty());
    }
    else
    {
        m_ui->checkUseDownloadPath->setCheckState(Qt::PartiallyChecked);
    }
 
    if (!m_allSameCategory)
    {
        m_ui->comboCategory->addItem(m_currentCategoriesString);
        m_ui->comboCategory->clearEditText();
        m_ui->comboCategory->lineEdit()->setPlaceholderText(m_currentCategoriesString);
    }
    else if (!firstTorrentCategory.isEmpty())
    {
        m_ui->comboCategory->setCurrentText(firstTorrentCategory);
        m_ui->comboCategory->addItem(firstTorrentCategory);
    }
    m_ui->comboCategory->addItem(QString());
 
    m_categories = session->categories();
    std::sort(m_categories.begin(), m_categories.end(), Utils::Compare::NaturalLessThan<Qt::CaseInsensitive>());
    for (const QString &category : asConst(m_categories))
    {
        if (m_allSameCategory && (category == firstTorrentCategory))
            continue;
 
        m_ui->comboCategory->addItem(category);
    }
 
    const bool isAltLimitEnabled = session->isAltGlobalSpeedLimitEnabled();
    const int globalUploadLimit = isAltLimitEnabled
            ? (session->altGlobalUploadSpeedLimit() / 1024)
            : (session->globalUploadSpeedLimit() / 1024);
    const int globalDownloadLimit = isAltLimitEnabled
            ? (session->altGlobalDownloadSpeedLimit() / 1024)
            : (session->globalDownloadSpeedLimit() / 1024);
 
    const int uploadVal = std::max(0, (firstTorrentUpLimit / 1024));
    const int downloadVal = std::max(0, (firstTorrentDownLimit / 1024));
    int maxUpload = (globalUploadLimit <= 0) ? 10000 : globalUploadLimit;
    int maxDownload = (globalDownloadLimit <= 0) ? 10000 : globalDownloadLimit;
 
    // This can happen for example if global rate limit is lower than torrent rate limit.
    if (uploadVal > maxUpload)
        maxUpload = uploadVal;
    if (downloadVal > maxDownload)
        maxDownload = downloadVal;
 
    m_ui->sliderUploadLimit->setMaximum(maxUpload);
    m_ui->sliderUploadLimit->setValue(allSameUpLimit ? uploadVal : (maxUpload / 2));
    if (allSameUpLimit)
    {
        m_ui->spinUploadLimit->setValue(uploadVal);
    }
    else
    {
        m_ui->spinUploadLimit->setSpecialValueText(QString::fromUtf8(C_INEQUALITY));
        m_ui->spinUploadLimit->setMinimum(-1);
        m_ui->spinUploadLimit->setValue(-1);
        connect(m_ui->spinUploadLimit, qOverload<int>(&QSpinBox::valueChanged)
                           , this, &TorrentOptionsDialog::handleUpSpeedLimitChanged);
    }
 
    m_ui->sliderDownloadLimit->setMaximum(maxDownload);
    m_ui->sliderDownloadLimit->setValue(allSameDownLimit ? downloadVal : (maxDownload / 2));
    if (allSameDownLimit)
    {
        m_ui->spinDownloadLimit->setValue(downloadVal);
    }
    else
    {
        m_ui->spinDownloadLimit->setSpecialValueText(QString::fromUtf8(C_INEQUALITY));
        m_ui->spinDownloadLimit->setMinimum(-1);
        m_ui->spinDownloadLimit->setValue(-1);
        connect(m_ui->spinDownloadLimit, qOverload<int>(&QSpinBox::valueChanged)
                           , this, &TorrentOptionsDialog::handleDownSpeedLimitChanged);
    }
 
    const bool useGlobalValue = allSameRatio && allSameSeedingTime
        && (firstTorrentRatio == BitTorrent::Torrent::USE_GLOBAL_RATIO)
        && (firstTorrentSeedingTime == BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME);
 
    if (!allSameRatio || !allSameSeedingTime)
    {
        m_ui->radioUseGlobalShareLimits->setChecked(false);
        m_ui->radioNoLimit->setChecked(false);
        m_ui->radioTorrentLimit->setChecked(false);
    }
    else if (useGlobalValue)
    {
        m_ui->radioUseGlobalShareLimits->setChecked(true);
    }
    else if ((firstTorrentRatio == BitTorrent::Torrent::NO_RATIO_LIMIT)
             && (firstTorrentSeedingTime == BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT))
    {
        m_ui->radioNoLimit->setChecked(true);
    }
    else
    {
        m_ui->radioTorrentLimit->setChecked(true);
        if (firstTorrentRatio >= 0)
            m_ui->checkMaxRatio->setChecked(true);
        if (firstTorrentSeedingTime >= 0)
            m_ui->checkMaxTime->setChecked(true);
    }
 
    const qreal maxRatio = (allSameRatio && (firstTorrentRatio >= 0))
            ? firstTorrentRatio : session->globalMaxRatio();
    const int maxSeedingTime = (allSameSeedingTime && (firstTorrentSeedingTime >= 0))
            ? firstTorrentSeedingTime : session->globalMaxSeedingMinutes();
    m_ui->spinRatioLimit->setValue(maxRatio);
    m_ui->spinTimeLimit->setValue(maxSeedingTime);
 
    if (!allTorrentsArePrivate)
    {
        if (allSameDHT)
            m_ui->checkDisableDHT->setChecked(isFirstTorrentDHTDisabled);
        else
            m_ui->checkDisableDHT->setCheckState(Qt::PartiallyChecked);
 
        if (allSamePEX)
            m_ui->checkDisablePEX->setChecked(isFirstTorrentPEXDisabled);
        else
            m_ui->checkDisablePEX->setCheckState(Qt::PartiallyChecked);
 
        if (allSameLSD)
            m_ui->checkDisableLSD->setChecked(isFirstTorrentLSDDisabled);
        else
            m_ui->checkDisableLSD->setCheckState(Qt::PartiallyChecked);
    }
    else
    {
        m_ui->checkDisableDHT->setChecked(true);
        m_ui->checkDisableDHT->setEnabled(false);
        m_ui->checkDisablePEX->setChecked(true);
        m_ui->checkDisablePEX->setEnabled(false);
        m_ui->checkDisableLSD->setChecked(true);
        m_ui->checkDisableLSD->setEnabled(false);
    }
 
    const QString privateTorrentsTooltip = tr("Not applicable to private torrents");
    m_ui->checkDisableDHT->setToolTip(privateTorrentsTooltip);
    m_ui->checkDisablePEX->setToolTip(privateTorrentsTooltip);
    m_ui->checkDisableLSD->setToolTip(privateTorrentsTooltip);
 
    if (allSameSequential)
        m_ui->checkSequential->setChecked(isFirstTorrentSequentialEnabled);
    else
        m_ui->checkSequential->setCheckState(Qt::PartiallyChecked);
 
    if (allSameFirstLastPieces)
        m_ui->checkFirstLastPieces->setChecked(isFirstTorrentFirstLastPiecesEnabled);
    else
        m_ui->checkFirstLastPieces->setCheckState(Qt::PartiallyChecked);
 
    m_initialValues =
    {
        m_ui->savePath->selectedPath(),
        m_ui->downloadPath->selectedPath(),
        m_ui->comboCategory->currentText(),
        getRatio(),
        getSeedingTime(),
        m_ui->spinUploadLimit->value(),
        m_ui->spinDownloadLimit->value(),
        m_ui->checkAutoTMM->checkState(),
        m_ui->checkUseDownloadPath->checkState(),
        m_ui->checkDisableDHT->checkState(),
        m_ui->checkDisablePEX->checkState(),
        m_ui->checkDisableLSD->checkState(),
        m_ui->checkSequential->checkState(),
        m_ui->checkFirstLastPieces->checkState()
    };
 
    // Needs to be called after the initial values struct is initialized
    handleTMMChanged();
    handleUseDownloadPathChanged();
    handleRatioTypeChanged();
 
    connect(m_ui->checkAutoTMM, &QCheckBox::clicked, this, &TorrentOptionsDialog::handleTMMChanged);
    connect(m_ui->checkUseDownloadPath, &QCheckBox::clicked, this, &TorrentOptionsDialog::handleUseDownloadPathChanged);
    connect(m_ui->comboCategory, &QComboBox::activated, this, &TorrentOptionsDialog::handleCategoryChanged);
 
    // Sync up/down speed limit sliders with their corresponding spinboxes
    connect(m_ui->sliderUploadLimit, &QSlider::valueChanged, m_ui->spinUploadLimit, &QSpinBox::setValue);
    connect(m_ui->sliderDownloadLimit, &QSlider::valueChanged, m_ui->spinDownloadLimit, &QSpinBox::setValue);
    connect(m_ui->spinUploadLimit, qOverload<int>(&QSpinBox::valueChanged)
            , this, [this](const int value) { updateSliderValue(m_ui->sliderUploadLimit, value); });
    connect(m_ui->spinDownloadLimit, qOverload<int>(&QSpinBox::valueChanged)
            , this, [this](const int value) { updateSliderValue(m_ui->sliderDownloadLimit, value); });
 
    connect(m_ui->checkMaxRatio, &QCheckBox::toggled, m_ui->spinRatioLimit, &QDoubleSpinBox::setEnabled);
    connect(m_ui->checkMaxTime, &QCheckBox::toggled, m_ui->spinTimeLimit, &QSpinBox::setEnabled);
 
    connect(m_ui->buttonGroup, &QButtonGroup::idClicked, this, &TorrentOptionsDialog::handleRatioTypeChanged);
 
    Utils::Gui::resize(this, m_storeDialogSize);
}

References asConst(), C_INEQUALITY, category, FileSystemPathEdit::DirectorySave, getRatio(), getSeedingTime(), handleCategoryChanged(), handleDownSpeedLimitChanged(), handleRatioTypeChanged(), handleTMMChanged(), handleUpSpeedLimitChanged(), handleUseDownloadPathChanged(), BitTorrent::Session::instance(), m_allSameCategory, m_categories, m_currentCategoriesString, m_initialValues, m_storeDialogSize, m_torrentIDs, m_ui, BitTorrent::Torrent::NO_RATIO_LIMIT, BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT, Utils::Gui::resize(), anonymous_namespace{preferences.cpp}::setValue(), BitTorrent::Torrent::USE_GLOBAL_RATIO, BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME, and anonymous_namespace{preferences.cpp}::value().

Here is the call graph for this function:

~TorrentOptionsDialog()

TorrentOptionsDialog::~TorrentOptionsDialog ( )

override

Definition at line 396 of file torrentoptionsdialog.cpp.

{
    m_storeDialogSize = size();
    delete m_ui;
}

References m_storeDialogSize, and m_ui.

Member Function Documentation

accept

void TorrentOptionsDialog::accept ( )

overrideslot

Definition at line 402 of file torrentoptionsdialog.cpp.

{
    if (m_ui->radioTorrentLimit->isChecked() && !m_ui->checkMaxRatio->isChecked() && !m_ui->checkMaxTime->isChecked())
    {
        QMessageBox::critical(this, tr("No share limit method selected"), tr("Please select a limit method first"));
        return;
    }
 
    auto *session = BitTorrent::Session::instance();
    for (const BitTorrent::TorrentID &id : asConst(m_torrentIDs))
    {
        BitTorrent::Torrent *torrent = session->findTorrent(id);
        if (!torrent) continue;
 
        if (m_initialValues.autoTMM != m_ui->checkAutoTMM->checkState())
            torrent->setAutoTMMEnabled(m_ui->checkAutoTMM->isChecked());
 
        if (m_ui->checkAutoTMM->checkState() == Qt::Unchecked)
        {
            const QString savePath = m_ui->savePath->selectedPath();
            if (m_initialValues.savePath != savePath)
                torrent->setSavePath(Utils::Fs::expandPathAbs(savePath));
 
            const Qt::CheckState useDownloadPathState = m_ui->checkUseDownloadPath->checkState();
            if (useDownloadPathState == Qt::Checked)
            {
                const QString downloadPath = m_ui->downloadPath->selectedPath();
                if (m_initialValues.downloadPath != downloadPath)
                    torrent->setDownloadPath(Utils::Fs::expandPathAbs(downloadPath));
            }
            else if (useDownloadPathState == Qt::Unchecked)
            {
                torrent->setDownloadPath(QString());
            }
        }
 
        const QString category = m_ui->comboCategory->currentText();
        // index 0 is always the current category
        if ((m_initialValues.category != category) || (m_ui->comboCategory->currentIndex() != 0))
        {
            if (!m_categories.contains(category))
                session->addCategory(category);
 
            torrent->setCategory(category);
        }
 
        if (m_initialValues.upSpeedLimit != m_ui->spinUploadLimit->value())
            torrent->setUploadLimit(m_ui->spinUploadLimit->value() * 1024);
        if (m_initialValues.downSpeedLimit != m_ui->spinDownloadLimit->value())
            torrent->setDownloadLimit(m_ui->spinDownloadLimit->value() * 1024);
 
        const qreal ratioLimit = getRatio();
        if (m_initialValues.ratio != ratioLimit)
            torrent->setRatioLimit(ratioLimit);
 
        const int seedingTimeLimit = getSeedingTime();
        if (m_initialValues.seedingTime != seedingTimeLimit)
            torrent->setSeedingTimeLimit(seedingTimeLimit);
 
        if (!torrent->isPrivate())
        {
            if (m_initialValues.disableDHT != m_ui->checkDisableDHT->checkState())
                torrent->setDHTDisabled(m_ui->checkDisableDHT->isChecked());
            if (m_initialValues.disablePEX != m_ui->checkDisablePEX->checkState())
                torrent->setPEXDisabled(m_ui->checkDisablePEX->isChecked());
            if (m_initialValues.disableLSD != m_ui->checkDisableLSD->checkState())
                torrent->setLSDDisabled(m_ui->checkDisableLSD->isChecked());
        }
 
        if (m_initialValues.sequential != m_ui->checkSequential->checkState())
            torrent->setSequentialDownload(m_ui->checkSequential->isChecked());
        if (m_initialValues.firstLastPieces != m_ui->checkFirstLastPieces->checkState())
            torrent->setFirstLastPiecePriority(m_ui->checkFirstLastPieces->isChecked());
    }
 
    QDialog::accept();
}

References asConst(), category, downloadPath, Utils::Fs::expandPathAbs(), getRatio(), getSeedingTime(), BitTorrent::Session::instance(), BitTorrent::Torrent::isPrivate(), m_categories, m_initialValues, m_torrentIDs, m_ui, savePath, BitTorrent::Torrent::setAutoTMMEnabled(), BitTorrent::Torrent::setCategory(), BitTorrent::Torrent::setDHTDisabled(), BitTorrent::Torrent::setDownloadLimit(), BitTorrent::Torrent::setDownloadPath(), BitTorrent::Torrent::setFirstLastPiecePriority(), BitTorrent::Torrent::setLSDDisabled(), BitTorrent::Torrent::setPEXDisabled(), BitTorrent::Torrent::setRatioLimit(), BitTorrent::Torrent::setSavePath(), BitTorrent::Torrent::setSeedingTimeLimit(), BitTorrent::Torrent::setSequentialDownload(), and BitTorrent::Torrent::setUploadLimit().

Here is the call graph for this function:

getRatio()

qreal TorrentOptionsDialog::getRatio ( ) const

private

Definition at line 480 of file torrentoptionsdialog.cpp.

{
    if (m_ui->buttonGroup->checkedId() == -1) // No radio button is selected
        return MIXED_SHARE_LIMITS;
 
    if (m_ui->radioUseGlobalShareLimits->isChecked())
        return BitTorrent::Torrent::USE_GLOBAL_RATIO;
 
    if (m_ui->radioNoLimit->isChecked() || !m_ui->checkMaxRatio->isChecked())
        return BitTorrent::Torrent::NO_RATIO_LIMIT;
 
    return m_ui->spinRatioLimit->value();
}

References m_ui, anonymous_namespace{torrentoptionsdialog.cpp}::MIXED_SHARE_LIMITS, BitTorrent::Torrent::NO_RATIO_LIMIT, and BitTorrent::Torrent::USE_GLOBAL_RATIO.

Referenced by accept(), and TorrentOptionsDialog().

Here is the caller graph for this function:

getSeedingTime()

int TorrentOptionsDialog::getSeedingTime ( ) const

private

Definition at line 494 of file torrentoptionsdialog.cpp.

{
    if (m_ui->buttonGroup->checkedId() == -1) // No radio button is selected
        return MIXED_SHARE_LIMITS;
 
    if (m_ui->radioUseGlobalShareLimits->isChecked())
        return BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME;
 
    if (m_ui->radioNoLimit->isChecked() || !m_ui->checkMaxTime->isChecked())
        return  BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT;
 
    return m_ui->spinTimeLimit->value();
}

References m_ui, anonymous_namespace{torrentoptionsdialog.cpp}::MIXED_SHARE_LIMITS, BitTorrent::Torrent::NO_SEEDING_TIME_LIMIT, and BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME.

Referenced by accept(), and TorrentOptionsDialog().

Here is the caller graph for this function:

handleCategoryChanged

void TorrentOptionsDialog::handleCategoryChanged ( int  index )

privateslot

Definition at line 508 of file torrentoptionsdialog.cpp.

{
    Q_UNUSED(index);
 
    if (m_ui->checkAutoTMM->checkState() == Qt::Checked)
    {
        if (!m_allSameCategory && (m_ui->comboCategory->currentIndex() == 0))
        {
            m_ui->savePath->setSelectedPath(QString());
        }
        else
        {
            const QString savePath = BitTorrent::Session::instance()->categorySavePath(m_ui->comboCategory->currentText());
            m_ui->savePath->setSelectedPath(Utils::Fs::toNativePath(savePath));
        }
    }
 
    if (!m_allSameCategory && (m_ui->comboCategory->currentIndex() == 0))
    {
        m_ui->comboCategory->clearEditText();
        m_ui->comboCategory->lineEdit()->setPlaceholderText(m_currentCategoriesString);
    }
    else
    {
        m_ui->comboCategory->lineEdit()->setPlaceholderText(QString());
    }
}

References BitTorrent::Session::categorySavePath(), BitTorrent::Session::instance(), m_allSameCategory, m_currentCategoriesString, m_ui, savePath, and Utils::Fs::toNativePath().

Referenced by TorrentOptionsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

handleDownSpeedLimitChanged

void TorrentOptionsDialog::handleDownSpeedLimitChanged ( )

privateslot

Definition at line 612 of file torrentoptionsdialog.cpp.

{
    m_ui->spinDownloadLimit->setMinimum(0);
    m_ui->spinDownloadLimit->setSpecialValueText(QString::fromUtf8(C_INFINITY));
    disconnect(m_ui->spinDownloadLimit, qOverload<int>(&QSpinBox::valueChanged)
                   , this, &TorrentOptionsDialog::handleDownSpeedLimitChanged);
}

References C_INFINITY, and m_ui.

Referenced by TorrentOptionsDialog().

Here is the caller graph for this function:

handleRatioTypeChanged

void TorrentOptionsDialog::handleRatioTypeChanged ( )

privateslot

Definition at line 582 of file torrentoptionsdialog.cpp.

{
    if ((m_initialValues.ratio == MIXED_SHARE_LIMITS) || (m_initialValues.seedingTime == MIXED_SHARE_LIMITS))
    {
        QAbstractButton *currentRadio = m_ui->buttonGroup->checkedButton();
        if (currentRadio && (currentRadio == m_previousRadio))
        {
            // Hack to deselect the currently selected radio button programatically because Qt doesn't allow it in exclusive mode
            m_ui->buttonGroup->setExclusive(false);
            currentRadio->setChecked(false);
            m_ui->buttonGroup->setExclusive(true);
        }
        m_previousRadio = m_ui->buttonGroup->checkedButton();
    }
 
    m_ui->checkMaxRatio->setEnabled(m_ui->radioTorrentLimit->isChecked());
    m_ui->checkMaxTime->setEnabled(m_ui->radioTorrentLimit->isChecked());
 
    m_ui->spinRatioLimit->setEnabled(m_ui->radioTorrentLimit->isChecked() && m_ui->checkMaxRatio->isChecked());
    m_ui->spinTimeLimit->setEnabled(m_ui->radioTorrentLimit->isChecked() && m_ui->checkMaxTime->isChecked());
}

References m_initialValues, m_previousRadio, m_ui, and anonymous_namespace{torrentoptionsdialog.cpp}::MIXED_SHARE_LIMITS.

Referenced by TorrentOptionsDialog().

Here is the caller graph for this function:

handleTMMChanged

void TorrentOptionsDialog::handleTMMChanged ( )

privateslot

Definition at line 536 of file torrentoptionsdialog.cpp.

{
    if (m_ui->checkAutoTMM->checkState() == Qt::Unchecked)
    {
        m_ui->groupBoxSavePath->setEnabled(true);
        m_ui->savePath->setSelectedPath(Utils::Fs::toNativePath(m_initialValues.savePath));
        m_ui->downloadPath->setSelectedPath(Utils::Fs::toNativePath(m_initialValues.downloadPath));
        m_ui->checkUseDownloadPath->setCheckState(m_initialValues.useDownloadPath);
    }
    else
    {
        m_ui->groupBoxSavePath->setEnabled(false);
        if (m_ui->checkAutoTMM->checkState() == Qt::Checked)
        {
            if (!m_allSameCategory && (m_ui->comboCategory->currentIndex() == 0))
            {
                m_ui->savePath->setSelectedPath(QString());
                m_ui->downloadPath->setSelectedPath(QString());
                m_ui->checkUseDownloadPath->setCheckState(Qt::PartiallyChecked);
            }
            else
            {
                const QString savePath = BitTorrent::Session::instance()->categorySavePath(m_ui->comboCategory->currentText());
                m_ui->savePath->setSelectedPath(Utils::Fs::toNativePath(savePath));
                const QString downloadPath = BitTorrent::Session::instance()->categoryDownloadPath(m_ui->comboCategory->currentText());
                m_ui->downloadPath->setSelectedPath(Utils::Fs::toNativePath(downloadPath));
                m_ui->checkUseDownloadPath->setChecked(!downloadPath.isEmpty());
            }
        }
        else // partially checked
        {
            m_ui->savePath->setSelectedPath(QString());
            m_ui->downloadPath->setSelectedPath(QString());
            m_ui->checkUseDownloadPath->setCheckState(Qt::PartiallyChecked);
        }
    }
}

References BitTorrent::Session::categoryDownloadPath(), BitTorrent::Session::categorySavePath(), downloadPath, BitTorrent::Session::instance(), m_allSameCategory, m_initialValues, m_ui, savePath, and Utils::Fs::toNativePath().

Referenced by TorrentOptionsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

handleUpSpeedLimitChanged

void TorrentOptionsDialog::handleUpSpeedLimitChanged ( )

privateslot

Definition at line 604 of file torrentoptionsdialog.cpp.

{
    m_ui->spinUploadLimit->setMinimum(0);
    m_ui->spinUploadLimit->setSpecialValueText(QString::fromUtf8(C_INFINITY));
    disconnect(m_ui->spinUploadLimit, qOverload<int>(&QSpinBox::valueChanged)
                   , this, &TorrentOptionsDialog::handleUpSpeedLimitChanged);
}

References C_INFINITY, and m_ui.

Referenced by TorrentOptionsDialog().

Here is the caller graph for this function:

handleUseDownloadPathChanged

void TorrentOptionsDialog::handleUseDownloadPathChanged ( )

privateslot

Definition at line 574 of file torrentoptionsdialog.cpp.

{
    const bool isChecked = m_ui->checkUseDownloadPath->checkState() == Qt::Checked;
    m_ui->downloadPath->setEnabled(isChecked);
    if (isChecked && m_ui->downloadPath->selectedPath().isEmpty())
        m_ui->downloadPath->setSelectedPath(BitTorrent::Session::instance()->downloadPath());
}

References downloadPath, BitTorrent::Session::instance(), and m_ui.

Referenced by TorrentOptionsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

autoTMM

Qt::CheckState TorrentOptionsDialog::autoTMM

Definition at line 92 of file torrentoptionsdialog.h.

category

QString TorrentOptionsDialog::category

Definition at line 87 of file torrentoptionsdialog.h.

Referenced by accept(), and TorrentOptionsDialog().

disableDHT

Qt::CheckState TorrentOptionsDialog::disableDHT

Definition at line 94 of file torrentoptionsdialog.h.

disableLSD

Qt::CheckState TorrentOptionsDialog::disableLSD

Definition at line 96 of file torrentoptionsdialog.h.

disablePEX

Qt::CheckState TorrentOptionsDialog::disablePEX

Definition at line 95 of file torrentoptionsdialog.h.

downloadPath

QString TorrentOptionsDialog::downloadPath

Definition at line 86 of file torrentoptionsdialog.h.

Referenced by accept(), handleTMMChanged(), and handleUseDownloadPathChanged().

downSpeedLimit

int TorrentOptionsDialog::downSpeedLimit

Definition at line 91 of file torrentoptionsdialog.h.

firstLastPieces

Qt::CheckState TorrentOptionsDialog::firstLastPieces

Definition at line 98 of file torrentoptionsdialog.h.

m_allSameCategory

bool TorrentOptionsDialog::m_allSameCategory = true

private

Definition at line 81 of file torrentoptionsdialog.h.

Referenced by handleCategoryChanged(), handleTMMChanged(), and TorrentOptionsDialog().

m_categories

QStringList TorrentOptionsDialog::m_categories

private

Definition at line 79 of file torrentoptionsdialog.h.

Referenced by accept(), and TorrentOptionsDialog().

m_currentCategoriesString

QString TorrentOptionsDialog::m_currentCategoriesString

private

Definition at line 80 of file torrentoptionsdialog.h.

Referenced by handleCategoryChanged(), and TorrentOptionsDialog().

struct { ... } TorrentOptionsDialog::m_initialValues

Referenced by accept(), handleRatioTypeChanged(), handleTMMChanged(), and TorrentOptionsDialog().

m_previousRadio

QAbstractButton* TorrentOptionsDialog::m_previousRadio = nullptr

private

Definition at line 82 of file torrentoptionsdialog.h.

Referenced by handleRatioTypeChanged().

m_storeDialogSize

SettingValue<QSize> TorrentOptionsDialog::m_storeDialogSize

private

Definition at line 78 of file torrentoptionsdialog.h.

Referenced by TorrentOptionsDialog(), and ~TorrentOptionsDialog().

m_torrentIDs

QVector<BitTorrent::TorrentID> TorrentOptionsDialog::m_torrentIDs

private

Definition at line 76 of file torrentoptionsdialog.h.

Referenced by accept(), and TorrentOptionsDialog().

m_ui

Ui::TorrentOptionsDialog* TorrentOptionsDialog::m_ui

private

Definition at line 77 of file torrentoptionsdialog.h.

Referenced by accept(), getRatio(), getSeedingTime(), handleCategoryChanged(), handleDownSpeedLimitChanged(), handleRatioTypeChanged(), handleTMMChanged(), handleUpSpeedLimitChanged(), handleUseDownloadPathChanged(), TorrentOptionsDialog(), and ~TorrentOptionsDialog().

ratio

qreal TorrentOptionsDialog::ratio

Definition at line 88 of file torrentoptionsdialog.h.

savePath

QString TorrentOptionsDialog::savePath

Definition at line 85 of file torrentoptionsdialog.h.

Referenced by accept(), handleCategoryChanged(), and handleTMMChanged().

seedingTime

int TorrentOptionsDialog::seedingTime

Definition at line 89 of file torrentoptionsdialog.h.

sequential

Qt::CheckState TorrentOptionsDialog::sequential

Definition at line 97 of file torrentoptionsdialog.h.

upSpeedLimit

int TorrentOptionsDialog::upSpeedLimit

Definition at line 90 of file torrentoptionsdialog.h.

useDownloadPath

Qt::CheckState TorrentOptionsDialog::useDownloadPath

Definition at line 93 of file torrentoptionsdialog.h.

---

The documentation for this class was generated from the following files:

• src/gui/torrentoptionsdialog.h
• src/gui/torrentoptionsdialog.cpp