update CHANGELOG

This should be returned by processors

CHANGELOG.md

@@ -1,4 +1,13 @@
 # looqs: Release notes
+## 2024-05-xx - v0.10
+CHANGES:
+ - Move to Qt6, drop Qt5 support.
+ - Index ToC of PDFs
+ - ToC can be searched with filter: toc:(query). (Basic, more to come).
+ - sqlite: Improvements so rare "database locked" errors don't occur.
+ - Minor fixes
+ - Add packages: Ubuntu 23.10.
+ - Remove packages: Ubuntu 22.10
 
 ## 2023-05-07 - v0.9
 Highlights: Tag support. Also begin new index mode to only index metadata (currently only path + file size, more to come).

COPYING

@@ -0,0 +1,681 @@
+This file lists looqs license and the license of third-party libraries.
+
+
+Copyright (c) 2018-2024: Albert Schwarzkopf <looqs at quitesimple period org>
+
+looqs is made available under the following license: 
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

cli/cli.pro

@@ -37,15 +37,16 @@ win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../shared/release/ -ls
 else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../shared/debug/ -lshared
 else:unix: LIBS += -L$$OUT_PWD/../shared/ -lshared
 
-LIBS += -luchardet -lpoppler-qt5 -lquazip5
+LIBS += -luchardet -lpoppler-qt6
 
-packagesExist(quazip1-qt5) {
-	PKGCONFIG += quazip1-qt5
+packagesExist(quazip1-qt6) {
+	PKGCONFIG += quazip1-qt6
 	CONFIG += link_pkgconfig
-	LIBS -= -lquazip5
 }
 
 INCLUDEPATH += $$PWD/../shared
+INCLUDEPATH += /usr/include/poppler/qt6/
+
 DEPENDPATH += $$PWD/../shared
 
 win32-g++:CONFIG(release, debug|release): PRE_TARGETDEPS += $$OUT_PWD/../shared/release/libshared.a

gui/aboutdialog.cpp

@@ -19,7 +19,6 @@ AboutDialog::AboutDialog(QWidget *parent) : QDialog(parent)
 	closeButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
 	connect(closeButton, &QPushButton::clicked, this, &QDialog::close);
 
-	closeLayout->setMargin(10);
 	closeLayout->addStretch(10);
 	closeLayout->addWidget(closeButton);
 
@@ -32,7 +31,7 @@ AboutDialog::AboutDialog(QWidget *parent) : QDialog(parent)
 	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 += "Copyright (c) 2018-2024: 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>";

gui/gui.pro

@@ -71,8 +71,8 @@ HEADERS += \
 FORMS += \
         mainwindow.ui
 
-INCLUDEPATH += /usr/include/poppler/qt5/
-INCLUDEPATH += /usr/include/quazip5
+INCLUDEPATH += /usr/include/poppler/qt6/
+INCLUDEPATH += /usr/include/quazip6
 
 QT += widgets sql
 
@@ -80,12 +80,12 @@ win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../shared/release/ -ls
 else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../shared/debug/ -lshared
 else:unix: LIBS += -L$$OUT_PWD/../shared/ -lshared
 
-LIBS += -luchardet -lpoppler-qt5 -lquazip5
+LIBS += -luchardet -lpoppler-qt6 -lquazip6
 
-packagesExist(quazip1-qt5) {
-	PKGCONFIG += quazip1-qt5
+packagesExist(quazip1-qt6) {
+	PKGCONFIG += quazip1-qt6
 	CONFIG += link_pkgconfig
-	LIBS -= -lquazip5
+	LIBS -= -lquazip6
 }
 
 INCLUDEPATH += $$PWD/../shared

gui/ipcpreviewclient.cpp

@@ -68,22 +68,25 @@ void IPCPreviewClient::start(RenderConfig config, const QVector<RenderTarget> &t
 	if(socket->isOpen() && socket->isWritable())
 	{
 		QDataStream stream(socket);
+		stream.startTransaction();
 		stream << GeneratePreviews;
 		stream << config;
 		stream << targets;
+		stream.commitTransaction();
 		socket->flush();
 
-		int numTarget = 0;
+		qsizetype numTarget = 0;
 		if(socket->isOpen() && socket->isReadable() && socket->state() == QLocalSocket::ConnectedState)
 		{
 			do
 			{
-				socket->waitForReadyRead(100);
+				socket->waitForReadyRead(5000);
 				stream.startTransaction();
 				stream >> numTarget;
 			} while(!stream.commitTransaction() && socket->state() == QLocalSocket::ConnectedState);
 			if(numTarget != targets.count())
 			{
+				qDebug() << "Target count mismatch";
 				emit error("IPC Error: Server reports less targets than it should");
 				return;
 			}

gui/ipcserver.cpp

@@ -51,7 +51,9 @@ void IpcServer::spawnerNewConnection()
 			} while(!stream.commitTransaction() && socket->state() == QLocalSocket::ConnectedState);
 			if(socket->state() == QLocalSocket::ConnectedState)
 			{
+				stream.startTransaction();
 				stream << targets.count();
+				stream.commitTransaction();
 				socket->flush();
 				IPCPreviewWorker *previewWorker = new IPCPreviewWorker(socket);
 				connect(previewWorker, &IPCPreviewWorker::finished, this, [previewWorker] { delete previewWorker; });
@@ -59,6 +61,7 @@ void IpcServer::spawnerNewConnection()
 			}
 			else
 			{
+				qDebug() << "Deleting socket...";
 				delete socket;
 			}
 		}

gui/mainwindow.cpp

@@ -1,4 +1,4 @@
-#include <poppler-qt5.h>
+#include <poppler-qt6.h>
 #include <QLabel>
 #include <QtDebug>
 #include <QFileInfo>
@@ -15,10 +15,8 @@
 #include <QFileDialog>
 #include <QScreen>
 #include <QProgressDialog>
-#include <QDesktopWidget>
 #include <QWidgetAction>
 #include <QInputDialog>
-
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
 #include "clicklabel.h"
@@ -305,6 +303,7 @@ void MainWindow::startIndexing()
 	ui->txtPathScanAdd->setEnabled(false);
 	ui->btnAddPath->setEnabled(false);
 	ui->btnChoosePath->setEnabled(false);
+	ui->btnDeletePath->setEnabled(false);
 	ui->txtSearch->setEnabled(false);
 	ui->previewProcessBar->setValue(0);
 	ui->previewProcessBar->setVisible(true);
@@ -354,6 +353,7 @@ void MainWindow::finishIndexing()
 	ui->txtPathScanAdd->setEnabled(true);
 	ui->btnAddPath->setEnabled(true);
 	ui->btnChoosePath->setEnabled(true);
+	ui->btnDeletePath->setEnabled(true);
 	ui->txtSearch->setEnabled(true);
 	if(result.erroredPaths > 0)
 	{
@@ -632,6 +632,8 @@ void MainWindow::saveSettings()
 								  "Failed to remove old database. Settings not saved.");
 			return;
 		}
+		QFile::remove(Common::databasePath() + "-shm");
+		QFile::remove(Common::databasePath() + "-wal");
 	}
 
 	QSettings settings;
@@ -673,7 +675,7 @@ void MainWindow::previewReceived()
 		headerLabel->setText(QString("Path: ") + preview->getDocumentPath());
 
 		ClickLabel *label = dynamic_cast<ClickLabel *>(preview->createPreviewWidget());
-		label->setMaximumWidth(QApplication::desktop()->availableGeometry().width() - 200);
+		label->setMaximumWidth(QApplication::primaryScreen()->availableGeometry().width() - 200);
 
 		QVBoxLayout *previewLayout = new QVBoxLayout();
 
@@ -702,7 +704,7 @@ void MainWindow::previewReceived()
 
 		previewLayout->addWidget(headerLabel);
 
-		previewLayout->setMargin(0);
+		previewLayout->setContentsMargins(0, 0, 0, 0);
 		previewLayout->insertStretch(0, 1);
 		previewLayout->insertStretch(-1, 1);
 		previewLayout->setAlignment(Qt::AlignCenter);

gui/previewcoordinator.cpp

@@ -10,6 +10,7 @@ PreviewCoordinator::PreviewCoordinator()
 	connect(&ipcPreviewClient, &IPCPreviewClient::finished, this, [&] { emit completedGeneration(); });
 	connect(this, &PreviewCoordinator::ipcStartGeneration, &ipcPreviewClient, &IPCPreviewClient::startGeneration,
 			Qt::QueuedConnection);
+	connect(&ipcPreviewClient, &IPCPreviewClient::error, this, [&](QString err) { emit error(err); });
 
 	this->ipcClientThread.start();
 }

