Show files in tooltips for pieces progress bars

In addition to the current tooltip, which shows color legend, if user
holds the Shift key during hovering we show another tooltip which
contains a table of contents for the piece under the moue cursor. The
table lists file sizes and names. If the cursor points to a part of a
file which spans several pieces, those pieces are highlighted.

src/base/CMakeLists.txt

@@ -46,6 +46,7 @@ utils/misc.h
 utils/string.h
 filesystemwatcher.h
 iconprovider.h
+indexrange.h
 logger.h
 preferences.h
 qinisettings.h

src/base/base.pri

@@ -6,6 +6,7 @@ HEADERS += \
     $$PWD/logger.h \
     $$PWD/settingsstorage.h \
     $$PWD/preferences.h \
+    $$PWD/indexrange.h \
     $$PWD/iconprovider.h \
     $$PWD/http/irequesthandler.h \
     $$PWD/http/connection.h \

src/base/bittorrent/torrentinfo.cpp

@@ -26,6 +26,7 @@
  * exception statement from your version.
  */
 
+#include <QDebug>
 #include <QString>
 #include <QList>
 #include <QUrl>
@@ -138,6 +139,12 @@ int TorrentInfo::pieceLength() const
     return m_nativeInfo->piece_length();
 }
 
+int TorrentInfo::pieceLength(int index) const
+{
+    if (!isValid()) return -1;
+    return m_nativeInfo->piece_size(index);
+}
+
 int TorrentInfo::piecesCount() const
 {
     if (!isValid()) return -1;
@@ -178,7 +185,7 @@ qlonglong TorrentInfo::fileSize(int index) const
 
 qlonglong TorrentInfo::fileOffset(int index) const
 {
-    if (!isValid()) return  -1;
+    if (!isValid()) return -1;
     return m_nativeInfo->file_at(index).offset;
 }
 
@@ -213,24 +220,79 @@ QByteArray TorrentInfo::metadata() const
 
 QStringList TorrentInfo::filesForPiece(int pieceIndex) const
 {
-    if (pieceIndex < 0)
-        return QStringList();
+    // no checks here because fileIndicesForPiece() will return an empty list
+    QVector<int> fileIndices = fileIndicesForPiece(pieceIndex);
 
-    std::vector<libtorrent::file_slice> files(
-        nativeInfo()->map_block(pieceIndex, 0, nativeInfo()->piece_size(pieceIndex)));
     QStringList res;
-    for (const libtorrent::file_slice& s: files) {
-        res.append(filePath(s.file_index));
-    }
+    res.reserve(fileIndices.size());
+    std::transform(fileIndices.begin(), fileIndices.end(), std::back_inserter(res),
+        [this](int i) { return filePath(i); });
+
     return res;
 }
 
+QVector<int> TorrentInfo::fileIndicesForPiece(int pieceIndex) const
+{
+    if (!isValid() || (pieceIndex < 0) || (pieceIndex >= piecesCount()))
+        return QVector<int>();
+
+    std::vector<libt::file_slice> files(
+        nativeInfo()->map_block(pieceIndex, 0, nativeInfo()->piece_size(pieceIndex)));
+    QVector<int> res;
+    res.reserve(files.size());
+    std::transform(files.begin(), files.end(), std::back_inserter(res),
+        [](const libt::file_slice &s) { return s.file_index; });
+
+    return res;
+}
+
+TorrentInfo::PieceRange TorrentInfo::filePieces(const QString& file) const
+{
+    if (!isValid()) // if we do not check here the debug message will be printed, which would be not correct
+        return {};
+
+    int index = fileIndex(file);
+    if (index == -1) {
+        qDebug() << "Filename" << file << "was not found in torrent" << name();
+        return {};
+    }
+    return filePieces(index);
+}
+
+TorrentInfo::PieceRange TorrentInfo::filePieces(int fileIndex) const
+{
+    if (!isValid())
+        return {};
+
+    if ((fileIndex < 0) || (fileIndex >= filesCount())) {
+        qDebug() << "File index (" << fileIndex << ") is out of range for torrent" << name();
+        return {};
+    }
+
+    const libt::file_storage &files = nativeInfo()->files();
+    const auto fileSize = files.file_size(fileIndex);
+    const auto firstOffset = files.file_offset(fileIndex);
+    return makeInterval(static_cast<int>(firstOffset / pieceLength()),
+                        static_cast<int>((firstOffset + fileSize - 1) / pieceLength()));
+}
+
 void TorrentInfo::renameFile(uint index, const QString &newPath)
 {
     if (!isValid()) return;
     nativeInfo()->rename_file(index, Utils::String::toStdString(newPath));
 }
 
+int BitTorrent::TorrentInfo::fileIndex(const QString& fileName) const
+{
+    // the check whether the object valid is not needed here
+    // because filesCount() returns -1 in that case and the loop exits immediately
+    for (int i = 0; i < filesCount(); ++i)
+        if (fileName == filePath(i))
+            return i;
+
+    return -1;
+}
+
 TorrentInfo::NativePtr TorrentInfo::nativeInfo() const
 {
     return m_nativeInfo;

src/base/bittorrent/torrentinfo.h

@@ -34,12 +34,15 @@
 #include <libtorrent/torrent_info.hpp>
 #include <libtorrent/version.hpp>
 
+#include "base/indexrange.h"
+
 class QString;
 class QUrl;
 class QDateTime;
 class QStringList;
 class QByteArray;
 template<typename T> class QList;
+template<typename T> class QVector;
 
 namespace BitTorrent
 {
@@ -75,6 +78,7 @@ namespace BitTorrent
         qlonglong totalSize() const;
         int filesCount() const;
         int pieceLength() const;
+        int pieceLength(int index) const;
         int piecesCount() const;
         QString filePath(int index) const;
         QStringList filePaths() const;
@@ -86,12 +90,21 @@ namespace BitTorrent
         QList<QUrl> urlSeeds() const;
         QByteArray metadata() const;
         QStringList filesForPiece(int pieceIndex) const;
+        QVector<int> fileIndicesForPiece(int pieceIndex) const;
+
+        using PieceRange = IndexRange<int>;
+        // returns pair of the first and the last pieces into which
+        // the given file extends (maybe partially).
+        PieceRange filePieces(const QString &file) const;
+        PieceRange filePieces(int fileIndex) const;
 
         void renameFile(uint index, const QString &newPath);
 
         NativePtr nativeInfo() const;
 
     private:
+        // returns file index or -1 if fileName is not found
+        int fileIndex(const QString &fileName) const;
         NativePtr m_nativeInfo;
     };
 }

src/base/indexrange.h

@@ -0,0 +1,130 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2016  Eugene Shalygin
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#ifndef QBT_INDEXRANGE_H
+#define QBT_INDEXRANGE_H
+
+#include <QtGlobal>
+
+// Interval is defined via [first;last]
+template <typename Index>
+class IndexInterval
+{
+public:
+    using IndexType = Index;
+
+    IndexInterval(IndexType first, IndexType last)
+        : m_first {first}
+        , m_last {last}
+    {
+        Q_ASSERT(first <= last);
+    }
+
+    IndexType first() const
+    {
+        return m_first;
+    }
+
+    IndexType last() const
+    {
+        return m_last;
+    }
+
+private:
+    IndexType m_first;
+    IndexType m_last;
+};
+
+template <typename T>
+inline IndexInterval<T> makeInterval(T first, T last)
+{
+    return {first, last};
+}
+
+// range is defined via first index and size
+template <typename Index, typename IndexDiff = Index>
+class IndexRange
+{
+public:
+    using IndexType = Index;
+    using IndexDiffType = IndexDiff;
+
+    constexpr IndexRange()
+        : m_first {0}
+        , m_size {0}
+    {
+    }
+
+    constexpr IndexRange(IndexType first, IndexDiffType size)
+        : m_first {first}
+        , m_size {size}
+    {
+    }
+
+    constexpr IndexRange(const IndexInterval<IndexType> &interval)
+        : m_first {interval.first()}
+        , m_size {interval.last() - interval.first() + 1}
+    {
+    }
+
+    constexpr IndexType begin() const
+    {
+        return m_first;
+    }
+
+    constexpr IndexType end() const
+    {
+        return m_first + m_size;
+    }
+
+    constexpr IndexDiffType size() const
+    {
+        return m_size;
+    }
+
+    constexpr IndexType first() const
+    {
+        return m_first;
+    }
+
+    constexpr IndexType last() const
+    {
+        return m_first + m_size - 1;
+    }
+
+    constexpr bool isEmpty() const
+    {
+        return m_size == 0;
+    }
+
+private:
+    IndexType m_first;
+    IndexDiffType m_size;
+};
+
+#endif // QBT_INDEXRANGE_H