kget/core/transfertreemodel.cpp

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 2006 Dario Massarin <nekkar@libero.it>
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public
   7    License as published by the Free Software Foundation; version 2
   8    of the License.
   9 */
  10
  11 #include "core/transfertreemodel.h"
  12
  13 #include "core/kget.h"
  14 #include "core/transfertreeselectionmodel.h"
  15 #include "core/transfergrouphandler.h"
  16 #include "core/transfergroup.h"
  17 #include "core/transferhandler.h"
  18 #include "core/transfer.h"
  19 #include "settings.h"
  20
  21 #include <kdebug.h>
  22 #include <klocale.h>
  23 #include <kio/netaccess.h>
  24 #include <kiconloader.h>
  25
  26 #include <qmimedata.h>
  27
  28 TransferTreeModel::TransferTreeModel(Scheduler * scheduler)
  29     : QAbstractItemModel(),
  30       m_scheduler(scheduler),
  31       m_timerId(-1)
  32 {
  33
  34 }
  35
  36 TransferTreeModel::~TransferTreeModel()
  37 {
  38
  39 }
  40
  41 void TransferTreeModel::addGroup(TransferGroup * group)
  42 {
  43     beginInsertRows(QModelIndex(), m_transferGroups.size(), m_transferGroups.size());
  44
  45     m_transferGroups.append(group);
  46
  47     endInsertRows();
  48 }
  49
  50 void TransferTreeModel::delGroup(TransferGroup * group)
  51 {
  52     beginRemoveRows(QModelIndex(), m_transferGroups.indexOf(group), m_transferGroups.indexOf(group));
  53
  54     m_transferGroups.removeAll(group);
  55     m_changedGroups.removeAll(group->handler());
  56
  57     endRemoveRows();
  58 }
  59
  60 void TransferTreeModel::addTransfer(Transfer * transfer, TransferGroup * group)
  61 {
  62     beginInsertRows(createIndex(m_transferGroups.indexOf(group), 0, group->handler()), group->size(), group->size());
  63
  64     group->append(transfer);
  65
  66     endInsertRows();
  67 }
  68
  69 void TransferTreeModel::delTransfer(Transfer * transfer)
  70 {
  71     TransferGroup * group = transfer->group();
  72
  73     beginRemoveRows(createIndex(m_transferGroups.indexOf(group), 0, group->handler()), group->size()-1, group->size()-1);
  74
  75     group->remove(transfer);
  76     m_changedTransfers.removeAll(transfer->handler());
  77
  78     endRemoveRows();
  79 }
  80
  81 void TransferTreeModel::moveTransfer(Transfer * transfer, TransferGroup * destGroup, Transfer * after)
  82 {
  83     if( (after) && (destGroup != after->group()) )
  84         return;
  85
  86     int removePosition = transfer->group()->indexOf(transfer);
  87     int insertPosition = destGroup->size();
  88     int groupIndex = m_transferGroups.indexOf(destGroup);
  89
  90     beginRemoveRows(createIndex(groupIndex, 0, destGroup->handler()), removePosition, removePosition);
  91
  92     beginInsertRows(createIndex(m_transferGroups.indexOf(destGroup), 0, destGroup->handler()), insertPosition, insertPosition);
  93
  94     if(destGroup == transfer->group())
  95     {
  96         if(after)
  97             destGroup->move(transfer, after);
  98         else
  99             destGroup->move(transfer, static_cast<Transfer *>(destGroup->last()));
 100     }
 101     else
 102     {
 103         transfer->group()->remove(transfer);
 104
 105         if(destGroup->size() != 0)
 106             destGroup->insert(transfer, static_cast<Transfer *>(destGroup->last()));
 107         else
 108             destGroup->append(transfer);
 109
 110         transfer->m_jobQueue = destGroup;
 111     }
 112
 113     endInsertRows();
 114     endRemoveRows();
 115
 116     KGet::selectionModel()->clearSelection();
 117 }
 118
 119 const QList<TransferGroup *> & TransferTreeModel::transferGroups()
 120 {
 121     return m_transferGroups;
 122 }
 123
 124 TransferGroup * TransferTreeModel::findGroup(const QString & groupName)
 125 {
 126     QList<TransferGroup *>::iterator it = m_transferGroups.begin();
 127     QList<TransferGroup *>::iterator itEnd = m_transferGroups.end();
 128
 129     for(; it!=itEnd ; ++it)
 130     {
 131         if( (*it)->name() == groupName )
 132         {
 133             return *it;
 134         }
 135     }
 136     return 0;
 137 }
 138
 139 Transfer * TransferTreeModel::findTransfer(const KUrl &src)
 140 {
 141     QList<TransferGroup *>::iterator it = m_transferGroups.begin();
 142     QList<TransferGroup *>::iterator itEnd = m_transferGroups.end();
 143
 144     Transfer * t;
 145
 146     for(; it!=itEnd ; ++it)
 147     {
 148         if( ( t = (*it)->findTransfer(src) ) )
 149             return t;
 150     }
 151     return 0;
 152 }
 153
 154 Transfer *TransferTreeModel::findTransferByDestination(const KUrl &dest)
 155 {
 156     QList<TransferGroup *>::iterator it = m_transferGroups.begin();
 157     QList<TransferGroup *>::iterator itEnd = m_transferGroups.end();
 158
 159     Transfer *t;
 160     for(; it!=itEnd; ++it) {
 161         if((t = (*it)->findTransferByDestination(dest))) {
 162             return t;
 163         }
 164     }
 165
 166     return 0;
 167 }
 168
 169 bool TransferTreeModel::isTransferGroup(const QModelIndex & index) const
 170 {
 171 //     kDebug(5001) << "TransferTreeModel::isTransferGroup()";
 172
 173     void * pointer = index.internalPointer();
 174
 175     foreach(TransferGroup * group, m_transferGroups)
 176     {
 177         if(group->handler() == pointer)
 178         {
 179             return true;
 180         }
 181     }
 182
 183     return false;
 184 }
 185
 186 void TransferTreeModel::postDataChangedEvent(TransferHandler * transfer)
 187 {
 188     if(m_timerId == -1)
 189         m_timerId = startTimer(200);
 190
 191     m_changedTransfers.append(transfer);
 192 }
 193
 194 void TransferTreeModel::postDataChangedEvent(TransferGroupHandler * group)
 195 {
 196     if(m_timerId == -1)
 197         m_timerId = startTimer(200);
 198
 199     m_changedGroups.append(group);
 200 }
 201
 202 QModelIndex TransferTreeModel::createIndex(int row, int column, void * ptr) const
 203 {
 204     static int i = 0;
 205
 206     i++;
 207
 208 //     kDebug(5001) << "TransferTreeModel::createIndex() " << i;
 209
 210     return QAbstractItemModel::createIndex(row, column, ptr);
 211 }
 212
 213 int TransferTreeModel::rowCount(const QModelIndex & parent) const{
 214 //     kDebug(5001) << "TransferTreeModel::rowCount()";
 215
 216     if(!parent.isValid())
 217     {
 218 //         kDebug(5001) << "      (ROOT)  -> return " << m_transferGroups.size();
 219         return m_transferGroups.size();
 220     }
 221
 222     if(isTransferGroup(parent))
 223     {
 224         void * pointer = parent.internalPointer();
 225
 226         TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 227
 228 //         kDebug(5001) << "      (GROUP:" << group->name() << ") -> return " << group->size();
 229
 230         return group->size();
 231     }
 232
 233     return 0;
 234 }
 235
 236 int TransferTreeModel::columnCount(const QModelIndex & parent) const
 237 {
 238 //     kDebug(5001) << "TransferTreeModel::columnCount()";
 239
 240     if(!parent.isValid())
 241     {
 242         //Here we should return rootItem->columnCount(); .. but we don't
 243         //have a root Item... bah
 244         return 5;
 245     }
 246
 247     void * pointer = parent.internalPointer();
 248
 249     if(isTransferGroup(parent))
 250     {
 251         //The given index refers to a group object
 252         TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 253         return group->columnCount();
 254     }
 255
 256     //The given index refers to a group object
 257     TransferHandler * transfer = static_cast<TransferHandler *>(pointer);
 258     return transfer->columnCount();
 259 }
 260
 261
 262 Qt::ItemFlags TransferTreeModel::flags (const QModelIndex & index) const
 263 {
 264 //     kDebug(5001) << "TransferTreeModel::flags()";
 265     if (!index.isValid())
 266         return Qt::ItemIsEnabled;
 267
 268     Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 269
 270     if(isTransferGroup(index))
 271     {
 272         if(index.column() == 0)
 273             flags |= Qt::ItemIsDropEnabled;
 274     }
 275     else
 276         flags |= Qt::ItemIsDragEnabled;
 277
 278     //flags |= Qt::ItemIsDropEnabled;
 279
 280     // We can edit all the groups but the default one
 281     if(index.row() > 0) {
 282         flags |= Qt::ItemIsEditable;
 283     }
 284
 285     return flags;
 286 }
 287
 288 QVariant TransferTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 289 {
 290     if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
 291     {
 292         switch (section)
 293         {
 294             case 0:
 295                 return i18n("Name");
 296             case 1:
 297                 return i18n("Status");
 298             case 2:
 299                 return i18n("Size");
 300             case 3:
 301                 return i18n("Progress");
 302             case 4:
 303                 return i18n("Speed");
 304             default:
 305                 return QVariant();
 306         }
 307     }
 308
 309     return QVariant();
 310 }
 311
 312 QVariant TransferTreeModel::data(const QModelIndex & index, int role) const
 313 {
 314 //     kDebug(5001) << "TransferTreeModel::data()";
 315
 316     if (!index.isValid())
 317     {
 318 //         kDebug(5001) << "           (ROOT)";
 319         return QVariant();
 320     }
 321
 322     // KextendableItemDelegate::ShowExtensionIndicatorRole
 323     // tells the KExtendableItemDelegate which column contains the extender icon
 324     if (role == Qt::UserRole + 200 && !isTransferGroup(index)) {
 325         if (index.column () == 0 && Settings::showExpandableTransferDetails()) {
 326             return true;
 327         }
 328         else {
 329             return false;
 330         }
 331     }
 332
 333     if (role == Qt::DisplayRole || role == Qt::DecorationRole)
 334     {
 335         void * pointer = index.internalPointer();
 336
 337         if(isTransferGroup(index))
 338         {
 339             if (role == Qt::DisplayRole)
 340             {
 341 //                 kDebug(5001) << "           (GROUP)";
 342                 //The given index refers to a group object
 343                 TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 344                 return group->data(index.column());
 345             }
 346             else //Qt::DecorationRole -> icon
 347             {
 348                 if (index.column() == 0)
 349                     return SmallIcon("bookmark-new-list", 32);
 350                 else
 351                     return QVariant();
 352             }
 353         }
 354
 355 //         kDebug(5001) << "           (TRANSFER)";
 356
 357         //The given index refers to a transfer object
 358         TransferHandler * transfer = static_cast<TransferHandler *>(pointer);
 359
 360         if (role == Qt::DisplayRole)
 361             return transfer->data(index.column());
 362         else //Qt::DecorationRole -> icon
 363         {
 364             switch (index.column())
 365             {
 366                 case 0:
 367                     return KIO::pixmapForUrl(transfer->dest(), 0, KIconLoader::Desktop, 16);
 368                 case 1:
 369                     return transfer->statusPixmap();
 370                 default:
 371                     return QVariant();
 372             }
 373         }
 374     }
 375
 376     if (role == Qt::TextAlignmentRole)
 377     {
 378         if(isTransferGroup(index))
 379         {
 380             switch (index.column())
 381             {
 382                 case 0: // name
 383                     return Qt::AlignVCenter;
 384                 case 2: // size
 385                     return Qt::AlignCenter;
 386                 case 4: // speed
 387                     return Qt::AlignCenter;
 388                 case 3: //progress
 389                     return Qt::AlignCenter;
 390                 default:
 391                     return QVariant(Qt::AlignLeft | Qt::AlignBottom);
 392             }
 393         }
 394
 395         switch (index.column())
 396         {
 397             case 0: // name
 398                 return QVariant(Qt::AlignLeft | Qt::AlignVCenter);
 399             case 2: // size
 400                 return Qt::AlignCenter;
 401             case 4: // speed
 402                 return Qt::AlignCenter;
 403             case 3: //progress
 404                 return Qt::AlignCenter;
 405             default:
 406                 return Qt::AlignCenter;
 407         }
 408     }
 409
 410     return QVariant();
 411 }
 412
 413 QModelIndex TransferTreeModel::index(int row, int column, const QModelIndex & parent) const
 414 {
 415 //     kDebug(5001) << "TransferTreeModel::index()  ( " << row << " , " << column << " )";
 416
 417     if(!parent.isValid())
 418     {
 419 //         kDebug(5001) << "TransferTreeModel::index() -> group ( " << row << " , " << column << " )   Groups=" << m_transferGroups.size();
 420         //Look for the specific group
 421         if(row < m_transferGroups.size() && row >= 0)
 422         {
 423             return createIndex(row, column, m_transferGroups[row]->handler());
 424
 425         }
 426         else
 427             return QModelIndex();
 428     }
 429
 430     if(isTransferGroup(parent))
 431     {
 432         //The given parent refers to a TransferGroup object
 433         void * pointer = parent.internalPointer();
 434         TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 435
 436         //Look for the specific transfer
 437         if(row < group->size() && row >= 0)
 438         {
 439 //             kDebug(5001) << "aa      row=" << row;
 440             (*group)[row];
 441 //             kDebug(5001) << "bb";
 442 //             return (*group)[row]->index(column);
 443             return createIndex(row, column, (*group)[row]);
 444         }
 445         else
 446             return QModelIndex();
 447     }
 448
 449     //If here, the given parent is a Transfer object which hasn't any child
 450     return QModelIndex();
 451 }
 452
 453 QModelIndex TransferTreeModel::parent(const QModelIndex & index ) const
 454 {
 455 //     kDebug(5001) << "TransferTreeModel::parent()";
 456
 457     if(!index.isValid())
 458         return QModelIndex();
 459
 460     if(!isTransferGroup(index))
 461     {
 462         //The given index refers to a Transfer item
 463         void * pointer = index.internalPointer();
 464         TransferGroupHandler * group = static_cast<TransferHandler *>(pointer)->group();
 465         return createIndex(m_transferGroups.indexOf(group->m_group), 0, group);
 466     }
 467
 468     return QModelIndex();
 469 }
 470
 471 Qt::DropActions TransferTreeModel::supportedDropActions() const
 472 {
 473     return Qt::CopyAction | Qt::MoveAction;
 474 }
 475
 476 QStringList TransferTreeModel::mimeTypes() const
 477 {
 478     QStringList types;
 479     types << "application/vnd.text.list";
 480     return types;
 481 }
 482
 483 QMimeData * TransferTreeModel::mimeData(const QModelIndexList &indexes) const
 484 {
 485     QMimeData * mimeData = new QMimeData();
 486     QByteArray encodedData;
 487
 488     QDataStream stream(&encodedData, QIODevice::WriteOnly);
 489
 490     foreach (QModelIndex index, indexes)
 491     {
 492         if (index.isValid())
 493         {
 494             if(index.column() == 0 && index.parent().isValid())
 495             {
 496                 stream << data(index.parent(), Qt::DisplayRole).toString();
 497                 stream << QString::number((qulonglong) index.internalPointer(),16);
 498             }
 499         }
 500     }
 501
 502     mimeData->setData("application/vnd.text.list", encodedData);
 503     return mimeData;
 504 }
 505
 506 bool TransferTreeModel::dropMimeData(const QMimeData * mdata, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 507 {
 508     if (action == Qt::IgnoreAction)
 509         return true;
 510
 511     if (!mdata->hasFormat("application/vnd.text.list"))
 512         return false;
 513
 514     if (column > 0)
 515         return false;
 516
 517     if (parent.isValid())
 518         kDebug(5001) << "TransferTreeModel::dropMimeData" << " " << row << " "
 519                                                           << column << endl;
 520
 521     QByteArray encodedData = mdata->data("application/vnd.text.list");
 522     QDataStream stream(&encodedData, QIODevice::ReadOnly);
 523     QStringList stringList;
 524     int rows = 0;
 525
 526     while (!stream.atEnd())
 527     {
 528         QString text;
 529         stream >> text;
 530         stringList << text;
 531         ++rows;
 532     }
 533
 534     kDebug(5001) << "TransferTreeModel::dropMimeData    DATA:";
 535     kDebug(5001) << stringList;
 536
 537
 538     for(int i=0; i < rows; i++)
 539     {
 540 //         TransferGroup * group = findGroup(stringList[i]);
 541
 542 //         TransferGroup * destGroup = static_cast<TransferGroup *>(index(row, column, parent).internalPointer());
 543
 544         TransferGroup * destGroup = findGroup(data(parent, Qt::DisplayRole).toString());
 545
 546         TransferHandler * transferHandler = (TransferHandler *) stringList[++i].toInt(0, 16);
 547
 548         moveTransfer(transferHandler->m_transfer, destGroup);
 549     }
 550     return true;
 551 }
 552
 553 void TransferTreeModel::timerEvent(QTimerEvent *event)
 554 {
 555     Q_UNUSED(event);
 556 //     kDebug(5001) << "TransferTreeModel::timerEvent";
 557
 558     QList<TransferHandler *> updatedTransfers;
 559     QList<TransferGroupHandler *> updatedGroups;
 560
 561     foreach(TransferHandler * transfer, m_changedTransfers)
 562     {
 563         if(!updatedTransfers.contains(transfer))
 564         {
 565             TransferGroupHandler * group = transfer->group();
 566
 567             emit dataChanged(createIndex(group->indexOf(transfer), 0, transfer),
 568                             createIndex(group->indexOf(transfer), transfer->columnCount(), transfer));
 569
 570             updatedTransfers.append(transfer);
 571         }
 572     }
 573
 574     foreach(TransferGroupHandler * group, m_changedGroups)
 575     {
 576         if(!updatedGroups.contains(group))
 577         {
 578             emit dataChanged(createIndex(m_transferGroups.indexOf(group->m_group), 0, group),
 579                             createIndex(m_transferGroups.indexOf(group->m_group), group->columnCount(), group));
 580
 581             updatedGroups.append(group);
 582         }
 583     }
 584
 585     m_changedTransfers.clear();
 586     m_changedGroups.clear();
 587
 588     killTimer(m_timerId);
 589     m_timerId = -1;
 590 }
 591
 592 #include "transfertreemodel.moc"