gui/previewgeneratorodt.cpp

@@ -24,7 +24,7 @@ QSharedPointer<PreviewResult> PreviewGeneratorOdt::generate(RenderConfig config,
 		throw LooqsGeneralException("Error while reading content.xml of " + documentPath);
 	}
 	TagStripperProcessor tsp;
-	QString content = tsp.process(entireContent).constFirst().content;
+	QString content = tsp.process(entireContent).pages.constFirst().content;
 
 	PreviewGeneratorPlainText plainTextGenerator;
 	result->setText(plainTextGenerator.generatePreviewText(content, config, info.fileName()));

gui/previewgeneratorpdf.cpp

@@ -13,20 +13,21 @@ Poppler::Document *PreviewGeneratorPdf::document(QString path)
 		return documentcache.value(path);
 	}
 	locker.unlock();
-	Poppler::Document *result = Poppler::Document::load(path);
-	if(result == nullptr)
+	auto result = Poppler::Document::load(path);
+	if(!result)
 	{
+		qDebug() << "Failed to load document: " << path;
 		// TODO: some kind of user feedback would be nice
 		return nullptr;
 	}
 	result->setRenderHint(Poppler::Document::TextAntialiasing);
 	result->setRenderHint(Poppler::Document::TextHinting);
 	result->setRenderHint(Poppler::Document::TextSlightHinting);
-
+	auto ptr = result.release();
 	locker.relock();
-	documentcache.insert(path, result);
+	documentcache.insert(path, ptr);
 	locker.unlock();
