mirror of
https://github.com/transmission/transmission
synced 2024-12-25 09:13:06 +00:00
4b9626bb83
1. add the option the code to be used under GPLv2 or GPLv3; previously only GPLv2 was allowed 2. add the "proxy option" as described in GPLv3 so we can add future licenses without having to bulk-edit everything again :) 3. remove the awkward "exception for MIT code in Mac client" clause; it was unnecessary and confusing.
672 lines
18 KiB
C++
672 lines
18 KiB
C++
/*
|
|
* This file Copyright (C) 2009-2014 Mnemosyne LLC
|
|
*
|
|
* It may be used under the GNU Public License v2 or v3 licenses,
|
|
* or any future license endorsed by Mnemosyne LLC.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
#include <algorithm> // std::min()
|
|
|
|
#include <QApplication>
|
|
#include <QCheckBox>
|
|
#include <QComboBox>
|
|
#include <QDialogButtonBox>
|
|
#include <QEvent>
|
|
#include <QFileDialog>
|
|
#include <QFileIconProvider>
|
|
#include <QFileInfo>
|
|
#include <QGridLayout>
|
|
#include <QLabel>
|
|
#include <QMessageBox>
|
|
#include <QPushButton>
|
|
#include <QResizeEvent>
|
|
#include <QSet>
|
|
#include <QVBoxLayout>
|
|
#include <QWidget>
|
|
#include <QLineEdit>
|
|
|
|
#include <libtransmission/transmission.h>
|
|
#include <libtransmission/utils.h> /* mime64 */
|
|
#include <libtransmission/variant.h>
|
|
|
|
#include "add-data.h"
|
|
#include "file-tree.h"
|
|
#include "freespace-label.h"
|
|
#include "hig.h"
|
|
#include "options.h"
|
|
#include "prefs.h"
|
|
#include "session.h"
|
|
#include "torrent.h"
|
|
#include "utils.h"
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
FileAdded :: executed (int64_t tag, const QString& result, struct tr_variant * arguments)
|
|
{
|
|
Q_UNUSED (arguments);
|
|
|
|
if (tag != myTag)
|
|
return;
|
|
|
|
if ((result == "success") && !myDelFile.isEmpty ())
|
|
{
|
|
QFile file (myDelFile);
|
|
file.setPermissions (QFile::ReadOwner | QFile::WriteOwner);
|
|
file.remove ();
|
|
}
|
|
|
|
if (result != "success")
|
|
{
|
|
QString text = result;
|
|
|
|
for (int i=0, n=text.size (); i<n; ++i)
|
|
if (!i || text[i-1].isSpace ())
|
|
text[i] = text[i].toUpper ();
|
|
|
|
QMessageBox::warning (QApplication::activeWindow (),
|
|
tr ("Error Adding Torrent"),
|
|
QString ("<p><b>%1</b></p><p>%2</p>").arg (text).arg (myName));
|
|
}
|
|
|
|
deleteLater ();
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
Options :: Options (Session& session, const Prefs& prefs, const AddData& addme, QWidget * parent):
|
|
QDialog (parent, Qt::Dialog),
|
|
mySession (session),
|
|
myAdd (addme),
|
|
myHaveInfo (false),
|
|
mySourceButton (0),
|
|
mySourceEdit (0),
|
|
myDestinationButton (0),
|
|
myDestinationEdit (0),
|
|
myVerifyButton (0),
|
|
myVerifyFile (0),
|
|
myVerifyHash (QCryptographicHash::Sha1),
|
|
myEditTimer (this)
|
|
{
|
|
QFontMetrics fontMetrics (font ());
|
|
QGridLayout * layout = new QGridLayout (this);
|
|
int row = 0;
|
|
|
|
QString title;
|
|
if (myAdd.type == AddData::FILENAME)
|
|
title = tr ("Open Torrent from File");
|
|
else
|
|
title = tr ("Open Torrent from URL or Magnet Link");
|
|
setWindowTitle (title);
|
|
|
|
myEditTimer.setInterval (2000);
|
|
myEditTimer.setSingleShot (true);
|
|
connect (&myEditTimer, SIGNAL (timeout ()), this, SLOT (onDestinationEditedIdle ()));
|
|
|
|
const int iconSize (style ()->pixelMetric (QStyle :: PM_SmallIconSize));
|
|
QIcon fileIcon = style ()->standardIcon (QStyle::SP_FileIcon);
|
|
const QPixmap filePixmap = fileIcon.pixmap (iconSize);
|
|
|
|
QLabel * l = new QLabel (tr ("&Source:"));
|
|
layout->addWidget (l, row, 0, Qt::AlignLeft);
|
|
|
|
QWidget * w;
|
|
QPushButton * p;
|
|
|
|
if (myAdd.type == AddData::FILENAME)
|
|
{
|
|
p = mySourceButton = new QPushButton;
|
|
p->setIcon (filePixmap);
|
|
p->setStyleSheet (QString::fromUtf8 ("text-align: left; padding-left: 5; padding-right: 5"));
|
|
p->installEventFilter (this);
|
|
w = p;
|
|
connect (p, SIGNAL (clicked (bool)), this, SLOT (onFilenameClicked ()));
|
|
}
|
|
else
|
|
{
|
|
QLineEdit * e = mySourceEdit = new QLineEdit;
|
|
e->setText (myAdd.readableName());
|
|
e->setCursorPosition (0);
|
|
e->selectAll ();
|
|
w = e;
|
|
connect (e, SIGNAL(editingFinished()), this, SLOT(onSourceEditingFinished()));
|
|
}
|
|
|
|
const int width = fontMetrics.size (0, QString::fromUtf8 ("This is a pretty long torrent filename indeed.torrent")).width ();
|
|
w->setMinimumWidth (width);
|
|
layout->addWidget (w, row, 1);
|
|
l->setBuddy (w);
|
|
|
|
l = new QLabel (tr ("&Destination folder:"));
|
|
layout->addWidget (l, ++row, 0, Qt::AlignLeft);
|
|
const QString downloadDir (prefs.getString (Prefs::DOWNLOAD_DIR));
|
|
myFreespaceLabel = new FreespaceLabel (mySession, downloadDir, this);
|
|
|
|
if (session.isLocal ())
|
|
{
|
|
const QFileIconProvider iconProvider;
|
|
const QIcon folderIcon = iconProvider.icon (QFileIconProvider::Folder);
|
|
const QPixmap folderPixmap = folderIcon.pixmap (iconSize);
|
|
|
|
myLocalDestination.setPath (downloadDir);
|
|
p = myDestinationButton = new QPushButton;
|
|
p->setIcon (folderPixmap);
|
|
p->setStyleSheet ("text-align: left; padding-left: 5; padding-right: 5");
|
|
p->installEventFilter (this);
|
|
layout->addWidget (p, row, 1);
|
|
l->setBuddy (p);
|
|
connect (p, SIGNAL (clicked (bool)), this, SLOT (onDestinationClicked ()));
|
|
}
|
|
else
|
|
{
|
|
QLineEdit * e = myDestinationEdit = new QLineEdit;
|
|
e->setText (downloadDir);
|
|
layout->addWidget (e, row, 1);
|
|
l->setBuddy (e);
|
|
connect (e, SIGNAL (textEdited (const QString&)), this, SLOT (onDestinationEdited (const QString&)));
|
|
}
|
|
|
|
l = myFreespaceLabel;
|
|
layout->addWidget (l, ++row, 0, 1, 2, Qt::Alignment (Qt::AlignRight | Qt::AlignTop));
|
|
layout->setRowMinimumHeight (row, l->height () + HIG::PAD_SMALL);
|
|
|
|
myTree = new FileTreeView (0, false);
|
|
layout->addWidget (myTree, ++row, 0, 1, 2);
|
|
if (!session.isLocal ())
|
|
myTree->hideColumn (2); // hide the % done, since we've no way of knowing
|
|
|
|
QComboBox * m = new QComboBox;
|
|
m->addItem (tr ("High"), TR_PRI_HIGH);
|
|
m->addItem (tr ("Normal"), TR_PRI_NORMAL);
|
|
m->addItem (tr ("Low"), TR_PRI_LOW);
|
|
m->setCurrentIndex (1); // Normal
|
|
myPriorityCombo = m;
|
|
l = new QLabel (tr ("&Priority:"));
|
|
l->setBuddy (m);
|
|
layout->addWidget (l, ++row, 0, Qt::AlignLeft);
|
|
layout->addWidget (m, row, 1);
|
|
|
|
if (session.isLocal ())
|
|
{
|
|
p = myVerifyButton = new QPushButton (tr ("&Verify Local Data"));
|
|
layout->addWidget (p, ++row, 0, Qt::AlignLeft);
|
|
}
|
|
|
|
QCheckBox * c;
|
|
c = myStartCheck = new QCheckBox (tr ("S&tart when added"));
|
|
c->setChecked (prefs.getBool (Prefs :: START));
|
|
layout->addWidget (c, ++row, 0, 1, 2, Qt::AlignLeft);
|
|
|
|
c = myTrashCheck = new QCheckBox (tr ("Mo&ve .torrent file to the trash"));
|
|
c->setChecked (prefs.getBool (Prefs :: TRASH_ORIGINAL));
|
|
layout->addWidget (c, ++row, 0, 1, 2, Qt::AlignLeft);
|
|
|
|
QDialogButtonBox * b = new QDialogButtonBox (QDialogButtonBox::Open|QDialogButtonBox::Cancel, Qt::Horizontal, this);
|
|
connect (b, SIGNAL (rejected ()), this, SLOT (deleteLater ()));
|
|
connect (b, SIGNAL (accepted ()), this, SLOT (onAccepted ()));
|
|
layout->addWidget (b, ++row, 0, 1, 2);
|
|
|
|
layout->setRowStretch (3, 2);
|
|
layout->setColumnStretch (1, 2);
|
|
layout->setSpacing (HIG :: PAD);
|
|
|
|
connect (myTree, SIGNAL (priorityChanged (const QSet<int>&,int)), this, SLOT (onPriorityChanged (const QSet<int>&,int)));
|
|
connect (myTree, SIGNAL (wantedChanged (const QSet<int>&,bool)), this, SLOT (onWantedChanged (const QSet<int>&,bool)));
|
|
if (session.isLocal ())
|
|
connect (myVerifyButton, SIGNAL (clicked (bool)), this, SLOT (onVerify ()));
|
|
|
|
connect (&myVerifyTimer, SIGNAL (timeout ()), this, SLOT (onTimeout ()));
|
|
|
|
reload ();
|
|
}
|
|
|
|
Options :: ~Options ()
|
|
{
|
|
clearInfo ();
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
Options :: refreshButton (QPushButton * p, const QString& text, int width)
|
|
{
|
|
if (width <= 0)
|
|
width = p->width ();
|
|
width -= 15;
|
|
QFontMetrics fontMetrics (font ());
|
|
QString str = fontMetrics.elidedText (text, Qt::ElideRight, width);
|
|
p->setText (str);
|
|
}
|
|
|
|
void
|
|
Options :: refreshSource (int width)
|
|
{
|
|
QString text = myAdd.readableName ();
|
|
|
|
if (mySourceButton)
|
|
refreshButton (mySourceButton, text, width);
|
|
|
|
if (mySourceEdit)
|
|
mySourceEdit->setText (text);
|
|
}
|
|
|
|
void
|
|
Options :: refreshDestinationButton (int width)
|
|
{
|
|
if (myDestinationButton != 0)
|
|
refreshButton (myDestinationButton, myLocalDestination.absolutePath (), width);
|
|
}
|
|
|
|
|
|
bool
|
|
Options :: eventFilter (QObject * o, QEvent * event)
|
|
{
|
|
if (event->type() == QEvent::Resize)
|
|
{
|
|
if (o == mySourceButton)
|
|
refreshSource (dynamic_cast<QResizeEvent*> (event)->size ().width ());
|
|
|
|
else if (o == myDestinationButton)
|
|
refreshDestinationButton (dynamic_cast<QResizeEvent*> (event)->size ().width ());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
Options :: clearInfo ()
|
|
{
|
|
if (myHaveInfo)
|
|
tr_metainfoFree (&myInfo);
|
|
|
|
myHaveInfo = false;
|
|
myFiles.clear ();
|
|
}
|
|
|
|
void
|
|
Options :: reload ()
|
|
{
|
|
clearInfo ();
|
|
clearVerify ();
|
|
|
|
tr_ctor * ctor = tr_ctorNew (0);
|
|
|
|
switch (myAdd.type)
|
|
{
|
|
case AddData::MAGNET:
|
|
tr_ctorSetMetainfoFromMagnetLink (ctor, myAdd.magnet.toUtf8 ().constData ());
|
|
break;
|
|
|
|
case AddData::FILENAME:
|
|
tr_ctorSetMetainfoFromFile (ctor, myAdd.filename.toUtf8 ().constData ());
|
|
break;
|
|
|
|
case AddData::METAINFO:
|
|
tr_ctorSetMetainfo (ctor, (const quint8*)myAdd.metainfo.constData (), myAdd.metainfo.size ());
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
const int err = tr_torrentParse (ctor, &myInfo);
|
|
myHaveInfo = !err;
|
|
tr_ctorFree (ctor);
|
|
|
|
myTree->clear ();
|
|
myTree->setVisible (myHaveInfo && (myInfo.fileCount>0));
|
|
myFiles.clear ();
|
|
myPriorities.clear ();
|
|
myWanted.clear ();
|
|
|
|
if (myVerifyButton)
|
|
myVerifyButton->setVisible (myHaveInfo && (myInfo.fileCount>0));
|
|
|
|
if (myHaveInfo)
|
|
{
|
|
myPriorities.insert (0, myInfo.fileCount, TR_PRI_NORMAL);
|
|
myWanted.insert (0, myInfo.fileCount, true);
|
|
|
|
for (tr_file_index_t i=0; i<myInfo.fileCount; ++i)
|
|
{
|
|
TrFile file;
|
|
file.index = i;
|
|
file.priority = myPriorities[i];
|
|
file.wanted = myWanted[i];
|
|
file.size = myInfo.files[i].length;
|
|
file.have = 0;
|
|
file.filename = QString::fromUtf8 (myInfo.files[i].name);
|
|
myFiles.append (file);
|
|
}
|
|
}
|
|
|
|
myTree->update (myFiles);
|
|
}
|
|
|
|
void
|
|
Options :: onPriorityChanged (const QSet<int>& fileIndices, int priority)
|
|
{
|
|
foreach (int i, fileIndices)
|
|
myPriorities[i] = priority;
|
|
}
|
|
|
|
void
|
|
Options :: onWantedChanged (const QSet<int>& fileIndices, bool isWanted)
|
|
{
|
|
foreach (int i, fileIndices)
|
|
myWanted[i] = isWanted;
|
|
}
|
|
|
|
void
|
|
Options :: onAccepted ()
|
|
{
|
|
// rpc spec section 3.4 "adding a torrent"
|
|
|
|
const int64_t tag = mySession.getUniqueTag ();
|
|
tr_variant top;
|
|
tr_variantInitDict (&top, 3);
|
|
tr_variantDictAddStr (&top, TR_KEY_method, "torrent-add");
|
|
tr_variantDictAddInt (&top, TR_KEY_tag, tag);
|
|
tr_variant * args (tr_variantDictAddDict (&top, TR_KEY_arguments, 10));
|
|
QString downloadDir;
|
|
|
|
// "download-dir"
|
|
if (myDestinationButton)
|
|
downloadDir = myLocalDestination.absolutePath ();
|
|
else
|
|
downloadDir = myDestinationEdit->text ();
|
|
|
|
tr_variantDictAddStr (args, TR_KEY_download_dir, downloadDir.toUtf8 ().constData ());
|
|
|
|
// "metainfo"
|
|
switch (myAdd.type)
|
|
{
|
|
case AddData::MAGNET:
|
|
tr_variantDictAddStr (args, TR_KEY_filename, myAdd.magnet.toUtf8 ().constData ());
|
|
break;
|
|
|
|
case AddData::URL:
|
|
tr_variantDictAddStr (args, TR_KEY_filename, myAdd.url.toString ().toUtf8 ().constData ());
|
|
break;
|
|
|
|
case AddData::FILENAME:
|
|
case AddData::METAINFO: {
|
|
const QByteArray b64 = myAdd.toBase64 ();
|
|
tr_variantDictAddRaw (args, TR_KEY_metainfo, b64.constData (), b64.size ());
|
|
break;
|
|
}
|
|
|
|
default:
|
|
qWarning ("unhandled AddData.type: %d", myAdd.type);
|
|
}
|
|
|
|
// paused
|
|
tr_variantDictAddBool (args, TR_KEY_paused, !myStartCheck->isChecked ());
|
|
|
|
// priority
|
|
const int index = myPriorityCombo->currentIndex ();
|
|
const int priority = myPriorityCombo->itemData (index).toInt ();
|
|
tr_variantDictAddInt (args, TR_KEY_bandwidthPriority, priority);
|
|
|
|
// files-unwanted
|
|
int count = myWanted.count (false);
|
|
if (count > 0)
|
|
{
|
|
tr_variant * l = tr_variantDictAddList (args, TR_KEY_files_unwanted, count);
|
|
for (int i=0, n=myWanted.size (); i<n; ++i)
|
|
if (myWanted.at (i) == false)
|
|
tr_variantListAddInt (l, i);
|
|
}
|
|
|
|
// priority-low
|
|
count = myPriorities.count (TR_PRI_LOW);
|
|
if (count > 0)
|
|
{
|
|
tr_variant * l = tr_variantDictAddList (args, TR_KEY_priority_low, count);
|
|
for (int i=0, n=myPriorities.size (); i<n; ++i)
|
|
if (myPriorities.at (i) == TR_PRI_LOW)
|
|
tr_variantListAddInt (l, i);
|
|
}
|
|
|
|
// priority-high
|
|
count = myPriorities.count (TR_PRI_HIGH);
|
|
if (count > 0)
|
|
{
|
|
tr_variant * l = tr_variantDictAddList (args, TR_KEY_priority_high, count);
|
|
for (int i=0, n=myPriorities.size (); i<n; ++i)
|
|
if (myPriorities.at (i) == TR_PRI_HIGH)
|
|
tr_variantListAddInt (l, i);
|
|
}
|
|
|
|
// maybe delete the source .torrent
|
|
FileAdded * fileAdded = new FileAdded (tag, myAdd.readableName ());
|
|
if (myTrashCheck->isChecked () && (myAdd.type==AddData::FILENAME))
|
|
fileAdded->setFileToDelete (myAdd.filename);
|
|
connect (&mySession, SIGNAL (executed (int64_t,const QString&, struct tr_variant*)),
|
|
fileAdded, SLOT (executed (int64_t,const QString&, struct tr_variant*)));
|
|
|
|
mySession.exec (&top);
|
|
|
|
tr_variantFree (&top);
|
|
deleteLater ();
|
|
}
|
|
|
|
void
|
|
Options :: onFilenameClicked ()
|
|
{
|
|
if (myAdd.type == AddData::FILENAME)
|
|
{
|
|
QFileDialog * d = new QFileDialog (this,
|
|
tr ("Open Torrent"),
|
|
QFileInfo (myAdd.filename).absolutePath (),
|
|
tr ("Torrent Files (*.torrent);;All Files (*.*)"));
|
|
d->setFileMode (QFileDialog::ExistingFile);
|
|
d->setAttribute (Qt::WA_DeleteOnClose);
|
|
connect (d, SIGNAL (filesSelected (const QStringList&)), this, SLOT (onFilesSelected (const QStringList&)));
|
|
d->show ();
|
|
}
|
|
}
|
|
|
|
void
|
|
Options :: onFilesSelected (const QStringList& files)
|
|
{
|
|
if (files.size () == 1)
|
|
{
|
|
myAdd.set (files.at (0));
|
|
refreshSource ();
|
|
reload ();
|
|
}
|
|
}
|
|
|
|
void
|
|
Options :: onSourceEditingFinished ()
|
|
{
|
|
myAdd.set (mySourceEdit->text());
|
|
}
|
|
|
|
void
|
|
Options :: onDestinationClicked ()
|
|
{
|
|
QFileDialog * d = new QFileDialog (this, tr ("Select Destination"), myLocalDestination.absolutePath ());
|
|
d->setFileMode (QFileDialog::Directory);
|
|
d->setAttribute (Qt::WA_DeleteOnClose);
|
|
connect (d, SIGNAL (filesSelected (const QStringList&)), this, SLOT (onDestinationsSelected (const QStringList&)));
|
|
d->show ();
|
|
}
|
|
|
|
void
|
|
Options :: onDestinationsSelected (const QStringList& destinations)
|
|
{
|
|
if (destinations.size () == 1)
|
|
{
|
|
QString destination = Utils::removeTrailingDirSeparator (destinations.first ());
|
|
myFreespaceLabel->setPath (destination);
|
|
myLocalDestination.setPath (destination);
|
|
refreshDestinationButton ();
|
|
}
|
|
}
|
|
|
|
void
|
|
Options :: onDestinationEdited (const QString& text)
|
|
{
|
|
Q_UNUSED (text);
|
|
|
|
myEditTimer.start ();
|
|
}
|
|
|
|
void
|
|
Options :: onDestinationEditedIdle ()
|
|
{
|
|
myFreespaceLabel->setPath (myDestinationEdit->text());
|
|
}
|
|
|
|
/***
|
|
****
|
|
**** VERIFY
|
|
****
|
|
***/
|
|
|
|
void
|
|
Options :: clearVerify ()
|
|
{
|
|
myVerifyHash.reset ();
|
|
myVerifyFile.close ();
|
|
myVerifyFilePos = 0;
|
|
myVerifyFlags.clear ();
|
|
myVerifyFileIndex = 0;
|
|
myVerifyPieceIndex = 0;
|
|
myVerifyPiecePos = 0;
|
|
myVerifyTimer.stop ();
|
|
|
|
for (int i=0, n=myFiles.size (); i<n; ++i)
|
|
myFiles[i].have = 0;
|
|
|
|
myTree->update (myFiles);
|
|
}
|
|
|
|
void
|
|
Options :: onVerify ()
|
|
{
|
|
clearVerify ();
|
|
myVerifyFlags.insert (0, myInfo.pieceCount, false);
|
|
myVerifyTimer.setSingleShot (false);
|
|
myVerifyTimer.start (0);
|
|
}
|
|
|
|
namespace
|
|
{
|
|
uint64_t getPieceSize (const tr_info * info, tr_piece_index_t pieceIndex)
|
|
{
|
|
if (pieceIndex != info->pieceCount - 1)
|
|
return info->pieceSize;
|
|
return info->totalSize % info->pieceSize;
|
|
}
|
|
}
|
|
|
|
void
|
|
Options :: onTimeout ()
|
|
{
|
|
if (myFiles.isEmpty())
|
|
{
|
|
myVerifyTimer.stop ();
|
|
return;
|
|
}
|
|
|
|
const tr_file * file = &myInfo.files[myVerifyFileIndex];
|
|
|
|
if (!myVerifyFilePos && !myVerifyFile.isOpen ())
|
|
{
|
|
const QFileInfo fileInfo (myLocalDestination, QString::fromUtf8 (file->name));
|
|
myVerifyFile.setFileName (fileInfo.absoluteFilePath ());
|
|
myVerifyFile.open (QIODevice::ReadOnly);
|
|
}
|
|
|
|
int64_t leftInPiece = getPieceSize (&myInfo, myVerifyPieceIndex) - myVerifyPiecePos;
|
|
int64_t leftInFile = file->length - myVerifyFilePos;
|
|
int64_t bytesThisPass = std::min (leftInFile, leftInPiece);
|
|
bytesThisPass = std::min (bytesThisPass, (int64_t)sizeof (myVerifyBuf));
|
|
|
|
if (myVerifyFile.isOpen () && myVerifyFile.seek (myVerifyFilePos))
|
|
{
|
|
int64_t numRead = myVerifyFile.read (myVerifyBuf, bytesThisPass);
|
|
if (numRead == bytesThisPass)
|
|
myVerifyHash.addData (myVerifyBuf, numRead);
|
|
}
|
|
|
|
leftInPiece -= bytesThisPass;
|
|
leftInFile -= bytesThisPass;
|
|
myVerifyPiecePos += bytesThisPass;
|
|
myVerifyFilePos += bytesThisPass;
|
|
|
|
myVerifyBins[myVerifyFileIndex] += bytesThisPass;
|
|
|
|
if (leftInPiece == 0)
|
|
{
|
|
const QByteArray result (myVerifyHash.result ());
|
|
const bool matches = !memcmp (result.constData (),
|
|
myInfo.pieces[myVerifyPieceIndex].hash,
|
|
SHA_DIGEST_LENGTH);
|
|
myVerifyFlags[myVerifyPieceIndex] = matches;
|
|
myVerifyPiecePos = 0;
|
|
++myVerifyPieceIndex;
|
|
myVerifyHash.reset ();
|
|
|
|
FileList changedFiles;
|
|
if (matches)
|
|
{
|
|
mybins_t::const_iterator i;
|
|
for (i=myVerifyBins.begin (); i!=myVerifyBins.end (); ++i)
|
|
{
|
|
TrFile& f (myFiles[i.key ()]);
|
|
f.have += i.value ();
|
|
changedFiles.append (f);
|
|
}
|
|
}
|
|
myTree->update (changedFiles);
|
|
myVerifyBins.clear ();
|
|
}
|
|
|
|
if (leftInFile == 0)
|
|
{
|
|
myVerifyFile.close ();
|
|
++myVerifyFileIndex;
|
|
myVerifyFilePos = 0;
|
|
}
|
|
|
|
bool done = myVerifyPieceIndex >= myInfo.pieceCount;
|
|
if (done)
|
|
{
|
|
uint64_t have = 0;
|
|
foreach (const TrFile& f, myFiles)
|
|
have += f.have;
|
|
|
|
if (!have) // everything failed
|
|
{
|
|
// did the user accidentally specify the child directory instead of the parent?
|
|
const QStringList tokens = QString (file->name).split ('/');
|
|
if (!tokens.empty () && myLocalDestination.dirName ()==tokens.at (0))
|
|
{
|
|
// move up one directory and try again
|
|
myLocalDestination.cdUp ();
|
|
refreshDestinationButton (-1);
|
|
onVerify ();
|
|
done = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (done)
|
|
myVerifyTimer.stop ();
|
|
}
|