diff --git a/src/addnewtorrentdialog.cpp b/src/addnewtorrentdialog.cpp
index 7f4383ac5..1857eea14 100644
--- a/src/addnewtorrentdialog.cpp
+++ b/src/addnewtorrentdialog.cpp
@@ -41,6 +41,7 @@
 #include "autoexpandabledialog.h"
 #include "messageboxraised.h"
 
+#include <QDebug>
 #include <QString>
 #include <QFile>
 #include <QUrl>
diff --git a/src/properties/propertieswidget.cpp b/src/properties/propertieswidget.cpp
index 8ce9a7a8c..7d0669232 100644
--- a/src/properties/propertieswidget.cpp
+++ b/src/properties/propertieswidget.cpp
@@ -28,6 +28,7 @@
  * Contact : chris@qbittorrent.org
  */
 
+#include <QDebug>
 #include <QTimer>
 #include <QListWidgetItem>
 #include <QVBoxLayout>
diff --git a/src/qtlibtorrent/qbtsession.cpp b/src/qtlibtorrent/qbtsession.cpp
index 571c9d92f..607428009 100755
--- a/src/qtlibtorrent/qbtsession.cpp
+++ b/src/qtlibtorrent/qbtsession.cpp
@@ -28,6 +28,7 @@
  * Contact : chris@qbittorrent.org
  */
 
+#include <QDebug>
 #include <QDir>
 #include <QDateTime>
 #include <QString>
@@ -73,6 +74,7 @@
 #include <libtorrent/alert_types.hpp>
 #include <libtorrent/session.hpp>
 #include <libtorrent/ip_filter.hpp>
+#include <libtorrent/magnet_uri.hpp>
 #include <queue>
 #include <string.h>
 #include "dnsupdater.h"
@@ -82,12 +84,6 @@
 #include <libtorrent/natpmp.hpp>
 #endif
 
-//initialize static member variables
-QHash<QString, TorrentTempData::TorrentData> TorrentTempData::data = QHash<QString, TorrentTempData::TorrentData>();
-QHash<QString, TorrentTempData::TorrentMoveState> TorrentTempData::torrentMoveStates = QHash<QString, TorrentTempData::TorrentMoveState>();
-QHash<QString, bool> HiddenData::data = QHash<QString, bool>();
-unsigned int HiddenData::metadata_counter = 0;
-
 using namespace libtorrent;
 
 QBtSession* QBtSession::m_instance = 0;
diff --git a/src/qtlibtorrent/qtorrenthandle.cpp b/src/qtlibtorrent/qtorrenthandle.cpp
index b0b725dd1..967668823 100644
--- a/src/qtlibtorrent/qtorrenthandle.cpp
+++ b/src/qtlibtorrent/qtorrenthandle.cpp
@@ -28,6 +28,7 @@
  * Contact : chris@qbittorrent.org
  */
 
+#include <QDebug>
 #include <QString>
 #include <QStringList>
 #include <QFile>
diff --git a/src/src.pro b/src/src.pro
index dbafe1467..37c9d3fc1 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -114,6 +114,7 @@ HEADERS += misc.h \
 SOURCES += main.cpp \
            downloadthread.cpp \
            scannedfoldersmodel.cpp \
+           torrentpersistentdata.cpp \
            misc.cpp \
            fs_utils.cpp \
            smtp.cpp \
diff --git a/src/torrentcreator/torrentcreatordlg.cpp b/src/torrentcreator/torrentcreatordlg.cpp
index ca2eda942..96743ee84 100644
--- a/src/torrentcreator/torrentcreatordlg.cpp
+++ b/src/torrentcreator/torrentcreatordlg.cpp
@@ -28,6 +28,7 @@
  * Contact : chris@qbittorrent.org
  */
 
+#include <QDebug>
 #include <QFileDialog>
 #include <QMessageBox>
 
