Fix indentation size in qtlibtorrent/* files.

src/core/qtlibtorrent/alertdispatcher.cpp

@@ -37,99 +37,99 @@
 const size_t DEFAULT_ALERTS_CAPACITY = 32;
 
 struct QAlertDispatcher::Tag {
-  Tag(QAlertDispatcher* dispatcher);
+    Tag(QAlertDispatcher* dispatcher);
 
-  QAlertDispatcher* dispatcher;
-  QMutex alerts_mutex;
+    QAlertDispatcher* dispatcher;
+    QMutex alerts_mutex;
 };
 
 QAlertDispatcher::Tag::Tag(QAlertDispatcher* dispatcher)
-  : dispatcher(dispatcher)
+    : dispatcher(dispatcher)
 {}
 
 QAlertDispatcher::QAlertDispatcher(libtorrent::session *session, QObject* parent)
-  : QObject(parent)
-  , m_session(session)
-  , current_tag(new Tag(this))
-  , event_posted(false)
+    : QObject(parent)
+    , m_session(session)
+    , current_tag(new Tag(this))
+    , event_posted(false)
 {
-  alerts.reserve(DEFAULT_ALERTS_CAPACITY);
-  m_session->set_alert_dispatch(boost::bind(&QAlertDispatcher::dispatch, current_tag, _1));
+    alerts.reserve(DEFAULT_ALERTS_CAPACITY);
+    m_session->set_alert_dispatch(boost::bind(&QAlertDispatcher::dispatch, current_tag, _1));
 }
 
 QAlertDispatcher::~QAlertDispatcher() {
-  // When QAlertDispatcher is destoyed, libtorrent still can call
-  // QAlertDispatcher::dispatch a few times after destruction. This is
-  // handled by passing a "tag". A tag is a object that references QAlertDispatch.
-  // Tag could be invalidated. So on destruction QAlertDispatcher invalidates a tag
-  // and then unsubscribes from alerts. When QAlertDispatcher::dispatch is called
-  // with invalid tag it simply discard an alert.
-
-  {
-    QMutexLocker lock(&current_tag->alerts_mutex);
-    current_tag->dispatcher = 0;
-    current_tag.clear();
-  }
-
-  typedef boost::function<void (std::auto_ptr<libtorrent::alert>)> dispatch_function_t;
-  m_session->set_alert_dispatch(dispatch_function_t());
+    // When QAlertDispatcher is destoyed, libtorrent still can call
+    // QAlertDispatcher::dispatch a few times after destruction. This is
+    // handled by passing a "tag". A tag is a object that references QAlertDispatch.
+    // Tag could be invalidated. So on destruction QAlertDispatcher invalidates a tag
+    // and then unsubscribes from alerts. When QAlertDispatcher::dispatch is called
+    // with invalid tag it simply discard an alert.
+
+    {
+        QMutexLocker lock(&current_tag->alerts_mutex);
+        current_tag->dispatcher = 0;
+        current_tag.clear();
+    }
+
+    typedef boost::function<void (std::auto_ptr<libtorrent::alert>)> dispatch_function_t;
+    m_session->set_alert_dispatch(dispatch_function_t());
 }
 
 void QAlertDispatcher::getPendingAlertsNoWait(std::vector<libtorrent::alert*>& out) {
-  Q_ASSERT(out.empty());
-  out.reserve(DEFAULT_ALERTS_CAPACITY);
+    Q_ASSERT(out.empty());
+    out.reserve(DEFAULT_ALERTS_CAPACITY);
 
-  QMutexLocker lock(&current_tag->alerts_mutex);
-  alerts.swap(out);
-  event_posted = false;
+    QMutexLocker lock(&current_tag->alerts_mutex);
+    alerts.swap(out);
+    event_posted = false;
 }
 
 void QAlertDispatcher::getPendingAlerts(std::vector<libtorrent::alert*>& out, unsigned long time) {
-  Q_ASSERT(out.empty());
-  out.reserve(DEFAULT_ALERTS_CAPACITY);
+    Q_ASSERT(out.empty());
+    out.reserve(DEFAULT_ALERTS_CAPACITY);
 
-  QMutexLocker lock(&current_tag->alerts_mutex);
+    QMutexLocker lock(&current_tag->alerts_mutex);
 
-  while (alerts.empty())
-    alerts_condvar.wait(&current_tag->alerts_mutex, time);
+    while (alerts.empty())
+        alerts_condvar.wait(&current_tag->alerts_mutex, time);
 
-  alerts.swap(out);
-  event_posted = false;
+    alerts.swap(out);
+    event_posted = false;
 }
 
 void QAlertDispatcher::dispatch(QSharedPointer<Tag> tag,
                                 std::auto_ptr<libtorrent::alert> alert_ptr) {
-  QMutexLocker lock(&(tag->alerts_mutex));
-  QAlertDispatcher* that = tag->dispatcher;
-  if (!that)
-    return;
+    QMutexLocker lock(&(tag->alerts_mutex));
+    QAlertDispatcher* that = tag->dispatcher;
+    if (!that)
+        return;
 
-  bool was_empty = that->alerts.empty();
+    bool was_empty = that->alerts.empty();
 
-  that->alerts.push_back(alert_ptr.get());
-  alert_ptr.release();
+    that->alerts.push_back(alert_ptr.get());
+    alert_ptr.release();
 
-  if (was_empty)
-    that->alerts_condvar.wakeAll();
+    if (was_empty)
+        that->alerts_condvar.wakeAll();
 
-  that->enqueueToMainThread();
+    that->enqueueToMainThread();
 
-  Q_ASSERT(that->current_tag == tag);
+    Q_ASSERT(that->current_tag == tag);
 }
 
 void QAlertDispatcher::enqueueToMainThread() {
-  if (!event_posted) {
-    event_posted = true;
-    QMetaObject::invokeMethod(this, "deliverSignal", Qt::QueuedConnection);
-  }
+    if (!event_posted) {
+        event_posted = true;
+        QMetaObject::invokeMethod(this, "deliverSignal", Qt::QueuedConnection);
+    }
 }
 
 void QAlertDispatcher::deliverSignal() {
-  emit alertsReceived();
+    emit alertsReceived();
 
-  QMutexLocker lock(&current_tag->alerts_mutex);
-  event_posted = false;
+    QMutexLocker lock(&current_tag->alerts_mutex);
+    event_posted = false;
 
-  if (!alerts.empty())
-    enqueueToMainThread();
+    if (!alerts.empty())
+        enqueueToMainThread();
 }

src/core/qtlibtorrent/alertdispatcher.h

@@ -41,40 +41,40 @@
 #include <memory>
 
 namespace libtorrent {
-  class session;
-  class alert;
+class session;
+class alert;
 }
 
 class QAlertDispatcher : public QObject {
-  Q_OBJECT
-  Q_DISABLE_COPY(QAlertDispatcher)
+    Q_OBJECT
+    Q_DISABLE_COPY(QAlertDispatcher)
 
-  struct Tag;
+    struct Tag;
 
 public:
-  QAlertDispatcher(libtorrent::session *session, QObject* parent);
-  ~QAlertDispatcher();
+    QAlertDispatcher(libtorrent::session *session, QObject* parent);
+    ~QAlertDispatcher();
 
-  void getPendingAlertsNoWait(std::vector<libtorrent::alert*>&);
-  void getPendingAlerts(std::vector<libtorrent::alert*>&, unsigned long time = ULONG_MAX);
+    void getPendingAlertsNoWait(std::vector<libtorrent::alert*>&);
+    void getPendingAlerts(std::vector<libtorrent::alert*>&, unsigned long time = ULONG_MAX);
 
 signals:
-  void alertsReceived();
+    void alertsReceived();
 
 private:
-  static void dispatch(QSharedPointer<Tag>,
-                       std::auto_ptr<libtorrent::alert>);
-  void enqueueToMainThread();
+    static void dispatch(QSharedPointer<Tag>,
+                         std::auto_ptr<libtorrent::alert>);
+    void enqueueToMainThread();
 
 private slots:
-  void deliverSignal();
+    void deliverSignal();
 
 private:
-  libtorrent::session *m_session;
-  QWaitCondition alerts_condvar;
-  std::vector<libtorrent::alert*> alerts;
-  QSharedPointer<Tag> current_tag;
-  bool event_posted;
+    libtorrent::session *m_session;
+    QWaitCondition alerts_condvar;
+    std::vector<libtorrent::alert*> alerts;
+    QSharedPointer<Tag> current_tag;
+    bool event_posted;
 };
 
 #endif // ALERTDISPATCHER_H

src/core/qtlibtorrent/bandwidthscheduler.h

@@ -9,71 +9,71 @@
 
 
 class BandwidthScheduler: public QTimer {
-  Q_OBJECT
+    Q_OBJECT
 
 public:
-  BandwidthScheduler(QObject *parent): QTimer(parent) {
-    Q_ASSERT(Preferences::instance()->isSchedulerEnabled());
-    // Signal shot, we call start() again manually
-    setSingleShot(true);
-    // Connect Signals/Slots
-    connect(this, SIGNAL(timeout()), this, SLOT(start()));
-  }
+    BandwidthScheduler(QObject *parent): QTimer(parent) {
+        Q_ASSERT(Preferences::instance()->isSchedulerEnabled());
+        // Signal shot, we call start() again manually
+        setSingleShot(true);
+        // Connect Signals/Slots
+        connect(this, SIGNAL(timeout()), this, SLOT(start()));
+    }
 
 public slots:
-  void start() {
-    const Preferences* const pref = Preferences::instance();
-    Q_ASSERT(pref->isSchedulerEnabled());
-    bool alt_bw_enabled = pref->isAltBandwidthEnabled();
+    void start() {
+        const Preferences* const pref = Preferences::instance();
+        Q_ASSERT(pref->isSchedulerEnabled());
+        bool alt_bw_enabled = pref->isAltBandwidthEnabled();
 
-    QTime start = pref->getSchedulerStartTime();
-    QTime end = pref->getSchedulerEndTime();
-    QTime now = QTime::currentTime();
-    int sched_days = pref->getSchedulerDays();
-    int day = QDateTime::currentDateTime().toLocalTime().date().dayOfWeek();
-    bool new_mode = false;
-    bool reverse = false;
+        QTime start = pref->getSchedulerStartTime();
+        QTime end = pref->getSchedulerEndTime();
+        QTime now = QTime::currentTime();
+        int sched_days = pref->getSchedulerDays();
+        int day = QDateTime::currentDateTime().toLocalTime().date().dayOfWeek();
+        bool new_mode = false;
+        bool reverse = false;
 
-    if (start > end) {
-      QTime temp = start;
-      start = end;
-      end = temp;
-      reverse = true;
-    }
+        if (start > end) {
+            QTime temp = start;
+            start = end;
+            end = temp;
+            reverse = true;
+        }
 
-    if (start <= now && end >= now) {
-      switch(sched_days) {
-      case EVERY_DAY:
-        new_mode = true;
-        break;
-      case WEEK_ENDS:
-        if (day == 6 || day == 7)
-          new_mode = true;
-        break;
-      case WEEK_DAYS:
-        if (day != 6 && day != 7)
-          new_mode = true;
-        break;
-      default:
-        if (day == sched_days - 2)
-          new_mode = true;
-        break;
-      }
-    }
+        if (start <= now && end >= now) {
+            switch(sched_days) {
+            case EVERY_DAY:
+                new_mode = true;
+                break;
+            case WEEK_ENDS:
+                if (day == 6 || day == 7)
+                    new_mode = true;
+                break;
+            case WEEK_DAYS:
+                if (day != 6 && day != 7)
+                    new_mode = true;
+                break;
+            default:
+                if (day == sched_days - 2)
+                    new_mode = true;
+                break;
+            }
+        }
 
-    if (reverse)
-      new_mode = !new_mode;
+        if (reverse)
+            new_mode = !new_mode;
 
-    if (new_mode != alt_bw_enabled)
-      emit switchToAlternativeMode(new_mode);
+        if (new_mode != alt_bw_enabled)
+            emit switchToAlternativeMode(new_mode);
 
-    // Timeout regularly to accomodate for external system clock changes
-    // eg from the user or from a timesync utility
-    QTimer::start(1500);
-  }
+        // Timeout regularly to accomodate for external system clock changes
+        // eg from the user or from a timesync utility
+        QTimer::start(1500);
+    }
 
 signals:
-  void switchToAlternativeMode(bool alternative);
+    void switchToAlternativeMode(bool alternative);
 };
 
 #endif // BANDWIDTHSCHEDULER_H

src/core/qtlibtorrent/filterparserthread.cpp

@@ -41,290 +41,290 @@ FilterParserThread::FilterParserThread(QObject* parent, libtorrent::session *s)
 }
 
 FilterParserThread::~FilterParserThread() {
-  abort = true;
-  wait();
+    abort = true;
+    wait();
 }
 
 // Parser for eMule ip filter in DAT format
 int FilterParserThread::parseDATFilterFile(QString filePath, libtorrent::ip_filter& filter) {
-  int ruleCount = 0;
-  QFile file(filePath);
-  if (file.exists()) {
-    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-      std::cerr << "I/O Error: Could not open ip filer file in read mode." << std::endl;
-      return ruleCount;
-    }
-    unsigned int nbLine = 0;
-    while (!file.atEnd() && !abort) {
-      ++nbLine;
-      QByteArray line = file.readLine();
-      // Ignoring empty lines
-      line = line.trimmed();
-      if (line.isEmpty()) continue;
-      // Ignoring commented lines
-      if (line.startsWith('#') || line.startsWith("//")) continue;
+    int ruleCount = 0;
+    QFile file(filePath);
+    if (file.exists()) {
+        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            std::cerr << "I/O Error: Could not open ip filer file in read mode." << std::endl;
+            return ruleCount;
+        }
+        unsigned int nbLine = 0;
+        while (!file.atEnd() && !abort) {
+            ++nbLine;
+            QByteArray line = file.readLine();
+            // Ignoring empty lines
+            line = line.trimmed();
+            if (line.isEmpty()) continue;
+            // Ignoring commented lines
+            if (line.startsWith('#') || line.startsWith("//")) continue;
 
-      // Line should be splitted by commas
-      QList<QByteArray> partsList = line.split(',');
-      const uint nbElem = partsList.size();
+            // Line should be splitted by commas
+            QList<QByteArray> partsList = line.split(',');
+            const uint nbElem = partsList.size();
 
-      // IP Range should be splitted by a dash
-      QList<QByteArray> IPs = partsList.first().split('-');
-      if (IPs.size() != 2) {
-        qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
-        qDebug("Line was %s", line.constData());
-        continue;
-      }
+            // IP Range should be splitted by a dash
+            QList<QByteArray> IPs = partsList.first().split('-');
+            if (IPs.size() != 2) {
+                qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
+                qDebug("Line was %s", line.constData());
+                continue;
+            }
 
-      boost::system::error_code ec;
-      const QString strStartIP = cleanupIPAddress(IPs.at(0));
-      if (strStartIP.isEmpty()) {
-        qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
-        qDebug("Start IP of the range is malformated: %s", qPrintable(strStartIP));
-        continue;
-      }
-      libtorrent::address startAddr = libtorrent::address::from_string(qPrintable(strStartIP), ec);
-      if (ec) {
-        qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
-        qDebug("Start IP of the range is malformated: %s", qPrintable(strStartIP));
-        continue;
-      }
-      const QString strEndIP = cleanupIPAddress(IPs.at(1));
-      if (strEndIP.isEmpty()) {
-        qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
-        qDebug("End IP of the range is malformated: %s", qPrintable(strEndIP));
-        continue;
-      }
-      libtorrent::address endAddr = libtorrent::address::from_string(qPrintable(strEndIP), ec);
-      if (ec) {
-        qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
-        qDebug("End IP of the range is malformated: %s", qPrintable(strEndIP));
-        continue;
-      }
-      if (startAddr.is_v4() != endAddr.is_v4()) {
-        qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
-        qDebug("One IP is IPv4 and the other is IPv6!");
-        continue;
-      }
+            boost::system::error_code ec;
+            const QString strStartIP = cleanupIPAddress(IPs.at(0));
+            if (strStartIP.isEmpty()) {
+                qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
+                qDebug("Start IP of the range is malformated: %s", qPrintable(strStartIP));
+                continue;
+            }
+            libtorrent::address startAddr = libtorrent::address::from_string(qPrintable(strStartIP), ec);
+            if (ec) {
+                qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
+                qDebug("Start IP of the range is malformated: %s", qPrintable(strStartIP));
+                continue;
+            }
+            const QString strEndIP = cleanupIPAddress(IPs.at(1));
+            if (strEndIP.isEmpty()) {
+                qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
+                qDebug("End IP of the range is malformated: %s", qPrintable(strEndIP));
+                continue;
+            }
+            libtorrent::address endAddr = libtorrent::address::from_string(qPrintable(strEndIP), ec);
+            if (ec) {
+                qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
+                qDebug("End IP of the range is malformated: %s", qPrintable(strEndIP));
+                continue;
+            }
+            if (startAddr.is_v4() != endAddr.is_v4()) {
+                qDebug("Ipfilter.dat: line %d is malformed.", nbLine);
+                qDebug("One IP is IPv4 and the other is IPv6!");
+                continue;
+            }
 
-      // Check if there is an access value (apparently not mandatory)
-      int nbAccess = 0;
-      if (nbElem > 1) {
-        // There is possibly one
-        nbAccess = partsList.at(1).trimmed().toInt();
-      }
+            // Check if there is an access value (apparently not mandatory)
+            int nbAccess = 0;
+            if (nbElem > 1) {
+                // There is possibly one
+                nbAccess = partsList.at(1).trimmed().toInt();
+            }
 
-      if (nbAccess > 127) {
-        // Ignoring this rule because access value is too high
-        continue;
-      }
-      // Now Add to the filter
-      try {
-        filter.add_rule(startAddr, endAddr, libtorrent::ip_filter::blocked);
-        ++ruleCount;
-      }catch(exception) {
-        qDebug("Bad line in filter file, avoided crash...");
-      }
+            if (nbAccess > 127) {
+                // Ignoring this rule because access value is too high
+                continue;
+            }
+            // Now Add to the filter
+            try {
+                filter.add_rule(startAddr, endAddr, libtorrent::ip_filter::blocked);
+                ++ruleCount;
+            }catch(exception) {
+                qDebug("Bad line in filter file, avoided crash...");
+            }
+        }
+        file.close();
     }
-    file.close();
-  }
-  return ruleCount;
+    return ruleCount;
 }
 
 // Parser for PeerGuardian ip filter in p2p format
 int FilterParserThread::parseP2PFilterFile(QString filePath, libtorrent::ip_filter& filter) {
-  int ruleCount = 0;
-  QFile file(filePath);
-  if (file.exists()) {
-    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-      std::cerr << "I/O Error: Could not open ip filer file in read mode." << std::endl;
-      return ruleCount;
-    }
-    unsigned int nbLine = 0;
-    while (!file.atEnd() && !abort) {
-      ++nbLine;
-      QByteArray line = file.readLine().trimmed();
-      if (line.isEmpty()) continue;
-      // Ignoring commented lines
-      if (line.startsWith('#') || line.startsWith("//")) continue;
-      // Line is splitted by :
-      QList<QByteArray> partsList = line.split(':');
-      if (partsList.size() < 2) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        continue;
-      }
-      // Get IP range
-      QList<QByteArray> IPs = partsList.last().split('-');
-      if (IPs.size() != 2) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        qDebug("line was: %s", line.constData());
-        continue;
-      }
-      boost::system::error_code ec;
-      QString strStartIP = cleanupIPAddress(IPs.at(0));
-      if (strStartIP.isEmpty()) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        qDebug("Start IP is invalid: %s", qPrintable(strStartIP));
-        continue;
-      }
-      libtorrent::address startAddr = libtorrent::address::from_string(qPrintable(strStartIP), ec);
-      if (ec) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        qDebug("Start IP is invalid: %s", qPrintable(strStartIP));
-        continue;
-      }
-      QString strEndIP = cleanupIPAddress(IPs.at(1));
-      if (strEndIP.isEmpty()) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        qDebug("End IP is invalid: %s", qPrintable(strStartIP));
-        continue;
-      }
-      libtorrent::address endAddr = libtorrent::address::from_string(qPrintable(strEndIP), ec);
-      if (ec) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        qDebug("End IP is invalid: %s", qPrintable(strStartIP));
-        continue;
-      }
-      if (startAddr.is_v4() != endAddr.is_v4()) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        qDebug("Line was: %s", line.constData());
-        continue;
-      }
-      try {
-        filter.add_rule(startAddr, endAddr, libtorrent::ip_filter::blocked);
-        ++ruleCount;
-      } catch(std::exception&) {
-        qDebug("p2p file: line %d is malformed.", nbLine);
-        qDebug("Line was: %s", line.constData());
-        continue;
-      }
+    int ruleCount = 0;
+    QFile file(filePath);
+    if (file.exists()) {
+        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            std::cerr << "I/O Error: Could not open ip filer file in read mode." << std::endl;
+            return ruleCount;
+        }
+        unsigned int nbLine = 0;
+        while (!file.atEnd() && !abort) {
+            ++nbLine;
+            QByteArray line = file.readLine().trimmed();
+            if (line.isEmpty()) continue;
+            // Ignoring commented lines
+            if (line.startsWith('#') || line.startsWith("//")) continue;
+            // Line is splitted by :
+            QList<QByteArray> partsList = line.split(':');
+            if (partsList.size() < 2) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                continue;
+            }
+            // Get IP range
+            QList<QByteArray> IPs = partsList.last().split('-');
+            if (IPs.size() != 2) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                qDebug("line was: %s", line.constData());
+                continue;
+            }
+            boost::system::error_code ec;
+            QString strStartIP = cleanupIPAddress(IPs.at(0));
+            if (strStartIP.isEmpty()) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                qDebug("Start IP is invalid: %s", qPrintable(strStartIP));
+                continue;
+            }
+            libtorrent::address startAddr = libtorrent::address::from_string(qPrintable(strStartIP), ec);
+            if (ec) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                qDebug("Start IP is invalid: %s", qPrintable(strStartIP));
+                continue;
+            }
+            QString strEndIP = cleanupIPAddress(IPs.at(1));
+            if (strEndIP.isEmpty()) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                qDebug("End IP is invalid: %s", qPrintable(strStartIP));
+                continue;
+            }
+            libtorrent::address endAddr = libtorrent::address::from_string(qPrintable(strEndIP), ec);
+            if (ec) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                qDebug("End IP is invalid: %s", qPrintable(strStartIP));
+                continue;
+            }
+            if (startAddr.is_v4() != endAddr.is_v4()) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                qDebug("Line was: %s", line.constData());
+                continue;
+            }
+            try {
+                filter.add_rule(startAddr, endAddr, libtorrent::ip_filter::blocked);
+                ++ruleCount;
+            } catch(std::exception&) {
+                qDebug("p2p file: line %d is malformed.", nbLine);
+                qDebug("Line was: %s", line.constData());
+                continue;
+            }
+        }
+        file.close();
     }
-    file.close();
-  }
-  return ruleCount;
+    return ruleCount;
 }
 
 int FilterParserThread::getlineInStream(QDataStream& stream, string& name, char delim) {
-  char c;
-  int total_read = 0;
-  int read;
-  do {
-    read = stream.readRawData(&c, 1);
-    total_read += read;
-    if (read > 0) {
-      if (c != delim) {
-        name += c;
-      } else {
-        // Delim found
-        return total_read;
-      }
-    }
-  } while(read > 0);
-  return total_read;
+    char c;
+    int total_read = 0;
+    int read;
+    do {
+        read = stream.readRawData(&c, 1);
+        total_read += read;
+        if (read > 0) {
+            if (c != delim) {
+                name += c;
+            } else {
+                // Delim found
+                return total_read;
+            }
+        }
+    } while(read > 0);
+    return total_read;
 }
 
 // Parser for PeerGuardian ip filter in p2p format
 int FilterParserThread::parseP2BFilterFile(QString filePath, libtorrent::ip_filter& filter) {
-  int ruleCount = 0;
-  QFile file(filePath);
-  if (file.exists()) {
-    if (!file.open(QIODevice::ReadOnly)) {
-      std::cerr << "I/O Error: Could not open ip filer file in read mode." << std::endl;
-      return ruleCount;
-    }
-    QDataStream stream(&file);
-    // Read header
-    char buf[7];
-    unsigned char version;
-    if (
-        !stream.readRawData(buf, sizeof(buf)) ||
-        memcmp(buf, "\xFF\xFF\xFF\xFFP2B", 7) ||
-        !stream.readRawData((char*)&version, sizeof(version))
-        ) {
-      std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
-      return ruleCount;
-    }
-
-    if (version==1 || version==2) {
-      qDebug ("p2b version 1 or 2");
-      unsigned int start, end;
-
-      string name;
-      while(getlineInStream(stream, name, '\0') && !abort) {
+    int ruleCount = 0;
+    QFile file(filePath);
+    if (file.exists()) {
+        if (!file.open(QIODevice::ReadOnly)) {
+            std::cerr << "I/O Error: Could not open ip filer file in read mode." << std::endl;
+            return ruleCount;
+        }
+        QDataStream stream(&file);
+        // Read header
+        char buf[7];
+        unsigned char version;
         if (
-            !stream.readRawData((char*)&start, sizeof(start)) ||
-            !stream.readRawData((char*)&end, sizeof(end))
+            !stream.readRawData(buf, sizeof(buf)) ||
+            memcmp(buf, "\xFF\xFF\xFF\xFFP2B", 7) ||
+            !stream.readRawData((char*)&version, sizeof(version))
             ) {
-          std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
-          return ruleCount;
+            std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
+            return ruleCount;
         }
-        // Network byte order to Host byte order
-        // asio address_v4 contructor expects it
-        // that way
-        libtorrent::address_v4 first(ntohl(start));
-        libtorrent::address_v4 last(ntohl(end));
-        // Apply to bittorrent session
-        try {
-          filter.add_rule(first, last, libtorrent::ip_filter::blocked);
-          ++ruleCount;
-        } catch(std::exception&) {}
-      }
-    }
-    else if (version==3) {
-      qDebug ("p2b version 3");
-      unsigned int namecount;
-      if (!stream.readRawData((char*)&namecount, sizeof(namecount))) {
-        std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
-        return ruleCount;
-      }
-      namecount=ntohl(namecount);
-      // Reading names although, we don't really care about them
-      for (unsigned int i=0; i<namecount; i++) {
-        string name;
-        if (!getlineInStream(stream, name, '\0')) {
-          std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
-          return ruleCount;
+
+        if (version==1 || version==2) {
+            qDebug ("p2b version 1 or 2");
+            unsigned int start, end;
+
+            string name;
+            while(getlineInStream(stream, name, '\0') && !abort) {
+                if (
+                    !stream.readRawData((char*)&start, sizeof(start)) ||
+                    !stream.readRawData((char*)&end, sizeof(end))
+                    ) {
+                    std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
+                    return ruleCount;
+                }
+                // Network byte order to Host byte order
+                // asio address_v4 contructor expects it
+                // that way
+                libtorrent::address_v4 first(ntohl(start));
+                libtorrent::address_v4 last(ntohl(end));
+                // Apply to bittorrent session
+                try {
+                    filter.add_rule(first, last, libtorrent::ip_filter::blocked);
+                    ++ruleCount;
+                } catch(std::exception&) {}
+            }
         }
-        if (abort) return ruleCount;
-      }
-      // Reading the ranges
-      unsigned int rangecount;
-      if (!stream.readRawData((char*)&rangecount, sizeof(rangecount))) {
-        std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
-        return ruleCount;
-      }
-      rangecount=ntohl(rangecount);
+        else if (version==3) {
+            qDebug ("p2b version 3");
+            unsigned int namecount;
+            if (!stream.readRawData((char*)&namecount, sizeof(namecount))) {
+                std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
+                return ruleCount;
+            }
+            namecount=ntohl(namecount);
+            // Reading names although, we don't really care about them
+            for (unsigned int i=0; i<namecount; i++) {
+                string name;
+                if (!getlineInStream(stream, name, '\0')) {
+                    std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
+                    return ruleCount;
+                }
+                if (abort) return ruleCount;
+            }
+            // Reading the ranges
+            unsigned int rangecount;
+            if (!stream.readRawData((char*)&rangecount, sizeof(rangecount))) {
+                std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
+                return ruleCount;
+            }
+            rangecount=ntohl(rangecount);
 
-      unsigned int name, start, end;
+            unsigned int name, start, end;
 
-      for (unsigned int i=0; i<rangecount; i++) {
-        if (
-            !stream.readRawData((char*)&name, sizeof(name)) ||
-            !stream.readRawData((char*)&start, sizeof(start)) ||
-            !stream.readRawData((char*)&end, sizeof(end))
-            ) {
-          std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
-          return ruleCount;
+            for (unsigned int i=0; i<rangecount; i++) {
+                if (
+                    !stream.readRawData((char*)&name, sizeof(name)) ||
+                    !stream.readRawData((char*)&start, sizeof(start)) ||
+                    !stream.readRawData((char*)&end, sizeof(end))
+                    ) {
+                    std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
+                    return ruleCount;
+                }
+                // Network byte order to Host byte order
+                // asio address_v4 contructor expects it
+                // that way
+                libtorrent::address_v4 first(ntohl(start));
+                libtorrent::address_v4 last(ntohl(end));
+                // Apply to bittorrent session
+                try {
+                    filter.add_rule(first, last, libtorrent::ip_filter::blocked);
+                    ++ruleCount;
+                } catch(std::exception&) {}
+                if (abort) return ruleCount;
+            }
+        } else {
+            std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
+            return ruleCount;
         }
-        // Network byte order to Host byte order
-        // asio address_v4 contructor expects it
-        // that way
-        libtorrent::address_v4 first(ntohl(start));
-        libtorrent::address_v4 last(ntohl(end));
-        // Apply to bittorrent session
-        try {
-          filter.add_rule(first, last, libtorrent::ip_filter::blocked);
-          ++ruleCount;
-        } catch(std::exception&) {}
-        if (abort) return ruleCount;
-      }
-    } else {
-      std::cerr << "Parsing Error: The filter file is not a valid PeerGuardian P2B file." << std::endl;
-      return ruleCount;
+        file.close();
     }
-    file.close();
-  }
-  return ruleCount;
+    return ruleCount;
 }
 
 // Process ip filter file
@@ -333,62 +333,62 @@ int FilterParserThread::parseP2BFilterFile(QString filePath, libtorrent::ip_filt
 //  * PeerGuardian Text (P2P): http://wiki.phoenixlabs.org/wiki/P2P_Format
 //  * PeerGuardian Binary (P2B): http://wiki.phoenixlabs.org/wiki/P2B_Format
 void FilterParserThread::processFilterFile(QString _filePath) {
-  if (isRunning()) {
-    // Already parsing a filter, abort first
-    abort = true;
-    wait();
-  }
-  abort = false;
-  filePath = _filePath;
-  // Run it
-  start();
+    if (isRunning()) {
+        // Already parsing a filter, abort first
+        abort = true;
+        wait();
+    }
+    abort = false;
+    filePath = _filePath;
+    // Run it
+    start();
 }
 
 void FilterParserThread::processFilterList(libtorrent::session *s, const QStringList& IPs) {
-  // First, import current filter
-  libtorrent::ip_filter filter = s->get_ip_filter();
-  foreach (const QString &ip, IPs) {
-    qDebug("Manual ban of peer %s", ip.toLocal8Bit().constData());
-    boost::system::error_code ec;
-    libtorrent::address addr = libtorrent::address::from_string(ip.toLocal8Bit().constData(), ec);
-    Q_ASSERT(!ec);
-    if (!ec)
-      filter.add_rule(addr, addr, libtorrent::ip_filter::blocked);
-  }
-  s->set_ip_filter(filter);
+    // First, import current filter
+    libtorrent::ip_filter filter = s->get_ip_filter();
+    foreach (const QString &ip, IPs) {
+        qDebug("Manual ban of peer %s", ip.toLocal8Bit().constData());
+        boost::system::error_code ec;
+        libtorrent::address addr = libtorrent::address::from_string(ip.toLocal8Bit().constData(), ec);
+        Q_ASSERT(!ec);
+        if (!ec)
+            filter.add_rule(addr, addr, libtorrent::ip_filter::blocked);
+    }
+    s->set_ip_filter(filter);
 }
 
 QString FilterParserThread::cleanupIPAddress(QString _ip) {
-  QHostAddress ip(_ip.trimmed());
-  if (ip.isNull()) {
-    return QString();
-  }
-  return ip.toString();
+    QHostAddress ip(_ip.trimmed());
+    if (ip.isNull()) {
+        return QString();
+    }
+    return ip.toString();
 }
 
 void FilterParserThread::run() {
-  qDebug("Processing filter file");
-  libtorrent::ip_filter filter = s->get_ip_filter();
-  int ruleCount = 0;
-  if (filePath.endsWith(".p2p", Qt::CaseInsensitive)) {
-    // PeerGuardian p2p file
-    ruleCount = parseP2PFilterFile(filePath, filter);
-  } else {
-    if (filePath.endsWith(".p2b", Qt::CaseInsensitive)) {
-      // PeerGuardian p2b file
-      ruleCount = parseP2BFilterFile(filePath, filter);
+    qDebug("Processing filter file");
+    libtorrent::ip_filter filter = s->get_ip_filter();
+    int ruleCount = 0;
+    if (filePath.endsWith(".p2p", Qt::CaseInsensitive)) {
+        // PeerGuardian p2p file
+        ruleCount = parseP2PFilterFile(filePath, filter);
     } else {
-      // Default: eMule DAT format
-      ruleCount = parseDATFilterFile(filePath, filter);
+        if (filePath.endsWith(".p2b", Qt::CaseInsensitive)) {
+            // PeerGuardian p2b file
+            ruleCount = parseP2BFilterFile(filePath, filter);
+        } else {
+            // Default: eMule DAT format
+            ruleCount = parseDATFilterFile(filePath, filter);
+        }
     }
-  }
-  if (abort)
-    return;
-  try {
-    s->set_ip_filter(filter);
-    emit IPFilterParsed(ruleCount);
-  } catch(std::exception&) {
-    emit IPFilterError();
-  }
-  qDebug("IP Filter thread: finished parsing, filter applied");
+    if (abort)
+        return;
+    try {
+        s->set_ip_filter(filter);
+        emit IPFilterParsed(ruleCount);
+    } catch(std::exception&) {
+        emit IPFilterError();
+    }
+    qDebug("IP Filter thread: finished parsing, filter applied");
 }

src/core/qtlibtorrent/filterparserthread.h

@@ -36,8 +36,8 @@
 #include <QStringList>
 
 namespace libtorrent {
-  class session;
-  struct ip_filter;
+class session;
+struct ip_filter;
 }
 
 using namespace std;
@@ -52,31 +52,31 @@ using namespace std;
 // End of P2B stuff
 
 class FilterParserThread : public QThread  {
-  Q_OBJECT
+    Q_OBJECT
 
 public:
-  FilterParserThread(QObject* parent, libtorrent::session *s);
-  ~FilterParserThread();
+    FilterParserThread(QObject* parent, libtorrent::session *s);
+    ~FilterParserThread();
 
-  int parseDATFilterFile(QString filePath, libtorrent::ip_filter& filter);
-  int parseP2PFilterFile(QString filePath, libtorrent::ip_filter& filter);
-  int getlineInStream(QDataStream& stream, string& name, char delim);
-  int parseP2BFilterFile(QString filePath, libtorrent::ip_filter& filter);
-  void processFilterFile(QString _filePath);
-  static void processFilterList(libtorrent::session *s, const QStringList& IPs);
+    int parseDATFilterFile(QString filePath, libtorrent::ip_filter& filter);
+    int parseP2PFilterFile(QString filePath, libtorrent::ip_filter& filter);
+    int getlineInStream(QDataStream& stream, string& name, char delim);
+    int parseP2BFilterFile(QString filePath, libtorrent::ip_filter& filter);
+    void processFilterFile(QString _filePath);
+    static void processFilterList(libtorrent::session *s, const QStringList& IPs);
 
 signals:
-  void IPFilterParsed(int ruleCount);
-  void IPFilterError();
+    void IPFilterParsed(int ruleCount);
+    void IPFilterError();
 
 protected:
-  QString cleanupIPAddress(QString _ip);
-  void run();
+    QString cleanupIPAddress(QString _ip);
+    void run();
 
 private:
-  libtorrent::session *s;
-  bool abort;
-  QString filePath;
+    libtorrent::session *s;
+    bool abort;
+    QString filePath;
 };
 
 #endif

src/core/qtlibtorrent/qbtsession.h

@@ -49,42 +49,42 @@
 #endif
 
 namespace libtorrent {
-  struct add_torrent_params;
-  struct pe_settings;
-  struct proxy_settings;
-  class session;
-  struct session_status;
+struct add_torrent_params;
+struct pe_settings;
+struct proxy_settings;
+class session;
+struct session_status;
 
-  class alert;
-  struct torrent_finished_alert;
-  struct save_resume_data_alert;
-  struct file_renamed_alert;
-  struct torrent_deleted_alert;
-  struct storage_moved_alert;
-  struct storage_moved_failed_alert;
-  struct metadata_received_alert;
-  struct file_error_alert;
-  struct file_completed_alert;
-  struct torrent_paused_alert;
-  struct tracker_error_alert;
-  struct tracker_reply_alert;
-  struct tracker_warning_alert;
-  struct portmap_error_alert;
-  struct portmap_alert;
-  struct peer_blocked_alert;
-  struct peer_ban_alert;
-  struct fastresume_rejected_alert;
-  struct url_seed_alert;
-  struct listen_succeeded_alert;
-  struct listen_failed_alert;
-  struct torrent_checked_alert;
-  struct external_ip_alert;
-  struct state_update_alert;
-  struct stats_alert;
+class alert;
+struct torrent_finished_alert;
+struct save_resume_data_alert;
+struct file_renamed_alert;
+struct torrent_deleted_alert;
+struct storage_moved_alert;
+struct storage_moved_failed_alert;
+struct metadata_received_alert;
+struct file_error_alert;
+struct file_completed_alert;
+struct torrent_paused_alert;
+struct tracker_error_alert;
+struct tracker_reply_alert;
+struct tracker_warning_alert;
+struct portmap_error_alert;
+struct portmap_alert;
+struct peer_blocked_alert;
+struct peer_ban_alert;
+struct fastresume_rejected_alert;
+struct url_seed_alert;
+struct listen_succeeded_alert;
+struct listen_failed_alert;
+struct torrent_checked_alert;
+struct external_ip_alert;
+struct state_update_alert;
+struct stats_alert;
 
 #if LIBTORRENT_VERSION_NUM < 10000
-  class upnp;
-  class natpmp;
+class upnp;
+class natpmp;
 #endif
 }
 
@@ -97,250 +97,250 @@ class TorrentStatistics;
 class QAlertDispatcher;
 
 enum TorrentExportFolder {
-  RegularTorrentExportFolder,
-  FinishedTorrentExportFolder
+    RegularTorrentExportFolder,
+    FinishedTorrentExportFolder
 };
 
 class QTracker;
 
 class QBtSession : public QObject {
-  Q_OBJECT
-  Q_DISABLE_COPY(QBtSession)
+    Q_OBJECT
+    Q_DISABLE_COPY(QBtSession)
 
 public:
-  static const qreal MAX_RATIO;
+    static const qreal MAX_RATIO;
 
 private:
-  explicit QBtSession();
-  static QBtSession* m_instance;
+    explicit QBtSession();
+    static QBtSession* m_instance;
 
 public:
-  static QBtSession* instance();
-  static void drop();
-  ~QBtSession();
-  QTorrentHandle getTorrentHandle(const QString &hash) const;
-  std::vector<libtorrent::torrent_handle> getTorrents() const;
-  bool isFilePreviewPossible(const QString& hash) const;
-  qreal getPayloadDownloadRate() const;
-  qreal getPayloadUploadRate() const;
-  libtorrent::session_status getSessionStatus() const;
-  int getListenPort() const;
-  qreal getRealRatio(const libtorrent::torrent_status &status) const;
-  QHash<QString, TrackerInfos> getTrackersInfo(const QString &hash) const;
-  bool hasActiveTorrents() const;
-  bool hasDownloadingTorrents() const;
-  //int getMaximumActiveDownloads() const;
-  //int getMaximumActiveTorrents() const;
-  inline libtorrent::session* getSession() const { return s; }
-  inline bool useTemporaryFolder() const { return !defaultTempPath.isEmpty(); }
-  inline QString getDefaultSavePath() const { return defaultSavePath; }
-  inline ScanFoldersModel* getScanFoldersModel() const {  return m_scanFolders; }
-  inline bool isDHTEnabled() const { return DHTEnabled; }
-  inline bool isLSDEnabled() const { return LSDEnabled; }
-  inline bool isPexEnabled() const { return PeXEnabled; }
-  inline bool isQueueingEnabled() const { return queueingEnabled; }
-  quint64 getAlltimeDL() const;
-  quint64 getAlltimeUL() const;
-  void postTorrentUpdate();
+    static QBtSession* instance();
+    static void drop();
+    ~QBtSession();
+    QTorrentHandle getTorrentHandle(const QString &hash) const;
+    std::vector<libtorrent::torrent_handle> getTorrents() const;
+    bool isFilePreviewPossible(const QString& hash) const;
+    qreal getPayloadDownloadRate() const;
+    qreal getPayloadUploadRate() const;
+    libtorrent::session_status getSessionStatus() const;
+    int getListenPort() const;
+    qreal getRealRatio(const libtorrent::torrent_status &status) const;
+    QHash<QString, TrackerInfos> getTrackersInfo(const QString &hash) const;
+    bool hasActiveTorrents() const;
+    bool hasDownloadingTorrents() const;
+    //int getMaximumActiveDownloads() const;
+    //int getMaximumActiveTorrents() const;
+    inline libtorrent::session* getSession() const { return s; }
+    inline bool useTemporaryFolder() const { return !defaultTempPath.isEmpty(); }
+    inline QString getDefaultSavePath() const { return defaultSavePath; }
+    inline ScanFoldersModel* getScanFoldersModel() const {  return m_scanFolders; }
+    inline bool isDHTEnabled() const { return DHTEnabled; }
+    inline bool isLSDEnabled() const { return LSDEnabled; }
+    inline bool isPexEnabled() const { return PeXEnabled; }
+    inline bool isQueueingEnabled() const { return queueingEnabled; }
+    quint64 getAlltimeDL() const;
+    quint64 getAlltimeUL() const;
+    void postTorrentUpdate();
 
 public slots:
-  QTorrentHandle addTorrent(QString path, bool fromScanDir = false, QString from_url = QString(), bool resumed = false, bool imported = false);
-  QTorrentHandle addMagnetUri(QString magnet_uri, bool resumed=false, bool fromScanDir=false, const QString &filePath=QString());
-  void loadSessionState();
-  void saveSessionState();
-  void downloadFromUrl(const QString &url, const QList<QNetworkCookie>& cookies = QList<QNetworkCookie>());
-  void deleteTorrent(const QString &hash, bool delete_local_files = false);
-  void startUpTorrents();
-  void recheckTorrent(const QString &hash);
-  void useAlternativeSpeedsLimit(bool alternative);
-  qlonglong getETA(const QString& hash, const libtorrent::torrent_status &status) const;
-  /* Needed by Web UI */
-  void pauseAllTorrents();
-  void pauseTorrent(const QString &hash);
-  void resumeTorrent(const QString &hash);
-  void resumeAllTorrents();
-  /* End Web UI */
-  void preAllocateAllFiles(bool b);
-  void saveFastResumeData();
-  void enableIPFilter(const QString &filter_path, bool force=false);
-  void disableIPFilter();
-  void setQueueingEnabled(bool enable);
-  void handleDownloadFailure(QString url, QString reason);
-  void handleMagnetRedirect(const QString &url_new, const QString &url_old);
+    QTorrentHandle addTorrent(QString path, bool fromScanDir = false, QString from_url = QString(), bool resumed = false, bool imported = false);
+    QTorrentHandle addMagnetUri(QString magnet_uri, bool resumed=false, bool fromScanDir=false, const QString &filePath=QString());
+    void loadSessionState();
+    void saveSessionState();
+    void downloadFromUrl(const QString &url, const QList<QNetworkCookie>& cookies = QList<QNetworkCookie>());
+    void deleteTorrent(const QString &hash, bool delete_local_files = false);
+    void startUpTorrents();
+    void recheckTorrent(const QString &hash);
+    void useAlternativeSpeedsLimit(bool alternative);
+    qlonglong getETA(const QString& hash, const libtorrent::torrent_status &status) const;
+    /* Needed by Web UI */
+    void pauseAllTorrents();
+    void pauseTorrent(const QString &hash);
+    void resumeTorrent(const QString &hash);
+    void resumeAllTorrents();
+    /* End Web UI */
+    void preAllocateAllFiles(bool b);
+    void saveFastResumeData();
+    void enableIPFilter(const QString &filter_path, bool force=false);
+    void disableIPFilter();
+    void setQueueingEnabled(bool enable);
+    void handleDownloadFailure(QString url, QString reason);
+    void handleMagnetRedirect(const QString &url_new, const QString &url_old);
 #ifndef DISABLE_GUI
