README.md

@@ -4,8 +4,6 @@ search terms have been found, as shown in the screenshots below.
 
 
 ## Screenshots
-The screenshots in this section may occasionally be slightly outdated, but they are usually recent enough to get an overall impression of the current state.
-
 ### List
 ![Screenshot looqs results](https://garage.quitesimple.org/assets/looqs/opearting_systems_looqs.png)
 

gui/gui.pro

@@ -23,8 +23,7 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 
 SOURCES += \
-    ipcpreviewclient.cpp \
+    ipcclient.cpp \
-    ipcpreviewworker.cpp \
     ipcserver.cpp \
         main.cpp \
         mainwindow.cpp \
@@ -36,13 +35,11 @@ SOURCES += \
     previewresult.cpp \
     previewresultpdf.cpp \
     previewresultplaintext.cpp \
-    renderconfig.cpp \
+    previewworker.cpp
-    rendertarget.cpp
 
 HEADERS += \
     ipc.h \
-    ipcpreviewclient.h \
+    ipcclient.h \
-    ipcpreviewworker.h \
     ipcserver.h \
         mainwindow.h \
     clicklabel.h \
@@ -53,8 +50,8 @@ HEADERS += \
     previewresult.h \
     previewresultpdf.h \
     previewresultplaintext.h \
-    renderconfig.h \
+    previewworker.h \
-    rendertarget.h
+    renderconfig.h
 
 FORMS += \
         mainwindow.ui

gui/ipc.h

@@ -3,13 +3,8 @@
 
 enum IPCCommand
 {
-	GeneratePreviews = 23,
+	DocOpen,
-	StopGeneratePreviews,
+	FileOpen,
+	AddFile,
 };
-
-enum IPCReply
-{
-	FinishedGeneratePreviews,
-};
-
 #endif // IPC_H

gui/ipcclient.cpp

@@ -0,0 +1,27 @@
+#include <QDataStream>
+#include "ipcclient.h"
+
+IPCClient::IPCClient(QString socketPath)
+{
+	this->socketPath = socketPath;
+}
+
+bool IPCClient::sendCommand(IPCCommand command, QStringList args)
+{
+	bool result = false;
+	QLocalSocket socket;
+	socket.connectToServer(socketPath);
+	if(socket.isOpen() && socket.isWritable())
+	{
+		QDataStream stream(&socket);
+		stream << command;
+		stream << args;
+		socket.flush();
+		result = true;
+	}
+	else
+	{
+		qDebug() << "Not connected to IPC server";
+	}
+	return result;
+}

gui/ipcclient.h

@@ -0,0 +1,18 @@
+#ifndef IPCCLIENT_H
+#define IPCCLIENT_H
+#include <QLocalSocket>
+#include <QString>
+#include <QStringList>
+#include "ipc.h"
+
+class IPCClient
+{
+  private:
+	QString socketPath;
+
+  public:
+	IPCClient(QString socketPath);
+	bool sendCommand(IPCCommand command, QStringList args);
+};
+
+#endif // IPCCLIENT_H

gui/ipcpreviewclient.cpp

@@ -1,129 +0,0 @@
-#include <QLocalSocket>
-#include <QApplication>
-#include "ipc.h"
-#include "ipcpreviewclient.h"
-#include "previewresultpdf.h"
-#include "previewresultplaintext.h"
-
-bool IPCPreviewClient::connect()
-{
-	if(socket->state() == QLocalSocket::ConnectedState)
-	{
-		socket->disconnectFromServer();
-		if(socket->state() == QLocalSocket::ConnectedState)
-		{
-			socket->waitForDisconnected(100);
-		}
-	}
-	socket->connectToServer(socketPath);
-	socket->waitForConnected(100);
-	return socket->state() == QLocalSocket::ConnectedState;
-}
-
-QSharedPointer<PreviewResult> IPCPreviewClient::deserialize(QByteArray &array)
-{
-	QDataStream stream{&array, QIODevice::ReadOnly};
-
-	PreviewResultType type;
-	stream >> type;
-	if(type == PreviewResultType::PDF)
-	{
-		return PreviewResultPdf::deserialize(array);
-	}
-	if(type == PreviewResultType::PlainText)
-	{
-		return PreviewResultPlainText::deserialize(array);
-	}
-	return QSharedPointer<PreviewResult>(nullptr);
-}
-
-IPCPreviewClient::IPCPreviewClient()
-{
-	this->socket = new QLocalSocket(this);
-}
-
-void IPCPreviewClient::setSocketPath(QString socketPath)
-{
-	this->socketPath = socketPath;
-}
-
-void IPCPreviewClient::startGeneration(RenderConfig config, const QVector<RenderTarget> &targets)
-{
-	this->start(config, targets);
-}
-
-void IPCPreviewClient::start(RenderConfig config, const QVector<RenderTarget> &targets)
-{
-	if(targets.count() == 0)
-	{
-		return;
-	}
-
-	if(!connect() || !socket->isOpen())
-	{
-		emit error("Could not connect to IPC worker");
-		return;
-	}
-
-	if(socket->isOpen() && socket->isWritable())
-	{
-		QDataStream stream(socket);
-		stream << GeneratePreviews;
-		stream << config;
-		stream << targets;
-		socket->flush();
-
-		int numTarget = 0;
-		if(socket->isOpen() && socket->isReadable() && socket->state() == QLocalSocket::ConnectedState)
-		{
-			do
-			{
-				socket->waitForReadyRead(100);
-				stream.startTransaction();
-				stream >> numTarget;
-			} while(!stream.commitTransaction() && socket->state() == QLocalSocket::ConnectedState);
-			if(numTarget != targets.count())
-			{
-				throw std::runtime_error("Server reports less targets than it should");
-			}
-		}
-		else
-		{
-			emit error("Error while trying to process previews: " + socket->errorString());
-			return;
-		}
-
-		int processed = 0;
-		++this->currentPreviewGeneration;
-		while(socket->isOpen() && socket->isReadable() && processed < targets.count())
-		{
-			QByteArray array;
-			do
-			{
-				socket->waitForReadyRead(100);
-				stream.startTransaction();
-				stream >> array;
-			} while(!stream.commitTransaction() && socket->state() == QLocalSocket::ConnectedState);
-			emit previewReceived(deserialize(array), this->currentPreviewGeneration);
-			++processed;
-		}
-		if(processed != targets.count())
-		{
-			emit error("IPC worker didn't send enough previews. This is a bug, please report");
-		}
-	}
-	socket->disconnectFromServer();
-	emit finished();
-}
-
-void IPCPreviewClient::stopGeneration()
-{
-	if(!connect() || !socket->isOpen())
-	{
-		emit error("Could not connect to IPC worker");
-		return;
-	}
-	QDataStream stream(socket);
-	stream << StopGeneratePreviews;
-	socket->flush();
-}

gui/ipcpreviewclient.h

@@ -1,37 +0,0 @@
-#ifndef IPCPREVIEWCLIENT_H
-#define IPCPREVIEWCLIENT_H
-#include <QObject>
-#include <QLocalSocket>
-#include "previewresult.h"
-#include "renderconfig.h"
-#include "rendertarget.h"
-
-class IPCPreviewClient : public QObject
-{
-	Q_OBJECT
-  private:
-	unsigned int currentPreviewGeneration = 1;
-	QLocalSocket *socket;
-	QString socketPath;
-
-	bool connect();
-	QSharedPointer<PreviewResult> deserialize(QByteArray &array);
-
-  public:
-	IPCPreviewClient();
-	~IPCPreviewClient()
-	{
-		delete socket;
-	}
-	void setSocketPath(QString socketPath);
-  public slots:
-	void start(RenderConfig config, const QVector<RenderTarget> &targets);
-	void startGeneration(RenderConfig config, const QVector<RenderTarget> &targets);
-	void stopGeneration();
-  signals:
-	void previewReceived(QSharedPointer<PreviewResult> previewResult, unsigned int currentPreviewGeneration);
-	void finished();
-	void error(QString);
-};
-
-#endif // IPCPREVIEWCLIENT_H

gui/ipcpreviewworker.cpp

@@ -1,24 +0,0 @@
-#include <QtConcurrent>
-#include "ipcpreviewworker.h"
-#include "previewgeneratormapfunctor.h"
-IPCPreviewWorker::IPCPreviewWorker()
-{
-	this->connect(&previewWorkerWatcher, &QFutureWatcher<QByteArray>::resultReadyAt, this,
-				  [this](int index) { emit previewGenerated(previewWorkerWatcher.resultAt(index)); });
-	connect(&previewWorkerWatcher, &QFutureWatcher<QByteArray>::finished, this, [this] { emit finished(); });
-}
-
-void IPCPreviewWorker::start(RenderConfig config, const QVector<RenderTarget> &targets, QLocalSocket *peer)
-{
-	stop();
-	auto mapFunctor = PreviewGeneratorMapFunctor();
-	mapFunctor.setRenderConfig(config);
-
-	previewWorkerWatcher.setFuture(QtConcurrent::mapped(targets, mapFunctor));
-}
-
-void IPCPreviewWorker::stop()
-{
-	previewWorkerWatcher.cancel();
-	previewWorkerWatcher.waitForFinished();
-}

gui/ipcpreviewworker.h

@@ -1,24 +0,0 @@
-#ifndef IPCPREVIEWWORKER_H
-#define IPCPREVIEWWORKER_H
-#include <QLocalSocket>
-#include <QFutureWatcher>
-#include "renderconfig.h"
-#include "rendertarget.h"
-#include "previewgenerator.h"
-
-class IPCPreviewWorker : public QObject
-{
-	Q_OBJECT
-  private:
-	QFutureWatcher<QByteArray> previewWorkerWatcher;
-
-  public:
-	IPCPreviewWorker();
-	void start(RenderConfig config, const QVector<RenderTarget> &targets, QLocalSocket *peer);
-	void stop();
-  signals:
-	void previewGenerated(QByteArray);
-	void finished();
-};
-
-#endif // IPCPREVIEWWORKER_H

gui/ipcserver.cpp

@@ -9,17 +9,13 @@
 #include "common.h"
 #include "databasefactory.h"
 #include "../shared/logger.h"
-#include "renderconfig.h"
-#include "rendertarget.h"
-#include "ipcpreviewworker.h"
 
 IpcServer::IpcServer()
 {
-	/* Only 1, we are doing work for the GUI, not a service for general availability */
+	this->dbFactory = QSharedPointer<DatabaseFactory>(new DatabaseFactory(Common::databasePath()));
-	this->spawningServer.setMaxPendingConnections(1);
+	this->dbService = QSharedPointer<SqliteDbService>(new SqliteDbService(*this->dbFactory.get()));
+	this->fileSaver = QSharedPointer<FileSaver>(new FileSaver(*this->dbService.get()));
 	connect(&this->spawningServer, &QLocalServer::newConnection, this, &IpcServer::spawnerNewConnection);
-	connect(&this->previewWorker, &IPCPreviewWorker::previewGenerated, this, &IpcServer::handlePreviewGenerated);
-	connect(&this->previewWorker, &IPCPreviewWorker::finished, this, [this] { this->currentSocket->flush(); });
 }
 
 bool IpcServer::startSpawner(QString socketPath)
@@ -28,46 +24,85 @@ bool IpcServer::startSpawner(QString socketPath)
 	return this->spawningServer.listen(socketPath);
 }
 
