Release v0.7

submodules: exile.h: Update
USAGE.md: Update
2022-09-10 15:15:39 +02:00 · 2022-09-10 15:15:39 +02:00 · 2022-09-10 15:15:31 +02:00 · 2022-08-28 17:48:16 +02:00 · 2022-08-28 13:10:39 +02:00 · 2022-08-28 13:05:33 +02:00
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,4 +1,80 @@
 # looqs: Release notes
+## 2022-09-10 - v0.7
+
+CHANGES:
+
+ - GUI: Add vertical scroll option, default to it. Most feedback considered horizontal scrolling unnatural.
+ - GUI: Previews: Improve plaintext preview snippet selection by prioritizing those which contain the most search terms
+ - GUI: Previews: Only highlight whole words, not parts in words.
+ - GUI: Previews: Don't treat text wrapped inside '<' '>' in plaintext files as HTMl tags which caused such text to get lost in previews.
+ - GUI: Avoid triggering preview generation in some cases even when previews tab is not the active one
+ - GUI: Implement a search history. Allow going up/down with arrow keys in the search field.
+ - GUI: Previews: Allow CTRL + mouse wheel to zoom in on previews
+ - General: Fix an incorrect sqlite query which caused the ranking information of search results to be lost. "All files" filter in the previews tab therefore now orders by the seemingly most relevant pages, across all documents.
+ - General: Fix handling of content search queries with prefix terms (those ending in '*').
+ - GUI: Show how many results are previewable.
+ - GUI: Refactor to improve stability of sandboxed IPC worker in order to avoid rare segfaults.
+
+## 2022-08-14 - v0.6
+This release features multiple fixes and enhancements.
+
+Bad news first: It drops a trivial trigger that appeared to work quite fine, but silently may cause "unpredictability" of the sqlite FTS5 index ( [9422a5b494](https://github.com/quitesimpleorg/looqs/commit/9422a5b494dabd0f1324dc2f92a34c3036137414) ). As a result, FTS queries may return weird and unexplainable results. This is not reasonably automatically recoverable by looqs. I strongly recommend creating a clean, new database. All previous versions are affected. To do that, go to "Settings" -> checking "Remove old database on save" -> "Save settings and restart". Alternatively, specify a new path to keep the old database.
+
+CHANGES:
+
+ - GUI: Add line numbers and context lines to plaintext previews
+ - GUI: Fix case where previews for old queries would have still been visible if new query would not create previews
+ - GUI: Add CTRL + F, CTRL+W, CTRL+Tab, CTRL+Shift+Tab shortcuts (see user manual)
+ - GUI: Add checkbox in "Settings" tab allowing to delete database.
+ - General: Fix wrong regexes that caused query errors with chars like -
+ - General: Drop trigger sending incomplete sqlite fts5 deletion command, causing undefined index behaviour
+
+## 2022-07-30 - v0.5.1
+
+CHANGES:
+
+ - gui: Fix regression in implicit paths queries introduced in previous version
+
+## 2022-07-29 - v0.5
+This release features multiple fixes and enhancements.
+
+It changes the database to drop an unused content column. Dropping it allows us
+to change to a contentless sqlite FTS index which frees up space.
+
+Upgrading might take a few seconds to a few minutes as looqs will recreate the whole index.
+How long this will take depends on the size of your database.
+
+The other major highlight is preview support for .odt files (unformatted, like plaintext).
+
+List of changes:
+
+ - General: As Ubuntu 21.10 is EOL, no looqs package will be provided for it any longer
+ - General: Update database scheme to drop unused content column and free up space
+ - General: Properly escape FTS arguments passed to sqlite to avoid query errors on some terms
+ - GUI: Fix double searches and results when explicit content search filters are provided
+ - GUI: Previews: Plaintext previews now obey scale selection too
+ - GUI: Previews: Begin basic, unformatted previews of .odt files
+ - GUI: Previews: Add file path below every preview for convenience (hovering unnecessary now).
+ - GUI: Previews: Fix bug causing an empty preview if a plaintext file started with a searched word
+ - GUI: Add menu option to open user manual
+ - GUI: Show progress dialog during database upgrade
+ - General: Correct error count in some conditions for failed paths
+ - General: Update user manual
+ - Minor improvements
+
+## 2022-06-29 - v0.4
+This release makes several minor improvements and begins prebuilt binaries of looqs that (should) run
+on any recent Linux distribution.
+
+ - General: Begin new, experimental distro-agnostic tarball containing prebuilt binaries and libs. See the README for more information.
+ - GUI: In the "Previews" tab, allow filtering by file, to only show previews for a specific file.
+ - GUI: Add "Show previews" context menu option to files in result (if available)
+ - General: Fix build with libquazip 1.X
+ - General: Properly report access errors as a failure during indexing
+ - GUI: Add button to export a list of all paths that failed
+ - General: Improve dir scan threading
+ - CLI: Improve helptext
+ - General: Add voidlinux build instructions

 ## 2022-06-14 - v0.3
 CHANGES:
--- a/1119
+++ b/1119
--- a/README.md
+++ b/README.md
@ -1,12 +1,9 @@
 # looqs - Full-text search with previews for your files
-looqs is a tool that creates a full-text search index for your files. It allows you to look at previews where your
-search terms have been found, as shown in the screenshots below.
+looqs is a tool that creates a full-text search index for your files. It allows you to look at previews where your 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 of the GUI.
-
 ### Preview
-looqs allow you to look inside files. It marks what you have searched for.
+looqs allows you to look inside files. It highlights what you have searched for.

 ![Screenshot looqs](https://garage.quitesimple.org/assets/looqs/orwell.png)
 ![Screenshot looqs search fstream](https://garage.quitesimple.org/assets/looqs/fstream_write.png)
@ -28,9 +25,10 @@ There is no need to write the long form of filters. There are also booleans avai

 ![Screenshot looqs results](https://garage.quitesimple.org/assets/looqs/looqs_beatles_marley.png)

+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 of the GUI.

 ## Current status
-Last version: 2022-06-14, v0.3
+Latest version: 2022-09-10, v0.7

 Please see [Changelog](CHANGELOG.md) for a human readable list of changes.

@ -47,7 +45,7 @@ Please see [Changelog](CHANGELOG.md) for a human readable list of changes.
 - GUI, CLI interface
 - Indexing of file path and some metadata.
 - Indexing of file file content for FTS search. Currently: .pdf, odt, docx, plaintext.
- Preview of file formats: Currently: .pdf, plaintext
+- Preview of file formats: Currently: .pdf, .odt, plaintext
 - Highlight searched terms.
 - Quickly open PDF viewer or text editor at location of preview
 - Search filters
@ -58,6 +56,8 @@ Linux (on amd64) is currently the main focus. Currently, I don't plan on support
 ### Licence
 GPLv3.

+For the dependencies/third-party libraries, see: LICENSE-3RD-PARTY
+
 ### Contributing
 Please see the [Contribution guidelines](CONTRIBUTING.md) file.

@ -67,7 +67,7 @@ Please see [USAGE.md](USAGE.md) for the user manual. There is also [HACKING.md](

 ## Build

-### Ubuntu 21.10/22.04
+### Debian/Ubuntu

 To build on Ubuntu and Debian, clone the repo and then run:
 ```
@ -78,12 +78,23 @@ qmake
 make
 ```

+### Void
+```
+# as root
+xbps-install qt5-devel poppler-qt5-devel quazip-qt5-devel uchardet-devel gcc make
+# as user
+git submodule init
+git submodule update
+qmake
+make
+```
+
 The GUI is located in `gui/looqs-gui`, the binary for the CLI is in `cli/looqs`

 ## Packages
 At this point, looqs is not in any official distro package repo, but I maintain some packages.

-### Ubuntu 21.10/22.04
+### Ubuntu 22.04
 Latest release can be installed using apt from the repo.
 ```
 # First, obtain key, assume it's trusted.
@ -95,7 +106,35 @@ sudo apt-get update
 sudo apt-get install looqs
 ```

+### Prebuilt tarball (distro-agnostic) (EXPERIMENTAL)
+looqs is also distributed as a tarball containing prebuilt binaries and its library dependencies. The tarball is
+built using the Gentoo Hardened toolchain and the Qt version is smaller than what distributions usually
+include. It does not include libraries that should mess with fontrendering or the graphics stack. The binaries should run on any recent Linux distribution (requires glibc 2.34 or newer at least) and expects
+dependencies such as libGL to be provided by your distribution already (should be the case).
+
+It's considered experimental for two reasons. Firstly, looqs has no updater (yet). You will have to manually check for updates. Secondly, I can't guarantee that I'll be quick with updates of the tarball specifically if the library versions become outdated between looqs updates.
+
+You are therefore encouraged to use distro-native packages or to build it yourself if possible.
+
+The tarball can be obtained here: https://repo.quitesimple.org/tarball/looqs
+
+Quick start:
+
+```
+# Verify sig, see the end of this document: gpg --verify looqs-v0.4.tar.xz.sig
+tar xf looqs-v0.4.tar.xz # Replace with the actual version you have obtained
+cd looqs-v0.4
+./looqs-gui # or ./looqs for the CLI
+```
+
+An AppImage may accompany the tarball in the future.
+
+
 ### Other distros
 I'll probably add a package for voidlinux at some point and maybe will provide a Gentoo ebuild. However, I would appreciate help for others distros. If you create a package, let me know!

-As for distro-agnostic packages, I will also take a look into appimage / flatpak etc.  and/or maybe just provide a self-contained archive.
+
+### Signature verification
+Release tags can be verified with  [my PGP public key](https://quitesimple.org/share/pubkey). For what little it's worth, its fingerprint is: `C342 CA02 D2EC 2E14 F3C3  D5FF 7F7B 4C08 02CD 02F2`
+
+Packages can be verified with the [repo-specific public key](https://repo.quitesimple.org/repo.quitesimple.org.asc). For what little it's worth, its fingerprint is: `1B49 45B3 16B2 468A 3DAC  C1E0 75EF 3FE8 D753 C8F9`
--- a/USAGE.md
+++ b/USAGE.md
@ -9,50 +9,60 @@ looqs is still at an early stage and may exhibit some weirdness and contain bugs
 ## Current Limitations and things to know
 You should be aware of the following:

- It may seem natural, but the GUI and CLI operate on the same database, so if you add files using the CLI, the GUI will search them too.
+- Lags are to be expected for networked mount points such as SMB and NFS etc.
+
+- It may seem natural, but the GUI and CLI operate on the same database, so if you add files using the CLI, the GUI will know about them too.

 - If a file is listed in the "Search results" tab, it does not imply that a preview will be available in the "Previews" tab, as looqs can search more file formats than it can generate previews for currently.

- Database paths are stored inefficiently, not deduplicated to simplify queries. This may add up quickly. Also, each PDF text is stored twice. Each page separately + the whole document to simplify queries.
-To give you some idea: At the time this section was written, 167874 files were in my index. A FTS index was built for 14280 of those, of which 4146 were PDF documents. The PDFs take around 10GB storage space on the filesystem. All files for which an FTS has been built are around 7GB in size on the filesystem. The looqs database had a size of 1.6 GB.
-
- Existing files are considered modified when the mtime has changed. looqs currently does not check whether the content
-has changed. 
+- Existing files are considered modified when the modification time has changed. looqs currently does not check whether the content has changed.

 ## Config
-The config file is in `$HOME/.config/quitesimple.org/looqs.conf`. It will be created on first execution of the CLI or GUI
-interface. The GUI has a menu entry to quickly open this config file. This is to be considered temporary and will be removed once the GUI itself can edit all settings.
+The config file is in `$HOME/.config/quitesimple.org/looqs.conf`. It will be created on first execution of the CLI or GUI interface. Generally, you should not edit this file directly. Instead, use the "Settings" tab in the GUI.

-Database default path: `$HOME/.local/share/quitesimple.org/looqs/looqs.sqlite`. If this does not work for
-you, move it and adjust adjust the path in the config file.
+Database default path: `$HOME/.local/share/quitesimple.org/looqs/looqs.sqlite`. If you prefer a different path, move it and adjust the path.


 ## GUI
-The GUI is minimal at this point. Depending on what you want to do, you may need to open the config file and change the settings there. Chances are that you may not need to do that. 

 ### First run
 You will be presented with an empty list. Go to the **"Index"** tab, add some directories and click **"Start indexing"**.

+### Indexing
 For large directories the progress bar is essentially just decoration. As long as you see the counters
 increase, everything is fine even if it seems the progress bar is stuck.

 The indexing can be stopped. If you run it again you do not start from scratch, because looqs knows
-which files have been modified or not since they have been added to the index. Thus, files will
-only be reprocedded when necessary. Note that cancellation itself may take a moment as files finish processing. 
+which files have been modified since they have been added to the index. Thus, files will
+only be reprocessed when necessary. Note that cancellation itself may take a moment as files finish processing.
+
+The counters increase in batches, therefore it's normal that it seems no progress is being made, particularly when processing lots of large documents. This aspect will be improved in a future version.

 ### Search
-The text field at the top is where you type your query. It can be selected quickly using **CTRL + L**. Filters are avalable,
-see this document at the end. By default, both the full path and the content are searched. Path names take precedence.
+The text field at the top is where you type your query. It can be selected quickly using **CTRL + L**. Filters are available, see this document at the end. By default, both the full path and the content are searched. Path names take precedence, i. e. they will appear the top of the list.
+
+**CTRL + F**: This is helpful shortcut if you want to perform several searches. Consider the following
+query: "p:(docs) c:(invoice credit card)". Press CTRL+F to highlight 'invoice credit card'. This way
+you can quickly perform content searches in paths containing 'docs'.
+
+**CTRL + W**: Removes the last filter. If we take above's example "p:(docs) c:(invoice credit card)" again, then CTRL + W kills "c:(invoice credit card)".
+
+The arrow keys (up and down) can be used to go back and forward in the search history.

 ### Configuring PDF viewer
 It's most convenient if, when you click on a preview, the PDF reader opens the page you clicked. For that, looqs needs to know which viewer you want to launch.

-It tries to auto detect some common viewers. You must set the value of the ```pdfviewer=``` config entry yourself if it doesn't do something you
-like, such as not opening your favorite viewer. In the command line options, "%f" represents the filepath, "%p" the page number.
+It tries to auto detect some common viewers. You must set the value in the "Settings" tab yourself if the
+default does not work for you. In the command line options, "%f" represents the filepath, "%p" the page number.

-### Preview tab
-The preview tab shows previews. It marks your search keywords too. Click on a preview to open the file.
-A right click on a preview allows you to copy the file path, or to open the containing folder. Hovering tells you which file the preview originates from.
+### Previews tab
+The 'previews' tab shows previews. It marks your search keywords too. Click on a preview to open the file.
+A right click on a preview allows you to copy the file path, or to open the containing folder.
+
+When the combobox is set to "All previews", the previews are ordered by relevance from all documents/pages.
+
+By default, a vertical scrolling is active. In the settings, it can be changed to horizontal scroll, which may be
+preferred by users of (larger) wide screen monitors.

 ### Syncing index
 Over time, files get deleted or their content changes. Go to **looqs** -> **Sync index**. looqs will reindex the content of files which have been changed. Files that cannot be found anymore will be removed from the index.
@ -85,12 +95,11 @@ There is an implicit "AND" condition, meaning if you search for "photo" and "mou
 will be shown containing both terms, but not either alone.

 ### Deletion and Fixing Out of sync index
-You sometimes delete files, to get rid of those from the index too, run:
+To get rid of deleted files from the index, run:

 ```
 looqs delete --deleted --dry-run
 ```
-
 This commands lists all files which are indexed, but which cannot be found anymore.

 Remove them using:
@ -126,13 +135,13 @@ looqs update
 ```

 This will not add new files, you must run ```looqs add``` for this. For this reason, most users
-will probably seldomly use the 'update' command alone.
+will probably seldom use the 'update' command alone.


 ## Tips

 ### Keeping index up to date
-The most obvious way is to use the GUI and add your favorite paths in the "Index" tab. Then occasionally, just rescan. This works for me personally, looqs quickly picks up new files. This however may not be good enough for some users.
+The most obvious way is to use the GUI to add your favorite paths in the "Index" tab. Then occasionally, just rescan. This works for me personally, looqs quickly picks up new files. This however may not be good enough for some users.

 Some users may prefer setting up cronjobs or wire up the CLI interface with file system monitoring tools such as [adhocify](https://github.com/quitesimpleorg/adhocify).

@ -144,20 +153,20 @@ are indexed by looqs, you may find the lh (look here) alias useful:
 alias lh='looqs search $(pwd)'
 ```

-So typing "lh recipes" searchs the current dir and its subdirs for a file containing 'recipes'.
+So typing "lh recipes" searches the current dir and its subdirs for a file containing 'recipes'. Alternatively, a "lh c:(rice)" may be a quick grep alternative.

 ## Query syntax / Search filters
 A number of search filters are available.

 | Filter (long) |  Filter (short) | Explanation |
 | ----------- | ----------- |----------- |
-| path.contains:(term) | p:(term) | Pretty much a SQL LIKE '%term%' conditions, just searches the path string |
+| path.contains:(term) | p:(term) | Pretty much a SQL LIKE '%term%' condition, just searches the path string |
 | path.ends:(term) | pe:(term) | Filters path ending with the specified term, e. g.: pe:(.ogg) |
 | path.begins:(term) | pb:(term) |  Filters path beginning with the specified term |
-| contains:(terms) | c:(terms) | ull-text search, also understands quotes | 
-
-Filters can be combined. The booleans AND and OR are supported. Negations can be applied too, except for c:(). 
-The AND boolean is implicit and thus entering it strictly optional. 
+| contains:(terms) | c:(terms) | Full-text search, also understands quotes |
+| limit:(integer) | - | Limits the number of results. The default is 1000. Say "limit:0" to see all results |
+Filters can be combined. The booleans AND and OR are supported. Negations can be applied too, except for c:(). Negations are specified with "!".
+The AND boolean is implicit and thus entering it strictly optional.

 Examples:

@ -166,8 +175,10 @@ Examples:
 |pe:(.ogg) p:(marley)| Finds paths that end with .ogg and contain 'marley' (case-insensitive)
 |p:(slides) support vector machine &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; |Performs a content search for 'support vector machine' in all paths containing 'slides'|
 |p:(notes) (pe:(odt) OR pe:(docx)) &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;|Finds files such as notes.docx, notes.odt but also any .docs and .odt when the path contains the string 'notes'|
-|memcpy !(pe:(.c) OR pe:(.cpp))| Performs a FTS search for 'memcpy' but excludes .cpp and .c files. 
-|c:("I think, therefore")|Performs a FTS search for the phrase "I think, therefore". 
+|memcpy !(pe:(.c) OR pe:(.cpp))| Performs a FTS search for 'memcpy' but excludes .cpp and .c files.|
+|c:("I think, therefore")|Performs a FTS search for the phrase "I think, therefore".|
+|c:("invoice") Downloads|This query is equivalent to c:("invoice") p:("Downloads")|
+



--- a/cli/cli.pro
+++ b/cli/cli.pro
@ -37,6 +37,12 @@ else:unix: LIBS += -L$$OUT_PWD/../shared/ -lshared

 LIBS += -luchardet -lpoppler-qt5 -lquazip5

+packagesExist(quazip1-qt5) {
+	PKGCONFIG += quazip1-qt5
+	CONFIG += link_pkgconfig
+	LIBS -= -lquazip5
+}
+
 INCLUDEPATH += $$PWD/../shared
 DEPENDPATH += $$PWD/../shared

--- a/cli/commandadd.cpp
+++ b/cli/commandadd.cpp
@ -47,7 +47,8 @@ int CommandAdd::handle(QStringList arguments)
 					   {{"t", "threads"}, "Number of threads to use.", "threads"}});

 	parser.addHelpOption();
-	parser.addPositionalArgument("add", "Add paths to the index", "add [paths...]");
+	parser.addPositionalArgument("add", "Add paths to the index",
+								 "add [paths...]. If no path is given, read from stdin, one path per line.");

 	parser.process(arguments);
 	this->keepGoing = parser.isSet("continue");
--- a/cli/commandsearch.cpp
+++ b/cli/commandsearch.cpp
@ -33,11 +33,18 @@ int CommandSearch::handle(QStringList arguments)

 	try
 	{
+
+		QHash<QString, bool> seenMap;
 		auto results = dbService->search(query);

-		for(SearchResult &result : results)
+		for(const SearchResult &result : results)
 		{
-			Logger::info() << result.fileData.absPath << Qt::endl;
+			const QString &absPath = result.fileData.absPath;
+			if(!seenMap.contains(absPath))
+			{
+				seenMap[absPath] = true;
+				Logger::info() << absPath << Qt::endl;
+			}
 		}
 	}
 	catch(LooqsGeneralException &e)
--- a/cli/main.cpp
+++ b/cli/main.cpp
@ -26,10 +26,12 @@
 #include "sandboxedprocessor.h"
 #include "../shared/common.h"
 #include "../shared/filescanworker.h"
+#include "../shared/dbmigrator.h"

 void printUsage(QString argv0)
 {
 	qInfo() << "Usage:" << argv0 << "command";
+	qInfo() << "Valid commands: add, update, delete, search, list. Each command has a --help option.";
 }

 Command *commandFromName(QString name, SqliteDbService &dbService)
@ -74,6 +76,27 @@ int main(int argc, char *argv[])
 	try
 	{
 		Common::ensureConfigured();
+
+		DatabaseFactory factory{Common::databasePath()};
+		DBMigrator migrator{factory};
+		if(migrator.migrationNeeded())
+		{
+			Logger::info() << "Database is being upgraded, please be patient..." << Qt::endl;
+
+			QObject::connect(&migrator, &DBMigrator::migrationDone,
+							 [&](uint32_t migration)
+							 { Logger::info() << "Progress: Successfully migrated to: " << migration << Qt::endl; });
+			QObject::connect(&migrator, &DBMigrator::done,
+							 []() { Logger::info() << "Database upgrade successful" << Qt::endl; });
+			QObject::connect(&migrator, &DBMigrator::error,
+							 [&](QString error)
+							 {
+								 Logger::error() << error << Qt::endl;
+								 qApp->quit();
+							 });
+
+			migrator.performMigrations();
+		}
 	}
 	catch(LooqsGeneralException &e)
 	{
@ -97,7 +120,7 @@ int main(int argc, char *argv[])

 		QString file = args.at(1);
 		SandboxedProcessor processor(file);
-		return processor.process();
+		return static_cast<int>(processor.process());
 	}
 	Command *cmd = commandFromName(commandName, dbService);
 	if(cmd != nullptr)
@ -116,7 +139,7 @@ int main(int argc, char *argv[])
 	}
 	else
 	{
-		Logger::error() << "Unknown command:" << commandName << Qt::endl;
+		printUsage(argv0);
 		return 1;
 	}

--- a/gui/aboutdialog.cpp
+++ b/gui/aboutdialog.cpp
@ -0,0 +1,74 @@
+#include <QTabWidget>
+#include <QVBoxLayout>
+#include <QLabel>
+#include <QTextBrowser>
+#include <QPushButton>
+#include "aboutdialog.h"
+#include "common.h"
+
+AboutDialog::AboutDialog(QWidget *parent) : QDialog(parent)
+{
+	QVBoxLayout *layout = new QVBoxLayout(this);
+	QTabWidget *tabWidget = new QTabWidget(this);
+
+	this->setWindowTitle("About looqs");
+
+	QHBoxLayout *closeLayout = new QHBoxLayout();
+	QPushButton *closeButton = new QPushButton(this);
+	closeButton->setText("Close");
+	closeButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
+	connect(closeButton, &QPushButton::clicked, this, &QDialog::close);
+
+	closeLayout->setMargin(10);
+	closeLayout->addStretch(10);
+	closeLayout->addWidget(closeButton);
+
+	layout->addWidget(tabWidget);
+	layout->addLayout(closeLayout);
+	QFrame *frame = new QFrame(this);
+	QVBoxLayout *aboutLayout = new QVBoxLayout(frame);
+	frame->setLayout(aboutLayout);
+
+	QLabel *aboutLooqs = new QLabel(this);
+	QString html = "<h2>looqs</h2>";
+	html += "Full-text search with previews for your files<br><br>";
+	html += "Copyright (c) 2018-2022: Albert Schwarzkopf<br><br>";
+	html += QString("Version: %1<br><br>").arg(Common::versionText());
+	html += "Contact: looqs at quitesimple dot org<br><br>";
+	html += "Website: <a href=\"https://quitesimple.org\">https://quitesimple.org</a><br><br>";
+	html += "Source code: <a "
+			"href=\"https://github.com/quitesimpleorg/looqs\">https://github.com/quitesimpleorg/looqs</a><br><br>";
+	html += "License: GPLv3<br><br>";
+	html += "looqs is open source and free of charge in the hope it will be useful. The author(s) do not "
+			"give any warranty. In the unlikely event of any damage, the author(s) cannot be held responsible. "
+			"You are using looqs at your own risk<br><br>";
+	html += "looqs uses third-party libraries, please see the corresponding tab.";
+	aboutLooqs->setText(html);
+	aboutLooqs->setTextFormat(Qt::RichText);
+
+	QLabel *logo = new QLabel(this);
+	QImage image(QString(":/looqs.svg"));
+	logo->setPixmap(QPixmap::fromImage(image));
+
+	aboutLayout->addWidget(logo);
+	aboutLayout->addWidget(aboutLooqs);
+
+	tabWidget->addTab(frame, "About");
+
+	QFile license(QString(":/LICENSE"));
+	license.open(QIODevice::ReadOnly);
+	QString licenseText = license.readAll();
+
+	QFile thirdPartyLicense(QString(":./LICENSE-3RD-PARTY"));
+	thirdPartyLicense.open(QIODevice::ReadOnly);
+	QString thirdPartyLicenseInfo = thirdPartyLicense.readAll();
+
+	QTextBrowser *licenseTextBrowser = new QTextBrowser(this);
+	licenseTextBrowser->setText(licenseText);
+
+	QTextBrowser *thirdPartyLicenceTextBrowser = new QTextBrowser(this);
+	thirdPartyLicenceTextBrowser->setText(thirdPartyLicenseInfo);
+
+	tabWidget->addTab(licenseTextBrowser, "License");
+	tabWidget->addTab(thirdPartyLicenceTextBrowser, "Third-party libraries");
+}
--- a/gui/aboutdialog.h
+++ b/gui/aboutdialog.h
@ -0,0 +1,12 @@
+#ifndef ABOUTDIALOG_H
+#define ABOUTDIALOG_H
+#include <QDialog>
+
+class AboutDialog : public QDialog
+{
+	Q_OBJECT
+  public:
+	AboutDialog(QWidget *parent = nullptr);
+};
+
+#endif // ABOUTDIALOG_H
--- a/gui/gui.pro
+++ b/gui/gui.pro
@ -7,7 +7,11 @@
 QT       += core concurrent gui network

 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
 CONFIG += c++17
+
+
+
 TARGET = looqs-gui
 TEMPLATE = app

@ -23,6 +27,7 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

 SOURCES += \
+    aboutdialog.cpp \
    ipcpreviewclient.cpp \
    ipcpreviewworker.cpp \
    ipcserver.cpp \
@ -31,15 +36,18 @@ SOURCES += \
      clicklabel.cpp \
    previewgenerator.cpp \
    previewgeneratormapfunctor.cpp \
+    previewgeneratorodt.cpp \
    previewgeneratorpdf.cpp \
    previewgeneratorplaintext.cpp \
    previewresult.cpp \
+    previewresultodt.cpp \
    previewresultpdf.cpp \
    previewresultplaintext.cpp \
    renderconfig.cpp \
    rendertarget.cpp

 HEADERS += \
+    aboutdialog.h \
    ipc.h \
    ipcpreviewclient.h \
    ipcpreviewworker.h \
@ -48,9 +56,11 @@ HEADERS += \
    clicklabel.h \
    previewgenerator.h \
    previewgeneratormapfunctor.h \
+    previewgeneratorodt.h \
    previewgeneratorpdf.h \
    previewgeneratorplaintext.h \
    previewresult.h \
+    previewresultodt.h \
    previewresultpdf.h \
    previewresultplaintext.h \
    renderconfig.h \
@ -60,6 +70,7 @@ FORMS += \
        mainwindow.ui

 INCLUDEPATH += /usr/include/poppler/qt5/
+INCLUDEPATH += /usr/include/quazip5

 QT += widgets sql

@ -69,6 +80,12 @@ else:unix: LIBS += -L$$OUT_PWD/../shared/ -lshared

 LIBS += -luchardet -lpoppler-qt5 -lquazip5

+packagesExist(quazip1-qt5) {
+	PKGCONFIG += quazip1-qt5
+	CONFIG += link_pkgconfig
+	LIBS -= -lquazip5
+}
+
 INCLUDEPATH += $$PWD/../shared
 DEPENDPATH += $$PWD/../shared

--- a/gui/ipcpreviewworker.cpp
+++ b/gui/ipcpreviewworker.cpp
@ -1,16 +1,50 @@
 #include <QtConcurrent>
 #include "ipcpreviewworker.h"
 #include "previewgeneratormapfunctor.h"
-IPCPreviewWorker::IPCPreviewWorker()
+IPCPreviewWorker::IPCPreviewWorker(QLocalSocket *peer)
 {
+	this->peer = peer;
 	this->connect(&previewWorkerWatcher, &QFutureWatcher<QByteArray>::resultReadyAt, this,
-				  [this](int index) { emit previewGenerated(previewWorkerWatcher.resultAt(index)); });
-	connect(&previewWorkerWatcher, &QFutureWatcher<QByteArray>::finished, this, [this] { emit finished(); });
+				  [this](int index)
+				  {
+					  if(this->peer != nullptr)
+					  {
+						  QDataStream stream{this->peer};
+						  stream << previewWorkerWatcher.resultAt(index);
+						  this->peer->flush();
+					  }
+				  });
+	connect(&previewWorkerWatcher, &QFutureWatcher<QByteArray>::finished, this, &IPCPreviewWorker::shutdownSocket);
+	connect(this->peer, &QLocalSocket::disconnected, this, &IPCPreviewWorker::shutdownSocket);
 }

-void IPCPreviewWorker::start(RenderConfig config, const QVector<RenderTarget> &targets, QLocalSocket *peer)
+void IPCPreviewWorker::shutdownSocket()
+{
+	if(cleaned)
+	{
+		return;
+	}
+	cleaned = true;
+	if(this->peer != nullptr)
+	{
+		if(this->peer->state() == QLocalSocket::ConnectedState)
+		{
+			this->peer->flush();
+			this->peer->waitForBytesWritten();
+			this->peer->disconnectFromServer();
+			if(this->peer->state() != QLocalSocket::UnconnectedState)
+			{
+				this->peer->waitForDisconnected();
+			}
+		}
+		delete this->peer;
+		this->peer = nullptr;
+	}
+	emit finished();
+}
+
+void IPCPreviewWorker::start(RenderConfig config, const QVector<RenderTarget> &targets)
 {
-	stop();
 	auto mapFunctor = PreviewGeneratorMapFunctor();
 	mapFunctor.setRenderConfig(config);

--- a/gui/ipcpreviewworker.h
+++ b/gui/ipcpreviewworker.h
@ -11,13 +11,21 @@ class IPCPreviewWorker : public QObject
 	Q_OBJECT
  private:
 	QFutureWatcher<QByteArray> previewWorkerWatcher;
+	QLocalSocket *peer;
+	bool cleaned = false;

  public:
-	IPCPreviewWorker();
-	void start(RenderConfig config, const QVector<RenderTarget> &targets, QLocalSocket *peer);
+	IPCPreviewWorker(QLocalSocket *peer);
+	void start(RenderConfig config, const QVector<RenderTarget> &targets);
 	void stop();
+	~IPCPreviewWorker()
+	{
+		delete this->peer;
+	}
+  private slots:
+	void shutdownSocket();
+
  signals:
-	void previewGenerated(QByteArray);
 	void finished();
 };

--- a/gui/ipcserver.cpp
+++ b/gui/ipcserver.cpp
@ -18,8 +18,6 @@ IpcServer::IpcServer()
 	/* Only 1, we are doing work for the GUI, not a service for general availability */
 	this->spawningServer.setMaxPendingConnections(1);
 	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)
@ -31,8 +29,6 @@ bool IpcServer::startSpawner(QString socketPath)
 void IpcServer::spawnerNewConnection()
 {
 	QLocalSocket *socket = this->spawningServer.nextPendingConnection();
-	connect(socket, &QLocalSocket::disconnected, socket, &QLocalSocket::deleteLater);
-	this->currentSocket = socket;
 	if(socket != nullptr)
 	{
 		if(!socket->waitForReadyRead())
@ -53,21 +49,22 @@ void IpcServer::spawnerNewConnection()
 				stream.startTransaction();
 				stream >> renderConfig >> targets;
 			} while(!stream.commitTransaction() && socket->state() == QLocalSocket::ConnectedState);
-
-			stream << targets.count();
-			socket->flush();
-			previewWorker.start(renderConfig, targets, socket);
+			if(socket->state() == QLocalSocket::ConnectedState)
+			{
+				stream << targets.count();
+				socket->flush();
+				IPCPreviewWorker *previewWorker = new IPCPreviewWorker(socket);
+				connect(previewWorker, &IPCPreviewWorker::finished, this, [previewWorker] { delete previewWorker; });
+				previewWorker->start(renderConfig, targets);
+			}
+			else
+			{
+				delete socket;
+			}
 		}
 		if(command == StopGeneratePreviews)
 		{
-			previewWorker.stop();
+			/* TODO: implement */
 		}
 	}
 }
-
-void IpcServer::handlePreviewGenerated(QByteArray ba)
-{
-	QDataStream stream{this->currentSocket};
-	stream << ba;
-	this->currentSocket->flush();
-}
--- a/gui/ipcserver.h
+++ b/gui/ipcserver.h
@ -10,13 +10,10 @@ class IpcServer : public QObject
 {
 	Q_OBJECT
  private:
-	IPCPreviewWorker previewWorker;
 	QLocalServer spawningServer;
-	QLocalSocket *currentSocket = nullptr;
 	SaveFileResult addFile(QString file);
  private slots:
 	void spawnerNewConnection();
-	void handlePreviewGenerated(QByteArray ba);

  public:
 	IpcServer();
--- a/gui/main.cpp
+++ b/gui/main.cpp
@ -12,6 +12,8 @@
 #include "previewresultpdf.h"
 #include "../shared/common.h"
 #include "../shared/sandboxedprocessor.h"
+#include "../shared/dbmigrator.h"
+#include "../shared/logger.h"
 #include "../submodules/exile.h/exile.h"
 #include "ipcserver.h"

@ -114,7 +116,7 @@ int main(int argc, char *argv[])

 			QString file = args.at(2);
 			SandboxedProcessor processor(file);
-			return processor.process();
+			return static_cast<int>(processor.process());
 		}
 	}
 	QString ipcSocketPath = Common::ipcSocketPath();
