WIP REBASE ipc refactoring

Since the previous commit we don't group the results
anymore, making the vector redundant

.gitignore

@@ -0,0 +1,11 @@
+.user
+.o
+*.user
+*.o
+*.a
+moc_*.cpp
+moc_*.h
+Makefile
+cli/looqs
+gui/looqs-gui
+qrc_*

CHANGELOG.md

@@ -0,0 +1,107 @@
+# looqs: Release notes
+## 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:
+- GUI: Add settings tab to configure various settings
+- GUI: Don't render previews for results that do not originate from a content search. This was confusing.
+- GUI: Remove 'open config file' menu action
+- GUI: Highlight "words" that are actually numbers in preview texts
+- search: Search for "words" that are a number, e. g. 23. Previously, those were ignored due to a regression.
+- CLI: Minor cleanups.
+- sandbox: Improve preview generation sandbox further by restricting it more
+- sandbox: Fix case where activiation would fail during indexing in some cases on kernels without landlock.
+- Remove 'firstrun' setting
+
+
+## 2022-06-07 - v0.2
+CHANGES:
+- Sandboxing: Add environment variable `LOOQS_DISABLE_SANDBOXING` to disable sandboxing. This is intended for troubleshooting
+- Sandboxing: Fix issue where activation failed on kernels without landlock
+
+## 2022-06-06 - v0.1
+The first release comes with basic functionality. It's a start that can be considered useful to some degree.
+
+looqs is still at an early stage and may exhibit some weirdness and contain bugs.
+
+Tested architectures: amd64.
+
+CHANGES:
+- CLI command "looqs" to add/update/delete and search
+- GUI: "looqs-gui" to search, render previews, and add files to index
+- General: Add multi-threaded indexing of all files (paths, mtime)
+- General: Generate sqlite based full-text search index for: .pdf,.odt,.ods, text files
+- General: Sandboxed content processing
+- GUI: Sandboxed IPC sub-process to render previews.
+- GUI: Add previews for pdf: Render the page the search keywords were found. Highlight the keywords when rendering the page.
+- GUI: Add previews for plaintext files: Extract snippets. Highlight the keywords when rendering the page.
+- General: Add basic filters for query.
+- GUI: Add icon. Special thanks to the following sources:
+	https://www.svgrepo.com/svg/151751/magnifier-with-small-handle
+	https://www.svgrepo.com/svg/52764/open-book
+
+	Thanks!
+- General: Documentation.
+
+- Add packages: Ubuntu 21.10, 22.04
+
+Thanks to all those who provided feedback (and endured bugs) at various stages. You know who you are, thx!

CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# looqs - Contributing
+Contributions are welcome, please use the following guidelines. 
+
+## Repository
+The github repository https://github.com/quitesimpleorg/looqs is the primary one. Pull-Requests and Issues go there, but you can also submit your feedback there. 
+
+Those who prefer a more classical approach can mail their patches etc. to looqs at quitesimple org. Ideally git-format patch and git send-email. 
+
+The repository at https://gitea.quitesimple.org/crtxcr/looqs was supposed to be the main one, but these
+plans are on hold for the time being. Just ignore it. 
+
+## Pull-Requests & Rebasing
+Your merge requests should be submitted against the dev branch. master branch won't be rebased. I'll try to avoid in the dev branch. I definitly rebase WIP/feature branches. 
+
+
+## Commit messages
+Commit messages begin with the component your change affects, e. g.  "gui:", "cli:", "shared:", followed by the class. 
+Then choose an appropriate verb in present tense. Wrong: Fixed, Fixes. Correct: Fix. Make sure lines are not too long, 
+I personally go by gut feeling in this matter. 
+
+If your change has an issue, link it at the end: Closes: https://github.com/quitesimpleorg/looqs/issues/1
+
+Example: "shared: Indexer: Use WildcardMatcher to ignore paths"
+
+## License
+You license your changes under the GPLv3 by contributing.

HACKING.md

@@ -0,0 +1,33 @@
+# looqs - Hacking
+
+## Introduction
+Without elaborating here, I hacked looqs because I was not satisfied with the state of desktop search on Linux.
+
+Originally a set of CLI python  scripts, it is now written in C++ and offers a GUI made using Qt. While a "web app" would have been an option, I prefer a desktop application for something like looqs. I chose Qt because I am more familiar with it than with any other GUI framework. To my knowledge, potential alternatives like GTK do not include as many "batteries" as Qt anyway, so the job presumably would have been harder there,
+at least for me.
+
+If you are interested in how to contribute, please see the file [CONTRIBUTING.md](CONTRIBUTING.md) which contains the instructions on how to submit patches etc.
+
+## Security
+The architecture ensures that the parsing of documents and the preview generation is sandboxed by [exile.h](https://github.com/quitesimpleorg/exile.h). looqs uses a multi-process architecture to achieve this.
+
+Qt code is considered trusted in this model. While one may critize this, it was the only practical solution. looqs uses Qt's serialization mechanism and other classes to communicate between the non-sandboxed GUI process and the sandboxed processes.
+
+Set the enviornment variable `LOOQS_DISABLE_SANDBOX=1` to disable sandboxing. It's intended for troublehshooting.
+
+## Database
+The heart is sqlite, with the FTS5 extensions behind the full-text search. While FTS may not be sqlite's strong suit, I definitly did not want to run one of those oftenly recommended heavy (Java based) solutions. I explored other options like Postgresql, I've discard them due to some limitations back then.
+
+Down the road, alternatives will be explored of course if sqlite should not suffice anymore.
+
+## File format support
+The pdf library is libpoppler. Files such as .odt or .docx documents are opened with libquazip. The XML files in there are not parsed,
+looqs simply strips the tags and that seems to work fine so far. Naturally, this is not the "proper way", so there is room for improvement maybe here. However, those file formats are not a huge priortiy for me personally. libuchardet does encoding detection and conversion.
+
+Naturally, looqs won't be able to index and render previews for everything. Such approach would create a huge bloated binary. In the future, there will be some plugin system of some sorts, either we will load .so objects or use subprocesses.
+
+## Name
+looqs looks for files. You as the user can also look inside them. The 'k' in "looks" was replaced by a 'q'. Originally, I wanted my projects to have "qs" (for quitesimple) in their name. While abandoned now, this got us to looqs.
+
+
+

README.md

@@ -1,44 +1,75 @@
-# looqs - FTS for the Linux desktop with previews for search results
-looqs 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 - 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.
 
 ## Screenshots
-### List
-![Screenshot looqs results](https://garage.quitesimple.org/assets/looqs/opearting_systems_looqs.png)
-
 ### Preview
+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)
 
+### Results list
+#### Classic results list
+Just enter what you want to find, it will search paths and file content.
+![Screenshot looqs results](https://garage.quitesimple.org/assets/looqs/looqs_diary.png)
+
+#### Searching with filters
+You can be more specific to get what you want with filters
+
+**Filters (long form)**
+![Screenshot looqs results](https://garage.quitesimple.org/assets/looqs/opearting_systems_looqs.png)
+
+**Filters (short form)**
+
+There is no need to write the long form of filters. There are also booleans available
+
+![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-0X-XX, v0.1
+Latest version: 2022-08-14, v0.6
 
-Please see [Changelog](CHANGELOG.md) for a human readable list of changes. 
+Please see [Changelog](CHANGELOG.md) for a human readable list of changes.
 
 
 ## Goals and principles
  * **Find & Preview**. Instead of merely telling you where your search phrase has been found, it should also render the corresponding portion/pages of the documents and highlight the searched words.
  * **No daemons**. As some other desktop search projects are prone to have annoying daemons running that eat system resources away, this solution should make do without daemons where possible.
- * **Easy setup**. Similiarly, there should be no need for heavy-weight databases. Instead, this solution tries to squeeze out the most from simple approaches. In particular, it relies on sqlite.
+ * **Easy setup**. Similarly, there should be no need for heavy-weight databases. Instead, looqs tries to squeeze out the most from simple approaches. In particular, it relies on sqlite.
  * **GUI & CLI**. Provide CLI interfaces and GUI interfaces
  * **Sandboxing**. As reading and rendering lots of formats naturally opens the door for security bugs, those tasks are offloaded to small, sandboxed sub-processes to mitigate the effect of exploited vulnerabilities.
 
+
+## Features
+- 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, .odt, plaintext
+- Highlight searched terms.
+- Quickly open PDF viewer or text editor at location of preview
+- Search filters
+
 ## Supported platforms
 Linux (on amd64) is currently the main focus. Currently, I don't plan on supporting anything else and the sandboxing architecture does not make it likely. I suppose a version without sandboxing might be conceivable for other platforms, but I have no plans or resources to actively target anything but Linux at this point.
 
 ### Licence
-GPLv3. 
+GPLv3.
+
+For the dependencies/third-party libraries, see: LICENSE-3RD-PARTY
 
 ### Contributing
-Fow now, github issues and pull-requests are preferred, but you can also just email
-your patches or issues to : looqs at quitesimple.org
+Please see the [Contribution guidelines](CONTRIBUTING.md) file.
+
+## Documentation
+Please see [USAGE.md](USAGE.md) for the user manual. There is also [HACKING.md](HACKING.md) with more technical information.
 
 
 ## Build
 
-### Ubuntu 21.10/22.04
+### Debian/Ubuntu
+
+To build on Ubuntu and Debian, clone the repo and then run:
 ```
 git submodule init
 git submodule update
@@ -47,10 +78,63 @@ 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
+```
 
-
-## Documentation
-Please see [Usage.md](USAGE.md) for the user manual. 
+The GUI is located in `gui/looqs-gui`, the binary for the CLI is in `cli/looqs`
 
 ## Packages
-Coming soon™
+At this point, looqs is not in any official distro package repo, but I maintain some packages.
+
+### Ubuntu 22.04
+Latest release can be installed using apt from the repo.
+```
+# First, obtain key, assume it's trusted.
+wget -O- https://repo.quitesimple.org/repo.quitesimple.org.asc  | gpg --dearmor > repo.quitesimple.org-keyring.gpg
+cat repo.quitesimple.org-keyring.gpg | sudo tee -a /usr/share/keyrings/repo.quitesimple.org.gpg > /dev/null
+
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/repo.quitesimple.org.gpg] https://repo.quitesimple.org/debian/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/quitesimple.list
+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!
+
+
+### 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`

USAGE.md

@@ -0,0 +1,180 @@
+# looqs - User guide
+This document is still work in progress.
+
+## General points
+Please consult the [README](README.md) for a description of what looqs is and on how to obtain it.
+
+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:
+
+- 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.
+
+- 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. 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 you prefer a different path, move it and adjust the path.
+
+
+## GUI
+
+### 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 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 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)".
+
+### 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 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.
+
+### 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.
+
+Reindexing a path using the "Index" tab will index new files and update existing ones. Currently however, this does not deal with deleted files.
+
+I recommend doing a sync from time to time.
+
+## CLI
+The CLI command "looqs" comes with helptext. This documentation is incomplete at the moment.
+
+### First run
+There is no point in using the "search" command on the first run. Add some files if not done so already.
+
+### Adding files
+To add files to the index, run ```looqs add [path]```, where 'path' can be a directory or a single file.
+If the path is a directory, the directory will be recursively descended, and all files in there added.
+
+"Skipped" implies the file has not been changed since it has been added to the index. If it has changed, the index content will be updated.
+
+### Searching files
+Of course the CLI will not render any previews, but it can show you the paths where search results
+have been found.
+
+```
+looqs search [terms...]
+```
+
+There is an implicit "AND" condition, meaning if you search for "photo" and "mountain", only paths
+will be shown containing both terms, but not either alone.
+
+### Deletion and Fixing Out of sync index
+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:
+```
+looqs delete --deleted --verbose
+```
+
+You can also delete by pattern:
+
+```
+looqs delete --pattern '*.java'
+```
+
+Delete never removes anything from the file system, it only operates on the database.
+
+The equivalent of the GUI sync command is:
+```
+looks update -v --continue --delete
+```
+
+
+### Updating files
+The content and metadata index for files can be updated:
+
+```
+looqs update -n
+```
+
+Those files still exist, but the content that has been indexed it out of date. This can be corrected with
+
+```
+looqs update
+```
+
+This will not add new files, you must run ```looqs add``` for this. For this reason, most users
+will probably seldom use the 'update' command alone.
+
+
+## Tips
+
+### Keeping index up to date
+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).
+
+### lh shell alias
+If you are in a shell and you know your file is somewhere in your current directory or its subdirs, and those
+are indexed by looqs, you may find the lh (look here) alias useful:
+
+```
+alias lh='looqs search $(pwd)'
+```
+
+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%' 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) | 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:
+
+| Query | Explanation |
+| ----------- | ----------- |
+|pe:(.ogg) p:(marley)| Finds paths that end with .ogg and contain 'marley' (case-insensitive)
+|p:(slides) support vector machine           |Performs a content search for 'support vector machine' in all paths containing 'slides'|
+|p:(notes) (pe:(odt) OR pe:(docx))          |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".|
+|c:("invoice") Downloads|This query is equivalent to c:("invoice") p:("Downloads")|
+
+
+
+
+
+
+

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
 

cli/commandadd.cpp

@@ -29,8 +29,12 @@ void CommandAdd::indexerFinished()
 		}
 	}
 
-	/* TODO maybe not 0 if keepGoing not given */
-	emit finishedCmd(0);
+	int ret = 0;
+	if(!keepGoing && failedPathsCount > 0)
+	{
+		ret = 1;
+	}
+	emit finishedCmd(ret);
 }
 
 int CommandAdd::handle(QStringList arguments)
@@ -40,20 +44,14 @@ int CommandAdd::handle(QStringList arguments)
 						"Continue adding files, don't exit on first error. If this option is not given, looqs will "
 						"exit asap, but it's possible that a few files will still be processed. "
 						"Set -t 1 to avoid this behavior, but processing will be slower. "},
-					   {{"a", "all"}, "On error, no files should be added, even already processed ones"},
-					   {{"v", "verbose"}, "Print skipped and added files"},
 					   {{"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);
-	bool keepGoing = parser.isSet("continue");
-	bool verbose = parser.isSet("verbose");
-	if(parser.isSet("all"))
-	{
-		throw LooqsGeneralException("To be implemented");
-	}
+	this->keepGoing = parser.isSet("continue");
 	if(parser.isSet("threads"))
 	{
 		QString threadsCount = parser.value("threads");
@@ -75,17 +73,15 @@ int CommandAdd::handle(QStringList arguments)
 
 	indexer = new Indexer(*this->dbService);
 	indexer->setTargetPaths(files.toVector());
+	indexer->setKeepGoing(keepGoing);
 
 	connect(indexer, &Indexer::pathsCountChanged, this,
 			[](int pathsCount) { Logger::info() << "Found paths: " << pathsCount << Qt::endl; });
-
 	connect(indexer, &Indexer::indexProgress, this,
 			[](int pathsCount, unsigned int added, unsigned int skipped, unsigned int failed, unsigned int totalCount)
 			{ Logger::info() << "Processed files: " << pathsCount << Qt::endl; });
 	connect(indexer, &Indexer::finished, this, &CommandAdd::indexerFinished);
 
-	/* TODO: keepGoing, verbose */
-
 	this->autoFinish = false;
 	indexer->beginIndexing();
 

cli/commandadd.h

@@ -10,6 +10,7 @@ class CommandAdd : public Command
   private:
 	SaveFileResult addFile(QString path);
 	Indexer *indexer;
+	bool keepGoing = true;
 
   protected:
   public:

cli/commandlist.cpp

@@ -7,29 +7,31 @@ int CommandList::handle(QStringList arguments)
 {
 	QCommandLineParser parser;
 	parser.addOptions({
-		{{"r", "reverse"}, "Print most-recent changed files first"},
-		{{"c", "count"}, "Counts the number of paths listed"},
-		{"pattern", "Only list files from index matching the pattern, e. g. */.git/*", "pattern"},
+		{"pattern", "Only list files from index matching the pattern, e. g. '*.txt'", "pattern"},
 	});
 
 	parser.addHelpOption();
 	parser.addPositionalArgument("list", "Lists paths in the index", "list [options]");
 
 	parser.process(arguments);
-	bool reverse = parser.isSet("reverse");
-	if(reverse)
+
+	QString pattern = parser.value("pattern");
+
+	QVector<FileData> results;
+
+	int offset = 0;
+	int limit = 1000;
+
+	auto resultscount = dbService->getFiles(results, pattern, offset, limit);
+	while(resultscount > 0)
 	{
-		throw LooqsGeneralException("Reverse option to be implemented");
+		for(FileData &fileData : results)
+		{
+			Logger::info() << fileData.absPath << Qt::endl;
+		}
+		offset += limit;
+		results.clear();
+		resultscount = dbService->getFiles(results, pattern, offset, limit);
 	}
-
-	QStringList files = parser.positionalArguments();
-	QString queryStrings = files.join(' ');
-	auto results = dbService->search(LooqsQuery::build(queryStrings, TokenType::FILTER_PATH_CONTAINS, false));
-
-	for(SearchResult &result : results)
-	{
-		Logger::info() << result.fileData.absPath << Qt::endl;
-	}
-
 	return 0;
 }

cli/commandlist.h

@@ -1,5 +1,5 @@
-#ifndef COMMANDSEARCH_H
-#define COMMANDSEARCH_H
+#ifndef COMMANDLIST_H
+#define COMMANDLIST_H
 #include "command.h"
 #include "../shared/sqlitesearch.h"
 
@@ -11,4 +11,4 @@ class CommandList : public Command
 	int handle(QStringList arguments) override;
 };
 
-#endif // COMMANDSEARCH_H
+#endif // COMMANDLIST_H

cli/commandsearch.cpp

@@ -8,14 +8,19 @@ int CommandSearch::handle(QStringList arguments)
 	QCommandLineParser parser;
 	parser.addOptions({
 		{{"r", "reverse"},
-		 "Print most-recent changed files first. This is short for adding \"sort:(mtime asc)\" to the query."},
+		 "Print most-recently changed files last. This is short for adding \"sort:(mtime asc)\" to the query."},
 	});
 
 	parser.addHelpOption();
 	parser.process(arguments);
 
-	QStringList files = parser.positionalArguments();
-	QString queryStrings = files.join(' ');
+	QStringList terms = parser.positionalArguments();
+	if(terms.length() == 0)
+	{
+		Logger::error() << "Please enter search terms" << Qt::endl;
+		return 1;
+	}
+	QString queryStrings = terms.join(' ');
 	LooqsQuery query = LooqsQuery::build(queryStrings, TokenType::FILTER_PATH_CONTAINS, false);
 	bool reverse = parser.isSet("reverse");
 	if(reverse)
@@ -26,11 +31,26 @@ int CommandSearch::handle(QStringList arguments)
 		query.addSortCondition(sc);
 	}
 
-	auto results = dbService->search(query);
-
-	for(SearchResult &result : results)
+	try
 	{
-		Logger::info() << result.fileData.absPath << Qt::endl;
+
+		QHash<QString, bool> seenMap;
+		auto results = dbService->search(query);
+
+		for(const SearchResult &result : results)
+		{
+			const QString &absPath = result.fileData.absPath;
+			if(!seenMap.contains(absPath))
+			{
+				seenMap[absPath] = true;
+				Logger::info() << absPath << Qt::endl;
+			}
+		}
+	}
+	catch(LooqsGeneralException &e)
+	{
+		Logger::error() << "Exception:" << e.message << Qt::endl;
+		return 1;
 	}
 
 	return 0;

cli/commandupdate.cpp

@@ -4,6 +4,7 @@
 #include <QThreadPool>
 #include "commandupdate.h"
 #include "logger.h"
+#include "../shared/indexsyncer.h"
 
 int CommandUpdate::handle(QStringList arguments)
 {
@@ -12,18 +13,17 @@ int CommandUpdate::handle(QStringList arguments)
 		{{{"v", "verbose"}, "Print path of the files while updating them"},
 		 {{"n", "dry-run"}, "Only print which files would be updated, don't actually update them"},
 		 {"pattern", "Only consider to update files in the index matching the pattern, e. g. */.git/*.", "pattern"},
-		 {{"d", "delete"}, "If a file does not exist anymore, delete it"},
+		 {{"d", "delete"}, "If a file does not exist anymore, delete it from the index"},
 		 {{"c", "continue"},
 		  "Continue adding files, don't exit on first error. If this option is not given, looqs will exit asap, but "
 		  "it's possible that a few files will still be processed. "
 		  "Set -t 1 to avoid this behavior, but processing will be slower."},
-		 {{"a", "all"}, "On error, no files should be updated, even already processed ones"},
 		 {{"t", "threads"}, "Number of threads to use.", "threads"}
 
 		});
 
 	parser.addHelpOption();
-	parser.addPositionalArgument("update", "Checks files for changes and updates them", "update");
+	parser.addPositionalArgument("update", "Checks files for changes and updates the index", "update");
 
 	parser.process(arguments);
 	bool keepGoing = parser.isSet("continue");
@@ -32,85 +32,61 @@ int CommandUpdate::handle(QStringList arguments)
 	bool dryRun = parser.isSet("dry-run");
 	QString pattern = parser.value("pattern");
 
-	if(parser.isSet("all"))
-	{
-		throw LooqsGeneralException("To be implemented");
-	}
 	if(parser.isSet("threads"))
 	{
 		QString threadsCount = parser.value("threads");
 		QThreadPool::globalInstance()->setMaxThreadCount(threadsCount.toInt());
 	}
-	FileSaver saver(*this->dbService);
-	QVector<FileData> files;
-	int offset = 0;
-	int limit = 1000;
-	int processedRows = dbService->getFiles(files, pattern, offset, limit);
 
-	while(processedRows > 0)
+	bool hasErrors = false;
+	IndexSyncer *syncer = new IndexSyncer(*this->dbService);
+	syncer->setKeepGoing(keepGoing);
+	syncer->setVerbose(verbose);
+	syncer->setPattern(pattern);
+	syncer->setDryRun(dryRun);
+	syncer->setRemoveDeletedFromIndex(deleteMissing);
+
+	if(dryRun)
 	{
-		QVector<QString> filePathsToUpdate;
-		for(FileData &fileData : files)
-		{
-			QFileInfo fileInfo(fileData.absPath);
-			if(fileInfo.exists() && fileInfo.isFile())
-			{
-				if(fileInfo.lastModified().toSecsSinceEpoch() != fileData.mtime)
-				{
-					if(!dryRun)
-					{
-						filePathsToUpdate.append(fileData.absPath);
-					}
-					else
-					{
-						Logger::info() << "Would update" << fileData.absPath << Qt::endl;
-					}
-				}
-			}
-			else
-			{
-				if(deleteMissing)
-				{
-					if(!dryRun)
-					{
-						if(!this->dbService->deleteFile(fileData.absPath))
-						{
-							Logger::error()
-								<< "Error: Failed to delete" << fileData.absPath << "from databas" << Qt::endl;
-							if(!keepGoing)
-							{
-								return 1;
-							}
-						}
-						if(verbose)
-						{
-							Logger::info() << "Deleted" << fileData.absPath << Qt::endl;
-						}
-					}
-					else
-					{
-
-						Logger::info() << "Would delete" << fileData.absPath << Qt::endl;
-					}
-				}
-			}
-		}
-
-		int updatedFilesCount = saver.updateFiles(filePathsToUpdate, keepGoing, verbose);
-		int shouldHaveUpdatedCount = filePathsToUpdate.size();
-		if(updatedFilesCount != shouldHaveUpdatedCount)
-		{
-			if(!keepGoing)
-			{
-				Logger::error() << "Failed to update all files selected for updating. Updated" << updatedFilesCount
-								<< "out of" << shouldHaveUpdatedCount << "selected for upating" << Qt::endl;
-				return 1;
-			}
-		}
-		offset += limit;
-		files.clear();
-		processedRows = this->dbService->getFiles(files, pattern, offset, limit);
+		connect(syncer, &IndexSyncer::removedDryRun, this,
+				[](QString path) { Logger::info() << "Would delete" << path << Qt::endl; });
+		connect(syncer, &IndexSyncer::updatedDryRun, this,
+				[](QString path) { Logger::info() << "Would update" << path << Qt::endl; });
 	}
+	else
+	{
+		connect(syncer, &IndexSyncer::removed, this,
+				[](QString path) { Logger::info() << "Removed " << path << Qt::endl; });
+		/* TODO: updated not printed, handled be verbose in FileSaver, but this can be improved */
+	}
+	connect(syncer, &IndexSyncer::finished, this,
+			[&](unsigned int totalUpdated, unsigned int totalRemoved, unsigned int totalErrors)
+			{
+				Logger::info() << "Syncing finished" << Qt::endl;
 
+				if(!dryRun)
+				{
+					Logger::info() << "Total updated:" << totalUpdated << Qt::endl;
+					Logger::info() << "Total removed from index: " << totalRemoved << Qt::endl;
+					Logger::info() << "Total deleted:" << totalErrors << Qt::endl;
+				}
+
+				int retval = 0;
+				if(hasErrors && !keepGoing)
+				{
+					retval = 1;
+				}
+				emit finishedCmd(retval);
+			});
+	connect(syncer, &IndexSyncer::error, this,
+			[&](QString error)
+			{
+				Logger::error() << error << Qt::endl;
+				hasErrors = true;
+			});
+
+	this->autoFinish = false;
+	syncer->sync();
+	/* Actual return code is handled by finishedCmd signal */
 	return 0;
 }

cli/main.cpp

@@ -10,7 +10,6 @@
 #include <QSettings>
 #include <functional>
 #include <QTimer>
-
 #include <exception>
 #include "encodingdetector.h"
 #include "pdfprocessor.h"
@@ -21,15 +20,18 @@
 #include "commanddelete.h"
 #include "commandupdate.h"
 #include "commandsearch.h"
+#include "commandlist.h"
 #include "databasefactory.h"
 #include "logger.h"
 #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)
@@ -50,6 +52,10 @@ Command *commandFromName(QString name, SqliteDbService &dbService)
 	{
 		return new CommandSearch(dbService);
 	}
+	if(name == "list")
+	{
+		return new CommandList(dbService);
+	}
 
 	return nullptr;
 }
@@ -70,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)
 	{
@@ -93,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)
@@ -112,7 +139,7 @@ int main(int argc, char *argv[])
 	}
 	else
 	{
-		Logger::error() << "Unknown command:" << commandName << Qt::endl;
+		printUsage(argv0);
 		return 1;
 	}
 

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");
+}

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

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,40 +27,50 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 
 SOURCES += \
-    ipcclient.cpp \
+    aboutdialog.cpp \
+    ipcpreviewclient.cpp \
+    ipcpreviewworker.cpp \
     ipcserver.cpp \
         main.cpp \
         mainwindow.cpp \
       clicklabel.cpp \
     previewgenerator.cpp \
     previewgeneratormapfunctor.cpp \
+    previewgeneratorodt.cpp \
     previewgeneratorpdf.cpp \
     previewgeneratorplaintext.cpp \
     previewresult.cpp \
+    previewresultodt.cpp \
     previewresultpdf.cpp \
     previewresultplaintext.cpp \
-    previewworker.cpp
+    renderconfig.cpp \
+    rendertarget.cpp
 
 HEADERS += \
+    aboutdialog.h \
     ipc.h \
-    ipcclient.h \
+    ipcpreviewclient.h \
+    ipcpreviewworker.h \
     ipcserver.h \
         mainwindow.h \
     clicklabel.h \
     previewgenerator.h \
     previewgeneratormapfunctor.h \
+    previewgeneratorodt.h \
     previewgeneratorpdf.h \
     previewgeneratorplaintext.h \
     previewresult.h \
+    previewresultodt.h \
     previewresultpdf.h \
     previewresultplaintext.h \
-    previewworker.h \
-    renderconfig.h
+    renderconfig.h \
+    rendertarget.h
 
 FORMS += \
         mainwindow.ui
 
 INCLUDEPATH += /usr/include/poppler/qt5/
+INCLUDEPATH += /usr/include/quazip5
 
 QT += widgets sql
 
@@ -66,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
 
@@ -74,3 +94,5 @@ else:win32-g++:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$OUT_PWD/../shar
 else:win32:!win32-g++:CONFIG(release, debug|release): PRE_TARGETDEPS += $$OUT_PWD/../shared/release/shared.lib
 else:win32:!win32-g++:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$OUT_PWD/../shared/debug/shared.lib
 else:unix: PRE_TARGETDEPS += $$OUT_PWD/../shared/libshared.a
+
+RESOURCES = ../looqs.svg

gui/ipc.h

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

gui/ipcclient.cpp

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

gui/ipcclient.h

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

gui/ipcpreviewclient.cpp

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

gui/ipcpreviewclient.h

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

gui/ipcpreviewworker.cpp

@@ -0,0 +1,58 @@
+#include <QtConcurrent>
+#include "ipcpreviewworker.h"
+#include "previewgeneratormapfunctor.h"
+IPCPreviewWorker::IPCPreviewWorker(QLocalSocket *peer)
+{
+	this->peer = peer;
+	this->connect(&previewWorkerWatcher, &QFutureWatcher<QByteArray>::resultReadyAt, this,
+				  [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::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)
+{
+	auto mapFunctor = PreviewGeneratorMapFunctor();
+	mapFunctor.setRenderConfig(config);
+
+	previewWorkerWatcher.setFuture(QtConcurrent::mapped(targets, mapFunctor));
+}
+
+void IPCPreviewWorker::stop()
+{
+	previewWorkerWatcher.cancel();
+	previewWorkerWatcher.waitForFinished();
+}

gui/ipcpreviewworker.h

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

gui/ipcserver.cpp

@@ -9,12 +9,14 @@
 #include "common.h"
 #include "databasefactory.h"
 #include "../shared/logger.h"
+#include "renderconfig.h"
+#include "rendertarget.h"
+#include "ipcpreviewworker.h"
 
 IpcServer::IpcServer()
 {
-	this->dbFactory = QSharedPointer<DatabaseFactory>(new DatabaseFactory(Common::databasePath()));
-	this->dbService = QSharedPointer<SqliteDbService>(new SqliteDbService(*this->dbFactory.get()));
-	this->fileSaver = QSharedPointer<FileSaver>(new FileSaver(*this->dbService.get()));
+	/* 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);
 }
 
@@ -24,85 +26,45 @@ bool IpcServer::startSpawner(QString socketPath)
 	return this->spawningServer.listen(socketPath);
 }
 
-bool IpcServer::docOpen(QString path, int pagenum)
-{
-
-	QSettings settings;
-	QString command = settings.value("pdfviewer").toString();
-	if(path.endsWith(".pdf") && command != "" && command.contains("%p") && command.contains("%f"))
-	{
-		QStringList splitted = command.split(" ");
-		if(splitted.size() > 1)
-		{
-			QString cmd = splitted[0];
-			QStringList args = splitted.mid(1);
-			args.replaceInStrings("%f", path);
-			args.replaceInStrings("%p", QString::number(pagenum));
-
-			QProcess::startDetached(cmd, args);
-		}
-	}
-	else
-	{
-		QDesktopServices::openUrl(QUrl::fromLocalFile(path));
-	}
-	return true;
-}
-
-bool IpcServer::fileOpen(QString path)
-{
-	return QDesktopServices::openUrl(QUrl::fromLocalFile(path));
-}
-
-SaveFileResult IpcServer::addFile(QString file)
-{
-	try
-	{
-		return this->fileSaver->addFile(file);
-	}
-	catch(std::exception &e)
-	{
-		Logger::error() << e.what() << Qt::endl;
-		return PROCESSFAIL;
-	}
-}
-
 void IpcServer::spawnerNewConnection()
 {
-	QScopedPointer<QLocalSocket> socket{this->spawningServer.nextPendingConnection()};
-	if(!socket.isNull())
+	QLocalSocket *socket = this->spawningServer.nextPendingConnection();
+	if(socket != nullptr)
 	{
 		if(!socket->waitForReadyRead())
 		{
 			return;
 		}
-		QDataStream stream(socket.get());
+		QDataStream stream(socket);
 		IPCCommand command;
-		QStringList args;
 		stream >> command;
-		stream >> args;
-		if(args.size() < 1)
+		if(command == GeneratePreviews)
 		{
-			stream << "invalid";
-			return;
-		}
-		if(command == DocOpen)
-		{
-			if(args.size() < 2)
+			RenderConfig renderConfig;
+			QVector<RenderTarget> targets;
+			do
 			{
-				stream << "invalid";
-				return;
-			}
-			docOpen(args[0], args[1].toInt());
-		}
-		if(command == FileOpen)
-		{
-			if(args.size() < 1)
+				/* TODO: this is not entirely robust */
+				socket->waitForReadyRead(100);
+				stream.startTransaction();
+				stream >> renderConfig >> targets;
+			} while(!stream.commitTransaction() && socket->state() == QLocalSocket::ConnectedState);
+			if(socket->state() == QLocalSocket::ConnectedState)
 			{
-				stream << "invalid";
-				return;
+				stream << targets.count();
+				socket->flush();
+				IPCPreviewWorker *previewWorker = new IPCPreviewWorker(socket);
+				connect(previewWorker, &IPCPreviewWorker::finished, this, [previewWorker] { delete previewWorker; });
+				previewWorker->start(renderConfig, targets);
 			}
-			fileOpen(args[0]);
+			else
+			{
+				delete socket;
+			}
+		}
+		if(command == StopGeneratePreviews)
+		{
+			/* TODO: implement */
 		}
 	}
 }

gui/ipcserver.h

@@ -4,16 +4,13 @@
 #include <QLocalServer>
 #include "ipc.h"
 #include "filesaver.h"
+#include "ipcpreviewworker.h"
+
 class IpcServer : public QObject
 {
 	Q_OBJECT
   private:
-	QSharedPointer<DatabaseFactory> dbFactory;
-	QSharedPointer<SqliteDbService> dbService;
-	QSharedPointer<FileSaver> fileSaver;
 	QLocalServer spawningServer;
-	bool docOpen(QString path, int pagenum);
-	bool fileOpen(QString path);
 	SaveFileResult addFile(QString file);
   private slots:
 	void spawnerNewConnection();

gui/main.cpp

@@ -5,96 +5,98 @@
 #include <QProcess>
 #include <QDir>
 #include <QCommandLineParser>
+#include <QFileInfo>
 
 #include "mainwindow.h"
 #include "searchresult.h"
 #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"
 
-void enableSandbox(QString socketPath)
+void enableIpcSandbox()
 {
-	struct exile_policy *policy = exile_init_policy();
+	struct exile_policy *policy = exile_create_policy();
 	if(policy == NULL)
 	{
 		qCritical() << "Failed to init policy for sandbox";
 		exit(EXIT_FAILURE);
 	}
-	QDir dir;
-	dir.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation));
-	dir.mkpath(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
+	policy->namespace_options = EXILE_UNSHARE_USER | EXILE_UNSHARE_MOUNT | EXILE_UNSHARE_NETWORK;
+	policy->no_new_privs = 1;
+	policy->drop_caps = 1;
+	policy->vow_promises = exile_vows_from_str("thread cpath rpath unix stdio proc error");
+	policy->mount_path_policies_to_chroot = 1;
 
-	std::string appDataLocation = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation).toStdString();
-	std::string cacheDataLocation = QStandardPaths::writableLocation(QStandardPaths::CacheLocation).toStdString();
-	std::string configDataLocation = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation).toStdString();
+	QString ipcSocketPath = Common::ipcSocketPath();
+	QFileInfo info{ipcSocketPath};
+	QString ipcSocketPathDir = info.absolutePath();
+	std::string stdIpcSocketPath = ipcSocketPathDir.toStdString();
 
-	std::string sockPath = socketPath.toStdString();
-	std::string dbPath = QFileInfo(Common::databasePath()).absolutePath().toStdString();
-	std::string mySelf = QFileInfo("/proc/self/exe").symLinkTarget().toStdString();
-	policy->namespace_options = EXILE_UNSHARE_USER;
-	if(exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ, "/") != 0)
-	{
-		qCritical() << "Failed to append a path to the path policy";
-		exit(EXIT_FAILURE);
-	}
+	/* we only need the 'server' side of the 'unix' vow (for unix sockets)'. The process
+	 * has no business to connect anywhere.
+	 *
+	 * Maybe this case should be handled by exile at some point, but for now deal with it here */
+	exile_append_syscall_policy(policy, EXILE_SYS(connect), EXILE_SYSCALL_DENY_RET_ERROR, NULL, 0);
 
-	if(exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_ALL_WRITE,
-								  appDataLocation.c_str()) != 0)
-	{
-		qCritical() << "Failed to append appDataLocation path to the path policy";
-		exit(EXIT_FAILURE);
-	}
-	if(exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_ALL_WRITE,
-								  cacheDataLocation.c_str()) != 0)
-	{
-		qCritical() << "Failed to append cacheDataLocation path to the path policy";
-		exit(EXIT_FAILURE);
-	}
-	if(exile_append_path_policies(policy,
-								  EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_REMOVE_FILE | EXILE_FS_ALLOW_ALL_WRITE,
-								  dbPath.c_str()) != 0)
-	{
-		qCritical() << "Failed to append dbPath path to the path policy";
-		exit(EXIT_FAILURE);
-	}
-	if(exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_EXEC, mySelf.c_str(), "/lib64",
-								  "/lib") != 0)
-	{
-		qCritical() << "Failed to append mySelf path to the path policy";
-		exit(EXIT_FAILURE);
-	}
-	if(exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_ALL_WRITE,
-								  configDataLocation.c_str()) != 0)
-	{
-		qCritical() << "Failed to append configDataLocation path to the path policy";
-		exit(EXIT_FAILURE);
-	}
+	/* ALLOW_EXEC is needed for fallback, not in landlock mode. It does not allow executing anything though here
+	 * due to the vows */
+	exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_EXEC, "/");
+	exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_ALL_WRITE | EXILE_FS_ALLOW_EXEC,
+							   stdIpcSocketPath.c_str());
 	int ret = exile_enable_policy(policy);
 	if(ret != 0)
 	{
-		qDebug() << "Failed to establish sandbox";
+		qDebug() << "Failed to establish sandbox" << Qt::endl;
 		exit(EXIT_FAILURE);
 	}
+
+	/* Arguments are irrelevant for sandbox test, just want to silence analyzer/compiler warnings */
+	ret = socket(AF_INET, SOCK_STREAM, 0);
+	if(ret != -1 || errno != EACCES)
+	{
+		qCritical() << "Sandbox sanity check failed" << Qt::endl;
+		exit(EXIT_FAILURE);
+	}
+
+	const struct sockaddr *addr = {};
+	ret = connect(3, addr, sizeof(*addr));
+	if(ret != -1 || errno != EACCES)
+	{
+		qCritical() << "Sandbox sanity check failed" << Qt::endl;
+		exit(EXIT_FAILURE);
+	}
+
 	exile_free_policy(policy);
 }
+
 int main(int argc, char *argv[])
 {
-	QString socketPath = "/tmp/looqs-spawner";
+	QString socketPath = Common::ipcSocketPath();
 	if(argc > 1)
 	{
 		QString arg = argv[1];
 		if(arg == "ipc")
 		{
 			Common::setupAppInfo();
-			QApplication a(argc, argv);
+			if(Common::noSandboxModeRequested())
+			{
+				qInfo() << "Launching with no sandbox!" << Qt::endl;
+			}
+			else
+			{
+				enableIpcSandbox();
+			}
+			QCoreApplication a(argc, argv);
 
 			IpcServer *ipcserver = new IpcServer();
 			qDebug() << "Launching IPC Server";
 			if(!ipcserver->startSpawner(socketPath))
 			{
-				qCritical() << "Error failed to spawn";
+				qCritical() << "Error failed to spawn" << Qt::endl;
 				return 1;
 			}
 			qDebug() << "Launched IPC Server";
@@ -103,24 +105,38 @@ int main(int argc, char *argv[])
 		if(arg == "process")
 		{
 			Common::setupAppInfo();
-			QApplication a(argc, argv);
+			QCoreApplication a(argc, argv);
 
 			QStringList args = a.arguments();
-			if(args.length() < 1)
+			if(args.length() < 3)
 			{
 				qDebug() << "Filename is required";
 				return 1;
 			}
 
-			QString file = args.at(1);
+			QString file = args.at(2);
 			SandboxedProcessor processor(file);
-			return processor.process();
+			return static_cast<int>(processor.process());
 		}
 	}
+	QString ipcSocketPath = Common::ipcSocketPath();
+	QFileInfo info{ipcSocketPath};
+	QString ipcSocketPathDir = info.absolutePath();
+
+	QDir dir;
+	if(!dir.mkpath(ipcSocketPathDir))
+	{
+		qCritical() << "Failed to create dir for ipc socket" << Qt::endl;
+		exit(EXIT_FAILURE);
+	}
+
 	QProcess process;
 	QStringList args;
 	args << "ipc";
-	if(!process.startDetached("/proc/self/exe", args))
+	process.setProcessChannelMode(QProcess::ForwardedChannels);
+
+	process.start("/proc/self/exe", args);
+	if(!process.waitForStarted(5000))
 	{
 		QString errorMsg = "Failed to start IPC server";
 		qDebug() << errorMsg;
@@ -128,7 +144,6 @@ int main(int argc, char *argv[])
 	}
 	Common::setupAppInfo();
 	QCommandLineParser parser;
-	parser.addOption({{"s", "no-sandbox"}, "Disable sandboxing"});
 	QStringList appArgs;
 	for(int i = 0; i < argc; i++)
 	{
@@ -136,17 +151,66 @@ int main(int argc, char *argv[])
 	}
 	parser.parse(appArgs);
 
+	QApplication a(argc, argv);
 	try
 	{
 		Common::ensureConfigured();
-		if(!parser.isSet("no-sandbox"))
+		DatabaseFactory factory{Common::databasePath()};
+		DBMigrator migrator{factory};
+
+		if(migrator.migrationNeeded())
 		{
-			enableSandbox(socketPath);
-			qInfo() << "Sandbox: on";
-		}
-		else
-		{
-			qInfo() << "Sandbox: off";
+			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)
@@ -155,17 +219,19 @@ int main(int argc, char *argv[])
 		QMessageBox::critical(nullptr, "Error", e.message);
 		return 1;
 	}
-	// Keep this post sandbox, afterwards does not work (suspect due to threads, but unconfirmed)
-	QApplication a(argc, argv);
+	a.setWindowIcon(QIcon(":/looqs.svg"));
+	QObject::connect(&a, &QApplication::aboutToQuit, &process, &QProcess::kill);
 
 	qRegisterMetaType<QVector<SearchResult>>("QVector<SearchResult>");
 	qRegisterMetaType<QVector<PreviewResultPdf>>("QVector<PreviewResultPdf>");
 	qRegisterMetaType<PreviewResultPdf>("PreviewResultPdf");
 	qRegisterMetaType<FileScanResult>("FileScanResult");
-
-	IPCClient client{socketPath};
-	MainWindow w{0, client};
-	w.showMaximized();
-
-	return a.exec();
+	qRegisterMetaType<RenderConfig>("RenderConfig");
+	qRegisterMetaType<QVector<RenderTarget>>("QVector<RenderTarget>");
+	qRegisterMetaType<QSharedPointer<PreviewResult>>("QSharedPointer<PreviewResult>");
+	MainWindow *w = new MainWindow{0, socketPath};
+	w->showMaximized();
+	int ret = a.exec();
+	process.waitForFinished(1000);
+	return ret;
 }

gui/mainwindow.cpp

@@ -12,24 +12,35 @@
 #include <QComboBox>
 #include <QtConcurrent/QtConcurrent>
 #include <QMessageBox>
+#include <QFileDialog>
+#include <QScreen>
+#include <QProgressDialog>
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
 #include "clicklabel.h"
 #include "../shared/sqlitesearch.h"
 #include "../shared/looqsgeneralexception.h"
 #include "../shared/common.h"
+#include "ipcpreviewclient.h"
+#include "previewgenerator.h"
+#include "aboutdialog.h"
 
-MainWindow::MainWindow(QWidget *parent, IPCClient &client) : QMainWindow(parent), ui(new Ui::MainWindow)
+MainWindow::MainWindow(QWidget *parent, QString socketPath)
+	: QMainWindow(parent), ui(new Ui::MainWindow), progressDialog(this)
 {
+	this->progressDialog.cancel(); // because constructing it shows it, quite weird
 	ui->setupUi(this);
 	setWindowTitle(QCoreApplication::applicationName());
-	this->ipcClient = &client;
+	this->ipcPreviewClient.moveToThread(&this->ipcClientThread);
+	this->ipcPreviewClient.setSocketPath(socketPath);
 	QSettings settings;
 
 	this->dbFactory = new DatabaseFactory(Common::databasePath());
 
 	db = this->dbFactory->forCurrentThread();
 	this->dbService = new SqliteDbService(*this->dbFactory);
+	this->indexSyncer = new IndexSyncer(*this->dbService);
+	this->indexSyncer->moveToThread(&this->syncerThread);
 
 	indexer = new Indexer(*(this->dbService));
 	indexer->setParent(this);
@@ -45,6 +56,28 @@ MainWindow::MainWindow(QWidget *parent, IPCClient &client) : QMainWindow(parent)
 
 	QStringList indexPaths = settings.value("indexPaths").toStringList();
 	ui->lstPaths->addItems(indexPaths);
+
+	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()
@@ -64,6 +97,7 @@ void MainWindow::addPathToIndex()
 	this->ui->lstPaths->addItem(path);
 	this->ui->txtPathScanAdd->clear();
 }
+
 void MainWindow::connectSignals()
 {
 	connect(ui->txtSearch, &QLineEdit::returnPressed, this, &MainWindow::lineEditReturnPressed);
@@ -81,16 +115,6 @@ void MainWindow::connectSignals()
 					handleSearchError(e.message);
 				}
 			});
-	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::resultReadyAt, this,
-			[&](int index) { previewReceived(previewWorkerWatcher.resultAt(index)); });
-	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::progressValueChanged,
-			ui->previewProcessBar, &QProgressBar::setValue);
-	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::started, this,
-			[&] { ui->indexerTab->setEnabled(false); });
-
-	connect(&previewWorkerWatcher, &QFutureWatcher<QSharedPointer<PreviewResult>>::finished, this,
-			[&] { ui->indexerTab->setEnabled(true); });
-
 	connect(ui->treeResultsList, &QTreeWidget::itemActivated, this, &MainWindow::treeSearchItemActivated);
 	connect(ui->treeResultsList, &QTreeWidget::customContextMenuRequested, this,
 			&MainWindow::showSearchResultsContextMenu);
@@ -129,6 +153,126 @@ void MainWindow::connectSignals()
 			{ ui->btnDeletePath->setEnabled(this->ui->lstPaths->selectedItems().count() > 0); });
 
 	connect(ui->btnDeletePath, &QPushButton::clicked, this, [&] { qDeleteAll(ui->lstPaths->selectedItems()); });
+	connect(ui->btnChoosePath, &QPushButton::clicked, this,
+			[&]
+			{
+				QFileDialog dialog(nullptr);
+				dialog.setFileMode(QFileDialog::Directory);
+				dialog.setOptions(QFileDialog::ShowDirsOnly);
+				if(dialog.exec())
+				{
+					auto paths = dialog.selectedFiles();
+					if(paths.size() == 1)
+					{
+						ui->lstPaths->addItem(paths[0]);
+					}
+				}
+			});
+	connect(ui->menuAboutAction, &QAction::triggered, this,
+			[this](bool checked)
+			{
+				AboutDialog aboutDialog(this);
+
+				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)
+			{
+				this->progressDialog.cancel();
+
+				QMessageBox::information(
+					this, "Syncing finished",
+					QString("Syncing finished\n\nTotal updated: %1\nTotal deleted: %2\nTotal errors: %3\n")
+						.arg(QString::number(totalUpdated))
+						.arg(QString::number(totalDeleted))
+						.arg(QString::number(totalErrored)));
+			});
+	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()
+{
+	progressDialog.setWindowTitle("Syncing");
+	progressDialog.setLabelText("Syncing - this might take a moment, please wait");
+	progressDialog.setWindowModality(Qt::ApplicationModal);
+	progressDialog.setMinimum(0);
+	progressDialog.setMaximum(0);
+	progressDialog.setValue(0);
+	progressDialog.open();
+
+	indexSyncer->setKeepGoing(true);
+	indexSyncer->setVerbose(false);
+	indexSyncer->setDryRun(false);
+	indexSyncer->setRemoveDeletedFromIndex(true);
+
+	this->syncerThread.start();
+
+	emit beginIndexSync();
 }
 
 void MainWindow::spinPreviewPageValueChanged(int val)
@@ -148,10 +292,12 @@ void MainWindow::startIndexing()
 
 	ui->previewsTab->setEnabled(false);
 	ui->resultsTab->setEnabled(false);
+	ui->settingsTab->setEnabled(false);
 	ui->txtPathScanAdd->setEnabled(false);
 	ui->txtSearch->setEnabled(false);
 	ui->previewProcessBar->setValue(0);
 	ui->previewProcessBar->setVisible(true);
+	ui->btnOpenFailed->setVisible(false);
 
 	QVector<QString> paths;
 	QStringList pathSettingsValue;
@@ -162,9 +308,12 @@ void MainWindow::startIndexing()
 		pathSettingsValue.append(path);
 	}
 	this->indexer->setTargetPaths(paths);
+	QString ignorePatterns = ui->txtIgnorePatterns->text();
+	this->indexer->setIgnorePattern(ignorePatterns.split(";"));
 	this->indexer->beginIndexing();
 	QSettings settings;
 	settings.setValue("indexPaths", pathSettingsValue);
+	settings.setValue("ignorePatterns", ignorePatterns);
 	ui->btnStartIndexing->setText("Stop indexing");
 }
 
@@ -181,8 +330,13 @@ void MainWindow::finishIndexing()
 	ui->btnStartIndexing->setText("Start indexing");
 	ui->previewsTab->setEnabled(true);
 	ui->resultsTab->setEnabled(true);
+	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)
@@ -202,6 +356,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 =
@@ -209,17 +539,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);
 }
 
@@ -243,28 +571,118 @@ void MainWindow::tabChanged()
 			makePreviews(ui->spinPreviewPage->value());
 		}
 	}
+	/* Settings tab active */
+	if(ui->tabWidget->currentIndex() == 3)
+	{
+		initSettingsTabs();
+	}
 }
 
-void MainWindow::previewReceived(QSharedPointer<PreviewResult> preview)
+void MainWindow::initSettingsTabs()
 {
-	if(preview->hasPreview())
+	QSettings settings;
+
+	QString pdfViewerCmd = settings.value(SETTINGS_KEY_PDFVIEWER).toString();
+	QString excludedPaths = Common::excludedPaths().join(';');
+	QString mountPaths = Common::mountPaths().join(';');
+	QString databasePath = Common::databasePath();
+	int numPagesPerPreview = settings.value(SETTINGS_KEY_PREVIEWSPERPAGE, 20).toInt();
+
+	ui->txtSettingPdfPreviewerCmd->setText(pdfViewerCmd);
+	ui->txtSettingIgnoredPaths->setText(excludedPaths);
+	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();
+	QStringList excludedPaths = ui->txtSettingIgnoredPaths->text().split(';');
+	QStringList mountPaths = ui->txtSettingMountPaths->text().split(';');
+	QString databasePath = ui->txtSettingDatabasePath->text();
+
+	settings.setValue(SETTINGS_KEY_PDFVIEWER, pdfViewerCmd);
+	settings.setValue(SETTINGS_KEY_EXCLUDEDPATHS, excludedPaths);
+	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();
+
+	QProcess::startDetached(qApp->arguments()[0], qApp->arguments().mid(1));
+	qApp->quit();
+}
+
+void MainWindow::previewReceived(QSharedPointer<PreviewResult> preview, unsigned int previewGeneration)
+{
+	if(previewGeneration < this->currentPreviewGeneration)
+	{
+		return;
+	}
+	this->ui->previewProcessBar->setValue(this->ui->previewProcessBar->value() + 1);
+	if(!preview.isNull() && preview->hasPreview())
 	{
 		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]() { ipcDocOpen(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());
-				});
+
+		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);
+		QWidget *previewWidget = new QWidget();
+
+		previewWidget->setLayout(previewLayout);
+
+		ui->scrollAreaWidgetContents->layout()->addWidget(previewWidget);
 	}
 }
 
@@ -276,7 +694,19 @@ void MainWindow::lineEditReturnPressed()
 		ui->lblSearchResults->setText("Invalid paranthesis");
 		return;
 	}
+	if(ui->tabWidget->currentIndex() > 1)
+	{
+		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);
@@ -285,21 +715,83 @@ 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);
-				results.append(searcher.search(filesQuery));
+				if(pathsQuery.getLimit() == -1)
+				{
+					pathsQuery.setLimit(1000);
+				}
+				results.append(searcher.search(pathsQuery));
 			}
 			if(addContentSearch)
 			{
+				if(this->contentSearchQuery.getLimit() == -1)
+				{
+					this->contentSearchQuery.setLimit(1000);
+				}
 				results.append(searcher.search(this->contentSearchQuery));
 			}
+			else
+			{
+				this->contentSearchQuery.setTokens({});
+			}
 			return results;
 		});
 	searchWatcher.setFuture(searchFuture);
@@ -308,28 +800,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);
 
 	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))
+		{
+			seenMap[absPath] = true;
+			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(PreviewGenerator::get(pathInfo) != nullptr)
+			if(!result.wasContentSearch)
 			{
-				this->previewableSearchResults.append(result);
+				continue;
+			}
+
+			if(!pathInfo.suffix().contains("htm")) // hack until we can preview them properly...
+			{
+				if(PreviewGenerator::get(pathInfo) != nullptr)
+				{
+					this->previewableSearchResults.append(result);
+					ui->comboPreviewFiles->addItem(result.fileData.absPath);
+				}
 			}
 		}
 		else
@@ -337,14 +849,14 @@ void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 			hasDeleted = true;
 		}
 	}
+
 	ui->treeResultsList->resizeColumnToContents(0);
 	ui->treeResultsList->resizeColumnToContents(1);
+	ui->treeResultsList->resizeColumnToContents(2);
 	previewDirty = !this->previewableSearchResults.empty();
 
-	int numpages = ceil(static_cast<double>(this->previewableSearchResults.size()) / previewsPerPage);
-	ui->spinPreviewPage->setMinimum(1);
-	ui->spinPreviewPage->setMaximum(numpages);
 	ui->spinPreviewPage->setValue(1);
+
 	if(previewTabActive() && previewDirty)
 	{
 		makePreviews(1);
@@ -353,29 +865,42 @@ void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
 	QString statusText = "Results: " + QString::number(results.size()) + " files";
 	if(hasDeleted)
 	{
-		statusText += " WARNING: Some files don't exist anymore. No preview available for those. Index out of sync";
+		statusText += " WARNING: Some files are inaccessible. No preview available for those. Index may be out of sync";
 	}
 	ui->lblSearchResults->setText(statusText);
 }
 
-void MainWindow::makePreviews(int page)
+int MainWindow::currentSelectedScale()
 {
-
-	this->previewWorkerWatcher.cancel();
-	this->previewWorkerWatcher.waitForFinished();
-
-	QCoreApplication::processEvents(); // Maybe not necessary anymore, depends on whether it's possible that a slot is
-									   // still to be fired.
-	qDeleteAll(ui->scrollAreaWidgetContents->children());
-
-	ui->scrollAreaWidgetContents->setLayout(new QHBoxLayout());
-	ui->previewProcessBar->setMaximum(this->previewableSearchResults.size());
-	processedPdfPreviews = 0;
 	QString scaleText = ui->comboScale->currentText();
 	scaleText.chop(1);
+	return scaleText.toInt();
+}
+
+void MainWindow::makePreviews(int page)
+{
+	if(this->previewableSearchResults.empty())
+	{
+		return;
+	}
+	qDeleteAll(ui->scrollAreaWidgetContents->children());
+
+	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;
 
 	QVector<QString> wordsToHighlight;
-	QRegularExpression extractor(R"#("([^"]*)"|(\w+))#");
+	QRegularExpression extractor(R"#("([^"]*)"|([^\s]+))#");
 	for(const Token &token : this->contentSearchQuery.getTokens())
 	{
 		if(token.type == FILTER_CONTENT_CONTAINS)
@@ -393,14 +918,49 @@ void MainWindow::makePreviews(int page)
 			}
 		}
 	}
-	PreviewWorker worker;
 	int end = previewsPerPage;
 	int begin = page * previewsPerPage - previewsPerPage;
-	this->previewWorkerWatcher.setFuture(worker.generatePreviews(this->previewableSearchResults.mid(begin, end),
-																 wordsToHighlight, scaleText.toInt() / 100.));
-	ui->previewProcessBar->setMaximum(this->previewWorkerWatcher.progressMaximum());
-	ui->previewProcessBar->setMinimum(this->previewWorkerWatcher.progressMinimum());
+	if(begin < 0)
+	{
+		// Should not happen actually
+		begin = 0;
+	}
+
+	int currentScale = currentSelectedScale();
+	RenderConfig renderConfig;
+	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;
+		renderTarget.page = (int)sr.page;
+		targets.append(renderTarget);
+	}
+	int numpages = ceil(static_cast<double>(targets.size()) / previewsPerPage);
+	ui->spinPreviewPage->setMaximum(numpages);
+	targets = targets.mid(begin, end);
+
+	ui->lblTotalPreviewPagesCount->setText(QString::number(numpages));
+	ui->previewProcessBar->setMaximum(targets.count());
+	ui->previewProcessBar->setMinimum(0);
+	ui->previewProcessBar->setValue(0);
 	ui->previewProcessBar->setVisible(this->previewableSearchResults.size() > 0);
+	++this->currentPreviewGeneration;
+	this->ui->spinPreviewPage->setEnabled(false);
+	this->ui->comboPreviewFiles->setEnabled(false);
+	this->ui->txtSearch->setEnabled(false);
+	emit startIpcPreviews(renderConfig, targets);
 }
 
 void MainWindow::handleSearchError(QString error)
@@ -414,27 +974,53 @@ void MainWindow::createSearchResutlMenu(QMenu &menu, const QFileInfo &fileInfo)
 				   [&fileInfo] { QGuiApplication::clipboard()->setText(fileInfo.fileName()); });
 	menu.addAction("Copy full path to clipboard",
 				   [&fileInfo] { QGuiApplication::clipboard()->setText(fileInfo.absoluteFilePath()); });
-	menu.addAction("Open containing folder", [this, &fileInfo] { this->ipcFileOpen(fileInfo.absolutePath()); });
+	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::ipcDocOpen(QString path, int num)
+void MainWindow::openDocument(QString path, int num)
 {
-	QStringList args;
-	args << path;
-	args << QString::number(num);
-	this->ipcClient->sendCommand(DocOpen, args);
+	QSettings settings;
+	QString command = settings.value("pdfviewer").toString();
+	if(path.endsWith(".pdf") && command != "" && command.contains("%p") && command.contains("%f"))
+	{
+		QStringList splitted = command.split(" ");
+		if(splitted.size() > 1)
+		{
+			QString cmd = splitted[0];
+			QStringList args = splitted.mid(1);
+			args.replaceInStrings("%f", path);
+			args.replaceInStrings("%p", QString::number(num));
+			QProcess::startDetached(cmd, args);
+		}
+	}
+	else
+	{
+		QDesktopServices::openUrl(QUrl::fromLocalFile(path));
+	}
 }
 
-void MainWindow::ipcFileOpen(QString path)
+void MainWindow::openFile(QString path)
 {
-	QStringList args;
-	args << path;
-	this->ipcClient->sendCommand(FileOpen, args);
+	QDesktopServices::openUrl(QUrl::fromLocalFile(path));
 }
 
 void MainWindow::treeSearchItemActivated(QTreeWidgetItem *item, int i)
 {
-	ipcFileOpen(item->text(1));
+	openFile(item->text(1));
 }
 
 void MainWindow::showSearchResultsContextMenu(const QPoint &point)
@@ -452,5 +1038,19 @@ void MainWindow::showSearchResultsContextMenu(const QPoint &point)
 
 MainWindow::~MainWindow()
 {
+	syncerThread.terminate();
+	ipcClientThread.terminate();
+	delete this->indexSyncer;
+	delete this->dbService;
+	delete this->dbFactory;
+	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();
+}

gui/mainwindow.h

@@ -9,9 +9,10 @@
 #include <QFutureWatcher>
 #include <QSqlDatabase>
 #include <QLocalSocket>
-#include "previewworker.h"
+#include <QProgressDialog>
 #include "../shared/looqsquery.h"
-#include "ipcclient.h"
+#include "../shared/indexsyncer.h"
+#include "ipcpreviewclient.h"
 #include "indexer.h"
 namespace Ui
 {
@@ -23,23 +24,30 @@ class MainWindow : public QMainWindow
 	Q_OBJECT
 
   public:
-	explicit MainWindow(QWidget *parent, IPCClient &client);
+	explicit MainWindow(QWidget *parent, QString socketPath);
 	~MainWindow();
   signals:
 	void beginSearch(const QString &query);
 	void startPdfPreviewGeneration(QVector<SearchResult> paths, double scalefactor);
 
+  protected:
+	void closeEvent(QCloseEvent *event) override;
+
   private:
 	DatabaseFactory *dbFactory;
 	SqliteDbService *dbService;
 	Ui::MainWindow *ui;
-	IPCClient *ipcClient;
+	IPCPreviewClient ipcPreviewClient;
+	QThread ipcClientThread;
+	QThread syncerThread;
+	IndexSyncer *indexSyncer;
+	QProgressDialog progressDialog;
+
 	Indexer *indexer;
 	QFileIconProvider iconProvider;
 	bool previewDirty;
 	QSqlDatabase db;
 	QFutureWatcher<QVector<SearchResult>> searchWatcher;
-	QFutureWatcher<QSharedPointer<PreviewResult>> previewWorkerWatcher;
 	void add(QString path, unsigned int page);
 	QVector<SearchResult> previewableSearchResults;
 	void connectSignals();
@@ -53,20 +61,35 @@ class MainWindow : public QMainWindow
 	LooqsQuery contentSearchQuery;
 	int previewsPerPage;
 	void createSearchResutlMenu(QMenu &menu, const QFileInfo &fileInfo);
-	void ipcDocOpen(QString path, int num);
-	void ipcFileOpen(QString path);
-
+	void openDocument(QString path, int num);
+	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);
 	void showSearchResultsContextMenu(const QPoint &point);
 	void tabChanged();
-	void previewReceived(QSharedPointer<PreviewResult> preview);
+	void previewReceived(QSharedPointer<PreviewResult> preview, unsigned int previewGeneration);
 	void comboScaleChanged(int i);
 	void spinPreviewPageValueChanged(int val);
 	void startIndexing();
 	void finishIndexing();
 	void addPathToIndex();
+	void startIndexSync();
+	void saveSettings();
+	void exportFailedPaths();
+
+  signals:
+	void startIpcPreviews(RenderConfig config, const QVector<RenderTarget> &targets);
+	void stopIpcPreviews();
+	void beginIndexSync();
 };
 
 #endif // MAINWINDOW_H

gui/mainwindow.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>1221</width>
-    <height>674</height>
+    <width>1280</width>
+    <height>888</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -27,7 +27,7 @@
        <enum>QTabWidget::South</enum>
       </property>
       <property name="currentIndex">
-       <number>2</number>
+       <number>3</number>
       </property>
       <widget class="QWidget" name="resultsTab">
        <attribute name="title">
@@ -81,8 +81,8 @@
             <rect>
              <x>0</x>
              <y>0</y>
-             <width>1185</width>
-             <height>419</height>
+             <width>1244</width>
+             <height>598</height>
             </rect>
            </property>
            <layout class="QHBoxLayout" name="horizontalLayout"/>
@@ -155,6 +155,23 @@
             </property>
            </widget>
           </item>
+          <item>
+           <widget class="QLabel" name="lblTotalPreviewPagesCount">
+            <property name="text">
+             <string/>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QComboBox" name="comboPreviewFiles">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+           </widget>
+          </item>
           <item>
            <spacer name="horizontalSpacer">
             <property name="orientation">
@@ -177,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">
@@ -236,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>
@@ -243,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>
@@ -267,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>
@@ -291,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>
@@ -315,23 +423,216 @@
              </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="lineEdit"/>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="settingsTab">
+       <attribute name="title">
+        <string>Settings</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout_6">
+        <item>
+         <widget class="QGroupBox" name="groupPdfSettings">
+          <property name="title">
+           <string>PDF Viewer</string>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout_5">
+           <item>
+            <widget class="QLabel" name="label_2">
+             <property name="text">
+              <string>Command to open PDF pages in (%f = file path; %p = page number)</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLineEdit" name="txtSettingPdfPreviewerCmd"/>
+           </item>
+          </layout>
+         </widget>
         </item>
-        <item row="10" column="0">
-         <widget class="QPushButton" name="btnStartIndexing">
+        <item>
+         <widget class="QGroupBox" name="groupMountPaths">
+          <property name="title">
+           <string>Mount paths</string>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout_7">
+           <item>
+            <widget class="QLabel" name="lblMountPaths">
+             <property name="text">
+              <string>Path prefixes of files that should not be removed during sync, even if they cannot be accessed (e . g. files indexed on external disks) . Separated by ;</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLineEdit" name="txtSettingMountPaths"/>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QGroupBox" name="groupBox">
+          <property name="title">
+           <string>Ignored paths</string>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout_8">
+           <item>
+            <widget class="QLabel" name="label_3">
+             <property name="text">
+              <string>Path prefixes that should always be ignored during indexing (will be applied before the ignore patterns). Separated by ;</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLineEdit" name="txtSettingIgnoredPaths"/>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QGroupBox" name="groupSettingDatabasePath">
+          <property name="title">
+           <string>Database path</string>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout_10">
+           <item>
+            <widget class="QLabel" name="lblSettingDatabasePath">
+             <property name="text">
+              <string>Path of the database. Note: Changing it here will create an empty, new database. The old will not be moved.  </string>
+             </property>
+            </widget>
+           </item>
+           <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">
+           <string>Misc</string>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout_9">
+           <item>
+            <layout class="QHBoxLayout" name="horizontalLayout_9">
+             <item>
+              <widget class="QLabel" name="lblMaxNumbersPreviewPages">
+               <property name="text">
+                <string>Max number of previews per 'page' in 'Previews' tab: </string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QSpinBox" name="spinSettingNumerPerPages"/>
+             </item>
+             <item>
+              <spacer name="horizontalSpacer_2">
+               <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_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>
+         <widget class="QPushButton" name="btnSaveSettings">
           <property name="text">
-           <string>Start indexing</string>
+           <string>Save settings and restart</string>
           </property>
          </widget>
         </item>
@@ -349,13 +650,54 @@
     <item>
      <widget class="QProgressBar" name="previewProcessBar">
       <property name="value">
-       <number>24</number>
+       <number>0</number>
       </property>
      </widget>
     </item>
    </layout>
   </widget>
   <widget class="QStatusBar" name="statusBar"/>
+  <widget class="QMenuBar" name="menuBar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>1280</width>
+     <height>35</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menulooqs">
+    <property name="title">
+     <string>looqs</string>
+    </property>
+    <addaction name="menuSyncIndexAction"/>
+    <addaction name="menuOpenUserManualAction"/>
+    <addaction name="menuAboutAction"/>
+    <addaction name="menuAboutQtAction"/>
+    <addaction name="separator"/>
+   </widget>
+   <addaction name="menulooqs"/>
+  </widget>
+  <action name="menuAboutAction">
+   <property name="text">
+    <string>About</string>
+   </property>
+  </action>
+  <action name="menuAboutQtAction">
+   <property name="text">
+    <string>About Qt</string>
+   </property>
+  </action>
+  <action name="menuSyncIndexAction">
+   <property name="text">
+    <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/>

gui/previewgenerator.cpp

@@ -1,15 +1,26 @@
+#include "../shared/common.h"
 #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)
 {
-	return generators.value(info.suffix(), nullptr);
+	PreviewGenerator *result = generators.value(info.suffix(), nullptr);
+	if(result == nullptr)
+	{
+		if(Common::isTextFile(info))
+		{
+			return plainTextGenerator;
+		}
+	}
+	return result;
 }

gui/previewgenerator.h

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

gui/previewgeneratormapfunctor.cpp

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

gui/previewgeneratormapfunctor.h

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

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);
+}

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

gui/previewgeneratorpdf.cpp

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

gui/previewgeneratorpdf.h

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

gui/previewgeneratorplaintext.cpp

@@ -2,32 +2,26 @@
 
 #include "previewgeneratorplaintext.h"
 #include "previewresultplaintext.h"
+#include "../shared/limitqueue.h"
 
-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 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;
 
+	unsigned int currentSnippets = 0;
 	for(QString &word : config.wordsToHighlight)
 	{
 
 		int lastPos = 0;
 		int index = content.indexOf(word, lastPos, Qt::CaseInsensitive);
-		while(index != -1)
+		while(index != -1 && currentSnippets < MAX_SNIPPETS)
 		{
 			countmap[word] = countmap.value(word, 0) + 1;
 
@@ -51,6 +45,7 @@ PreviewResult *PreviewGeneratorPlainText::generate(RenderConfig config, QString
 			lastPos = index;
 
 			index = content.indexOf(word, lastPos + 1, Qt::CaseInsensitive);
+			++currentSnippets;
 		}
 		lastWordPos = lastPos;
 	}
@@ -62,20 +57,110 @@ PreviewResult *PreviewGeneratorPlainText::generate(RenderConfig config, QString
 		++i;
 	}
 
+	QString header = "<b>" + fileName + "</b> ";
 	for(QString &word : config.wordsToHighlight)
 	{
 		resulText.replace(word, "<span style=\"background-color: yellow;\">" + word + "</span>", Qt::CaseInsensitive);
+		header += word + ": " + QString::number(countmap[word]) + " ";
 	}
 
-	QFileInfo info{documentPath};
+	if(currentSnippets == MAX_SNIPPETS)
+	{
+		header += "(truncated)";
+	}
+
+	header += "<hr>";
+
+	return header + resulText.replace("\n", "<br>").mid(0, 1000);
+}
+
+QString PreviewGeneratorPlainText::generateLineBasedPreviewText(QTextStream &in, RenderConfig config, QString fileName)
+{
+	QString resultText;
+	const unsigned 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;
+
+	auto appendLine = [&resultText](int lineNumber, QString &line)
+	{ resultText.append(QString("<b>%1</b>%2<br>").arg(lineNumber).arg(line)); };
+
+	QHash<QString, int> countmap;
+	QString header = "<b>" + fileName + "</b> ";
+
+	unsigned int snippetsCount = 0;
+	unsigned int lineCount = 0;
+	while(in.readLineInto(&currentLine) && snippetsCount < MAX_SNIPPETS)
+	{
+		++lineCount;
+		bool matched = false;
+		if(justReadLinesCount > 0)
+		{
+			appendLine(lineCount, currentLine);
+			--justReadLinesCount;
+			continue;
+		}
+		if(justReadLinesCount == 0)
+		{
+			resultText += "---<br>";
+			justReadLinesCount = -1;
+			++snippetsCount;
+		}
+		for(QString &word : config.wordsToHighlight)
+		{
+			if(currentLine.contains(word, Qt::CaseInsensitive))
+			{
+				countmap[word] = countmap.value(word, 0) + 1;
+				matched = true;
+				currentLine.replace(word, "<span style=\"background-color: yellow;\">" + word + "</span>",
+									Qt::CaseInsensitive);
+			}
+		}
+		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);
+		}
+	}
 
-	QString header = "<b>" + info.fileName() + "</b> ";
 	for(QString &word : config.wordsToHighlight)
 	{
 		header += word + ": " + QString::number(countmap[word]) + " ";
 	}
+	if(snippetsCount == MAX_SNIPPETS)
+	{
+		header += "(truncated)";
+	}
 	header += "<hr>";
 
-	result->setText(header + resulText.replace("\n", "<br>"));
-	return result;
+	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);
 }

gui/previewgeneratorplaintext.h

@@ -1,12 +1,18 @@
 #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;
-	PreviewResult *generate(RenderConfig config, QString documentPath, unsigned int page);
+	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);
 };
 
 #endif // PREVIEWGENERATORPLAINTEXT_H

gui/previewresult.cpp

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

gui/previewresult.h

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

gui/previewresultodt.cpp

@@ -0,0 +1 @@
+#include "previewresultodt.h"

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

gui/previewresultpdf.cpp

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

gui/previewresultpdf.h

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

gui/previewresultplaintext.cpp

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

gui/previewresultplaintext.h

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

gui/previewworker.cpp

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

gui/previewworker.h

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

gui/renderconfig.cpp

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

gui/renderconfig.h

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

gui/rendertarget.cpp

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

gui/rendertarget.h

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

looqs.desktop

@@ -1,6 +1,6 @@
 [Desktop Entry]
 Name=looqs
-Exec=/usr/bin/looqs-gui
+Exec=looqs-gui
 Terminal=false
 Type=Application
 Icon=looqs

shared/common.cpp

@@ -7,44 +7,71 @@
 #include <QSqlError>
 #include <QTextStream>
 #include <QDebug>
+#include <QMimeDatabase>
 #include "looqsgeneralexception.h"
 #include "common.h"
 #include "dbmigrator.h"
 #include "databasefactory.h"
 #include "logger.h"
 
-#define SETTINGS_KEY_DBPATH "dbpath"
-#define SETTINGS_KEY_FIRSTRUN "firstrun"
-#define SETTINGS_KEY_IPCSOCKETPATH "ipcsocketpath"
-
 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;
 }
 
+void Common::setPdfViewer()
+{
+	QString value;
+
+	/* TODO: well, we should query this probably from xdg*/
+	QString okularPath = QStandardPaths::findExecutable("okular");
+	QString evincePath = QStandardPaths::findExecutable("evince");
+	QString qpdfviewPath = QStandardPaths::findExecutable("qpdfview");
+
+	if(okularPath != "")
+	{
+		value = okularPath + " %f -p %p";
+	}
+	else if(evincePath != "")
+	{
+		value = evincePath + " -i %p %f";
+	}
+	else if(qpdfviewPath != "")
+	{
+		value = qpdfviewPath + " %f#%p";
+	}
+
+	if(value != "")
+	{
+		QSettings settings;
+		settings.setValue(SETTINGS_KEY_PDFVIEWER, value);
+	}
+}
 void Common::ensureConfigured()
 {
 	QSettings settings;
-	QVariant firstRun = settings.value(SETTINGS_KEY_FIRSTRUN);
-	if(!firstRun.isValid())
+	QString dbpath = databasePath();
+	if(dbpath == "")
 	{
-		QString dbpath = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
+		dbpath = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
 		QDir dir;
 		if(!dir.exists(dbpath))
 		{
@@ -54,36 +81,19 @@ void Common::ensureConfigured()
 			}
 		}
 		dbpath += "/looqs.sqlite";
+	}
+	if(!QFile::exists(dbpath))
+	{
 		if(!initSqliteDatabase(dbpath))
 		{
 			throw LooqsGeneralException("Failed to initialize sqlite database");
 		}
-		settings.setValue(SETTINGS_KEY_FIRSTRUN, false);
 		settings.setValue(SETTINGS_KEY_DBPATH, dbpath);
 	}
-	else
+	QVariant pdfViewer = settings.value(SETTINGS_KEY_PDFVIEWER);
+	if(!pdfViewer.isValid())
 	{
-
-		QString dbpath = databasePath();
-		if(!QFile::exists(dbpath))
-		{
-			throw LooqsGeneralException("Database " + dbpath + " was not found");
-		}
-		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;
-		}
+		setPdfViewer();
 	}
 }
 
@@ -105,8 +115,95 @@ QString Common::databasePath()
 	return env;
 }
 
+bool Common::noSandboxModeRequested()
+{
+	QString env = getenv("LOOQS_DISABLE_SANDBOX");
+	if(env == "1")
+	{
+		return true;
+	}
+	return false;
+}
+
 QString Common::ipcSocketPath()
 {
-	QSettings settings;
-	return settings.value(SETTINGS_KEY_IPCSOCKETPATH, "/tmp/looqs-spawner").toString();
+	return "/tmp/.looqs/looqs-ipc-socket";
+
+	/* May not a good idea to set it in the settings and probably nobody would ever bother to change it anyway */
+	// QSettings settings;
+	// return settings.value(SETTINGS_KEY_IPCSOCKETPATH, "/tmp/.looqs/looqs-ipc-socket").toString();
+}
+
+QStringList Common::excludedPaths()
+{
+	static int ran = false;
+	static QStringList excludedPaths;
+	if(!ran)
+	{
+		QSettings settings;
+		QStringList defaults{"/proc", "/sys", "/dev", "/tmp", "/var/run", "/run"};
+		excludedPaths = settings.value(SETTINGS_KEY_EXCLUDEDPATHS, defaults).toStringList();
+		ran = true;
+	}
+	return excludedPaths;
+}
+
+QStringList Common::mountPaths()
+{
+	static int ran = false;
+	static QStringList mountPaths;
+	if(!ran)
+	{
+		QSettings settings;
+		mountPaths = settings.value(SETTINGS_KEY_MOUNTPATHS, QStringList{"/media", "/mnt"}).toStringList();
+		ran = true;
+	}
+	return mountPaths;
+}
+
+bool Common::isMountPath(QString path)
+{
+	QStringList mountPaths = Common::mountPaths();
+	for(QString &mountPath : mountPaths)
+	{
+		if(path.startsWith(mountPath))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+bool Common::isTextFile(QFileInfo fileInfo)
+{
+	/* TODO: This is not sandboxed yet ... */
+	QMimeDatabase mimeDatabase;
+	QMimeType mimeType = mimeDatabase.mimeTypeForFile(fileInfo);
+	if(mimeType.name().startsWith("text/"))
+	{
+		return true;
+	}
+	else
+	{
+		for(QString &str : mimeType.allAncestors())
+		{
+			if(str.startsWith("text/"))
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+QString Common::versionText()
+{
+	QString commitid = GIT_COMMIT_ID;
+	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));
 }

shared/common.h

@@ -1,13 +1,31 @@
 #ifndef COMMON_H
 #define COMMON_H
 #include <QCoreApplication>
+#include <QFileInfo>
+
+#define SETTINGS_KEY_DBPATH "dbpath"
+#define SETTINGS_KEY_IPCSOCKETPATH "ipcsocketpath"
+#define SETTINGS_KEY_PDFVIEWER "pdfviewer"
+#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
 {
 void setupAppInfo();
 QString databasePath();
 QString ipcSocketPath();
+void setPdfViewer();
 bool initSqliteDatabase(QString path);
 void ensureConfigured();
+QStringList excludedPaths();
+QStringList mountPaths();
+bool isTextFile(QFileInfo fileInfo);
+bool isMountPath(QString path);
+bool noSandboxModeRequested();
+QString versionText();
+QString userManualUrl();
 } // namespace Common
 #endif

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();
 }

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

shared/dirscanworker.cpp

@@ -7,7 +7,7 @@ DirScanWorker::DirScanWorker(ConcurrentQueue<QString> &queue, ConcurrentQueue<QS
 {
 	this->queue = &queue;
 	this->resultQueue = &resultQueue;
-	this->ignorePattern = ignorePattern;
+	this->wildcardMatcher.setPatterns(ignorePattern);
 	this->progressReportThreshold = progressReportThreshold;
 	this->stopToken = &stopToken;
 	setAutoDelete(false);
@@ -19,15 +19,27 @@ 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))
 	{
-		QDirIterator iterator(path, ignorePattern, QDir::Files, QDirIterator::Subdirectories);
+		if(wildcardMatcher.match(path))
+		{
+			continue;
+		}
+		QDirIterator iterator(path, QStringList{}, QDir::Files, QDirIterator::Subdirectories);
 		while(iterator.hasNext())
 		{
-			this->results.append(iterator.next());
+			QString entry = iterator.next();
+			if(wildcardMatcher.match(entry))
+			{
+				continue;
+			}
+			this->results.append(entry);
 			++currentProgress;
 			if(currentProgress == progressReportThreshold)
 			{

shared/dirscanworker.h

@@ -4,6 +4,7 @@
 #include <QRunnable>
 #include <QDirIterator>
 #include "concurrentqueue.h"
+#include "wildcardmatcher.h"
 class DirScanWorker : public QObject, public QRunnable
 {
 	Q_OBJECT
@@ -12,7 +13,7 @@ class DirScanWorker : public QObject, public QRunnable
 	ConcurrentQueue<QString> *queue = nullptr;
 	ConcurrentQueue<QString> *resultQueue = nullptr;
 
-	QStringList ignorePattern;
+	WildcardMatcher wildcardMatcher;
 	QVector<QString> results;
 
 	std::atomic<bool> *stopToken;

shared/filesaver.cpp

@@ -23,6 +23,7 @@ SaveFileResult FileSaver::addFile(QString path)
 {
 	QFileInfo info(path);
 	QString absPath = info.absoluteFilePath();
+
 	auto mtime = info.lastModified().toSecsSinceEpoch();
 	if(this->dbService->fileExistsInDatabase(absPath, mtime))
 	{
@@ -84,7 +85,11 @@ int FileSaver::processFiles(const QVector<QString> paths, std::function<SaveFile
 										  }
 										  else if(result == OK)
 										  {
-											  Logger::info() << "Added" << path << Qt::endl;
+											  Logger::info() << "Saved" << path << Qt::endl;
+										  }
+										  else if(result == OK_WASEMPTY)
+										  {
+											  Logger::info() << "Saved (but content was empty)" << path << Qt::endl;
 										  }
 									  }
 								  }
@@ -95,9 +100,14 @@ int FileSaver::processFiles(const QVector<QString> paths, std::function<SaveFile
 SaveFileResult FileSaver::saveFile(const QFileInfo &fileInfo)
 {
 	QVector<PageData> pageData;
-	QString absPath = fileInfo.absoluteFilePath();
+	QString canonicalPath = fileInfo.canonicalFilePath();
 
-	int status = -1;
+	int processorReturnCode = -1;
+
+	if(!fileInfo.isReadable())
+	{
+		return NOACCESS;
+	}
 
 	if(!fileInfo.exists())
 	{
@@ -106,44 +116,53 @@ SaveFileResult FileSaver::saveFile(const QFileInfo &fileInfo)
 
 	if(fileInfo.isFile())
 	{
-		QProcess process;
-		QStringList args;
-		args << "process" << absPath;
-		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())
+		for(QString &excludedPath : this->excludedPaths)
 		{
-			PageData pd;
-			in >> pd;
-			pageData.append(pd);
+			if(canonicalPath.startsWith(excludedPath))
+			{
+				return SKIPPED;
+			}
 		}
-		status = process.exitCode();
-		if(status != 0 && status != NOTHING_PROCESSED)
-		{
-			Logger::error() << "FileSaver::saveFile(): Error while processing" << absPath << ":"
-							<< "Exit code " << status << Qt::endl;
 
-			return PROCESSFAIL;
+		if(fileInfo.size() > 0)
+		{
+			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())
+			{
+				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 " << absPath << Qt::endl;
+		return OK_WASEMPTY;
 	}
-
-	return this->dbService->saveFile(fileInfo, pageData);
+	return result;
 }

shared/filesaver.h

@@ -5,11 +5,12 @@
 #include "pagedata.h"
 #include "filedata.h"
 #include "sqlitedbservice.h"
-
+#include "common.h"
 class FileSaver
 {
   private:
 	SqliteDbService *dbService;
+	QStringList excludedPaths = Common::excludedPaths();
 
   public:
 	FileSaver(SqliteDbService &dbService);
@@ -20,8 +21,6 @@ class FileSaver
 					 bool keepGoing, bool verbose);
 	int addFiles(const QVector<QString> paths, bool keepGoing, bool verbose);
 	int updateFiles(const QVector<QString> paths, bool keepGoing, bool verbose);
-
-	;
 };
 
 #endif // FILESAVER_H

shared/indexer.cpp

@@ -1,5 +1,6 @@
 #include "indexer.h"
 #include "logger.h"
+#include "wildcardmatcher.h"
 
 Indexer::Indexer(SqliteDbService &db)
 {
@@ -17,8 +18,28 @@ void Indexer::beginIndexing()
 	this->currentIndexResult.begin = QDateTime::currentDateTime();
 	QVector<QString> dirs;
 
+	WildcardMatcher wildcardMatcher;
+
+	QStringList ignoreList = this->ignorePattern;
+
+	for(QString &excludedPath : Common::excludedPaths())
+	{
+		QString pattern = excludedPath;
+		if(!pattern.endsWith("/"))
+		{
+			pattern += "/";
+		}
+		pattern += "*";
+		ignoreList.append(excludedPath);
+	}
+	ignoreList.append(this->ignorePattern);
+	wildcardMatcher.setPatterns(ignoreList);
 	for(QString &path : this->pathsToScan)
 	{
+		if(wildcardMatcher.match(path))
+		{
+			continue;
+		}
 		QFileInfo info{path};
 		if(info.isDir())
 		{
@@ -29,10 +50,14 @@ void Indexer::beginIndexing()
 			this->filePathTargetsQueue.enqueue(path);
 		}
 	}
-	this->dirScanner->setPaths(dirs);
-	this->dirScanner->setIgnorePatterns(this->ignorePattern);
 
-	this->dirScanner->scan();
+	if(!dirs.empty())
+	{
+		this->dirScanner->setPaths(dirs);
+		this->dirScanner->setIgnorePatterns(ignoreList);
+
+		this->dirScanner->scan();
+	}
 
 	this->workerCancellationToken.store(false, std::memory_order_seq_cst);
 	launchWorker(this->filePathTargetsQueue, this->filePathTargetsQueue.remaining());
@@ -48,6 +73,16 @@ void Indexer::setTargetPaths(QVector<QString> pathsToScan)
 	this->pathsToScan = pathsToScan;
 }
 
+void Indexer::setVerbose(bool verbose)
+{
+	this->verbose = verbose;
+}
+
+void Indexer::setKeepGoing(bool keepGoing)
+{
+	this->keepGoing = keepGoing;
+}
+
 void Indexer::requestCancellation()
 {
 	this->dirScanner->cancel();
@@ -61,7 +96,7 @@ IndexResult Indexer::getResult()
 
 void Indexer::dirScanFinished()
 {
-	Logger::info() << "Dir scan finished";
+	Logger::info() << "Dir scan finished" << Qt::endl;
 	if(!isRunning())
 	{
 		emit finished();
@@ -85,18 +120,26 @@ void Indexer::dirScanProgress(int current, int total)
 
 void Indexer::processFileScanResult(FileScanResult result)
 {
-	if(verbose)
+	if(isErrorSaveFileResult(result.second))
 	{
 		this->currentIndexResult.results.append(result);
+		if(!keepGoing)
+		{
+			this->requestCancellation();
+			emit finished();
+			return;
+		}
 	}
 	else
 	{
-		if(result.second == DBFAIL || result.second == PROCESSFAIL || result.second == NOTFOUND)
+		if(verbose)
 		{
 			this->currentIndexResult.results.append(result);
 		}
 	}
-	if(result.second == OK)
+
+	/* TODO: OK_WASEMPTY might need a special list */
+	if(result.second == OK || result.second == OK_WASEMPTY)
 	{
 		++this->currentIndexResult.addedPaths;
 	}

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
@@ -67,6 +78,8 @@ class Indexer : public QObject
 	void beginIndexing();
 	void setIgnorePattern(QStringList ignorePattern);
 	void setTargetPaths(QVector<QString> pathsToScan);
+	void setVerbose(bool verbose);
+	void setKeepGoing(bool keepGoing);
 
 	void requestCancellation();
 

shared/indexsyncer.cpp

@@ -0,0 +1,134 @@
+#include <QDateTime>
+#include "filesaver.h"
+#include "indexsyncer.h"
+
+IndexSyncer::IndexSyncer(SqliteDbService &dbService)
+{
+	this->dbService = &dbService;
+}
+
+void IndexSyncer::setDryRun(bool dryRun)
+{
+	this->dryRun = dryRun;
+}
+
+void IndexSyncer::setVerbose(bool verbose)
+{
+	this->verbose = verbose;
+}
+
+void IndexSyncer::setKeepGoing(bool keepGoing)
+{
+	this->keepGoing = keepGoing;
+}
+
+void IndexSyncer::setRemoveDeletedFromIndex(bool removeDeletedFromIndex)
+{
+	this->removeDeletedFromIndex = removeDeletedFromIndex;
+}
+
+void IndexSyncer::setPattern(QString pattern)
+{
+	this->pattern = pattern;
+}
+
+void IndexSyncer::sync()
+{
+	this->stopToken.store(false, std::memory_order_relaxed);
+	FileSaver saver(*this->dbService);
+	QVector<FileData> files;
+	int offset = 0;
+	int limit = 10000;
+	unsigned int processedRows = dbService->getFiles(files, pattern, offset, limit);
+
+	unsigned int totalUpdatesFilesCount = 0;
+	unsigned int totalDeletedFilesCount = 0;
+	unsigned int totalErroredFilesCount = 0;
+
+	while(processedRows > 0)
+	{
+		QVector<QString> filePathsToUpdate;
+		for(FileData &fileData : files)
+		{
+			if(processedRows % 100 == 0 && this->stopToken.load(std::memory_order_relaxed))
+			{
+				emit finished(totalUpdatesFilesCount, totalDeletedFilesCount, totalErroredFilesCount);
+				return;
+			}
+			if(Common::isMountPath(fileData.absPath))
+			{
+				continue;
+			}
+
+			QFileInfo fileInfo(fileData.absPath);
+			if(fileInfo.exists())
+			{
+				if(fileInfo.isFile())
+				{
+					if(fileInfo.lastModified().toSecsSinceEpoch() != fileData.mtime)
+					{
+						if(!dryRun)
+						{
+							filePathsToUpdate.append(fileData.absPath);
+						}
+						else
+						{
+							emit updatedDryRun(fileData.absPath);
+						}
+					}
+				}
+			}
+			else
+			{
+				if(this->removeDeletedFromIndex)
+				{
+					if(!dryRun)
+					{
+						if(!this->dbService->deleteFile(fileData.absPath))
+						{
+							emit error("Error: Failed to delete " + fileData.absPath + " from the index");
+							if(!this->keepGoing)
+							{
+								emit finished(totalUpdatesFilesCount, totalDeletedFilesCount, totalErroredFilesCount);
+								return;
+							}
+						}
+						emit removed(fileData.absPath);
+						++totalDeletedFilesCount;
+					}
+					else
+					{
+						emit removedDryRun(fileData.absPath);
+					}
+				}
+			}
+		}
+
+		unsigned int updatedFilesCount = saver.updateFiles(filePathsToUpdate, keepGoing, verbose);
+		unsigned int shouldHaveUpdatedCount = static_cast<unsigned int>(filePathsToUpdate.size());
+		if(updatedFilesCount != shouldHaveUpdatedCount)
+		{
+
+			totalErroredFilesCount += (shouldHaveUpdatedCount - updatedFilesCount);
+			if(!keepGoing)
+			{
+				QString errorMsg = QString("Failed to update all files selected for updating in this batch. Updated") +
+								   updatedFilesCount + "out of" + shouldHaveUpdatedCount + "selected for updating";
+				emit error(errorMsg);
+				emit finished(totalUpdatesFilesCount, totalDeletedFilesCount, totalErroredFilesCount);
+			}
+		}
+		offset += limit;
+		files.clear();
+		totalUpdatesFilesCount += updatedFilesCount;
+
+		processedRows = this->dbService->getFiles(files, pattern, offset, limit);
+	}
+
+	emit finished(totalUpdatesFilesCount, totalDeletedFilesCount, totalErroredFilesCount);
+}
+
+void IndexSyncer::cancel()
+{
+	this->stopToken.store(true, std::memory_order_seq_cst);
+}

shared/indexsyncer.h

@@ -0,0 +1,39 @@
+#ifndef INDEXSYNCER_H
+#define INDEXSYNCER_H
+#include "sqlitedbservice.h"
+
+class IndexSyncer : public QObject
+{
+	Q_OBJECT
+  private:
+	SqliteDbService *dbService = nullptr;
+	bool keepGoing = true;
+	bool removeDeletedFromIndex = true;
+	bool dryRun = false;
+	bool verbose = false;
+	QString pattern;
+
+	std::atomic<bool> stopToken{false};
+
+  public:
+	IndexSyncer(SqliteDbService &dbService);
+
+  public slots:
+	void sync();
+	void cancel();
+	void setDryRun(bool dryRun);
+	void setVerbose(bool verbose);
+	void setKeepGoing(bool keepGoing);
+	void setRemoveDeletedFromIndex(bool removeDeletedFromIndex);
+	void setPattern(QString pattern);
+
+  signals:
+	void error(QString error);
+	void removed(QString path);
+	void removedDryRun(QString path);
+	void updatedDryRun(QString path);
+	void updated(QString path);
+	void finished(unsigned int totalUpdated, unsigned int totalDeleted, unsigned int totalErrored);
+};
+
+#endif // INDEXSYNCER_H

shared/limitqueue.h

@@ -0,0 +1,48 @@
+#ifndef LIMITQUEUE_H
+#define LIMITQUEUE_H
+#include <QQueue>
+
+template <class T> class LimitQueue
+{
+  protected:
+	QQueue<T> queue;
+	unsigned int limit = 0;
+
+  public:
+	LimitQueue();
+	LimitQueue(unsigned 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(unsigned int limit)
+	{
+		this->limit = limit;
+	}
+
+	void clear()
+	{
+		queue.clear();
+	}
+};
+
+#endif // LIMITQUEUE_H

shared/looqsquery.cpp

@@ -23,12 +23,12 @@ QueryType LooqsQuery::getQueryType()
 	return static_cast<QueryType>(tokensMask & COMBINED);
 }
 
-bool LooqsQuery::hasContentSearch()
+bool LooqsQuery::hasContentSearch() const
 {
 	return (this->getTokensMask() & FILTER_CONTENT) == FILTER_CONTENT;
 }
 
-bool LooqsQuery::hasPathSearch()
+bool LooqsQuery::hasPathSearch() const
 {
 	return (this->getTokensMask() & FILTER_PATH) == FILTER_PATH;
 }
@@ -169,6 +169,10 @@ void LooqsQuery::addToken(Token t)
  * TODO: It's a bit ugly still*/
 LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, bool mergeLoneWords)
 {
+	if(expression.isEmpty())
+	{
+		return LooqsQuery{};
+	}
 	if(!checkParanthesis(expression))
 	{
 		throw LooqsGeneralException("Invalid paranthesis");
@@ -176,8 +180,8 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 
 	QStringList loneWords;
 	LooqsQuery result;
-	QRegularExpression rx("((?<filtername>(\\.|\\w)+):(?<args>\\((?<innerargs>[^\\)]+)\\)|([\\w,])+)|(?<boolean>AND|OR)"
-						  "|(?<negation>!)|(?<bracket>\\(|\\))|(?<loneword>[\"\\w]+))");
+	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); };
@@ -216,19 +220,8 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 			{
 				throw LooqsGeneralException("Can't have two negations following each other");
 			}
-			if(!previousWasBool())
-			{
-				result.addToken(Token(BOOL_AND)); // Implicit and, our default operation
-			}
 			result.addToken(Token(NEGATION));
 		}
-		if(!result.tokens.isEmpty() && !previousWasBool() && !previousWas(NEGATION) && !previousWas(BRACKET_OPEN) &&
-		   bracket != ")")
-		{
-			// the current token isn't a negation, isn't a boolean. Thus, implicit AND is required
-			result.addToken(Token(BOOL_AND));
-		}
-
 		if(bracket != "")
 		{
 			if(bracket == "(")
@@ -255,7 +248,7 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 
 		if(filtername != "")
 		{
-			TokenType tokenType;
+			TokenType tokenType = WORD;
 			QString value = m.captured("innerargs");
 			if(value == "")
 			{
@@ -266,15 +259,15 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 				throw LooqsGeneralException("value cannot be empty for filters");
 			}
 
-			if(filtername == "path.contains")
+			if(filtername == "p" || filtername == "path.contains")
 			{
 				tokenType = FILTER_PATH_CONTAINS;
 			}
-			else if(filtername == "path.starts")
+			else if(filtername == "pb" || filtername == "path.starts")
 			{
 				tokenType = FILTER_PATH_STARTS;
 			}
-			else if(filtername == "path.ends")
+			else if(filtername == "pe" || filtername == "path.ends")
 			{
 				tokenType = FILTER_PATH_ENDS;
 			}
@@ -290,21 +283,21 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 			{
 				tokenType = FILTER_CONTENT_PAGE;
 			}
-			else if(filtername ==
-					"sort") // TODO: given this is not really a "filter", this feels slightly misplaced here
+			// TODO: given this is not really a "filter", this feels slightly misplaced here
+			else if(filtername == "sort")
 			{
 				if(!result.sortConditions.empty())
 				{
 					throw LooqsGeneralException("Two sort statements are illegal");
 				}
-				// TODO: hack, since we are not a "filter", we must remove a preceeding (implicit) boolean
-				if((result.tokens.last().type & BOOL) == BOOL)
-				{
-					result.tokens.pop_back();
-				}
 				result.sortConditions = createSortConditions(value);
 				continue;
 			}
+			else if(filtername == "limit")
+			{
+				result.limit = value.toInt();
+				continue;
+			}
 			else
 			{
 				throw LooqsGeneralException("Unknown filter provided!");
@@ -322,6 +315,26 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 		}
 	}
 
+	/* Add our default implicit AND boolean condition where appropriate */
+	QVector<Token> newTokens;
+
+	TokenType prevType = BOOL_AND;
+	int needsBoolean = FILTER_CONTENT | FILTER_PATH | NEGATION | WORD;
+	for(Token &t : result.tokens)
+	{
+		if(t.type == BRACKET_OPEN || t.type & needsBoolean)
+		{
+			if(!((prevType & BOOL) == BOOL) && !((prevType & NEGATION) == NEGATION) &&
+			   !((prevType & BRACKET_OPEN) == BRACKET_OPEN))
+			{
+				newTokens.append(Token(BOOL_AND));
+			}
+		}
+		prevType = t.type;
+		newTokens.append(t);
+	}
+	result.tokens = newTokens;
+
 	bool contentsearch = result.hasContentSearch();
 	bool sortsForContent = std::any_of(result.sortConditions.begin(), result.sortConditions.end(),
 									   [](SortCondition c) { return c.field == CONTENT_TEXT; });

shared/looqsquery.h

@@ -40,9 +40,17 @@ class LooqsQuery
 	/* Helper field to determine quertype as well as to quickly check what kind of filters etc.
 	 * are being used in this query*/
 	int tokensMask = 0;
+	int limit = -1;
 	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;
@@ -52,12 +60,46 @@ class LooqsQuery
 	{
 		return tokensMask;
 	}
-	bool hasContentSearch();
-	bool hasPathSearch();
+	int getLimit() const
+	{
+		return limit;
+	}
+	void setLimit(int limit)
+	{
+		this->limit = limit;
+	}
+	bool hasContentSearch() const;
+	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

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;

shared/migrations/3.sql

@@ -0,0 +1 @@
+DROP trigger content_ad;

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>

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"
 

shared/paralleldirscanner.cpp

@@ -43,7 +43,6 @@ void ParallelDirScanner::handleWorkersProgress(unsigned int progress)
 
 void ParallelDirScanner::handleWorkersFinish()
 {
-	Logger::info() << "Worker finished";
 	// no mutexes required due to queued connection
 	++finishedWorkers;
 	if(this->stopToken.load(std::memory_order_seq_cst) || finishedWorkers == getThreadsNum())
@@ -51,6 +50,7 @@ void ParallelDirScanner::handleWorkersFinish()
 		running = false;
 		emit scanComplete();
 	}
+	delete QObject::sender();
 }
 
 unsigned int ParallelDirScanner::getThreadsNum() const
@@ -65,14 +65,41 @@ unsigned int ParallelDirScanner::getThreadsNum() const
 
 void ParallelDirScanner::scan()
 {
-	Logger::info() << "I am scanning";
 	this->stopToken.store(false, std::memory_order_relaxed);
 	this->finishedWorkers = 0;
 	this->processedPaths = 0;
 	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)
 	{

shared/paralleldirscanner.h

@@ -41,6 +41,7 @@ class ParallelDirScanner : public QObject
 	void progress(int, int);
   public slots:
 	void cancel();
+  private slots:
 	void handleWorkersProgress(unsigned int progress);
 	void handleWorkersFinish();
 };

shared/plaintexts.qrc

@@ -0,0 +1,6 @@
+<RCC>
+    <qresource>
+		<file>../LICENSE</file>
+        <file>../LICENSE-3RD-PARTY</file>
+    </qresource>
+</RCC>

shared/processor.h

@@ -10,8 +10,6 @@ enum DataSource
 	ARRAY
 };
 
-#define NOTHING_PROCESSED 4
-
 class Processor
 {
   public:

shared/sandboxedprocessor.cpp

@@ -9,6 +9,7 @@
 #include "odtprocessor.h"
 #include "odsprocessor.h"
 #include "../submodules/exile.h/exile.h"
+#include "common.h"
 #include "logger.h"
 
 static DefaultTextProcessor *defaultTextProcessor = new DefaultTextProcessor();
@@ -22,21 +23,29 @@ static QMap<QString, Processor *> processors{
 	{"py", defaultTextProcessor},	{"xml", nothingProcessor},	   {"html", tagStripperProcessor},
 	{"java", defaultTextProcessor}, {"js", defaultTextProcessor},  {"cpp", defaultTextProcessor},
 	{"c", defaultTextProcessor},	{"sql", defaultTextProcessor}, {"odt", odtProcessor},
-	{"ods", odsProcessor}};
+	{"ods", odsProcessor},			{"svg", nothingProcessor}};
 
 void SandboxedProcessor::enableSandbox(QString readablePath)
 {
+	if(Common::noSandboxModeRequested())
+	{
+		qInfo() << "Sandbox is disabled!" << Qt::endl;
+		return;
+	}
 	struct exile_policy *policy = exile_init_policy();
 	if(policy == NULL)
 	{
-		qCritical() << "Could not init exile";
+		qCritical() << "Could not init exile" << Qt::endl;
 		exit(EXIT_FAILURE);
 	}
 	policy->namespace_options = EXILE_UNSHARE_NETWORK | EXILE_UNSHARE_USER;
 
+	std::string readablePathLocation;
 	if(!readablePath.isEmpty())
 	{
-		std::string readablePathLocation = readablePath.toStdString();
+		policy->namespace_options |= EXILE_UNSHARE_MOUNT;
+		policy->mount_path_policies_to_chroot = 1;
+		readablePathLocation = readablePath.toStdString();
 		if(exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ, readablePathLocation.c_str()) != 0)
 		{
 			qCritical() << "Failed to add path policies";
@@ -50,7 +59,7 @@ void SandboxedProcessor::enableSandbox(QString readablePath)
 	int ret = exile_enable_policy(policy);
 	if(ret != 0)
 	{
-		qDebug() << "Failed to establish sandbox: " << ret;
+		qCritical() << "Failed to establish sandbox: " << ret;
 		exit(EXIT_FAILURE);
 	}
 	exile_free_policy(policy);
@@ -71,15 +80,26 @@ 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(), nothingProcessor);
-
-	if(processor == nothingProcessor)
+	Processor *processor = processors.value(fileInfo.suffix(), nullptr);
+	if(processor == nullptr)
+	{
+		/* TODO: Not sandboxed */
+		if(Common::isTextFile(fileInfo))
+		{
+			processor = defaultTextProcessor;
+		}
+	}
+	if(!fileInfo.isReadable())
+	{
+		return NOACCESS;
+	}
+	if(processor == nullptr || processor == nothingProcessor)
 	{
 		/* Nothing to do */
-		return NOTHING_PROCESSED;
+		return OK;
 	}
 
 	QVector<PageData> pageData;
@@ -103,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;
 }

shared/sandboxedprocessor.h

@@ -1,12 +1,15 @@
 #ifndef SANDBOXEDPROCESSOR_H
 #define SANDBOXEDPROCESSOR_H
 #include <QString>
+#include <QMimeDatabase>
 #include "pagedata.h"
+#include "savefileresult.h"
 
 class SandboxedProcessor
 {
   private:
 	QString filePath;
+	QMimeDatabase mimeDatabase;
 
 	void enableSandbox(QString readablePath = "");
 	void printResults(const QVector<PageData> &pageData);
@@ -17,7 +20,7 @@ class SandboxedProcessor
 		this->filePath = filepath;
 	}
 
-	int process();
+	SaveFileResult process();
 };
 
 #endif // SANDBOXEDPROCESSOR_H

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

shared/searchresult.h

@@ -6,7 +6,8 @@ class SearchResult
 {
   public:
 	FileData fileData;
-	QVector<unsigned int> pages;
+	unsigned int page;
+	bool wasContentSearch = false;
 };
 
 #endif // SEARCHRESULT_H

shared/shared.pro

@@ -16,12 +16,21 @@ 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
 # depend on your compiler). Please consult the documentation of the
 # deprecated API in order to know how to port your code away from it.
 DEFINES += QT_DEPRECATED_WARNINGS
 
+DEFINES += GIT_COMMIT_ID="\\\"$(shell git rev-parse --short HEAD)\\\""
+DEFINES += GIT_TAG="\\\"$(shell git describe --tags HEAD)\\\""
+
 # You can also make your code fail to compile if you use deprecated APIs.
 # In order to do so, uncomment the following line.
 # You can also select to disable deprecated APIs only up to a certain version of Qt.
@@ -37,6 +46,7 @@ SOURCES += sqlitesearch.cpp \
     filesaver.cpp \
     filescanworker.cpp \
     indexer.cpp \
+    indexsyncer.cpp \
     logger.cpp \
     looqsgeneralexception.cpp \
     common.cpp \
@@ -52,7 +62,8 @@ SOURCES += sqlitesearch.cpp \
     sqlitedbservice.cpp \
     tagstripperprocessor.cpp \
     utils.cpp \
-    ../submodules/exile.h/exile.c
+    ../submodules/exile.h/exile.c \
+    wildcardmatcher.cpp
 
 HEADERS += sqlitesearch.h \
     concurrentqueue.h \
@@ -65,6 +76,8 @@ HEADERS += sqlitesearch.h \
     filesaver.h \
     filescanworker.h \
     indexer.h \
+    indexsyncer.h \
+    limitqueue.h \
     logger.h \
     looqsgeneralexception.h \
     looqsquery.h \
@@ -76,14 +89,17 @@ HEADERS += sqlitesearch.h \
     pdfprocessor.h \
     processor.h \
     sandboxedprocessor.h \
+    savefileresult.h \
     searchresult.h \
     sqlitedbservice.h \
     tagstripperprocessor.h \
     token.h \
     common.h \
-    utils.h
+    utils.h \
+    wildcardmatcher.h
 unix {
     target.path = /usr/lib
     INSTALLS += target
 }
 RESOURCES = migrations/migrations.qrc
+RESOURCES += plaintexts.qrc

shared/sqlitedbservice.cpp

@@ -62,10 +62,11 @@ bool SqliteDbService::deleteFile(QString path)
 	}
 	return result;
 }
-int SqliteDbService::getFiles(QVector<FileData> &results, QString wildCardPattern, int offset, int limit)
+
+unsigned int SqliteDbService::getFiles(QVector<FileData> &results, QString wildCardPattern, int offset, int limit)
 {
 
-	int processedRows = 0;
+	unsigned int processedRows = 0;
 	// TODO: translate/convert wildCardPattern to SQL where instead of regex
 	QString sql = "SELECT path, mtime, size, filetype FROM file";
 
@@ -150,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();

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
 {
@@ -24,7 +17,7 @@ class SqliteDbService
   public:
 	SqliteDbService(DatabaseFactory &dbFactory);
 	SaveFileResult saveFile(QFileInfo fileInfo, QVector<PageData> &pageData);
-	int getFiles(QVector<FileData> &results, QString wildCardPattern, int offset, int limit);
+	unsigned int getFiles(QVector<FileData> &results, QString wildCardPattern, int offset, int limit);
 	bool deleteFile(QString path);
 	bool fileExistsInDatabase(QString path);
 	bool fileExistsInDatabase(QString path, qint64 mtime);

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,11 +204,16 @@ 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;
 	}
 
+	if(query.getLimit() > 0)
+	{
+		prepSql += " LIMIT " + QString::number(query.getLimit());
+	}
+
 	QSqlQuery dbquery(*db);
 	dbquery.prepare(prepSql);
 	for(const QString &value : bindValues)
@@ -208,6 +239,7 @@ QVector<SearchResult> SqliteSearch::search(const LooqsQuery &query)
 		throw LooqsGeneralException("SQL Error: " + dbQuery.lastError().text());
 	}
 
+	bool contentSearch = query.hasContentSearch();
 	while(dbQuery.next())
 	{
 		SearchResult result;
@@ -215,15 +247,8 @@ 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);
 	}
 	return results;

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

shared/token.h

@@ -4,24 +4,25 @@
 
 enum TokenType
 {
-	WORD,
-	NEGATION = 2,
-	BOOL = 4,
+	WORD = 8,
+	NEGATION = 16,
+	BOOL = 32,
 	BOOL_AND,
 	BOOL_OR,
-	GROUP = 8,
+	GROUP = 64,
 	BRACKET_OPEN,
 	BRACKET_CLOSE,
-	SORT = 16,
-	FILTER_PATH = 32,
+	SORT = 128,
+	FILTER_PATH = 256,
 	FILTER_PATH_MTIME,
 	FILTER_PATH_CONTAINS,
 	FILTER_PATH_SIZE,
 	FILTER_PATH_ENDS,
 	FILTER_PATH_STARTS,
-	FILTER_CONTENT = 64,
+	FILTER_CONTENT = 512,
 	FILTER_CONTENT_CONTAINS,
 	FILTER_CONTENT_PAGE,
+	LIMIT = 1024
 };
 
 class Token

shared/wildcardmatcher.cpp

@@ -0,0 +1,29 @@
+#include "wildcardmatcher.h"
+
+void WildcardMatcher::setPatterns(QStringList patterns)
+{
+	this->regexes.clear();
+	for(QString &str : patterns)
+	{
+		QRegExp regexp;
+		regexp.setPattern(str);
+		regexp.setPatternSyntax(QRegExp::WildcardUnix);
+		this->regexes.append(regexp);
+	}
+}
+
+WildcardMatcher::WildcardMatcher()
+{
+}
+
+bool WildcardMatcher::match(QString haystack) const
+{
+	for(const QRegExp &regexp : this->regexes)
+	{
+		if(regexp.exactMatch(haystack))
+		{
+			return true;
+		}
+	}
+	return false;
+}

shared/wildcardmatcher.h

@@ -0,0 +1,17 @@
+#ifndef WILDCARDMATCHER_H
+#define WILDCARDMATCHER_H
+#include <QStringList>
+#include <QRegExp>
+class WildcardMatcher
+{
+  private:
+	QVector<QRegExp> regexes;
+	QStringList patterns;
+
+  public:
+	WildcardMatcher();
+	bool match(QString haystack) const;
+	void setPatterns(QStringList patterns);
+};
+
+#endif // WILDCARDMATCHER_H