+bool IpcServer::docOpen(QString path, int pagenum)
+{
+
+	QSettings settings;
+	QString command = settings.value("pdfviewer").toString();
+	if(path.endsWith(".pdf") && command != "" && command.contains("%p") && command.contains("%f"))
+	{
+		QStringList splitted = command.split(" ");
+		if(splitted.size() > 1)
+		{
+			QString cmd = splitted[0];
+			QStringList args = splitted.mid(1);
+			args.replaceInStrings("%f", path);
+			args.replaceInStrings("%p", QString::number(pagenum));
+
+			QProcess::startDetached(cmd, args);
+		}
+	}
+	else
+	{
+		QDesktopServices::openUrl(QUrl::fromLocalFile(path));
+	}
+	return true;
+}
+
+bool IpcServer::fileOpen(QString path)
+{
+	return QDesktopServices::openUrl(QUrl::fromLocalFile(path));
+}
+
+SaveFileResult IpcServer::addFile(QString file)
+{
+	try
+	{
+		return this->fileSaver->addFile(file);
+	}
+	catch(std::exception &e)
+	{
+		Logger::error() << e.what() << Qt::endl;
+		return PROCESSFAIL;
+	}
+}
+
 void IpcServer::spawnerNewConnection()
 {
-	QLocalSocket *socket = this->spawningServer.nextPendingConnection();
+	QScopedPointer<QLocalSocket> socket{this->spawningServer.nextPendingConnection()};
-	connect(socket, &QLocalSocket::disconnected, socket, &QLocalSocket::deleteLater);
+	if(!socket.isNull())
-	this->currentSocket = socket;
-	if(socket != nullptr)
 	{
 		if(!socket->waitForReadyRead())
 		{
 			return;
 		}
-		QDataStream stream(socket);
+		QDataStream stream(socket.get());
 		IPCCommand command;
+		QStringList args;
 		stream >> command;
-		if(command == GeneratePreviews)
+		stream >> args;
+		if(args.size() < 1)
 		{
-			RenderConfig renderConfig;
+			stream << "invalid";
-			QVector<RenderTarget> targets;
+			return;
-			do
-			{
-				/* TODO: this is not entirely robust */
-				socket->waitForReadyRead(100);
-				stream.startTransaction();
-				stream >> renderConfig >> targets;
-			} while(!stream.commitTransaction() && socket->state() == QLocalSocket::ConnectedState);
-
-			stream << targets.count();
-			socket->flush();
-			previewWorker.start(renderConfig, targets, socket);
 		}
-		if(command == StopGeneratePreviews)
+		if(command == DocOpen)
 		{
-			previewWorker.stop();
+			if(args.size() < 2)
+			{
+				stream << "invalid";
+				return;
+			}
+			docOpen(args[0], args[1].toInt());
+		}
+		if(command == FileOpen)
+		{
+			if(args.size() < 1)
+			{
+				stream << "invalid";
+				return;
+			}
+			fileOpen(args[0]);
 		}
 	}
 }