@ -153,6 +155,63 @@ int main(int argc, char *argv[])
 	try
 	{
 		Common::ensureConfigured();
+		DatabaseFactory factory{Common::databasePath()};
+		DBMigrator migrator{factory};
+
+		if(migrator.migrationNeeded())
+		{
+			auto answer = QMessageBox::question(nullptr, "Proceed with upgrade?",
+												"A database upgrade is required. This might take a few minutes. Say "
+												"'yes' to start upgrade, 'no' to exit.");
+
+			if(answer == QMessageBox::No)
+			{
+				a.quit();
+				return 0;
+			}
+
+			QFile out;
+			out.open(stderr, QIODevice::WriteOnly);
+			Logger migrationLogger{&out};
+			migrationLogger << "Database is being upgraded, please be patient..." << Qt::endl;
+			QThread migratorThread;
+			migrator.moveToThread(&migratorThread);
+			migratorThread.start();
+			QProgressDialog progressDialog;
+
+			QObject::connect(&migrator, &DBMigrator::migrationDone,
+							 [&migrationLogger](uint32_t migration)
+							 { migrationLogger << "Progress: Successfully migrated to: " << migration << Qt::endl; });
+			QObject::connect(&migrator, &DBMigrator::done, &progressDialog, &QProgressDialog::reset);
+			QObject::connect(&migrator, &DBMigrator::error,
+							 [&](QString error)
+							 {
+								 QMetaObject::invokeMethod(qApp,
+														   [error]
+
+														   {
+															   Logger::error() << error << Qt::endl;
+															   QMessageBox::critical(nullptr, "Error during upgrade",
+																					 error);
+															   qApp->quit();
+														   }
+
+								 );
+							 });
+			QTimer::singleShot(0, &migrator, &DBMigrator::start);
+
+			progressDialog.setWindowTitle("Upgrading database");
+			progressDialog.setLabelText("Upgrading database - this might take several minutes, please wait");
+			progressDialog.setWindowModality(Qt::ApplicationModal);
+			progressDialog.setMinimum(0);
+			progressDialog.setMaximum(0);
+			progressDialog.setValue(0);
+			progressDialog.setCancelButton(nullptr);
+			progressDialog.exec();
+
+			migrationLogger << "Database has been successfully upgraded" << Qt::endl;
+			migratorThread.quit();
+		}
 	}
 	catch(LooqsGeneralException &e)
 	{
--- a/gui/mainwindow.cpp
+++ b/gui/mainwindow.cpp
@ -15,6 +15,7 @@
 #include <QFileDialog>
 #include <QScreen>
 #include <QProgressDialog>
+#include <QDesktopWidget>
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
 #include "clicklabel.h"
@ -23,6 +24,7 @@
 #include "../shared/common.h"
 #include "ipcpreviewclient.h"
 #include "previewgenerator.h"
+#include "aboutdialog.h"

 MainWindow::MainWindow(QWidget *parent, QString socketPath)
 	: QMainWindow(parent), ui(new Ui::MainWindow), progressDialog(this)
@ -32,27 +34,6 @@ MainWindow::MainWindow(QWidget *parent, QString socketPath)
 	setWindowTitle(QCoreApplication::applicationName());
 	this->ipcPreviewClient.moveToThread(&this->ipcClientThread);
 	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());