-	return result;
+	return ptr;
 }
 
 QSharedPointer<PreviewResult> PreviewGeneratorPdf::generate(RenderConfig config, QString documentPath,
@@ -36,10 +37,12 @@ QSharedPointer<PreviewResult> PreviewGeneratorPdf::generate(RenderConfig config,
 	Poppler::Document *doc = document(documentPath);
 	if(doc == nullptr)
 	{
+		qDebug() << "Failed to obtain document for: " << documentPath;
 		return QSharedPointer<PreviewResult>(result);
 	}
 	if(doc->isLocked())
 	{
+		qDebug() << "Failed to open document as its locked: " << documentPath;
 		return QSharedPointer<PreviewResult>(result);
 	}
 	int p = (int)page - 1;
@@ -47,7 +50,12 @@ QSharedPointer<PreviewResult> PreviewGeneratorPdf::generate(RenderConfig config,
 	{
 		p = 0;
 	}
-	Poppler::Page *pdfPage = doc->page(p);
+	auto pdfPage = doc->page(p);
+	if(!pdfPage)
+	{
+		qDebug() << "Failed to open page " << p << " for document" << documentPath;
+		return QSharedPointer<PreviewResult>(result);
+	}
 	QImage img = pdfPage->renderToImage(config.scaleX, config.scaleY);
 	for(QString &word : config.wordsToHighlight)
 	{

gui/previewgeneratorpdf.h

@@ -1,6 +1,6 @@
 #ifndef PREVIEWGENERATORPDF_H
 #define PREVIEWGENERATORPDF_H
-#include <poppler-qt5.h>
+#include <poppler-qt6.h>
 #include "previewgenerator.h"
 #include "previewresultpdf.h"
 

shared/databasefactory.cpp

@@ -1,4 +1,5 @@
 #include <QThread>
+#include <QSqlQuery>
 #include "databasefactory.h"
 #include "logger.h"
 #include "looqsgeneralexception.h"
@@ -31,11 +32,23 @@ QSqlDatabase DatabaseFactory::forCurrentThread()
 	QSqlDatabase db =
 		QSqlDatabase::addDatabase("QSQLITE", "LOOQS" + QString::number((quint64)QThread::currentThread(), 16));
 	db.setDatabaseName(this->connectionString);
+	db.setConnectOptions("QSQLITE_BUSY_TIMEOUT=30000");
 	if(!db.open())
 	{
 		Logger::error() << "Failed to open the database: " << this->connectionString << Qt::endl;
 		throw LooqsGeneralException("Failed to create open new connection");
 	}
+	QSqlQuery q(db);
+	if(!q.exec("PRAGMA journal_mode=WAL;"))
+	{
+		Logger::error() << "Failed to set WAL mode: " << this->connectionString << Qt::endl;
+		throw LooqsGeneralException("Failed to set WAL mode on sqlite database");
+	}
+	if(!q.exec("PRAGMA wal_autocheckpoint=250;"))
+	{
+		Logger::error() << "Failed to set WAL autocheckpoint: " << this->connectionString << Qt::endl;
+		throw LooqsGeneralException("Failed to set WAL autocheckpoint on sqlite database");
+	}
 	dbStore.setLocalData(db);
 	return db;
 }

shared/defaulttextprocessor.cpp

@@ -1,6 +1,6 @@
 #include <QFile>
 #include <QDataStream>
-#include <QTextCodec>
+#include <QStringDecoder>
 #include <QDebug>
 #include "defaulttextprocessor.h"
 
@@ -13,10 +13,10 @@ QString DefaultTextProcessor::processText(const QByteArray &data) const
 	QString encoding = encodingDetector.detectEncoding(data);
 	if(!encoding.isEmpty())
 	{
-		QTextCodec *codec = QTextCodec::codecForName(encoding.toUtf8());
-		if(codec != nullptr)
+		QStringDecoder decoder = QStringDecoder(encoding.toStdString().c_str());
+		if(decoder.isValid())
 		{
-			return codec->toUnicode(data);
+			return decoder(data);
 		}
 		qWarning() << "No codec found for " << encoding;
 		return QString(data);
@@ -24,7 +24,9 @@ QString DefaultTextProcessor::processText(const QByteArray &data) const
 	return {};
 }
 
-QVector<PageData> DefaultTextProcessor::process(const QByteArray &data) const
+DocumentProcessResult DefaultTextProcessor::process(const QByteArray &data) const
 {
-	return {{0, processText(data)}};
+	DocumentProcessResult result;
+	result.pages.append({0, processText(data)});
+	return result;
 }

shared/defaulttextprocessor.h

@@ -11,7 +11,7 @@ class DefaultTextProcessor : public Processor
   public:
 	DefaultTextProcessor();
 	QString processText(const QByteArray &data) const;
-	QVector<PageData> process(const QByteArray &data) const override;
+	DocumentProcessResult process(const QByteArray &data) const override;
 };
 
 #endif // DEFAULTTEXTPROCESSOR_H

shared/documentoutlineentry.cpp

@@ -0,0 +1,31 @@
+#include "documentoutlineentry.h"
+
+DocumentOutlineEntry::DocumentOutlineEntry()
+{
+}
+
+QDataStream &operator<<(QDataStream &out, const DocumentOutlineEntry &pd)
+{
+	out << pd.text << pd.type << pd.destinationPage;
+	out << pd.children.size();
+	for(const DocumentOutlineEntry &entry : pd.children)
+	{
+		out << entry;
+	}
+	return out;
+}
+
+QDataStream &operator>>(QDataStream &in, DocumentOutlineEntry &pd)
+{
+	in >> pd.text >> pd.type >> pd.destinationPage;
+
+	qsizetype numChildren;
+	in >> numChildren;
+	for(int i = 0; i < numChildren; i++)
+	{
+		DocumentOutlineEntry entry;
+		in >> entry;
+		pd.children.append(entry);
+	}
+	return in;
+}

shared/documentoutlineentry.h

@@ -0,0 +1,30 @@
+#ifndef DOCUMENTOUTLINEENTRY_H
+#define DOCUMENTOUTLINEENTRY_H
+#include <QMetaType>
+#include <QDataStream>
+#include <QString>
+#include <QVector>
+
+enum OutlineDestinationType
+{
+	OUTLINE_DESTINATION_TYPE_NONE,
+	OUTLINE_DESTINATION_TYPE_PAGE
+	/* In the future, links, or #anchors are possible */
+};
+
+class DocumentOutlineEntry
+{
+  public:
+	DocumentOutlineEntry();
+	QVector<DocumentOutlineEntry> children;
+	OutlineDestinationType type;
+	QString text;
+	unsigned int destinationPage;
+};
+
+Q_DECLARE_METATYPE(DocumentOutlineEntry);
+
+QDataStream &operator<<(QDataStream &out, const DocumentOutlineEntry &pd);
+QDataStream &operator>>(QDataStream &in, DocumentOutlineEntry &pd);
+
+#endif // DOCUMENTOUTLINEENTRY_H

shared/documentprocessresult.cpp

@@ -0,0 +1,39 @@
+#include "documentprocessresult.h"
+#include <QDebug>
+QDataStream &operator<<(QDataStream &out, const DocumentProcessResult &pd)
+{
+	out << pd.pages.size();
+	out << pd.outlines.size();
+	for(const PageData &pd : pd.pages)
+	{
+		out << pd;
+	}
+	for(const DocumentOutlineEntry &outline : pd.outlines)
+	{
+		out << outline;
+	}
+	return out;
+}
+
+QDataStream &operator>>(QDataStream &in, DocumentProcessResult &pd)
+{
+	qsizetype numPages, numOutlines;
+	in >> numPages;
+	in >> numOutlines;
+
+	for(int i = 0; i < numPages; i++)
+	{
+		PageData data;
+		in >> data;
+		pd.pages.append(data);
+	}
+
+	for(int i = 0; i < numOutlines; i++)
+	{
+		DocumentOutlineEntry outline;
+		in >> outline;
+		pd.outlines.append(outline);
+	}
+
+	return in;
+}

shared/documentprocessresult.h

@@ -0,0 +1,17 @@
+#ifndef DOCUMENTPROCESSRESULT_H
+#define DOCUMENTPROCESSRESULT_H
+#include <pagedata.h>
+#include <documentoutlineentry.h>
+
+class DocumentProcessResult
+{
+  public:
+	QVector<PageData> pages;
+	QVector<DocumentOutlineEntry> outlines;
+};
+Q_DECLARE_METATYPE(DocumentProcessResult);
+
+QDataStream &operator<<(QDataStream &out, const DocumentProcessResult &pd);
+QDataStream &operator>>(QDataStream &in, DocumentProcessResult &pd);
+
+#endif // DOCUMENTPROCESSRESULT_H

shared/filesaver.cpp

@@ -110,7 +110,7 @@ int FileSaver::processFiles(const QVector<QString> paths, std::function<SaveFile
 
 SaveFileResult FileSaver::saveFile(const QFileInfo &fileInfo)
 {
-	QVector<PageData> pageData;
+	DocumentProcessResult processResult;
 	QString canonicalPath = fileInfo.canonicalFilePath();
 
 	int processorReturnCode = -1;
@@ -169,11 +169,10 @@ SaveFileResult FileSaver::saveFile(const QFileInfo &fileInfo)
 			 * finishes.
 			 */
 			QDataStream in(process.readAllStandardOutput());
-			while(!in.atEnd())
+
+			if(!in.atEnd())
 			{
-				PageData pd;
-				in >> pd;
-				pageData.append(pd);
+				in >> processResult;
 			}
 			processorReturnCode = process.exitCode();
 			if(processorReturnCode != OK && processorReturnCode != OK_WASEMPTY)
@@ -185,7 +184,7 @@ SaveFileResult FileSaver::saveFile(const QFileInfo &fileInfo)
 			}
 		}
 	}
-	SaveFileResult result = this->dbService->saveFile(fileInfo, pageData, this->fileSaverOptions.metadataOnly);
+	SaveFileResult result = this->dbService->saveFile(fileInfo, processResult, this->fileSaverOptions.metadataOnly);
 	if(result == OK && processorReturnCode == OK_WASEMPTY)
 	{
 		return OK_WASEMPTY;

shared/indexer.cpp

@@ -163,6 +163,7 @@ void Indexer::processFinishedWorker()
 	--this->runningWorkers;
 	if(!isRunning())
 	{
+		this->db->runWalCheckpoint();
 		emit finished();
 	}
 }

shared/indexsyncer.cpp

@@ -110,7 +110,7 @@ void IndexSyncer::sync()
 			if(!this->fileSaverOptions.keepGoing)
 			{
 				QString errorMsg = QString("Failed to update all files selected for updating in this batch. Updated") +
-								   updatedFilesCount + "out of" + shouldHaveUpdatedCount + "selected for updating";
+								   QString::number(updatedFilesCount) + "out of" + QString::number(shouldHaveUpdatedCount) + "selected for updating";
 				emit error(errorMsg);
 				emit finished(totalUpdatesFilesCount, totalDeletedFilesCount, totalErroredFilesCount);
 			}

shared/looqsquery.cpp

@@ -29,6 +29,11 @@ bool LooqsQuery::hasContentSearch() const
 	return (this->getTokensMask() & FILTER_CONTENT) == FILTER_CONTENT;
 }
 