-
-void IpcServer::handlePreviewGenerated(QByteArray ba)
-{
-	QDataStream stream{this->currentSocket};
-	stream << ba;
-	this->currentSocket->flush();
-}

gui/ipcserver.h

@@ -4,19 +4,19 @@
 #include <QLocalServer>
 #include "ipc.h"
 #include "filesaver.h"
-#include "ipcpreviewworker.h"
-
 class IpcServer : public QObject
 {
 	Q_OBJECT
   private:
-	IPCPreviewWorker previewWorker;
+	QSharedPointer<DatabaseFactory> dbFactory;
+	QSharedPointer<SqliteDbService> dbService;
+	QSharedPointer<FileSaver> fileSaver;
 	QLocalServer spawningServer;
-	QLocalSocket *currentSocket = nullptr;
+	bool docOpen(QString path, int pagenum);
+	bool fileOpen(QString path);
 	SaveFileResult addFile(QString file);
   private slots:
 	void spawnerNewConnection();
-	void handlePreviewGenerated(QByteArray ba);
 
   public:
 	IpcServer();

gui/main.cpp

@@ -5,7 +5,6 @@
 #include <QProcess>
 #include <QDir>
 #include <QCommandLineParser>
-#include <QFileInfo>
 
 #include "mainwindow.h"
 #include "searchresult.h"
@@ -33,46 +32,15 @@ void enableSandbox()
 	}
 	exile_free_policy(policy);
 }
-
-void enableIpcSandbox()
-{
-	struct exile_policy *policy = exile_create_policy();
-	if(policy == NULL)
-	{
-		qCritical() << "Failed to init policy for sandbox";
-		exit(EXIT_FAILURE);
-	}
-	policy->namespace_options = EXILE_UNSHARE_NETWORK | EXILE_UNSHARE_USER;
-	policy->no_new_privs = 1;
-	policy->drop_caps = 1;
-	policy->vow_promises = exile_vows_from_str("thread cpath wpath rpath unix stdio prot_exec proc shm fsnotify ioctl");
-
-	QString ipcSocketPath = Common::ipcSocketPath();
-	QFileInfo info{ipcSocketPath};
-	QString ipcSocketPathDir = info.absolutePath();
-	std::string stdIpcSocketPath = ipcSocketPathDir.toStdString();
-
-	exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ, "/");
-	exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_ALL_WRITE, stdIpcSocketPath.c_str());
-	int ret = exile_enable_policy(policy);
-	if(ret != 0)
-	{
-		qDebug() << "Failed to establish sandbox";
-		exit(EXIT_FAILURE);
-	}
-	exile_free_policy(policy);
-}
-
 int main(int argc, char *argv[])
 {
-	QString socketPath = Common::ipcSocketPath();
+	QString socketPath = "/tmp/looqs-spawner";
 	if(argc > 1)
 	{
 		QString arg = argv[1];
 		if(arg == "ipc")
 		{
 			Common::setupAppInfo();
-			enableIpcSandbox();
 			QApplication a(argc, argv);
 
 			IpcServer *ipcserver = new IpcServer();
@@ -102,24 +70,10 @@ int main(int argc, char *argv[])
 			return processor.process();
 		}
 	}
-	QString ipcSocketPath = Common::ipcSocketPath();
-	QFileInfo info{ipcSocketPath};
-	QString ipcSocketPathDir = info.absolutePath();
-
-	QDir dir;
-	if(!dir.mkpath(ipcSocketPathDir))
-	{
-		qCritical() << "Failed to create dir for ipc socket" << Qt::endl;
-		exit(EXIT_FAILURE);
-	}
-
 	QProcess process;
 	QStringList args;
 	args << "ipc";
-	process.setProcessChannelMode(QProcess::ForwardedChannels);
+	if(!process.startDetached("/proc/self/exe", args))
-
-	process.start("/proc/self/exe", args);
-	if(!process.waitForStarted(5000))
 	{
 		QString errorMsg = "Failed to start IPC server";
 		qDebug() << errorMsg;
@@ -154,18 +108,17 @@ int main(int argc, char *argv[])
 		QMessageBox::critical(nullptr, "Error", e.message);
 		return 1;
 	}
+	// Keep this post sandbox, afterwards does not work (suspect due to threads, but unconfirmed)
 	QApplication a(argc, argv);
 	a.setWindowIcon(QIcon(":/icon.svg"));
-	QObject::connect(&a, &QApplication::aboutToQuit, &process, &QProcess::kill);
 
 	qRegisterMetaType<QVector<SearchResult>>("QVector<SearchResult>");
 	qRegisterMetaType<QVector<PreviewResultPdf>>("QVector<PreviewResultPdf>");
 	qRegisterMetaType<PreviewResultPdf>("PreviewResultPdf");
 	qRegisterMetaType<FileScanResult>("FileScanResult");
-	qRegisterMetaType<RenderConfig>("RenderConfig");
+
-	qRegisterMetaType<QVector<RenderTarget>>("QVector<RenderTarget>");
+	IPCClient client{socketPath};
-	qRegisterMetaType<QSharedPointer<PreviewResult>>("QSharedPointer<PreviewResult>");
+	MainWindow w{0, client};
-	MainWindow w{0, socketPath};
 	w.showMaximized();
 	return a.exec();
 }

