peerviewmodel.cpp

Go to the documentation of this file.

/***************************************************************************
 *   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 "peerviewmodel.h"
#include <klocale.h>
#include <kicon.h>
#include <kstandarddirs.h>
#include <interfaces/torrentinterface.h>
#include <util/functions.h>
#include <kdebug.h>

using namespace bt;

namespace kt
{
    static KIcon yes,no;
    static bool icons_loaded = false;

    PeerViewModel::Item::Item(bt::PeerInterface* peer) : peer(peer)
    {
        stats = peer->getStats();
        if (!icons_loaded)
        {
            yes = KIcon("dialog-ok");
            no = KIcon("dialog-cancel");
        }
    }
        /*  
    bool PeerViewModel::Item::changed() const
    {
        const PeerInterface::Stats & s = peer->getStats();
        

        if (s.download_rate != stats.download_rate || 
            s.upload_rate != stats.upload_rate || 
            s.choked != stats.choked || 
            s.snubbed != stats.snubbed || 
            s.perc_of_file != stats.perc_of_file || 
            s.aca_score != stats.aca_score || 
            s.has_upload_slot != stats.has_upload_slot || 
            s.num_down_requests != stats.num_down_requests || 
            s.num_up_requests != stats.num_up_requests || 
            s.bytes_downloaded != stats.bytes_downloaded || 
            s.bytes_uploaded != stats.bytes_uploaded ||
            s.interested != stats.interested ||
            s.am_interested != stats.am_interested)
        {
            stats = s;
            return true;
        }
        return false;
    }
    */
    bool PeerViewModel::Item::changed(int col,bool & modified) const
    {
        const PeerInterface::Stats & s = peer->getStats();
        bool ret = false;
        
        switch (col)
        {
            case 3: 
                ret = s.download_rate != stats.download_rate;
                break;
            case 4: 
                ret = s.upload_rate != stats.upload_rate;
                break;
            case 5: 
                ret = s.choked != stats.choked;
                break;
            case 6: 
                ret = s.snubbed != stats.snubbed;
                break;
            case 7: 
                ret = s.perc_of_file != stats.perc_of_file;
                break;
            case 9: 
                ret = s.aca_score != stats.aca_score;
                break;
            case 10: 
                ret = s.has_upload_slot != stats.has_upload_slot;
                break;
            case 11:
                ret = (s.num_down_requests != stats.num_down_requests || s.num_up_requests != stats.num_up_requests);
                break;
            case 12: 
                ret = s.bytes_downloaded != stats.bytes_downloaded;
                break;
            case 13: 
                ret = s.bytes_uploaded != stats.bytes_uploaded;
                break;
            case 14: 
                ret = s.interested != stats.interested;
                break;
            case 15:
                ret = s.am_interested != stats.am_interested;
                break;
            default: 
                ret = false;
                break;
        }

        modified = s.download_rate != stats.download_rate || 
                s.upload_rate != stats.upload_rate || 
                s.choked != stats.choked || 
                s.snubbed != stats.snubbed || 
                s.perc_of_file != stats.perc_of_file || 
                s.aca_score != stats.aca_score || 
                s.has_upload_slot != stats.has_upload_slot || 
                s.num_down_requests != stats.num_down_requests || 
                s.num_up_requests != stats.num_up_requests || 
                s.bytes_downloaded != stats.bytes_downloaded || 
                s.bytes_uploaded != stats.bytes_uploaded ||
                s.interested != stats.interested ||
                s.am_interested != stats.am_interested;
        stats = s;
        return ret;
    }
    
    QVariant PeerViewModel::Item::data(int col) const
    {
        switch (col)
        {
            case 0: return stats.ip_address;
            case 1: return stats.client;
            case 2: 
                if (stats.download_rate >= 103)
                    return BytesPerSecToString(stats.download_rate);
                else
                    return QVariant();
            case 3: 
                if (stats.upload_rate >= 103)
                    return BytesPerSecToString(stats.upload_rate);
                else
                    return QVariant();
            case 4: return stats.choked ? i18nc("Choked", "Yes") : i18nc("Not choked", "No");
            case 5: return stats.snubbed ? i18nc("Snubbed", "Yes") : i18nc("Not snubbed", "No");
            case 6: return QString("%1 %").arg(KGlobal::locale()->formatNumber(stats.perc_of_file,2));
            case 7: return QVariant();
            case 8: return KGlobal::locale()->formatNumber(stats.aca_score,2);
            case 9: return QVariant(); 
            case 10: return QString("%1 / %2").arg(stats.num_down_requests).arg(stats.num_up_requests);
            case 11: return BytesToString(stats.bytes_downloaded);
            case 12: return BytesToString(stats.bytes_uploaded);
            case 13: return stats.interested ? i18nc("Interested", "Yes") : i18nc("Not Interested", "No");
            case 14: return stats.am_interested ? i18nc("Interesting", "Yes") : i18nc("Not Interesting", "No");
            default: return QVariant();
        }
        return QVariant();
    }
    
    bool PeerViewModel::Item::lessThan(int col,const Item* other) const
    {
        switch (col)
        {
            case 0: return stats.ip_address < other->stats.ip_address;
            case 1: return QString::localeAwareCompare(stats.client,other->stats.client) < 0;
            case 2: return stats.download_rate < other->stats.download_rate;
            case 3: return stats.upload_rate < other->stats.upload_rate;
            case 4: return stats.choked < other->stats.choked;
            case 5: return stats.snubbed < other->stats.snubbed;
            case 6: return stats.perc_of_file < other->stats.perc_of_file;
            case 7: return stats.dht_support < other->stats.dht_support;
            case 8: return stats.aca_score < other->stats.aca_score;
            case 9: return stats.has_upload_slot < other->stats.has_upload_slot;
            case 10: return stats.num_down_requests + stats.num_up_requests < 
                            other->stats.num_down_requests + other->stats.num_up_requests;
            case 11: return stats.bytes_downloaded < other->stats.bytes_downloaded;
            case 12: return stats.bytes_uploaded < other->stats.bytes_uploaded;
            case 13: return stats.interested < other->stats.interested;
            case 14: return stats.am_interested < other->stats.am_interested;
            default: return false;
        }
        return false;
    }
    
    QVariant PeerViewModel::Item::decoration(int col) const
    {
        switch (col)
        {
            case 0:
                if (stats.encrypted)
                    return KIcon("kt-encrypted");
                break;
            case 1: return flag;
            case 8: return stats.dht_support ? yes : no;
            case 10: return stats.has_upload_slot ? yes : KIcon();
        }
        
        return QVariant();
    }
    

    PeerViewModel::PeerViewModel ( QObject* parent )
    : QAbstractTableModel(parent)
    {
        sort_column = 0;
        sort_order = Qt::AscendingOrder;
    }


    PeerViewModel::~PeerViewModel()
    {
        qDeleteAll(items);
    }
    
    void PeerViewModel::peerAdded(bt::PeerInterface* peer)
    {
        items.append(new Item(peer));
        insertRow(items.count() - 1);
        sort(sort_column,sort_order);
    }
    
    void PeerViewModel::peerRemoved(bt::PeerInterface* peer)
    {
        int idx = 0;
        for (QList<Item*>::iterator i = items.begin();i != items.end();i++)
        {
            Item* item = *i;
            if (item->peer == peer)
            {
                items.erase(i);
                delete item;
                removeRow(idx);
                break;
            }
            idx++;
        }
    }
    
    void PeerViewModel::clear()
    {
        qDeleteAll(items);
        items.clear();
        reset();
    }
    
    void PeerViewModel::update()
    {
        bool resort = false;
        Uint32 idx=0;
        foreach (Item* i,items)
        {
            bool modified = false;
            if (i->changed(sort_column,modified))
                resort = true;
            
            if (modified && !resort)
                emit dataChanged(index(idx,3),index(idx,15));
            idx++;
        }
    
        if (resort)
            sort(sort_column,sort_order);
    }
    
    QModelIndex PeerViewModel::index(int row,int column,const QModelIndex & parent) const
    {
        if (!hasIndex(row,column,parent) || parent.isValid())
            return QModelIndex();
        else
            return createIndex(row,column,items[row]);
    }

    int PeerViewModel::rowCount( const QModelIndex & parent) const
    {
        if (parent.isValid())
            return 0;
        else
            return items.count();
    }
    
    int PeerViewModel::columnCount(const QModelIndex & parent) const
    {
        if (parent.isValid())
            return 0;
        else
            return 16;
    }
    
    QVariant PeerViewModel::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("IP Address");
                case 1: return i18n("Client");
                case 2: return i18n("Down Speed");
                case 3: return i18n("Up Speed");
                case 4: return i18n("Choked");
                case 5: return i18n("Snubbed");
                case 6: return i18n("Availability");
                case 7: return i18n("DHT");
                case 8: return i18n("Score");
                case 9: return i18n("Upload Slot");
                case 10: return i18n("Requests");
                case 11: return i18n("Downloaded");
                case 12: return i18n("Uploaded");
                case 13: return i18n("Interested");
                case 14: return i18n("Interesting");
                default: return QVariant();
            }
        }
        else if (role == Qt::ToolTipRole)
        {
            switch (section)
            {
                case 0: return i18n("IP address of the peer");
                case 1: return i18n("Which client the peer is using");
                case 2: return i18n("Download speed");
                case 3: return i18n("Upload speed");
                case 4: return i18n("Whether or not the peer has choked us.  If we are choked, the peer will not send us any data.");
                case 5: return i18n("Snubbed means the peer has not sent us any data in the last 2 minutes");
                case 6: return i18n("How much of the torrent's data the peer has");
                case 7: return i18n("Whether or not the peer has DHT enabled");
                case 8: return i18n("The score of the peer. KTorrent uses this to determine who to upload to.");
                case 9: return i18n("Only peers which have an upload slot will get data from us");
                case 10: return i18n("The number of download and upload requests");
                case 11: return i18n("How much data we have downloaded from this peer");
                case 12: return i18n("How much data we have uploaded to this peer");
                case 13: return i18n("Whether the peer is interested in downloading data from us");
                case 14: return i18n("Whether we are interested in downloading from this peer");
                default: return QVariant();
            }
        }
        
        return QVariant();
    }
    
    QVariant PeerViewModel::data(const QModelIndex & index,int role) const
    {
        if (!index.isValid() || index.row() >= items.count() || index.row() < 0)
            return QVariant(); 
        
        Item* item = (Item*)index.internalPointer();
        if (role == Qt::DisplayRole)
            return item->data(index.column());
        else if (role == Qt::DecorationRole)
            return item->decoration(index.column());
        
        return QVariant();
    }
    
    bool PeerViewModel::removeRows ( int row,int count,const QModelIndex & /*parent*/ )
    {
        beginRemoveRows(QModelIndex(),row,row + count - 1);
        endRemoveRows();
        return true;
    }
    
    bool PeerViewModel::insertRows ( int row,int count,const QModelIndex & /*parent*/ )
    {
        beginInsertRows(QModelIndex(),row,row + count - 1);
        endInsertRows();
        return true;
    }

    bt::PeerInterface* PeerViewModel::indexToPeer(const QModelIndex & index)
    {
        if (!index.isValid() || index.row() >= items.count() || index.row() < 0)
            return 0; 
        else
            return ((Item*)index.internalPointer())->peer;
    }
    
    class PeerViewModelItemCmp
    {
    public:
        PeerViewModelItemCmp(int col,Qt::SortOrder order) : col(col),order(order)
        {}
        
        bool operator()(PeerViewModel::Item* a,PeerViewModel::Item* b)
        {
            if (order == Qt::AscendingOrder)
                return a->lessThan(col,b);
            else
                return !a->lessThan(col,b);
        }
        
        int col;
        Qt::SortOrder order;
    };

    void PeerViewModel::sort(int col, Qt::SortOrder order)
    {
        sort_column = col;
        sort_order = order;
        emit layoutAboutToBeChanged();
        qStableSort(items.begin(),items.end(),PeerViewModelItemCmp(col,order));
        emit layoutChanged();
    }
}