kget/transfer-plugins/bittorrent/torrentfiletreemodel.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Joris Guisson and Ivan Vasic                    *
   3  *   joris.guisson@gmail.com                                               *
   4  *   ivasic@gmail.com                                                      *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program is distributed in the hope that it will be useful,       *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this program; if not, write to the                         *
  18  *   Free Software Foundation, Inc.,                                       *
  19  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
  20  ***************************************************************************/
  21 #include <klocale.h>
  22 #include <kicon.h>
  23 #include <kmimetype.h>
  24 #include <QTreeView>
  25 #include <bcodec/bdecoder.h>
  26 #include <bcodec/bencoder.h>
  27 #include <bcodec/bnode.h>
  28 #include <interfaces/torrentinterface.h>
  29 #include <interfaces/torrentfileinterface.h>
  30 #include <util/functions.h>
  31 #include <util/log.h>
  32 #include "torrentfiletreemodel.h"
  33
  34 using namespace bt;
  35
  36 namespace kt
  37 {
  38
  39         TorrentFileTreeModel::Node::Node(Node* parent,bt::TorrentFileInterface* file,const QString & name)
  40                 : parent(parent),file(file),name(name),size(0)
  41         {}
  42
  43         TorrentFileTreeModel::Node::Node(Node* parent,const QString & name)
  44                 : parent(parent),file(0),name(name),size(0)
  45         {
  46         }
  47
  48         TorrentFileTreeModel::Node::~Node()
  49         {
  50                 qDeleteAll(children);
  51         }
  52
  53         void TorrentFileTreeModel::Node::insert(const QString & path,bt::TorrentFileInterface* file)
  54         {
  55                 int p = path.indexOf(bt::DirSeparator());
  56                 if (p == -1)
  57                 {
  58                                 // the file is part of this directory
  59                         children.append(new Node(this,file,path));
  60                 }
  61                 else
  62                 {
  63                         QString subdir = path.left(p);
  64                         foreach (Node* n,children)
  65                         {
  66                                 if (n->name == subdir)
  67                                 {
  68                                         n->insert(path.mid(p+1),file);
  69                                         return;
  70                                 }
  71                         }
  72
  73                         Node* n = new Node(this,subdir);
  74                         children.append(n);
  75                         n->insert(path.mid(p+1),file);
  76                 }
  77         }
  78
  79         int TorrentFileTreeModel::Node::row()
  80         {
  81                 if (parent)
  82                         return parent->children.indexOf(this);
  83                 else
  84                         return 0;
  85         }
  86
  87         bt::Uint64 TorrentFileTreeModel::Node::fileSize(const bt::TorrentInterface* tc)
  88         {
  89                 if (size > 0)
  90                         return size;
  91
  92                 if (!file)
  93                 {
  94                         // directory
  95                         foreach (Node* n,children)
  96                                 size += n->fileSize(tc);
  97                 }
  98                 else
  99                 {
 100                         size = file->getSize();
 101                 }
 102                 return size;
 103         }
 104
 105         bt::Uint64 TorrentFileTreeModel::Node::bytesToDownload(const bt::TorrentInterface* tc)
 106         {
 107                 bt::Uint64 s = 0;
 108
 109                 if (!file)
 110                 {
 111                                 // directory
 112                         foreach (Node* n,children)
 113                                 s += n->bytesToDownload(tc);
 114                 }
 115                 else
 116                 {
 117                         if (!file->doNotDownload())
 118                                 s = file->getSize();
 119                 }
 120                 return s;
 121         }
 122
 123         Qt::CheckState TorrentFileTreeModel::Node::checkState(const bt::TorrentInterface* tc) const
 124         {
 125                 if (!file)
 126                 {
 127                         bool found_checked = false;
 128                         bool found_unchecked = false;
 129                                 // directory
 130                         foreach (Node* n,children)
 131                         {
 132                                 Qt::CheckState s = n->checkState(tc);
 133                                 if (s == Qt::PartiallyChecked)
 134                                         return s;
 135                                 else if (s == Qt::Checked)
 136                                         found_checked = true;
 137                                 else
 138                                         found_unchecked = true;
 139
 140                                 if (found_checked && found_unchecked)
 141                                         return Qt::PartiallyChecked;
 142                         }
 143
 144                         return found_checked ? Qt::Checked : Qt::Unchecked;
 145                 }
 146                 else
 147                 {
 148                         return file->doNotDownload() || file->getPriority() == ONLY_SEED_PRIORITY ? Qt::Unchecked : Qt::Checked;
 149                 }
 150         }
 151
 152         void TorrentFileTreeModel::Node::saveExpandedState(const QModelIndex & index,QTreeView* tv,BEncoder* enc)
 153         {
 154                 if (file)
 155                         return;
 156
 157                 enc->write("expanded");
 158                 enc->write((Uint32)(tv->isExpanded(index) ? 1 : 0));
 159
 160                 int idx = 0;
 161                 foreach (Node* n,children)
 162                 {
 163                         if (!n->file)
 164                         {
 165                                 enc->write(n->name);
 166                                 enc->beginDict();
 167                                 n->saveExpandedState(index.child(idx,0),tv,enc);
 168                                 enc->end();
 169                         }
 170                         idx++;
 171                 }
 172         }
 173
 174         void TorrentFileTreeModel::Node::loadExpandedState(const QModelIndex & index,QTreeView* tv,BNode* n)
 175         {
 176                 if (file)
 177                         return;
 178
 179                 BDictNode* dict = dynamic_cast<BDictNode*>(n);
 180                 if (!dict)
 181                         return;
 182
 183                 BValueNode* v = dict->getValue("expanded");
 184                 if (v)
 185                         tv->setExpanded(index,v->data().toInt() == 1);
 186
 187                 int idx = 0;
 188                 foreach (Node* n,children)
 189                 {
 190                         if (!n->file)
 191                         {
 192                                 BDictNode* d = dict->getDict(n->name);
 193                                 if (d)
 194                                         n->loadExpandedState(index.child(idx,0),tv,d);
 195                         }
 196                         idx++;
 197                 }
 198         }
 199
 200         TorrentFileTreeModel::TorrentFileTreeModel(bt::TorrentInterface* tc,DeselectMode mode,QObject* parent)
 201         : TorrentFileModel(tc,mode,parent),root(0),emit_check_state_change(true)
 202         {
 203                 if (tc->getStats().multi_file_torrent)
 204                         constructTree();
 205                 else
 206                         root = new Node(0,tc->getStats().torrent_name);
 207         }
 208
 209
 210         TorrentFileTreeModel::~TorrentFileTreeModel()
 211         {}
 212
 213         void TorrentFileTreeModel::constructTree()
 214         {
 215                 if (!root)
 216                         root = new Node(0,tc->getStats().torrent_name);
 217
 218                 for (Uint32 i = 0;i < tc->getNumFiles();i++)
 219                 {
 220                         bt::TorrentFileInterface & tf = tc->getTorrentFile(i);
 221                         root->insert(tf.getPath(),&tf);
 222                 }
 223         }
 224
 225         int TorrentFileTreeModel::rowCount(const QModelIndex & parent) const
 226         {
 227                 if (!parent.isValid())
 228                 {
 229                         return 1;
 230                 }
 231                 else
 232                 {
 233                         Node* n = (Node*)parent.internalPointer();
 234                         return n->children.count();
 235                 }
 236         }
 237
 238         int TorrentFileTreeModel::columnCount(const QModelIndex & parent) const
 239         {
 240                 if (!parent.isValid())
 241                         return 2;
 242                 else
 243                         return 2;
 244         }
 245
 246         QVariant TorrentFileTreeModel::headerData(int section, Qt::Orientation orientation,int role) const
 247         {
 248                 if (role != Qt::DisplayRole || orientation != Qt::Horizontal)
 249                         return QVariant();
 250
 251                 switch (section)
 252                 {
 253                         case 0: return i18n("File");
 254                         case 1: return i18n("Size");
 255                         default:
 256                                 return QVariant();
 257                 }
 258         }
 259
 260         QVariant TorrentFileTreeModel::data(const QModelIndex & index, int role) const
 261         {
 262                 if (!index.isValid())
 263                         return QVariant();
 264
 265                 Node* n = (Node*)index.internalPointer();
 266                 if (!n)
 267                         return QVariant();
 268
 269                 if (role == Qt::DisplayRole)
 270                 {
 271                         switch (index.column())
 272                         {
 273                                 case 0: return n->name;
 274                                 case 1:
 275                                         if (tc->getStats().multi_file_torrent)
 276                                                 return BytesToString(n->fileSize(tc));
 277                                         else
 278                                                 return BytesToString(tc->getStats().total_bytes);
 279                                 default: return QVariant();
 280                         }
 281                 }
 282                 else if (role == Qt::DecorationRole && index.column() == 0)
 283                 {
 284                         // if this is an empty folder then we are in the single file case
 285                         if (!n->file)
 286                                 return n->children.count() > 0 ?
 287                                                 KIcon("folder") : KIcon(KMimeType::findByPath(tc->getStats().torrent_name)->iconName());
 288                         else
 289                                 return KIcon(KMimeType::findByPath(n->file->getPath())->iconName());
 290                 }
 291                 else if (role == Qt::CheckStateRole && index.column() == 0)
 292                 {
 293                         if (tc->getStats().multi_file_torrent)
 294                                 return n->checkState(tc);
 295                 }
 296
 297                 return QVariant();
 298         }
 299
 300         QModelIndex TorrentFileTreeModel::parent(const QModelIndex & index) const
 301         {
 302                 if (!index.isValid())
 303                         return QModelIndex();
 304
 305                 Node* child = static_cast<Node*>(index.internalPointer());
 306                 if (!child)
 307                         return QModelIndex();
 308
 309                 Node* parent = child->parent;
 310                 if (!parent)
 311                         return QModelIndex();
 312                 else
 313                         return createIndex(parent->row(), 0, parent);
 314         }
 315
 316         QModelIndex TorrentFileTreeModel::index(int row,int column,const QModelIndex & parent) const
 317         {
 318                 if (!hasIndex(row, column, parent))
 319                         return QModelIndex();
 320
 321                 Node* p = 0;
 322
 323                 if (!parent.isValid())
 324                         return createIndex(row,column,root);
 325                 else
 326                 {
 327                         p = static_cast<Node*>(parent.internalPointer());
 328
 329                         if (row >= 0 && row < p->children.count())
 330                                 return createIndex(row,column,p->children.at(row));
 331                         else
 332                                 return QModelIndex();
 333                 }
 334         }
 335
 336         Qt::ItemFlags TorrentFileTreeModel::flags(const QModelIndex & index) const
 337         {
 338                 if (!index.isValid())
 339                         return 0;
 340                 else if (tc->getStats().multi_file_torrent)
 341                         return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
 342                 else
 343                         return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 344         }
 345
 346         bool TorrentFileTreeModel::setData(const QModelIndex & index, const QVariant & value, int role)
 347         {
 348                 if (!index.isValid() || role != Qt::CheckStateRole)
 349                         return false;
 350
 351                 Node* n = static_cast<Node*>(index.internalPointer());
 352                 if (!n)
 353                         return false;
 354
 355                 Qt::CheckState newState = static_cast<Qt::CheckState>(value.toInt());
 356                 if (!n->file)
 357                 {
 358                         bool reenable = false;
 359                         if (emit_check_state_change)
 360                         {
 361                                 reenable = true;
 362                                 emit_check_state_change = false;
 363                         }
 364
 365                         for (Uint32 i = 0;i < n->children.count();i++)
 366                         {
 367                                 // recurse down the tree
 368                                 setData(index.child(i,0),value,role);
 369                         }
 370
 371                         if (reenable)
 372                                 emit_check_state_change = true;
 373                 }
 374                 else
 375                 {
 376                         bt::TorrentFileInterface* file = n->file;
 377                         if (newState == Qt::Checked)
 378                         {
 379                                 if (file->getPriority() == ONLY_SEED_PRIORITY)
 380                                         file->setPriority(NORMAL_PRIORITY);
 381                                 else
 382                                         file->setDoNotDownload(false);
 383                         }
 384                         else
 385                         {
 386                                 if (mode == KEEP_FILES)
 387                                         file->setPriority(ONLY_SEED_PRIORITY);
 388                                 else
 389                                         file->setDoNotDownload(true);
 390                         }
 391                         dataChanged(createIndex(index.row(),0),createIndex(index.row(),columnCount(index) - 1));
 392
 393                         QModelIndex parent = index.parent();
 394                         if (parent.isValid())
 395                                 dataChanged(parent,parent); // parent needs to be updated to
 396                 }
 397
 398                 if (emit_check_state_change)
 399                         checkStateChanged();
 400                 return true;
 401         }
 402
 403         void TorrentFileTreeModel::checkAll()
 404         {
 405                 if (tc->getStats().multi_file_torrent)
 406                         setData(index(0,0,QModelIndex()),Qt::Checked,Qt::CheckStateRole);
 407         }
 408
 409         void TorrentFileTreeModel::uncheckAll()
 410         {
 411                 if (tc->getStats().multi_file_torrent)
 412                         setData(index(0,0,QModelIndex()),Qt::Unchecked,Qt::CheckStateRole);
 413         }
 414
 415         void TorrentFileTreeModel::invertCheck()
 416         {
 417                 if (!tc->getStats().multi_file_torrent)
 418                         return;
 419
 420                 invertCheck(index(0,0,QModelIndex()));
 421         }
 422
 423         void TorrentFileTreeModel::invertCheck(const QModelIndex & idx)
 424         {
 425                 Node* n = static_cast<Node*>(idx.internalPointer());
 426                 if (!n)
 427                         return;
 428
 429                 if (!n->file)
 430                 {
 431                         for (Uint32 i = 0;i < n->children.count();i++)
 432                         {
 433                                 // recurse down the tree
 434                                 invertCheck(idx.child(i,0));
 435                         }
 436                 }
 437                 else
 438                 {
 439                         if (n->file->doNotDownload())
 440                                 setData(idx,Qt::Checked,Qt::CheckStateRole);
 441                         else
 442                                 setData(idx,Qt::Unchecked,Qt::CheckStateRole);
 443                 }
 444         }
 445
 446         bt::Uint64 TorrentFileTreeModel::bytesToDownload()
 447         {
 448                 if (tc->getStats().multi_file_torrent)
 449                         return root->bytesToDownload(tc);
 450                 else
 451                         return tc->getStats().total_bytes;
 452         }
 453
 454         QByteArray TorrentFileTreeModel::saveExpandedState(QTreeView* tv)
 455         {
 456                 if (!tc->getStats().multi_file_torrent)
 457                         return QByteArray();
 458
 459                 QByteArray data;
 460                 BEncoder enc(new BEncoderBufferOutput(data));
 461                 enc.beginDict();
 462                 root->saveExpandedState(index(0,0,QModelIndex()),tv,&enc);
 463                 enc.end();
 464                 return data;
 465         }
 466
 467
 468         void TorrentFileTreeModel::loadExpandedState(QTreeView* tv,const QByteArray & state)
 469         {
 470                 if (!tc->getStats().multi_file_torrent)
 471                         return;
 472
 473                 BDecoder dec(state,false,0);
 474                 BNode* n = dec.decode();
 475                 if (n && n->getType() == BNode::DICT)
 476                 {
 477                         n->printDebugInfo();
 478                         root->loadExpandedState(index(0,0,QModelIndex()),tv,n);
 479                 }
 480                 delete n;
 481         }
 482
 483         bt::TorrentFileInterface* TorrentFileTreeModel::indexToFile(const QModelIndex & idx)
 484         {
 485                 if (!idx.isValid())
 486                         return 0;
 487
 488                 Node* n = (Node*)idx.internalPointer();
 489                 if (!n)
 490                         return 0;
 491
 492                 return n->file;
 493         }
 494
 495         QString TorrentFileTreeModel::dirPath(const QModelIndex & idx)
 496         {
 497                 if (!idx.isValid())
 498                         return QString::null;
 499
 500                 Node* n = (Node*)idx.internalPointer();
 501                 if (!n || n == root)
 502                         return QString::null;
 503
 504                 QString ret = n->name;
 505                 do
 506                 {
 507                         n = n->parent;
 508                         if (n && n->parent)
 509                                 ret = n->name + bt::DirSeparator() + ret;
 510                 }while (n);
 511
 512                 return ret;
 513         }
 514
 515         void TorrentFileTreeModel::changePriority(const QModelIndexList & indexes,bt::Priority newpriority)
 516         {
 517                 foreach (QModelIndex idx,indexes)
 518                 {
 519                         Node* n = (Node*)idx.internalPointer();
 520                         if (!n)
 521                                 continue;
 522
 523                         setData(idx,newpriority,Qt::UserRole);
 524                 }
 525         }
 526 }
 527
 528 #include "torrentfiletreemodel.moc"