-  void downloadUrlAndSkipDialog(QString url, QString save_path=QString(), QString label=QString(),
-                                const QList<QNetworkCookie>& cookies = QList<QNetworkCookie>(),
-                                const RssDownloadRule::AddPausedState &aps = RssDownloadRule::USE_GLOBAL);
+    void downloadUrlAndSkipDialog(QString url, QString save_path=QString(), QString label=QString(),
+                                  const QList<QNetworkCookie>& cookies = QList<QNetworkCookie>(),
+                                  const RssDownloadRule::AddPausedState &aps = RssDownloadRule::USE_GLOBAL);
 #else
-  void downloadUrlAndSkipDialog(QString url, QString save_path=QString(), QString label=QString(),
-                                const QList<QNetworkCookie>& cookies = QList<QNetworkCookie>());
+    void downloadUrlAndSkipDialog(QString url, QString save_path=QString(), QString label=QString(),
+                                  const QList<QNetworkCookie>& cookies = QList<QNetworkCookie>());
 #endif
-  // Session configuration - Setters
-  void setListeningPort(int port);
-  void setMaxConnectionsPerTorrent(int max);
-  void setMaxUploadsPerTorrent(int max);
-  void setDownloadRateLimit(long rate);
-  void setUploadRateLimit(long rate);
-  void setGlobalMaxRatio(qreal ratio);
-  qreal getGlobalMaxRatio() const { return global_ratio_limit; }
-  void setMaxRatioPerTorrent(const QString &hash, qreal ratio);
-  qreal getMaxRatioPerTorrent(const QString &hash, bool *usesGlobalRatio) const;
-  void removeRatioPerTorrent(const QString &hash);
-  void setDefaultSavePath(const QString &savepath);
-  void setDefaultTempPath(const QString &temppath);
-  void setAppendLabelToSavePath(bool append);
-  void appendLabelToTorrentSavePath(const QTorrentHandle &h);
-  void changeLabelInTorrentSavePath(const QTorrentHandle &h, QString old_label, QString new_label);
-  void appendqBextensionToTorrent(const QTorrentHandle &h, bool append);
-  void setAppendqBExtension(bool append);
-  void setDownloadLimit(QString hash, long val);
-  void setUploadLimit(QString hash, long val);
-  void enableUPnP(bool b);
-  void enableLSD(bool b);
-  void enableDHT(bool b);
-  void processDownloadedFile(QString, QString);
+    // Session configuration - Setters
+    void setListeningPort(int port);
+    void setMaxConnectionsPerTorrent(int max);
+    void setMaxUploadsPerTorrent(int max);
+    void setDownloadRateLimit(long rate);
+    void setUploadRateLimit(long rate);
+    void setGlobalMaxRatio(qreal ratio);
+    qreal getGlobalMaxRatio() const { return global_ratio_limit; }
+    void setMaxRatioPerTorrent(const QString &hash, qreal ratio);
+    qreal getMaxRatioPerTorrent(const QString &hash, bool *usesGlobalRatio) const;
+    void removeRatioPerTorrent(const QString &hash);
+    void setDefaultSavePath(const QString &savepath);
+    void setDefaultTempPath(const QString &temppath);
+    void setAppendLabelToSavePath(bool append);
+    void appendLabelToTorrentSavePath(const QTorrentHandle &h);
+    void changeLabelInTorrentSavePath(const QTorrentHandle &h, QString old_label, QString new_label);
+    void appendqBextensionToTorrent(const QTorrentHandle &h, bool append);
+    void setAppendqBExtension(bool append);
+    void setDownloadLimit(QString hash, long val);
+    void setUploadLimit(QString hash, long val);
+    void enableUPnP(bool b);
+    void enableLSD(bool b);
+    void enableDHT(bool b);
+    void processDownloadedFile(QString, QString);
 #ifndef DISABLE_GUI
