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; either
   8    version 2 of the License, or (at your option) any later version.
   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     // Remove index corresponding to when it's created.
  74     int remove_index = group->indexOf(transfer);
  75     beginRemoveRows(createIndex(m_transferGroups.indexOf(group), 0, group->handler()), remove_index, remove_index);
  76
  77     group->remove(transfer);
  78     m_changedTransfers.removeAll(transfer->handler());
  79
  80     endRemoveRows();
  81 }
  82
  83 void TransferTreeModel::moveTransfer(Transfer * transfer, TransferGroup * destGroup, Transfer * after)
  84 {
  85     if( (after) && (destGroup != after->group()) )
  86         return;
  87
  88     int removePosition = transfer->group()->indexOf(transfer);
  89     int insertPosition = destGroup->size();
  90     int groupIndex = m_transferGroups.indexOf(destGroup);
  91
  92     beginRemoveRows(createIndex(groupIndex, 0, destGroup->handler()), removePosition, removePosition);
  93
  94     beginInsertRows(createIndex(m_transferGroups.indexOf(destGroup), 0, destGroup->handler()), insertPosition, insertPosition);
  95
  96     if(destGroup == transfer->group())
  97     {
  98         if(after)
  99             destGroup->move(transfer, after);
 100         else
 101             destGroup->move(transfer, static_cast<Transfer *>(destGroup->last()));
 102     }
 103     else
 104     {
 105         transfer->group()->remove(transfer);
 106
 107         if(destGroup->size() != 0)
 108             destGroup->insert(transfer, static_cast<Transfer *>(destGroup->last()));
 109         else
 110             destGroup->append(transfer);
 111
 112         transfer->m_jobQueue = destGroup;
 113     }
 114
 115     endInsertRows();
 116     endRemoveRows();
 117
 118     KGet::selectionModel()->clearSelection();
 119 }
 120
 121 const QList<TransferGroup *> & TransferTreeModel::transferGroups()
 122 {
 123     return m_transferGroups;
 124 }
 125
 126 TransferGroup * TransferTreeModel::findGroup(const QString & groupName)
 127 {
 128     QList<TransferGroup *>::iterator it = m_transferGroups.begin();
 129     QList<TransferGroup *>::iterator itEnd = m_transferGroups.end();
 130
 131     for(; it!=itEnd ; ++it)
 132     {
 133         if( (*it)->name() == groupName )
 134         {
 135             return *it;
 136         }
 137     }
 138     return 0;
 139 }
 140
 141 Transfer * TransferTreeModel::findTransfer(const KUrl &src)
 142 {
 143     QList<TransferGroup *>::iterator it = m_transferGroups.begin();
 144     QList<TransferGroup *>::iterator itEnd = m_transferGroups.end();
 145
 146     Transfer * t;
 147
 148     for(; it!=itEnd ; ++it)
 149     {
 150         if( ( t = (*it)->findTransfer(src) ) )
 151             return t;
 152     }
 153     return 0;
 154 }
 155
 156 Transfer *TransferTreeModel::findTransferByDestination(const KUrl &dest)
 157 {
 158     QList<TransferGroup *>::iterator it = m_transferGroups.begin();
 159     QList<TransferGroup *>::iterator itEnd = m_transferGroups.end();
 160
 161     Transfer *t;
 162     for(; it!=itEnd; ++it) {
 163         if((t = (*it)->findTransferByDestination(dest))) {
 164             return t;
 165         }
 166     }
 167
 168     return 0;
 169 }
 170
 171 bool TransferTreeModel::isTransferGroup(const QModelIndex & index) const
 172 {
 173 //     kDebug(5001) << "TransferTreeModel::isTransferGroup()";
 174
 175     void * pointer = index.internalPointer();
 176
 177     Handler *ph = static_cast<Handler*>(pointer);
 178     if (dynamic_cast<TransferGroupHandler*>(ph))
 179     {
 180         return true;
 181     }
 182     return false;
 183 }
 184
 185 void TransferTreeModel::postDataChangedEvent(TransferHandler * transfer)
 186 {
 187     if(m_timerId == -1)
 188         m_timerId = startTimer(500);
 189
 190     m_changedTransfers.append(transfer);
 191 }
 192
 193 void TransferTreeModel::postDataChangedEvent(TransferGroupHandler * group)
 194 {
 195     if(m_timerId == -1)
 196         m_timerId = startTimer(500);
 197
 198     m_changedGroups.append(group);
 199 }
 200
 201 QModelIndex TransferTreeModel::createIndex(int row, int column, void * ptr) const
 202 {
 203     static int i = 0;
 204
 205     i++;
 206
 207 //     kDebug(5001) << "TransferTreeModel::createIndex() " << i;
 208
 209     return QAbstractItemModel::createIndex(row, column, ptr);
 210 }
 211
 212 int TransferTreeModel::rowCount(const QModelIndex & parent) const{
 213 //     kDebug(5001) << "TransferTreeModel::rowCount()";
 214
 215     if(!parent.isValid())
 216     {
 217 //         kDebug(5001) << "      (ROOT)  -> return " << m_transferGroups.size();
 218         return m_transferGroups.size();
 219     }
 220
 221     if(isTransferGroup(parent))
 222     {
 223         void * pointer = parent.internalPointer();
 224
 225         TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 226
 227 //         kDebug(5001) << "      (GROUP:" << group->name() << ") -> return " << group->size();
 228
 229         return group->size();
 230     }
 231
 232     return 0;
 233 }
 234
 235 int TransferTreeModel::columnCount(const QModelIndex & parent) const
 236 {
 237 //     kDebug(5001) << "TransferTreeModel::columnCount()";
 238
 239     if(!parent.isValid())
 240     {
 241         //Here we should return rootItem->columnCount(); .. but we don't
 242         //have a root Item... bah
 243         return 6;
 244     }
 245
 246     void * pointer = parent.internalPointer();
 247
 248     if(isTransferGroup(parent))
 249     {
 250         //The given index refers to a group object
 251         TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 252         return group->columnCount();
 253     }
 254
 255     //The given index refers to a group object
 256     TransferHandler * transfer = static_cast<TransferHandler *>(pointer);
 257     return transfer->columnCount();
 258 }
 259
 260
 261 Qt::ItemFlags TransferTreeModel::flags (const QModelIndex & index) const
 262 {
 263 //     kDebug(5001) << "TransferTreeModel::flags()";
 264     if (!index.isValid())
 265         return Qt::ItemIsEnabled;
 266
 267     Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 268
 269     if(isTransferGroup(index))
 270     {
 271         if(index.column() == 0)
 272             flags |= Qt::ItemIsDropEnabled;
 273     }
 274     else
 275         flags |= Qt::ItemIsDragEnabled;
 276
 277     //flags |= Qt::ItemIsDropEnabled;
 278
 279     // We can edit all the groups but the default one
 280     if(index.row() > 0) {
 281         flags |= Qt::ItemIsEditable;
 282     }
 283
 284     return flags;
 285 }
 286
 287 QVariant TransferTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 288 {
 289     if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
 290     {
 291         switch (section)
 292         {
 293             case 0:
 294                 return i18nc("name of download", "Name");
 295             case 1:
 296                 return i18nc("status of download", "Status");
 297             case 2:
 298                 return i18nc("size of download", "Size");
 299             case 3:
 300                 return i18nc("progress of download", "Progress");
 301             case 4:
 302                 return i18nc("speed of download", "Speed");
 303             case 5:
 304                 return i18nc("remaining time of download", "Remaining Time");
 305             default:
 306                 return QVariant();
 307         }
 308     }
 309
 310     return QVariant();
 311 }
 312
 313 QVariant TransferTreeModel::data(const QModelIndex & index, int role) const
 314 {
 315 //     kDebug(5001) << "TransferTreeModel::data()";
 316
 317     if (!index.isValid())
 318     {
 319 //         kDebug(5001) << "           (ROOT)";
 320         return QVariant();
 321     }
 322
 323     // KextendableItemDelegate::ShowExtensionIndicatorRole
 324     // tells the KExtendableItemDelegate which column contains the extender icon
 325     if (role == Qt::UserRole + 200 && !isTransferGroup(index)) {
 326         if (index.column () == 0 && Settings::showExpandableTransferDetails()) {
 327             return true;
 328         }
 329         else {
 330             return false;
 331         }
 332     }
 333
 334     if (role == Qt::DisplayRole || role == Qt::DecorationRole)
 335     {
 336         void * pointer = index.internalPointer();
 337
 338         if(isTransferGroup(index))
 339         {
 340             TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 341             if (role == Qt::DisplayRole)
 342             {
 343 //                 kDebug(5001) << "           (GROUP)";
 344                 //The given index refers to a group object
 345                 return group->data(index.column());
 346             }
 347             else //Qt::DecorationRole -> icon
 348             {
 349                 if (index.column() == 0)
 350                     return group->pixmap();
 351                 else
 352                     return QVariant();
 353             }
 354         }
 355
 356 //         kDebug(5001) << "           (TRANSFER)";
 357
 358         //The given index refers to a transfer object
 359         TransferHandler * transfer = static_cast<TransferHandler *>(pointer);
 360
 361         if (role == Qt::DisplayRole)
 362             return transfer->data(index.column());
 363         else //Qt::DecorationRole -> icon
 364         {
 365             switch (index.column())
 366             {
 367                 case 0:
 368                     return KIO::pixmapForUrl(transfer->dest(), 0, KIconLoader::Desktop, 16);
 369                 case 1:
 370                     return transfer->statusPixmap();
 371                 default:
 372                     return QVariant();
 373             }
 374         }
 375     }
 376
 377     if (role == Qt::TextAlignmentRole)
 378     {
 379         if(isTransferGroup(index))
 380         {
 381             switch (index.column())
 382             {
 383                 case 0: // name
 384                     return Qt::AlignVCenter;
 385                 case 2: // size
 386                     return Qt::AlignCenter;
 387                 case 4: // speed
 388                     return Qt::AlignCenter;
 389                 case 3: //progress
 390                     return Qt::AlignCenter;
 391                 default:
 392                     return QVariant(Qt::AlignLeft | Qt::AlignBottom);
 393             }
 394         }
 395
 396         switch (index.column())
 397         {
 398             case 0: // name
 399                 return QVariant(Qt::AlignLeft | Qt::AlignVCenter);
 400             case 2: // size
 401                 return Qt::AlignCenter;
 402             case 4: // speed
 403                 return Qt::AlignCenter;
 404             case 3: //progress
 405                 return Qt::AlignCenter;
 406             default:
 407                 return Qt::AlignCenter;
 408         }
 409     }
 410
 411     return QVariant();
 412 }
 413
 414 QModelIndex TransferTreeModel::index(int row, int column, const QModelIndex & parent) const
 415 {
 416 //     kDebug(5001) << "TransferTreeModel::index()  ( " << row << " , " << column << " )";
 417
 418     if(!parent.isValid())
 419     {
 420 //         kDebug(5001) << "TransferTreeModel::index() -> group ( " << row << " , " << column << " )   Groups=" << m_transferGroups.size();
 421         //Look for the specific group
 422         if(row < m_transferGroups.size() && row >= 0)
 423         {
 424             return createIndex(row, column, m_transferGroups[row]->handler());
 425
 426         }
 427         else
 428             return QModelIndex();
 429     }
 430
 431     if(isTransferGroup(parent))
 432     {
 433         //The given parent refers to a TransferGroupHandler object
 434         void * pointer = parent.internalPointer();
 435         TransferGroupHandler * group = static_cast<TransferGroupHandler *>(pointer);
 436
 437         //Look for the specific transfer
 438         if(row < group->size() && row >= 0)
 439         {
 440 //             kDebug(5001) << "aa      row=" << row;
 441             (*group)[row];
 442 //             kDebug(5001) << "bb";
 443 //             return (*group)[row]->index(column);
 444             return createIndex(row, column, (*group)[row]);
 445         }
 446         else
 447             return QModelIndex();
 448     }
 449
 450     //If here, the given parent is a Transfer object which hasn't any child
 451     return QModelIndex();
 452 }
 453
 454 QModelIndex TransferTreeModel::parent(const QModelIndex & index ) const
 455 {
 456 //     kDebug(5001) << "TransferTreeModel::parent()";
 457
 458     if(!index.isValid())
 459         return QModelIndex();
 460
 461     if(!isTransferGroup(index))
 462     {
 463         //The given index refers to a Transfer item
 464         void * pointer = index.internalPointer();
 465         TransferGroupHandler * group = static_cast<TransferHandler *>(pointer)->group();
 466         return createIndex(m_transferGroups.indexOf(group->m_group), 0, group);
 467     }
 468
 469     return QModelIndex();
 470 }
 471
 472 Qt::DropActions TransferTreeModel::supportedDropActions() const
 473 {
 474     return Qt::CopyAction | Qt::MoveAction;
 475 }
 476
 477 QStringList TransferTreeModel::mimeTypes() const
 478 {
 479     QStringList types;
 480     types << "application/vnd.text.list";
 481     return types;
 482 }
 483
 484 QMimeData * TransferTreeModel::mimeData(const QModelIndexList &indexes) const
 485 {
 486     QMimeData * mimeData = new QMimeData();
 487     QByteArray encodedData;
 488
 489     QDataStream stream(&encodedData, QIODevice::WriteOnly);
 490
 491     foreach (const QModelIndex &index, indexes)
 492     {
 493         if (index.isValid())
 494         {
 495             if(index.column() == 0 && index.parent().isValid())
 496             {
 497                 stream << data(index.parent(), Qt::DisplayRole).toString();
 498                 stream << QString::number((qulonglong) index.internalPointer(),16);
 499             }
 500         }
 501     }
 502
 503     mimeData->setData("application/vnd.text.list", encodedData);
 504     return mimeData;
 505 }
 506
 507 bool TransferTreeModel::dropMimeData(const QMimeData * mdata, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 508 {
 509     if (action == Qt::IgnoreAction)
 510         return true;
 511
 512     if (!mdata->hasFormat("application/vnd.text.list"))
 513         return false;
 514
 515     if (column > 0)
 516         return false;
 517
 518     if (parent.isValid())
 519         kDebug(5001) << "TransferTreeModel::dropMimeData" << " " << row << " "
 520                                                           << column << endl;
 521
 522     QByteArray encodedData = mdata->data("application/vnd.text.list");
 523     QDataStream stream(&encodedData, QIODevice::ReadOnly);
 524     QStringList stringList;
 525     int rows = 0;
 526
 527     while (!stream.atEnd())
 528     {
 529         QString text;
 530         stream >> text;
 531         stringList << text;
 532         ++rows;
 533     }
 534
 535     kDebug(5001) << "TransferTreeModel::dropMimeData    DATA:";
 536     kDebug(5001) << stringList;
 537
 538
 539     for(int i=0; i < rows; i++)
 540     {
 541 //         TransferGroup * group = findGroup(stringList[i]);
 542
 543 //         TransferGroup * destGroup = static_cast<TransferGroup *>(index(row, column, parent).internalPointer());
 544
 545         TransferGroup * destGroup = findGroup(data(parent, Qt::DisplayRole).toString());
 546
 547         TransferHandler * transferHandler = (TransferHandler *) stringList[++i].toInt(0, 16);
 548
 549         if(destGroup)
 550             moveTransfer(transferHandler->m_transfer, destGroup);
 551     }
 552     return true;
 553 }
 554
 555 QString TransferTreeModel::columnName(int column)
 556 {
 557     switch(column) {
 558         case TransferTreeModel::Name:
 559             return i18n("Name");
 560         case TransferTreeModel::Status:
 561             return i18n("Status");
 562         case TransferTreeModel::Size:
 563             return i18n("Size");
 564         case TransferTreeModel::Progress:
 565             return i18n("Progress");
 566         case TransferTreeModel::Speed:
 567             return i18n("Speed");
 568         case TransferTreeModel::RemainingTime:
 569             return i18n("Remaining Time");
 570         default:
 571             return QString();
 572     }
 573 }
 574
 575 void TransferTreeModel::timerEvent(QTimerEvent *event)
 576 {
 577     Q_UNUSED(event);
 578 //     kDebug(5001) << "TransferTreeModel::timerEvent";
 579
 580     QList<TransferHandler *> updatedTransfers;
 581     QList<TransferGroupHandler *> updatedGroups;
 582
 583     foreach(TransferHandler * transfer, m_changedTransfers)
 584     {
 585         if(!updatedTransfers.contains(transfer))
 586         {
 587             TransferGroupHandler * group = transfer->group();
 588             Transfer::ChangesFlags changesFlags = transfer->changesFlags(0);
 589
 590             for(int i=0; i<8; i++)//Check the 8 most right bits of the flag
 591             {
 592                 if (((changesFlags >> i) & 0x00000001))//remove the ith bit(s) from the right and check if the rest is 0x00000001...
 593                 {
 594                     QModelIndex index = createIndex(group->indexOf(transfer), i, transfer);
 595                     emit dataChanged(index,index);
 596                 }
 597             }
 598
 599             transfer->resetChangesFlags(0);
 600             updatedTransfers.append(transfer);
 601         }
 602     }
 603
 604     foreach(TransferGroupHandler * group, m_changedGroups)
 605     {
 606         if(!updatedGroups.contains(group))
 607         {
 608             TransferGroup::ChangesFlags changesFlags = group->changesFlags(0);
 609
 610             for(int i=0; i<8; i++)
 611             {
 612                 if(((changesFlags >> i) & 0x00000001))
 613                 {
 614                     QModelIndex index = createIndex(m_transferGroups.indexOf(group->m_group), i, group);
 615                     emit dataChanged(index,index);
 616                 }
 617             }
 618
 619             group->resetChangesFlags(0);
 620             updatedGroups.append(group);
 621         }
 622     }
 623
 624     m_changedTransfers.clear();
 625     m_changedGroups.clear();
 626
 627     killTimer(m_timerId);
 628     m_timerId = -1;
 629 }
 630
 631 #include "transfertreemodel.moc"