1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the examples of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtGui>

    43 

    44 #include "addtorrentdialog.h"

    45 #include "mainwindow.h"

    46 #include "ratecontroller.h"

    47 #include "torrentclient.h"

    48 

    49 // TorrentView extends QTreeWidget to allow drag and drop.

    50 class TorrentView : public QTreeWidget

    51 {

    52     Q_OBJECT

    53 public:

    54     TorrentView(QWidget *parent = 0);

    55 

    56 signals:

    57     void fileDropped(const QString &fileName);

    58 

    59 protected:

    60     void dragMoveEvent(QDragMoveEvent *event);

    61     void dropEvent(QDropEvent *event);

    62 };

    63 

    64 // TorrentViewDelegate is used to draw the progress bars.

    65 class TorrentViewDelegate : public QItemDelegate

    66 {

    67     Q_OBJECT

    68 public:

    69     inline TorrentViewDelegate(MainWindow *mainWindow) : QItemDelegate(mainWindow) {}

    70 

    71     inline void paint(QPainter *painter, const QStyleOptionViewItem &option,

    72                       const QModelIndex &index ) const

    73     {

    74         if (index.column() != 2) {

    75             QItemDelegate::paint(painter, option, index);

    76             return;

    77         }

    78 

    79         // Set up a QStyleOptionProgressBar to precisely mimic the

    80         // environment of a progress bar.

    81         QStyleOptionProgressBar progressBarOption;

    82         progressBarOption.state = QStyle::State_Enabled;

    83         progressBarOption.direction = QApplication::layoutDirection();

    84         progressBarOption.rect = option.rect;

    85         progressBarOption.fontMetrics = QApplication::fontMetrics();

    86         progressBarOption.minimum = 0;

    87         progressBarOption.maximum = 100;

    88         progressBarOption.textAlignment = Qt::AlignCenter;

    89         progressBarOption.textVisible = true;

    90 

    91         // Set the progress and text values of the style option.

    92         int progress = qobject_cast<MainWindow *>(parent())->clientForRow(index.row())->progress();

    93         progressBarOption.progress = progress < 0 ? 0 : progress;

    94         progressBarOption.text = QString().sprintf("%d%%", progressBarOption.progress);

    95 

    96         // Draw the progress bar onto the view.

    97         QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBarOption, painter);

    98     }

    99 };

   100 

   101 MainWindow::MainWindow(QWidget *parent)

   102     : QMainWindow(parent), quitDialog(0), saveChanges(false)

   103 {

   104     // Initialize some static strings

   105     QStringList headers;

   106     headers << tr("Torrent") << tr("Peers/Seeds") << tr("Progress")

   107             << tr("Down rate") << tr("Up rate") << tr("Status");

   108 

   109     // Main torrent list

   110     torrentView = new TorrentView(this);

   111     torrentView->setItemDelegate(new TorrentViewDelegate(this));

   112     torrentView->setHeaderLabels(headers);

   113     torrentView->setSelectionBehavior(QAbstractItemView::SelectRows);

   114     torrentView->setAlternatingRowColors(true);

   115     torrentView->setRootIsDecorated(false);

   116     setCentralWidget(torrentView);

   117 

   118     // Set header resize modes and initial section sizes

   119     QFontMetrics fm = fontMetrics();

   120     QHeaderView *header = torrentView->header();

   121     header->resizeSection(0, fm.width("typical-name-for-a-torrent.torrent"));

   122     header->resizeSection(1, fm.width(headers.at(1) + "  "));

   123     header->resizeSection(2, fm.width(headers.at(2) + "  "));

   124     header->resizeSection(3, qMax(fm.width(headers.at(3) + "  "), fm.width(" 1234.0 KB/s ")));

   125     header->resizeSection(4, qMax(fm.width(headers.at(4) + "  "), fm.width(" 1234.0 KB/s ")));

   126     header->resizeSection(5, qMax(fm.width(headers.at(5) + "  "), fm.width(tr("Downloading") + "  ")));

   127 

   128     // Create common actions

   129     QAction *newTorrentAction = new QAction(QIcon(":/icons/bottom.png"), tr("Add &new torrent"), this);

   130     pauseTorrentAction = new QAction(QIcon(":/icons/player_pause.png"), tr("&Pause torrent"), this);

   131     removeTorrentAction = new QAction(QIcon(":/icons/player_stop.png"), tr("&Remove torrent"), this);

   132     

   133     // File menu

   134     QMenu *fileMenu = menuBar()->addMenu(tr("&File"));

   135     fileMenu->addAction(newTorrentAction);

   136     fileMenu->addAction(pauseTorrentAction);

   137     fileMenu->addAction(removeTorrentAction);

   138     fileMenu->addSeparator();

   139     fileMenu->addAction(QIcon(":/icons/exit.png"), tr("E&xit"), this, SLOT(close()));

   140 

   141     // Help menu

   142     QMenu *helpMenu = menuBar()->addMenu(tr("&Help"));

   143     helpMenu->addAction(tr("&About"), this, SLOT(about()));

   144     helpMenu->addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));

   145 

   146     // Top toolbar

   147     QToolBar *topBar = new QToolBar(tr("Tools"));

   148     addToolBar(Qt::TopToolBarArea, topBar);

   149     topBar->setMovable(false);

   150     topBar->addAction(newTorrentAction);

   151     topBar->addAction(removeTorrentAction);

   152     topBar->addAction(pauseTorrentAction);

   153     topBar->addSeparator();

   154     downActionTool = topBar->addAction(QIcon(tr(":/icons/1downarrow.png")), tr("Move down"));

   155     upActionTool = topBar->addAction(QIcon(tr(":/icons/1uparrow.png")), tr("Move up"));

   156 

   157     // Bottom toolbar

   158     QToolBar *bottomBar = new QToolBar(tr("Rate control"));

   159     addToolBar(Qt::BottomToolBarArea, bottomBar);

   160     bottomBar->setMovable(false);

   161     downloadLimitSlider = new QSlider(Qt::Horizontal);

   162     downloadLimitSlider->setRange(0, 1000);

   163     bottomBar->addWidget(new QLabel(tr("Max download:")));

   164     bottomBar->addWidget(downloadLimitSlider);

   165     bottomBar->addWidget((downloadLimitLabel = new QLabel(tr("0 KB/s"))));

   166     downloadLimitLabel->setFixedSize(QSize(fm.width(tr("99999 KB/s")), fm.lineSpacing()));

   167     bottomBar->addSeparator();

   168     uploadLimitSlider = new QSlider(Qt::Horizontal);

   169     uploadLimitSlider->setRange(0, 1000);

   170     bottomBar->addWidget(new QLabel(tr("Max upload:")));

   171     bottomBar->addWidget(uploadLimitSlider);

   172     bottomBar->addWidget((uploadLimitLabel = new QLabel(tr("0 KB/s"))));

   173     uploadLimitLabel->setFixedSize(QSize(fm.width(tr("99999 KB/s")), fm.lineSpacing()));

   174 

   175     // Set up connections

   176     connect(torrentView, SIGNAL(itemSelectionChanged()),

   177             this, SLOT(setActionsEnabled()));

   178     connect(torrentView, SIGNAL(fileDropped(const QString &)),

   179             this, SLOT(acceptFileDrop(const QString &)));

   180     connect(uploadLimitSlider, SIGNAL(valueChanged(int)),

   181             this, SLOT(setUploadLimit(int)));

   182     connect(downloadLimitSlider, SIGNAL(valueChanged(int)),

   183             this, SLOT(setDownloadLimit(int)));

   184     connect(newTorrentAction, SIGNAL(triggered()),

   185             this, SLOT(addTorrent()));

   186     connect(pauseTorrentAction, SIGNAL(triggered()),

   187             this, SLOT(pauseTorrent()));

   188     connect(removeTorrentAction, SIGNAL(triggered()),

   189             this, SLOT(removeTorrent()));

   190     connect(upActionTool, SIGNAL(triggered(bool)),

   191             this, SLOT(moveTorrentUp()));

   192     connect(downActionTool, SIGNAL(triggered(bool)),

   193             this, SLOT(moveTorrentDown()));

   194 

   195     // Load settings and start

   196     setWindowTitle(tr("Torrent Client"));

   197     setActionsEnabled();

   198     QMetaObject::invokeMethod(this, "loadSettings", Qt::QueuedConnection);

   199 }

   200 

   201 QSize MainWindow::sizeHint() const

   202 {

   203     const QHeaderView *header = torrentView->header();

   204 

   205     // Add up the sizes of all header sections. The last section is

   206     // stretched, so its size is relative to the size of the width;

   207     // instead of counting it, we count the size of its largest value.

   208     int width = fontMetrics().width(tr("Downloading") + "  ");

   209     for (int i = 0; i < header->count() - 1; ++i)

   210         width += header->sectionSize(i);

   211 

   212     return QSize(width, QMainWindow::sizeHint().height())

   213         .expandedTo(QApplication::globalStrut());

   214 }

   215 

   216 const TorrentClient *MainWindow::clientForRow(int row) const

   217 {

   218     // Return the client at the given row.

   219     return jobs.at(row).client;

   220 }

   221 

   222 int MainWindow::rowOfClient(TorrentClient *client) const

   223 {

   224     // Return the row that displays this client's status, or -1 if the

   225     // client is not known.

   226     int row = 0;

   227     foreach (Job job, jobs) {

   228         if (job.client == client)

   229             return row;

   230         ++row;

   231     }

   232     return -1;

   233 }

   234 

   235 void MainWindow::loadSettings()

   236 {

   237     // Load base settings (last working directory, upload/download limits).

   238     QSettings settings("Trolltech", "Torrent");

   239     lastDirectory = settings.value("LastDirectory").toString();

   240     if (lastDirectory.isEmpty())

   241         lastDirectory = QDir::currentPath();

   242     int up = settings.value("UploadLimit").toInt();

   243     int down = settings.value("DownloadLimit").toInt();

   244     uploadLimitSlider->setValue(up ? up : 170);

   245     downloadLimitSlider->setValue(down ? down : 550);

   246 

   247     // Resume all previous downloads.

   248     int size = settings.beginReadArray("Torrents");

   249     for (int i = 0; i < size; ++i) {

   250         settings.setArrayIndex(i);

   251         QByteArray resumeState = settings.value("resumeState").toByteArray();

   252         QString fileName = settings.value("sourceFileName").toString();

   253         QString dest = settings.value("destinationFolder").toString();

   254 

   255         if (addTorrent(fileName, dest, resumeState)) {

   256             TorrentClient *client = jobs.last().client;

   257             client->setDownloadedBytes(settings.value("downloadedBytes").toLongLong());

   258             client->setUploadedBytes(settings.value("uploadedBytes").toLongLong());

   259         }

   260     }

   261 }

   262 

   263 bool MainWindow::addTorrent()

   264 {

   265     // Show the file dialog, let the user select what torrent to start downloading.

   266     QString fileName = QFileDialog::getOpenFileName(this, tr("Choose a torrent file"),

   267                                                     lastDirectory,

   268                                                     tr("Torrents (*.torrent);;"

   269                                                        " All files (*.*)"));

   270     if (fileName.isEmpty())

   271         return false;

   272     lastDirectory = QFileInfo(fileName).absolutePath();

   273 

   274     // Show the "Add Torrent" dialog.

   275     AddTorrentDialog *addTorrentDialog = new AddTorrentDialog(this);

   276     addTorrentDialog->setTorrent(fileName);

   277     addTorrentDialog->deleteLater();

   278     if (!addTorrentDialog->exec())

   279         return false;

   280 

   281     // Add the torrent to our list of downloads

   282     addTorrent(fileName, addTorrentDialog->destinationFolder());

   283     if (!saveChanges) {

   284         saveChanges = true;

   285         QTimer::singleShot(1000, this, SLOT(saveSettings()));

   286     }

   287     return true;

   288 }

   289 

   290 void MainWindow::removeTorrent()

   291 {

   292     // Find the row of the current item, and find the torrent client

   293     // for that row.

   294     int row = torrentView->indexOfTopLevelItem(torrentView->currentItem());

   295     TorrentClient *client = jobs.at(row).client;

   296 

   297     // Stop the client.

   298     client->disconnect();

   299     connect(client, SIGNAL(stopped()), this, SLOT(torrentStopped()));

   300     client->stop();

   301 

   302     // Remove the row from the view.

   303     delete torrentView->takeTopLevelItem(row);

   304     jobs.removeAt(row);

   305     setActionsEnabled();

   306 

   307     saveChanges = true;

   308     saveSettings();

   309 }

   310 

   311 void MainWindow::torrentStopped()

   312 {

   313     // Schedule the client for deletion.

   314     TorrentClient *client = qobject_cast<TorrentClient *>(sender());

   315     client->deleteLater();

   316 

   317     // If the quit dialog is shown, update its progress.

   318     if (quitDialog) {

   319         if (++jobsStopped == jobsToStop)

   320             quitDialog->close();

   321     }

   322 }

   323 

   324 void MainWindow::torrentError(TorrentClient::Error)

   325 {

   326     // Delete the client.

   327     TorrentClient *client = qobject_cast<TorrentClient *>(sender());

   328     int row = rowOfClient(client);

   329     QString fileName = jobs.at(row).torrentFileName;

   330     jobs.removeAt(row);

   331 

   332     // Display the warning.

   333     QMessageBox::warning(this, tr("Error"),

   334                          tr("An error occurred while downloading %0: %1")

   335                          .arg(fileName)

   336                          .arg(client->errorString()));

   337 

   338     delete torrentView->takeTopLevelItem(row);

   339     client->deleteLater();

   340 }

   341 

   342 bool MainWindow::addTorrent(const QString &fileName, const QString &destinationFolder,

   343                             const QByteArray &resumeState)

   344 {

   345     // Check if the torrent is already being downloaded.

   346     foreach (Job job, jobs) {

   347         if (job.torrentFileName == fileName && job.destinationDirectory == destinationFolder) {

   348             QMessageBox::warning(this, tr("Already downloading"),

   349                                  tr("The torrent file %1 is "

   350                                     "already being downloaded.").arg(fileName));

   351             return false;

   352         }

   353     }

   354 

   355     // Create a new torrent client and attempt to parse the torrent data.

   356     TorrentClient *client = new TorrentClient(this);

   357     if (!client->setTorrent(fileName)) {

   358         QMessageBox::warning(this, tr("Error"),

   359                              tr("The torrent file %1 cannot not be opened/resumed.").arg(fileName));

   360         delete client;

   361         return false;

   362     }

   363     client->setDestinationFolder(destinationFolder);

   364     client->setDumpedState(resumeState);

   365 

   366     // Setup the client connections.

   367     connect(client, SIGNAL(stateChanged(TorrentClient::State)), this, SLOT(updateState(TorrentClient::State)));

   368     connect(client, SIGNAL(peerInfoUpdated()), this, SLOT(updatePeerInfo()));

   369     connect(client, SIGNAL(progressUpdated(int)), this, SLOT(updateProgress(int)));

   370     connect(client, SIGNAL(downloadRateUpdated(int)), this, SLOT(updateDownloadRate(int)));

   371     connect(client, SIGNAL(uploadRateUpdated(int)), this, SLOT(updateUploadRate(int)));

   372     connect(client, SIGNAL(stopped()), this, SLOT(torrentStopped()));

   373     connect(client, SIGNAL(error(TorrentClient::Error)), this, SLOT(torrentError(TorrentClient::Error)));

   374 

   375     // Add the client to the list of downloading jobs.

   376     Job job;

   377     job.client = client;

   378     job.torrentFileName = fileName;

   379     job.destinationDirectory = destinationFolder;

   380     jobs << job;

   381 

   382     // Create and add a row in the torrent view for this download.

   383     QTreeWidgetItem *item = new QTreeWidgetItem(torrentView);

   384 

   385     QString baseFileName = QFileInfo(fileName).fileName();

   386     if (baseFileName.toLower().endsWith(".torrent"))

   387         baseFileName.remove(baseFileName.size() - 8);

   388 

   389     item->setText(0, baseFileName);

   390     item->setToolTip(0, tr("Torrent: %1<br>Destination: %2")

   391                      .arg(baseFileName).arg(destinationFolder));

   392     item->setText(1, tr("0/0"));

   393     item->setText(2, "0");

   394     item->setText(3, "0.0 KB/s");

   395     item->setText(4, "0.0 KB/s");

   396     item->setText(5, tr("Idle"));

   397     item->setFlags(item->flags() & ~Qt::ItemIsEditable);

   398     item->setTextAlignment(1, Qt::AlignHCenter);

   399 

   400     if (!saveChanges) {

   401         saveChanges = true;

   402         QTimer::singleShot(5000, this, SLOT(saveSettings()));

   403     }

   404     client->start();

   405     return true;

   406 }

   407 

   408 void MainWindow::saveSettings()

   409 {

   410     if (!saveChanges)

   411       return;

   412     saveChanges = false;

   413 

   414     // Prepare and reset the settings

   415     QSettings settings("Trolltech", "Torrent");

   416     settings.clear();

   417 

   418     settings.setValue("LastDirectory", lastDirectory);

   419     settings.setValue("UploadLimit", uploadLimitSlider->value());

   420     settings.setValue("DownloadLimit", downloadLimitSlider->value());

   421 

   422     // Store data on all known torrents

   423     settings.beginWriteArray("Torrents");

   424     for (int i = 0; i < jobs.size(); ++i) {

   425         settings.setArrayIndex(i);

   426         settings.setValue("sourceFileName", jobs.at(i).torrentFileName);

   427         settings.setValue("destinationFolder", jobs.at(i).destinationDirectory);

   428         settings.setValue("uploadedBytes", jobs.at(i).client->uploadedBytes());

   429         settings.setValue("downloadedBytes", jobs.at(i).client->downloadedBytes());

   430         settings.setValue("resumeState", jobs.at(i).client->dumpedState());

   431     }

   432     settings.endArray();

   433     settings.sync();

   434 }

   435 

   436 void MainWindow::updateState(TorrentClient::State)

   437 {

   438     // Update the state string whenever the client's state changes.

   439     TorrentClient *client = qobject_cast<TorrentClient *>(sender());

   440     int row = rowOfClient(client);

   441     QTreeWidgetItem *item = torrentView->topLevelItem(row);

   442     if (item) {

   443         item->setToolTip(0, tr("Torrent: %1<br>Destination: %2<br>State: %3")

   444                          .arg(jobs.at(row).torrentFileName)

   445                          .arg(jobs.at(row).destinationDirectory)

   446                          .arg(client->stateString()));

   447 

   448         item->setText(5, client->stateString());

   449     }

   450     setActionsEnabled();

   451 }

   452 

   453 void MainWindow::updatePeerInfo()

   454 {

   455     // Update the number of connected, visited, seed and leecher peers.

   456     TorrentClient *client = qobject_cast<TorrentClient *>(sender());

   457     int row = rowOfClient(client);

   458 

   459     QTreeWidgetItem *item = torrentView->topLevelItem(row);

   460     item->setText(1, tr("%1/%2").arg(client->connectedPeerCount())

   461                   .arg(client->seedCount()));

   462 }

   463 

   464 void MainWindow::updateProgress(int percent)

   465 {

   466     TorrentClient *client = qobject_cast<TorrentClient *>(sender());

   467     int row = rowOfClient(client);

   468 

   469     // Update the progressbar.

   470     QTreeWidgetItem *item = torrentView->topLevelItem(row);

   471     if (item)

   472         item->setText(2, QString::number(percent));

   473 }

   474 

   475 void MainWindow::setActionsEnabled()

   476 {

   477     // Find the view item and client for the current row, and update

   478     // the states of the actions.

   479     QTreeWidgetItem *item = 0;

   480     if (!torrentView->selectedItems().isEmpty())

   481         item = torrentView->selectedItems().first();

   482     TorrentClient *client = item ? jobs.at(torrentView->indexOfTopLevelItem(item)).client : 0;

   483     bool pauseEnabled = client && ((client->state() == TorrentClient::Paused)

   484                                        ||  (client->state() > TorrentClient::Preparing));

   485 

   486     removeTorrentAction->setEnabled(item != 0);

   487     pauseTorrentAction->setEnabled(item != 0 && pauseEnabled);

   488 

   489     if (client && client->state() == TorrentClient::Paused) {

   490         pauseTorrentAction->setIcon(QIcon(":/icons/player_play.png"));

   491         pauseTorrentAction->setText(tr("Resume torrent"));

   492     } else {

   493         pauseTorrentAction->setIcon(QIcon(":/icons/player_pause.png"));

   494         pauseTorrentAction->setText(tr("Pause torrent"));

   495     }

   496 

   497     int row = torrentView->indexOfTopLevelItem(item);

   498     upActionTool->setEnabled(item && row != 0);

   499     downActionTool->setEnabled(item && row != jobs.size() - 1);

   500 }

   501 

   502 void MainWindow::updateDownloadRate(int bytesPerSecond)

   503 {

   504     // Update the download rate.

   505     TorrentClient *client = qobject_cast<TorrentClient *>(sender());

   506     int row = rowOfClient(client);

   507     QString num;

   508     num.sprintf("%.1f KB/s", bytesPerSecond / 1024.0);

   509     torrentView->topLevelItem(row)->setText(3, num);

   510 

   511     if (!saveChanges) {

   512         saveChanges = true;

   513         QTimer::singleShot(5000, this, SLOT(saveSettings()));

   514     }

   515 }

   516 

   517 void MainWindow::updateUploadRate(int bytesPerSecond)

   518 {

   519     // Update the upload rate.

   520     TorrentClient *client = qobject_cast<TorrentClient *>(sender());

   521     int row = rowOfClient(client);

   522     QString num;

   523     num.sprintf("%.1f KB/s", bytesPerSecond / 1024.0);

   524     torrentView->topLevelItem(row)->setText(4, num);

   525 

   526     if (!saveChanges) {

   527         saveChanges = true;

   528         QTimer::singleShot(5000, this, SLOT(saveSettings()));

   529     }

   530 }

   531 

   532 void MainWindow::pauseTorrent()

   533 {

   534     // Pause or unpause the current torrent.

   535     int row = torrentView->indexOfTopLevelItem(torrentView->currentItem());

   536     TorrentClient *client = jobs.at(row).client;

   537     client->setPaused(client->state() != TorrentClient::Paused);

   538     setActionsEnabled();

   539 }

   540 

   541 void MainWindow::moveTorrentUp()

   542 {

   543     QTreeWidgetItem *item = torrentView->currentItem();

   544     int row = torrentView->indexOfTopLevelItem(item);

   545     if (row == 0)

   546         return;

   547 

   548     Job tmp = jobs.at(row - 1);

   549     jobs[row - 1] = jobs[row];

   550     jobs[row] = tmp;

   551 

   552     QTreeWidgetItem *itemAbove = torrentView->takeTopLevelItem(row - 1);

   553     torrentView->insertTopLevelItem(row, itemAbove);

   554     setActionsEnabled();

   555 }

   556 

   557 void MainWindow::moveTorrentDown()

   558 {

   559     QTreeWidgetItem *item = torrentView->currentItem();

   560     int row = torrentView->indexOfTopLevelItem(item);

   561     if (row == jobs.size() - 1)

   562         return;

   563 

   564     Job tmp = jobs.at(row + 1);

   565     jobs[row + 1] = jobs[row];

   566     jobs[row] = tmp;

   567 

   568     QTreeWidgetItem *itemAbove = torrentView->takeTopLevelItem(row + 1);

   569     torrentView->insertTopLevelItem(row, itemAbove);

   570     setActionsEnabled();

   571 }

   572 

   573 static int rateFromValue(int value)

   574 {

   575     int rate = 0;

   576     if (value >= 0 && value < 250) {

   577         rate = 1 + int(value * 0.124);

   578     } else if (value < 500) {

   579         rate = 32 + int((value - 250) * 0.384);

   580     } else if (value < 750) {

   581         rate = 128 + int((value - 500) * 1.536);

   582     } else {

   583         rate = 512 + int((value - 750) * 6.1445);

   584     }

   585     return rate;

   586 }

   587 

   588 void MainWindow::setUploadLimit(int value)

   589 {

   590     int rate = rateFromValue(value);

   591     uploadLimitLabel->setText(tr("%1 KB/s").arg(QString().sprintf("%4d", rate)));

   592     RateController::instance()->setUploadLimit(rate * 1024);

   593 }

   594 

   595 void MainWindow::setDownloadLimit(int value)

   596 {

   597     int rate = rateFromValue(value);

   598     downloadLimitLabel->setText(tr("%1 KB/s").arg(QString().sprintf("%4d", rate)));

   599     RateController::instance()->setDownloadLimit(rate * 1024);

   600 }

   601 

   602 void MainWindow::about()

   603 {

   604     QLabel *icon = new QLabel;

   605     icon->setPixmap(QPixmap(":/icons/peertopeer.png"));

   606 

   607     QLabel *text = new QLabel;

   608     text->setWordWrap(true);

   609     text->setText("<p>The <b>Torrent Client</b> example demonstrates how to"

   610                   " write a complete peer-to-peer file sharing"

   611                   " application using Qt's network and thread classes.</p>"

   612                   "<p>This feature complete client implementation of"

   613                   " the BitTorrent protocol can efficiently"

   614                   " maintain several hundred network connections"

   615                   " simultaneously.</p>");

   616 

   617     QPushButton *quitButton = new QPushButton("OK");

   618 

   619     QHBoxLayout *topLayout = new QHBoxLayout;

   620     topLayout->setMargin(10);

   621     topLayout->setSpacing(10);

   622     topLayout->addWidget(icon);

   623     topLayout->addWidget(text);

   624 

   625     QHBoxLayout *bottomLayout = new QHBoxLayout;

   626     bottomLayout->addStretch();

   627     bottomLayout->addWidget(quitButton);

   628     bottomLayout->addStretch();

   629 

   630     QVBoxLayout *mainLayout = new QVBoxLayout;

   631     mainLayout->addLayout(topLayout);

   632     mainLayout->addLayout(bottomLayout);

   633 

   634     QDialog about(this);

   635     about.setModal(true);

   636     about.setWindowTitle(tr("About Torrent Client"));

   637     about.setLayout(mainLayout);

   638 

   639     connect(quitButton, SIGNAL(clicked()), &about, SLOT(close()));

   640 

   641     about.exec();

   642 }

   643 

   644 void MainWindow::acceptFileDrop(const QString &fileName)

   645 {

   646     // Create and show the "Add Torrent" dialog.

   647     AddTorrentDialog *addTorrentDialog = new AddTorrentDialog;

   648     lastDirectory = QFileInfo(fileName).absolutePath();

   649     addTorrentDialog->setTorrent(fileName);

   650     addTorrentDialog->deleteLater();

   651     if (!addTorrentDialog->exec())

   652         return;

   653 

   654     // Add the torrent to our list of downloads.

   655     addTorrent(fileName, addTorrentDialog->destinationFolder());

   656     saveSettings();

   657 }

   658 

   659 void MainWindow::closeEvent(QCloseEvent *)

   660 {

   661     if (jobs.isEmpty())

   662         return;

   663 

   664     // Save upload / download numbers.

   665     saveSettings();

   666     saveChanges = false;

   667 

   668     quitDialog = new QProgressDialog(tr("Disconnecting from trackers"), tr("Abort"), 0, jobsToStop, this);

   669 

   670     // Stop all clients, remove the rows from the view and wait for

   671     // them to signal that they have stopped.

   672     jobsToStop = 0;

   673     jobsStopped = 0;

   674     foreach (Job job, jobs) {

   675         ++jobsToStop;

   676         TorrentClient *client = job.client;

   677         client->disconnect();

   678         connect(client, SIGNAL(stopped()), this, SLOT(torrentStopped()));

   679         client->stop();

   680         delete torrentView->takeTopLevelItem(0);

   681     }

   682 

   683     if (jobsToStop > jobsStopped)

   684         quitDialog->exec();

   685     quitDialog->deleteLater();

   686     quitDialog = 0;

   687 }

   688 

   689 TorrentView::TorrentView(QWidget *parent)

   690     : QTreeWidget(parent)

   691 {

   692     setAcceptDrops(true);

   693 }

   694 

   695 void TorrentView::dragMoveEvent(QDragMoveEvent *event)

   696 {

   697     // Accept file actions with a '.torrent' extension.

   698     QUrl url(event->mimeData()->text());

   699     if (url.isValid() && url.scheme().toLower() == "file"

   700             && url.path().toLower().endsWith(".torrent"))

   701         event->acceptProposedAction();

   702 }

   703 

   704 void TorrentView::dropEvent(QDropEvent *event)

   705 {

   706     // Accept drops if the file has a '.torrent' extension and it

   707     // exists.

   708     QString fileName = QUrl(event->mimeData()->text()).path();

   709     if (QFile::exists(fileName) && fileName.toLower().endsWith(".torrent"))

   710         emit fileDropped(fileName);

   711 }

   712 

   713 #include "mainwindow.moc"