-  void addMagnetSkipAddDlg(const QString& uri, const QString& save_path = QString(), const QString& label = QString(),
-                           const RssDownloadRule::AddPausedState &aps = RssDownloadRule::USE_GLOBAL, const QString &uri_old = QString());
+    void addMagnetSkipAddDlg(const QString& uri, const QString& save_path = QString(), const QString& label = QString(),
+                             const RssDownloadRule::AddPausedState &aps = RssDownloadRule::USE_GLOBAL, const QString &uri_old = QString());
 #else
-   void addMagnetSkipAddDlg(const QString& uri, const QString& save_path = QString(), const QString& label = QString(), const QString &uri_old = QString());
+    void addMagnetSkipAddDlg(const QString& uri, const QString& save_path = QString(), const QString& label = QString(), const QString &uri_old = QString());
 #endif
-  void addMagnetInteractive(const QString& uri);
-  void downloadFromURLList(const QStringList& urls);
-  void banIP(QString ip);
-  void recursiveTorrentDownload(const QTorrentHandle &h);
-  void unhideMagnet(const QString &hash);
+    void addMagnetInteractive(const QString& uri);
+    void downloadFromURLList(const QStringList& urls);
+    void banIP(QString ip);
+    void recursiveTorrentDownload(const QTorrentHandle &h);
+    void unhideMagnet(const QString &hash);
 
 private:
