mirror of
https://bitbucket.org/smil3y/kde-extraapps.git
synced 2025-02-25 03:12:53 +00:00
314 lines
8 KiB
C++
314 lines
8 KiB
C++
/***************************************************************************
|
|
* Copyright (C) 2008 by Joris Guisson and Ivan Vasic *
|
|
* joris.guisson@gmail.com *
|
|
* ivasic@gmail.com *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
|
|
***************************************************************************/
|
|
#include "trackermodel.h"
|
|
#include <QList>
|
|
#include <klocale.h>
|
|
#include <interfaces/torrentinterface.h>
|
|
#include <interfaces/trackerinterface.h>
|
|
|
|
namespace kt
|
|
{
|
|
|
|
TrackerModel::TrackerModel(QObject* parent)
|
|
: QAbstractTableModel(parent),tc(0)
|
|
{
|
|
running = false;
|
|
}
|
|
|
|
|
|
TrackerModel::~TrackerModel()
|
|
{
|
|
qDeleteAll(trackers);
|
|
}
|
|
|
|
void TrackerModel::changeTC(bt::TorrentInterface* tc)
|
|
{
|
|
qDeleteAll(trackers);
|
|
trackers.clear();
|
|
this->tc = tc;
|
|
if (tc)
|
|
{
|
|
QList<bt::TrackerInterface*> tracker_list = tc->getTrackersList()->getTrackers();
|
|
foreach (bt::TrackerInterface* trk,tracker_list)
|
|
{
|
|
trackers.append(new Item(trk));
|
|
}
|
|
}
|
|
|
|
reset();
|
|
}
|
|
|
|
void TrackerModel::update()
|
|
{
|
|
if (!tc)
|
|
return;
|
|
|
|
int idx = 0;
|
|
foreach (Item* t,trackers)
|
|
{
|
|
if (t->update())
|
|
emit dataChanged(index(idx,1),index(idx,5));
|
|
idx++;
|
|
}
|
|
|
|
running = tc->getStats().running;
|
|
}
|
|
|
|
|
|
int TrackerModel::rowCount(const QModelIndex &parent) const
|
|
{
|
|
if (parent.isValid() || !tc)
|
|
return 0;
|
|
else
|
|
return trackers.count();
|
|
}
|
|
|
|
int TrackerModel::columnCount(const QModelIndex& parent) const
|
|
{
|
|
if (parent.isValid())
|
|
return 0;
|
|
else
|
|
return 6;
|
|
}
|
|
|
|
|
|
QVariant TrackerModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
if (!tc || !index.isValid() || index.row() < 0 || index.row() >= trackers.count())
|
|
return QVariant();
|
|
|
|
Item* item = (Item*)index.internalPointer();
|
|
if (!item)
|
|
return QVariant();
|
|
|
|
bt::TrackerInterface* trk = item->trk;
|
|
|
|
if (role == Qt::CheckStateRole && index.column() == 0)
|
|
{
|
|
return trk->isEnabled() ? Qt::Checked : Qt::Unchecked;
|
|
}
|
|
else if (role == Qt::DisplayRole)
|
|
{
|
|
return item->displayData(index.column());
|
|
}
|
|
else if (role == Qt::UserRole)
|
|
{
|
|
return item->sortData(index.column());
|
|
}
|
|
else if (role == Qt::ForegroundRole && index.column() == 1 && trk->trackerStatus() == bt::TRACKER_ERROR)
|
|
{
|
|
return Qt::red;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
bool TrackerModel::setData(const QModelIndex & index,const QVariant & value,int role)
|
|
{
|
|
if (!tc || !index.isValid() || index.row() < 0 || index.row() >= trackers.count())
|
|
return false;
|
|
|
|
if (role == Qt::CheckStateRole)
|
|
{
|
|
KUrl url = trackers.at(index.row())->trk->trackerURL();
|
|
tc->getTrackersList()->setTrackerEnabled(url,(Qt::CheckState)value.toUInt() == Qt::Checked);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
QVariant TrackerModel::headerData(int section, Qt::Orientation orientation,int role) const
|
|
{
|
|
if (orientation != Qt::Horizontal)
|
|
return QVariant();
|
|
|
|
if (role == Qt::DisplayRole)
|
|
{
|
|
switch (section)
|
|
{
|
|
case 0: return i18n("Url");
|
|
case 1: return i18n("Status");
|
|
case 2: return i18n("Seeders");
|
|
case 3: return i18n("Leechers");
|
|
case 4: return i18n("Times Downloaded");
|
|
case 5: return i18n("Next Update");
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
bool TrackerModel::insertRows(int row,int count,const QModelIndex & parent)
|
|
{
|
|
Q_UNUSED(parent)
|
|
beginInsertRows(QModelIndex(),row,row + count - 1);
|
|
if (tc)
|
|
{
|
|
QList<bt::TrackerInterface*> tracker_list = tc->getTrackersList()->getTrackers();
|
|
QList<Item*>::iterator i = trackers.begin();
|
|
foreach (bt::TrackerInterface* trk,tracker_list)
|
|
{
|
|
if (i != trackers.end())
|
|
{
|
|
Item* item = *i;
|
|
item->trk = trk;
|
|
}
|
|
else
|
|
trackers.append(new Item(trk));
|
|
i++;
|
|
}
|
|
}
|
|
endInsertRows();
|
|
return true;
|
|
}
|
|
|
|
bool TrackerModel::removeRows(int row,int count,const QModelIndex & parent)
|
|
{
|
|
Q_UNUSED(parent)
|
|
beginRemoveRows(QModelIndex(),row,row + count - 1);
|
|
if (tc)
|
|
{
|
|
for (int i = 0;i < count;i++)
|
|
{
|
|
Item* item = trackers.takeAt(row);
|
|
KUrl url = item->trk->trackerURL();
|
|
tc->getTrackersList()->removeTracker(url);
|
|
delete item;
|
|
}
|
|
}
|
|
endRemoveRows();
|
|
return true;
|
|
}
|
|
|
|
Qt::ItemFlags TrackerModel::flags(const QModelIndex & index) const
|
|
{
|
|
if (!tc || !index.isValid() || index.row() >= trackers.count() || index.row() < 0 || index.column() != 0)
|
|
return QAbstractItemModel::flags(index);
|
|
else
|
|
return QAbstractItemModel::flags(index) | Qt::ItemIsUserCheckable;
|
|
}
|
|
|
|
QModelIndex TrackerModel::index(int row, int column, const QModelIndex& parent) const
|
|
{
|
|
if (parent.isValid() || row < 0 || row >= trackers.count() || column < 0 || column >= 6)
|
|
return QModelIndex();
|
|
else
|
|
return createIndex(row,column,trackers.at(row));
|
|
}
|
|
|
|
|
|
KUrl TrackerModel::trackerUrl(const QModelIndex & index)
|
|
{
|
|
if (!tc || !index.isValid() || index.row() < 0 || index.row() >= trackers.count())
|
|
return KUrl();
|
|
|
|
return ((Item*)index.internalPointer())->trk->trackerURL();
|
|
}
|
|
|
|
bt::TrackerInterface* TrackerModel::tracker(const QModelIndex & index)
|
|
{
|
|
if (!tc || !index.isValid() || index.row() < 0 || index.row() >= trackers.count())
|
|
return 0;
|
|
|
|
return ((Item*)index.internalPointer())->trk;
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
|
|
TrackerModel::Item::Item(bt::TrackerInterface* tracker) : trk(tracker)
|
|
{
|
|
seeders = leechers = -1;
|
|
times_downloaded = -1;
|
|
time_to_next_update = 0;
|
|
status = tracker->trackerStatus();
|
|
}
|
|
|
|
bool TrackerModel::Item::update()
|
|
{
|
|
bool ret = false;
|
|
if (status != trk->trackerStatus())
|
|
{
|
|
status = trk->trackerStatus();
|
|
ret = true;
|
|
}
|
|
|
|
if (seeders != trk->getNumSeeders())
|
|
{
|
|
seeders = trk->getNumSeeders();
|
|
ret = true;
|
|
}
|
|
|
|
if (leechers != trk->getNumLeechers())
|
|
{
|
|
leechers = trk->getNumLeechers();
|
|
ret = true;
|
|
}
|
|
|
|
if (times_downloaded != trk->getTotalTimesDownloaded())
|
|
{
|
|
times_downloaded = trk->getTotalTimesDownloaded();
|
|
ret = true;
|
|
}
|
|
|
|
if (static_cast<bt::Uint32>(time_to_next_update) != trk->timeToNextUpdate())
|
|
{
|
|
time_to_next_update = trk->timeToNextUpdate();
|
|
ret = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
QVariant TrackerModel::Item::displayData(int column) const
|
|
{
|
|
switch (column)
|
|
{
|
|
case 0: return trk->trackerURL().prettyUrl();
|
|
case 1: return trk->trackerStatusString();
|
|
case 2: return seeders >= 0 ? seeders : QVariant();
|
|
case 3: return leechers >= 0 ? leechers : QVariant();
|
|
case 4: return times_downloaded >= 0 ? times_downloaded : QVariant();
|
|
case 5:
|
|
{
|
|
int secs = time_to_next_update;
|
|
if (secs)
|
|
return QTime().addSecs(secs).toString("mm:ss");
|
|
else
|
|
return QVariant();
|
|
}
|
|
default: return QVariant();
|
|
}
|
|
}
|
|
|
|
QVariant TrackerModel::Item::sortData(int column) const
|
|
{
|
|
switch (column)
|
|
{
|
|
case 0: return trk->trackerURL().prettyUrl();
|
|
case 1: return status;
|
|
case 2: return seeders;
|
|
case 3: return leechers;
|
|
case 4: return times_downloaded;
|
|
case 5: return time_to_next_update;
|
|
default: return QVariant();
|
|
}
|
|
}
|
|
|
|
}
|