+bool LooqsQuery::hasOutlineSearch() const
+{
+	return (this->getTokensMask() & FILTER_OUTLINE_CONTAINS) == FILTER_OUTLINE_CONTAINS;
+}
+
 bool LooqsQuery::hasPathSearch() const
 {
 	return (this->getTokensMask() & FILTER_PATH) == FILTER_PATH;
@@ -289,6 +294,10 @@ LooqsQuery LooqsQuery::build(QString expression, TokenType loneWordsTokenType, b
 			{
 				tokenType = FILTER_TAG_ASSIGNED;
 			}
+			else if(filtername == "toc" || filtername == "outline")
+			{
+				tokenType = FILTER_OUTLINE_CONTAINS;
+			}
 			// TODO: given this is not really a "filter", this feels slightly misplaced here
 			else if(filtername == "sort")
 			{

shared/looqsquery.h

@@ -68,6 +68,7 @@ class LooqsQuery
 		this->limit = limit;
 	}
 	bool hasContentSearch() const;
+	bool hasOutlineSearch() const;
 	bool hasPathSearch() const;
 
 	void addSortCondition(SortCondition sc);

shared/migrations/6.sql

@@ -0,0 +1,2 @@
+CREATE TABLE outline(id INTEGER PRIMARY KEY, fileid INTEGER REFERENCES file (id) ON DELETE CASCADE, text varchar(1024), page integer);
+CREATE INDEX outline_fileid ON outline (fileid);

shared/migrations/migrations.qrc

@@ -5,5 +5,6 @@
         <file>3.sql</file>
         <file>4.sql</file>
         <file>5.sql</file>
+        <file>6.sql</file>
     </qresource>
 </RCC>

shared/nothingprocessor.h

@@ -10,7 +10,7 @@ class NothingProcessor : public Processor
 	NothingProcessor();
 
   public:
-	QVector<PageData> process(const QByteArray & /*data*/) const override
+	DocumentProcessResult process(const QByteArray & /*data*/) const override
 	{
 		return {};
 	}

shared/odtprocessor.cpp

@@ -3,12 +3,12 @@
 #include "odtprocessor.h"
 #include "tagstripperprocessor.h"
 
-QVector<PageData> OdtProcessor::process(const QByteArray & /*data*/) const
+DocumentProcessResult OdtProcessor::process(const QByteArray & /*data*/) const
 {
 	throw LooqsGeneralException("Not implemented yet");
 }
 
-QVector<PageData> OdtProcessor::process(QString path) const
+DocumentProcessResult OdtProcessor::process(QString path) const
 {
 	QuaZipFile zipFile(path);
 	zipFile.setFileName("content.xml");

shared/odtprocessor.h

@@ -8,9 +8,9 @@ class OdtProcessor : public Processor
 	{
 		this->PREFERED_DATA_SOURCE = FILEPATH;
 	}
-	QVector<PageData> process(const QByteArray &data) const override;
+	DocumentProcessResult process(const QByteArray &data) const override;
 
-	QVector<PageData> process(QString path) const override;
+	DocumentProcessResult process(QString path) const override;
 };
 
 #endif // ODTPROCESSOR_H

shared/pdfprocessor.cpp

@@ -1,15 +1,35 @@
 #include <QScopedPointer>
-#include <poppler-qt5.h>
 #include "pdfprocessor.h"
 PdfProcessor::PdfProcessor()
 {
 }
 
-QVector<PageData> PdfProcessor::process(const QByteArray &data) const
+QVector<DocumentOutlineEntry> PdfProcessor::createOutline(const QVector<Poppler::OutlineItem> &outlineItems) const
 {
-	QVector<PageData> result;
-	QScopedPointer<Poppler::Document> doc(Poppler::Document::loadFromData(data));
-	if(doc.isNull())
+	QVector<DocumentOutlineEntry> result;
+	for(const Poppler::OutlineItem &outlineItem : outlineItems)
+	{
+		DocumentOutlineEntry documentOutlineEntry;
+		documentOutlineEntry.text = outlineItem.name();
+		documentOutlineEntry.type = OUTLINE_DESTINATION_TYPE_PAGE;
+		if(!outlineItem.destination().isNull())
+		{
+			documentOutlineEntry.destinationPage = outlineItem.destination()->pageNumber();
+		}
+		if(outlineItem.hasChildren())
+		{
+			documentOutlineEntry.children = createOutline(outlineItem.children());
+		}
+		result.append(documentOutlineEntry);
+	}
+	return result;
+}
+
+DocumentProcessResult PdfProcessor::process(const QByteArray &data) const
+{
+	DocumentProcessResult result;
+	auto doc(Poppler::Document::loadFromData(data));
+	if(!doc)
 	{
 		throw LooqsGeneralException("Failed to process pdf data");
 	}
@@ -26,12 +46,13 @@ QVector<PageData> PdfProcessor::process(const QByteArray &data) const
 	for(auto i = 0; i < pagecount; i++)
 	{
 		QString text = doc->page(i)->text(entirePage);
-		result.append({static_cast<unsigned int>(i + 1), text});
+		result.pages.append({static_cast<unsigned int>(i + 1), text});
 		/*TODO: hack, so we can fts search several words over the whole document, not just pages.
 		 * this of course uses more space and should be solved differently.
 		 */
 		entire += text;
 	}
-	result.append({0, entire});
+	result.pages.append({0, entire});
+	result.outlines = createOutline(doc->outline());
 	return result;
 }

shared/pdfprocessor.h

@@ -1,5 +1,6 @@
 #ifndef PDFPROCESSOR_H
 #define PDFPROCESSOR_H
+#include <poppler-qt6.h>
 #include "processor.h"
 class PdfProcessor : public Processor
 {
@@ -7,7 +8,8 @@ class PdfProcessor : public Processor
 	PdfProcessor();
 
   public:
-	QVector<PageData> process(const QByteArray &data) const override;
+	QVector<DocumentOutlineEntry> createOutline(const QVector<Poppler::OutlineItem> &outlineItems) const;
+	DocumentProcessResult process(const QByteArray &data) const override;
 };
 
 #endif // PDFPROCESSOR_H

shared/processor.h

@@ -2,8 +2,8 @@
 #define PROCESSOR_H
 #include <QVector>
 #include <QFile>
-#include "pagedata.h"
 #include "utils.h"
+#include "documentprocessresult.h"
 enum DataSource
 {
 	FILEPATH,
@@ -18,8 +18,8 @@ class Processor
 	 * a single file */
 	DataSource PREFERED_DATA_SOURCE = ARRAY;
 	Processor();
-	virtual QVector<PageData> process(const QByteArray &data) const = 0;
-	virtual QVector<PageData> process(QString path) const
+	virtual DocumentProcessResult process(const QByteArray &data) const = 0;
+	virtual DocumentProcessResult process(QString path) const
 	{
 		return process(Utils::readFile(path));
 	}

shared/sandboxedprocessor.cpp

@@ -65,18 +65,12 @@ void SandboxedProcessor::enableSandbox(QString readablePath)
 	exile_free_policy(policy);
 }
 
-void SandboxedProcessor::printResults(const QVector<PageData> &pageData)
+void SandboxedProcessor::printResults(const DocumentProcessResult &result)
 {
 	QFile fsstdout;
 	fsstdout.open(stdout, QIODevice::WriteOnly);
 	QDataStream stream(&fsstdout);
-
-	for(const PageData &data : pageData)
-	{
-		stream << data;
-		// fsstdout.flush();
-	}
-
+	stream << result;
 	fsstdout.close();
 }
 
@@ -102,7 +96,7 @@ SaveFileResult SandboxedProcessor::process()
 		return OK;
 	}
 
-	QVector<PageData> pageData;
+	DocumentProcessResult processResult;
 	QString absPath = fileInfo.absoluteFilePath();
 
 	try
@@ -111,13 +105,13 @@ SaveFileResult SandboxedProcessor::process()
 		{
 			/* Read access to FS needed... doh..*/
 			enableSandbox(absPath);
-			pageData = processor->process(absPath);
+			processResult = processor->process(absPath);
 		}
 		else
 		{
 			QByteArray data = Utils::readFile(absPath);
 			enableSandbox();
-			pageData = processor->process(data);
+			processResult = processor->process(data);
 		}
 	}
 	catch(LooqsGeneralException &e)