-  void applyEncryptionSettings(libtorrent::pe_settings se);
-  void setProxySettings(libtorrent::proxy_settings proxySettings);
-  void setSessionSettings(const libtorrent::session_settings &sessionSettings);
-  QString getSavePath(const QString &hash, bool fromScanDir = false, QString filePath = QString::null, bool imported = false);
-  bool loadFastResumeData(const QString &hash, std::vector<char> &buf);
-  void loadTorrentSettings(QTorrentHandle &h);
-  void loadTorrentTempData(QTorrentHandle &h, QString savePath, bool magnet);
-  void initializeAddTorrentParams(const QString &hash, libtorrent::add_torrent_params &p);
-  void updateRatioTimer();
-  void recoverPersistentData(const QString &hash, const std::vector<char> &buf);
-  void backupPersistentData(const QString &hash, boost::shared_ptr<libtorrent::entry> data);
-  void handleAlert(libtorrent::alert* a);
-  void handleTorrentFinishedAlert(libtorrent::torrent_finished_alert* p);
-  void handleSaveResumeDataAlert(libtorrent::save_resume_data_alert* p);
-  void handleFileRenamedAlert(libtorrent::file_renamed_alert* p);
-  void handleTorrentDeletedAlert(libtorrent::torrent_deleted_alert* p);
-  void handleStorageMovedAlert(libtorrent::storage_moved_alert* p);
-  void handleStorageMovedFailedAlert(libtorrent::storage_moved_failed_alert* p);
-  void handleMetadataReceivedAlert(libtorrent::metadata_received_alert* p);
-  void handleFileErrorAlert(libtorrent::file_error_alert* p);
-  void handleFileCompletedAlert(libtorrent::file_completed_alert* p);
-  void handleTorrentPausedAlert(libtorrent::torrent_paused_alert* p);
-  void handleTrackerErrorAlert(libtorrent::tracker_error_alert* p);
-  void handleTrackerReplyAlert(libtorrent::tracker_reply_alert* p);
-  void handleTrackerWarningAlert(libtorrent::tracker_warning_alert* p);
-  void handlePortmapWarningAlert(libtorrent::portmap_error_alert* p);
-  void handlePortmapAlert(libtorrent::portmap_alert* p);
-  void handlePeerBlockedAlert(libtorrent::peer_blocked_alert* p);
-  void handlePeerBanAlert(libtorrent::peer_ban_alert* p);
-  void handleFastResumeRejectedAlert(libtorrent::fastresume_rejected_alert* p);
-  void handleUrlSeedAlert(libtorrent::url_seed_alert* p);
-  void handleListenSucceededAlert(libtorrent::listen_succeeded_alert *p);
-  void handleListenFailedAlert(libtorrent::listen_failed_alert *p);
-  void handleTorrentCheckedAlert(libtorrent::torrent_checked_alert* p);
-  void handleExternalIPAlert(libtorrent::external_ip_alert *p);
-  void handleStateUpdateAlert(libtorrent::state_update_alert *p);
-  void handleStatsAlert(libtorrent::stats_alert *p);
+    void applyEncryptionSettings(libtorrent::pe_settings se);
+    void setProxySettings(libtorrent::proxy_settings proxySettings);
+    void setSessionSettings(const libtorrent::session_settings &sessionSettings);
+    QString getSavePath(const QString &hash, bool fromScanDir = false, QString filePath = QString::null, bool imported = false);
+    bool loadFastResumeData(const QString &hash, std::vector<char> &buf);
+    void loadTorrentSettings(QTorrentHandle &h);
+    void loadTorrentTempData(QTorrentHandle &h, QString savePath, bool magnet);
+    void initializeAddTorrentParams(const QString &hash, libtorrent::add_torrent_params &p);
+    void updateRatioTimer();
+    void recoverPersistentData(const QString &hash, const std::vector<char> &buf);
+    void backupPersistentData(const QString &hash, boost::shared_ptr<libtorrent::entry> data);
+    void handleAlert(libtorrent::alert* a);
+    void handleTorrentFinishedAlert(libtorrent::torrent_finished_alert* p);
+    void handleSaveResumeDataAlert(libtorrent::save_resume_data_alert* p);
+    void handleFileRenamedAlert(libtorrent::file_renamed_alert* p);
+    void handleTorrentDeletedAlert(libtorrent::torrent_deleted_alert* p);
+    void handleStorageMovedAlert(libtorrent::storage_moved_alert* p);
+    void handleStorageMovedFailedAlert(libtorrent::storage_moved_failed_alert* p);
+    void handleMetadataReceivedAlert(libtorrent::metadata_received_alert* p);
+    void handleFileErrorAlert(libtorrent::file_error_alert* p);
+    void handleFileCompletedAlert(libtorrent::file_completed_alert* p);
+    void handleTorrentPausedAlert(libtorrent::torrent_paused_alert* p);
+    void handleTrackerErrorAlert(libtorrent::tracker_error_alert* p);
+    void handleTrackerReplyAlert(libtorrent::tracker_reply_alert* p);
+    void handleTrackerWarningAlert(libtorrent::tracker_warning_alert* p);
+    void handlePortmapWarningAlert(libtorrent::portmap_error_alert* p);
+    void handlePortmapAlert(libtorrent::portmap_alert* p);
+    void handlePeerBlockedAlert(libtorrent::peer_blocked_alert* p);
+    void handlePeerBanAlert(libtorrent::peer_ban_alert* p);
+    void handleFastResumeRejectedAlert(libtorrent::fastresume_rejected_alert* p);
+    void handleUrlSeedAlert(libtorrent::url_seed_alert* p);
+    void handleListenSucceededAlert(libtorrent::listen_succeeded_alert *p);
+    void handleListenFailedAlert(libtorrent::listen_failed_alert *p);
+    void handleTorrentCheckedAlert(libtorrent::torrent_checked_alert* p);
+    void handleExternalIPAlert(libtorrent::external_ip_alert *p);
+    void handleStateUpdateAlert(libtorrent::state_update_alert *p);
+    void handleStatsAlert(libtorrent::stats_alert *p);
 
 private slots:
-  void addTorrentsFromScanFolder(QStringList&);
-  void readAlerts();
-  void processBigRatios();
-  void exportTorrentFiles(QString path);
-  void saveTempFastResumeData();
-  void sendNotificationEmail(const QTorrentHandle &h);
-  void autoRunExternalProgram(const QTorrentHandle &h);
-  void mergeTorrents(QTorrentHandle& h_ex, boost::intrusive_ptr<libtorrent::torrent_info> t);
-  void mergeTorrents(QTorrentHandle& h_ex, const QString& magnet_uri);
-  void exportTorrentFile(const QTorrentHandle &h, TorrentExportFolder folder = RegularTorrentExportFolder);
-  void handleIPFilterParsed(int ruleCount);
-  void handleIPFilterError();
-  void configureSession();
+    void addTorrentsFromScanFolder(QStringList&);
+    void readAlerts();
+    void processBigRatios();
+    void exportTorrentFiles(QString path);
+    void saveTempFastResumeData();
+    void sendNotificationEmail(const QTorrentHandle &h);
+    void autoRunExternalProgram(const QTorrentHandle &h);
+    void mergeTorrents(QTorrentHandle& h_ex, boost::intrusive_ptr<libtorrent::torrent_info> t);
+    void mergeTorrents(QTorrentHandle& h_ex, const QString& magnet_uri);
+    void exportTorrentFile(const QTorrentHandle &h, TorrentExportFolder folder = RegularTorrentExportFolder);
+    void handleIPFilterParsed(int ruleCount);
+    void handleIPFilterError();
+    void configureSession();
 
 signals:
-  void addedTorrent(const QTorrentHandle& h);
-  void torrentAboutToBeRemoved(const QTorrentHandle &h);
-  void pausedTorrent(const QTorrentHandle& h);
-  void resumedTorrent(const QTorrentHandle& h);
-  void finishedTorrent(const QTorrentHandle& h);
-  void fullDiskError(const QTorrentHandle& h, QString msg);
-  void trackerError(const QString &hash, QString time, QString msg);
-  void trackerAuthenticationRequired(const QTorrentHandle& h);
-  void newDownloadedTorrent(QString path, QString url);
-  void newDownloadedTorrentFromRss(QString url);
-  void newMagnetLink(const QString& link);
-  void updateFileSize(const QString &hash);
-  void downloadFromUrlFailure(QString url, QString reason);
-  void torrentFinishedChecking(const QTorrentHandle& h);
-  void metadataReceived(const QTorrentHandle &h);
-  void savePathChanged(const QTorrentHandle &h);
-  void alternativeSpeedsModeChanged(bool alternative);
-  void recursiveTorrentDownloadPossible(const QTorrentHandle &h);
-  void ipFilterParsed(bool error, int ruleCount);
-  void metadataReceivedHidden(const QTorrentHandle &h);
-  void stateUpdate(const std::vector<libtorrent::torrent_status> &statuses);
-  void statsReceived(const libtorrent::stats_alert&);
+    void addedTorrent(const QTorrentHandle& h);
+    void torrentAboutToBeRemoved(const QTorrentHandle &h);
+    void pausedTorrent(const QTorrentHandle& h);
+    void resumedTorrent(const QTorrentHandle& h);
+    void finishedTorrent(const QTorrentHandle& h);
+    void fullDiskError(const QTorrentHandle& h, QString msg);
+    void trackerError(const QString &hash, QString time, QString msg);
+    void trackerAuthenticationRequired(const QTorrentHandle& h);
+    void newDownloadedTorrent(QString path, QString url);
+    void newDownloadedTorrentFromRss(QString url);
+    void newMagnetLink(const QString& link);
+    void updateFileSize(const QString &hash);
+    void downloadFromUrlFailure(QString url, QString reason);
+    void torrentFinishedChecking(const QTorrentHandle& h);
+    void metadataReceived(const QTorrentHandle &h);
+    void savePathChanged(const QTorrentHandle &h);
+    void alternativeSpeedsModeChanged(bool alternative);
+    void recursiveTorrentDownloadPossible(const QTorrentHandle &h);
+    void ipFilterParsed(bool error, int ruleCount);
+    void metadataReceivedHidden(const QTorrentHandle &h);
+    void stateUpdate(const std::vector<libtorrent::torrent_status> &statuses);
+    void statsReceived(const libtorrent::stats_alert&);
 
 private:
-  // Bittorrent
-  libtorrent::session *s;
-  QPointer<BandwidthScheduler> bd_scheduler;
-  QMap<QUrl, QPair<QString, QString> > savepathLabel_fromurl; // Use QMap for compatibility with Qt < 4.7: qHash(QUrl)
+    // Bittorrent
+    libtorrent::session *s;
+    QPointer<BandwidthScheduler> bd_scheduler;
+    QMap<QUrl, QPair<QString, QString> > savepathLabel_fromurl; // Use QMap for compatibility with Qt < 4.7: qHash(QUrl)
 #ifndef DISABLE_GUI
-  QMap<QUrl, RssDownloadRule::AddPausedState> addpaused_fromurl;
+    QMap<QUrl, RssDownloadRule::AddPausedState> addpaused_fromurl;
 #endif
-  QHash<QString, QHash<QString, TrackerInfos> > trackersInfos;
-  QHash<QString, QString> savePathsToRemove;
-  QStringList torrentsToPausedAfterChecking;
-  QTimer resumeDataTimer;
-  // Ratio
-  QPointer<QTimer> BigRatioTimer;
-  // HTTP
-  DownloadThread* downloader;
-  // File System
-  ScanFoldersModel *m_scanFolders;
-  // Settings
-  bool preAllocateAll;
-  qreal global_ratio_limit;
-  int high_ratio_action;
-  bool LSDEnabled;
-  bool DHTEnabled;
-  bool PeXEnabled;
-  bool queueingEnabled;
-  bool appendLabelToSavePath;
-  bool m_torrentExportEnabled;
-  bool m_finishedTorrentExportEnabled;
-  bool appendqBExtension;
-  QString defaultSavePath;
-  QString defaultTempPath;
-  // IP filtering
-  QPointer<FilterParserThread> filterParser;
-  QString filterPath;
-  QList<QUrl> url_skippingDlg;
-  // GeoIP
+    QHash<QString, QHash<QString, TrackerInfos> > trackersInfos;
+    QHash<QString, QString> savePathsToRemove;
+    QStringList torrentsToPausedAfterChecking;
+    QTimer resumeDataTimer;
+    // Ratio
+    QPointer<QTimer> BigRatioTimer;
+    // HTTP
+    DownloadThread* downloader;
+    // File System
+    ScanFoldersModel *m_scanFolders;
+    // Settings
+    bool preAllocateAll;
+    qreal global_ratio_limit;
+    int high_ratio_action;
+    bool LSDEnabled;
+    bool DHTEnabled;
+    bool PeXEnabled;
+    bool queueingEnabled;
+    bool appendLabelToSavePath;
+    bool m_torrentExportEnabled;
+    bool m_finishedTorrentExportEnabled;
+    bool appendqBExtension;
+    QString defaultSavePath;
+    QString defaultTempPath;
+    // IP filtering
+    QPointer<FilterParserThread> filterParser;
+    QString filterPath;
+    QList<QUrl> url_skippingDlg;
+    // GeoIP
 #ifndef DISABLE_GUI
