NodeModel.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko 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.

Calitko 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 Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "NodeModel.h"
#include "Gnutella/LocalPeer.h"

NodeModel::NodeModel()
 :  nodeInfos(), updateTimer(), mapper()
{
    // <pd_todo> move back to the view
    connect (&updateTimer, SIGNAL (timeout()), this, SLOT (refreshModel()));
    updateTimer.setInterval (ModelRefreshInterval);
    updateTimer.start();
    connect (&mapper, SIGNAL (mapped (QObject *)),
         this, SLOT (setDisconnected (QObject *)));
}

NodeModel::~NodeModel()
{
    foreach (NodeData *info, nodeInfos)
        delete info;
    nodeInfos.clear();
}
int NodeModel::nodeIndex (ConnectionId id)
{
    int count = nodeInfos.count();
    for (int i = 0; i < count; i++)
        if (nodeInfos.at (i)->id == id)
            return i;

    return -1;
}

void NodeModel::refreshModel()
{
    dataChanged (index(0, 0), index(rowCount() - 1, columnCount() - 1));
}

int NodeModel::rowCount (const QModelIndex &) const
{
    return nodeInfos.count();
}

int NodeModel::columnCount (const QModelIndex &) const
{
    return ColumnCount;
}

QVariant NodeModel::data (const QModelIndex &index, int role) const
{
    if (role == Qt::DisplayRole){
        NodeData* nodeInfo = nodeInfos.at(index.row());
        switch (index.column())
        {
        case AddressIndex:              return nodeInfo->address;
        case PortIndex:                 return static_cast <uint> (nodeInfo->port);
        case DurationIndex:
            switch (nodeInfo->status)
            {
            case Connecting:            return tr ("Connecting...");
            case Handshaking:           return tr ("Handshaking...");
            case Connected:         //return tr ("Connected"); <pd_todo> Calculate days and time!
                return QTime().addSecs (nodeInfo->startDateTime.secsTo (QDateTime::currentDateTime()));
            case Disconnecting:         return tr ("Disconnecting...");
            case Disconnected:          return tr ("Disconnected");
            default:                    return tr ("Unknown");
            }
        case TypeIndex:
            switch (nodeInfo->type)
            {
            case Peer:                  return tr ("Peer");
            case Ultrapeer:             return tr ("Ultrapeer");
            case Leaf:                  return tr ("Leaf");
            case Undetermined:          // fallthrough
            default:                    return QVariant();
            }
        case ServentIndex:              return nodeInfo->servent;
        default:                        return QVariant();
        }
    }

    if (role == Qt::DecorationRole && index.column() == AddressIndex)
        return QIcon ("Icons/peer.png");

    return QVariant();
}

QVariant NodeModel::headerData (int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Vertical || role != Qt::DisplayRole)
        return QVariant();

    switch (section)
    {
    case AddressIndex:      return tr ("Address");
    case PortIndex:         return tr ("Port");
    case DurationIndex:     return tr ("Duration");
    case TypeIndex:         return tr ("Type");
    case ServentIndex:      return tr ("Servent");
    default:                return QVariant();
    }
}

void NodeModel::nodeConnecting (Connection *connection, NodeAddress nodeAddress)
{
    int row = nodeInfos.count();
    beginInsertRows (QModelIndex(), row, row);

    NodeData *info      = new NodeData;
    info->id            = reinterpret_cast <ConnectionId> (connection);
    info->address       = nodeAddress.hostAddress().toString();
    if (info->address.length() == 0)
        info->address   = nodeAddress.hostName();
    info->port          = nodeAddress.hostPort();
    info->startDateTime = QDateTime::currentDateTime();
    info->status        = Connecting;
    info->type          = Undetermined;
    nodeInfos.append (info);

    endInsertRows ();

    connect (connection, SIGNAL (destroyed()), &mapper, SLOT (map()));
    mapper.setMapping (connection, reinterpret_cast <QObject *> (connection));
}

void NodeModel::setHandshaking (Connection *connection)
{
    setNodeStatus (reinterpret_cast <ConnectionId> (connection), Handshaking);
}

void NodeModel::setConnected (Connection *connection, NodeInfo nodeInfo)
{
    Type type = Undetermined;
    if (nodeInfo.type == Gnutella::TypeLeaf)
        type = Leaf;
    if (nodeInfo.type == Gnutella::TypePeer)
        type = Peer;
    if (nodeInfo.type == Gnutella::TypeUltrapeer)
        type = Ultrapeer;

    setNodeStatus (reinterpret_cast <ConnectionId> (connection), Connected);
    setNodeType (reinterpret_cast <ConnectionId> (connection), type);
    setNodeServent (reinterpret_cast <ConnectionId> (connection), nodeInfo.identification);
    setNodePort (reinterpret_cast <ConnectionId> (connection), nodeInfo.address.hostPort());
}

void NodeModel::setDisconnected (QObject *id)
{
    nodeDisconnected (reinterpret_cast <ConnectionId> (id));
}

bool NodeModel::nodeDisconnected (ConnectionId id)
{
    int row = nodeIndex (id);
    if (row == -1)
        return false;

    beginRemoveRows (QModelIndex(), row, row);

    delete nodeInfos.takeAt (row);

    endRemoveRows();
    return true;
}

bool NodeModel::setNodeStatus (ConnectionId id, Status status)
{
    int row = nodeIndex (id);
    if (row == -1)
        return false;

    NodeData *info = nodeInfos.at (row);
    if (status == Connected)
        info->startDateTime = QDateTime::currentDateTime();
    info->status = status;

    dataChanged (index (row, DurationIndex), index (row, DurationIndex));
    return true;
}

bool NodeModel::setNodeType (ConnectionId id, Type type)
{
    int row = nodeIndex (id);
    if (row == -1)
        return false;

    nodeInfos.at (row)->type = type;
    dataChanged (index (row, TypeIndex), index (row, TypeIndex));
    return true;
}

bool NodeModel::setNodeServent (ConnectionId id, const QString &servent)
{
    int row = nodeIndex (id);
    if (row == -1)
        return false;

    nodeInfos.at (row)->servent = servent;
    dataChanged (index (row, ServentIndex), index (row, ServentIndex));
    return true;
}

bool NodeModel::setNodePort (ConnectionId id, quint16 port)
{
    int row = nodeIndex (id);
    if (row == -1)
        return false;

    nodeInfos.at (row)->port = port;
    dataChanged (index (row, PortIndex), index (row, PortIndex));
    return true;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.