2010-03-20 22:09:27 +03:00
|
|
|
/*
|
|
|
|
* Bittorrent Client using Qt4 and libtorrent.
|
|
|
|
* Copyright (C) 2006 Christophe Dumez
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*
|
|
|
|
* In addition, as a special exception, the copyright holders give permission to
|
|
|
|
* link this program with the OpenSSL project's "OpenSSL" library (or with
|
|
|
|
* modified versions of it that use the same license as the "OpenSSL" library),
|
|
|
|
* and distribute the linked executables. You must obey the GNU General Public
|
|
|
|
* License in all respects for all of the code used other than "OpenSSL". If you
|
|
|
|
* modify file(s), you may extend this exception to your version of the file(s),
|
|
|
|
* but you are not obligated to do so. If you do not wish to do so, delete this
|
|
|
|
* exception statement from your version.
|
|
|
|
*
|
|
|
|
* Contact : chris@qbittorrent.org
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "misc.h"
|
|
|
|
|
|
|
|
#include <QUrl>
|
|
|
|
#include <QDir>
|
|
|
|
#include <QFileInfo>
|
|
|
|
#include <QDateTime>
|
|
|
|
#include <QByteArray>
|
|
|
|
|
|
|
|
#ifdef DISABLE_GUI
|
|
|
|
#include <QCoreApplication>
|
|
|
|
#else
|
|
|
|
#include <QApplication>
|
|
|
|
#include <QDesktopWidget>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef Q_WS_WIN
|
|
|
|
#include <shlobj.h>
|
2010-06-09 13:48:14 +04:00
|
|
|
#include <windows.h>
|
|
|
|
const int UNLEN = 256;
|
|
|
|
#else
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
2010-03-20 22:09:27 +03:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
#include <CoreServices/CoreServices.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef Q_WS_WIN
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#else
|
|
|
|
#include <sys/vfs.h>
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
#include <winbase.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
QString misc::QDesktopServicesDataLocation() {
|
|
|
|
#ifdef Q_WS_WIN
|
2010-04-28 15:45:13 +04:00
|
|
|
LPWSTR path=new WCHAR[256];
|
|
|
|
QString result;
|
2010-03-20 22:09:27 +03:00
|
|
|
#if defined Q_WS_WINCE
|
|
|
|
if (SHGetSpecialFolderPath(0, path, CSIDL_APPDATA, FALSE))
|
|
|
|
#else
|
|
|
|
if (SHGetSpecialFolderPath(0, path, CSIDL_LOCAL_APPDATA, FALSE))
|
|
|
|
#endif
|
|
|
|
result = QString::fromWCharArray(path);
|
|
|
|
if (!QCoreApplication::applicationName().isEmpty())
|
|
|
|
result = result + QLatin1String("\\") + qApp->applicationName();
|
2010-05-30 21:51:40 +04:00
|
|
|
if(!result.endsWith("\\"))
|
2010-06-05 22:59:05 +04:00
|
|
|
result += "\\";
|
2010-05-30 21:51:40 +04:00
|
|
|
return result;
|
2010-03-20 22:09:27 +03:00
|
|
|
#else
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
// http://developer.apple.com/documentation/Carbon/Reference/Folder_Manager/Reference/reference.html
|
|
|
|
FSRef ref;
|
|
|
|
OSErr err = FSFindFolder(kUserDomain, kApplicationSupportFolderType, false, &ref);
|
|
|
|
if (err)
|
|
|
|
return QString();
|
|
|
|
QString path;
|
|
|
|
QByteArray ba(2048, 0);
|
|
|
|
if (FSRefMakePath(&ref, reinterpret_cast<UInt8 *>(ba.data()), ba.size()) == noErr)
|
|
|
|
path = QString::fromUtf8(ba).normalized(QString::NormalizationForm_C);
|
|
|
|
path += QLatin1Char('/') + qApp->applicationName();
|
|
|
|
return path;
|
|
|
|
#else
|
|
|
|
QString xdgDataHome = QLatin1String(qgetenv("XDG_DATA_HOME"));
|
|
|
|
if (xdgDataHome.isEmpty())
|
|
|
|
xdgDataHome = QDir::homePath() + QLatin1String("/.local/share");
|
|
|
|
xdgDataHome += QLatin1String("/data/")
|
|
|
|
+ qApp->applicationName();
|
|
|
|
return xdgDataHome;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
QString misc::QDesktopServicesCacheLocation() {
|
|
|
|
#ifdef Q_WS_WIN
|
|
|
|
return QDesktopServicesDataLocation() + QLatin1String("\\cache");
|
|
|
|
#else
|
|
|
|
#ifdef Q_WS_MAC
|
|
|
|
// http://developer.apple.com/documentation/Carbon/Reference/Folder_Manager/Reference/reference.html
|
|
|
|
FSRef ref;
|
|
|
|
OSErr err = FSFindFolder(kUserDomain, kCachedDataFolderType, false, &ref);
|
|
|
|
if (err)
|
|
|
|
return QString();
|
2010-06-09 19:13:52 +04:00
|
|
|
QString path;
|
|
|
|
QByteArray ba(2048, 0);
|
|
|
|
if (FSRefMakePath(&ref, reinterpret_cast<UInt8 *>(ba.data()), ba.size()) == noErr)
|
|
|
|
path = QString::fromUtf8(ba).normalized(QString::NormalizationForm_C);
|
2010-03-20 22:09:27 +03:00
|
|
|
path += QLatin1Char('/') + qApp->applicationName();
|
|
|
|
return path;
|
|
|
|
#else
|
|
|
|
QString xdgCacheHome = QLatin1String(qgetenv("XDG_CACHE_HOME"));
|
|
|
|
if (xdgCacheHome.isEmpty())
|
|
|
|
xdgCacheHome = QDir::homePath() + QLatin1String("/.cache");
|
|
|
|
xdgCacheHome += QLatin1Char('/') + QCoreApplication::applicationName();
|
|
|
|
return xdgCacheHome;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
long long misc::freeDiskSpaceOnPath(QString path) {
|
|
|
|
if(path.isEmpty()) return -1;
|
2010-06-22 15:53:49 +04:00
|
|
|
path = path.replace("\\", "/");
|
2010-03-20 22:09:27 +03:00
|
|
|
QDir dir_path(path);
|
|
|
|
if(!dir_path.exists()) {
|
2010-06-22 15:53:49 +04:00
|
|
|
QStringList parts = path.split("/");
|
|
|
|
while (parts.size() > 1 && !QDir(parts.join("/")).exists()) {
|
|
|
|
parts.removeLast();
|
|
|
|
}
|
|
|
|
dir_path = QDir(parts.join("/"));
|
|
|
|
if(!dir_path.exists()) return -1;
|
2010-03-20 22:09:27 +03:00
|
|
|
}
|
|
|
|
Q_ASSERT(dir_path.exists());
|
|
|
|
#ifndef Q_WS_WIN
|
|
|
|
unsigned long long available;
|
|
|
|
struct statfs stats;
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString statfs_path = dir_path.path()+"/.";
|
2010-03-20 22:09:27 +03:00
|
|
|
const int ret = statfs (qPrintable(statfs_path), &stats) ;
|
|
|
|
if(ret == 0) {
|
|
|
|
available = ((unsigned long long)stats.f_bavail) *
|
|
|
|
((unsigned long long)stats.f_bsize) ;
|
|
|
|
return available;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
|
|
|
|
PULARGE_INTEGER,
|
|
|
|
PULARGE_INTEGER,
|
|
|
|
PULARGE_INTEGER);
|
|
|
|
GetDiskFreeSpaceEx_t
|
|
|
|
pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
|
|
|
|
(
|
2010-04-28 15:45:13 +04:00
|
|
|
::GetModuleHandle(TEXT("kernel32.dll")),
|
2010-03-20 22:09:27 +03:00
|
|
|
"GetDiskFreeSpaceExW"
|
|
|
|
);
|
|
|
|
if ( pGetDiskFreeSpaceEx )
|
|
|
|
{
|
|
|
|
ULARGE_INTEGER bytesFree, bytesTotal;
|
|
|
|
unsigned long long *ret;
|
2010-04-28 15:45:13 +04:00
|
|
|
if (pGetDiskFreeSpaceEx((LPCTSTR)path.utf16(), &bytesFree, &bytesTotal, NULL)) {
|
|
|
|
ret = (unsigned long long*)&bytesFree;
|
|
|
|
return *ret;
|
2010-03-20 22:09:27 +03:00
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-04-06 13:17:33 +04:00
|
|
|
QString misc::truncateRootFolder(boost::intrusive_ptr<torrent_info> t) {
|
2010-06-19 18:39:23 +04:00
|
|
|
if(t->num_files() == 1) {
|
|
|
|
// Single file torrent
|
|
|
|
// Remove possible subfolders
|
|
|
|
QString path = QString::fromUtf8(t->file_at(0).path.string().c_str());
|
|
|
|
QStringList path_parts = path.split("/", QString::SkipEmptyParts);
|
|
|
|
t->rename_file(0, path_parts.last().toUtf8().data());
|
|
|
|
return QString::null;
|
|
|
|
}
|
2010-04-06 13:17:33 +04:00
|
|
|
QString root_folder;
|
|
|
|
int i = 0;
|
|
|
|
for(torrent_info::file_iterator it = t->begin_files(); it < t->end_files(); it++) {
|
|
|
|
QString path = QString::fromUtf8(it->path.string().c_str());
|
|
|
|
QStringList path_parts = path.split("/", QString::SkipEmptyParts);
|
|
|
|
if(path_parts.size() > 1) {
|
|
|
|
root_folder = path_parts.takeFirst();
|
2010-06-19 16:25:14 +04:00
|
|
|
t->rename_file(i, path_parts.join("/").toUtf8().data());
|
2010-04-06 13:17:33 +04:00
|
|
|
}
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
return root_folder;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString misc::truncateRootFolder(libtorrent::torrent_handle h) {
|
2010-06-19 18:39:23 +04:00
|
|
|
torrent_info t = h.get_torrent_info();
|
|
|
|
if(t.num_files() == 1) {
|
|
|
|
// Single file torrent
|
|
|
|
// Remove possible subfolders
|
|
|
|
QString path = QString::fromUtf8(t.file_at(0).path.string().c_str());
|
|
|
|
QStringList path_parts = path.split("/", QString::SkipEmptyParts);
|
|
|
|
t.rename_file(0, path_parts.last().toUtf8().data());
|
|
|
|
return QString::null;
|
|
|
|
}
|
2010-04-06 13:17:33 +04:00
|
|
|
QString root_folder;
|
|
|
|
int i = 0;
|
|
|
|
for(torrent_info::file_iterator it = t.begin_files(); it < t.end_files(); it++) {
|
|
|
|
QString path = QString::fromUtf8(it->path.string().c_str());
|
|
|
|
QStringList path_parts = path.split("/", QString::SkipEmptyParts);
|
|
|
|
if(path_parts.size() > 1) {
|
|
|
|
root_folder = path_parts.takeFirst();
|
2010-06-19 16:25:14 +04:00
|
|
|
h.rename_file(i, path_parts.join("/").toUtf8().data());
|
2010-04-06 13:17:33 +04:00
|
|
|
}
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
return root_folder;
|
|
|
|
}
|
|
|
|
|
2010-03-20 22:09:27 +03:00
|
|
|
bool misc::sameFiles(QString path1, QString path2) {
|
|
|
|
QFile f1(path1);
|
|
|
|
if(!f1.exists()) return false;
|
|
|
|
QFile f2(path2);
|
|
|
|
if(!f2.exists()) return false;
|
|
|
|
QByteArray content1, content2;
|
|
|
|
if(f1.open(QIODevice::ReadOnly)) {
|
|
|
|
content1 = f1.readAll();
|
|
|
|
f1.close();
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if(f2.open(QIODevice::ReadOnly)) {
|
|
|
|
content1 = f2.readAll();
|
|
|
|
f2.close();
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return content1 == content2;
|
|
|
|
}
|
|
|
|
|
|
|
|
void misc::copyDir(QString src_path, QString dst_path) {
|
|
|
|
QDir sourceDir(src_path);
|
|
|
|
if(!sourceDir.exists()) return;
|
|
|
|
// Create destination directory
|
|
|
|
QDir destDir(dst_path);
|
|
|
|
if(!destDir.exists()) {
|
|
|
|
if(!destDir.mkpath(destDir.absolutePath())) return;
|
|
|
|
}
|
|
|
|
// List source directory
|
2010-07-23 18:05:53 +04:00
|
|
|
const QFileInfoList content = sourceDir.entryInfoList();
|
2010-03-20 22:09:27 +03:00
|
|
|
foreach(const QFileInfo& child, content) {
|
|
|
|
if(child.fileName()[0] == '.') continue;
|
|
|
|
if(child.isDir()) {
|
|
|
|
copyDir(child.absoluteFilePath(), dst_path+QDir::separator()+QDir(child.absoluteFilePath()).dirName());
|
|
|
|
continue;
|
|
|
|
}
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString src_child_path = child.absoluteFilePath();
|
|
|
|
const QString dest_child_path = destDir.absoluteFilePath(child.fileName());
|
2010-03-20 22:09:27 +03:00
|
|
|
// Copy the file from src to dest
|
|
|
|
QFile::copy(src_child_path, dest_child_path);
|
|
|
|
// Remove source file
|
2010-07-24 23:34:51 +04:00
|
|
|
safeRemove(src_child_path);
|
2010-03-20 22:09:27 +03:00
|
|
|
}
|
|
|
|
// Remove source folder
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString dir_name = sourceDir.dirName();
|
2010-03-20 22:09:27 +03:00
|
|
|
if(sourceDir.cdUp()) {
|
|
|
|
sourceDir.rmdir(dir_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-10 18:17:26 +04:00
|
|
|
QString misc::updateLabelInSavePath(const QString& defaultSavePath, QString save_path, const QString old_label, const QString new_label) {
|
|
|
|
if(old_label == new_label) return save_path;
|
2010-04-22 20:19:49 +04:00
|
|
|
qDebug("UpdateLabelInSavePath(%s, %s, %s)", qPrintable(save_path), qPrintable(old_label), qPrintable(new_label));
|
2010-04-10 18:17:26 +04:00
|
|
|
if(!save_path.startsWith(defaultSavePath)) return save_path;
|
|
|
|
QString new_save_path = save_path.replace(defaultSavePath, "");
|
|
|
|
QStringList path_parts = new_save_path.split(QDir::separator(), QString::SkipEmptyParts);
|
|
|
|
if(path_parts.empty()) {
|
|
|
|
if(!new_label.isEmpty())
|
|
|
|
path_parts << new_label;
|
|
|
|
} else {
|
|
|
|
if(old_label.isEmpty() || path_parts.first() != old_label) {
|
2010-04-10 18:50:11 +04:00
|
|
|
if(path_parts.first() != new_label)
|
|
|
|
path_parts.prepend(new_label);
|
2010-04-10 18:17:26 +04:00
|
|
|
} else {
|
2010-04-10 18:50:11 +04:00
|
|
|
if(new_label.isEmpty()) {
|
2010-04-10 18:17:26 +04:00
|
|
|
path_parts.removeAt(0);
|
2010-04-10 18:50:11 +04:00
|
|
|
} else {
|
|
|
|
if(path_parts.first() != new_label)
|
|
|
|
path_parts.replace(0, new_label);
|
|
|
|
}
|
2010-04-10 18:17:26 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
new_save_path = defaultSavePath;
|
|
|
|
if(!new_save_path.endsWith(QDir::separator())) new_save_path += QDir::separator();
|
|
|
|
new_save_path += path_parts.join(QDir::separator());
|
2010-04-22 20:19:49 +04:00
|
|
|
qDebug("New save path is %s", qPrintable(new_save_path));
|
2010-04-10 18:17:26 +04:00
|
|
|
return new_save_path;
|
|
|
|
}
|
|
|
|
|
2010-03-20 22:09:27 +03:00
|
|
|
void misc::moveToXDGFolders() {
|
2010-07-24 23:34:51 +04:00
|
|
|
QDir old_qBtPath(QDir::homePath().replace("\\","/")+"/"+".qbittorrent");
|
|
|
|
if(old_qBtPath.exists()) {
|
2010-03-20 22:09:27 +03:00
|
|
|
// Copy BT_backup folder
|
2010-07-24 23:34:51 +04:00
|
|
|
const QString old_BTBackupPath = old_qBtPath.absoluteFilePath("BT_backup");
|
2010-03-20 22:09:27 +03:00
|
|
|
if(QDir(old_BTBackupPath).exists()) {
|
|
|
|
copyDir(old_BTBackupPath, BTBackupLocation());
|
|
|
|
}
|
|
|
|
// Copy search engine folder
|
2010-07-24 23:34:51 +04:00
|
|
|
const QString old_searchPath = old_qBtPath.absoluteFilePath("search_engine");
|
2010-03-20 22:09:27 +03:00
|
|
|
if(QDir(old_searchPath).exists()) {
|
|
|
|
copyDir(old_searchPath, searchEngineLocation());
|
|
|
|
}
|
|
|
|
// Copy *_state files
|
2010-07-24 23:34:51 +04:00
|
|
|
if(QFile::exists(old_qBtPath.absoluteFilePath("dht_state"))) {
|
|
|
|
QFile::copy(old_qBtPath.absoluteFilePath("dht_state"), QDir(cacheLocation()).absoluteFilePath("dht_state"));
|
|
|
|
safeRemove(old_qBtPath.absoluteFilePath("dht_state"));
|
2010-03-20 22:09:27 +03:00
|
|
|
}
|
2010-07-24 23:34:51 +04:00
|
|
|
if(QFile::exists(old_qBtPath.absoluteFilePath("ses_state"))) {
|
|
|
|
QFile::copy(old_qBtPath.absoluteFilePath("ses_state"), QDir(cacheLocation()).absoluteFilePath("ses_state"));
|
|
|
|
safeRemove(old_qBtPath.absoluteFilePath("ses_state"));
|
2010-03-20 22:09:27 +03:00
|
|
|
}
|
|
|
|
// Remove .qbittorrent folder if empty
|
|
|
|
QDir::home().rmdir(".qbittorrent");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QString misc::toValidFileSystemName(QString filename) {
|
|
|
|
qDebug("toValidFSName: %s", qPrintable(filename));
|
|
|
|
filename = filename.replace("\\", "/").trimmed();
|
|
|
|
const QRegExp regex("[/:?\"*<>|]");
|
|
|
|
filename = filename.replace(regex, " ").trimmed();
|
|
|
|
qDebug("toValidFSName, result: %s", qPrintable(filename));
|
|
|
|
return filename;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool misc::isValidFileSystemName(QString filename) {
|
|
|
|
filename = filename.replace("\\", "/").trimmed();
|
|
|
|
if(filename.isEmpty()) return false;
|
|
|
|
const QRegExp regex("[/:?\"*<>|]");
|
|
|
|
if(filename.contains(regex))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef DISABLE_GUI
|
|
|
|
// Get screen center
|
|
|
|
QPoint misc::screenCenter(QWidget *win) {
|
|
|
|
int scrn = 0;
|
|
|
|
const QWidget *w = win->window();
|
|
|
|
|
|
|
|
if(w)
|
|
|
|
scrn = QApplication::desktop()->screenNumber(w);
|
|
|
|
else if(QApplication::desktop()->isVirtualDesktop())
|
|
|
|
scrn = QApplication::desktop()->screenNumber(QCursor::pos());
|
|
|
|
else
|
|
|
|
scrn = QApplication::desktop()->screenNumber(win);
|
|
|
|
|
|
|
|
QRect desk(QApplication::desktop()->availableGeometry(scrn));
|
|
|
|
return QPoint((desk.width() - win->frameGeometry().width()) / 2, (desk.height() - win->frameGeometry().height()) / 2);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
QString misc::searchEngineLocation() {
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString location = QDir::cleanPath(QDesktopServicesDataLocation()
|
2010-03-20 22:09:27 +03:00
|
|
|
+ QDir::separator() + "search_engine");
|
|
|
|
QDir locationDir(location);
|
|
|
|
if(!locationDir.exists())
|
|
|
|
locationDir.mkpath(locationDir.absolutePath());
|
|
|
|
return location;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString misc::BTBackupLocation() {
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString location = QDir::cleanPath(QDesktopServicesDataLocation()
|
2010-03-20 22:09:27 +03:00
|
|
|
+ QDir::separator() + "BT_backup");
|
|
|
|
QDir locationDir(location);
|
|
|
|
if(!locationDir.exists())
|
|
|
|
locationDir.mkpath(locationDir.absolutePath());
|
|
|
|
return location;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString misc::cacheLocation() {
|
2010-05-30 21:51:40 +04:00
|
|
|
QString location = QDir::cleanPath(QDesktopServicesCacheLocation());
|
2010-03-20 22:09:27 +03:00
|
|
|
QDir locationDir(location);
|
|
|
|
if(!locationDir.exists())
|
|
|
|
locationDir.mkpath(locationDir.absolutePath());
|
|
|
|
return location;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return best userfriendly storage unit (B, KiB, MiB, GiB, TiB)
|
|
|
|
// use Binary prefix standards from IEC 60027-2
|
|
|
|
// see http://en.wikipedia.org/wiki/Kilobyte
|
|
|
|
// value must be given in bytes
|
|
|
|
QString misc::friendlyUnit(double val) {
|
|
|
|
if(val < 0)
|
|
|
|
return tr("Unknown", "Unknown (size)");
|
|
|
|
const QString units[5] = {tr("B", "bytes"), tr("KiB", "kibibytes (1024 bytes)"), tr("MiB", "mebibytes (1024 kibibytes)"), tr("GiB", "gibibytes (1024 mibibytes)"), tr("TiB", "tebibytes (1024 gibibytes)")};
|
|
|
|
char i = 0;
|
|
|
|
while(val >= 1024. && i++<6)
|
|
|
|
val /= 1024.;
|
2010-06-27 18:19:24 +04:00
|
|
|
if(i == 0)
|
|
|
|
return QString::number((long)val) + " " + units[0];
|
2010-03-20 22:09:27 +03:00
|
|
|
return QString::number(val, 'f', 1) + " " + units[(int)i];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool misc::isPreviewable(QString extension){
|
|
|
|
extension = extension.toUpper();
|
|
|
|
if(extension == "AVI") return true;
|
|
|
|
if(extension == "MP3") return true;
|
|
|
|
if(extension == "OGG") return true;
|
|
|
|
if(extension == "OGM") return true;
|
|
|
|
if(extension == "WMV") return true;
|
|
|
|
if(extension == "WMA") return true;
|
|
|
|
if(extension == "MPEG") return true;
|
|
|
|
if(extension == "MPG") return true;
|
|
|
|
if(extension == "ASF") return true;
|
|
|
|
if(extension == "QT") return true;
|
|
|
|
if(extension == "RM") return true;
|
|
|
|
if(extension == "RMVB") return true;
|
|
|
|
if(extension == "RMV") return true;
|
|
|
|
if(extension == "SWF") return true;
|
|
|
|
if(extension == "FLV") return true;
|
|
|
|
if(extension == "WAV") return true;
|
|
|
|
if(extension == "MOV") return true;
|
|
|
|
if(extension == "VOB") return true;
|
|
|
|
if(extension == "MID") return true;
|
|
|
|
if(extension == "AC3") return true;
|
|
|
|
if(extension == "MP4") return true;
|
|
|
|
if(extension == "MP2") return true;
|
|
|
|
if(extension == "AVI") return true;
|
|
|
|
if(extension == "FLAC") return true;
|
|
|
|
if(extension == "AU") return true;
|
|
|
|
if(extension == "MPE") return true;
|
|
|
|
if(extension == "MOV") return true;
|
|
|
|
if(extension == "MKV") return true;
|
|
|
|
if(extension == "AIF") return true;
|
|
|
|
if(extension == "AIFF") return true;
|
|
|
|
if(extension == "AIFC") return true;
|
|
|
|
if(extension == "RA") return true;
|
|
|
|
if(extension == "RAM") return true;
|
|
|
|
if(extension == "M4P") return true;
|
|
|
|
if(extension == "M4A") return true;
|
|
|
|
if(extension == "3GP") return true;
|
|
|
|
if(extension == "AAC") return true;
|
|
|
|
if(extension == "SWA") return true;
|
|
|
|
if(extension == "MPC") return true;
|
|
|
|
if(extension == "MPP") return true;
|
2010-03-20 22:37:28 +03:00
|
|
|
if(extension == "M3U") return true;
|
2010-03-20 22:09:27 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool misc::removeEmptyTree(QString path) {
|
|
|
|
QDir dir(path);
|
|
|
|
foreach(const QString &child, dir.entryList(QDir::AllDirs)) {
|
|
|
|
if(child == "." || child == "..") continue;
|
|
|
|
return removeEmptyTree(dir.absoluteFilePath(child));
|
|
|
|
}
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString dir_name = dir.dirName();
|
2010-03-20 22:09:27 +03:00
|
|
|
if(dir.cdUp()) {
|
|
|
|
return dir.rmdir(dir_name);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-07-23 02:19:42 +04:00
|
|
|
QString misc::bcLinkToMagnet(QString bc_link) {
|
|
|
|
QByteArray raw_bc = bc_link.toUtf8();
|
|
|
|
raw_bc = raw_bc.mid(8); // skip bc://bt/
|
|
|
|
raw_bc = QByteArray::fromBase64(raw_bc); // Decode base64
|
|
|
|
// Format is now AA/url_encoded_filename/size_bytes/info_hash/ZZ
|
|
|
|
QStringList parts = QString(raw_bc).split("/");
|
|
|
|
if(parts.size() != 5) return QString::null;
|
|
|
|
QString filename = parts.at(1);
|
|
|
|
QString hash = parts.at(3);
|
|
|
|
QString magnet = "magnet:?xt=urn:btih:" + hash;
|
|
|
|
magnet += "&dn=" + filename;
|
|
|
|
return magnet;
|
|
|
|
}
|
|
|
|
|
2010-03-20 22:09:27 +03:00
|
|
|
QString misc::magnetUriToName(QString magnet_uri) {
|
|
|
|
QString name = "";
|
|
|
|
QRegExp regHex("dn=([^&]+)");
|
|
|
|
const int pos = regHex.indexIn(magnet_uri);
|
|
|
|
if(pos > -1) {
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString found = regHex.cap(1);
|
2010-03-20 22:09:27 +03:00
|
|
|
// URL decode
|
|
|
|
name = QUrl::fromPercentEncoding(found.toLocal8Bit()).replace("+", " ");
|
|
|
|
}
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString misc::magnetUriToHash(QString magnet_uri) {
|
|
|
|
QString hash = "";
|
|
|
|
QRegExp regHex("urn:btih:([0-9A-Za-z]+)");
|
|
|
|
// Hex
|
|
|
|
int pos = regHex.indexIn(magnet_uri);
|
|
|
|
if(pos > -1) {
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString found = regHex.cap(1);
|
2010-03-20 22:09:27 +03:00
|
|
|
if(found.length() == 40) {
|
|
|
|
const sha1_hash sha1(QString(QByteArray::fromHex(regHex.cap(1).toLocal8Bit())).toStdString());
|
|
|
|
qDebug("magnetUriToHash (Hex): hash: %s", qPrintable(misc::toQString(sha1)));
|
|
|
|
return misc::toQString(sha1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Base 32
|
|
|
|
QRegExp regBase32("urn:btih:([A-Za-z2-7=]+)");
|
|
|
|
pos = regBase32.indexIn(magnet_uri);
|
|
|
|
if(pos > -1) {
|
2010-07-23 18:05:53 +04:00
|
|
|
const QString found = regBase32.cap(1);
|
2010-03-20 22:09:27 +03:00
|
|
|
if(found.length() > 20 && (found.length()*5)%40 == 0) {
|
|
|
|
const sha1_hash sha1(base32decode(regBase32.cap(1).toStdString()));
|
|
|
|
hash = misc::toQString(sha1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qDebug("magnetUriToHash (base32): hash: %s", qPrintable(hash));
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString misc::boostTimeToQString(const boost::optional<boost::posix_time::ptime> boostDate) {
|
2010-05-01 21:37:12 +04:00
|
|
|
if(!boostDate || !boostDate.is_initialized() || boostDate->is_not_a_date_time()) return tr("Unknown");
|
2010-05-01 22:07:56 +04:00
|
|
|
struct std::tm tm;
|
|
|
|
try {
|
|
|
|
tm = boost::posix_time::to_tm(*boostDate);
|
|
|
|
} catch(std::exception e) {
|
|
|
|
return tr("Unknown");
|
|
|
|
}
|
2010-05-01 21:37:12 +04:00
|
|
|
time_t t = mktime(&tm);
|
|
|
|
if(t < 0)
|
|
|
|
return tr("Unknown");
|
|
|
|
QDateTime dt = QDateTime::fromTime_t(t);
|
|
|
|
if(dt.isNull() || !dt.isValid())
|
|
|
|
return tr("Unknown");
|
|
|
|
return dt.toString(Qt::DefaultLocaleLongDate);
|
2010-03-20 22:09:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Replace ~ in path
|
|
|
|
QString misc::expandPath(QString path) {
|
|
|
|
path = path.trimmed();
|
|
|
|
if(path.isEmpty()) return path;
|
|
|
|
if(path.length() == 1) {
|
|
|
|
if(path[0] == '~' ) return QDir::homePath();
|
|
|
|
}
|
|
|
|
if(path[0] == '~' && path[1] == QDir::separator()) {
|
|
|
|
path = path.replace(0, 1, QDir::homePath());
|
|
|
|
} else {
|
|
|
|
if(QDir::isAbsolutePath(path)) {
|
|
|
|
path = QDir(path).absolutePath();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return QDir::cleanPath(path);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Take a number of seconds and return an user-friendly
|
|
|
|
// time duration like "1d 2h 10m".
|
|
|
|
QString misc::userFriendlyDuration(qlonglong seconds) {
|
2010-05-21 15:46:12 +04:00
|
|
|
if(seconds < 0 || seconds >= MAX_ETA) {
|
2010-03-20 22:09:27 +03:00
|
|
|
return QString::fromUtf8("∞");
|
|
|
|
}
|
2010-05-21 15:25:30 +04:00
|
|
|
if(seconds == 0) {
|
|
|
|
return "0";
|
|
|
|
}
|
2010-03-20 22:09:27 +03:00
|
|
|
if(seconds < 60) {
|
|
|
|
return tr("< 1m", "< 1 minute");
|
|
|
|
}
|
|
|
|
int minutes = seconds / 60;
|
|
|
|
if(minutes < 60) {
|
|
|
|
return tr("%1m","e.g: 10minutes").arg(QString::number(minutes));
|
|
|
|
}
|
|
|
|
int hours = minutes / 60;
|
|
|
|
minutes = minutes - hours*60;
|
|
|
|
if(hours < 24) {
|
2010-06-21 18:10:20 +04:00
|
|
|
return tr("%1h %2m", "e.g: 3hours 5minutes").arg(QString::number(hours)).arg(QString::number(minutes));
|
2010-03-20 22:09:27 +03:00
|
|
|
}
|
|
|
|
int days = hours / 24;
|
|
|
|
hours = hours - days * 24;
|
|
|
|
if(days < 100) {
|
2010-06-21 18:10:20 +04:00
|
|
|
return tr("%1d %2h", "e.g: 2days 10hours").arg(QString::number(days)).arg(QString::number(hours));
|
2010-03-20 22:09:27 +03:00
|
|
|
}
|
|
|
|
return QString::fromUtf8("∞");
|
|
|
|
}
|
2010-06-05 22:59:05 +04:00
|
|
|
|
2010-06-09 13:48:14 +04:00
|
|
|
QString misc::getUserIDString() {
|
|
|
|
QString uid = "0";
|
|
|
|
#ifdef Q_WS_WIN
|
|
|
|
char buffer[UNLEN+1] = {0};
|
|
|
|
DWORD buffer_len = UNLEN + 1;
|
|
|
|
if (!GetUserNameA(buffer, &buffer_len))
|
|
|
|
uid = QString(buffer);
|
|
|
|
#else
|
|
|
|
uid = QString::number(getuid());
|
|
|
|
#endif
|
|
|
|
return uid;
|
|
|
|
}
|
|
|
|
|
2010-06-05 22:59:05 +04:00
|
|
|
QStringList misc::toStringList(const QList<bool> &l) {
|
|
|
|
QStringList ret;
|
|
|
|
foreach(const bool &b, l) {
|
|
|
|
if(b)
|
|
|
|
ret << "1";
|
|
|
|
else
|
|
|
|
ret << "0";
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
QList<int> misc::intListfromStringList(const QStringList &l) {
|
|
|
|
QList<int> ret;
|
|
|
|
foreach(const QString &s, l) {
|
|
|
|
ret << s.toInt();
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
QList<bool> misc::boolListfromStringList(const QStringList &l) {
|
|
|
|
QList<bool> ret;
|
|
|
|
foreach(const QString &s, l) {
|
|
|
|
if(s == "1")
|
|
|
|
ret << true;
|
|
|
|
else
|
|
|
|
ret << false;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|