gui/mainwindow.cpp

@@ -13,43 +13,18 @@
 #include <QtConcurrent/QtConcurrent>
 #include <QMessageBox>
 #include <QFileDialog>
-#include <QScreen>
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
 #include "clicklabel.h"
 #include "../shared/sqlitesearch.h"
 #include "../shared/looqsgeneralexception.h"
 #include "../shared/common.h"
-#include "ipcpreviewclient.h"
-#include "previewgenerator.h"
 
-MainWindow::MainWindow(QWidget *parent, QString socketPath) : QMainWindow(parent), ui(new Ui::MainWindow)
+MainWindow::MainWindow(QWidget *parent, IPCClient &client) : QMainWindow(parent), ui(new Ui::MainWindow)
 {
 	ui->setupUi(this);
 	setWindowTitle(QCoreApplication::applicationName());
-	this->ipcPreviewClient.moveToThread(&this->ipcClientThread);
+	this->ipcClient = &client;
-	this->ipcPreviewClient.setSocketPath(socketPath);
-
-	connect(&ipcPreviewClient, &IPCPreviewClient::previewReceived, this, &MainWindow::previewReceived,
-			Qt::QueuedConnection);
-	connect(&ipcPreviewClient, &IPCPreviewClient::finished, this,
-			[&]
-			{
-				this->ui->previewProcessBar->setValue(this->ui->previewProcessBar->maximum());
-				this->ui->spinPreviewPage->setEnabled(true);
-			});
-	connect(&ipcPreviewClient, &IPCPreviewClient::error, this,
-			[this](QString msg)
-			{
-				qCritical() << msg << Qt::endl;
-				QMessageBox::critical(this, "IPC error", msg);
-			});
-
-	connect(this, &MainWindow::startIpcPreviews, &ipcPreviewClient, &IPCPreviewClient::startGeneration,
-			Qt::QueuedConnection);
-	connect(this, &MainWindow::stopIpcPreviews, &ipcPreviewClient, &IPCPreviewClient::stopGeneration,
-			Qt::QueuedConnection);
-	this->ipcClientThread.start();
 	QSettings settings;
 
 	this->dbFactory = new DatabaseFactory(Common::databasePath());
@@ -71,9 +46,6 @@ MainWindow::MainWindow(QWidget *parent, QString socketPath) : QMainWindow(parent
 
 	QStringList indexPaths = settings.value("indexPaths").toStringList();
 	ui->lstPaths->addItems(indexPaths);
-
-	ui->spinPreviewPage->setValue(1);
-	ui->spinPreviewPage->setMinimum(1);
 }
 
 void MainWindow::addPathToIndex()
@@ -110,18 +82,16 @@ void MainWindow::connectSignals()
 					handleSearchError(e.message);
 				}
 			});
-
+	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::resultReadyAt, this,
-	/* connect(&previewWorkerWatcher, &QFutureWatcher<QByteArray>::resultReadyAt, this,
+			[&](int index) { previewReceived(previewWorkerWatcher.resultAt(index)); });
-			[&](int index) {
-		previewReceived(previewWorkerWatcher.resultAt(index)); });
 	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::progressValueChanged,
 			ui->previewProcessBar, &QProgressBar::setValue);
 	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::started, this,
-					[&] { ui->indexerTab->setEnabled(false); });*/
+			[&] { ui->indexerTab->setEnabled(false); });
 
-	/*connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::finished, this,
+	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::finished, this,
 			[&] { ui->indexerTab->setEnabled(true); });
-	*/
+
 	connect(ui->treeResultsList, &QTreeWidget::itemActivated, this, &MainWindow::treeSearchItemActivated);
 	connect(ui->treeResultsList, &QTreeWidget::customContextMenuRequested, this,
 			&MainWindow::showSearchResultsContextMenu);
@@ -291,21 +261,16 @@ void MainWindow::tabChanged()
 	}
 }
 