diff --git a/src/torrentpersistentdata.cpp b/src/torrentpersistentdata.cpp
new file mode 100644
index 000000000..569dcb3dc
--- /dev/null
+++ b/src/torrentpersistentdata.cpp
@@ -0,0 +1,440 @@
+/*
+ * Bittorrent Client using Qt4 and libtorrent.
+ * Copyright (C) 2006  Christophe Dumez
+ *
+ * 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.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#include "torrentpersistentdata.h"
+
+#include <QDebug>
+#include <QVariant>
+
+#include "qinisettings.h"
+#include "misc.h"
+#include "qtorrenthandle.h"
+
+#include <libtorrent/version.hpp>
+#include <libtorrent/magnet_uri.hpp>
+
+QHash<QString, TorrentTempData::TorrentData> TorrentTempData::data = QHash<QString, TorrentTempData::TorrentData>();
+QHash<QString, TorrentTempData::TorrentMoveState> TorrentTempData::torrentMoveStates = QHash<QString, TorrentTempData::TorrentMoveState>();
+QHash<QString, bool> HiddenData::data = QHash<QString, bool>();
+unsigned int HiddenData::metadata_counter = 0;
+
+bool TorrentTempData::hasTempData(const QString &hash) {
+  return data.contains(hash);
+}
+
+void TorrentTempData::deleteTempData(const QString &hash) {
+  data.remove(hash);
+}
+
+void TorrentTempData::setFilesPriority(const QString &hash,  const std::vector<int> &pp) {
+  data[hash].files_priority = pp;
+}
+
+void TorrentTempData::setFilesPath(const QString &hash, const QStringList &path_list) {
+  data[hash].path_list = path_list;
+}
+
+void TorrentTempData::setSavePath(const QString &hash, const QString &save_path) {
+  data[hash].save_path = save_path;
+}
+
+void TorrentTempData::setLabel(const QString &hash, const QString &label) {
+  data[hash].label = label;
+}
+
+void TorrentTempData::setSequential(const QString &hash, const bool &sequential) {
+  data[hash].sequential = sequential;
+}
+
+bool TorrentTempData::isSequential(const QString &hash) {
+  return data.value(hash).sequential;
+}
+
+void TorrentTempData::setSeedingMode(const QString &hash, const bool &seed) {
+  data[hash].seed = seed;
+}
+
+bool TorrentTempData::isSeedingMode(const QString &hash) {
+  return data.value(hash).seed;
+}
+
+QString TorrentTempData::getSavePath(const QString &hash) {
+  return data.value(hash).save_path;
+}
+
+QStringList TorrentTempData::getFilesPath(const QString &hash) {
+  return data.value(hash).path_list;
+}
+
+QString TorrentTempData::getLabel(const QString &hash) {
+  return data.value(hash).label;
+}
+
+void TorrentTempData::getFilesPriority(const QString &hash, std::vector<int> &fp) {
+  fp = data.value(hash).files_priority;
+}
+
+bool TorrentTempData::isMoveInProgress(const QString &hash) {
+  return torrentMoveStates.find(hash) != torrentMoveStates.end();
+}
+
+void TorrentTempData::enqueueMove(const QString &hash, const QString &queuedPath) {
+  QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
+  if (i == torrentMoveStates.end()) {
+    Q_ASSERT(false);
+    return;
+  }
+  i->queuedPath = queuedPath;
+}
+
+void TorrentTempData::startMove(const QString &hash, const QString &oldPath, const QString& newPath) {
+  QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
+  if (i != torrentMoveStates.end()) {
+    Q_ASSERT(false);
+    return;
+  }
+
+  torrentMoveStates.insert(hash, TorrentMoveState(oldPath, newPath));
+}
+
+void TorrentTempData::finishMove(const QString &hash) {
+  QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
+  if (i == torrentMoveStates.end()) {
+    Q_ASSERT(false);
+    return;
+  }
+  torrentMoveStates.erase(i);
+}
+
+QString TorrentTempData::getOldPath(const QString &hash) {
+  QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
+  if (i == torrentMoveStates.end()) {
+    Q_ASSERT(false);
+    return QString();
+  }
+  return i->oldPath;
+}
+
+QString TorrentTempData::getNewPath(const QString &hash) {
+  QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
+  if (i == torrentMoveStates.end()) {
+    Q_ASSERT(false);
+    return QString();
+  }
+  return i->newPath;
+}
+
+QString TorrentTempData::getQueuedPath(const QString &hash) {
+  QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
+  if (i == torrentMoveStates.end()) {
+    Q_ASSERT(false);
+    return QString();
+  }
+  return i->queuedPath;
+}
+
+void HiddenData::addData(const QString &hash) {
+  data[hash] = false;
+}
+
+bool HiddenData::hasData(const QString &hash) {
+  return data.contains(hash);
+}
+
+void HiddenData::deleteData(const QString &hash) {
+  if (data.value(hash, false))
+    metadata_counter--;
+  data.remove(hash);
+}
+
+int HiddenData::getSize() {
+  return data.size();
+}
+
+int HiddenData::getDownloadingSize() {
+  return data.size() - metadata_counter;
+}
+
+void HiddenData::gotMetadata(const QString &hash) {
+  if (!data.contains(hash))
+      return;
+  data[hash] = true;
+  metadata_counter++;
+}
+
+bool TorrentPersistentData::isKnownTorrent(QString hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  return all_data.contains(hash);
+}
+
+QStringList TorrentPersistentData::knownTorrents() {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  return all_data.keys();
+}
+
+void TorrentPersistentData::setRatioLimit(const QString &hash, const qreal &ratio) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  data["max_ratio"] = ratio;
+  all_data[hash] = data;
+  settings.setValue("torrents", all_data);
+}
+
+qreal TorrentPersistentData::getRatioLimit(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("max_ratio", USE_GLOBAL_RATIO).toReal();
+}
+
+bool TorrentPersistentData::hasPerTorrentRatioLimit() {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant>::ConstIterator it = all_data.constBegin();
+  QHash<QString, QVariant>::ConstIterator itend = all_data.constEnd();
+  for ( ; it != itend; ++it) {
+    if (it.value().toHash().value("max_ratio", USE_GLOBAL_RATIO).toReal() >= 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void TorrentPersistentData::setAddedDate(const QString &hash, const QDateTime &time) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  if (!data.contains("add_date")) {
+    data["add_date"] = time;
+    all_data[hash] = data;
+    settings.setValue("torrents", all_data);
+  }
+}
+
+QDateTime TorrentPersistentData::getAddedDate(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  QDateTime dt = data.value("add_date").toDateTime();
+  if (!dt.isValid()) {
+    setAddedDate(hash);
+    dt = QDateTime::currentDateTime();
+  }
+  return dt;
+}
+
+void TorrentPersistentData::setErrorState(const QString &hash, const bool has_error) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  data["has_error"] = has_error;
+  all_data[hash] = data;
+  settings.setValue("torrents", all_data);
+}
+
+bool TorrentPersistentData::hasError(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("has_error", false).toBool();
+}
+
+QDateTime TorrentPersistentData::getSeedDate(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("seed_date").toDateTime();
+}
+
+void TorrentPersistentData::deletePersistentData(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  if (all_data.contains(hash)) {
+    all_data.remove(hash);
+    settings.setValue("torrents", all_data);
+  }
+}
+
+void TorrentPersistentData::saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path, const bool is_magnet) {
+  Q_ASSERT(h.is_valid());
+  qDebug("Saving persistent data for %s", qPrintable(h.hash()));
+  // Save persistent data
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data.value(h.hash()).toHash();
+  data["is_magnet"] = is_magnet;
+  if (is_magnet) {
+    data["magnet_uri"] = misc::toQString(make_magnet_uri(h));
+  }
+  data["seed"] = h.is_seed();
+  data["priority"] = h.queue_position();
+  if (save_path.isEmpty()) {
+    qDebug("TorrentPersistantData: save path is %s", qPrintable(h.save_path()));
+    data["save_path"] = h.save_path();
+  } else {
+    qDebug("TorrentPersistantData: overriding save path is %s", qPrintable(save_path));
+    data["save_path"] = save_path; // Override torrent save path (e.g. because it is a temp dir)
+  }
+  // Label
+  data["label"] = TorrentTempData::getLabel(h.hash());
+  // Save data
+  all_data[h.hash()] = data;
+  settings.setValue("torrents", all_data);
+  qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(h.hash()));
+  // Set Added date
+  setAddedDate(h.hash());
+  // Finally, remove temp data
+  TorrentTempData::deleteTempData(h.hash());
+}
+
+void TorrentPersistentData::saveSavePath(const QString &hash, const QString &save_path) {
+  Q_ASSERT(!hash.isEmpty());
+  qDebug("TorrentPersistentData::saveSavePath(%s)", qPrintable(save_path));
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  data["save_path"] = save_path;
+  all_data[hash] = data;
+  settings.setValue("torrents", all_data);
+  qDebug("TorrentPersistentData: Saving save_path: %s, hash: %s", qPrintable(save_path), qPrintable(hash));
+}
+
+void TorrentPersistentData::saveLabel(const QString &hash, const QString &label) {
+  Q_ASSERT(!hash.isEmpty());
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  data["label"] = label;
+  all_data[hash] = data;
+  settings.setValue("torrents", all_data);
+}
+
+void TorrentPersistentData::saveName(const QString &hash, const QString &name) {
+  Q_ASSERT(!hash.isEmpty());
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  data["name"] = name;
+  all_data[hash] = data;
+  settings.setValue("torrents", all_data);
+}
+
+void TorrentPersistentData::savePriority(const QTorrentHandle &h) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+  data["priority"] = h.queue_position();
+  all_data[h.hash()] = data;
+  settings.setValue("torrents", all_data);
+}
+
+void TorrentPersistentData::savePriority(const QString &hash, const int &queue_pos) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data[hash].toHash();
+  data["priority"] = queue_pos;
+  all_data[hash] = data;
+  settings.setValue("torrents", all_data);
+}
+
+void TorrentPersistentData::saveSeedStatus(const QTorrentHandle &h) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+  bool was_seed = data.value("seed", false).toBool();
+  if (was_seed != h.is_seed()) {
+    data["seed"] = !was_seed;
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+}
+
+void TorrentPersistentData::saveSeedStatus(const QString &hash, const bool seedStatus) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  QHash<QString, QVariant> data = all_data[hash].toHash();
+  data["seed"] = seedStatus;
+  all_data[hash] = data;
+  settings.setValue("torrents", all_data);
+}
+
+QString TorrentPersistentData::getSavePath(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  //qDebug("TorrentPersistentData: getSavePath %s", data["save_path"].toString().toLocal8Bit().data());
+  return data.value("save_path").toString();
+}
+
+QString TorrentPersistentData::getLabel(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("label", "").toString();
+}
+
+QString TorrentPersistentData::getName(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("name", "").toString();
+}
+
+int TorrentPersistentData::getPriority(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("priority", -1).toInt();
+}
+
+bool TorrentPersistentData::isSeed(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("seed", false).toBool();
+}
+
+bool TorrentPersistentData::isMagnet(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  return data.value("is_magnet", false).toBool();
+}
+
+QString TorrentPersistentData::getMagnetUri(const QString &hash) {
+  QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+  const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
+  const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+  Q_ASSERT(data.value("is_magnet", false).toBool());
+  return data.value("magnet_uri").toString();
+}
diff --git a/src/torrentpersistentdata.h b/src/torrentpersistentdata.h
index 130ffac01..56d02ec3a 100644
--- a/src/torrentpersistentdata.h
+++ b/src/torrentpersistentdata.h
@@ -31,134 +31,37 @@
 #ifndef TORRENTPERSISTENTDATA_H
 #define TORRENTPERSISTENTDATA_H
 
-#include <QVariant>
 #include <QDateTime>
-#include <QDebug>
-#include <libtorrent/version.hpp>
-#include <libtorrent/magnet_uri.hpp>
-#include "qtorrenthandle.h"
-#include "misc.h"
-#include <vector>
-#include "qinisettings.h"
 #include <QHash>
+#include <QStringList>
+#include <vector>
+
+class QTorrentHandle;
 
 class TorrentTempData {
   // This class stores strings w/o modifying separators
 public:
-  static bool hasTempData(const QString &hash) {
-    return data.contains(hash);
-  }
-
-  static void deleteTempData(const QString &hash) {
-    data.remove(hash);
-  }
-
-  static void setFilesPriority(const QString &hash,  const std::vector<int> &pp) {
-    data[hash].files_priority = pp;
-  }
-
-  static void setFilesPath(const QString &hash, const QStringList &path_list) {
-    data[hash].path_list = path_list;
-  }
-
-  static void setSavePath(const QString &hash, const QString &save_path) {
-    data[hash].save_path = save_path;
-  }
-
-  static void setLabel(const QString &hash, const QString &label) {
-    data[hash].label = label;
-  }
-
-  static void setSequential(const QString &hash, const bool &sequential) {
-    data[hash].sequential = sequential;
-  }
-
-  static bool isSequential(const QString &hash) {
-    return data.value(hash).sequential;
-  }
-
-  static void setSeedingMode(const QString &hash, const bool &seed) {
-    data[hash].seed = seed;
-  }
-
-  static bool isSeedingMode(const QString &hash) {
-    return data.value(hash).seed;
-  }
-
-  static QString getSavePath(const QString &hash) {
-    return data.value(hash).save_path;
-  }
-
-  static QStringList getFilesPath(const QString &hash) {
-    return data.value(hash).path_list;
-  }
-
-  static QString getLabel(const QString &hash) {
-    return data.value(hash).label;
-  }
-
-  static void getFilesPriority(const QString &hash, std::vector<int> &fp) {
-    fp = data.value(hash).files_priority;
-  }
-
-  static bool isMoveInProgress(const QString &hash) {
-    return torrentMoveStates.find(hash) != torrentMoveStates.end();
-  }
-
-  static void enqueueMove(const QString &hash, const QString &queuedPath) {
-    QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
-    if (i == torrentMoveStates.end()) {
-      Q_ASSERT(false);
-      return;
-    }
-    i->queuedPath = queuedPath;
-  }
-
-  static void startMove(const QString &hash, const QString &oldPath, const QString& newPath) {
-    QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
-    if (i != torrentMoveStates.end()) {
-      Q_ASSERT(false);
-      return;
-    }
-
-    torrentMoveStates.insert(hash, TorrentMoveState(oldPath, newPath));
-  }
-
-  static void finishMove(const QString &hash) {
-    QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
-    if (i == torrentMoveStates.end()) {
-      Q_ASSERT(false);
-      return;
-    }
-    torrentMoveStates.erase(i);
-  }
-
-  static QString getOldPath(const QString &hash) {
-    QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
-    if (i == torrentMoveStates.end()) {
-      Q_ASSERT(false);
-      return QString();
-    }
-    return i->oldPath;
-  }
-
-  static QString getNewPath(const QString &hash) {
-    QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
-    if (i == torrentMoveStates.end()) {
-      Q_ASSERT(false);
-      return QString();
-    }
-    return i->newPath;
-  }
-
-  static QString getQueuedPath(const QString &hash) {
-    QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
-    if (i == torrentMoveStates.end()) {
-      Q_ASSERT(false);
-      return QString();
-    }
-    return i->queuedPath;
-  }
+  static bool hasTempData(const QString &hash);
+  static void deleteTempData(const QString &hash);
+  static void setFilesPriority(const QString &hash,  const std::vector<int> &pp);
+  static void setFilesPath(const QString &hash, const QStringList &path_list);
+  static void setSavePath(const QString &hash, const QString &save_path);
+  static void setLabel(const QString &hash, const QString &label);
+  static void setSequential(const QString &hash, const bool &sequential);
+  static bool isSequential(const QString &hash);
+  static void setSeedingMode(const QString &hash, const bool &seed);
+  static bool isSeedingMode(const QString &hash);
+  static QString getSavePath(const QString &hash);
+  static QStringList getFilesPath(const QString &hash);
+  static QString getLabel(const QString &hash);
+  static void getFilesPriority(const QString &hash, std::vector<int> &fp);
+  static bool isMoveInProgress(const QString &hash);
+  static void enqueueMove(const QString &hash, const QString &queuedPath);
+  static void startMove(const QString &hash, const QString &oldPath, const QString& newPath);
+  static void finishMove(const QString &hash);
+  static QString getOldPath(const QString &hash);
+  static QString getNewPath(const QString &hash);
+  static QString getQueuedPath(const QString &hash);
 
 private:
   struct TorrentData {
@@ -190,34 +93,12 @@ private:
 
 class HiddenData {
 public:
-  static void addData(const QString &hash) {
-    data[hash] = false;
-  }
-
-  static bool hasData(const QString &hash) {
-    return data.contains(hash);
-  }
-
-  static void deleteData(const QString &hash) {
-    if (data.value(hash, false))
-      metadata_counter--;
-    data.remove(hash);
-  }
-
-  static int getSize() {
-    return data.size();
-  }
-
-  static int getDownloadingSize() {
-    return data.size() - metadata_counter;
-  }
-
-  static void gotMetadata(const QString &hash) {
-    if (!data.contains(hash))
-        return;
-    data[hash] = true;
-    metadata_counter++;
-  }
+  static void addData(const QString &hash);
+  static bool hasData(const QString &hash);
+  static void deleteData(const QString &hash);
+  static int getSize();
+  static int getDownloadingSize();
+  static void gotMetadata(const QString &hash);
 
 private:
   static QHash<QString, bool> data;
@@ -233,259 +114,36 @@ public:
   };
 
 public:
-  static bool isKnownTorrent(QString hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    return all_data.contains(hash);
-  }
-
-  static QStringList knownTorrents() {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    return all_data.keys();
-  }
-
-  static void setRatioLimit(const QString &hash, const qreal &ratio) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    data["max_ratio"] = ratio;
-    all_data[hash] = data;
-    settings.setValue("torrents", all_data);
-  }
-
-  static qreal getRatioLimit(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("max_ratio", USE_GLOBAL_RATIO).toReal();
-  }
-
-  static bool hasPerTorrentRatioLimit() {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant>::ConstIterator it = all_data.constBegin();
-    QHash<QString, QVariant>::ConstIterator itend = all_data.constEnd();
-    for ( ; it != itend; ++it) {
-      if (it.value().toHash().value("max_ratio", USE_GLOBAL_RATIO).toReal() >= 0) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  static void setAddedDate(const QString &hash, const QDateTime &time = QDateTime::currentDateTime()) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    if (!data.contains("add_date")) {
-      data["add_date"] = time;
-      all_data[hash] = data;
-      settings.setValue("torrents", all_data);
-    }
-  }
-
-  static QDateTime getAddedDate(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    QDateTime dt = data.value("add_date").toDateTime();
-    if (!dt.isValid()) {
-      setAddedDate(hash);
-      dt = QDateTime::currentDateTime();
-    }
-    return dt;
-  }
-
-  static void setErrorState(const QString &hash, const bool has_error) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    data["has_error"] = has_error;
-    all_data[hash] = data;
-    settings.setValue("torrents", all_data);
-  }
-
-  static bool hasError(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("has_error", false).toBool();
-  }
-
-  static QDateTime getSeedDate(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("seed_date").toDateTime();
-  }
-
-  static void deletePersistentData(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    if (all_data.contains(hash)) {
-      all_data.remove(hash);
-      settings.setValue("torrents", all_data);
-    }
-  }
-
-  static void saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path = QString::null, const bool is_magnet = false) {
-    Q_ASSERT(h.is_valid());
-    qDebug("Saving persistent data for %s", qPrintable(h.hash()));
-    // Save persistent data
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data.value(h.hash()).toHash();
-    data["is_magnet"] = is_magnet;
-    if (is_magnet) {
-      data["magnet_uri"] = misc::toQString(make_magnet_uri(h));
-    }
-    data["seed"] = h.is_seed();
-    data["priority"] = h.queue_position();
-    if (save_path.isEmpty()) {
-      qDebug("TorrentPersistantData: save path is %s", qPrintable(h.save_path()));
-      data["save_path"] = h.save_path();
-    } else {
-      qDebug("TorrentPersistantData: overriding save path is %s", qPrintable(save_path));
-      data["save_path"] = save_path; // Override torrent save path (e.g. because it is a temp dir)
-    }
-    // Label
-    data["label"] = TorrentTempData::getLabel(h.hash());
-    // Save data
-    all_data[h.hash()] = data;
-    settings.setValue("torrents", all_data);
-    qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(h.hash()));
-    // Set Added date
-    setAddedDate(h.hash());
-    // Finally, remove temp data
-    TorrentTempData::deleteTempData(h.hash());
-  }
+  static bool isKnownTorrent(QString hash);
+  static QStringList knownTorrents();
+  static void setRatioLimit(const QString &hash, const qreal &ratio);
+  static qreal getRatioLimit(const QString &hash);
+  static bool hasPerTorrentRatioLimit() ;
+  static void setAddedDate(const QString &hash, const QDateTime &time = QDateTime::currentDateTime());
+  static QDateTime getAddedDate(const QString &hash);
+  static void setErrorState(const QString &hash, const bool has_error);
+  static bool hasError(const QString &hash);
+  static QDateTime getSeedDate(const QString &hash);
+  static void deletePersistentData(const QString &hash);
+  static void saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path = QString::null, const bool is_magnet = false);
 
   // Setters
-
-  static void saveSavePath(const QString &hash, const QString &save_path) {
-    Q_ASSERT(!hash.isEmpty());
-    qDebug("TorrentPersistentData::saveSavePath(%s)", qPrintable(save_path));
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    data["save_path"] = save_path;
-    all_data[hash] = data;
-    settings.setValue("torrents", all_data);
-    qDebug("TorrentPersistentData: Saving save_path: %s, hash: %s", qPrintable(save_path), qPrintable(hash));
-  }
-
-  static void saveLabel(const QString &hash, const QString &label) {
-    Q_ASSERT(!hash.isEmpty());
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    data["label"] = label;
-    all_data[hash] = data;
-    settings.setValue("torrents", all_data);
-  }
-
-  static void saveName(const QString &hash, const QString &name) {
-    Q_ASSERT(!hash.isEmpty());
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    data["name"] = name;
-    all_data[hash] = data;
-    settings.setValue("torrents", all_data);
-  }
-
-  static void savePriority(const QTorrentHandle &h) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
-    data["priority"] = h.queue_position();
-    all_data[h.hash()] = data;
-    settings.setValue("torrents", all_data);
-  }
-
-  static void savePriority(const QString &hash, const int &queue_pos) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data[hash].toHash();
-    data["priority"] = queue_pos;
-    all_data[hash] = data;
-    settings.setValue("torrents", all_data);
-  }
-
-  static void saveSeedStatus(const QTorrentHandle &h) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
-    bool was_seed = data.value("seed", false).toBool();
-    if (was_seed != h.is_seed()) {
-      data["seed"] = !was_seed;
-      all_data[h.hash()] = data;
-      settings.setValue("torrents", all_data);
-    }
-  }
-
-  static void saveSeedStatus(const QString &hash, const bool seedStatus) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    QHash<QString, QVariant> data = all_data[hash].toHash();
-    data["seed"] = seedStatus;
-    all_data[hash] = data;
-    settings.setValue("torrents", all_data);
-  }
+  static void saveSavePath(const QString &hash, const QString &save_path);
+  static void saveLabel(const QString &hash, const QString &label);
+  static void saveName(const QString &hash, const QString &name);
+  static void savePriority(const QTorrentHandle &h);
+  static void savePriority(const QString &hash, const int &queue_pos);
+  static void saveSeedStatus(const QTorrentHandle &h);
+  static void saveSeedStatus(const QString &hash, const bool seedStatus);
 
   // Getters
-  static QString getSavePath(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    //qDebug("TorrentPersistentData: getSavePath %s", data["save_path"].toString().toLocal8Bit().data());
-    return data.value("save_path").toString();
-  }
-
-  static QString getLabel(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("label", "").toString();
-  }
-
-  static QString getName(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("name", "").toString();
-  }
-
-  static int getPriority(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("priority", -1).toInt();
-  }
-
-  static bool isSeed(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("seed", false).toBool();
-  }
-
-  static bool isMagnet(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("is_magnet", false).toBool();
-  }
-
-  static QString getMagnetUri(const QString &hash) {
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    const QHash<QString, QVariant> all_data = settings.value("torrents").toHash();
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    Q_ASSERT(data.value("is_magnet", false).toBool());
-    return data.value("magnet_uri").toString();
-  }
-
+  static QString getSavePath(const QString &hash);
+  static QString getLabel(const QString &hash);
+  static QString getName(const QString &hash);
+  static int getPriority(const QString &hash);
+  static bool isSeed(const QString &hash);
+  static bool isMagnet(const QString &hash);
+  static QString getMagnetUri(const QString &hash);
 };
 
 #endif // TORRENTPERSISTENTDATA_H
diff --git a/src/transferlistfilterswidget.cpp b/src/transferlistfilterswidget.cpp
index b3d553f6f..21618c429 100644
--- a/src/transferlistfilterswidget.cpp
+++ b/src/transferlistfilterswidget.cpp
@@ -30,6 +30,7 @@
 
 #include "transferlistfilterswidget.h"
 
+#include <QDebug>
 #include <QListWidgetItem>
 #include <QIcon>
 #include <QVBoxLayout>
diff --git a/src/transferlistwidget.cpp b/src/transferlistwidget.cpp
index e98fa2bf5..6b22ca885 100644
--- a/src/transferlistwidget.cpp
+++ b/src/transferlistwidget.cpp
@@ -28,6 +28,7 @@
  * Contact : chris@qbittorrent.org
  */
 
+#include <QDebug>
 #include <QShortcut>
 #include <QStandardItemModel>
 #include <QSortFilterProxyModel>
@@ -42,6 +43,7 @@
 #include <QMessageBox>
 
 #include <libtorrent/version.hpp>
+#include <libtorrent/magnet_uri.hpp>
 #include <vector>
 #include <queue>
 
diff --git a/src/webui/btjson.cpp b/src/webui/btjson.cpp
index 735e68893..4272e1650 100644
--- a/src/webui/btjson.cpp
+++ b/src/webui/btjson.cpp
@@ -35,6 +35,8 @@
 #include "torrentpersistentdata.h"
 #include "jsonutils.h"
 
+#include <QDebug>
+#include <QVariant>
 #if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
 #include <QElapsedTimer>
 #endif
diff --git a/src/webui/jsonutils.h b/src/webui/jsonutils.h
index b08cfb0d8..82c720579 100644
--- a/src/webui/jsonutils.h
+++ b/src/webui/jsonutils.h
@@ -31,6 +31,7 @@
 #ifndef JSONUTILS_H
 #define JSONUTILS_H
 
+#include <QVariant>
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
 #include <QJsonDocument>
 #include <QJsonObject>