@ -80,8 +61,24 @@ MainWindow::MainWindow(QWidget *parent, QString socketPath)
 	QString ignorePatterns = settings.value("ignorePatterns").toString();
 	ui->txtIgnorePatterns->setText(ignorePatterns);

+	QStringList searchHistoryList = settings.value(SETTINGS_KEY_SEARCHHISTORY).toStringList();
+	this->searchHistory = searchHistoryList.toVector();
+	this->currentSearchHistoryIndex = this->searchHistory.size();
+
 	ui->spinPreviewPage->setValue(1);
 	ui->spinPreviewPage->setMinimum(1);
+
+	ui->btnOpenFailed->setVisible(false);
+	ui->comboPreviewFiles->setVisible(false);
+
+	auto policy = ui->btnOpenFailed->sizePolicy();
+	policy.setRetainSizeWhenHidden(true);
+	ui->btnOpenFailed->setSizePolicy(policy);
+
+	ui->txtSearch->installEventFilter(this);
+	ui->scrollArea->viewport()->installEventFilter(this);
+
+	this->ipcClientThread.start();
 }

 void MainWindow::addPathToIndex()
@ -172,29 +169,19 @@ void MainWindow::connectSignals()
 					}
 				}
 			});
-	connect(
-		ui->menuAboutAction, &QAction::triggered, this,
-		[this](bool checked)
-		{
-			QString html = "<h2>looqs</h2>";
-			html += "Full-text search with previews for your files<br><br>";
-			html += "Copyright (c) 2018-2022: Albert Schwarzkopf<br><br>";
-			html += QString("Version: %1<br><br>").arg(Common::versionText());
-			html += "Contact: looqs at quitesimple dot org<br><br>";
-			html += "Website: <a href=\"https://quitesimple.org\">https://quitesimple.org</a><br><br>";
-			html +=
-				"Source code: <a "
-				"href=\"https://github.com/quitesimpleorg/looqs\">https://github.com/quitesimpleorg/looqs</a><br><br>";
-			html += "License: GPLv3<br><br><br>";
-			html += "looqs is open source and free of charge in the hope it will be useful. The author(s) do not "
-					"give any warranty. In the unlikely event of any damage, the author(s) cannot be held responsible. "
-					"You are using looqs at your own risk";
+	connect(ui->menuAboutAction, &QAction::triggered, this,
+			[this](bool checked)
+			{
+				AboutDialog aboutDialog(this);

-			QMessageBox::about(this, "About looqs", html);
-		});
+				aboutDialog.exec();
+			});
 	connect(ui->menuAboutQtAction, &QAction::triggered, this,
 			[this](bool checked) { QMessageBox::aboutQt(this, "About Qt"); });
 	connect(ui->menuSyncIndexAction, &QAction::triggered, this, &MainWindow::startIndexSync);
+	connect(ui->menuOpenUserManualAction, &QAction::triggered, this,
+			[this]() { QDesktopServices::openUrl(Common::userManualUrl()); });
+
 	connect(indexSyncer, &IndexSyncer::finished, this,
 			[&](unsigned int totalUpdated, unsigned int totalDeleted, unsigned int totalErrored)
 			{
@ -210,6 +197,63 @@ void MainWindow::connectSignals()
 	connect(this, &MainWindow::beginIndexSync, indexSyncer, &IndexSyncer::sync);
 	connect(&this->progressDialog, &QProgressDialog::canceled, indexSyncer, &IndexSyncer::cancel);
 	connect(ui->btnSaveSettings, &QPushButton::clicked, this, &MainWindow::saveSettings);
+	connect(ui->btnOpenFailed, &QPushButton::clicked, this, &MainWindow::exportFailedPaths);
+	connect(
+		ui->comboPreviewFiles, qOverload<int>(&QComboBox::currentIndexChanged), this,
+		[&]()
+		{
+			if(this->previewTabActive())
+			{
+				makePreviews(1);
+			}
+		},
+		Qt::QueuedConnection);
+	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);
+				this->ui->comboPreviewFiles->setEnabled(true);
+				ui->txtSearch->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);
+}
+
+void MainWindow::exportFailedPaths()
+{
+
+	QString filename =
+		QString("/tmp/looqs_indexresult_failed_%1").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd_hhmmss"));
+	QFile outFile(filename);
+	if(!outFile.open(QIODevice::WriteOnly | QIODevice::Text))
+	{
+		QMessageBox::critical(this, "Failed to write log file", "An error occured while trying to create log file");
+		return;
+	}
+
+	QTextStream stream(&outFile);
+
+	IndexResult result = this->indexer->getResult();
+
+	stream << "Failed to index the following paths:\n";
+	for(FileScanResult &fsr : result.failedResults())
+	{
+		stream << fsr.first << " " << SaveFileResultToString(fsr.second) << '\n';
+	}
+
+	QDesktopServices::openUrl(filename);
 }

 void MainWindow::startIndexSync()
@ -254,6 +298,7 @@ void MainWindow::startIndexing()
 	ui->txtSearch->setEnabled(false);
 	ui->previewProcessBar->setValue(0);
 	ui->previewProcessBar->setVisible(true);
+	ui->btnOpenFailed->setVisible(false);

 	QVector<QString> paths;
 	QStringList pathSettingsValue;
@ -289,6 +334,10 @@ void MainWindow::finishIndexing()
 	ui->settingsTab->setEnabled(true);
 	ui->txtPathScanAdd->setEnabled(true);
 	ui->txtSearch->setEnabled(true);
+	if(result.erroredPaths > 0)
+	{
+		ui->btnOpenFailed->setVisible(true);
+	}
 }

 void MainWindow::comboScaleChanged(int i)
@ -308,6 +357,182 @@ bool MainWindow::indexerTabActive()
 	return ui->tabWidget->currentIndex() == 2;
 }

+void MainWindow::processShortcut(int key)
+{
+	if(key == Qt::Key_Tab || key == Qt::Key_Backtab)
+	{
+		int tabIndex = ui->tabWidget->currentIndex();
+		if(key == Qt::Key_Tab)
+		{
+			++tabIndex;
+		}
+		if(key == Qt::Key_Backtab)
+		{
+			--tabIndex;
+		}
+		tabIndex = tabIndex % ui->tabWidget->count();
+		if(tabIndex < 0)
+		{
+			tabIndex = ui->tabWidget->count() - 1;
+		}
+		ui->tabWidget->setCurrentIndex(tabIndex);
+	}
+	if(key == Qt::Key_L)
+	{
+		ui->txtSearch->setFocus();
+		ui->txtSearch->selectAll();
+	}
+	if(key == Qt::Key_W)
+	{
+		ui->txtSearch->setFocus();
+		QString currentText = ui->txtSearch->text().trimmed();
+		int index = currentText.lastIndexOf(QRegularExpression("[\\s\\)]"));
+		if(index != -1)
+		{
+			bool isFilter = (index == currentText.length() - 1);
+			currentText.remove(index + 1, currentText.length() - index - 1);
+			if(isFilter)
+			{
+				index = currentText.lastIndexOf(' ', index);
+				if(index == -1)
+				{
+					index = 0;
+				}
+				currentText.remove(index, currentText.length());
+			}
+			if(currentText.length() > 0)
+			{
+				currentText += ' ';
+			}
+			ui->txtSearch->setText(currentText);
+		}
+		else
+		{
+			ui->txtSearch->clear();
+		}
+	}
+	if(key == Qt::Key_F)
+	{
+		ui->txtSearch->setFocus();
+		QString currentText = ui->txtSearch->text().trimmed();
+		int index = currentText.lastIndexOf(')');
+		if(index != -1)
+		{
+			bool isFilter = (index == currentText.length() - 1);
+			if(!isFilter)
+			{
+				ui->txtSearch->setSelection(index + 2, ui->txtSearch->text().length() - index - 1);
+			}
+			else
+			{
+				int begin = currentText.lastIndexOf('(', index - 1);
+				if(begin != -1)
+				{
+					ui->txtSearch->setSelection(begin + 1, index - begin - 1);
+				}
+			}
+		}
+		else
+		{
+			int spaceIndex = currentText.lastIndexOf(' ');
+			int colonIndex = currentText.lastIndexOf(':');
+			if(colonIndex > spaceIndex)
+			{
+				int target = currentText.indexOf(' ', colonIndex);
+				if(target == -1)
+				{
+					target = ui->txtSearch->text().size() - colonIndex;
+				}
+				ui->txtSearch->setSelection(colonIndex + 1, target - 1);
+			}
+			else
+			{
+				ui->txtSearch->setSelection(spaceIndex + 1, ui->txtSearch->text().size() - spaceIndex - 1);
+			}
+		}
+	}
+}
+
+bool MainWindow::eventFilter(QObject *object, QEvent *event)
+{
+	if(object == ui->txtSearch && !searchHistory.empty())
+	{
+		if(event->type() == QEvent::KeyPress)
+		{
+			QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
+			if(keyEvent->key() == Qt::Key_Up)
+			{
+				if(this->currentSavedSearchText.isEmpty())
+				{
+					this->currentSavedSearchText = ui->txtSearch->text();
+				}
+				if(this->currentSearchHistoryIndex <= 0)
+				{
+					return true;
+				}
+				--this->currentSearchHistoryIndex;
+				QString text = this->searchHistory.at(this->currentSearchHistoryIndex);
+				ui->txtSearch->setText(text);
+				return true;
+			}
+			else if(keyEvent->key() == Qt::Key_Down)
+			{
+				if(this->currentSearchHistoryIndex == searchHistory.size() - 1)
+				{
+					if(!this->currentSavedSearchText.isEmpty())
+					{
+						ui->txtSearch->setText(this->currentSavedSearchText);
+						this->currentSavedSearchText.clear();
+						++this->currentSearchHistoryIndex;
+					}
+					return true;
+				}
+				if(this->currentSearchHistoryIndex < searchHistory.size() - 1)
+				{
+					++this->currentSearchHistoryIndex;
+					QString text = this->searchHistory.at(this->currentSearchHistoryIndex);
+					ui->txtSearch->setText(text);
+				}
+				return true;
+			}
+			else
+			{
+				this->currentSavedSearchText.clear();
+				/* Off by one on purpose so Key_Up decrements it again and lands at
+				 * the last entry */
+				this->currentSearchHistoryIndex = this->searchHistory.size();
+			}
+		}
+	}
+	if(object == ui->scrollArea->viewport())
+	{
+		if(event->type() == QEvent::Wheel)
+		{
+			QWheelEvent *wheelEvent = static_cast<QWheelEvent *>(event);
+			if(wheelEvent->modifiers() & Qt::ControlModifier)
+			{
+				if(wheelEvent->angleDelta().y() > 0)
+				{
+					if(ui->comboScale->currentIndex() < ui->comboScale->count() - 1)
+					{
+						ui->comboScale->setCurrentIndex(ui->comboScale->currentIndex() + 1);
+					}
+				}
+
+				else
+				{
+					if(ui->comboScale->currentIndex() > 0)
+					{
+						ui->comboScale->setCurrentIndex(ui->comboScale->currentIndex() - 1);
+					}
+				}
+				return true;
+			}
+		}
+	}
+	return QMainWindow::eventFilter(object, event);
+}
+
 void MainWindow::keyPressEvent(QKeyEvent *event)
 {
 	bool quit =
@ -315,17 +540,15 @@ void MainWindow::keyPressEvent(QKeyEvent *event)
 	if(quit)
 	{
 		qApp->quit();
+		return;
 	}

 	if(event->modifiers() & Qt::ControlModifier)
 	{
-
-		if(event->key() == Qt::Key_L)
-		{
-			ui->txtSearch->setFocus();
-			ui->txtSearch->selectAll();
-		}
+		processShortcut(event->key());
+		return;
 	}
+
 	QWidget::keyPressEvent(event);
 }

@ -371,10 +594,24 @@ void MainWindow::initSettingsTabs()
 	ui->txtSettingMountPaths->setText(mountPaths);
 	ui->spinSettingNumerPerPages->setValue(numPagesPerPreview);
 	ui->txtSettingDatabasePath->setText(databasePath);
+	bool horizontalScroll = settings.value(SETTINGS_KEY_PREVIEWS_SCROLL_HORIZONTALLY).toBool();
+	ui->radioScrollHorizontally->setChecked(horizontalScroll);
+	ui->radioScrollVertically->setChecked(!horizontalScroll);
 }

 void MainWindow::saveSettings()
 {
+	if(ui->chkRemoveOldDb->isChecked())
+	{
+		bool result = QFile::remove(Common::databasePath());
+		if(!result)
+		{
+			QMessageBox::critical(this, "Error removing database",
+								  "Failed to remove old database. Settings not saved.");
+			return;
+		}
+	}
+
 	QSettings settings;

 	QString pdfViewerCmd = ui->txtSettingPdfPreviewerCmd->text();
@ -387,6 +624,7 @@ void MainWindow::saveSettings()
 	settings.setValue(SETTINGS_KEY_MOUNTPATHS, mountPaths);
 	settings.setValue(SETTINGS_KEY_PREVIEWSPERPAGE, ui->spinSettingNumerPerPages->value());
 	settings.setValue(SETTINGS_KEY_DBPATH, databasePath);
+	settings.setValue(SETTINGS_KEY_PREVIEWS_SCROLL_HORIZONTALLY, ui->radioScrollHorizontally->isChecked());

 	settings.sync();

@ -406,19 +644,48 @@ void MainWindow::previewReceived(QSharedPointer<PreviewResult> preview, unsigned
 		QString docPath = preview->getDocumentPath();
 		auto previewPage = preview->getPage();

+		ClickLabel *headerLabel = new ClickLabel();
+		headerLabel->setText(QString("Path: ") + preview->getDocumentPath());
+
 		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::rightClick,
-				[this, docPath, previewPage]()
-				{
-					QFileInfo fileInfo{docPath};
-					QMenu menu("labeRightClick", this);
-					createSearchResutlMenu(menu, fileInfo);
-					menu.addAction("Copy page number", [previewPage]
-								   { QGuiApplication::clipboard()->setText(QString::number(previewPage)); });
-					menu.exec(QCursor::pos());
-				});
+		label->setMaximumWidth(QApplication::desktop()->availableGeometry().width() - 200);
+
+		QVBoxLayout *previewLayout = new QVBoxLayout();
+
+		QFont font = label->font();
+		font.setPointSize(QApplication::font().pointSize() * currentSelectedScale() / 100);
+		label->setFont(font);
+		headerLabel->setFont(font);
+
+		auto leftClickHandler = [this, docPath, previewPage]() { openDocument(docPath, previewPage); };
+		auto rightClickhandler = [this, docPath, previewPage]()
+		{
+			QFileInfo fileInfo{docPath};
+			QMenu menu("labeRightClick", this);
+			createSearchResutlMenu(menu, fileInfo);
+			menu.addAction("Copy page number",
+						   [previewPage] { QGuiApplication::clipboard()->setText(QString::number(previewPage)); });
+			menu.exec(QCursor::pos());
+		};
+
+		connect(label, &ClickLabel::leftClick, leftClickHandler);
+		connect(label, &ClickLabel::rightClick, rightClickhandler);
+
+		connect(headerLabel, &ClickLabel::rightClick, rightClickhandler);
+
+		previewLayout->addWidget(label);
+
+		previewLayout->addWidget(headerLabel);
+
+		previewLayout->setMargin(0);
+		previewLayout->insertStretch(0, 1);
+		previewLayout->insertStretch(-1, 1);
+		previewLayout->setAlignment(Qt::AlignCenter);
+		QWidget *previewWidget = new QWidget();
+
+		previewWidget->setLayout(previewLayout);
+
+		ui->scrollAreaWidgetContents->layout()->addWidget(previewWidget);
 	}
 }