-void MainWindow::previewReceived(QSharedPointer<PreviewResult> preview, unsigned int previewGeneration)
+void MainWindow::previewReceived(QSharedPointer<PreviewResult> preview)
 {
-	if(previewGeneration < this->currentPreviewGeneration)
+	if(preview->hasPreview())
-	{
-		return;
-	}
-	this->ui->previewProcessBar->setValue(this->ui->previewProcessBar->value() + 1);
-	if(!preview.isNull() && preview->hasPreview())
 	{
 		QString docPath = preview->getDocumentPath();
 		auto previewPage = preview->getPage();
 
 		ClickLabel *label = dynamic_cast<ClickLabel *>(preview->createPreviewWidget());
 		ui->scrollAreaWidgetContents->layout()->addWidget(label);
-		connect(label, &ClickLabel::leftClick, [this, docPath, previewPage]() { openDocument(docPath, previewPage); });
+		connect(label, &ClickLabel::leftClick, [this, docPath, previewPage]() { ipcDocOpen(docPath, previewPage); });
 		connect(label, &ClickLabel::rightClick,
 				[this, docPath, previewPage]()
 				{
@@ -392,8 +357,10 @@ void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 	ui->treeResultsList->resizeColumnToContents(1);
 	previewDirty = !this->previewableSearchResults.empty();
 
+	int numpages = ceil(static_cast<double>(this->previewableSearchResults.size()) / previewsPerPage);
+	ui->spinPreviewPage->setMinimum(1);
+	ui->spinPreviewPage->setMaximum(numpages);
 	ui->spinPreviewPage->setValue(1);
-
 	if(previewTabActive() && previewDirty)
 	{
 		makePreviews(1);
@@ -409,10 +376,12 @@ void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 
 void MainWindow::makePreviews(int page)
 {
-	if(this->previewableSearchResults.empty())
+
-	{
+	this->previewWorkerWatcher.cancel();
-		return;
+	this->previewWorkerWatcher.waitForFinished();
-	}
+
+	QCoreApplication::processEvents(); // Maybe not necessary anymore, depends on whether it's possible that a slot is
+									   // still to be fired.
 	qDeleteAll(ui->scrollAreaWidgetContents->children());
 
 	ui->scrollAreaWidgetContents->setLayout(new QHBoxLayout());
@@ -440,43 +409,14 @@ void MainWindow::makePreviews(int page)
 			}
 		}
 	}
+	PreviewWorker worker;
 	int end = previewsPerPage;
 	int begin = page * previewsPerPage - previewsPerPage;
-	if(begin < 0)
+	this->previewWorkerWatcher.setFuture(worker.generatePreviews(this->previewableSearchResults.mid(begin, end),
-	{
+																 wordsToHighlight, scaleText.toInt() / 100.));
-		// Should not happen actually
+	ui->previewProcessBar->setMaximum(this->previewWorkerWatcher.progressMaximum());
-		begin = 0;
+	ui->previewProcessBar->setMinimum(this->previewWorkerWatcher.progressMinimum());
-	}
-
-	RenderConfig renderConfig;
-	renderConfig.scaleX = QGuiApplication::primaryScreen()->physicalDotsPerInchX() * (scaleText.toInt() / 100.);
-	renderConfig.scaleY = QGuiApplication::primaryScreen()->physicalDotsPerInchY() * (scaleText.toInt() / 100.);
-	renderConfig.wordsToHighlight = wordsToHighlight;
-
-	QVector<RenderTarget> targets;
-	for(SearchResult &sr : this->previewableSearchResults)
-	{
-		RenderTarget renderTarget;
-		renderTarget.path = sr.fileData.absPath;
-
-		for(unsigned int pagenum : sr.pages)
-		{
-			renderTarget.page = (int)pagenum;
-			targets.append(renderTarget);
-		}
-	}
-	int numpages = ceil(static_cast<double>(targets.size()) / previewsPerPage);
-	ui->spinPreviewPage->setMaximum(numpages);
-	targets = targets.mid(begin, end);
-
-	ui->lblTotalPreviewPagesCount->setText(QString::number(numpages));
-	ui->previewProcessBar->setMaximum(targets.count());
-	ui->previewProcessBar->setMinimum(0);
-	ui->previewProcessBar->setValue(0);
 	ui->previewProcessBar->setVisible(this->previewableSearchResults.size() > 0);
-	++this->currentPreviewGeneration;
-	this->ui->spinPreviewPage->setEnabled(false);
-	emit startIpcPreviews(renderConfig, targets);
 }
 
 void MainWindow::handleSearchError(QString error)
@@ -490,39 +430,27 @@ void MainWindow::createSearchResutlMenu(QMenu &menu, const QFileInfo &fileInfo)
 				   [&fileInfo] { QGuiApplication::clipboard()->setText(fileInfo.fileName()); });
 	menu.addAction("Copy full path to clipboard",
 				   [&fileInfo] { QGuiApplication::clipboard()->setText(fileInfo.absoluteFilePath()); });
-	menu.addAction("Open containing folder", [this, &fileInfo] { this->openFile(fileInfo.absolutePath()); });
+	menu.addAction("Open containing folder", [this, &fileInfo] { this->ipcFileOpen(fileInfo.absolutePath()); });
 }
 
-void MainWindow::openDocument(QString path, int num)
+void MainWindow::ipcDocOpen(QString path, int num)
 {
-	QSettings settings;
+	QStringList args;
-	QString command = settings.value("pdfviewer").toString();
+	args << path;
-	if(path.endsWith(".pdf") && command != "" && command.contains("%p") && command.contains("%f"))
+	args << QString::number(num);
-	{
+	this->ipcClient->sendCommand(DocOpen, args);
-		QStringList splitted = command.split(" ");
-		if(splitted.size() > 1)
-		{
-			QString cmd = splitted[0];
-			QStringList args = splitted.mid(1);
-			args.replaceInStrings("%f", path);
-			args.replaceInStrings("%p", QString::number(num));
-			QProcess::startDetached(cmd, args);
-		}
-	}
-	else
-	{
-		QDesktopServices::openUrl(QUrl::fromLocalFile(path));
-	}
 }
 
-void MainWindow::openFile(QString path)
+void MainWindow::ipcFileOpen(QString path)
 {
-	QDesktopServices::openUrl(QUrl::fromLocalFile(path));
+	QStringList args;
+	args << path;
+	this->ipcClient->sendCommand(FileOpen, args);
 }
 
 void MainWindow::treeSearchItemActivated(QTreeWidgetItem *item, int i)
 {
-	openFile(item->text(1));
+	ipcFileOpen(item->text(1));
 }
 
 void MainWindow::showSearchResultsContextMenu(const QPoint &point)

gui/mainwindow.h

@@ -9,8 +9,9 @@
 #include <QFutureWatcher>
 #include <QSqlDatabase>
 #include <QLocalSocket>
+#include "previewworker.h"
 #include "../shared/looqsquery.h"