-  bool geoipDBLoaded;
-  bool resolve_countries;
+    bool geoipDBLoaded;
+    bool resolve_countries;
 #endif
-  // Tracker
-  QPointer<QTracker> m_tracker;
-  TorrentSpeedMonitor *m_speedMonitor;
-  shutDownAction m_shutdownAct;
-  // Port forwarding
+    // Tracker
+    QPointer<QTracker> m_tracker;
+    TorrentSpeedMonitor *m_speedMonitor;
+    shutDownAction m_shutdownAct;
+    // Port forwarding
 #if LIBTORRENT_VERSION_NUM < 10000
-  libtorrent::upnp *m_upnp;
-  libtorrent::natpmp *m_natpmp;
+    libtorrent::upnp *m_upnp;
+    libtorrent::natpmp *m_natpmp;
 #endif
-  QAlertDispatcher* m_alertDispatcher;
-  TorrentStatistics* m_torrentStatistics;
+    QAlertDispatcher* m_alertDispatcher;
+    TorrentStatistics* m_torrentStatistics;
 };
 
 #endif

src/core/qtlibtorrent/qtorrenthandle.cpp

@@ -182,7 +182,7 @@ bool QTorrentHandle::first_last_piece_first() const
     QPair<int, int> extremities = get_file_extremity_pieces(*t, index);
 
     return (torrent_handle::piece_priority(extremities.first) == 7)
-           && (torrent_handle::piece_priority(extremities.second) == 7);
+            && (torrent_handle::piece_priority(extremities.second) == 7);
 }
 
 QString QTorrentHandle::save_path() const
@@ -512,7 +512,7 @@ void QTorrentHandle::pause() const
     torrent_handle::auto_managed(false);
     torrent_handle::pause();
     if (!TorrentPersistentData::instance()->getHasMissingFiles(this->hash()))
-      torrent_handle::save_resume_data();
+        torrent_handle::save_resume_data();
 }
 
 void QTorrentHandle::resume() const
@@ -770,13 +770,13 @@ bool QTorrentHandle::is_queued(const libtorrent::torrent_status &status)
 bool QTorrentHandle::is_seed(const libtorrent::torrent_status &status)
 {
     return status.state == torrent_status::finished
-           || status.state == torrent_status::seeding;
+            || status.state == torrent_status::seeding;
 }
 
 bool QTorrentHandle::is_checking(const libtorrent::torrent_status &status)
 {
     return status.state == torrent_status::checking_files
-           || status.state == torrent_status::checking_resume_data;
+            || status.state == torrent_status::checking_resume_data;
 }
 
 bool QTorrentHandle::has_error(const libtorrent::torrent_status &status)

src/core/qtlibtorrent/shutdownconfirm.cpp