@ -435,6 +702,14 @@ void MainWindow::lineEditReturnPressed()
 		ui->tabWidget->setCurrentIndex(0);
 	}
 	// TODO: validate q;
+	while(this->searchHistory.size() > 30)
+	{
+		this->searchHistory.removeFirst();
+	}
+	this->searchHistory.append(q);
+	this->currentSearchHistoryIndex = this->searchHistory.size();
+	this->currentSavedSearchText.clear();
+
 	ui->treeResultsList->clear();
 	ui->lblSearchResults->setText("Searching...");
 	this->ui->txtSearch->setEnabled(false);
@ -443,21 +718,70 @@ void MainWindow::lineEditReturnPressed()
 		{
 			SqliteSearch searcher(db);
 			QVector<SearchResult> results;
-			this->contentSearchQuery = LooqsQuery::build(q, TokenType::FILTER_CONTENT_CONTAINS, true);
+			LooqsQuery tmpQuery = LooqsQuery::build(q, TokenType::WORD, true);

-			/* We can have a path search in contentsearch too (if given explicitly), so no need to do it twice.
-				Make sure path results are listed first. */
-			bool addContentSearch = this->contentSearchQuery.hasContentSearch();
-			bool addPathSearch = !this->contentSearchQuery.hasPathSearch() || !addContentSearch;
+			LooqsQuery pathsQuery = tmpQuery;
+
+			this->contentSearchQuery = tmpQuery;
+
+			bool addContentSearch = false;
+			bool addPathSearch = false;
+
+			auto createFinalTokens = [&tmpQuery](TokenType replacementToken)
+			{
+				QVector<Token> tokens = tmpQuery.getTokens();
+				for(Token &token : tokens)
+				{
+					if(token.type == TokenType::WORD)
+					{
+						token.type = replacementToken;
+					}
+				}
+				return tokens;
+			};
+
+			/* An explicit search, no lone words. We just pass it on */
+			if(!(tmpQuery.getTokensMask() & TokenType::WORD))
+			{
+				if(tmpQuery.hasContentSearch())
+				{
+					addContentSearch = true;
+				}
+				else
+				{
+					addPathSearch = true;
+				}
+			}
+			/* A path search, and lone words, e. g. p:("docs") invoice */
+			else if(tmpQuery.hasPathSearch() && (tmpQuery.getTokensMask() & TokenType::WORD))
+			{
+				this->contentSearchQuery = tmpQuery;
+				this->contentSearchQuery.setTokens(createFinalTokens(TokenType::FILTER_CONTENT_CONTAINS));
+				addContentSearch = true;
+				addPathSearch = false;
+			}
+			/* A content search and lone words, e. g. c:("to be or not") ebooks */
+			else if(tmpQuery.hasContentSearch() && (tmpQuery.getTokensMask() & TokenType::WORD))
+			{
+				this->contentSearchQuery = LooqsQuery::build(q, TokenType::FILTER_PATH_CONTAINS, false);
+				addContentSearch = true;
+				addPathSearch = false;
+			}
+			/* "Simply lone words, so search both" */
+			else if(!tmpQuery.hasPathSearch() && !tmpQuery.hasContentSearch())
+			{
+				this->contentSearchQuery.setTokens(createFinalTokens(TokenType::FILTER_CONTENT_CONTAINS));
+				pathsQuery = LooqsQuery::build(q, TokenType::FILTER_PATH_CONTAINS, false);
+				addContentSearch = true;
+				addPathSearch = true;
+			}
 			if(addPathSearch)
 			{
-				LooqsQuery filesQuery = LooqsQuery::build(q, TokenType::FILTER_PATH_CONTAINS, false);
-				if(filesQuery.getLimit() == -1)
+				if(pathsQuery.getLimit() == -1)
 				{
-					filesQuery.setLimit(1000);
+					pathsQuery.setLimit(1000);
 				}
-
-				results.append(searcher.search(filesQuery));
+				results.append(searcher.search(pathsQuery));
 			}
 			if(addContentSearch)
 			{
@ -465,9 +789,12 @@ void MainWindow::lineEditReturnPressed()
 				{
 					this->contentSearchQuery.setLimit(1000);
 				}
-
 				results.append(searcher.search(this->contentSearchQuery));
 			}
+			else
+			{
+				this->contentSearchQuery.setTokens({});
+			}
 			return results;
 		});
 	searchWatcher.setFuture(searchFuture);
@ -476,35 +803,48 @@ void MainWindow::lineEditReturnPressed()
 void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 {
 	this->previewableSearchResults.clear();
+	qDeleteAll(ui->scrollAreaWidgetContents->children());
+
 	ui->treeResultsList->clear();
+	ui->comboPreviewFiles->clear();
+	ui->comboPreviewFiles->addItem("All previews");
+	ui->comboPreviewFiles->setVisible(true);
+	ui->lblTotalPreviewPagesCount->setText("");

 	bool hasDeleted = false;
+	QHash<QString, bool> seenMap;
 	for(const SearchResult &result : results)
 	{
-		QFileInfo pathInfo(result.fileData.absPath);
+		const QString &absPath = result.fileData.absPath;
+		QFileInfo pathInfo(absPath);

-		QString fileName = pathInfo.fileName();
-		QTreeWidgetItem *item = new QTreeWidgetItem(ui->treeResultsList);
+		if(!seenMap.contains(absPath))
+		{
+			QString fileName = pathInfo.fileName();
+			QTreeWidgetItem *item = new QTreeWidgetItem(ui->treeResultsList);

-		QDateTime dt = QDateTime::fromSecsSinceEpoch(result.fileData.mtime);
-		item->setIcon(0, iconProvider.icon(pathInfo));
-		item->setText(0, fileName);
-		item->setText(1, result.fileData.absPath);
-		item->setText(2, dt.toString(Qt::ISODate));
-		item->setText(3, this->locale().formattedDataSize(result.fileData.size));
+			QDateTime dt = QDateTime::fromSecsSinceEpoch(result.fileData.mtime);
+			item->setIcon(0, iconProvider.icon(pathInfo));
+			item->setText(0, fileName);
+			item->setText(1, absPath);
+			item->setText(2, dt.toString(Qt::ISODate));
+			item->setText(3, this->locale().formattedDataSize(result.fileData.size));
+		}
 		bool exists = pathInfo.exists();
 		if(exists)
 		{
-			if(!result.wasContentSearch)
+			if(result.wasContentSearch)
 			{
-				continue;
-			}
-
-			if(!pathInfo.suffix().contains("htm")) // hack until we can preview them properly...
-			{
-				if(PreviewGenerator::get(pathInfo) != nullptr)
+				if(!pathInfo.suffix().contains("htm")) // hack until we can preview them properly...
 				{
-					this->previewableSearchResults.append(result);
+					if(PreviewGenerator::get(pathInfo) != nullptr)
+					{
+						this->previewableSearchResults.append(result);
+						if(!seenMap.contains(result.fileData.absPath))
+						{
+							ui->comboPreviewFiles->addItem(result.fileData.absPath);
+						}
+					}
 				}
 			}
 		}
@ -512,7 +852,9 @@ void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 		{
 			hasDeleted = true;
 		}
+		seenMap[absPath] = true;
 	}
+
 	ui->treeResultsList->resizeColumnToContents(0);
 	ui->treeResultsList->resizeColumnToContents(1);
 	ui->treeResultsList->resizeColumnToContents(2);
@ -526,6 +868,7 @@ void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 	}

 	QString statusText = "Results: " + QString::number(results.size()) + " files";
+	statusText += ", previewable: " + QString::number(this->previewableSearchResults.count());
 	if(hasDeleted)
 	{
 		statusText += " WARNING: Some files are inaccessible. No preview available for those. Index may be out of sync";
@ -533,6 +876,13 @@ void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 	ui->lblSearchResults->setText(statusText);
 }

+int MainWindow::currentSelectedScale()
+{
+	QString scaleText = ui->comboScale->currentText();
+	scaleText.chop(1);
+	return scaleText.toInt();
+}
+
 void MainWindow::makePreviews(int page)
 {
 	if(this->previewableSearchResults.empty())
@ -541,14 +891,22 @@ void MainWindow::makePreviews(int page)
 	}
 	qDeleteAll(ui->scrollAreaWidgetContents->children());

-	ui->scrollAreaWidgetContents->setLayout(new QHBoxLayout());
+	QSettings settings;
+	bool horizontalScroll = settings.value(SETTINGS_KEY_PREVIEWS_SCROLL_HORIZONTALLY, false).toBool();
+	if(horizontalScroll)
+	{
+		ui->scrollAreaWidgetContents->setLayout(new QHBoxLayout());
+	}
+	else
+	{
+		ui->scrollAreaWidgetContents->setLayout(new QVBoxLayout());
+		ui->scrollAreaWidgetContents->layout()->setAlignment(Qt::AlignCenter);
+	}
 	ui->previewProcessBar->setMaximum(this->previewableSearchResults.size());
 	processedPdfPreviews = 0;
-	QString scaleText = ui->comboScale->currentText();
-	scaleText.chop(1);

 	QVector<QString> wordsToHighlight;
-	QRegularExpression extractor(R"#("([^"]*)"|((\p{L}|\p{N})+))#");
+	QRegularExpression extractor(R"#("([^"]*)"|([^\s]+))#");
 	for(const Token &token : this->contentSearchQuery.getTokens())
 	{
 		if(token.type == FILTER_CONTENT_CONTAINS)
@ -574,22 +932,26 @@ void MainWindow::makePreviews(int page)
 		begin = 0;
 	}

+	int currentScale = currentSelectedScale();
 	RenderConfig renderConfig;
-	renderConfig.scaleX = QGuiApplication::primaryScreen()->physicalDotsPerInchX() * (scaleText.toInt() / 100.);
-	renderConfig.scaleY = QGuiApplication::primaryScreen()->physicalDotsPerInchY() * (scaleText.toInt() / 100.);
+	renderConfig.scaleX = QGuiApplication::primaryScreen()->physicalDotsPerInchX() * (currentScale / 100.);
+	renderConfig.scaleY = QGuiApplication::primaryScreen()->physicalDotsPerInchY() * (currentScale / 100.);
 	renderConfig.wordsToHighlight = wordsToHighlight;

 	QVector<RenderTarget> targets;
 	for(SearchResult &sr : this->previewableSearchResults)
 	{
+		if(ui->comboPreviewFiles->currentIndex() != 0)
+		{
+			if(sr.fileData.absPath != ui->comboPreviewFiles->currentText())
+			{
+				continue;
+			}
+		}
 		RenderTarget renderTarget;
 		renderTarget.path = sr.fileData.absPath;
-
-		for(unsigned int pagenum : sr.pages)
-		{
-			renderTarget.page = (int)pagenum;
-			targets.append(renderTarget);
-		}
+		renderTarget.page = (int)sr.page;
+		targets.append(renderTarget);
 	}
 	int numpages = ceil(static_cast<double>(targets.size()) / previewsPerPage);
 	ui->spinPreviewPage->setMaximum(numpages);
@ -602,6 +964,8 @@ void MainWindow::makePreviews(int page)
 	ui->previewProcessBar->setVisible(this->previewableSearchResults.size() > 0);
 	++this->currentPreviewGeneration;
 	this->ui->spinPreviewPage->setEnabled(false);
+	this->ui->comboPreviewFiles->setEnabled(false);
+	this->ui->txtSearch->setEnabled(false);
 	emit startIpcPreviews(renderConfig, targets);
 }

@ -617,6 +981,20 @@ void MainWindow::createSearchResutlMenu(QMenu &menu, const QFileInfo &fileInfo)
 	menu.addAction("Copy full path to clipboard",
 				   [&fileInfo] { QGuiApplication::clipboard()->setText(fileInfo.absoluteFilePath()); });
 	menu.addAction("Open containing folder", [this, &fileInfo] { this->openFile(fileInfo.absolutePath()); });
+
+	auto result =
+		std::find_if(this->previewableSearchResults.begin(), this->previewableSearchResults.end(),
+					 [this, &fileInfo](SearchResult &a) { return fileInfo.absoluteFilePath() == a.fileData.absPath; });
+
+	if(result != this->previewableSearchResults.end())
+	{
+		menu.addAction("Show previews for this file",
+					   [this, &fileInfo]
+					   {
+						   ui->tabWidget->setCurrentIndex(1);
+						   this->ui->comboPreviewFiles->setCurrentText(fileInfo.absoluteFilePath());
+					   });
+	}
 }

 void MainWindow::openDocument(QString path, int num)
@ -674,3 +1052,11 @@ MainWindow::~MainWindow()
 	delete this->indexer;
 	delete ui;
 }
+
+void MainWindow::closeEvent(QCloseEvent *event)
+{
+	QStringList list = this->searchHistory.toList();
+	QSettings settings;
+	settings.setValue(SETTINGS_KEY_SEARCHHISTORY, list);
+	settings.sync();
+}
--- a/gui/mainwindow.h
+++ b/gui/mainwindow.h
@ -30,6 +30,9 @@ class MainWindow : public QMainWindow
 	void beginSearch(const QString &query);
 	void startPdfPreviewGeneration(QVector<SearchResult> paths, double scalefactor);

+  protected:
+	void closeEvent(QCloseEvent *event) override;
+
  private:
 	DatabaseFactory *dbFactory;
 	SqliteDbService *dbService;
@ -62,6 +65,12 @@ class MainWindow : public QMainWindow
 	void openFile(QString path);
 	unsigned int currentPreviewGeneration = 1;
 	void initSettingsTabs();
+	int currentSelectedScale();
+	void processShortcut(int key);
+	bool eventFilter(QObject *object, QEvent *event);
+	QVector<QString> searchHistory;
+	int currentSearchHistoryIndex = 0;
+	QString currentSavedSearchText;
  private slots:
 	void lineEditReturnPressed();
 	void treeSearchItemActivated(QTreeWidgetItem *item, int i);
@ -75,6 +84,7 @@ class MainWindow : public QMainWindow
 	void addPathToIndex();
 	void startIndexSync();
 	void saveSettings();
+	void exportFailedPaths();

  signals:
 	void startIpcPreviews(RenderConfig config, const QVector<RenderTarget> &targets);
--- a/gui/mainwindow.ui
+++ b/gui/mainwindow.ui
@ -7,7 +7,7 @@
    <x>0</x>
    <y>0</y>
    <width>1280</width>
-    <height>736</height>
+    <height>923</height>
   </rect>
  </property>
  <property name="windowTitle">
@ -27,7 +27,7 @@
       <enum>QTabWidget::South</enum>
      </property>
      <property name="currentIndex">
-       <number>3</number>
+       <number>1</number>
      </property>
      <widget class="QWidget" name="resultsTab">
       <attribute name="title">
@ -82,7 +82,7 @@
             <x>0</x>
             <y>0</y>
             <width>1244</width>
-             <height>446</height>
+             <height>633</height>
            </rect>
           </property>
           <layout class="QHBoxLayout" name="horizontalLayout"/>
@ -162,6 +162,16 @@
            </property>
           </widget>
          </item>
+          <item>
+           <widget class="QComboBox" name="comboPreviewFiles">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+           </widget>
+          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
@ -184,6 +194,16 @@
        <string>Index</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout">
+        <item row="6" column="0">
+         <widget class="QLineEdit" name="txtIgnorePatterns"/>
+        </item>
+        <item row="11" column="0">
+         <widget class="QPushButton" name="btnStartIndexing">
+          <property name="text">
+           <string>Start indexing</string>
+          </property>
+         </widget>
+        </item>
        <item row="1" column="0">
         <widget class="QGroupBox" name="groupBoxPaths">
          <property name="title">
@ -243,6 +263,12 @@
            <layout class="QHBoxLayout" name="horizontalLayout_7">
             <item>
              <widget class="QLabel" name="lblPathsFound">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="text">
                <string>Paths found:</string>
               </property>
@ -250,17 +276,42 @@
             </item>
             <item>
              <widget class="QLabel" name="lblPathsFoundValue">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="text">
                <string/>
               </property>
              </widget>
             </item>
+             <item>
+              <spacer name="horizontalSpacer_5">
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>40</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
            </layout>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_4">
             <item>
              <widget class="QLabel" name="lblAdded">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="font">
                <font>
                 <weight>50</weight>
@ -274,17 +325,42 @@
             </item>
             <item>
              <widget class="QLabel" name="lblAddedValue">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="text">
                <string/>
               </property>
              </widget>
             </item>
+             <item>
+              <spacer name="horizontalSpacer_4">
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>40</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
            </layout>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_5">
             <item>
              <widget class="QLabel" name="lblSkipped">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="font">
                <font>
                 <weight>50</weight>
@ -298,17 +374,42 @@
             </item>
             <item>
              <widget class="QLabel" name="lblSkippedValue">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="text">
                <string/>
               </property>
              </widget>
             </item>
+             <item>
+              <spacer name="horizontalSpacer_3">
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>40</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
            </layout>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_6">
             <item>
              <widget class="QLabel" name="lblFailed">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="font">
                <font>
                 <weight>50</weight>
@ -322,26 +423,35 @@
             </item>
             <item>
              <widget class="QLabel" name="lblFailedValue">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
               <property name="text">
                <string/>
               </property>
              </widget>
             </item>
+             <item>
+              <widget class="QPushButton" name="btnOpenFailed">
+               <property name="sizePolicy">
+                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+                 <horstretch>0</horstretch>
+                 <verstretch>0</verstretch>
+                </sizepolicy>
+               </property>
+               <property name="text">
+                <string>Open log of failed paths</string>
+               </property>
+              </widget>
+             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
-        <item row="6" column="0">
-         <widget class="QLineEdit" name="txtIgnorePatterns"/>
-        </item>
-        <item row="10" column="0">
-         <widget class="QPushButton" name="btnStartIndexing">
-          <property name="text">
-           <string>Start indexing</string>
-          </property>
-         </widget>
-        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="settingsTab">
@ -422,9 +532,29 @@
           <item>
            <widget class="QLineEdit" name="txtSettingDatabasePath"/>
           </item>
+           <item>
+            <widget class="QCheckBox" name="chkRemoveOldDb">
+             <property name="text">
+              <string>Remove old database on save</string>
+             </property>
+            </widget>
+           </item>
          </layout>
         </widget>
        </item>
+        <item>
+         <spacer name="verticalSpacer">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
        <item>
         <widget class="QGroupBox" name="Misc">
          <property name="title">
@ -434,7 +564,7 @@
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_9">
             <item>
-              <widget class="QLabel" name="label_4">
+              <widget class="QLabel" name="lblMaxNumbersPreviewPages">
               <property name="text">
                <string>Max number of previews per 'page' in 'Previews' tab: </string>
               </property>
@ -458,22 +588,47 @@
             </item>
            </layout>
           </item>
+           <item>
+            <layout class="QHBoxLayout" name="horizontalLayout_8">
+             <item>
+              <widget class="QLabel" name="lblScrollModeForPreviews">
+               <property name="text">
+                <string>Scroll mode for previews:</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QRadioButton" name="radioScrollVertically">
+               <property name="text">
+                <string>Vertically</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QRadioButton" name="radioScrollHorizontally">
+               <property name="text">
+                <string>Horizontally</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <spacer name="horizontalSpacer_6">
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>40</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
+            </layout>
+           </item>
          </layout>
         </widget>
        </item>
-        <item>
-         <spacer name="verticalSpacer">
-          <property name="orientation">
-           <enum>Qt::Vertical</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>20</width>
-            <height>40</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
        <item>
         <widget class="QPushButton" name="btnSaveSettings">
          <property name="text">
@ -516,6 +671,7 @@
     <string>looqs</string>
    </property>
    <addaction name="menuSyncIndexAction"/>
+    <addaction name="menuOpenUserManualAction"/>
    <addaction name="menuAboutAction"/>
    <addaction name="menuAboutQtAction"/>
    <addaction name="separator"/>
@ -537,6 +693,11 @@
    <string>Sync index (remove deleted, update existing files)</string>
   </property>
  </action>
+  <action name="menuOpenUserManualAction">
+   <property name="text">
+    <string>Open user manual</string>
+   </property>
+  </action>
 </widget>
 <layoutdefault spacing="6" margin="11"/>
 <resources/>
--- a/gui/previewgenerator.cpp
+++ b/gui/previewgenerator.cpp
@ -2,13 +2,15 @@
 #include "previewgenerator.h"
 #include "previewgeneratorpdf.h"
 #include "previewgeneratorplaintext.h"
+#include "previewgeneratorodt.h"

 static PreviewGenerator *plainTextGenerator = new PreviewGeneratorPlainText();

 static QMap<QString, PreviewGenerator *> generators{
 	{"pdf", new PreviewGeneratorPdf()}, {"txt", plainTextGenerator},  {"md", plainTextGenerator},
 	{"py", plainTextGenerator},			{"java", plainTextGenerator}, {"js", plainTextGenerator},
-	{"cpp", plainTextGenerator},		{"c", plainTextGenerator},	  {"sql", plainTextGenerator}};
+	{"cpp", plainTextGenerator},		{"c", plainTextGenerator},	  {"sql", plainTextGenerator},
+	{"odt", new PreviewGeneratorOdt()}};

 PreviewGenerator *PreviewGenerator::get(QFileInfo &info)
 {
--- a/gui/previewgeneratorodt.cpp
+++ b/gui/previewgeneratorodt.cpp
@ -0,0 +1,32 @@
+#include <quazip.h>
+#include <quazipfile.h>
+#include "previewgeneratorplaintext.h"
+#include "previewgeneratorodt.h"
+#include "previewresultodt.h"
+#include "../shared/tagstripperprocessor.h"
+
+QSharedPointer<PreviewResult> PreviewGeneratorOdt::generate(RenderConfig config, QString documentPath,
+															unsigned int page)
+{
+	PreviewResultOdt *result = new PreviewResultOdt(documentPath, page);
+
+	QFileInfo info{documentPath};
+
+	QuaZipFile zipFile(documentPath);
+	zipFile.setFileName("content.xml");
+	if(!zipFile.open(QIODevice::ReadOnly))
+	{
+		return QSharedPointer<PreviewResult>(result);
+	}
+	QByteArray entireContent = zipFile.readAll();
+	if(entireContent.isEmpty())
+	{
+		throw LooqsGeneralException("Error while reading content.xml of " + documentPath);
+	}
+	TagStripperProcessor tsp;
+	QString content = tsp.process(entireContent).first().content;
+
+	PreviewGeneratorPlainText plainTextGenerator;
+	result->setText(plainTextGenerator.generatePreviewText(content, config, info.fileName()));
+	return QSharedPointer<PreviewResult>(result);
+}
--- a/gui/previewgeneratorodt.h
+++ b/gui/previewgeneratorodt.h
@ -0,0 +1,12 @@
+#ifndef PREVIEWGENERATORODT_H
+#define PREVIEWGENERATORODT_H
+
+#include "previewgenerator.h"
+class PreviewGeneratorOdt : public PreviewGenerator
+{
+  public:
+	using PreviewGenerator::PreviewGenerator;
+
+	QSharedPointer<PreviewResult> generate(RenderConfig config, QString documentPath, unsigned int page);
+};
+#endif // PREVIEWGENERATORODT_H
--- a/gui/previewgeneratorpdf.cpp
+++ b/gui/previewgeneratorpdf.cpp
@ -1,5 +1,6 @@
 #include <QMutexLocker>
 #include <QPainter>
+#include <QRegularExpression>
 #include "previewgeneratorpdf.h"

 static QMutex cacheMutex;
@ -17,6 +18,7 @@ Poppler::Document *PreviewGeneratorPdf::document(QString path)
 		return nullptr;
 	}
 	result->setRenderHint(Poppler::Document::TextAntialiasing);
+
 	QMutexLocker locker(&cacheMutex);
 	documentcache.insert(path, result);
 	locker.unlock();
@ -45,7 +47,12 @@ QSharedPointer<PreviewResult> PreviewGeneratorPdf::generate(RenderConfig config,
 	QImage img = pdfPage->renderToImage(config.scaleX, config.scaleY);
 	for(QString &word : config.wordsToHighlight)
 	{
-		QList<QRectF> rects = pdfPage->search(word, Poppler::Page::SearchFlag::IgnoreCase);
+		QList<QRectF> rects =
+			pdfPage->search(word, Poppler::Page::SearchFlag::IgnoreCase | Poppler::Page::SearchFlag::WholeWords);
+		if(rects.empty())
+		{
+			rects = pdfPage->search(word, Poppler::Page::SearchFlag::IgnoreCase);
+		}
 		for(QRectF &rect : rects)
 		{
 			QPainter painter(&img);
--- a/gui/previewgeneratorplaintext.cpp
+++ b/gui/previewgeneratorplaintext.cpp
@ -1,36 +1,28 @@
 #include <QTextStream>
+#include <QRegularExpression>

 #include "previewgeneratorplaintext.h"
 #include "previewresultplaintext.h"
+#include "../shared/limitqueue.h"

-QSharedPointer<PreviewResult> PreviewGeneratorPlainText::generate(RenderConfig config, QString documentPath,
-																  unsigned int page)
+QString PreviewGeneratorPlainText::generatePreviewText(QString content, RenderConfig config, QString fileName)
 {
-	PreviewResultPlainText *result = new PreviewResultPlainText(documentPath, page);
-	QFile file(documentPath);
-	if(!file.open(QFile::ReadOnly | QFile::Text))
-	{
-		return QSharedPointer<PreviewResultPlainText>(result);
-	}
-	QTextStream in(&file);
-
 	QString resulText = "";
-	QString content = in.readAll();
+
 	QMap<int, QString> snippet;

-	int coveredRange = 0;
+	int coveredRange = -1;
+	int lastWordPos = -1;

-	int lastWordPos = 0;
 	QHash<QString, int> countmap;

-	const unsigned int maxSnippets = 7;
 	unsigned int currentSnippets = 0;
 	for(QString &word : config.wordsToHighlight)
 	{

 		int lastPos = 0;
 		int index = content.indexOf(word, lastPos, Qt::CaseInsensitive);
-		while(index != -1 && currentSnippets < maxSnippets)
+		while(index != -1 && currentSnippets < MAX_SNIPPETS)
 		{
 			countmap[word] = countmap.value(word, 0) + 1;

@ -66,25 +58,218 @@ QSharedPointer<PreviewResult> PreviewGeneratorPlainText::generate(RenderConfig c
 		++i;
 	}

+	resulText = resulText.toHtmlEscaped();
+	QString header = "<b>" + fileName + "</b> ";
 	for(QString &word : config.wordsToHighlight)
 	{
 		resulText.replace(word, "<span style=\"background-color: yellow;\">" + word + "</span>", Qt::CaseInsensitive);
-	}
-
-	QFileInfo info{documentPath};
-
-	QString header = "<b>" + info.fileName() + "</b> ";
-	for(QString &word : config.wordsToHighlight)
-	{
 		header += word + ": " + QString::number(countmap[word]) + " ";
 	}
-	if(currentSnippets == maxSnippets)
+
+	if(currentSnippets == MAX_SNIPPETS)
 	{
 		header += "(truncated)";
 	}

 	header += "<hr>";

-	result->setText(header + resulText.replace("\n", "<br>").mid(0, 1000));
+	return header + resulText.replace("\n", "<br>").mid(0, 1000);
+}
+
+struct Snippet
+{
+	/* Contains each line number and line of the snippet*/
+	QString snippetText;
+
+	/* How many times a word occurs in the snippetText */
+	QHash<QString, int> wordCountMap;
+};
+
+QString PreviewGeneratorPlainText::generateLineBasedPreviewText(QTextStream &in, RenderConfig config, QString fileName)
+{
+	QVector<Snippet> snippets;
+	const int contextLinesCount = 2;
+	LimitQueue<QString> queue(contextLinesCount);
+	QString currentLine;
+	currentLine.reserve(512);
+
+	/* How many lines to read after a line with a match (like grep -A ) */
+	int justReadLinesCount = -1;
+
+	struct Snippet currentSnippet;
+
+	auto appendLine = [&currentSnippet, &config](int lineNumber, QString &line)
+	{
+		int foundWordsCount = 0;
+		for(QString &word : config.wordsToHighlight)
+		{
+			QRegularExpression searchRegex("\\b" + word + "\\b");
+			bool containsRegex = line.contains(searchRegex);
+			bool contains = false;
+			if(!containsRegex)
+			{
+				contains = line.contains(word, Qt::CaseInsensitive);
+			}
+			if(containsRegex || contains)
+			{
+				currentSnippet.wordCountMap[word] = currentSnippet.wordCountMap.value(word, 0) + 1;
+				QString replacementString = "<span style=\"background-color: yellow;\">" + word + "</span>";
+				if(containsRegex)
+				{
+					line.replace(searchRegex, replacementString);
+				}
+				else
+				{
+					line.replace(word, replacementString, Qt::CaseInsensitive);
+				}
+				++foundWordsCount;
+			}
+		}
+		currentSnippet.snippetText.append(QString("<b>%1</b>%2<br>").arg(lineNumber).arg(line));
+		return foundWordsCount;
+	};
+
+	unsigned int lineCount = 0;
+	while(in.readLineInto(&currentLine))
+	{
+		currentLine = currentLine.toHtmlEscaped();
+		++lineCount;
+		bool matched = false;
+		if(justReadLinesCount > 0)
+		{
+
+			int result = appendLine(lineCount, currentLine);
+			if(justReadLinesCount == 1 && result > 0)
+			{
+				justReadLinesCount = contextLinesCount;
+			}
+			else
+			{
+				--justReadLinesCount;
+			}
+
+			continue;
+		}
+		if(justReadLinesCount == 0)
+		{
+			currentSnippet.snippetText += "---<br>";
+			justReadLinesCount = -1;
+			snippets.append(currentSnippet);
+			currentSnippet = {};
+		}
+		for(QString &word : config.wordsToHighlight)
+		{
+			if(currentLine.contains(word, Qt::CaseInsensitive))
+			{
+				matched = true;
+				break;
+			}
+		}
+		if(matched)
+		{
+			while(queue.size() > 0)
+			{
+				int queuedLineCount = lineCount - queue.size();
+				QString queuedLine = queue.dequeue();
+				appendLine(queuedLineCount, queuedLine);
+			}
+			appendLine(lineCount, currentLine);
+			justReadLinesCount = contextLinesCount;
+		}
+		else
+		{
+			queue.enqueue(currentLine);
+		}
+	}
+
+	if(!currentSnippet.snippetText.isEmpty())
+	{
+		currentSnippet.snippetText += "---<br>";
+		snippets.append(currentSnippet);
+	}
+
+	std::sort(snippets.begin(), snippets.end(),
+			  [](Snippet &a, Snippet &b)
+			  {
+				  int differentWordsA = 0;
+				  int totalWordsA = 0;
+				  int differentWordsB = 0;
+				  int totalWordsB = 0;
+				  for(int count : a.wordCountMap.values())
+				  {
+					  if(count > 0)
+					  {
+						  ++differentWordsA;
+					  }
+					  totalWordsA += count;
+				  }
+				  for(int count : b.wordCountMap.values())
+				  {
+					  if(count > 0)
+					  {
+						  ++differentWordsB;
+					  }
+					  totalWordsB += count;
+				  }
+
+				  if(differentWordsA > differentWordsB)
+				  {
+					  return true;
+				  }
+				  if(differentWordsA == differentWordsB)
+				  {
+					  return totalWordsA > totalWordsB;
+				  }
+				  return false;
+			  });
+
+	QString resultText = "";
+
+	unsigned int snippetsCount = 0;
+
+	QString header = "<b>" + fileName + "</b> ";
+
+	QHash<QString, int> totalWordCountMap;
+	bool isTruncated = false;
+	for(Snippet &snippet : snippets)
+	{
+		if(snippetsCount++ < MAX_SNIPPETS)
+		{
+			resultText += snippet.snippetText;
+		}
+		else
+		{
+			isTruncated = true;
+		}
+		for(auto it = snippet.wordCountMap.keyValueBegin(); it != snippet.wordCountMap.keyValueEnd(); it++)
+		{
+			totalWordCountMap[it->first] = totalWordCountMap.value(it->first, 0) + it->second;
+		}
+	}
+	if(isTruncated)
+	{
+		header += "(truncated) ";
+	}
+	for(QString &word : config.wordsToHighlight)
+	{
+		header += word + ": " + QString::number(totalWordCountMap[word]) + " ";
+	}
+	header += "<hr>";
+
+	return header + resultText;
+}
+
+QSharedPointer<PreviewResult> PreviewGeneratorPlainText::generate(RenderConfig config, QString documentPath,
+																  unsigned int page)
+{
+	PreviewResultPlainText *result = new PreviewResultPlainText(documentPath, page);
+	QFile file(documentPath);
+	if(!file.open(QFile::ReadOnly | QFile::Text))
+	{
+		return QSharedPointer<PreviewResultPlainText>(result);
+	}
+	QTextStream in(&file);
+	QFileInfo info{documentPath};
+	result->setText(generateLineBasedPreviewText(in, config, info.fileName()));
 	return QSharedPointer<PreviewResultPlainText>(result);
 }
--- a/gui/previewgeneratorplaintext.h
+++ b/gui/previewgeneratorplaintext.h
@ -1,11 +1,17 @@
 #ifndef PREVIEWGENERATORPLAINTEXT_H
 #define PREVIEWGENERATORPLAINTEXT_H
+#include <QTextStream>
 #include "previewgenerator.h"

 class PreviewGeneratorPlainText : public PreviewGenerator
 {
+  protected:
+	const unsigned int MAX_SNIPPETS = 7;
+
  public:
 	using PreviewGenerator::PreviewGenerator;
+	QString generatePreviewText(QString content, RenderConfig config, QString fileName);
+	QString generateLineBasedPreviewText(QTextStream &in, RenderConfig config, QString fileName);
 	QSharedPointer<PreviewResult> generate(RenderConfig config, QString documentPath, unsigned int page);
 };

--- a/gui/previewresultodt.cpp
+++ b/gui/previewresultodt.cpp
@ -0,0 +1 @@
+#include "previewresultodt.h"
--- a/gui/previewresultodt.h
+++ b/gui/previewresultodt.h
@ -0,0 +1,10 @@
+#ifndef PREVIEWRESULTODT_H
+#define PREVIEWRESULTODT_H
+#include "previewresultplaintext.h"
+
+class PreviewResultOdt : public PreviewResultPlainText
+{
+	using PreviewResultPlainText::PreviewResultPlainText;
+};
+
+#endif // PREVIEWRESULTODT_H
--- a/shared/common.cpp
+++ b/shared/common.cpp
@ -17,50 +17,34 @@
 inline void initResources()
 {
 	Q_INIT_RESOURCE(migrations);
+	Q_INIT_RESOURCE(plaintexts);
 }

 bool Common::initSqliteDatabase(QString path)
 {
-	QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
-	db.setDatabaseName(path);
-	if(!db.open())
+	try
 	{
-		qDebug() << "failed to open database: " << path;
+		initResources();
+		DatabaseFactory factory(path);
+		DBMigrator migrator{factory};
+		migrator.performMigrations();
+	}
+	catch(std::exception &ex)
+	{
+		Logger::error() << "Failed to init dabase: " << ex.what();
 		return false;
 	}
-	initResources();
-	DBMigrator migrator{db};
-	migrator.performMigrations();
-	db.close();
 	return true;
 }

-QString Common::findInPath(QString needle)
-{
-	QStringList results;
-	QString pathVar = QProcessEnvironment::systemEnvironment().value("PATH", "/usr/bin/:/bin/:");
-	QStringList paths = pathVar.split(":");
-	for(const QString &path : paths)
-	{
-		// TODO: can pass ../ but so be it for now.
-
-		QFileInfo info{path + "/" + needle};
-		if(info.exists())
-		{
-			return info.absoluteFilePath();
-		}
-	}
-	return "";
-}
-
 void Common::setPdfViewer()
 {
 	QString value;

 	/* TODO: well, we should query this probably from xdg*/
-	QString okularPath = findInPath("okular");
-	QString evincePath = findInPath("evince");
-	QString qpdfviewPath = findInPath("qpdfview");
+	QString okularPath = QStandardPaths::findExecutable("okular");
+	QString evincePath = QStandardPaths::findExecutable("evince");
+	QString qpdfviewPath = QStandardPaths::findExecutable("qpdfview");

 	if(okularPath != "")
 	{
@ -68,16 +52,16 @@ void Common::setPdfViewer()
 	}
 	else if(evincePath != "")
 	{
-		value = evincePath + "-i %p %f";
+		value = evincePath + " -i %p %f";
 	}
 	else if(qpdfviewPath != "")
 	{
-		value = qpdfviewPath + "%f#%p";
+		value = qpdfviewPath + " %f#%p";
 	}

-	QSettings settings;
 	if(value != "")
 	{
+		QSettings settings;
 		settings.setValue(SETTINGS_KEY_PDFVIEWER, value);
 	}
 }
@ -106,21 +90,6 @@ void Common::ensureConfigured()
 		}
 		settings.setValue(SETTINGS_KEY_DBPATH, dbpath);
 	}
-	DatabaseFactory factory{dbpath};
-	auto db = factory.forCurrentThread();
-	DBMigrator migrator{db};
-	if(migrator.migrationNeeded())
-	{
-		QFile out;
-		out.open(stderr, QIODevice::WriteOnly);
-		Logger migrationLogger{&out};
-		migrationLogger << "Database is being upgraded, please be patient..." << Qt::endl;
-		QObject::connect(&migrator, &DBMigrator::migrationDone,
-						 [&migrationLogger](uint32_t migration)
-						 { migrationLogger << "Progress: Successfully migrated to: " << migration << Qt::endl; });
-		migrator.performMigrations();
-		migrationLogger << "Database upgraded successfully" << Qt::endl;
-	}
 	QVariant pdfViewer = settings.value(SETTINGS_KEY_PDFVIEWER);
 	if(!pdfViewer.isValid())
 	{
@ -233,3 +202,8 @@ QString Common::versionText()
 	QString tag = GIT_TAG;
 	return tag + " (" + commitid + ") built " + __DATE__ + " " + __TIME__;
 }
+
+QString Common::userManualUrl()
+{
+	return QString("https://github.com/quitesimpleorg/looqs/blob/%1/USAGE.md").arg(QString(GIT_COMMIT_ID));
+}
--- a/shared/common.h
+++ b/shared/common.h
@ -9,6 +9,8 @@
 #define SETTINGS_KEY_EXCLUDEDPATHS "excludedpaths"
 #define SETTINGS_KEY_MOUNTPATHS "mountpaths"
 #define SETTINGS_KEY_PREVIEWSPERPAGE "previewsPerPage"
+#define SETTINGS_KEY_SEARCHHISTORY "searchhistory"
+#define SETTINGS_KEY_PREVIEWS_SCROLL_HORIZONTALLY "horizontalscroll"

 namespace Common
 {
@ -16,7 +18,6 @@ void setupAppInfo();
 QString databasePath();
 QString ipcSocketPath();
 void setPdfViewer();
-QString findInPath(QString needle);
 bool initSqliteDatabase(QString path);
 void ensureConfigured();
 QStringList excludedPaths();
@ -25,5 +26,6 @@ bool isTextFile(QFileInfo fileInfo);
 bool isMountPath(QString path);
 bool noSandboxModeRequested();
 QString versionText();
+QString userManualUrl();
 } // namespace Common
 #endif
--- a/shared/dbmigrator.cpp
+++ b/shared/dbmigrator.cpp
@ -6,10 +6,10 @@
 #include "dbmigrator.h"
 #include "looqsgeneralexception.h"

-DBMigrator::DBMigrator(QSqlDatabase &db)
+DBMigrator::DBMigrator(DatabaseFactory &factory)
 {
 	Q_INIT_RESOURCE(migrations);
-	this->db = &db;
+	this->dbFactory = &factory;
 }

 DBMigrator::~DBMigrator()
@ -30,7 +30,8 @@ QStringList DBMigrator::getMigrationFilenames()

 uint32_t DBMigrator::currentRevision()
 {
-	QSqlQuery dbquery(*db);
+	QSqlDatabase db = dbFactory->forCurrentThread();
+	QSqlQuery dbquery(db);
 	dbquery.exec("PRAGMA user_version;");
 	if(!dbquery.next())
 	{
@ -48,38 +49,56 @@ bool DBMigrator::migrationNeeded()
 	return currentRev < static_cast<uint32_t>(migrations.size());
 }

+void DBMigrator::start()
+{
+	performMigrations();
+}
+
 void DBMigrator::performMigrations()
 {
 	QStringList migrations = getMigrationFilenames();
 	uint32_t currentRev = currentRevision();
 	uint32_t targetRev = (migrations.size());

-	for(uint32_t i = currentRev + 1; i <= targetRev; i++)
-	{
-		QString fileName = QString(":/looqs-migrations/%1.sql").arg(i);
-		QFile file{fileName};
-		if(!file.open(QIODevice::ReadOnly))
-		{
-			throw LooqsGeneralException("Migration: Failed to find required revision file");
-		}
-		QTextStream stream(&file);
-		db->transaction();
-		while(!stream.atEnd())
-		{
-			QString sql = stream.readLine();
-			QSqlQuery sqlQuery{*db};
-			if(!sqlQuery.exec(sql))
-			{
+	QSqlDatabase db = dbFactory->forCurrentThread();

-				db->rollback();
-				throw LooqsGeneralException("Failed to execute sql statement while initializing database: " +
-											sqlQuery.lastError().text());
+	try
+	{
+		for(uint32_t i = currentRev + 1; i <= targetRev; i++)
+		{
+			QString fileName = QString(":/looqs-migrations/%1.sql").arg(i);
+			QFile file{fileName};
+			if(!file.open(QIODevice::ReadOnly))
+			{
+				throw LooqsGeneralException("Migration: Failed to find required revision file");
 			}
+			QTextStream stream(&file);
+			db.transaction();
+			while(!stream.atEnd())
+			{
+				QString sql = stream.readLine();
+				QSqlQuery sqlQuery{db};
+				if(!sqlQuery.exec(sql))
+				{
+
+					db.rollback();
+					throw LooqsGeneralException("Failed to execute sql statement while initializing database: " +
+												sqlQuery.lastError().text());
+				}
+			}
+			QSqlQuery updateVersion{db};
+			updateVersion.exec(QString("PRAGMA user_version=%1;").arg(i));
+			db.commit();
+
+			QSqlQuery vacuumQuery{db};
+			vacuumQuery.exec("VACUUM;");
+
+			emit migrationDone(i);
 		}
-		QSqlQuery updateVersion{*db};
-		updateVersion.exec(QString("PRAGMA user_version=%1;").arg(i));
-		db->commit();
-		emit migrationDone(i);
+		emit done();
+	}
+	catch(LooqsGeneralException &e)
+	{
+		emit error(e.message);
 	}
-	emit done();
 }
--- a/shared/dbmigrator.h
+++ b/shared/dbmigrator.h
@ -3,14 +3,15 @@
 #include <QStringList>
 #include <QSqlDatabase>
 #include <QObject>
+#include "databasefactory.h"
 class DBMigrator : public QObject
 {
 	Q_OBJECT
  private:
-	QSqlDatabase *db;
+	DatabaseFactory *dbFactory;

  public:
-	DBMigrator(QSqlDatabase &db);
+	DBMigrator(DatabaseFactory &dbFactory);
 	~DBMigrator();
 	uint32_t currentRevision();
 	void performMigrations();
@ -19,6 +20,9 @@ class DBMigrator : public QObject
  signals:
 	void migrationDone(uint32_t);
 	void done();
+	void error(QString e);
+  public slots:
+	void start();
 };

 #endif // DBMIGRATOR_H
--- a/shared/dirscanworker.cpp
+++ b/shared/dirscanworker.cpp
@ -19,9 +19,12 @@ void DirScanWorker::run()
 	QString path;
 	/* TODO: if we have e. g. only one path, then only one thread will scan this path.
 		 *
-		 * Thus, we must resubmit to the queue directories so other threads can help
-		the current one (requires a new logic for threads in ParallelDirScanner). Alterantively,
-		start new DirScanWorkers ourselves here... */
+		 * Thus, we must submit new directory paths to the queue so other threads can help
+		the current one.
+
+		It also may not be guaranteed enqueuing new paths is faster than just scanning them,
+		at least not for dirs with a small number of files
+		*/
 	while(queue->dequeue(path))
 	{
 		if(wildcardMatcher.match(path))
--- a/shared/filesaver.cpp
+++ b/shared/filesaver.cpp
@ -87,6 +87,10 @@ int FileSaver::processFiles(const QVector<QString> paths, std::function<SaveFile
 										  {
 											  Logger::info() << "Saved" << path << Qt::endl;
 										  }
+										  else if(result == OK_WASEMPTY)
+										  {
+											  Logger::info() << "Saved (but content was empty)" << path << Qt::endl;
+										  }
 									  }
 								  }
 							  });
@ -98,7 +102,12 @@ SaveFileResult FileSaver::saveFile(const QFileInfo &fileInfo)
 	QVector<PageData> pageData;
 	QString canonicalPath = fileInfo.canonicalFilePath();

-	int status = -1;
+	int processorReturnCode = -1;
+
+	if(!fileInfo.isReadable())
+	{
+		return NOACCESS;
+	}

 	if(!fileInfo.exists())
 	{
@ -115,44 +124,45 @@ SaveFileResult FileSaver::saveFile(const QFileInfo &fileInfo)
 			}
 		}

-		QProcess process;
-		QStringList args;
-		args << "process" << canonicalPath;
-		process.setProcessChannelMode(QProcess::ForwardedErrorChannel);
-		process.start("/proc/self/exe", args);
-		process.waitForStarted();
-		process.waitForFinished();
-
-		/* TODO: This is suboptimal as it eats lots of mem
-		 * but avoids a weird QDataStream/QProcess behaviour
-		 * where it thinks the process has ended when it has not...
-		 *
-		 * Also, there seem to be issues with reads not being blocked, so
-		 * the only reliable way appears to be waiting until the process
-		 * finishes.
-		 */
-		QDataStream in(process.readAllStandardOutput());
-		while(!in.atEnd())
+		if(fileInfo.size() > 0)
 		{
-			PageData pd;
-			in >> pd;
-			pageData.append(pd);
-		}
-		status = process.exitCode();
-		if(status != 0 && status != NOTHING_PROCESSED)
-		{
-			Logger::error() << "FileSaver::saveFile(): Error while processing" << canonicalPath << ":"
-							<< "Exit code " << status << Qt::endl;
+			QProcess process;
+			QStringList args;
+			args << "process" << canonicalPath;
+			process.setProcessChannelMode(QProcess::ForwardedErrorChannel);
+			process.start("/proc/self/exe", args);
+			process.waitForStarted();
+			process.waitForFinished();

-			return PROCESSFAIL;
+			/* TODO: This is suboptimal as it eats lots of mem
+			 * but avoids a weird QDataStream/QProcess behaviour
+			 * where it thinks the process has ended when it has not...
+			 *
+			 * Also, there seem to be issues with reads not being blocked, so
+			 * the only reliable way appears to be waiting until the process
+			 * finishes.
+			 */
+			QDataStream in(process.readAllStandardOutput());
+			while(!in.atEnd())
+			{
+				PageData pd;
+				in >> pd;
+				pageData.append(pd);
+			}
+			processorReturnCode = process.exitCode();
+			if(processorReturnCode != OK && processorReturnCode != OK_WASEMPTY)
+			{
+				Logger::error() << "FileSaver::saveFile(): Error while processing" << canonicalPath << ":"
+								<< "Exit code " << processorReturnCode << Qt::endl;
+
+				return static_cast<SaveFileResult>(processorReturnCode);
+			}
 		}
 	}
-
-	// Could happen if a file corrupted for example
-	if(pageData.isEmpty() && status != NOTHING_PROCESSED)
+	SaveFileResult result = this->dbService->saveFile(fileInfo, pageData);
+	if(result == OK && processorReturnCode == OK_WASEMPTY)
 	{
-		Logger::error() << "Could not get any content for " << canonicalPath << Qt::endl;
+		return OK_WASEMPTY;
 	}
-
-	return this->dbService->saveFile(fileInfo, pageData);
+	return result;
 }
--- a/shared/indexer.cpp
+++ b/shared/indexer.cpp
@ -120,7 +120,7 @@ void Indexer::dirScanProgress(int current, int total)

 void Indexer::processFileScanResult(FileScanResult result)
 {
-	if(result.second == DBFAIL || result.second == PROCESSFAIL || result.second == NOTFOUND)
+	if(isErrorSaveFileResult(result.second))
 	{
 		this->currentIndexResult.results.append(result);
 		if(!keepGoing)
@ -138,7 +138,8 @@ void Indexer::processFileScanResult(FileScanResult result)
 		}
 	}

-	if(result.second == OK)
+	/* TODO: OK_WASEMPTY might need a special list */
+	if(result.second == OK || result.second == OK_WASEMPTY)
 	{
 		++this->currentIndexResult.addedPaths;
 	}
--- a/shared/indexer.h
+++ b/shared/indexer.h
@ -22,19 +22,30 @@ class IndexResult
 		return addedPaths + skippedPaths + erroredPaths;
 	}

-	QVector<QString> failedPaths() const
+	QVector<FileScanResult> failedResults() const
 	{
-		QVector<QString> result;
+		QVector<FileScanResult> result;
 		std::for_each(results.begin(), results.end(),
 					  [&result](FileScanResult res)
 					  {
-						  if(res.second == DBFAIL || res.second == PROCESSFAIL || res.second == NOTFOUND)
+						  if(res.second == DBFAIL || res.second == PROCESSFAIL || res.second == NOTFOUND ||
+							 res.second == NOACCESS)
 						  {
-							  result.append(res.first);
+							  result.append(res);
 						  }
 					  });
 		return result;
 	}
+
+	QVector<QString> failedPaths() const
+	{
+		QVector<QString> result;
+
+		QVector<FileScanResult> results = failedResults();
+
+		std::for_each(results.begin(), results.end(), [&result](FileScanResult res) { result.append(res.first); });
+		return result;
+	}
 };

 class Indexer : public QObject