-#include "ipcpreviewclient.h"
+#include "ipcclient.h"
 #include "indexer.h"
 namespace Ui
 {
@@ -22,7 +23,7 @@ class MainWindow : public QMainWindow
 	Q_OBJECT
 
   public:
-	explicit MainWindow(QWidget *parent, QString socketPath);
+	explicit MainWindow(QWidget *parent, IPCClient &client);
 	~MainWindow();
   signals:
 	void beginSearch(const QString &query);
@@ -32,14 +33,13 @@ class MainWindow : public QMainWindow
 	DatabaseFactory *dbFactory;
 	SqliteDbService *dbService;
 	Ui::MainWindow *ui;
-	IPCPreviewClient ipcPreviewClient;
+	IPCClient *ipcClient;
-	QThread ipcClientThread;
-
 	Indexer *indexer;
 	QFileIconProvider iconProvider;
 	bool previewDirty;
 	QSqlDatabase db;
 	QFutureWatcher<QVector<SearchResult>> searchWatcher;
+	QFutureWatcher<QSharedPointer<PreviewResult>> previewWorkerWatcher;
 	void add(QString path, unsigned int page);
 	QVector<SearchResult> previewableSearchResults;
 	void connectSignals();
@@ -53,24 +53,20 @@ class MainWindow : public QMainWindow
 	LooqsQuery contentSearchQuery;
 	int previewsPerPage;
 	void createSearchResutlMenu(QMenu &menu, const QFileInfo &fileInfo);
-	void openDocument(QString path, int num);
+	void ipcDocOpen(QString path, int num);
-	void openFile(QString path);
+	void ipcFileOpen(QString path);
-	unsigned int currentPreviewGeneration = 1;
+
   private slots:
 	void lineEditReturnPressed();
 	void treeSearchItemActivated(QTreeWidgetItem *item, int i);
 	void showSearchResultsContextMenu(const QPoint &point);
 	void tabChanged();
-	void previewReceived(QSharedPointer<PreviewResult> preview, unsigned int previewGeneration);
+	void previewReceived(QSharedPointer<PreviewResult> preview);
 	void comboScaleChanged(int i);
 	void spinPreviewPageValueChanged(int val);
 	void startIndexing();
 	void finishIndexing();
 	void addPathToIndex();
-
-  signals:
-	void startIpcPreviews(RenderConfig config, const QVector<RenderTarget> &targets);
-	void stopIpcPreviews();
 };
 
 #endif // MAINWINDOW_H

gui/mainwindow.ui

@@ -27,7 +27,7 @@
        <enum>QTabWidget::South</enum>
       </property>
       <property name="currentIndex">
-       <number>1</number>
+       <number>2</number>
       </property>
       <widget class="QWidget" name="resultsTab">
        <attribute name="title">
@@ -155,13 +155,6 @@
             </property>
            </widget>
           </item>
-          <item>
-           <widget class="QLabel" name="lblTotalPreviewPagesCount">
-            <property name="text">
-             <string/>
-            </property>
-           </widget>
-          </item>
           <item>
            <spacer name="horizontalSpacer">
             <property name="orientation">
@@ -356,7 +349,7 @@
     <item>
      <widget class="QProgressBar" name="previewProcessBar">
       <property name="value">
-       <number>0</number>
+       <number>24</number>
       </property>
      </widget>
     </item>

gui/previewgenerator.h

@@ -9,7 +9,7 @@
 class PreviewGenerator
 {
   public:
-	virtual QSharedPointer<PreviewResult> generate(RenderConfig config, QString documentPath, unsigned int page) = 0;
+	virtual PreviewResult *generate(RenderConfig config, QString documentPath, unsigned int page) = 0;
 	virtual ~PreviewGenerator()
 	{
 	}

gui/previewgeneratormapfunctor.cpp

@@ -10,15 +10,16 @@ void PreviewGeneratorMapFunctor::setRenderConfig(RenderConfig config)
 	this->renderConfig = config;
 }
 
-QByteArray PreviewGeneratorMapFunctor::operator()(const RenderTarget &renderTarget)
+QSharedPointer<PreviewResult> PreviewGeneratorMapFunctor::operator()(const QSharedPointer<PreviewResult> &renderResult)
 {
-	QFileInfo info{renderTarget.path};
+	QFileInfo info{renderResult->getDocumentPath()};
 	PreviewGenerator *previewGenerator = PreviewGenerator::get(info);
 	if(previewGenerator == nullptr)
 	{
-		return QByteArray{};
+		return QSharedPointer<PreviewResult>();
 	}
-	auto preview = previewGenerator->generate(this->renderConfig, renderTarget.path, renderTarget.page);
+	auto preview =
+		previewGenerator->generate(this->renderConfig, renderResult->getDocumentPath(), renderResult->getPage());
 
-	return preview->serialize();
+	return QSharedPointer<PreviewResult>(preview);
 }

gui/previewgeneratormapfunctor.h

@@ -2,9 +2,8 @@
 #define PREVIEWGENERATORMAPFUNCTOR_H
 
 #include "renderconfig.h"
-#include "rendertarget.h"
-
 #include "previewgenerator.h"
+
 class PreviewGeneratorMapFunctor
 {
 
@@ -17,13 +16,13 @@ class PreviewGeneratorMapFunctor
 	RenderConfig renderConfig;
 
   public:
-	typedef QByteArray result_type;
+	typedef QSharedPointer<PreviewResult> result_type;
 
 	PreviewGeneratorMapFunctor();
 
 	void setRenderConfig(RenderConfig config);
 
-	QByteArray operator()(const RenderTarget &renderTarget);
+	QSharedPointer<PreviewResult> operator()(const QSharedPointer<PreviewResult> &renderResult);
 };
 
 #endif // PREVIEWGENERATORMAPFUNCTOR_H

gui/previewgeneratorpdf.cpp

@@ -1,5 +1,6 @@
 #include <QMutexLocker>
 #include <QPainter>
+
 #include "previewgeneratorpdf.h"
 
 static QMutex cacheMutex;
@@ -23,18 +24,18 @@ Poppler::Document *PreviewGeneratorPdf::document(QString path)
 	return result;
 }
 
-QSharedPointer<PreviewResult> PreviewGeneratorPdf::generate(RenderConfig config, QString documentPath,
+PreviewResult *PreviewGeneratorPdf::generate(RenderConfig config, QString documentPath, unsigned int page)
-															unsigned int page)
 {
 	PreviewResultPdf *result = new PreviewResultPdf(documentPath, page);
+
 	Poppler::Document *doc = document(documentPath);
 	if(doc == nullptr)
 	{
-		return QSharedPointer<PreviewResult>(result);
+		return result;
 	}
 	if(doc->isLocked())
 	{
-		return QSharedPointer<PreviewResult>(result);
+		return result;
 	}
 	int p = (int)page - 1;
 	if(p < 0)
@@ -54,5 +55,5 @@ QSharedPointer<PreviewResult> PreviewGeneratorPdf::generate(RenderConfig config,
 		}
 	}
 	result->previewImage = img;
