mirror of
https://github.com/qbittorrent/qBittorrent.git
synced 2024-12-17 05:21:50 +03:00
728 lines
26 KiB
C++
728 lines
26 KiB
C++
/*
|
|
* 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 <QStandardItemModel>
|
|
#include <QHeaderView>
|
|
#include <QCompleter>
|
|
#include <QMessageBox>
|
|
#include <QTemporaryFile>
|
|
#include <QSystemTrayIcon>
|
|
#include <iostream>
|
|
#include <QTimer>
|
|
#include <QDir>
|
|
#include <QMenu>
|
|
#include <QClipboard>
|
|
#include <QMimeData>
|
|
#include <QSortFilterProxyModel>
|
|
#include <QFileDialog>
|
|
#include <QDesktopServices>
|
|
|
|
#ifdef Q_WS_WIN
|
|
#include <stdlib.h>
|
|
#endif
|
|
|
|
#include "searchengine.h"
|
|
#include "qbtsession.h"
|
|
#include "downloadthread.h"
|
|
#include "misc.h"
|
|
#include "preferences.h"
|
|
#include "searchlistdelegate.h"
|
|
#include "qinisettings.h"
|
|
#include "mainwindow.h"
|
|
|
|
#define SEARCHHISTORY_MAXSIZE 50
|
|
|
|
/*SEARCH ENGINE START*/
|
|
SearchEngine::SearchEngine(MainWindow *parent) : QWidget(parent), mp_mainWindow(parent) {
|
|
setupUi(this);
|
|
// Icons
|
|
search_button->setIcon(misc::getIcon("edit-find"));
|
|
download_button->setIcon(misc::getIcon("download"));
|
|
goToDescBtn->setIcon(misc::getIcon("application-x-mswinurl"));
|
|
enginesButton->setIcon(misc::getIcon("preferences-system-network"));
|
|
// new qCompleter to the search pattern
|
|
startSearchHistory();
|
|
createCompleter();
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(4,5,0))
|
|
tabWidget->setTabsClosable(true);
|
|
connect(tabWidget, SIGNAL(tabCloseRequested(int)), this, SLOT(closeTab(int)));
|
|
#else
|
|
// Add close tab button
|
|
closeTab_button = new QPushButton();
|
|
closeTab_button->setIcon(misc::getIcon("tab-close"));
|
|
closeTab_button->setFlat(true);
|
|
tabWidget->setCornerWidget(closeTab_button);
|
|
connect(closeTab_button, SIGNAL(clicked()), this, SLOT(closeTab_button_clicked()));
|
|
#endif
|
|
// Boolean initialization
|
|
search_stopped = false;
|
|
// Creating Search Process
|
|
#ifdef Q_WS_WIN
|
|
has_python = addPythonPathToEnv();
|
|
#endif
|
|
searchProcess = new QProcess(this);
|
|
searchProcess->setEnvironment(QProcess::systemEnvironment());
|
|
connect(searchProcess, SIGNAL(started()), this, SLOT(searchStarted()));
|
|
connect(searchProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(readSearchOutput()));
|
|
connect(searchProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(searchFinished(int,QProcess::ExitStatus)));
|
|
connect(tabWidget, SIGNAL(currentChanged(int)), this, SLOT(tab_changed(int)));
|
|
searchTimeout = new QTimer(this);
|
|
searchTimeout->setSingleShot(true);
|
|
connect(searchTimeout, SIGNAL(timeout()), this, SLOT(on_search_button_clicked()));
|
|
// Update nova.py search plugin if necessary
|
|
updateNova();
|
|
supported_engines = new SupportedEngines();
|
|
// Fill in category combobox
|
|
fillCatCombobox();
|
|
connect(search_pattern, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(displayPatternContextMenu(QPoint)));
|
|
connect(search_pattern, SIGNAL(textEdited(QString)), this, SLOT(searchTextEdited(QString)));
|
|
}
|
|
|
|
void SearchEngine::fillCatCombobox() {
|
|
comboCategory->clear();
|
|
comboCategory->addItem(full_cat_names["all"], QVariant("all"));
|
|
QStringList supported_cat = supported_engines->supportedCategories();
|
|
foreach(QString cat, supported_cat) {
|
|
qDebug("Supported category: %s", qPrintable(cat));
|
|
comboCategory->addItem(full_cat_names[cat], QVariant(cat));
|
|
}
|
|
}
|
|
|
|
#ifdef Q_WS_WIN
|
|
bool SearchEngine::addPythonPathToEnv() {
|
|
QString python_path = Preferences::getPythonPath();
|
|
if(!python_path.isEmpty()) {
|
|
// Add it to PATH envvar
|
|
QString path_envar = QString::fromLocal8Bit(getenv("PATH"));
|
|
if(path_envar.isNull()) {
|
|
path_envar = "";
|
|
}
|
|
path_envar = python_path+";"+path_envar;
|
|
qDebug("New PATH envvar is: %s", qPrintable(path_envar));
|
|
QString envar = "PATH="+path_envar;
|
|
putenv(envar.toLocal8Bit().data());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SearchEngine::installPython() {
|
|
setCursor(QCursor(Qt::WaitCursor));
|
|
// Download python
|
|
downloadThread *pydownloader = new downloadThread(this);
|
|
connect(pydownloader, SIGNAL(downloadFinished(QString,QString)), this, SLOT(pythonDownloadSuccess(QString,QString)));
|
|
connect(pydownloader, SIGNAL(downloadFailure(QString,QString)), this, SLOT(pythonDownloadFailure(QString,QString)));
|
|
pydownloader->downloadUrl("http://python.org/ftp/python/2.6.5/python-2.6.5.msi");
|
|
}
|
|
|
|
void SearchEngine::pythonDownloadSuccess(QString url, QString file_path) {
|
|
setCursor(QCursor(Qt::ArrowCursor));
|
|
Q_UNUSED(url);
|
|
QFile::rename(file_path, file_path+".msi");
|
|
QProcess installer;
|
|
qDebug("Launching Python installer in passive mode...");
|
|
|
|
installer.start("msiexec.exe /passive /i "+file_path.replace("/", "\\")+".msi");
|
|
// Wait for setup to complete
|
|
installer.waitForFinished();
|
|
|
|
qDebug("Installer stdout: %s", installer.readAllStandardOutput().data());
|
|
qDebug("Installer stderr: %s", installer.readAllStandardError().data());
|
|
qDebug("Setup should be complete!");
|
|
// Reload search engine
|
|
has_python = addPythonPathToEnv();
|
|
if(has_python) {
|
|
supported_engines->update();
|
|
// Launch the search again
|
|
on_search_button_clicked();
|
|
}
|
|
// Delete temp file
|
|
misc::safeRemove(file_path+".msi");
|
|
}
|
|
|
|
void SearchEngine::pythonDownloadFailure(QString url, QString error) {
|
|
Q_UNUSED(url);
|
|
setCursor(QCursor(Qt::ArrowCursor));
|
|
QMessageBox::warning(this, tr("Download error"), tr("Python setup could not be downloaded, reason: %1.\nPlease install it manually.").arg(error));
|
|
}
|
|
|
|
#endif
|
|
|
|
QString SearchEngine::selectedCategory() const {
|
|
return comboCategory->itemData(comboCategory->currentIndex()).toString();
|
|
}
|
|
|
|
SearchEngine::~SearchEngine(){
|
|
qDebug("Search destruction");
|
|
// save the searchHistory for later uses
|
|
saveSearchHistory();
|
|
searchProcess->kill();
|
|
searchProcess->waitForFinished();
|
|
foreach(QProcess *downloader, downloaders) {
|
|
// Make sure we disconnect the SIGNAL/SLOT first
|
|
// To avoid double free
|
|
downloader->disconnect();
|
|
downloader->kill();
|
|
downloader->waitForFinished();
|
|
delete downloader;
|
|
}
|
|
#if QT_VERSION < 0x040500
|
|
delete closeTab_button;
|
|
#endif
|
|
delete searchTimeout;
|
|
delete searchProcess;
|
|
delete supported_engines;
|
|
if(searchCompleter)
|
|
delete searchCompleter;
|
|
}
|
|
|
|
void SearchEngine::displayPatternContextMenu(QPoint) {
|
|
QMenu myMenu(this);
|
|
QAction cutAct(misc::getIcon("edit-cut"), tr("Cut"), &myMenu);
|
|
QAction copyAct(misc::getIcon("edit-copy"), tr("Copy"), &myMenu);
|
|
QAction pasteAct(misc::getIcon("edit-paste"), tr("Paste"), &myMenu);
|
|
QAction clearAct(misc::getIcon("edit-clear"), tr("Clear field"), &myMenu);
|
|
QAction clearHistoryAct(misc::getIcon("edit-clear-history"), tr("Clear completion history"), &myMenu);
|
|
bool hasCopyAct = false;
|
|
if(search_pattern->hasSelectedText()) {
|
|
myMenu.addAction(&cutAct);
|
|
myMenu.addAction(©Act);
|
|
hasCopyAct = true;
|
|
}
|
|
if(qApp->clipboard()->mimeData()->hasText()) {
|
|
myMenu.addAction(&pasteAct);
|
|
hasCopyAct = true;
|
|
}
|
|
if(hasCopyAct)
|
|
myMenu.addSeparator();
|
|
myMenu.addAction(&clearHistoryAct);
|
|
myMenu.addAction(&clearAct);
|
|
QAction *act = myMenu.exec(QCursor::pos());
|
|
if(act != 0) {
|
|
if(act == &clearHistoryAct) {
|
|
// Ask for confirmation
|
|
if(QMessageBox::question(this, tr("Confirmation"), tr("Are you sure you want to clear the history?"), QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes) {
|
|
// Clear history
|
|
searchHistory.setStringList(QStringList());
|
|
}
|
|
}
|
|
else if (act == &pasteAct) {
|
|
search_pattern->paste();
|
|
}
|
|
else if (act == &cutAct) {
|
|
search_pattern->cut();
|
|
}
|
|
else if (act == ©Act) {
|
|
search_pattern->copy();
|
|
}
|
|
else if (act == &clearAct) {
|
|
search_pattern->clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SearchEngine::tab_changed(int t)
|
|
{//when we switch from a tab that is not empty to another that is empty the download button
|
|
//doesn't have to be available
|
|
if(t>-1)
|
|
{//-1 = no more tab
|
|
if(all_tab.at(tabWidget->currentIndex())->getCurrentSearchListModel()->rowCount()) {
|
|
download_button->setEnabled(true);
|
|
goToDescBtn->setEnabled(true);
|
|
} else {
|
|
download_button->setEnabled(false);
|
|
goToDescBtn->setEnabled(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SearchEngine::on_enginesButton_clicked() {
|
|
engineSelectDlg *dlg = new engineSelectDlg(this, supported_engines);
|
|
connect(dlg, SIGNAL(enginesChanged()), this, SLOT(fillCatCombobox()));
|
|
}
|
|
|
|
// get the last searchs from a QIniSettings to a QStringList
|
|
void SearchEngine::startSearchHistory(){
|
|
QIniSettings settings("qBittorrent", "qBittorrent");
|
|
searchHistory.setStringList(settings.value("Search/searchHistory",QStringList()).toStringList());
|
|
}
|
|
|
|
// Save the history list into the QIniSettings for the next session
|
|
void SearchEngine::saveSearchHistory() {
|
|
QIniSettings settings("qBittorrent", "qBittorrent");
|
|
settings.setValue("Search/searchHistory",searchHistory.stringList());
|
|
}
|
|
|
|
void SearchEngine::searchTextEdited(QString) {
|
|
// Enable search button
|
|
search_button->setText(tr("Search"));
|
|
}
|
|
|
|
void SearchEngine::giveFocusToSearchInput() {
|
|
search_pattern->setFocus();
|
|
}
|
|
|
|
// Function called when we click on search button
|
|
void SearchEngine::on_search_button_clicked(){
|
|
#ifdef Q_WS_WIN
|
|
if(!has_python) {
|
|
if(QMessageBox::question(this, tr("Missing Python Interpreter"),
|
|
tr("Python 2.x is required to use the search engine but it does not seem to be installed.\nDo you want to install it now?"),
|
|
QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes) {
|
|
// Download and Install Python
|
|
installPython();
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
if(searchProcess->state() != QProcess::NotRunning){
|
|
#ifdef Q_WS_WIN
|
|
searchProcess->kill();
|
|
#else
|
|
searchProcess->terminate();
|
|
#endif
|
|
search_stopped = true;
|
|
if(searchTimeout->isActive()) {
|
|
searchTimeout->stop();
|
|
}
|
|
if(search_button->text() != tr("Search")) {
|
|
search_button->setText(tr("Search"));
|
|
return;
|
|
}
|
|
}
|
|
searchProcess->waitForFinished();
|
|
// Reload environment variables (proxy)
|
|
searchProcess->setEnvironment(QProcess::systemEnvironment());
|
|
|
|
QString pattern = search_pattern->text().trimmed();
|
|
// No search pattern entered
|
|
if(pattern.isEmpty()){
|
|
QMessageBox::critical(0, tr("Empty search pattern"), tr("Please type a search pattern first"));
|
|
return;
|
|
}
|
|
// Tab Addition
|
|
currentSearchTab=new SearchTab(this);
|
|
connect(currentSearchTab->header(), SIGNAL(sectionResized(int, int, int)), this, SLOT(propagateSectionResized(int,int,int)));
|
|
all_tab.append(currentSearchTab);
|
|
tabWidget->addTab(currentSearchTab, pattern);
|
|
tabWidget->setCurrentWidget(currentSearchTab);
|
|
#if QT_VERSION < 0x040500
|
|
closeTab_button->setEnabled(true);
|
|
#endif
|
|
// if the pattern is not in the pattern
|
|
QStringList wordList = searchHistory.stringList();
|
|
if(wordList.indexOf(pattern) == -1){
|
|
//update the searchHistory list
|
|
wordList.append(pattern);
|
|
// verify the max size of the history
|
|
if(wordList.size() > SEARCHHISTORY_MAXSIZE)
|
|
wordList = wordList.mid(wordList.size()/2);
|
|
searchHistory.setStringList(wordList);
|
|
}
|
|
|
|
// Getting checked search engines
|
|
QStringList params;
|
|
search_stopped = false;
|
|
params << misc::searchEngineLocation()+QDir::separator()+"nova2.py";
|
|
params << supported_engines->enginesEnabled().join(",");
|
|
qDebug("Search with category: %s", qPrintable(selectedCategory()));
|
|
params << selectedCategory();
|
|
params << pattern.split(" ");
|
|
// Update SearchEngine widgets
|
|
no_search_results = true;
|
|
nb_search_results = 0;
|
|
search_result_line_truncated.clear();
|
|
//on change le texte du label courrant
|
|
currentSearchTab->getCurrentLabel()->setText(tr("Results")+" <i>(0)</i>:");
|
|
// Launch search
|
|
searchProcess->start("python", params, QIODevice::ReadOnly);
|
|
searchTimeout->start(180000); // 3min
|
|
}
|
|
|
|
void SearchEngine::createCompleter() {
|
|
if(searchCompleter)
|
|
delete searchCompleter;
|
|
searchCompleter = new QCompleter(&searchHistory);
|
|
searchCompleter->setCaseSensitivity(Qt::CaseInsensitive);
|
|
search_pattern->setCompleter(searchCompleter);
|
|
}
|
|
|
|
void SearchEngine::propagateSectionResized(int index, int , int newsize) {
|
|
foreach(SearchTab * tab, all_tab) {
|
|
tab->getCurrentTreeView()->setColumnWidth(index, newsize);
|
|
}
|
|
saveResultsColumnsWidth();
|
|
}
|
|
|
|
void SearchEngine::saveResultsColumnsWidth() {
|
|
if(all_tab.size() > 0) {
|
|
QTreeView* treeview = all_tab.first()->getCurrentTreeView();
|
|
QIniSettings settings("qBittorrent", "qBittorrent");
|
|
QStringList width_list;
|
|
QStringList new_width_list;
|
|
short nbColumns = all_tab.first()->getCurrentSearchListModel()->columnCount();
|
|
|
|
QString line = settings.value("SearchResultsColsWidth", QString()).toString();
|
|
if(!line.isEmpty()) {
|
|
width_list = line.split(' ');
|
|
}
|
|
for(short i=0; i<nbColumns; ++i){
|
|
if(treeview->columnWidth(i)<1 && width_list.size() == nbColumns && width_list.at(i).toInt()>=1) {
|
|
// load the former width
|
|
new_width_list << width_list.at(i);
|
|
} else if(treeview->columnWidth(i)>=1) {
|
|
// usual case, save the current width
|
|
new_width_list << QString::number(treeview->columnWidth(i));
|
|
} else {
|
|
// default width
|
|
treeview->resizeColumnToContents(i);
|
|
new_width_list << QString::number(treeview->columnWidth(i));
|
|
}
|
|
}
|
|
settings.setValue("SearchResultsColsWidth", new_width_list.join(" "));
|
|
}
|
|
}
|
|
|
|
void SearchEngine::downloadTorrent(QString engine_url, QString torrent_url) {
|
|
if(torrent_url.startsWith("bc://bt/", Qt::CaseInsensitive)) {
|
|
qDebug("Converting bc link to magnet link");
|
|
torrent_url = misc::bcLinkToMagnet(torrent_url);
|
|
}
|
|
if(torrent_url.startsWith("magnet:")) {
|
|
QStringList urls;
|
|
urls << torrent_url;
|
|
mp_mainWindow->downloadFromURLList(urls);
|
|
} else {
|
|
QProcess *downloadProcess = new QProcess(this);
|
|
downloadProcess->setEnvironment(QProcess::systemEnvironment());
|
|
connect(downloadProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(downloadFinished(int,QProcess::ExitStatus)));
|
|
downloaders << downloadProcess;
|
|
QStringList params;
|
|
params << misc::searchEngineLocation()+QDir::separator()+"nova2dl.py";
|
|
params << engine_url;
|
|
params << torrent_url;
|
|
// Launch search
|
|
downloadProcess->start("python", params, QIODevice::ReadOnly);
|
|
}
|
|
}
|
|
|
|
void SearchEngine::searchStarted(){
|
|
// Update SearchEngine widgets
|
|
search_status->setText(tr("Searching..."));
|
|
search_status->repaint();
|
|
search_button->setText("Stop");
|
|
}
|
|
|
|
// search Qprocess return output as soon as it gets new
|
|
// stuff to read. We split it into lines and add each
|
|
// line to search results calling appendSearchResult().
|
|
void SearchEngine::readSearchOutput(){
|
|
QByteArray output = searchProcess->readAllStandardOutput();
|
|
output.replace("\r", "");
|
|
QList<QByteArray> lines_list = output.split('\n');
|
|
if(!search_result_line_truncated.isEmpty()){
|
|
QByteArray end_of_line = lines_list.takeFirst();
|
|
lines_list.prepend(search_result_line_truncated+end_of_line);
|
|
}
|
|
search_result_line_truncated = lines_list.takeLast().trimmed();
|
|
foreach(const QByteArray &line, lines_list){
|
|
appendSearchResult(QString::fromUtf8(line));
|
|
}
|
|
if(currentSearchTab)
|
|
currentSearchTab->getCurrentLabel()->setText(tr("Results")+QString::fromUtf8(" <i>(")+QString::number(nb_search_results)+QString::fromUtf8(")</i>:"));
|
|
}
|
|
|
|
void SearchEngine::downloadFinished(int exitcode, QProcess::ExitStatus) {
|
|
QProcess *downloadProcess = (QProcess*)sender();
|
|
if(exitcode == 0) {
|
|
QString line = QString::fromUtf8(downloadProcess->readAllStandardOutput()).trimmed();
|
|
QStringList parts = line.split(' ');
|
|
if(parts.size() == 2) {
|
|
QString path = parts[0];
|
|
QString url = parts[1];
|
|
QBtSession::instance()->processDownloadedFile(url, path);
|
|
}
|
|
}
|
|
qDebug("Deleting downloadProcess");
|
|
downloaders.removeOne(downloadProcess);
|
|
delete downloadProcess;
|
|
}
|
|
|
|
// Update nova.py search plugin if necessary
|
|
void SearchEngine::updateNova() {
|
|
qDebug("Updating nova");
|
|
// create nova directory if necessary
|
|
QDir search_dir(misc::searchEngineLocation());
|
|
QFile package_file(search_dir.absoluteFilePath("__init__.py"));
|
|
package_file.open(QIODevice::WriteOnly | QIODevice::Text);
|
|
package_file.close();
|
|
if(!search_dir.exists("engines")){
|
|
search_dir.mkdir("engines");
|
|
}
|
|
QFile package_file2(search_dir.absolutePath().replace("\\", "/")+"/engines/__init__.py");
|
|
package_file2.open(QIODevice::WriteOnly | QIODevice::Text);
|
|
package_file2.close();
|
|
// Copy search plugin files (if necessary)
|
|
QString filePath = search_dir.absoluteFilePath("nova2.py");
|
|
if(getPluginVersion(":/nova2/nova2.py") > getPluginVersion(filePath)) {
|
|
if(QFile::exists(filePath)) {
|
|
misc::safeRemove(filePath);
|
|
misc::safeRemove(filePath+"c");
|
|
}
|
|
QFile::copy(":/nova2/nova2.py", filePath);
|
|
}
|
|
|
|
filePath = search_dir.absoluteFilePath("nova2dl.py");
|
|
if(getPluginVersion(":/nova2/nova2dl.py") > getPluginVersion(filePath)) {
|
|
if(QFile::exists(filePath)){
|
|
misc::safeRemove(filePath);
|
|
misc::safeRemove(filePath+"c");
|
|
}
|
|
QFile::copy(":/nova2/nova2dl.py", filePath);
|
|
}
|
|
|
|
filePath = search_dir.absoluteFilePath("novaprinter.py");
|
|
if(getPluginVersion(":/nova2/novaprinter.py") > getPluginVersion(filePath)) {
|
|
if(QFile::exists(filePath)){
|
|
misc::safeRemove(filePath);
|
|
misc::safeRemove(filePath+"c");
|
|
}
|
|
QFile::copy(":/nova2/novaprinter.py", filePath);
|
|
}
|
|
|
|
filePath = search_dir.absoluteFilePath("helpers.py");
|
|
if(getPluginVersion(":/nova2/helpers.py") > getPluginVersion(filePath)) {
|
|
if(QFile::exists(filePath)){
|
|
misc::safeRemove(filePath);
|
|
misc::safeRemove(filePath+"c");
|
|
}
|
|
QFile::copy(":/nova2/helpers.py", filePath);
|
|
}
|
|
|
|
filePath = search_dir.absoluteFilePath("socks.py");
|
|
if(QFile::exists(filePath)){
|
|
misc::safeRemove(filePath);
|
|
misc::safeRemove(filePath+"c");
|
|
}
|
|
QFile::copy(":/nova2/socks.py", filePath);
|
|
QDir destDir(QDir(misc::searchEngineLocation()).absoluteFilePath("engines"));
|
|
QDir shipped_subDir(":/nova2/engines/");
|
|
QStringList files = shipped_subDir.entryList();
|
|
foreach(const QString &file, files){
|
|
QString shipped_file = shipped_subDir.absoluteFilePath(file);
|
|
// Copy python classes
|
|
if(file.endsWith(".py")) {
|
|
const QString dest_file = destDir.absoluteFilePath(file);
|
|
if(getPluginVersion(shipped_file) > getPluginVersion(dest_file) ) {
|
|
qDebug("shipped %s is more recent then local plugin, updating...", qPrintable(file));
|
|
if(QFile::exists(dest_file)) {
|
|
qDebug("Removing old %s", qPrintable(dest_file));
|
|
misc::safeRemove(dest_file);
|
|
misc::safeRemove(dest_file+"c");
|
|
}
|
|
qDebug("%s copied to %s", qPrintable(shipped_file), qPrintable(dest_file));
|
|
QFile::copy(shipped_file, dest_file);
|
|
}
|
|
} else {
|
|
// Copy icons
|
|
if(file.endsWith(".png")) {
|
|
if(!QFile::exists(destDir.absoluteFilePath(file))) {
|
|
QFile::copy(shipped_file, destDir.absoluteFilePath(file));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#ifndef Q_WS_WIN
|
|
// Fix permissions
|
|
misc::chmod644(QDir(misc::searchEngineLocation()));
|
|
#endif
|
|
}
|
|
|
|
// Slot called when search is Finished
|
|
// Search can be finished for 3 reasons :
|
|
// Error | Stopped by user | Finished normally
|
|
void SearchEngine::searchFinished(int exitcode,QProcess::ExitStatus){
|
|
if(searchTimeout->isActive()) {
|
|
searchTimeout->stop();
|
|
}
|
|
QIniSettings settings("qBittorrent", "qBittorrent");
|
|
bool useNotificationBalloons = settings.value("Preferences/General/NotificationBaloons", true).toBool();
|
|
if(useNotificationBalloons && mp_mainWindow->getCurrentTabWidget() != this) {
|
|
mp_mainWindow->showNotificationBaloon(tr("Search Engine"), tr("Search has finished"));
|
|
}
|
|
if(exitcode){
|
|
#ifdef Q_WS_WIN
|
|
search_status->setText(tr("Search aborted"));
|
|
#else
|
|
search_status->setText(tr("An error occured during search..."));
|
|
#endif
|
|
}else{
|
|
if(search_stopped){
|
|
search_status->setText(tr("Search aborted"));
|
|
}else{
|
|
if(no_search_results){
|
|
search_status->setText(tr("Search returned no results"));
|
|
}else{
|
|
search_status->setText(tr("Search has finished"));
|
|
}
|
|
}
|
|
}
|
|
if(currentSearchTab)
|
|
currentSearchTab->getCurrentLabel()->setText(tr("Results", "i.e: Search results")+QString::fromUtf8(" <i>(")+QString::number(nb_search_results)+QString::fromUtf8(")</i>:"));
|
|
search_button->setText("Search");
|
|
}
|
|
|
|
// SLOT to append one line to search results list
|
|
// Line is in the following form :
|
|
// file url | file name | file size | nb seeds | nb leechers | Search engine url
|
|
void SearchEngine::appendSearchResult(const QString &line){
|
|
if(!currentSearchTab) {
|
|
if(searchProcess->state() != QProcess::NotRunning){
|
|
searchProcess->terminate();
|
|
}
|
|
if(searchTimeout->isActive()) {
|
|
searchTimeout->stop();
|
|
}
|
|
search_stopped = true;
|
|
return;
|
|
}
|
|
const QStringList parts = line.split("|");
|
|
const int nb_fields = parts.size();
|
|
if(nb_fields < NB_PLUGIN_COLUMNS-1){ //-1 because desc_link is optional
|
|
return;
|
|
}
|
|
Q_ASSERT(currentSearchTab);
|
|
// Add item to search result list
|
|
QStandardItemModel* cur_model = currentSearchTab->getCurrentSearchListModel();
|
|
Q_ASSERT(cur_model);
|
|
int row = cur_model->rowCount();
|
|
cur_model->insertRow(row);
|
|
|
|
cur_model->setData(cur_model->index(row, DL_LINK), parts.at(PL_DL_LINK).trimmed()); // download URL
|
|
cur_model->setData(cur_model->index(row, NAME), parts.at(PL_NAME).trimmed()); // Name
|
|
cur_model->setData(cur_model->index(row, SIZE), parts.at(PL_SIZE).trimmed().toLongLong()); // Size
|
|
bool ok = false;
|
|
qlonglong nb_seeders = parts.at(PL_SEEDS).trimmed().toLongLong(&ok);
|
|
if(!ok || nb_seeders < 0) {
|
|
cur_model->setData(cur_model->index(row, SEEDS), tr("Unknown")); // Seeders
|
|
} else {
|
|
cur_model->setData(cur_model->index(row, SEEDS), nb_seeders); // Seeders
|
|
}
|
|
qlonglong nb_leechers = parts.at(PL_LEECHS).trimmed().toLongLong(&ok);
|
|
if(!ok || nb_leechers < 0) {
|
|
cur_model->setData(cur_model->index(row, LEECHS), tr("Unknown")); // Leechers
|
|
} else {
|
|
cur_model->setData(cur_model->index(row, LEECHS), nb_leechers); // Leechers
|
|
}
|
|
cur_model->setData(cur_model->index(row, ENGINE_URL), parts.at(PL_ENGINE_URL).trimmed()); // Engine URL
|
|
// Description Link
|
|
if(nb_fields == NB_PLUGIN_COLUMNS)
|
|
cur_model->setData(cur_model->index(row, DESC_LINK), parts.at(PL_DESC_LINK).trimmed());
|
|
|
|
no_search_results = false;
|
|
++nb_search_results;
|
|
// Enable clear & download buttons
|
|
download_button->setEnabled(true);
|
|
goToDescBtn->setEnabled(true);
|
|
}
|
|
|
|
#if QT_VERSION >= 0x040500
|
|
void SearchEngine::closeTab(int index) {
|
|
if(index == tabWidget->indexOf(currentSearchTab)) {
|
|
qDebug("Deleted current search Tab");
|
|
if(searchProcess->state() != QProcess::NotRunning){
|
|
searchProcess->terminate();
|
|
}
|
|
if(searchTimeout->isActive()) {
|
|
searchTimeout->stop();
|
|
}
|
|
search_stopped = true;
|
|
currentSearchTab = 0;
|
|
}
|
|
delete all_tab.takeAt(index);
|
|
if(!all_tab.size()) {
|
|
download_button->setEnabled(false);
|
|
goToDescBtn->setEnabled(false);
|
|
}
|
|
}
|
|
#else
|
|
// Clear search results list
|
|
void SearchEngine::closeTab_button_clicked(){
|
|
if(all_tab.size()) {
|
|
qDebug("currentTab rank: %d", tabWidget->currentIndex());
|
|
qDebug("currentSearchTab rank: %d", tabWidget->indexOf(currentSearchTab));
|
|
if(tabWidget->currentIndex() == tabWidget->indexOf(currentSearchTab)) {
|
|
qDebug("Deleted current search Tab");
|
|
if(searchProcess->state() != QProcess::NotRunning){
|
|
searchProcess->terminate();
|
|
}
|
|
if(searchTimeout->isActive()) {
|
|
searchTimeout->stop();
|
|
}
|
|
search_stopped = true;
|
|
currentSearchTab = 0;
|
|
}
|
|
delete all_tab.takeAt(tabWidget->currentIndex());
|
|
if(!all_tab.size()) {
|
|
closeTab_button->setEnabled(false);
|
|
download_button->setEnabled(false);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Download selected items in search results list
|
|
void SearchEngine::on_download_button_clicked(){
|
|
//QModelIndexList selectedIndexes = currentSearchTab->getCurrentTreeView()->selectionModel()->selectedIndexes();
|
|
QModelIndexList selectedIndexes = all_tab.at(tabWidget->currentIndex())->getCurrentTreeView()->selectionModel()->selectedIndexes();
|
|
foreach(const QModelIndex &index, selectedIndexes){
|
|
if(index.column() == NAME){
|
|
// Get Item url
|
|
QSortFilterProxyModel* model = all_tab.at(tabWidget->currentIndex())->getCurrentSearchListProxy();
|
|
QString torrent_url = model->data(model->index(index.row(), URL_COLUMN)).toString();
|
|
QString engine_url = model->data(model->index(index.row(), ENGINE_URL_COLUMN)).toString();
|
|
downloadTorrent(engine_url, torrent_url);
|
|
all_tab.at(tabWidget->currentIndex())->setRowColor(index.row(), "red");
|
|
}
|
|
}
|
|
}
|
|
|
|
void SearchEngine::on_goToDescBtn_clicked()
|
|
{
|
|
QModelIndexList selectedIndexes = all_tab.at(tabWidget->currentIndex())->getCurrentTreeView()->selectionModel()->selectedIndexes();
|
|
foreach(const QModelIndex &index, selectedIndexes){
|
|
if(index.column() == NAME) {
|
|
QSortFilterProxyModel* model = all_tab.at(tabWidget->currentIndex())->getCurrentSearchListProxy();
|
|
const QString desc_url = model->data(model->index(index.row(), DESC_LINK)).toString();
|
|
if(!desc_url.isEmpty())
|
|
QDesktopServices::openUrl(QUrl(desc_url));
|
|
}
|
|
}
|
|
}
|