@@ -35,80 +35,80 @@
 #include <QPushButton>
 
 ShutdownConfirmDlg::ShutdownConfirmDlg(const shutDownAction &action): exit_now(NULL), timeout(15), action0(action) {
-  // Title and button
-  if (action0 == NO_SHUTDOWN) {
-    setWindowTitle(tr("Exit confirmation"));
-    exit_now = addButton(tr("Exit now"), QMessageBox::AcceptRole);
-  }
-  else {
-    setWindowTitle(tr("Shutdown confirmation"));
-    exit_now = addButton(tr("Shutdown now"), QMessageBox::AcceptRole);
-  }
-  // Cancel Button
-  addButton(QMessageBox::Cancel);
-  // Text
-  updateText();
-  // Icon
-  setIcon(QMessageBox::Warning);
-  // Always on top
-  setWindowFlags(windowFlags()|Qt::WindowStaysOnTopHint);
-  // Set 'Cancel' as default button.
-  setDefaultButton(QMessageBox::Cancel);
-  timer.setInterval(1000); // 1sec
-  connect(&timer, SIGNAL(timeout()), this, SLOT(updateSeconds()));
-  show();
-  // Move to center
-  move(misc::screenCenter(this));
+    // Title and button
+    if (action0 == NO_SHUTDOWN) {
+        setWindowTitle(tr("Exit confirmation"));
+        exit_now = addButton(tr("Exit now"), QMessageBox::AcceptRole);
+    }
+    else {
+        setWindowTitle(tr("Shutdown confirmation"));
+        exit_now = addButton(tr("Shutdown now"), QMessageBox::AcceptRole);
+    }
+    // Cancel Button
+    addButton(QMessageBox::Cancel);
+    // Text
+    updateText();
+    // Icon
+    setIcon(QMessageBox::Warning);
+    // Always on top
+    setWindowFlags(windowFlags()|Qt::WindowStaysOnTopHint);
+    // Set 'Cancel' as default button.
+    setDefaultButton(QMessageBox::Cancel);
+    timer.setInterval(1000); // 1sec
+    connect(&timer, SIGNAL(timeout()), this, SLOT(updateSeconds()));
+    show();
+    // Move to center
+    move(misc::screenCenter(this));
 }
 
 void ShutdownConfirmDlg::showEvent(QShowEvent *event) {
-  QMessageBox::showEvent(event);
-  timer.start();
+    QMessageBox::showEvent(event);
+    timer.start();
 }
 
 bool ShutdownConfirmDlg::askForConfirmation(const shutDownAction &action) {
-  ShutdownConfirmDlg dlg(action);
-  dlg.exec();
-  return dlg.shutdown();
+    ShutdownConfirmDlg dlg(action);
+    dlg.exec();
+    return dlg.shutdown();
 }
 
 void ShutdownConfirmDlg::updateSeconds() {
-  --timeout;
-  updateText();
-  if (timeout == 0) {
-    timer.stop();
-    accept();
-  }
+    --timeout;
+    updateText();
+    if (timeout == 0) {
+        timer.stop();
+        accept();
+    }
 }
 
 bool ShutdownConfirmDlg::shutdown() const {
-  // This is necessary because result() in the case of QMessageBox
-  // returns a type of StandardButton, but since we use a custom button
-  // it will return 0 instead, even though we set the 'accept' role on it.
-  if (result() != QDialog::Accepted)
-    return (clickedButton() == exit_now);
-  else
-    return true;
+    // This is necessary because result() in the case of QMessageBox
+    // returns a type of StandardButton, but since we use a custom button
+    // it will return 0 instead, even though we set the 'accept' role on it.
+    if (result() != QDialog::Accepted)
+        return (clickedButton() == exit_now);
+    else
+        return true;
 }
 
 void ShutdownConfirmDlg::updateText() {
-  QString text;
+    QString text;
 
-  switch (action0) {
-  case NO_SHUTDOWN:
-    text = tr("qBittorrent will now exit unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
-    break;
-  case SHUTDOWN_COMPUTER:
-    text = tr("The computer will now be switched off unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
-    break;
-  case SUSPEND_COMPUTER:
-    text = tr("The computer will now go to sleep mode unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
-    break;
-  case HIBERNATE_COMPUTER:
-    text = tr("The computer will now go to hibernation mode unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
-    break;
-  }
+    switch (action0) {
+    case NO_SHUTDOWN:
+        text = tr("qBittorrent will now exit unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
+        break;
+    case SHUTDOWN_COMPUTER:
+        text = tr("The computer will now be switched off unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
+        break;
+    case SUSPEND_COMPUTER:
+        text = tr("The computer will now go to sleep mode unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
+        break;
+    case HIBERNATE_COMPUTER:
+        text = tr("The computer will now go to hibernation mode unless you cancel within the next %1 seconds.").arg(QString::number(timeout));
+        break;
+    }
 
-  setText(text);
+    setText(text);
 }
 

src/core/qtlibtorrent/shutdownconfirm.h

@@ -36,29 +36,29 @@
 #include "misc.h"
 
 class ShutdownConfirmDlg : public QMessageBox {
-  Q_OBJECT
+    Q_OBJECT
 
 public:
-  ShutdownConfirmDlg(const shutDownAction &action);
-  bool shutdown() const;
+    ShutdownConfirmDlg(const shutDownAction &action);
+    bool shutdown() const;
 
-  static bool askForConfirmation(const shutDownAction &action);
+    static bool askForConfirmation(const shutDownAction &action);
 
 protected:
-  void showEvent(QShowEvent *event);
+    void showEvent(QShowEvent *event);
 
 private slots:
-  void updateSeconds();
+    void updateSeconds();
 
 private:
-  // Methods
-  void updateText();
+    // Methods
+    void updateText();
 
-  // Vars
-  QAbstractButton *exit_now;
-  QTimer timer;
-  int timeout;
-  shutDownAction action0;
+    // Vars
+    QAbstractButton *exit_now;
+    QTimer timer;
+    int timeout;
+    shutDownAction action0;
 };
 
 #endif // SHUTDOWNCONFIRM_H

src/core/qtlibtorrent/torrentmodel.h

@@ -40,89 +40,89 @@
 #include "qtorrenthandle.h"
 
 struct TorrentStatusReport {
-  TorrentStatusReport(): nb_downloading(0), nb_seeding(0), nb_active(0), nb_inactive(0), nb_paused(0) {}
-  uint nb_downloading; uint nb_seeding; uint nb_active; uint nb_inactive; uint nb_paused;
+    TorrentStatusReport(): nb_downloading(0), nb_seeding(0), nb_active(0), nb_inactive(0), nb_paused(0) {}
+    uint nb_downloading; uint nb_seeding; uint nb_active; uint nb_inactive; uint nb_paused;
 };
 
 class TorrentModelItem : public QObject {
-Q_OBJECT
+    Q_OBJECT
 
 public:
-  enum State {STATE_DOWNLOADING, STATE_DOWNLOADING_META, STATE_ALLOCATING, STATE_STALLED_DL, STATE_SEEDING, STATE_STALLED_UP, STATE_QUEUED_DL, STATE_QUEUED_UP, STATE_CHECKING_UP, STATE_CHECKING_DL, STATE_QUEUED_CHECK, STATE_QUEUED_FASTCHECK, STATE_PAUSED_DL, STATE_PAUSED_UP, STATE_PAUSED_MISSING, STATE_INVALID};
-  enum Column {TR_NAME, TR_PRIORITY, TR_SIZE, TR_TOTAL_SIZE, TR_PROGRESS, TR_STATUS, TR_SEEDS, TR_PEERS, TR_DLSPEED, TR_UPSPEED, TR_ETA, TR_RATIO, TR_LABEL, TR_ADD_DATE, TR_SEED_DATE, TR_TRACKER, TR_DLLIMIT, TR_UPLIMIT, TR_AMOUNT_DOWNLOADED, TR_AMOUNT_UPLOADED, TR_AMOUNT_LEFT, TR_TIME_ELAPSED, TR_SAVE_PATH, TR_COMPLETED, TR_RATIO_LIMIT, TR_SEEN_COMPLETE_DATE, TR_LAST_ACTIVITY, NB_COLUMNS};
+    enum State {STATE_DOWNLOADING, STATE_DOWNLOADING_META, STATE_ALLOCATING, STATE_STALLED_DL, STATE_SEEDING, STATE_STALLED_UP, STATE_QUEUED_DL, STATE_QUEUED_UP, STATE_CHECKING_UP, STATE_CHECKING_DL, STATE_QUEUED_CHECK, STATE_QUEUED_FASTCHECK, STATE_PAUSED_DL, STATE_PAUSED_UP, STATE_PAUSED_MISSING, STATE_INVALID};
+    enum Column {TR_NAME, TR_PRIORITY, TR_SIZE, TR_TOTAL_SIZE, TR_PROGRESS, TR_STATUS, TR_SEEDS, TR_PEERS, TR_DLSPEED, TR_UPSPEED, TR_ETA, TR_RATIO, TR_LABEL, TR_ADD_DATE, TR_SEED_DATE, TR_TRACKER, TR_DLLIMIT, TR_UPLIMIT, TR_AMOUNT_DOWNLOADED, TR_AMOUNT_UPLOADED, TR_AMOUNT_LEFT, TR_TIME_ELAPSED, TR_SAVE_PATH, TR_COMPLETED, TR_RATIO_LIMIT, TR_SEEN_COMPLETE_DATE, TR_LAST_ACTIVITY, NB_COLUMNS};
 
 public:
-  TorrentModelItem(const QTorrentHandle& h);
-  void refreshStatus(libtorrent::torrent_status const& status);
-  inline int columnCount() const { return NB_COLUMNS; }
-  QVariant data(int column, int role = Qt::DisplayRole) const;
-  bool setData(int column, const QVariant &value, int role = Qt::DisplayRole);
-  inline QString const& hash() const { return m_hash; }
-  State state() const;
+    TorrentModelItem(const QTorrentHandle& h);
+    void refreshStatus(libtorrent::torrent_status const& status);
+    inline int columnCount() const { return NB_COLUMNS; }
+    QVariant data(int column, int role = Qt::DisplayRole) const;
+    bool setData(int column, const QVariant &value, int role = Qt::DisplayRole);
+    inline QString const& hash() const { return m_hash; }
+    State state() const;
 
 signals:
-  void labelChanged(QString previous, QString current);
+    void labelChanged(QString previous, QString current);
 
 private:
-  static QIcon getIconByState(State state);
-  static QColor getColorByState(State state);
+    static QIcon getIconByState(State state);
+    static QColor getColorByState(State state);
 
 private:
-  QTorrentHandle m_torrent;
-  libtorrent::torrent_status m_lastStatus;
-  QDateTime m_addedTime;
-  QString m_label;
-  QString m_name;
-  QString m_hash; // Cached for safety reasons
+    QTorrentHandle m_torrent;
+    libtorrent::torrent_status m_lastStatus;
+    QDateTime m_addedTime;
+    QString m_label;
+    QString m_name;
+    QString m_hash; // Cached for safety reasons
 };
 
 class TorrentModel : public QAbstractListModel
 {
-  Q_OBJECT
-  Q_DISABLE_COPY(TorrentModel)
+    Q_OBJECT
+    Q_DISABLE_COPY(TorrentModel)
 
 public:
-  explicit TorrentModel(QObject *parent = 0);
-  ~TorrentModel();
-  inline int rowCount(const QModelIndex& index = QModelIndex()) const { Q_UNUSED(index); return m_torrents.size(); }
-  int columnCount(const QModelIndex &parent=QModelIndex()) const { Q_UNUSED(parent); return TorrentModelItem::NB_COLUMNS; }
-  QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
-  bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::DisplayRole);
-  QVariant headerData(int section, Qt::Orientation orientation, int role) const;
-  int torrentRow(const QString &hash) const;
-  QString torrentHash(int row) const;
-  void setRefreshInterval(int refreshInterval);
-  TorrentStatusReport getTorrentStatusReport() const;
-  Qt::ItemFlags flags(const QModelIndex &index) const;
-  void populate();
-  bool inhibitSystem();
+    explicit TorrentModel(QObject *parent = 0);
+    ~TorrentModel();
+    inline int rowCount(const QModelIndex& index = QModelIndex()) const { Q_UNUSED(index); return m_torrents.size(); }
+    int columnCount(const QModelIndex &parent=QModelIndex()) const { Q_UNUSED(parent); return TorrentModelItem::NB_COLUMNS; }
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::DisplayRole);
+    QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+    int torrentRow(const QString &hash) const;
+    QString torrentHash(int row) const;
+    void setRefreshInterval(int refreshInterval);
+    TorrentStatusReport getTorrentStatusReport() const;
+    Qt::ItemFlags flags(const QModelIndex &index) const;
+    void populate();
+    bool inhibitSystem();
 
 signals:
-  void torrentAdded(TorrentModelItem *torrentItem);
-  void torrentAboutToBeRemoved(TorrentModelItem *torrentItem);
-  void torrentChangedLabel(TorrentModelItem *torrentItem, QString previous, QString current);
-  void modelRefreshed();
+    void torrentAdded(TorrentModelItem *torrentItem);
+    void torrentAboutToBeRemoved(TorrentModelItem *torrentItem);
+    void torrentChangedLabel(TorrentModelItem *torrentItem, QString previous, QString current);
+    void modelRefreshed();
 
 private slots:
-  void addTorrent(const QTorrentHandle& h);
-  void handleTorrentUpdate(const QTorrentHandle &h);
-  void handleFinishedTorrent(const QTorrentHandle& h);
-  void notifyTorrentChanged(int row);
-  void forceModelRefresh();
-  void handleTorrentLabelChange(QString previous, QString current);
-  void handleTorrentAboutToBeRemoved(const QTorrentHandle & h);
-  void stateUpdated(const std::vector<libtorrent::torrent_status> &statuses);
+    void addTorrent(const QTorrentHandle& h);
+    void handleTorrentUpdate(const QTorrentHandle &h);
+    void handleFinishedTorrent(const QTorrentHandle& h);
+    void notifyTorrentChanged(int row);
+    void forceModelRefresh();
+    void handleTorrentLabelChange(QString previous, QString current);
+    void handleTorrentAboutToBeRemoved(const QTorrentHandle & h);
+    void stateUpdated(const std::vector<libtorrent::torrent_status> &statuses);
 
 private:
-  void beginInsertTorrent(int row);
-  void endInsertTorrent();
-  void beginRemoveTorrent(int row);
-  void endRemoveTorrent();
+    void beginInsertTorrent(int row);
+    void endInsertTorrent();
+    void beginRemoveTorrent(int row);
+    void endRemoveTorrent();
 
 private:
-  QList<TorrentModelItem*> m_torrents;
-  int m_refreshInterval;
-  QTimer m_refreshTimer;
+    QList<TorrentModelItem*> m_torrents;
+    int m_refreshInterval;
+    QTimer m_refreshTimer;
 };
 
 #endif // TORRENTMODEL_H

src/core/qtlibtorrent/torrentspeedmonitor.cpp

@@ -38,88 +38,88 @@ using namespace libtorrent;
 
 namespace {
 
-  template<class T> struct Sample {
+template<class T> struct Sample {
     Sample()
-      : download()
-      , upload()
+        : download()
+        , upload()
     {}
 
     Sample(T download, T upload)
-      : download(download)
-      , upload(upload)
+        : download(download)
+        , upload(upload)
     {}
 
     template <typename U>
     explicit Sample(Sample<U> other)
-      : download(static_cast<U>(other.download))
-      , upload(static_cast<U>(other.upload))
+        : download(static_cast<U>(other.download))
+        , upload(static_cast<U>(other.upload))
     {}
 
     T download;
     T upload;
-  };
+};
 
-  template <typename T>
-  Sample<T>& operator+=(Sample<T>& lhs, Sample<T> const& rhs) {
+template <typename T>
+Sample<T>& operator+=(Sample<T>& lhs, Sample<T> const& rhs) {
     lhs.download += rhs.download;
     lhs.upload   += rhs.upload;
     return lhs;
-  }
+}
 
-  template <typename T>
-  Sample<T>& operator-=(Sample<T>& lhs, Sample<T> const& rhs) {
+template <typename T>
+Sample<T>& operator-=(Sample<T>& lhs, Sample<T> const& rhs) {
     lhs.download -= rhs.download;
     lhs.upload   -= rhs.upload;
     return lhs;
-  }
+}
 
-  template <typename T>
-  Sample<T> operator+(Sample<T> const& lhs, Sample<T> const& rhs) {
+template <typename T>
+Sample<T> operator+(Sample<T> const& lhs, Sample<T> const& rhs) {
     return Sample<T>(lhs.download + rhs.download, lhs.upload + rhs.upload);
-  }
+}
 
-  template <typename T>
-  Sample<T> operator-(Sample<T> const& lhs, Sample<T> const& rhs) {
+template <typename T>
+Sample<T> operator-(Sample<T> const& lhs, Sample<T> const& rhs) {
     return Sample<T>(lhs.download - rhs.download, lhs.upload - rhs.upload);
-  }
+}
 
-  template <typename T>
-  Sample<T> operator*(Sample<T> const& lhs, T rhs) {
+template <typename T>
+Sample<T> operator*(Sample<T> const& lhs, T rhs) {
     return Sample<T>(lhs.download * rhs, lhs.upload * rhs);
-  }
+}
 
-  template <typename T>
-  Sample<T> operator*(T lhs,Sample<T> const& rhs) {
+template <typename T>
+Sample<T> operator*(T lhs,Sample<T> const& rhs) {
     return Sample<T>(lhs * rhs.download, lhs * rhs.upload);
-  }
+}
 
-  template <typename T>
-  Sample<T> operator/(Sample<T> const& lhs, T rhs) {
+template <typename T>
+Sample<T> operator/(Sample<T> const& lhs, T rhs) {
     return Sample<T>(lhs.download / rhs, lhs.upload / rhs);
-  }
+}
 }
 
 class SpeedSample {
 
 public:
-  SpeedSample() {}
-  void addSample(Sample<int> const& item);
-  Sample<qreal> average() const;
+    SpeedSample() {}
+    void addSample(Sample<int> const& item);
+    Sample<qreal> average() const;
 
 private:
-  static const int max_samples = 30;
+    static const int max_samples = 30;
 
 private:
-  QList<Sample<int> > m_speedSamples;
-  Sample<long long> m_sum;
+    QList<Sample<int> > m_speedSamples;
+    Sample<long long> m_sum;
 };
 
 TorrentSpeedMonitor::TorrentSpeedMonitor(QBtSession* session)
-  : m_session(session)
+    : m_session(session)
 {
-  connect(m_session, SIGNAL(torrentAboutToBeRemoved(QTorrentHandle)), SLOT(removeSamples(QTorrentHandle)));
-  connect(m_session, SIGNAL(pausedTorrent(QTorrentHandle)), SLOT(removeSamples(QTorrentHandle)));
-  connect(m_session, SIGNAL(statsReceived(libtorrent::stats_alert)), SLOT(statsReceived(libtorrent::stats_alert)));
+    connect(m_session, SIGNAL(torrentAboutToBeRemoved(QTorrentHandle)), SLOT(removeSamples(QTorrentHandle)));
+    connect(m_session, SIGNAL(pausedTorrent(QTorrentHandle)), SLOT(removeSamples(QTorrentHandle)));
+    connect(m_session, SIGNAL(statsReceived(libtorrent::stats_alert)), SLOT(statsReceived(libtorrent::stats_alert)));
 }
 
 TorrentSpeedMonitor::~TorrentSpeedMonitor()
@@ -127,69 +127,69 @@ TorrentSpeedMonitor::~TorrentSpeedMonitor()
 
 void SpeedSample::addSample(Sample<int> const& item)
 {
-  m_speedSamples.push_back(item);
-  m_sum += Sample<long long>(item);
-  if (m_speedSamples.size() > max_samples) {
-    m_sum -= Sample<long long>(m_speedSamples.front());
-    m_speedSamples.pop_front();
-  }
+    m_speedSamples.push_back(item);
+    m_sum += Sample<long long>(item);
+    if (m_speedSamples.size() > max_samples) {
+        m_sum -= Sample<long long>(m_speedSamples.front());
+        m_speedSamples.pop_front();
+    }
 }
 
 Sample<qreal> SpeedSample::average() const
 {
-  if (m_speedSamples.empty())
-    return Sample<qreal>();
+    if (m_speedSamples.empty())
+        return Sample<qreal>();
 
-  return Sample<qreal>(m_sum) * (qreal(1.) / m_speedSamples.size());
+    return Sample<qreal>(m_sum) * (qreal(1.) / m_speedSamples.size());
 }
 
 void TorrentSpeedMonitor::removeSamples(const QTorrentHandle& h) {
-  try {
-    m_samples.remove(h.hash());
-  } catch(invalid_handle&) {}
+    try {
+        m_samples.remove(h.hash());
+    } catch(invalid_handle&) {}
 }
 
 qlonglong TorrentSpeedMonitor::getETA(const QString &hash, const libtorrent::torrent_status &status) const
 {
-  if (QTorrentHandle::is_paused(status))
-    return MAX_ETA;
+    if (QTorrentHandle::is_paused(status))
+        return MAX_ETA;
 
-  QHash<QString, SpeedSample>::const_iterator i = m_samples.find(hash);
-  if (i == m_samples.end())
-    return MAX_ETA;
+    QHash<QString, SpeedSample>::const_iterator i = m_samples.find(hash);
+    if (i == m_samples.end())
+        return MAX_ETA;
 
-  const Sample<qreal> speed_average = i->average();
+    const Sample<qreal> speed_average = i->average();
 
-  if (QTorrentHandle::is_seed(status)) {
-    if (!speed_average.upload)
-      return MAX_ETA;
+    if (QTorrentHandle::is_seed(status)) {
+        if (!speed_average.upload)
+            return MAX_ETA;
 
-    bool _unused;
-    qreal max_ratio = m_session->getMaxRatioPerTorrent(hash, &_unused);
-    if (max_ratio < 0)
-      return MAX_ETA;
+        bool _unused;
+        qreal max_ratio = m_session->getMaxRatioPerTorrent(hash, &_unused);
+        if (max_ratio < 0)
+            return MAX_ETA;
 
-    libtorrent::size_type realDL = status.all_time_download;
-    if (realDL <= 0)
-      realDL = status.total_wanted;
+        libtorrent::size_type realDL = status.all_time_download;
+        if (realDL <= 0)
+            realDL = status.total_wanted;
 
-    return (realDL * max_ratio - status.all_time_upload) / speed_average.upload;
-  }
+        return (realDL * max_ratio - status.all_time_upload) / speed_average.upload;
+    }
 
-  if (!speed_average.download)
-    return MAX_ETA;
+    if (!speed_average.download)
+        return MAX_ETA;
 
-  return (status.total_wanted - status.total_wanted_done) / speed_average.download;
+    return (status.total_wanted - status.total_wanted_done) / speed_average.download;
 }
 
 void TorrentSpeedMonitor::statsReceived(const stats_alert &stats)
 {
-  Q_ASSERT(stats.interval >= 1000);
+    Q_ASSERT(stats.interval >= 1000);
 
-  Sample<int> transferred(stats.transferred[stats_alert::download_payload],
-                          stats.transferred[stats_alert::upload_payload]);
+    Sample<int> transferred(stats.transferred[stats_alert::download_payload],
+            stats.transferred[stats_alert::upload_payload]);
 
-  Sample<int> normalized = Sample<int>(Sample<long long>(transferred) * 1000LL / static_cast<long long>(stats.interval));
+    Sample<int> normalized = Sample<int>(Sample<long long>(transferred) * 1000LL / static_cast<long long>(stats.interval));
 
-  m_samples[misc::toQString(stats.handle.info_hash())].addSample(normalized);
+    m_samples[misc::toQString(stats.handle.info_hash())].addSample(normalized);
 }

src/core/qtlibtorrent/torrentspeedmonitor.h

@@ -42,21 +42,21 @@ class SpeedSample;
 
 class TorrentSpeedMonitor : public QObject
 {
-  Q_OBJECT
-  Q_DISABLE_COPY(TorrentSpeedMonitor)
+    Q_OBJECT
+    Q_DISABLE_COPY(TorrentSpeedMonitor)
 
 public:
-  explicit TorrentSpeedMonitor(QBtSession* session);
-  ~TorrentSpeedMonitor();
-  qlonglong getETA(const QString &hash, const libtorrent::torrent_status &status) const;
+    explicit TorrentSpeedMonitor(QBtSession* session);
+    ~TorrentSpeedMonitor();
+    qlonglong getETA(const QString &hash, const libtorrent::torrent_status &status) const;
 
 private slots:
-  void statsReceived(const libtorrent::stats_alert& stats);
-  void removeSamples(const QTorrentHandle& h);
+    void statsReceived(const libtorrent::stats_alert& stats);
+    void removeSamples(const QTorrentHandle& h);
 
 private:
-  QHash<QString, SpeedSample> m_samples;
-  QBtSession *m_session;
+    QHash<QString, SpeedSample> m_samples;
+    QBtSession *m_session;
 };
 
 #endif // TORRENTSPEEDMONITOR_H

src/core/qtlibtorrent/torrentstatistics.cpp

@@ -9,92 +9,92 @@
 #include "preferences.h"
 
 TorrentStatistics::TorrentStatistics(QBtSession* session, QObject* parent)
-  : QObject(parent)
-  , m_session(session)
-  , m_sessionUL(0)
-  , m_sessionDL(0)
-  , m_lastWrite(0)
-  , m_dirty(false)
+    : QObject(parent)
+    , m_session(session)
+    , m_sessionUL(0)
+    , m_sessionDL(0)
+    , m_lastWrite(0)
+    , m_dirty(false)
 {
-  loadStats();
-  connect(&m_timer, SIGNAL(timeout()), this, SLOT(gatherStats()));
-  m_timer.start(60 * 1000);
+    loadStats();
+    connect(&m_timer, SIGNAL(timeout()), this, SLOT(gatherStats()));
+    m_timer.start(60 * 1000);
 }
 
 TorrentStatistics::~TorrentStatistics() {
-  if (m_dirty)
-    m_lastWrite = 0;
-  saveStats();
+    if (m_dirty)
+        m_lastWrite = 0;
+    saveStats();
 }
 
 quint64 TorrentStatistics::getAlltimeDL() const {
-  return m_alltimeDL + m_sessionDL;
+    return m_alltimeDL + m_sessionDL;
 }
 
 quint64 TorrentStatistics::getAlltimeUL() const {
-  return m_alltimeUL + m_sessionUL;
+    return m_alltimeUL + m_sessionUL;
 }
 
 void TorrentStatistics::gatherStats() {
-  libtorrent::session_status ss = m_session->getSessionStatus();
-  if (ss.total_download > m_sessionDL) {
-    m_sessionDL = ss.total_download;
-    m_dirty = true;
-  }
-  if (ss.total_upload > m_sessionUL) {
-    m_sessionUL = ss.total_upload;
-    m_dirty = true;
-  }
+    libtorrent::session_status ss = m_session->getSessionStatus();
+    if (ss.total_download > m_sessionDL) {
+        m_sessionDL = ss.total_download;
+        m_dirty = true;
+    }
+    if (ss.total_upload > m_sessionUL) {
+        m_sessionUL = ss.total_upload;
+        m_dirty = true;
+    }
 
-  saveStats();
+    saveStats();
 }
 
 void TorrentStatistics::saveStats() const {
-  if (!(m_dirty && (QDateTime::currentMSecsSinceEpoch() - m_lastWrite >= 15*60*1000) ))
-    return;
-  QIniSettings s("qBittorrent", "qBittorrent-data");
-  QVariantHash v;
-  v.insert("AlltimeDL", m_alltimeDL + m_sessionDL);
-  v.insert("AlltimeUL", m_alltimeUL + m_sessionUL);
-  s.setValue("Stats/AllStats", v);
-  m_dirty = false;
-  m_lastWrite = QDateTime::currentMSecsSinceEpoch();
+    if (!(m_dirty && (QDateTime::currentMSecsSinceEpoch() - m_lastWrite >= 15*60*1000) ))
+        return;
+    QIniSettings s("qBittorrent", "qBittorrent-data");
+    QVariantHash v;
+    v.insert("AlltimeDL", m_alltimeDL + m_sessionDL);
+    v.insert("AlltimeUL", m_alltimeUL + m_sessionUL);
+    s.setValue("Stats/AllStats", v);
+    m_dirty = false;
+    m_lastWrite = QDateTime::currentMSecsSinceEpoch();
 }
 
 void TorrentStatistics::loadStats() {
-  // Temp code. Versions v3.1.4 and v3.1.5 saved the data in the qbittorrent.ini file.
-  // This code reads the data from there, writes it to the new file, and removes the keys
-  // from the old file. This code should be removed after some time has passed.
-  // e.g. When we reach v3.3.0
-  // Don't forget to remove:
-  // 1. Preferences::getStats()
-  // 2. Preferences::removeStats()
-  // 3. #include "preferences.h"
-  Preferences* const pref = Preferences::instance();
-  QIniSettings s("qBittorrent", "qBittorrent-data");
-  QVariantHash v = pref->getStats();
+    // Temp code. Versions v3.1.4 and v3.1.5 saved the data in the qbittorrent.ini file.
+    // This code reads the data from there, writes it to the new file, and removes the keys
+    // from the old file. This code should be removed after some time has passed.
+    // e.g. When we reach v3.3.0
+    // Don't forget to remove:
+    // 1. Preferences::getStats()
+    // 2. Preferences::removeStats()
+    // 3. #include "preferences.h"
+    Preferences* const pref = Preferences::instance();
+    QIniSettings s("qBittorrent", "qBittorrent-data");
+    QVariantHash v = pref->getStats();
 
-  // Let's test if the qbittorrent.ini holds the key
-  if (!v.isEmpty()) {
-    m_dirty = true;
+    // Let's test if the qbittorrent.ini holds the key
+    if (!v.isEmpty()) {
+        m_dirty = true;
 
-    // If the user has used qbt > 3.1.5 and then reinstalled/used
-    // qbt < 3.1.6, there will be stats in qbittorrent-data.ini too
-    // so we need to merge those 2.
-    if (s.contains("Stats/AllStats")) {
-      QVariantHash tmp = s.value("Stats/AllStats").toHash();
-      v["AlltimeDL"] = v["AlltimeDL"].toULongLong() + tmp["AlltimeDL"].toULongLong();
-      v["AlltimeUL"] = v["AlltimeUL"].toULongLong() + tmp["AlltimeUL"].toULongLong();
+        // If the user has used qbt > 3.1.5 and then reinstalled/used
+        // qbt < 3.1.6, there will be stats in qbittorrent-data.ini too
+        // so we need to merge those 2.
+        if (s.contains("Stats/AllStats")) {
+            QVariantHash tmp = s.value("Stats/AllStats").toHash();
+            v["AlltimeDL"] = v["AlltimeDL"].toULongLong() + tmp["AlltimeDL"].toULongLong();
+            v["AlltimeUL"] = v["AlltimeUL"].toULongLong() + tmp["AlltimeUL"].toULongLong();
+        }
     }
-  }
-  else
-    v = s.value("Stats/AllStats").toHash();
+    else
+        v = s.value("Stats/AllStats").toHash();
 
-  m_alltimeDL = v["AlltimeDL"].toULongLong();
-  m_alltimeUL = v["AlltimeUL"].toULongLong();
+    m_alltimeDL = v["AlltimeDL"].toULongLong();
+    m_alltimeUL = v["AlltimeUL"].toULongLong();
 
-  if (m_dirty) {
-    saveStats();
-    pref->removeStats();
-  }
+    if (m_dirty) {
+        saveStats();
+        pref->removeStats();
+    }
 }

src/core/qtlibtorrent/torrentstatistics.h

@@ -8,34 +8,34 @@ class QBtSession;
 
 class TorrentStatistics : QObject
 {
-  Q_OBJECT
-  Q_DISABLE_COPY(TorrentStatistics)
+    Q_OBJECT
+    Q_DISABLE_COPY(TorrentStatistics)
 
 public:
-  TorrentStatistics(QBtSession* session, QObject* parent = 0);
-  ~TorrentStatistics();
+    TorrentStatistics(QBtSession* session, QObject* parent = 0);
+    ~TorrentStatistics();
 
-  quint64 getAlltimeDL() const;
-  quint64 getAlltimeUL() const;
+    quint64 getAlltimeDL() const;
+    quint64 getAlltimeUL() const;
 
 private slots:
-  void gatherStats();
+    void gatherStats();
 
 private:
-  void saveStats() const;
-  void loadStats();
+    void saveStats() const;
+    void loadStats();
 
 private:
-  QBtSession* m_session;
-  // Will overflow at 15.9 EiB
-  quint64 m_alltimeUL;
-  quint64 m_alltimeDL;
-  qint64 m_sessionUL;
-  qint64 m_sessionDL;
-  mutable qint64 m_lastWrite;
-  mutable bool m_dirty;
-
-  QTimer m_timer;
+    QBtSession* m_session;
+    // Will overflow at 15.9 EiB
+    quint64 m_alltimeUL;
+    quint64 m_alltimeDL;
+    qint64 m_sessionUL;
+    qint64 m_sessionDL;
+    mutable qint64 m_lastWrite;
+    mutable bool m_dirty;
+
+    QTimer m_timer;
 };
 
 #endif // TORRENTSTATISTICS_H

src/core/qtlibtorrent/trackerinfos.h

@@ -35,25 +35,25 @@
 
 class TrackerInfos {
 public:
-  QString name_or_url;
-  QString last_message;
-  unsigned long num_peers;
+    QString name_or_url;
+    QString last_message;
+    unsigned long num_peers;
 
-  //TrackerInfos() {}
-  TrackerInfos(const TrackerInfos &b)
-    : name_or_url(b.name_or_url)
-    , last_message(b.last_message)
-    , num_peers(b.num_peers)
-  {
-    Q_ASSERT(!name_or_url.isEmpty());
-  }
+    //TrackerInfos() {}
+    TrackerInfos(const TrackerInfos &b)
+        : name_or_url(b.name_or_url)
+        , last_message(b.last_message)
+        , num_peers(b.num_peers)
+    {
+        Q_ASSERT(!name_or_url.isEmpty());
+    }
 
-  TrackerInfos(QString name_or_url)
-    : name_or_url(name_or_url)
-    , last_message("")
-    , num_peers(0)
-  {
-  }
+    TrackerInfos(QString name_or_url)
+        : name_or_url(name_or_url)
+        , last_message("")
+        , num_peers(0)
+    {
+    }
 };
 
 #endif // TRACKERINFOS_H