-	return QSharedPointer<PreviewResult>(result);
+	return result;
 }

gui/previewgeneratorpdf.h

@@ -13,7 +13,7 @@ class PreviewGeneratorPdf : public PreviewGenerator
   public:
 	using PreviewGenerator::PreviewGenerator;
 
-	QSharedPointer<PreviewResult> generate(RenderConfig config, QString documentPath, unsigned int page);
+	PreviewResult *generate(RenderConfig config, QString documentPath, unsigned int page);
 
 	~PreviewGeneratorPdf()
 	{

gui/previewgeneratorplaintext.cpp

@@ -3,14 +3,13 @@
 #include "previewgeneratorplaintext.h"
 #include "previewresultplaintext.h"
 
-QSharedPointer<PreviewResult> PreviewGeneratorPlainText::generate(RenderConfig config, QString documentPath,
+PreviewResult *PreviewGeneratorPlainText::generate(RenderConfig config, QString documentPath, unsigned int page)
-																  unsigned int page)
 {
 	PreviewResultPlainText *result = new PreviewResultPlainText(documentPath, page);
 	QFile file(documentPath);
 	if(!file.open(QFile::ReadOnly | QFile::Text))
 	{
-		return QSharedPointer<PreviewResultPlainText>(result);
+		return result;
 	}
 	QTextStream in(&file);
 
@@ -78,5 +77,5 @@ QSharedPointer<PreviewResult> PreviewGeneratorPlainText::generate(RenderConfig c
 	header += "<hr>";
 
 	result->setText(header + resulText.replace("\n", "<br>"));
-	return QSharedPointer<PreviewResultPlainText>(result);
+	return result;
 }

gui/previewgeneratorplaintext.h

@@ -6,7 +6,7 @@ class PreviewGeneratorPlainText : public PreviewGenerator
 {
   public:
 	using PreviewGenerator::PreviewGenerator;
-	QSharedPointer<PreviewResult> generate(RenderConfig config, QString documentPath, unsigned int page);
+	PreviewResult *generate(RenderConfig config, QString documentPath, unsigned int page);
 };
 
 #endif // PREVIEWGENERATORPLAINTEXT_H

gui/previewresult.cpp

@@ -1,4 +1,5 @@
 #include "previewresult.h"
+
 PreviewResult::PreviewResult()
 {
 }
@@ -32,11 +33,3 @@ unsigned int PreviewResult::getPage() const
 {
 	return this->page;
 }
-
-QByteArray PreviewResult::serialize() const
-{
-	QByteArray result;
-	QDataStream stream{&result, QIODevice::WriteOnly};
-	stream << 0 << this->documentPath << this->page;
-	return result;
-}

gui/previewresult.h

@@ -2,12 +2,6 @@
 #define PREVIEWRESULT_H
 #include "clicklabel.h"
 
-enum PreviewResultType
-{
-	PDF = 1,
-	PlainText
-};
-
 class PreviewResult
 {
   protected:
@@ -23,7 +17,6 @@ class PreviewResult
 	virtual bool hasPreview();
 	QString getDocumentPath() const;
 	unsigned int getPage() const;
-	virtual QByteArray serialize() const;
 };
 
 #endif // PREVIEWRESULT_H

gui/previewresultpdf.cpp

@@ -1,4 +1,5 @@
 #include "previewresultpdf.h"
+
 PreviewResultPdf::PreviewResultPdf(const PreviewResult &o)
 {
 	this->documentPath = o.getDocumentPath();
@@ -18,27 +19,3 @@ bool PreviewResultPdf::hasPreview()
 	bool result = !this->previewImage.isNull();
 	return result;
 }
-
-QByteArray PreviewResultPdf::serialize() const
-{
-	QByteArray result;
-	QDataStream stream{&result, QIODevice::WriteOnly};
-	PreviewResultType type = PreviewResultType::PDF;
-	stream << type << this->documentPath << this->page << this->previewImage;
-	return result;
-}
-
-QSharedPointer<PreviewResultPdf> PreviewResultPdf::deserialize(QByteArray &ba)
-{
-	PreviewResultPdf *result = new PreviewResultPdf();
-	PreviewResultType type;
-
-	QDataStream stream{&ba, QIODevice::ReadOnly};
-	stream >> type;
-	if(type != PreviewResultType::PDF)
-	{
-		throw std::runtime_error("Invalid byte array: Not a pdf preview");
-	}
-	stream >> result->documentPath >> result->page >> result->previewImage;
-	return QSharedPointer<PreviewResultPdf>(result);
-}

gui/previewresultpdf.h

@@ -12,10 +12,6 @@ class PreviewResultPdf : public PreviewResult
 
 	QWidget *createPreviewWidget() override;
 	bool hasPreview() override;
-
-	QByteArray serialize() const;
-
-	static QSharedPointer<PreviewResultPdf> deserialize(QByteArray &ba);
 };
 
 #endif // PREVIEWRESULTPDF_H

gui/previewresultplaintext.cpp

@@ -28,27 +28,3 @@ void PreviewResultPlainText::setText(QString text)
 {
 	this->text = text;
 }
-
-QByteArray PreviewResultPlainText::serialize() const
-{
-	QByteArray result;
-	QDataStream stream{&result, QIODevice::WriteOnly};
-	PreviewResultType type = PreviewResultType::PlainText;
-	stream << type << this->documentPath << this->page << this->text;
-	return result;
-}
-
-QSharedPointer<PreviewResultPlainText> PreviewResultPlainText::deserialize(QByteArray &ba)
-{
-	PreviewResultPlainText *result = new PreviewResultPlainText();
-	PreviewResultType type;
-
-	QDataStream stream{&ba, QIODevice::ReadOnly};
-	stream >> type;
-	if(type != PreviewResultType::PlainText)
-	{
-		throw std::runtime_error("Invalid byte array: Not a pdf preview");
-	}
-	stream >> result->documentPath >> result->page >> result->text;
-	return QSharedPointer<PreviewResultPlainText>(result);
-}

gui/previewresultplaintext.h

@@ -15,9 +15,6 @@ class PreviewResultPlainText : public PreviewResult
 	bool hasPreview() override;
 
 	void setText(QString text);
-
-	QByteArray serialize() const;
-	static QSharedPointer<PreviewResultPlainText> deserialize(QByteArray &ba);
 };
 
 #endif // PREVIEWRESULTPLAINTEXT_H