@@ -126,6 +120,6 @@ SaveFileResult SandboxedProcessor::process()
 		return PROCESSFAIL;
 	}
 
-	printResults(pageData);
-	return pageData.isEmpty() ? OK_WASEMPTY : OK;
+	printResults(processResult);
+	return processResult.pages.isEmpty() ? OK_WASEMPTY : OK;
 }

shared/sandboxedprocessor.h

@@ -2,7 +2,7 @@
 #define SANDBOXEDPROCESSOR_H
 #include <QString>
 #include <QMimeDatabase>
-#include "pagedata.h"
+#include "documentprocessresult.h"
 #include "savefileresult.h"
 
 class SandboxedProcessor
@@ -12,7 +12,7 @@ class SandboxedProcessor
 	QMimeDatabase mimeDatabase;
 
 	void enableSandbox(QString readablePath = "");
-	void printResults(const QVector<PageData> &pageData);
+	void printResults(const DocumentProcessResult &pageData);
 
   public:
 	SandboxedProcessor(QString filepath)

shared/shared.pro

@@ -14,11 +14,11 @@ CONFIG += staticlib
 CONFIG += c++17
 
 INCLUDEPATH += $$PWD/../sandbox/exile.h/
-INCLUDEPATH += /usr/include/poppler/qt5/ /usr/include/quazip5
+INCLUDEPATH += /usr/include/poppler/qt6/ /usr/include/quazip5
 
 # Dirty, we only need the includes here but well this magic works, so...