--- a/shared/limitqueue.h
+++ b/shared/limitqueue.h
@ -0,0 +1,48 @@
+#ifndef LIMITQUEUE_H
+#define LIMITQUEUE_H
+#include <QQueue>
+
+template <class T> class LimitQueue
+{
+  protected:
+	QQueue<T> queue;
+	int limit = 0;
+
+  public:
+	LimitQueue();
+	LimitQueue(int limit)
+	{
+		this->limit = limit;
+	}
+
+	void enqueue(const T &t)
+	{
+		if(queue.size() == limit)
+		{
+			queue.dequeue();
+		}
+		queue.enqueue(t);
+	}
+
+	int size()
+	{
+		return queue.size();
+	}
+
+	T dequeue()
+	{
+		return queue.dequeue();
+	}
+
+	void setLimit(int limit)
+	{
+		this->limit = limit;
+	}
+
+	void clear()
+	{
+		queue.clear();
+	}
+};
+
+#endif // LIMITQUEUE_H
--- a/shared/looqsquery.cpp
+++ b/shared/looqsquery.cpp
@ -180,9 +180,8 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b

 	QStringList loneWords;
 	LooqsQuery result;
-	QRegularExpression rx(
-		"((?<filtername>(\\.|\\w)+):(?<args>\\((?<innerargs>[^\\)]+)\\)|([\\p{L}\\p{N},])+)|(?<boolean>AND|OR)"
-		"|(?<negation>!)|(?<bracket>\\(|\\))|(?<loneword>[\"\\p{L}\\p{N}]+))");
+	QRegularExpression rx("((?<filtername>(\\.|\\w)+):(?<args>\\((?<innerargs>[^\\)]+)\\)|([^\\s])+)|(?<boolean>AND|OR)"
+						  "|(?<negation>!)|(?<bracket>\\(|\\))|(?<loneword>[^\\s]+))");
 	QRegularExpressionMatchIterator i = rx.globalMatch(expression);
 	auto previousWasBool = [&result] { return !result.tokens.empty() && ((result.tokens.last().type & BOOL) == BOOL); };
 	auto previousWas = [&result](TokenType t) { return !result.tokens.empty() && (result.tokens.last().type == t); };
@ -320,7 +319,7 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 	QVector<Token> newTokens;

 	TokenType prevType = BOOL_AND;
-	int needsBoolean = FILTER_CONTENT | FILTER_PATH | NEGATION;
+	int needsBoolean = FILTER_CONTENT | FILTER_PATH | NEGATION | WORD;
 	for(Token &t : result.tokens)
 	{
 		if(t.type == BRACKET_OPEN || t.type & needsBoolean)
--- a/shared/looqsquery.h
+++ b/shared/looqsquery.h
@ -44,6 +44,13 @@ class LooqsQuery
 	QVector<Token> tokens;
 	QVector<SortCondition> sortConditions;
 	void addToken(Token t);
+	void updateTokensMask()
+	{
+		for(const Token &t : tokens)
+		{
+			this->tokensMask |= t.type;
+		}
+	}

  public:
 	const QVector<Token> &getTokens() const;
@ -65,8 +72,34 @@ class LooqsQuery
 	bool hasPathSearch() const;

 	void addSortCondition(SortCondition sc);
+
+	void setTokens(const QVector<Token> &tokens)
+	{
+		this->tokens = tokens;
+		updateTokensMask();
+	}
+
 	static bool checkParanthesis(QString query);
 	static LooqsQuery build(QString query, TokenType loneWordsTokenType, bool mergeLoneWords);
+
+	LooqsQuery()
+	{
+	}
+
+	LooqsQuery(const QVector<Token> &tokens, const QVector<SortCondition> &sortConditions)
+	{
+		this->tokens = tokens;
+		this->sortConditions = sortConditions;
+		updateTokensMask();
+	}
+
+	LooqsQuery(const LooqsQuery &o)
+	{
+		this->tokens = o.tokens;
+		this->sortConditions = o.sortConditions;
+		this->tokensMask = o.tokensMask;
+		this->limit = o.limit;
+	}
 };

 #endif // LOOQSQUERY_H
--- a/shared/migrations/2.sql
+++ b/shared/migrations/2.sql
@ -0,0 +1,14 @@
+ALTER TABLE content ADD ftsid integer;
+CREATE VIRTUAL TABLE fts USING fts5(content, content='');
+DROP TRIGGER contents_ai;
+DROP TRIGGER contents_au;
+DROP TRIGGER contents_ad;
+CREATE TEMP TABLE contentstemp(id INTEGER PRIMARY KEY, content text);
+CREATE TRIGGER contentstemp_ai AFTER INSERT ON contentstemp BEGIN  INSERT INTO fts(content) VALUES (new.content); UPDATE content SET ftsid=last_insert_rowid() WHERE id = new.id; END;
+INSERT INTO contentstemp(id, content) SELECT id, content FROM content;
+DROP TRIGGER contentstemp_ai;
+DROP TABLE contentstemp;
+DROP TABLE content_fts;
+ALTER TABLE content DROP COLUMN content;
+CREATE INDEX content_ftsid ON content (ftsid);
+CREATE TRIGGER content_ad AFTER DELETE ON content BEGIN  INSERT INTO fts(fts, rowid) VALUES('delete', old.ftsid); END;
--- a/shared/migrations/3.sql
+++ b/shared/migrations/3.sql
@ -0,0 +1 @@
+DROP trigger content_ad;
--- a/shared/migrations/migrations.qrc
+++ b/shared/migrations/migrations.qrc
@ -1,5 +1,7 @@
 <RCC>
    <qresource prefix="/looqs-migrations">
        <file>1.sql</file>
+        <file>2.sql</file>
+        <file>3.sql</file>
    </qresource>
 </RCC>
--- a/shared/odtprocessor.cpp
+++ b/shared/odtprocessor.cpp
@ -1,5 +1,5 @@
-#include <quazip5/quazip.h>
-#include <quazip5/quazipfile.h>
+#include <quazip.h>
+#include <quazipfile.h>
 #include "odtprocessor.h"
 #include "tagstripperprocessor.h"

--- a/shared/paralleldirscanner.cpp
+++ b/shared/paralleldirscanner.cpp
@ -71,7 +71,35 @@ void ParallelDirScanner::scan()
 	this->targetPathsQueue.clear();
 	this->resultPathsQueue.clear();

-	this->targetPathsQueue.enqueue(this->paths);
+	/* First scan without subdirs. This way we collect paths for the threads */
+	WildcardMatcher matcher;
+	matcher.setPatterns(this->ignorePatterns);
+	for(QString &path : this->paths)
+	{
+		QDirIterator iterator(path, QStringList{}, QDir::Dirs | QDir::QDir::Files | QDir::NoDotAndDotDot);
+		while(iterator.hasNext())
+		{
+			QString path = iterator.next();
+			if(matcher.match(path))
+			{
+				continue;
+			}
+			QFileInfo info = iterator.fileInfo();
+			if(!info.isSymLink())
+			{
+				if(info.isDir())
+				{
+					this->targetPathsQueue.enqueue(info.absoluteFilePath());
+				}
+				else
+				{
+					this->resultPathsQueue.enqueue(info.absoluteFilePath());
+					this->processedPaths += 1;
+				}
+			}
+		}
+	}
+	emit this->progress(this->processedPaths, this->processedPaths);
 	int threadsNum = getThreadsNum();
 	if(threadsNum == 0)
 	{
--- a/shared/plaintexts.qrc
+++ b/shared/plaintexts.qrc
@ -0,0 +1,6 @@
+<RCC>
+    <qresource>
+		<file>../LICENSE</file>
+        <file>../LICENSE-3RD-PARTY</file>
+    </qresource>
+</RCC>
--- a/shared/processor.h
+++ b/shared/processor.h
@ -10,8 +10,6 @@ enum DataSource
 	ARRAY
 };

-#define NOTHING_PROCESSED 4
-
 class Processor
 {
  public:
--- a/shared/sandboxedprocessor.cpp
+++ b/shared/sandboxedprocessor.cpp
@ -80,7 +80,7 @@ void SandboxedProcessor::printResults(const QVector<PageData> &pageData)
 	fsstdout.close();
 }

-int SandboxedProcessor::process()
+SaveFileResult SandboxedProcessor::process()
 {
 	QFileInfo fileInfo(this->filePath);
 	Processor *processor = processors.value(fileInfo.suffix(), nullptr);
@ -92,10 +92,14 @@ int SandboxedProcessor::process()
 			processor = defaultTextProcessor;
 		}
 	}
+	if(!fileInfo.isReadable())
+	{
+		return NOACCESS;
+	}
 	if(processor == nullptr || processor == nothingProcessor)
 	{
 		/* Nothing to do */
-		return NOTHING_PROCESSED;
+		return OK;
 	}

 	QVector<PageData> pageData;
@ -119,9 +123,9 @@ int SandboxedProcessor::process()
 	catch(LooqsGeneralException &e)
 	{
 		Logger::error() << "SandboxedProcessor: Error while processing" << absPath << ":" << e.message << Qt::endl;
-		return 3 /* PROCESSFAIL */;
+		return PROCESSFAIL;
 	}

 	printResults(pageData);
-	return 0;
+	return pageData.isEmpty() ? OK_WASEMPTY : OK;
 }
--- a/shared/sandboxedprocessor.h
+++ b/shared/sandboxedprocessor.h
@ -3,6 +3,7 @@
 #include <QString>
 #include <QMimeDatabase>
 #include "pagedata.h"
+#include "savefileresult.h"

 class SandboxedProcessor
 {
@ -19,7 +20,7 @@ class SandboxedProcessor
 		this->filePath = filepath;
 	}

-	int process();
+	SaveFileResult process();
 };

 #endif // SANDBOXEDPROCESSOR_H
--- a/shared/savefileresult.h
+++ b/shared/savefileresult.h
@ -0,0 +1,38 @@
+#ifndef SAVEFILERESULT_H
+#define SAVEFILERESULT_H
+
+#include <QStringList>
+
+enum SaveFileResult
+{
+	OK,
+	OK_WASEMPTY, /* The file was successfully read but no content could be extracted. Might be just an empty document or
+					so*/
+	SKIPPED,	 /* The file was not processed/saved, because it has not changed */
+	DBFAIL,		 /* A database error occured */
+	PROCESSFAIL, /* General processor failure */
+	NOTFOUND,	 /* The file was not found */
+	NOACCESS	 /* The process can't read the file */
+};
+
+static inline QString SaveFileResultToString(SaveFileResult sfr)
+{
+	QStringList SaveFileResultStr;
+
+	SaveFileResultStr << "OK"
+					  << "OK_WASEMPTY"
+					  << "SKIPPED"
+					  << "DBFAIL"
+					  << "PROCESSFAIL"
+					  << "NOTFOUND"
+					  << "NOACCESS";
+
+	return SaveFileResultStr[(int)sfr];
+}
+
+static inline bool isErrorSaveFileResult(SaveFileResult result)
+{
+	return result == DBFAIL || result == PROCESSFAIL || result == NOTFOUND || result == NOACCESS;
+}
+
+#endif // SAVEFILERESULT_H
--- a/shared/searchresult.h
+++ b/shared/searchresult.h
@ -6,7 +6,7 @@ class SearchResult
 {
  public:
 	FileData fileData;
-	QVector<unsigned int> pages;
+	unsigned int page;
 	bool wasContentSearch = false;
 };

--- a/shared/shared.pro
+++ b/shared/shared.pro
@ -16,7 +16,11 @@ CONFIG += c++17
 INCLUDEPATH += $$PWD/../sandbox/exile.h/
 INCLUDEPATH += /usr/include/poppler/qt5/ /usr/include/quazip5

-
+# Dirty, we only need the includes here but well this magic works, so...
+packagesExist(quazip1-qt5) {
+       PKGCONFIG += quazip1-qt5
+       CONFIG += link_pkgconfig
+}

 # The following define makes your compiler emit warnings if you use
 # any feature of Qt which has been marked as deprecated (the exact warnings
@ -73,6 +77,7 @@ HEADERS += sqlitesearch.h \
    filescanworker.h \
    indexer.h \
    indexsyncer.h \
+    limitqueue.h \
    logger.h \
    looqsgeneralexception.h \
    looqsquery.h \
@ -84,6 +89,7 @@ HEADERS += sqlitesearch.h \
    pdfprocessor.h \
    processor.h \
    sandboxedprocessor.h \
+    savefileresult.h \
    searchresult.h \
    sqlitedbservice.h \
    tagstripperprocessor.h \
@ -96,3 +102,4 @@ unix {
    INSTALLS += target
 }
 RESOURCES = migrations/migrations.qrc
+RESOURCES += plaintexts.qrc
--- a/shared/sqlitedbservice.cpp
+++ b/shared/sqlitedbservice.cpp
@ -151,11 +151,14 @@ SaveFileResult SqliteDbService::saveFile(QFileInfo fileInfo, QVector<PageData> &
 	int lastid = inserterQuery.lastInsertId().toInt();
 	for(const PageData &data : pageData)
 	{
+		QSqlQuery ftsQuery(db);
+		ftsQuery.prepare("INSERT INTO fts(content) VALUES(?)");
+		ftsQuery.addBindValue(data.content);
+		ftsQuery.exec();
 		QSqlQuery contentQuery(db);
-		contentQuery.prepare("INSERT INTO content(fileid, page, content) VALUES(?, ?, ?)");
+		contentQuery.prepare("INSERT INTO content(fileid, page, ftsid) VALUES(?, ?, last_insert_rowid())");
 		contentQuery.addBindValue(lastid);
 		contentQuery.addBindValue(data.pagenumber);
-		contentQuery.addBindValue(data.content);
 		if(!contentQuery.exec())
 		{
 			db.rollback();
--- a/shared/sqlitedbservice.h
+++ b/shared/sqlitedbservice.h
@ -7,14 +7,7 @@
 #include "filedata.h"
 #include "../shared/sqlitesearch.h"
 #include "../shared/token.h"
-enum SaveFileResult
-{
-	OK,
-	SKIPPED,
-	DBFAIL,
-	PROCESSFAIL,
-	NOTFOUND
-};
+#include "savefileresult.h"

 class SqliteDbService
 {
--- a/shared/sqlitesearch.cpp
+++ b/shared/sqlitesearch.cpp
@ -66,6 +66,33 @@ QString SqliteSearch::createSortSql(const QVector<SortCondition> sortConditions)
 	return "";
 }

+QString SqliteSearch::escapeFtsArgument(QString ftsArg)
+{
+	QString result;
+	QRegularExpression extractor(R"#("([^"]*)"|([^\s]+))#");
+	QRegularExpressionMatchIterator i = extractor.globalMatch(ftsArg);
+	while(i.hasNext())
+	{
+		QRegularExpressionMatch m = i.next();
+		QString value = m.captured(1);
+		if(value.isEmpty())
+		{
+			value = m.captured(2);
+			if(value.endsWith('*'))
+			{
+				value = value.mid(0, value.size() - 1);
+			}
+			result += "\"" + value + "\"*";
+		}
+		else
+		{
+			value = "\"\"" + value + "\"\"";
+			result += "\"" + value + "\" ";
+		}
+	}
+	return result;
+}
+
 QPair<QString, QVector<QString>> createNonArgPair(QString key)
 {
 	return {" " + key + " ", QVector<QString>()};
@ -115,9 +142,9 @@ QPair<QString, QVector<QString>> SqliteSearch::createSql(const Token &token)
 	}
 	if(token.type == FILTER_CONTENT_CONTAINS)
 	{
-		return {" content.id IN (SELECT content_fts.ROWID FROM content_fts WHERE content_fts.content MATCH ? ORDER BY "
+		return {" content.id IN (SELECT fts.ROWID FROM fts WHERE fts.content MATCH ? ORDER BY "
 				"rank) ",
-				{value}};
+				{escapeFtsArgument(value)}};
 	}
 	throw LooqsGeneralException("Unknown token passed (should not happen)");
 }
@ -141,11 +168,11 @@ QSqlQuery SqliteSearch::makeSqlQuery(const LooqsQuery &query)
 		{
 			if(!ftsAlreadyJoined)
 			{
-				joinSql += " INNER JOIN content_fts ON content.id = content_fts.ROWID ";
+				joinSql += " INNER JOIN fts ON content.ftsid = fts.ROWID ";
 				ftsAlreadyJoined = true;
 			}
-			whereSql += " content_fts.content MATCH ? ";
-			bindValues.append(token.value);
+			whereSql += " fts.content MATCH ? ";
+			bindValues.append(escapeFtsArgument(token.value));
 		}
 		else
 		{
@ -167,10 +194,9 @@ QSqlQuery SqliteSearch::makeSqlQuery(const LooqsQuery &query)
 				sortSql = "ORDER BY rank";
 			}
 		}
-		prepSql =
-			"SELECT file.path AS path, group_concat(content.page) AS pages, file.mtime AS mtime, file.size AS size, "
-			"file.filetype AS filetype FROM file INNER JOIN content ON file.id = content.fileid " +
-			joinSql + " WHERE 1=1 AND " + whereSql + " GROUP BY file.path  " + sortSql;
+		prepSql = "SELECT file.path AS path,  content.page AS page, file.mtime AS mtime, file.size AS size, "
+				  "file.filetype AS filetype FROM file INNER JOIN content ON file.id = content.fileid " +
+				  joinSql + " WHERE 1=1 AND " + whereSql + " " + sortSql;
 	}
 	else
 	{
@ -178,7 +204,7 @@ QSqlQuery SqliteSearch::makeSqlQuery(const LooqsQuery &query)
 		{
 			sortSql = "ORDER BY file.mtime DESC";
 		}
-		prepSql = "SELECT file.path AS path, '0' as pages,  file.mtime AS mtime, file.size AS size, file.filetype AS "
+		prepSql = "SELECT file.path AS path, '0' as page,  file.mtime AS mtime, file.size AS size, file.filetype AS "
 				  "filetype FROM file WHERE  1=1 AND " +
 				  whereSql + " " + sortSql;
 	}
@ -221,15 +247,7 @@ QVector<SearchResult> SqliteSearch::search(const LooqsQuery &query)
 		result.fileData.mtime = dbQuery.value("mtime").toUInt();
 		result.fileData.size = dbQuery.value("size").toUInt();
 		result.fileData.filetype = dbQuery.value("filetype").toChar();
-		QString pages = dbQuery.value("pages").toString();
-		QStringList pagesList = pages.split(",");
-		for(QString &page : pagesList)
-		{
-			if(page != "")
-			{
-				result.pages.append(page.toUInt());
-			}
-		}
+		result.page = dbQuery.value("page").toUInt();
 		result.wasContentSearch = contentSearch;
 		results.append(result);
 	}
--- a/shared/sqlitesearch.h
+++ b/shared/sqlitesearch.h
@ -18,6 +18,7 @@ class SqliteSearch
 	QString fieldToColumn(QueryField field);
 	QPair<QString, QVector<QString>> createSql(const Token &token);
 	QString createSortSql(const QVector<SortCondition> sortConditions);
+	QString escapeFtsArgument(QString ftsArg);
 };

 #endif // SQLITESEARCH_H
--- a/submodules/exile.h
+++ b/submodules/exile.h
Autor(a)	SHA1	Mensagem	Data
Albert S	785a517d62	Release v0.7	2022-09-10 15:15:39 +02:00
Albert S	bfb5d71448	submodules: exile.h: Update	2022-09-10 15:15:39 +02:00
Albert S	3e512b8be0	USAGE.md: Update	2022-09-10 15:15:31 +02:00
Albert S	2ab6e40d44	gui: mainwindow: Set comboPreviewFiles size policy to Maximum The current expanding setting resizes, somehow, the mainwindow when a path name is quite long.	2022-08-28 17:48:16 +02:00
Albert S	31f0568a87	shared: LimitQueue: Change limit type to int More consistent with "QQueue::size()" and silences warning	2022-08-28 13:10:39 +02:00
Albert S	238f9add49	gui: Set a more reasonable maximum width for previews They won't be this large but in particular for vertical scroll, this makes way more sense.	2022-08-28 13:05:33 +02:00
Albert S	7c63ee9178	gui: mainwindow: Set center alignment for previews Noticable now that we have vertical scrolling	2022-08-28 13:04:06 +02:00
Albert S	1edfcc8f23	gui: PreviewGeneratorPlainText: Escape html before working on text We use this semi-HTML mode to highlight words, but if we already have tags in the document this does not work quite well. Thus, escape the string before further processing it	2022-08-28 13:01:46 +02:00
Albert S	2df273dee3	gui: PreviewGenerator*: Fallback to partial highlighting if no whole word match	2022-08-28 12:44:42 +02:00
Albert S	5a47f5949f	gui: PreviewGeneratorPlainText: Rework snippets selection The current snippet selection is useless for many queries. Attempt a more reasonable snippet selection by prioritizing those where all words are contained. The more words a snippet has, the more important it is considered.Therefore, those will be at the top. Only highlight whole words	2022-08-27 22:18:43 +02:00
Albert S	e6a0c0daee	gui: PreviewGeneratorPdf: Only highlight whole words Only highlight whole words, which is less confusing	2022-08-27 22:17:10 +02:00
Albert S	11b070ed42	gui: mainwindow: Improve preview status reporting Better represent the state of available previews. Only add paths to ui->comboPreviewFiles once	2022-08-27 12:04:35 +02:00
Albert S	47874b3706	gui: ipcworker,ipcserver: Refactor Crashes were observed, faulting in libQtNetwork. Those were rather rare. We also have no traces. Probably depends on some order signal/slots were processed. Remove shared states between connections, such as the IPCPreviewWorker and socket instance in IPCServer.	2022-08-27 11:15:45 +02:00
Albert S	10d61acbd0	shared,gui: SearchResult: remove page vector Since the previous commit we don't group the results anymore, making the vector redundant	2022-08-24 00:00:11 +02:00
Albert S	eef0fae137	shared,gui,cli: Fix intra-file ordering for content search results group_concat() does not preserve order of the ORDRE BY rank, making the ordering quite meaningless for pages inside a file. The recently introduced combobox to filter on a per file basis should anyway be prefered than any kind of grouping in queries. So we just remove the groupings here. "All files" in the previews tab thus should show the best results first now, from any files part of the result set. A GUI option to sort by page instead of rank can be considered.	2022-08-23 23:44:47 +02:00
Albert S	d8205a0da4	gui: Disable search box as long as previews are being generated Otherwise "spamming" queries can cause high load and many outstanding may arrive only to be discarded anyway for not being part of the recent query.	2022-08-23 17:37:05 +02:00
Albert S	877224b6e1	gui: mainwindow: Only trigger preview generation when in tab Indirectly generation would fire when we set combobox index programitcally. So it's slot should only trigger the generation when the user is viewing the preview tab	2022-08-23 17:35:52 +02:00
Albert S	14730ed208	gui: mainwindow: Add vertical scroll option, default to it Seems horizontal mode is too unusual according to multiple feedback. Allow choosing this the mode in the settings	2022-08-21 22:57:48 +02:00
Albert S	fe610d3068	mainwindow: Allow CTRL + mouse wheel to zoom on previews	2022-08-21 18:42:32 +02:00
Albert S	0c1b57d911	mainwindow: Save/Restore history	2022-08-21 17:48:43 +02:00
Albert S	2885e40a3a	mainwindow: Add search history. Allow going up/down with arrow keys	2022-08-21 17:47:11 +02:00
Albert S	c0f4087937	sqlitesearch: escapeFtsArgument: Fix handling of '' prefix search The must not be in quotes	2022-08-21 07:55:49 +02:00
Albert S	46c52afe59	Release v0.6	2022-08-14 23:15:19 +02:00
Albert S	431abfe7c0	USAGE.md: Update	2022-08-14 20:28:17 +02:00
Albert S	47c19d121a	gui: mainwindow: Add CTRL(+Shift+)Tab shortcut to switch between tabs	2022-08-14 20:25:44 +02:00
Albert S	166c051cfb	gui: mainwindow: Add CTRL+F and CTRL+W shortcuts Add shortcuts to make entering queries more efficient CTRL+F: Highlights rightmost filter, e. g. c:(word1 word2) would highlight everything between (), so "word1 word" here. Alternatively, highlights lone words, so p:(docs) word1, would highlight word1. CTRL+W: Removes last filter or words.	2022-08-14 20:25:44 +02:00
Albert S	47d0440ffb	gui: mainwindow: Add checkbox to remove current database	2022-08-14 20:25:44 +02:00
Albert S	d900d58f26	shared: migrations: Add 3.sql: Drop potentailly harmful trigger In [1] it's stated that "If the values "inserted" into the text columns as part of a 'delete' command are not the same as those currently stored within the table, the results may be unpredictable." It's to be assumed only inserting ftsid is unpredictable. We have no way for a proper delete because files are not immutable or may have been deleted. For now the index will contain entries for files that don't exist. They won't appear in search results as they won't be joined in the query. [1] https://www.sqlite.org/fts5.html#the_delete_command	2022-08-14 20:24:21 +02:00
Albert S	eb58b8f770	gui: Clear previews always on new search results If a first search generates previews and the next one does not, old entries would still have been visible. So we just clear them once we get results.	2022-08-06 10:10:45 +02:00
Albert S	9a70a821bd	gui: PreviewGeneratorPlainText: Show line numbers Generate previews that show the line number and surrounding lines (like grep -C) for context.	2022-08-06 10:01:24 +02:00
Albert S	89bf65d9bb	gui: PreviewGeneratorPlaintext: Add MAX_SNIPPETS const, remove redundant loop	2022-08-06 09:35:00 +02:00
Albert S	ad06497b4b	shared: Add LimitQueue which discards oldest entry once limit hit	2022-08-06 09:06:00 +02:00
Albert S	00abc6bc1b	gui, shared: Fix and simplify word extraction regexes They did not work for chars like '-', causing errors. We can actually just extract non-space chars for these cases.	2022-08-06 08:57:39 +02:00
Albert S	e8b89b77ab	Release v0.5.1	2022-07-30 10:11:44 +02:00
Albert S	77f5c7e39d	gui: mainwindow: Revert pathsQuery to original behaviour Since `7c5c91e` we wrongly merge lone words for paths queries too. This creates unintended behaviour. Fix it by creating a new paths query without merged words, which restores the original behaviour. Also, get rid of some redundant calls to createFinalTokens()	2022-07-30 10:01:51 +02:00
Albert S	052f169ef2	Release v0.5	2022-07-29 10:17:04 +02:00
Albert S	ffdb326045	USAGE.md: Update	2022-07-29 10:17:04 +02:00
Albert S	7c5c91ef10	gui: search: Avoid double results + minor improvements Avoid double results in search by distinguishing whether a filter was explicitly given. Previously, we could not discern this. Furthermore, if a content search is given, lone words will be considered path searches. If a path search is given, we consider lone words implicit content search filters. This simplifies queries for the user	2022-07-29 10:17:04 +02:00
Albert S	076c3c4c7f	shared: LooqsQuery: Add implicit AND also for lone words	2022-07-29 10:17:04 +02:00
Albert S	c11fd1a9ff	shared: LooqsQuery: Allow constructing from tokens and sort conditions	2022-07-29 10:17:04 +02:00
Albert S	1849eba190	shared: sqlitesearch: Escape FTS arguments Most users are not to be expected to be familiar with sqlite's FTS syntax. It also leads to unnnecessary arrows in some instances. So wrap every space separated word in quotes, unless it's already in quotes. Then we just escape those with double-quotes.	2022-07-28 17:49:40 +02:00
Albert S	1188e51c35	cli: Run migrations if necessary	2022-07-28 14:28:45 +02:00
Albert S	1da8344295	shared: Adjust queries to db revision 2	2022-07-28 14:00:46 +02:00
Albert S	78f38fa418	shared: migrations: Add 2.sql: Change to contentless FTS We never used the content copy we stored. It only wasted space. Update scheme so we do not store the content anymore. Switch to contentless FTS approach	2022-07-28 14:00:46 +02:00
Albert S	7fa266e5e8	gui: main: Execute migrations. Show migration progress dialog We don't do silent upgrades anymore because they might take considerable time.	2022-07-28 13:43:02 +02:00
Albert S	c03d7da821	shared: common: Remove migration logic from ensureConfigured() Running migrations is okay for initialization. However, doing it here might take ages, so the GUI simply would not show up. Therefore, migration must be done by the CLI or GUI and they should show that migrations are running	2022-07-28 13:31:13 +02:00
Albert S	49b57e1740	shared: DBMigrator: Take DatabaseFactory, run vacuum, add error() sig, start() slot	2022-07-28 13:27:37 +02:00
Albert S	5996971195	shared: common: setPdfViewer(): Fix misplaced QSettings	2022-07-24 23:57:38 +02:00
Albert S	bf1265fe3a	shared: Retire Common::findInPath() for builtin Qt function	2022-07-24 18:19:38 +02:00
Albert S	43a0f08579	gui: PreviewGeneratorPlainText: Fix case of empty preview when word found on pos 0	2022-07-24 12:25:38 +02:00
Albert S	1aa5ae0ccc	gui: Introduce PreviewGeneratorOdt for basic previews of .odt files	2022-07-24 11:43:00 +02:00
Albert S	20d42a66a6	gui: Begin PreviewResultOdt	2022-07-24 11:41:25 +02:00
Albert S	cba4df3eac	gui: previews: Add label with file path below every preview	2022-07-24 11:40:38 +02:00
Albert S	fdbf3a7358	gui: PreviewGeneratorPlainText: Move snippet gen to own function for reuse	2022-07-24 11:34:52 +02:00
Albert S	ac4d7dd0a5	gui: mainwindow: Obey scale settings for plaintext previews too	2022-07-23 20:21:45 +02:00
Albert S	ab064c3e3b	gui: mainwindow: Add menu action to open web user manual	2022-07-23 20:16:19 +02:00
Albert S	a33c7f1859	gui: MainWindow: Move all connect() calls from constructor to connectSignals()	2022-07-16 23:35:40 +02:00
Albert S	4ce14a7284	README.md: Remove Ubuntu 21.10 as it is EOL so we won't care anymore about it	2022-07-15 16:31:12 +02:00
Albert S	cc9dae37e5	shared: Indexer: Use isErrorSaveFileResult() to check for non-successful results	2022-07-11 17:14:45 +02:00
Albert S	64a9638d1e	shared: SaveFileResult: Introduce isErrorSaveFileResult()	2022-07-11 17:13:58 +02:00
Albert S	5f19328679	Release v0.4	2022-06-29 19:31:40 +02:00
Albert S	5ffd7ae97e	shared: common: setPdfViewer(): Fix missing spaces between viewer and args	2022-06-29 19:31:40 +02:00
Albert S	9ed28df09c	README.me: Minor changes	2022-06-29 18:00:05 +02:00
Albert S	69e028daf5	gui: mainwindow: Open new AboutDialog	2022-06-29 18:00:05 +02:00
Albert S	d4b0c1feae	gui: Add new AboutDialog to show our licenses "paperwork"	2022-06-29 18:00:05 +02:00
Albert S	990888efc1	shared: Include license texts as resource	2022-06-29 18:00:05 +02:00
Albert S	3f8c147182	Add LICENSE-3RD-PARTY	2022-06-29 18:00:05 +02:00
Albert S	ba030169aa	gui: previews: Allow filtering file for which to show preview	2022-06-29 18:00:05 +02:00
Albert S	1636e39c5b	shared: ParallelDirScanner: Fix missing progress report from top-level scan	2022-06-27 23:11:26 +02:00
Albert S	bda23670e3	shared: ParallelDirScanner: Correct filter to 'NoDotAndDotDot' from 'NoDotDot'	2022-06-27 23:10:53 +02:00
Albert S	d0fe51c666	README: Mention prebuilt tarball, add sig verification, minor improvements	2022-06-24 19:17:50 +02:00
Albert S	a561032668	shared: Indexer: Adjust for OK_WASEMPTY	2022-06-24 19:17:50 +02:00
Albert S	b8006bde7b	shared: FileSaver: Don't launch SandboxedProcessor for empty files	2022-06-24 19:17:50 +02:00
Albert S	614238edda	shared: FileSaver: Print message for OK_WASEMPTY	2022-06-24 19:17:50 +02:00
Albert S	83ed935790	shared: FileSaver: Return OK_WASEMPTY We get OK_WASEMPTY from the processor when there usually should be something. Rarely, this is not the case. Let the callers know about this state at least	2022-06-24 19:17:50 +02:00
Albert S	69837ed60f	shared: SaveFileResult: Add OK_WASEMPTY when processor could not extract anything	2022-06-24 19:17:50 +02:00
Albert S	2ad99699bf	shared: FileSaver: Adjust to SandboxedProcessor new SaveFileResult value	2022-06-24 19:17:50 +02:00
Albert S	b6b3e2f3c0	shared SandBoxedProcessor: Return SaveFileResult, remove defines Not entirely ideal as SandboxedProcessor does not save anything, but an improvement nevertheless over the current mess	2022-06-24 19:17:50 +02:00
Albert S	cf0c940b15	shared: Move SaveFileResult enum to own header	2022-06-24 19:17:50 +02:00
Albert S	9c41d531b0	gui: mainwindow: Add button to save log of failed paths	2022-06-24 19:17:50 +02:00
Albert S	780318db6d	shared: Indexer: Consider new NOACCESS too	2022-06-24 19:17:50 +02:00
Albert S	9fd48d4664	shared: FileSaver: Return NOACCESS when no read access	2022-06-24 19:17:50 +02:00
Albert S	e99b2ba091	shared: Indexer: IndexResult: Introduce failedResults()	2022-06-24 19:17:50 +02:00
Albert S	0867ab294d	shared: SandboxedProcessor: Return NO_ACCESS when file not readable	2022-06-24 19:17:50 +02:00
Albert S	01a6a499c5	shared: SqliteDBService: Add 'NOACCESS'. Add function to convert enum to str	2022-06-24 19:17:50 +02:00
Albert S	b3c6ce3899	cli: main: Improve usage text, print it when unknown command given	2022-06-24 19:17:50 +02:00
Albert S	72dae1f7be	cli: CommandAdd: Mention we read from stdin when no path is given	2022-06-24 19:17:50 +02:00
Albert S	e01f5d6490	shared: ParallelDirScanner: Perform first pass to collect paths Scan the top directory to collect paths for the threads. This way we don't launch threads for paths without subdirs. Secondly, large trees like usually $HOME will be scanned by multiple threads at first. Nevertheless, ParallelDirScanner can be improved still as threads may run quickly out of work, so we may end up with only one anyway again	2022-06-24 19:17:50 +02:00
Albert S	759d2a7924	Fix builds with quazip 1.X Sigh. quazip changed the lib name, include locations, etc. from version 1. Some distributions only have 0.9. Some only 1.x and so some packages break, so they simply patch it when building the package. Luckily, nothing we use from quazip is affected from an API perspective. So detect if there is quazip1, then use pkg-config to link that, else do it like before.	2022-06-21 22:33:50 +02:00
Albert S	a820183477	README.md: Add voidlinux build instructions	2022-06-20 23:24:10 +02:00
Albert S	8c5825439a	USAGE.md: Update to better reflect current state	2022-06-14 18:50:26 +02:00