gui/previewworker.cpp

@@ -0,0 +1,39 @@
+#include <QApplication>
+#include <QScreen>
+#include <QScopedPointer>
+#include <QMutexLocker>
+#include <QtConcurrent/QtConcurrent>
+#include <QtConcurrent/QtConcurrentMap>
+#include <atomic>
+#include "previewworker.h"
+
+PreviewWorker::PreviewWorker()
+{
+}
+
+QFuture<QSharedPointer<PreviewResult>> PreviewWorker::generatePreviews(const QVector<SearchResult> paths,
+																	   QVector<QString> wordsToHighlight,
+																	   double scalefactor)
+{
+	QVector<QSharedPointer<PreviewResult>> previews;
+
+	for(const SearchResult &sr : paths)
+	{
+		for(unsigned int page : sr.pages)
+		{
+			QSharedPointer<PreviewResult> ptr =
+				QSharedPointer<PreviewResult>(new PreviewResult{sr.fileData.absPath, page});
+			previews.append(ptr);
+		}
+	}
+
+	RenderConfig renderConfig;
+	renderConfig.scaleX = QGuiApplication::primaryScreen()->physicalDotsPerInchX() * scalefactor;
+	renderConfig.scaleY = QGuiApplication::primaryScreen()->physicalDotsPerInchY() * scalefactor;
+	renderConfig.wordsToHighlight = wordsToHighlight;
+
+	auto mapFunctor = new PreviewGeneratorMapFunctor();
+	mapFunctor->setRenderConfig(renderConfig);
+
+	return QtConcurrent::mapped(previews, *mapFunctor);
+}

gui/previewworker.h

@@ -0,0 +1,29 @@
+#ifndef PREVIEWWORKER_H
+#define PREVIEWWORKER_H
+#include <QObject>
+#include <QImage>
+#include <QHash>
+#include <QThread>
+#include <QMutex>
+#include <QWaitCondition>
+#include <QMutex>
+#include <QFuture>
+#include "previewresultpdf.h"
+#include "searchresult.h"
+#include "previewgenerator.h"
+#include "previewworker.h"
+#include "previewgeneratorpdf.h"
+#include "previewgeneratormapfunctor.h"
+
+class PreviewWorker : public QObject
+{
+	Q_OBJECT
+  public:
+	PreviewWorker();
+	QSharedPointer<PreviewGenerator> createGenerator(QString path);
+
+	QFuture<QSharedPointer<PreviewResult>> generatePreviews(const QVector<SearchResult> paths,
+															QVector<QString> wordsToHighlight, double scalefactor);
+};
+
+#endif // PREVIEWWORKER_H

gui/renderconfig.cpp

@@ -1,17 +0,0 @@
-#include "renderconfig.h"
-
-QDataStream &operator<<(QDataStream &out, const RenderConfig &rc)
-{
-	out << rc.scaleX;
-	out << rc.scaleY;
-	out << rc.wordsToHighlight;
-	return out;
-}
-
-QDataStream &operator>>(QDataStream &in, RenderConfig &rc)
-{
-	in >> rc.scaleX;
-	in >> rc.scaleY;
-	in >> rc.wordsToHighlight;
-	return in;
-}

gui/renderconfig.h

@@ -1,17 +1,12 @@
 #ifndef RENDERCONFIG_H
 #define RENDERCONFIG_H
 #include <QVector>
-#include <QDataStream>
 
 struct RenderConfig
 {
 	double scaleX = 50 / 100.;
 	double scaleY = scaleX;
 	QVector<QString> wordsToHighlight;
-	friend QDataStream &operator<<(QDataStream &out, const RenderConfig &rc);
-	friend QDataStream &operator>>(QDataStream &in, RenderConfig &rc);
 };
 
-QDataStream &operator<<(QDataStream &out, const RenderConfig &rc);
-QDataStream &operator>>(QDataStream &in, RenderConfig &rc);
 #endif // RENDERCONFIG_H

gui/rendertarget.cpp

@@ -1,14 +0,0 @@
-#include <QDataStream>
-
-#include "rendertarget.h"
-QDataStream &operator<<(QDataStream &out, const RenderTarget &rc)
-{
-	out << rc.path << rc.page;
-	return out;
-}
-
-QDataStream &operator>>(QDataStream &in, RenderTarget &rc)
-{
-	in >> rc.path >> rc.page;
-	return in;
-}

gui/rendertarget.h

@@ -1,15 +0,0 @@
-#ifndef RENDERTARGET_H
-#define RENDERTARGET_H
-#include <QString>
-struct RenderTarget
-{
-  public:
-	QString path;
-	int page;
-	friend QDataStream &operator<<(QDataStream &out, const RenderTarget &rc);
-	friend QDataStream &operator>>(QDataStream &in, RenderTarget &rc);
-};
-
-QDataStream &operator<<(QDataStream &out, const RenderTarget &rc);
-QDataStream &operator>>(QDataStream &in, RenderTarget &rc);
-#endif // RENDERTARGET_H

shared/common.cpp

@@ -156,9 +156,6 @@ QString Common::databasePath()
 
 QString Common::ipcSocketPath()
 {
-	return "/tmp/.looqs/looqs-ipc-socket";
+	QSettings settings;
-
+	return settings.value(SETTINGS_KEY_IPCSOCKETPATH, "/tmp/looqs-spawner").toString();
-	/* May not a good idea to set it in the settings and probably nobody would ever bother to change it anyway */
-	// QSettings settings;
-	// return settings.value(SETTINGS_KEY_IPCSOCKETPATH, "/tmp/.looqs/looqs-ipc-socket").toString();
 }