-packagesExist(quazip1-qt5) {
-       PKGCONFIG += quazip1-qt5
+packagesExist(quazip1-qt6) {
+       PKGCONFIG += quazip1-qt6
        CONFIG += link_pkgconfig
 }
 
@@ -42,6 +42,8 @@ SOURCES += sqlitesearch.cpp \
     dbmigrator.cpp \
     defaulttextprocessor.cpp \
     dirscanworker.cpp \
+    documentoutlineentry.cpp \
+    documentprocessresult.cpp \
     encodingdetector.cpp \
     filesaver.cpp \
     filescanworker.cpp \
@@ -72,6 +74,8 @@ HEADERS += sqlitesearch.h \
     dbmigrator.h \
     defaulttextprocessor.h \
     dirscanworker.h \
+    documentoutlineentry.h \
+    documentprocessresult.h \
     encodingdetector.h \
     filedata.h \
     filesaver.h \

shared/sqlitedbservice.cpp

@@ -2,6 +2,7 @@
 #include <QFileInfo>
 #include <QDateTime>
 #include <QSqlError>
+#include <QRegularExpression>
 #include "looqsgeneralexception.h"
 #include "sqlitedbservice.h"
 #include "filedata.h"
@@ -81,16 +82,14 @@ unsigned int SqliteDbService::getFiles(QVector<FileData> &results, QString wildC
 		throw LooqsGeneralException("Error while trying to retrieve files from database: " + query.lastError().text());
 	}
 
-	// TODO: port this to QRegularExpression once >5.12 gets more widespread because of this bug
-	// https://bugreports.qt.io/browse/QTBUG-72539?focusedCommentId=439053&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel
 	bool usePattern = !wildCardPattern.isEmpty();
-	QRegExp regexPattern(wildCardPattern);
-	regexPattern.setPatternSyntax(QRegExp::PatternSyntax::WildcardUnix);
+	QString regex = QRegularExpression::wildcardToRegularExpression(wildCardPattern, QRegularExpression::UnanchoredWildcardConversion);
+	QRegularExpression regexPattern(regex);
 
 	while(query.next())
 	{
 		QString absPath = query.value(0).toString();
-		if(!usePattern || regexPattern.exactMatch(absPath))
+		if(!usePattern || regexPattern.match(absPath).hasMatch())
 		{
 			FileData current;
 			current.absPath = absPath;
@@ -166,7 +165,7 @@ QVector<QString> SqliteDbService::getPathsForTag(QString tag)
 bool SqliteDbService::setTags(QString path, const QSet<QString> &tags)
 {
 	QSqlDatabase db = dbFactory->forCurrentThread();
-	if(!db.transaction())
+	if(!this->beginTransaction(db))
 	{
 		Logger::error() << "Failed to open transaction for " << path << " : " << db.lastError() << Qt::endl;
 		return false;
@@ -182,6 +181,8 @@ bool SqliteDbService::setTags(QString path, const QSet<QString> &tags)
 		return false;
 	}
 
+	deletionQuery.finish();
+
 	for(const QString &tag : tags)
 	{
 		QSqlQuery tagQuery = QSqlQuery(db);
@@ -193,6 +194,7 @@ bool SqliteDbService::setTags(QString path, const QSet<QString> &tags)
 			Logger::error() << "Failed to insert tag " << tagQuery.lastError() << Qt::endl;
 			return false;
 		}
+		tagQuery.finish();
 		QSqlQuery fileTagQuery(db);
 		fileTagQuery.prepare(
 			"INSERT INTO filetag(fileid, tagid) VALUES((SELECT id FROM file WHERE path = ?), (SELECT id "
@@ -205,8 +207,9 @@ bool SqliteDbService::setTags(QString path, const QSet<QString> &tags)
 			Logger::error() << "Failed to assign tag to file" << Qt::endl;
 			return false;
 		}
+		fileTagQuery.finish();
 	}
-	if(!db.commit())
+	if(!this->commitTransaction(db))
 	{
 		db.rollback();
 		Logger::error() << "Failed to commit transaction when saving tags" << Qt::endl;
@@ -240,6 +243,7 @@ bool SqliteDbService::insertToFTS(bool useTrigrams, QSqlDatabase &db, int fileid
 			Logger::error() << "Failed fts insertion " << ftsQuery.lastError() << Qt::endl;
 			return false;
 		}
+		ftsQuery.finish();
 		QSqlQuery contentQuery(db);
 		contentQuery.prepare(contentInsertStatement);
 		contentQuery.addBindValue(fileid);
@@ -249,10 +253,47 @@ bool SqliteDbService::insertToFTS(bool useTrigrams, QSqlDatabase &db, int fileid
 			Logger::error() << "Failed content insertion " << contentQuery.lastError() << Qt::endl;
 			return false;
 		}
+		contentQuery.finish();
 	}
 	return true;
 }
 
+bool SqliteDbService::insertOutline(QSqlDatabase &db, int fileid, const QVector<DocumentOutlineEntry> &outlines)
+{
+	QSqlQuery outlineQuery(db);
+	outlineQuery.prepare("INSERT INTO outline(fileid, text, page) VALUES(?,?,?)");
+	outlineQuery.addBindValue(fileid);
+	for(const DocumentOutlineEntry &outline : outlines)
+	{
+		QString text = outline.text.trimmed();
+		if(text.length() > 0)
+		{
+			text = text.toLower();
+
+			outlineQuery.bindValue(1, text);
+			outlineQuery.bindValue(2, outline.destinationPage);
+			if(!outlineQuery.exec())
+			{
+				Logger::error() << "Failed outline insertion " << outlineQuery.lastError() << Qt::endl;
+				return false;
+			}
+			outlineQuery.finish();
+			if(!insertOutline(db, fileid, outline.children))
+			{
+				Logger::error() << "Failed outline insertion (children)) " << outlineQuery.lastError() << Qt::endl;
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+bool SqliteDbService::runWalCheckpoint()
+{
+	auto query = QSqlQuery(dbFactory->forCurrentThread());
+	return query.exec("PRAGMA wal_checkpoint(TRUNCATE);");
+}
+
 QSqlQuery SqliteDbService::exec(QString querystr, std::initializer_list<QVariant> args)
 {
 	auto query = QSqlQuery(dbFactory->forCurrentThread());
@@ -278,7 +319,33 @@ bool SqliteDbService::execBool(QString querystr, std::initializer_list<QVariant>
 	return query.value(0).toBool();
 }
 
-SaveFileResult SqliteDbService::saveFile(QFileInfo fileInfo, QVector<PageData> &pageData, bool pathsOnly)
+/*
+ *  The default only opens BEGIN TRANSACTION, but for multi-threaded, IMMEDIATE TRANSACTION is the more reasonable choice */
+bool SqliteDbService::beginTransaction(QSqlDatabase &db)
+{
+	QSqlQuery query(db);
+	if(!query.exec("BEGIN IMMEDIATE TRANSACTION"))
+	{
+		Logger::error() << "Immediate transaction could not be acquired" << query.lastError() << Qt::endl;
+		/* TODO: handle maybe the busy time out here */
+		return false;
+	}
+	return true;
+}
+
+bool SqliteDbService::commitTransaction(QSqlDatabase &db)
+{
+	QSqlQuery query(db);
+	if(!query.exec("COMMIT TRANSACTION"))
+	{
+		Logger::error() << "Transaction failed to commit" << Qt::endl;
+		/* TODO: handle maybe the busy time out here */
+		return false;
+	}
+	return true;
+}
+
+SaveFileResult SqliteDbService::saveFile(QFileInfo fileInfo, DocumentProcessResult &processResult, bool pathsOnly)
 {
 	QString absPath = fileInfo.absoluteFilePath();
 	auto mtime = fileInfo.lastModified().toSecsSinceEpoch();
@@ -288,6 +355,11 @@ SaveFileResult SqliteDbService::saveFile(QFileInfo fileInfo, QVector<PageData> &
 		fileType = 'f';
 	}
 
+	/* Insertion can take a long time and other threads can be be busy... we are not guaranteed to get a lock for the transaction.
+	 *  Don't want to set the sqlite busy handler to eternity. */
+	QMutexLocker lock(&this->writeMutex);
+
+
 	QSqlDatabase db = dbFactory->forCurrentThread();
 	QSqlQuery delQuery(db);
 	delQuery.prepare("DELETE FROM file WHERE path = ?");
@@ -300,7 +372,7 @@ SaveFileResult SqliteDbService::saveFile(QFileInfo fileInfo, QVector<PageData> &
 	inserterQuery.addBindValue(fileInfo.size());
 	inserterQuery.addBindValue(fileType);
 
-	if(!db.transaction())
+	if(!this->beginTransaction(db))
 	{
 		Logger::error() << "Failed to open transaction for " << absPath << " : " << db.lastError() << Qt::endl;
 		return DBFAIL;
@@ -312,6 +384,7 @@ SaveFileResult SqliteDbService::saveFile(QFileInfo fileInfo, QVector<PageData> &
 		db.rollback();
 		return DBFAIL;
 	}
+	delQuery.finish();
 
 	if(!inserterQuery.exec())
 	{
@@ -319,25 +392,32 @@ SaveFileResult SqliteDbService::saveFile(QFileInfo fileInfo, QVector<PageData> &
 		db.rollback();
 		return DBFAIL;
 	}
+	int lastid = inserterQuery.lastInsertId().toInt();
+	inserterQuery.finish();
 
 	if(!pathsOnly)
 	{
-		int lastid = inserterQuery.lastInsertId().toInt();
-		if(!insertToFTS(false, db, lastid, pageData))
+		if(!insertToFTS(false, db, lastid, processResult.pages))
 		{
 			db.rollback();
 			Logger::error() << "Failed to insert data to FTS index " << Qt::endl;
 			return DBFAIL;
 		}
-		if(!insertToFTS(true, db, lastid, pageData))
+		if(!insertToFTS(true, db, lastid, processResult.pages))
 		{
 			db.rollback();
 			Logger::error() << "Failed to insert data to FTS index " << Qt::endl;
 			return DBFAIL;
 		}
+		if(!insertOutline(db, lastid, processResult.outlines))
+		{
+			db.rollback();
+			Logger::error() << "Failed to insert outline data " << Qt::endl;
+			return DBFAIL;
+		}
 	}
 
-	if(!db.commit())
+	if(!this->commitTransaction(db))
 	{
 		db.rollback();
 		Logger::error() << "Failed to commit transaction for " << absPath << " : " << db.lastError() << Qt::endl;
@@ -367,7 +447,7 @@ bool SqliteDbService::addTag(QString tag, const QVector<QString> &paths)
 	fileTagQuery.prepare("INSERT INTO filetag(fileid, tagid) VALUES((SELECT id FROM file WHERE path = ?), (SELECT id "
 						 "FROM tag WHERE name = ?))");
 	fileTagQuery.bindValue(1, tag);
-	if(!db.transaction())
+	if(!this->beginTransaction(db))
 	{
 		Logger::error() << "Failed to open transaction to add paths for tag " << tag << " : " << db.lastError()
 						<< Qt::endl;
@@ -379,6 +459,7 @@ bool SqliteDbService::addTag(QString tag, const QVector<QString> &paths)
 		Logger::error() << "Failed INSERT query" << tagQuery.lastError() << Qt::endl;
 		return false;
 	}
+	tagQuery.finish();
 
 	for(const QString &path : paths)
 	{
@@ -389,9 +470,9 @@ bool SqliteDbService::addTag(QString tag, const QVector<QString> &paths)
 			Logger::error() << "Failed to add paths to tag" << Qt::endl;
 			return false;
 		}
+		fileTagQuery.finish();
 	}
-
-	if(!db.commit())
+	if(!this->commitTransaction(db))
 	{
 		db.rollback();
 		Logger::error() << "Failed to commit tag insertion transaction" << db.lastError() << Qt::endl;
@@ -422,6 +503,7 @@ bool SqliteDbService::removePathsForTag(QString tag, const QVector<QString> &pat
 			Logger::error() << "An error occured while trying to remove paths from tag assignment" << Qt::endl;
 			return false;
 		}
+		fileTagQuery.finish();
 	}
 	return true;
 }
@@ -429,7 +511,7 @@ bool SqliteDbService::removePathsForTag(QString tag, const QVector<QString> &pat
 bool SqliteDbService::deleteTag(QString tag)
 {
 	QSqlDatabase db = dbFactory->forCurrentThread();
-	if(!db.transaction())
+	if(!this->beginTransaction(db))
 	{
 		Logger::error() << "Failed to open transaction while trying to delete tag " << tag << " : " << db.lastError()
 						<< Qt::endl;
@@ -446,6 +528,7 @@ bool SqliteDbService::deleteTag(QString tag)
 		Logger::error() << "Error while trying to delete tag: " << db.lastError() << Qt::endl;
 		return false;
 	}
+	assignmentDeleteQuery.finish();
 
 	QSqlQuery deleteTagQuery(db);
 	deleteTagQuery.prepare("DELETE FROM tag WHERE name = ?");
@@ -456,8 +539,9 @@ bool SqliteDbService::deleteTag(QString tag)
 		Logger::error() << "Error while trying to delete tag: " << db.lastError() << Qt::endl;
 		return false;
 	}
+	deleteTagQuery.finish();
 
-	if(!db.commit())
+	if(!this->commitTransaction(db))
 	{
 		db.rollback();
 		Logger::error() << "Error while trying to delete tag: " << db.lastError() << Qt::endl;

shared/sqlitedbservice.h

@@ -1,11 +1,12 @@
 #ifndef SQLITEDBSERVICE_H
 #define SQLITEDBSERVICE_H
 #include <QFileInfo>
+#include <QMutexLocker>
 #include <optional>
 
 #include "databasefactory.h"
 #include "utils.h"
-#include "pagedata.h"
+#include "documentprocessresult.h"
 #include "filedata.h"
 #include "../shared/sqlitesearch.h"
 #include "../shared/token.h"
@@ -20,9 +21,14 @@ class SqliteDbService
 	QSqlQuery exec(QString query, std::initializer_list<QVariant> args);
 	bool execBool(QString querystr, std::initializer_list<QVariant> args);
 
+	bool beginTransaction(QSqlDatabase &db);
+	bool commitTransaction(QSqlDatabase &db);
+
+	QMutex writeMutex;
+
   public:
 	SqliteDbService(DatabaseFactory &dbFactory);
-	SaveFileResult saveFile(QFileInfo fileInfo, QVector<PageData> &pageData, bool pathsOnly);
+	SaveFileResult saveFile(QFileInfo fileInfo, DocumentProcessResult &pageData, bool pathsOnly);
 
 	bool deleteFile(QString path);
 	bool fileExistsInDatabase(QString path);
@@ -42,6 +48,9 @@ class SqliteDbService
 	QVector<SearchResult> search(const LooqsQuery &query);
 
 	std::optional<QChar> queryFileType(QString absPath);
+	bool insertOutline(QSqlDatabase &db, int fileid, const QVector<DocumentOutlineEntry> &outlines);
+
+	bool runWalCheckpoint();
 };
 
 #endif // SQLITEDBSERVICE_H

shared/sqlitesearch.cpp

@@ -148,6 +148,11 @@ QPair<QString, QVector<QString>> SqliteSearch::createSql(const Token &token)
 		return {" file.id IN (SELECT fileid FROM filetag WHERE tagid = (SELECT id FROM tag WHERE name = ?)) ",
 				{value.toLower()}};
 	}
+	if(token.type == FILTER_OUTLINE_CONTAINS)
+	{
+		return {" outline.text LIKE '%' || ? || '%'  ", {value.toLower()}};
+	}
+
 	throw LooqsGeneralException("Unknown token passed (should not happen)");
 }
 
@@ -156,6 +161,7 @@ QSqlQuery SqliteSearch::makeSqlQuery(const LooqsQuery &query)
 	QString whereSql;
 	QVector<QString> bindValues;
 	bool isContentSearch = (query.getTokensMask() & FILTER_CONTENT) == FILTER_CONTENT;
+	bool isOutlineSearch = query.hasOutlineSearch();
 	if(query.getTokens().isEmpty())
 	{
 		throw LooqsGeneralException("Nothing to search for supplied");
@@ -200,15 +206,22 @@ QSqlQuery SqliteSearch::makeSqlQuery(const LooqsQuery &query)
 	}
 	else
 	{
+		QString pageColumn = "'0' as page";
+		QString joiners = "";
+		if(isOutlineSearch)
+		{
+			pageColumn = "outline.page as page";
+			joiners = " INNER JOIN outline ON outline.fileid = file.id ";
+		}
 		if(sortSql.isEmpty())
 		{
 			sortSql = "ORDER BY file.mtime DESC";
 		}
-		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;
+		prepSql = "SELECT DISTINCT file.path AS path, " + pageColumn +
+				  ",file.mtime AS mtime, file.size AS size, "
+				  "file.filetype AS filetype FROM file" +
+				  joiners + " WHERE  1=1 AND " + whereSql + " " + sortSql;
 	}
-
 	if(query.getLimit() > 0)
 	{
 		prepSql += " LIMIT " + QString::number(query.getLimit());
@@ -242,7 +255,7 @@ QVector<SearchResult> SqliteSearch::search(const LooqsQuery &query)
 		throw LooqsGeneralException("SQL Error: " + dbQuery.lastError().text());
 	}
 
-	bool contentSearch = query.hasContentSearch();
+	bool contentSearch = query.hasContentSearch() || query.hasOutlineSearch();
 	while(dbQuery.next())
 	{
 		SearchResult result;

shared/tagstripperprocessor.cpp

@@ -1,14 +1,14 @@
 #include "tagstripperprocessor.h"
-
+#include <QRegularExpression>
 TagStripperProcessor::TagStripperProcessor()
 {
 }
 
-QVector<PageData> TagStripperProcessor::process(const QByteArray &data) const
+DocumentProcessResult TagStripperProcessor::process(const QByteArray &data) const
 {
 	auto result = DefaultTextProcessor::process(data);
 	// TODO: does not work properly with <br> and does not deal with entities...
-
-	result[0].content.remove(QRegExp("<[^>]*>"));
+	Q_ASSERT(result.pages.size() > 0);
+	result.pages[0].content.remove(QRegularExpression("<[^>]*>"));
 	return result;
 }

shared/tagstripperprocessor.h

@@ -8,7 +8,7 @@ class TagStripperProcessor : public DefaultTextProcessor
 	TagStripperProcessor();
 
   public:
-	QVector<PageData> process(const QByteArray &data) const override;
+	DocumentProcessResult process(const QByteArray &data) const override;
 };
 
 #endif // XMLSTRIPPERPROCESSOR_H

shared/token.h

@@ -20,6 +20,7 @@ enum TokenType
 	FILTER_PATH_ENDS,
 	FILTER_PATH_STARTS,
 	FILTER_TAG_ASSIGNED,
+	FILTER_OUTLINE_CONTAINS,
 	FILTER_CONTENT = 512, /* Everything below here is content search (except LIMIT) */
 	FILTER_CONTENT_CONTAINS,
 	FILTER_CONTENT_PAGE,

shared/utils.cpp

@@ -14,7 +14,7 @@ QByteArray Utils::readFile(QString path)
 	QByteArray data = file.readAll();
 	if(data.isEmpty() && file.error() != QFileDevice::FileError::NoError)
 	{
-		throw LooqsGeneralException("Error reading file: " + path + ", Error: " + file.error());
+		throw LooqsGeneralException("Error reading file: " + path + ", Error: " + QString::number(file.error()));
 	}
 	return data;
 }

shared/wildcardmatcher.cpp

@@ -5,9 +5,8 @@ void WildcardMatcher::setPatterns(QStringList patterns)
 	this->regexes.clear();
 	for(QString &str : patterns)
 	{
-		QRegExp regexp;
-		regexp.setPattern(str);
-		regexp.setPatternSyntax(QRegExp::WildcardUnix);
+		QRegularExpression regexp;
+		regexp.setPattern(QRegularExpression::wildcardToRegularExpression(str, QRegularExpression::UnanchoredWildcardConversion));
 		this->regexes.append(regexp);
 	}
 }
@@ -18,9 +17,10 @@ WildcardMatcher::WildcardMatcher()
 
 bool WildcardMatcher::match(QString haystack) const
 {
-	for(const QRegExp &regexp : this->regexes)
+	for(const QRegularExpression &regexp : this->regexes)
 	{
-		if(regexp.exactMatch(haystack))
+		QRegularExpressionMatch match = regexp.match(haystack);
+		if(match.hasMatch())
 		{
 			return true;
 		}

shared/wildcardmatcher.h

@@ -1,11 +1,11 @@
 #ifndef WILDCARDMATCHER_H
 #define WILDCARDMATCHER_H
 #include <QStringList>
-#include <QRegExp>
+#include <QRegularExpression>
 class WildcardMatcher
 {
   private:
-	QVector<QRegExp> regexes;
+	QVector<QRegularExpression> regexes;
 	QStringList patterns;
 
   public: