File _service:obs_scm:pimcommon-VERSIONgit.20190514T... of Package pimcommon

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:pimcommon-VERSIONgit.20190514T131636~0c3a7c5.obscpio of Package pimcommon (Revision 3ea20309fa21bc5d984bb9610c1e91ad)

Currently displaying revision 3ea20309fa21bc5d984bb9610c1e91ad , Show latest

07070100000000000081A40000000200000002000000015CDAA3940000004B000000000000000000000000000000000000003800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/.arcconfig{
  "phabricator.uri": "https://phabricator.kde.org/project/profile/34/"
}
07070100000001000081A40000000200000002000000015CDAA39400000E12000000000000000000000000000000000000003C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/CMakeLists.txtcmake_minimum_required(VERSION 3.5)
set(PIM_VERSION "5.11.42")

project(pimcommon VERSION ${PIM_VERSION})

set(KF5_MIN_VERSION "5.58.0")

find_package(ECM ${KF5_MIN_VERSION} CONFIG REQUIRED)
set(LIBRARY_NAMELINK)
set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules ${ECM_MODULE_PATH})

include(GenerateExportHeader)
include(ECMSetupVersion)
include(ECMGenerateHeaders)
include(ECMGeneratePriFile)

include(ECMSetupVersion)
include(FeatureSummary)
include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
include(ECMQtDeclareLoggingCategory)
include(ECMAddTests)
include(ECMInstallIcons)

set(PIMCOMMON_LIB_VERSION ${PIM_VERSION})
set(AKONADICONTACT_LIB_VERSION "5.11.40")
set(LIBKDEPIM_LIB_VERSION "5.11.40")
set(QT_REQUIRED_VERSION "5.10.0")
set(KMIME_LIB_VERSION "5.11.40")
set(KIMAP_LIB_VERSION "5.11.40")
set(KCONTACTS_LIB_VERSION "5.11.40")
set(KPIMTEXTEDIT_LIB_VERSION "5.11.40")
set(AKONADI_VERSION "5.11.40")

find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets DBus Network Test Xml PrintSupport)

find_package(KF5Archive ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5Codecs ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5Completion ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5Config ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5ConfigWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5CoreAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5DBusAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5I18n ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5IconThemes ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5ItemModels ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5JobWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5KIO ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5NewStuff ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5Service ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5WidgetsAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5XmlGui ${KF5_MIN_VERSION} CONFIG REQUIRED)

find_package(KF5Akonadi ${AKONADI_VERSION} CONFIG REQUIRED)
find_package(KF5AkonadiContact ${AKONADICONTACT_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5Contacts ${KCONTACTS_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5IMAP ${KIMAP_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5LibkdepimAkonadi ${LIBKDEPIM_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5PimTextEdit ${KPIMTEXTEDIT_LIB_VERSION} CONFIG REQUIRED)

find_package(KF5Purpose ${KF5_MIN_VERSION} CONFIG REQUIRED)

find_package(KF5DesignerPlugin ${KF5_MIN_VERSION} CONFIG)
set_package_properties(KF5DesignerPlugin PROPERTIES DESCRIPTION "KF5 designer plugin" TYPE OPTIONAL)

find_package(Xsltproc)
set_package_properties(Xsltproc PROPERTIES DESCRIPTION "XSLT processor from libxslt" TYPE REQUIRED PURPOSE "Required to generate D-Bus interfaces for all Akonadi resources.")

if(BUILD_TESTING)
   find_package(KF5Mime ${KMIME_LIB_VERSION} CONFIG REQUIRED)
   add_definitions(-DBUILD_TESTING)
endif(BUILD_TESTING)

########### Targets ###########

# workaround for https://bugreports.qt.io/browse/QTBUG-74665 (bug in qt5.13 reevaluate it)
if (${Qt5Widgets_VERSION} STREQUAL "5.13.0")
   MESSAGE(STATUS "Qt version: ${Qt5Widgets_VERSION} DISABLE compile without deprecated methods. bug QTBUG-74665")
else()
   add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x060000)
endif()
add_definitions(-DQT_NO_FOREACH)

add_subdirectory(src)
install( FILES pimcommon.renamecategories pimcommon.categories DESTINATION ${KDE_INSTALL_CONFDIR} )
feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
07070100000002000081A40000000200000002000000015CDAA39400004761000000000000000000000000000000000000003500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/COPYINGNOTE! The GPL below is copyrighted by the Free Software Foundation, but
the instance of code that it refers to (the kde programs) are copyrighted
by the authors who actually wrote it.

---------------------------------------------------------------------------
			
		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

Copyright (C) 1989, 1991 Free Software Foundation, Inc.
               51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  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
this service 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 make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  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.

We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and
modification follow.

GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
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
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

9. The Free Software Foundation may publish revised and/or new versions
of the 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 a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

NO WARRANTY

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE 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.

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
convey 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) 19yy  <name of author>

This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 19yy name of author
    Gnomovision 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, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

<signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This 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 Library General
Public License instead of this License.
07070100000003000081A40000000200000002000000015CDAA3940000679F000000000000000000000000000000000000003900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/COPYING.LIB
                  GNU LESSER GENERAL PUBLIC LICENSE
                       Version 2.1, February 1999

Copyright (C) 1991, 1999 Free Software Foundation, Inc.
	51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

Preamble

The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations
below.

When we speak of free software, we are referring to freedom of use,
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 this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.

We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.

For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it
becomes a de-facto standard.  To achieve this, non-free programs must
be allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

"Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control
compilation and installation of the library.

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.

1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

a) The modified work must itself be a software library.

b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

(For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.

c) Accompany the work with a written offer, valid for at least
    three years, to give the same user the materials specified in
    Subsection 6a, above, for a charge no more than the cost of
    performing this distribution.

d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
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
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply, and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License
may add an explicit geographical distribution limitation excluding those
countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

13. The Free Software Foundation may publish revised and/or new
versions of the Lesser 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 Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

NO WARRANTY

15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "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
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY 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
LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Libraries

If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change.  You can do so by permitting
redistribution under these terms (or, alternatively, under the terms
of the ordinary General Public License).

To apply these terms, attach the following notices to the library.
It is safest to attach them to the start of each source file to most
effectively convey 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 library's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

This library 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
    Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or
your school, if any, to sign a "copyright disclaimer" for the library,
if necessary.  Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James
  Random Hacker.

<signature of Ty Coon>, 1 April 1990
  Ty Coon, President of Vice

That's all there is to it!

07070100000004000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000003300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/cmake07070100000005000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000003B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/cmake/modules07070100000006000081A40000000200000002000000015CDAA394000003F7000000000000000000000000000000000000004E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/cmake/modules/FindXsltproc.cmake# Find xsltproc executable and provide a macro to generate D-Bus interfaces.
#
# The following variables are defined :
# XSLTPROC_EXECUTABLE - path to the xsltproc executable
# Xsltproc_FOUND - true if the program was found
#
find_program(XSLTPROC_EXECUTABLE xsltproc DOC "Path to the xsltproc executable")
mark_as_advanced(XSLTPROC_EXECUTABLE)

if(XSLTPROC_EXECUTABLE)
  set(Xsltproc_FOUND TRUE)

# We depend on kdepimlibs, make sure it's found
  if(NOT DEFINED KF5Akonadi_DATA_DIR)
    find_package(KF5Akonadi REQUIRED)
  endif()

# Macro to generate a D-Bus interface description from a KConfigXT file
  macro(kcfg_generate_dbus_interface _kcfg _name)
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_name}.xml
      COMMAND ${XSLTPROC_EXECUTABLE} --stringparam interfaceName ${_name}
      ${KF5Akonadi_DATA_DIR}/kcfg2dbus.xsl
      ${_kcfg}
      > ${CMAKE_CURRENT_BINARY_DIR}/${_name}.xml
      DEPENDS ${KF5Akonadi_DATA_DIR}/kcfg2dbus.xsl
      ${_kcfg}
      )
  endmacro()
endif()

07070100000007000081A40000000200000002000000015CDAA3940000013F000000000000000000000000000000000000003B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/metainfo.yamlname: pimcommon
description: PimCommon Library 
maintainer: mlaurent
public_lib: true
group: kdepim
platforms:
    - name: All
irc: akonadi

libraries:
 - qmake: PimCommon
   cmake: "KF5::PimCommon"
cmakename: KF5PimCommon
 - qmake: PimCommonAkonadi
   cmake: "KF5::PimCommonAkonadi"
cmakename: KF5PimCommonAkonadi

07070100000008000081A40000000200000002000000015CDAA3940000009D000000000000000000000000000000000000004200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/pimcommon.categoriesorg.kde.pim.pimcommon kdepim (pimcommon) IDENTIFIER [PIMCOMMON_LOG]
org.kde.pim.pimcommonakonadi kdepim (pimcommonakonadi) IDENTIFIER [PIMCOMMONAKONADI_LOG]
07070100000009000081A40000000200000002000000015CDAA39400000025000000000000000000000000000000000000004800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/pimcommon.renamecategorieslog_pimcommon org.kde.pim.pimcommon

0707010000000A000041ED0000000200000002000000045CDAA39400000000000000000000000000000000000000000000003100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src0707010000000B000081A40000000200000002000000015CDAA39400000077000000000000000000000000000000000000004000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/CMakeLists.txtadd_definitions(-DTRANSLATION_DOMAIN=\"libpimcommon\")

add_subdirectory(pimcommon)
add_subdirectory(pimcommonakonadi)
0707010000000C000081A40000000200000002000000015CDAA394000000C5000000000000000000000000000000000000003D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/Messages.sh#! /bin/sh
$EXTRACTRC `find . -name '*.ui'` >> rc.cpp || exit 11
$XGETTEXT `find . -name '*.h' -o -name '*.cpp' | grep -v '/tests/' | grep -v '/autotests/'` -o $podir/libpimcommon.pot
rm -f rc.cpp
0707010000000D000041ED0000000200000002000000115CDAA39400000000000000000000000000000000000000000000003B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon0707010000000E000081A40000000200000002000000015CDAA394000032E8000000000000000000000000000000000000004A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/CMakeLists.txtset(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5PimCommon")

configure_package_config_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/KF5PimCommonConfig.cmake.in"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonConfig.cmake"
    INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
    )

ecm_setup_version(PROJECT VARIABLE_PREFIX PIMCOMMON
    VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/pimcommon_version.h"
    PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonConfigVersion.cmake"
    SOVERSION 5
    )

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonConfig.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonConfigVersion.cmake"
    DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
    COMPONENT Devel
    )

install(EXPORT KF5PimCommonTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE KF5PimCommonTargets.cmake NAMESPACE KF5::)

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/pimcommon_version.h
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5} COMPONENT Devel
    )

set(libpimcommon_autocorrection_SRCS
    autocorrection/autocorrection.cpp
    autocorrection/autocorrectionwidget.cpp
    autocorrection/autocorrectionlistwidget.cpp
    autocorrection/autocorrectiontreewidget.cpp
    autocorrection/autocorrectionlanguage.cpp
    autocorrection/import/importlibreofficeautocorrection.cpp
    autocorrection/import/importkmailautocorrection.cpp
    autocorrection/import/importabstractautocorrection.cpp
    autocorrection/widgets/lineeditwithautocorrection.cpp
    autocorrection/widgets/richtexteditwithautocorrection.cpp
    )

set(libpimcommon_generericplugin_SRCS
    genericplugins/pluginutil.cpp
    genericplugins/genericpluginmanager.cpp
    genericplugins/genericplugin.cpp
    genericplugins/abstractgenericplugin.cpp
    genericplugins/abstractgenericplugininterface.cpp
    )

set(libpimcommon_configure_plugins_SRCS
    configureplugins/configurepluginslistwidget.cpp
    configureplugins/configurepluginswidget.cpp
    configureplugins/configureplugindialog.cpp
    )

set(libpimcommon_translator_SRCS
    translator/translatorutil.cpp
    translator/translatorwidget.cpp
    translator/translatordebugdialog.cpp
    translator/googletranslator.cpp
    )

set(libpimcommon_templatewidgets_SRCS
    templatewidgets/templatelistwidget.cpp
    templatewidgets/templateeditdialog.cpp
    templatewidgets/templatemanager.cpp
    )

set(libpimcommon_widgets_SRCS
    widgets/renamefiledialog.cpp
    widgets/simplestringlisteditor.cpp
    widgets/customtreeview.cpp
    widgets/configureimmutablewidgetutils.cpp
    widgets/kactionmenuchangecase.cpp
    widgets/spellchecklineedit.cpp
    widgets/kpimprintpreviewdialog.cpp
    widgets/lineeditwithcompleterng.cpp
    widgets/purposemenuwidget.cpp
    )

set(libpimcommon_customtools_SRCS
    customtools/customtoolsplugin.cpp
    customtools/customtoolspluginmanager.cpp
    customtools/customtoolswidgetng.cpp
    customtools/customtoolsviewinterface.cpp
    )

set(libpimcommon_util_SRCS
    util/pimutil.cpp
    util/networkutil.cpp
    )

set(libpimcommon_migrate_SRCS
    migration/migrateapplicationfiles.cpp
    migration/migratefileinfo.cpp
    )

set(libpimcommon_shareserviceurl_SRCS
    shareserviceurl/shareserviceurlmanager.cpp
    )

set(libpimcommon_logactivities_SRCS
    logactivities/logactivitiesmanager.cpp
    logactivities/logactivitiesdialog.cpp
    logactivities/logactivitieswidget.cpp
    logactivities/logactivitiespurposemenuwidget.cpp
    )

set(libpimcommon_networkmanager_SRCS
    network/networkmanager.cpp
    )

set(libpimcommon_SRCS
    settings/pimcommonsettings.cpp
    ${libpimcommon_configure_plugins_SRCS}
    ${libpimcommon_networkmanager_SRCS}
    ${libpimcommon_configure_plugins_SRCS}
    ${libpimcommon_shareserviceurl_SRCS}
    ${libpimcommon_migrate_SRCS}
    ${libpimcommon_util_SRCS}
    ${libpimcommon_texteditor_SRCS}
    ${libpimcommon_storageservice_SRCS}
    ${libpimcommon_autocorrection_SRCS}
    ${libpimcommon_translator_SRCS}
    ${libpimcommon_templatewidgets_SRCS}
    ${libpimcommon_widgets_SRCS}
    ${libpimcommon_customtools_SRCS}
    ${libpimcommon_logactivities_SRCS}
    ${libpimcommon_generericplugin_SRCS}
    )
qt5_add_resources(libpimcommon_SRCS widgets/icons.qrc)
ecm_qt_declare_logging_category(libpimcommon_SRCS HEADER pimcommon_debug.h IDENTIFIER PIMCOMMON_LOG CATEGORY_NAME org.kde.pim.pimcommon)

ki18n_wrap_ui(libpimcommon_SRCS
    autocorrection/ui/autocorrectionwidget.ui
    )

macro(add_resource_iface _kcfgFile _ifaceName _className _fileName)
    kcfg_generate_dbus_interface(${CMAKE_CURRENT_SOURCE_DIR}/${_kcfgFile} ${_ifaceName})
    qt5_add_dbus_interface(libpimcommon_SRCS
        ${CMAKE_CURRENT_BINARY_DIR}/${_ifaceName}.xml ${_fileName} ${_className}
        )
endmacro()

add_resource_iface(util/imapresource.kcfg org.kde.Akonadi.Imap.Settings ImapSettings imapresourcesettings)

kconfig_add_kcfg_files(libpimcommon_SRCS
    settings/pimcommonsetting_base.kcfgc
    )

add_library(KF5PimCommon ${libpimcommon_SRCS})
generate_export_header(KF5PimCommon BASE_NAME pimcommon)
add_library(KF5::PimCommon ALIAS KF5PimCommon)

target_link_libraries(KF5PimCommon
    PUBLIC
    Qt5::Network
    KF5::KIOCore
    KF5::ConfigWidgets
    PRIVATE
    KF5::I18n
    KF5::Libkdepim
    KF5::Archive
    KF5::NewStuff
    KF5::PimTextEdit
    KF5::XmlGui
    KF5::PimTextEdit
    KF5::IconThemes
    KF5::Completion
    KF5::KIOWidgets
    Qt5::PrintSupport
    KF5::Purpose
    KF5::PurposeWidgets
    )

target_include_directories(KF5PimCommon INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/PimCommon/;${KDE_INSTALL_INCLUDEDIR_KF5}/pimcommon>")

target_include_directories(KF5PimCommon PUBLIC "$<BUILD_INTERFACE:${pimcommon_SOURCE_DIR}/src;${pimcommon_BINARY_DIR}/src>")

set_target_properties(KF5PimCommon PROPERTIES
    VERSION ${PIMCOMMON_VERSION_STRING}
    SOVERSION ${PIMCOMMON_SOVERSION}
    EXPORT_NAME PimCommon
    )

install(TARGETS
    KF5PimCommon
    EXPORT KF5PimCommonTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS}  ${LIBRARY_NAMELINK}
    )

if (BUILD_TESTING)
    add_subdirectory(translator/autotests)
    add_subdirectory(autocorrection/autotests)
    add_subdirectory(widgets/autotests)
    add_subdirectory(migration/autotests)
    add_subdirectory(util/autotests)
    add_subdirectory(shareserviceurl/autotests)
    add_subdirectory(translator/tests)
    add_subdirectory(widgets/tests)
    add_subdirectory(autocorrection/tests)
    add_subdirectory(customtools/autotests)
    add_subdirectory(autotests)
    add_subdirectory(logactivities/autotests)
    add_subdirectory(logactivities/tests)
    add_subdirectory(configureplugins/autotests)
    add_subdirectory(genericplugins/autotests)
endif()

ecm_generate_headers(PimCommon_CamelCasegenericplugins_HEADERS
    HEADER_NAMES
    PluginUtil
    GenericPluginManager
    GenericPlugin
    AbstractGenericPlugin
    AbstractGenericPluginInterface
    REQUIRED_HEADERS PimCommon_genericplugins_HEADERS
    PREFIX PimCommon
    RELATIVE genericplugins
    )

ecm_generate_headers(PimCommon_CamelCasenetworkmanager_HEADERS
    HEADER_NAMES
    NetworkManager
    REQUIRED_HEADERS PimCommon_networkmanager_HEADERS
    PREFIX PimCommon
    RELATIVE network
    )

ecm_generate_headers(PimCommon_CamelCase_HEADERS
    HEADER_NAMES
    PimUtil
    NetworkUtil
    REQUIRED_HEADERS PimCommon_HEADERS
    PREFIX PimCommon
    RELATIVE util
    )

ecm_generate_headers(PimCommon_Camelcasesettings_HEADERS
    HEADER_NAMES
    PimCommonSettings
    REQUIRED_HEADERS PimCommon_settings_HEADERS
    PREFIX PimCommon
    RELATIVE settings
    )

ecm_generate_headers(PimCommon_Camelcaselogactivities_HEADERS
    HEADER_NAMES
    LogActivitiesManager
    REQUIRED_HEADERS PimCommon_logactivities_HEADERS
    PREFIX PimCommon
    RELATIVE logactivities
    )

ecm_generate_headers(PimCommon_Camelcaseshareserviceurl_HEADERS
    HEADER_NAMES
    ShareServiceUrlManager
    REQUIRED_HEADERS PimCommon_shareserviceurl_HEADERS
    PREFIX PimCommon
    RELATIVE shareserviceurl
    )

ecm_generate_headers(PimCommon_Camelcasetranslator_HEADERS
    HEADER_NAMES
    TranslatorWidget
    REQUIRED_HEADERS PimCommon_translator_HEADERS
    PREFIX PimCommon
    RELATIVE translator
    )

ecm_generate_headers(PimCommon_Camelcasecustomtools_HEADERS
    HEADER_NAMES
    CustomToolsWidgetng
    CustomToolsPlugin
    CustomToolsViewInterface
    CustomToolsPluginManager
    REQUIRED_HEADERS PimCommon_customtools_HEADERS
    PREFIX PimCommon
    RELATIVE customtools
    )

ecm_generate_headers(PimCommon_Camelcasemigrate_HEADERS
    HEADER_NAMES
    MigrateApplicationFiles
    MigrateFileInfo
    REQUIRED_HEADERS PimCommon_migrate_HEADERS
    PREFIX PimCommon
    RELATIVE migration
    )

ecm_generate_headers(PimCommon_Camelcaseautocorrectionwidgets_HEADERS
    HEADER_NAMES
    RichTexteditWithAutoCorrection
    LineEditWithAutoCorrection
    REQUIRED_HEADERS PimCommon_autocorrectionwidgets_HEADERS
    PREFIX PimCommon
    RELATIVE autocorrection/widgets/
    )

ecm_generate_headers(PimCommon_Camelcaseautocorrection_HEADERS
    HEADER_NAMES
    AutoCorrectionWidget
    AutoCorrectionLanguage
    AutoCorrection
    REQUIRED_HEADERS PimCommon_autocorrection_HEADERS
    PREFIX PimCommon
    RELATIVE autocorrection/
    )

ecm_generate_headers(PimCommon_Camelcasetemplatelist_HEADERS
    HEADER_NAMES
    TemplateListWidget
    TemplateManager
    REQUIRED_HEADERS PimCommon_templatelist_HEADERS
    PREFIX PimCommon
    RELATIVE templatewidgets
    )

ecm_generate_headers(PimCommon_Camelcasewidgets_HEADERS
    HEADER_NAMES
    CustomTreeView
    SpellCheckLineEdit
    ConfigureImmutableWidgetUtils
    RenameFileDialog
    SimpleStringListEditor
    KActionMenuChangeCase
    KPimPrintPreviewDialog
    LineEditWithCompleterNg
    PurposeMenuWidget
    REQUIRED_HEADERS PimCommon_widgets_HEADERS
    PREFIX PimCommon
    RELATIVE widgets
    )

ecm_generate_headers(PimCommon_Camelcaseconfigureplugins_HEADERS
    HEADER_NAMES
    ConfigurePluginsListWidget
    ConfigurePluginsWidget
    ConfigurePluginDialog
    REQUIRED_HEADERS PimCommon_configureplugins_HEADERS
    PREFIX PimCommon
    RELATIVE configureplugins
    )
ecm_generate_pri_file(BASE_NAME PimCommon
    LIB_NAME KF5PimCommon
    DEPS "Network KIOCore ConfigWidgets" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/PimCommon
    )

install(FILES
    ${PimCommon_Camelcaseconfigureplugins_HEADERS}
    ${PimCommon_CamelCasegenericplugins_HEADERS}
    ${PimCommon_Camelcaselogactivities_HEADERS}
    ${PimCommon_CamelCasenetworkmanager_HEADERS}
    ${PimCommon_CamelCase_HEADERS}
    ${PimCommon_CamelCasejob_HEADERS}
    ${PimCommon_Camelcaseautocorrection_HEADERS}
    ${PimCommon_Camelcaseautocorrectionwidgets_HEADERS}
    ${PimCommon_Camelcasecustomtools_HEADERS}
    ${PimCommon_Camelcasemanagerserversidesubscription_HEADERS}
    ${PimCommon_Camelcasemigrate_HEADERS}
    ${PimCommon_Camelcaseplaintexteditor_HEADERS}
    ${PimCommon_Camelcaserichtexteditor_HEADERS}
    ${PimCommon_Camelcasescript_HEADERS}
    ${PimCommon_Camelcasesettings_HEADERS}
    ${PimCommon_Camelcaseshareserviceurl_HEADERS}
    ${PimCommon_Camelcasestorageservice_HEADERS}
    ${PimCommon_Camelcasestorageservicedialog_HEADERS}
    ${PimCommon_Camelcasestorageserviceinterface_HEADERS}
    ${PimCommon_Camelcasestorageservicesettings_HEADERS}
    ${PimCommon_Camelcasestorageservicewidgets_HEADERS}
    ${PimCommon_Camelcasetemplatelist_HEADERS}
    ${PimCommon_Camelcasetexteditor_commonwidget_HEADERS}
    ${PimCommon_Camelcasetranslator_HEADERS}
    ${PimCommon_Camelcasewidgets_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/PimCommon
    COMPONENT Devel
    )

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/imapresourcesettings.h
    ${CMAKE_CURRENT_BINARY_DIR}/pimcommon_export.h
    ${CMAKE_CURRENT_BINARY_DIR}/pimcommonsetting_base.h
    ${PimCommon_HEADERS}
    ${PimCommon_genericplugins_HEADERS}
    ${PimCommon_configureplugins_HEADERS}
    ${PimCommon_networkmanager_HEADERS}
    ${PimCommon_autocorrection_HEADERS}
    ${PimCommon_autocorrectionwidgets_HEADERS}
    ${PimCommon_customtools_HEADERS}
    ${PimCommon_job_HEADERS}
    ${PimCommon_managerserversidesubscription_HEADERS}
    ${PimCommon_migrate_HEADERS}
    ${PimCommon_plaintexteditor_HEADERS}
    ${PimCommon_richtexteditor_HEADERS}
    ${PimCommon_settings_HEADERS}
    ${PimCommon_shareserviceurl_HEADERS}
    ${PimCommon_storageservice_HEADERS}
    ${PimCommon_storageservicedialog_HEADERS}
    ${PimCommon_storageserviceinterface_HEADERS}
    ${PimCommon_storageservicesettings_HEADERS}
    ${PimCommon_storageservicewidgets_HEADERS}
    ${PimCommon_templatelist_HEADERS}
    ${PimCommon_texteditor_commonwidget_HEADERS}
    ${PimCommon_translator_HEADERS}
    ${PimCommon_widgets_HEADERS}
    ${PimCommon_logactivities_HEADERS}

DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/pimcommon
    COMPONENT Devel
    )

install(FILES
    ${PRI_FILENAME}
    DESTINATION ${ECM_MKSPECS_INSTALL_DIR})

add_subdirectory(designer)

0707010000000F000081A40000000200000002000000015CDAA394000000A0000000000000000000000000000000000000005700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/KF5PimCommonConfig.cmake.in@PACKAGE_INIT@
include(CMakeFindDependencyMacro)
find_dependency(KF5Config "@KF5_MIN_VERSION@")

include("${CMAKE_CURRENT_LIST_DIR}/KF5PimCommonTargets.cmake")
07070100000010000041ED0000000200000002000000075CDAA39400000000000000000000000000000000000000000000004A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection07070100000011000081A40000000200000002000000015CDAA3940000AEFE000000000000000000000000000000000000005D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrection.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>
  code based on calligra autocorrection.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrection.h"

#include "settings/pimcommonsettings.h"
#include "import/importkmailautocorrection.h"
#include <KColorScheme>
#include <QLocale>
#include "pimcommon_debug.h"
#include <QTextBlock>
#include <QTextDocument>
#include <QFile>
#include <QDir>
#include <QStandardPaths>
#include <QFileInfo>
#include <QRegularExpression>
#include <QXmlStreamWriter>

using namespace PimCommon;

AutoCorrection::AutoCorrection()
    : mSingleSpaces(true)
    , mUppercaseFirstCharOfSentence(false)
    , mFixTwoUppercaseChars(false)
    , mAutoFractions(true)
    , mCapitalizeWeekDays(false)
    , mReplaceDoubleQuotes(false)
    , mReplaceSingleQuotes(false)
    , mEnabled(false)
    , mSuperScriptAppendix(false)
    , mAddNonBreakingSpace(false)
    , mMaxFindStringLenght(0)
    , mMinFindStringLenght(0)
{
    mNonBreakingSpace = QChar(QChar::Nbsp);
    // default double quote open 0x201c
    // default double quote close 0x201d
    // default single quote open 0x2018
    // default single quote close 0x2019
    mTypographicSingleQuotes.begin = QChar(0x2018);
    mTypographicSingleQuotes.end = QChar(0x2019);
    mTypographicDoubleQuotes.begin = QChar(0x201c);
    mTypographicDoubleQuotes.end = QChar(0x201d);

readConfig();

auto locale = QLocale::system();
    mCacheNameOfDays.reserve(7);
    for (int i = 1; i <= 7; ++i) {
        mCacheNameOfDays.append(locale.dayName(i).toLower());
    }
}

AutoCorrection::~AutoCorrection()
{
}

void AutoCorrection::selectStringOnMaximumSearchString(QTextCursor &cursor, int cursorPosition)
{
    cursor.setPosition(cursorPosition);

QTextBlock block = cursor.block();
    int pos = qMax(block.position(), cursorPosition - mMaxFindStringLenght);

//TODO verify that pos == block.position() => it's a full line => not a piece of word
    //TODO if not => check if pos -1 is a space => not a piece of word
    //TODO otherwise move cursor until we detect a space
    //TODO otherwise we must not autoconvert it.
    if (pos != block.position()) {
        const QString text = block.text();
        const int currentPos = (pos - block.position());
        if (!text.at(currentPos - 1).isSpace()) {
            //qDebug() << " current Text " << text << " currentPos "<< currentPos << " pos " << pos;
            //qDebug() << "selected text " << text.right(text.length() - currentPos);
            //qDebug() << "  text after " << text.at(currentPos - 1);
            bool foundWord = false;
            const int textLength(text.length());
            for (int i = currentPos; i < textLength; ++i) {
                if (text.at(i).isSpace()) {
                    pos = qMin(cursorPosition, pos + 1 + block.position());
                    foundWord = true;
                    break;
                }
            }
            if (!foundWord) {
                pos = cursorPosition;
            }
        }
    }
    cursor.setPosition(pos);
    cursor.setPosition(cursorPosition, QTextCursor::KeepAnchor);
}

void AutoCorrection::selectPreviousWord(QTextCursor &cursor, int cursorPosition)
{
    cursor.setPosition(cursorPosition);
    QTextBlock block = cursor.block();
    cursor.setPosition(block.position());
    cursorPosition -= block.position();
    QString string = block.text();
    int pos = 0;
    bool space = false;
    QString::Iterator iter = string.begin();
    while (iter != string.end()) {
        if (iter->isSpace()) {
            if (space) {
                // double spaces belong to the previous word
            } else if (pos < cursorPosition) {
                cursor.setPosition(pos + block.position() + 1);    // +1 because we don't want to set it on the space itself
            } else {
                space = true;
            }
        } else if (space) {
            break;
        }
        ++pos;
        ++iter;
    }
    cursor.setPosition(pos + block.position(), QTextCursor::KeepAnchor);
}

bool AutoCorrection::autocorrect(bool htmlMode, QTextDocument &document, int &position)
{
    if (mEnabled) {
        mCursor = QTextCursor(&document);
        mCursor.setPosition(position);

//If we already have a space not necessary to look at other autocorrect feature.
        if (!singleSpaces()) {
            return false;
        }

int oldPosition = position;
        selectPreviousWord(mCursor, position);
        mWord = mCursor.selectedText();
        if (mWord.isEmpty()) {
            return true;
        }
        mCursor.beginEditBlock();
        bool done = false;
        if (htmlMode) {
            done = autoFormatURLs();
            if (!done) {
                done = autoBoldUnderline();
                //We replace */- by format => remove cursor position by 2
                if (done) {
                    oldPosition -= 2;
                }
            }
            if (!done) {
                superscriptAppendix();
            }
        }
        if (!done) {
            done = autoFractions();
            //We replace three characters with 1
            if (done) {
                oldPosition -= 2;
            }
        }
        if (!done) {
            uppercaseFirstCharOfSentence();
            fixTwoUppercaseChars();
            capitalizeWeekDays();
            replaceTypographicQuotes();
            if (mWord.length() <= 2) {
                addNonBreakingSpace();
            }
        }

if (mCursor.selectedText() != mWord) {
            mCursor.insertText(mWord);
        }
        position = oldPosition;

if (!done) {
            selectStringOnMaximumSearchString(mCursor, position);
            mWord = mCursor.selectedText();
            if (!mWord.isEmpty()) {
                const int newPos = advancedAutocorrect();
                if (newPos != -1) {
                    if (mCursor.selectedText() != mWord) {
                        mCursor.insertText(mWord);
                    }
                    position = newPos;
                }
            }
        }
        mCursor.endEditBlock();
    }
    return true;
}

void AutoCorrection::readConfig()
{
    mAutoBoldUnderline = PimCommon::PimCommonSettings::self()->autoBoldUnderline();
    mAutoFormatUrl = PimCommon::PimCommonSettings::self()->autoFormatUrl();
    mUppercaseFirstCharOfSentence = PimCommon::PimCommonSettings::self()->uppercaseFirstCharOfSentence();
    mFixTwoUppercaseChars = PimCommon::PimCommonSettings::self()->fixTwoUppercaseChars();
    mSingleSpaces = PimCommon::PimCommonSettings::self()->singleSpaces();
    mAutoFractions = PimCommon::PimCommonSettings::self()->autoFractions();
    mCapitalizeWeekDays = PimCommon::PimCommonSettings::self()->capitalizeWeekDays();
    mAdvancedAutocorrect = PimCommon::PimCommonSettings::self()->advancedAutocorrect();
    mReplaceDoubleQuotes = PimCommon::PimCommonSettings::self()->replaceDoubleQuotes();
    mReplaceSingleQuotes = PimCommon::PimCommonSettings::self()->replaceSingleQuotes();
    mEnabled = PimCommon::PimCommonSettings::self()->enabled();
    mSuperScriptAppendix = PimCommon::PimCommonSettings::self()->superScript();
    mAddNonBreakingSpace = PimCommon::PimCommonSettings::self()->addNonBreakingSpaceInFrench();
    readAutoCorrectionXmlFile();
}

void AutoCorrection::writeConfig()
{
    PimCommon::PimCommonSettings::self()->setAutoBoldUnderline(mAutoBoldUnderline);
    PimCommon::PimCommonSettings::self()->setAutoFormatUrl(mAutoFormatUrl);
    PimCommon::PimCommonSettings::self()->setUppercaseFirstCharOfSentence(mUppercaseFirstCharOfSentence);
    PimCommon::PimCommonSettings::self()->setFixTwoUppercaseChars(mFixTwoUppercaseChars);
    PimCommon::PimCommonSettings::self()->setSingleSpaces(mSingleSpaces);
    PimCommon::PimCommonSettings::self()->setAutoFractions(mAutoFractions);
    PimCommon::PimCommonSettings::self()->setCapitalizeWeekDays(mCapitalizeWeekDays);
    PimCommon::PimCommonSettings::self()->setAdvancedAutocorrect(mAdvancedAutocorrect);
    PimCommon::PimCommonSettings::self()->setReplaceDoubleQuotes(mReplaceDoubleQuotes);
    PimCommon::PimCommonSettings::self()->setReplaceSingleQuotes(mReplaceSingleQuotes);
    PimCommon::PimCommonSettings::self()->setEnabled(mEnabled);
    PimCommon::PimCommonSettings::self()->setSuperScript(mSuperScriptAppendix);
    PimCommon::PimCommonSettings::self()->setAddNonBreakingSpaceInFrench(mAddNonBreakingSpace);
    PimCommon::PimCommonSettings::self()->requestSync();
    writeAutoCorrectionXmlFile();
}

bool AutoCorrection::addAutoCorrect(const QString &currentWord, const QString &replaceWord)
{
    if (!mAutocorrectEntries.contains(currentWord)) {
        mAutocorrectEntries.insert(currentWord, replaceWord);
        writeAutoCorrectionXmlFile();
        return true;
    } else {
        return false;
    }
}

void AutoCorrection::setUpperCaseExceptions(const QSet<QString> &exceptions)
{
    mUpperCaseExceptions = exceptions;
}

void AutoCorrection::setTwoUpperLetterExceptions(const QSet<QString> &exceptions)
{
    mTwoUpperLetterExceptions = exceptions;
}

void AutoCorrection::setAutocorrectEntries(const QHash<QString, QString> &entries)
{
    mMaxFindStringLenght = 0;
    mMinFindStringLenght = 0;
    QHashIterator<QString, QString> i(entries);
    while (i.hasNext()) {
        i.next();
        const int findStringLenght(i.key().length());
        mMaxFindStringLenght = qMax(mMaxFindStringLenght, findStringLenght);
        mMinFindStringLenght = qMin(mMinFindStringLenght, findStringLenght);
    }
    mAutocorrectEntries = entries;
}

void AutoCorrection::setAutoFormatUrl(bool b)
{
    mAutoFormatUrl = b;
}

void AutoCorrection::setAutoBoldUnderline(bool b)
{
    mAutoBoldUnderline = b;
}

void AutoCorrection::setSuperScript(bool b)
{
    mSuperScriptAppendix = b;
}

void AutoCorrection::setAddNonBreakingSpace(bool b)
{
    mAddNonBreakingSpace = b;
}

bool AutoCorrection::isEnabledAutoCorrection() const
{
    return mEnabled;
}

bool AutoCorrection::isUppercaseFirstCharOfSentence() const
{
    return mUppercaseFirstCharOfSentence;
}

bool AutoCorrection::isFixTwoUppercaseChars() const
{
    return mFixTwoUppercaseChars;
}

bool AutoCorrection::isSingleSpaces() const
{
    return mSingleSpaces;
}

bool AutoCorrection::isAutoFractions() const
{
    return mAutoFractions;
}

bool AutoCorrection::isCapitalizeWeekDays() const
{
    return mCapitalizeWeekDays;
}

bool AutoCorrection::isReplaceDoubleQuotes() const
{
    return mReplaceDoubleQuotes;
}

bool AutoCorrection::isReplaceSingleQuotes() const
{
    return mReplaceSingleQuotes;
}

bool AutoCorrection::isAdvancedAutocorrect() const
{
    return mAdvancedAutocorrect;
}

bool AutoCorrection::isAutoFormatUrl() const
{
    return mAutoFormatUrl;
}

bool AutoCorrection::isAutoBoldUnderline() const
{
    return mAutoBoldUnderline;
}

bool AutoCorrection::isSuperScript() const
{
    return mSuperScriptAppendix;
}

bool AutoCorrection::isAddNonBreakingSpace() const
{
    return mAddNonBreakingSpace;
}

AutoCorrection::TypographicQuotes AutoCorrection::typographicDefaultSingleQuotes() const
{
    AutoCorrection::TypographicQuotes quote;
    quote.begin = QChar(0x2018);
    quote.end = QChar(0x2019);
    return quote;
}

AutoCorrection::TypographicQuotes AutoCorrection::typographicDefaultDoubleQuotes() const
{
    AutoCorrection::TypographicQuotes quote;
    quote.begin = QChar(0x201c);
    quote.end = QChar(0x201d);
    return quote;
}

QSet<QString> AutoCorrection::upperCaseExceptions() const
{
    return mUpperCaseExceptions;
}

QSet<QString> AutoCorrection::twoUpperLetterExceptions() const
{
    return mTwoUpperLetterExceptions;
}

QHash<QString, QString> AutoCorrection::autocorrectEntries() const
{
    return mAutocorrectEntries;
}

void AutoCorrection::superscriptAppendix()
{
    if (!mSuperScriptAppendix) {
        return;
    }

const QString trimmed = mWord.trimmed();
    int startPos = -1;
    int endPos = -1;
    const int trimmedLenght(trimmed.length());

QHash<QString, QString>::const_iterator i = mSuperScriptEntries.constBegin();
    while (i != mSuperScriptEntries.constEnd()) {
        if (i.key() == trimmed) {
            startPos = mCursor.selectionStart() + 1;
            endPos = startPos - 1 + trimmedLenght;
            break;
        } else if (i.key() == QLatin1String("othernb")) {
            const int pos = trimmed.indexOf(i.value());
            if (pos > 0) {
                QString number = trimmed.left(pos);
                QString::ConstIterator constIter = number.constBegin();
                bool found = true;
                // don't apply superscript to 1th, 2th and 3th
                const int numberLength(number.length());
                if (numberLength == 1
                    && (*constIter == QLatin1Char('1')
                        || *constIter == QLatin1Char('2')
                        || *constIter == QLatin1Char('3'))) {
                    found = false;
                }
                if (found) {
                    while (constIter != number.constEnd()) {
                        if (!constIter->isNumber()) {
                            found = false;
                            break;
                        }
                        ++constIter;
                    }
                }
                if (found && numberLength + i.value().length() == trimmedLenght) {
                    startPos = mCursor.selectionStart() + pos;
                    endPos = startPos - pos + trimmedLenght;
                    break;
                }
            }
        }
        ++i;
    }

if (startPos != -1 && endPos != -1) {
        QTextCursor cursor(mCursor);
        cursor.setPosition(startPos);
        cursor.setPosition(endPos, QTextCursor::KeepAnchor);

QTextCharFormat format;
        format.setVerticalAlignment(QTextCharFormat::AlignSuperScript);
        cursor.mergeCharFormat(format);
    }
}

void AutoCorrection::addNonBreakingSpace()
{
    if (mAddNonBreakingSpace && isFrenchLanguage()) {
        const QTextBlock block = mCursor.block();
        const QString text = block.text();
        const QChar lastChar = text.at(mCursor.position() - 1 - block.position());

if (lastChar == QLatin1Char(':')
            || lastChar == QLatin1Char(';')
            || lastChar == QLatin1Char('!')
            || lastChar == QLatin1Char('?')
            || lastChar == QLatin1Char('%')) {
            const int pos = mCursor.position() - 2 - block.position();
            if (pos >= 0) {
                const QChar previousChar = text.at(pos);
                if (previousChar.isSpace()) {
                    QTextCursor cursor(mCursor);
                    cursor.setPosition(pos);
                    cursor.setPosition(pos + 1, QTextCursor::KeepAnchor);
                    cursor.deleteChar();
                    mCursor.insertText(mNonBreakingSpace);
                }
            }
        } else {
            //°C (degres)
            const QChar previousChar = text.at(mCursor.position() - 2 - block.position());
            if (lastChar == QLatin1Char('C') && previousChar == QChar(0x000B0)) {
                const int pos = mCursor.position() - 3 - block.position();
                if (pos >= 0) {
                    const QChar previousChar = text.at(pos);
                    if (previousChar.isSpace()) {
                        QTextCursor cursor(mCursor);
                        cursor.setPosition(pos);
                        cursor.setPosition(pos + 1, QTextCursor::KeepAnchor);
                        cursor.deleteChar();
                        mCursor.insertText(mNonBreakingSpace);
                    }
                }
            }
        }
    }
}

bool AutoCorrection::autoBoldUnderline()
{
    if (!mAutoBoldUnderline) {
        return false;
    }
    const QString trimmed = mWord.trimmed();

if (trimmed.length() < 3) {
        return false;
    }

const QChar trimmedFirstChar(trimmed.at(0));
    const QChar trimmedLastChar(trimmed.at(trimmed.length() - 1));
    const bool underline = (trimmedFirstChar == QLatin1Char('_') && trimmedLastChar == QLatin1Char('_'));
    const bool bold = (trimmedFirstChar == QLatin1Char('*') && trimmedLastChar == QLatin1Char('*'));
    const bool strikeOut = (trimmedFirstChar == QLatin1Char('-') && trimmedLastChar == QLatin1Char('-'));
    if (underline || bold || strikeOut) {
        const int startPos = mCursor.selectionStart();
        const QString replacement = trimmed.mid(1, trimmed.length() - 2);
        bool foundLetterNumber = false;

QString::ConstIterator constIter = replacement.constBegin();
        while (constIter != replacement.constEnd()) {
            if (constIter->isLetterOrNumber()) {
                foundLetterNumber = true;
                break;
            }
            ++constIter;
        }

// if no letter/number found, don't apply autocorrection like in OOo 2.x
        if (!foundLetterNumber) {
            return false;
        }
        mCursor.setPosition(startPos);
        mCursor.setPosition(startPos + trimmed.length(), QTextCursor::KeepAnchor);
        mCursor.insertText(replacement);
        mCursor.setPosition(startPos);
        mCursor.setPosition(startPos + replacement.length(), QTextCursor::KeepAnchor);

QTextCharFormat format;
        format.setFontUnderline(underline ? true : mCursor.charFormat().fontUnderline());
        format.setFontWeight(bold ? QFont::Bold : mCursor.charFormat().fontWeight());
        format.setFontStrikeOut(strikeOut ? true : mCursor.charFormat().fontStrikeOut());
        mCursor.mergeCharFormat(format);

// to avoid the selection being replaced by mWord
        mWord = mCursor.selectedText();
        return true;
    } else {
        return false;
    }

return true;
}

QColor AutoCorrection::linkColor()
{
    if (mLinkColor.isValid()) {
        return mLinkColor;
    }
    mLinkColor = KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::LinkText).color();
    return mLinkColor;
}

bool AutoCorrection::autoFormatURLs()
{
    if (!mAutoFormatUrl) {
        return false;
    }

const QString link = autoDetectURL(mWord);
    if (link.isNull()) {
        return false;
    }

const QString trimmed = mWord.trimmed();
    const int startPos = mCursor.selectionStart();
    mCursor.setPosition(startPos);
    mCursor.setPosition(startPos + trimmed.length(), QTextCursor::KeepAnchor);

QTextCharFormat format;
    format.setAnchorHref(link);
    format.setFontItalic(true);
    format.setAnchor(true);
    format.setUnderlineStyle(QTextCharFormat::SingleUnderline);
    format.setUnderlineColor(linkColor());
    format.setForeground(linkColor());
    mCursor.mergeCharFormat(format);

mWord = mCursor.selectedText();
    return true;
}

QString AutoCorrection::autoDetectURL(const QString &_word) const
{
    QString word = _word;

/* this method is ported from lib/kotext/KoAutoFormat.cpp KoAutoFormat::doAutoDetectUrl
     * from Calligra 1.x branch */
    // qCDebug(PIMCOMMON_LOG) <<"link:" << word;

bool secure = false;
    int link_type = 0;
    int pos = word.indexOf(QStringLiteral("http://"));
    int tmp_pos = word.indexOf(QStringLiteral("https://"));

if (tmp_pos != -1 && pos == -1) {
        secure = true;
    }

if (tmp_pos < pos && tmp_pos != -1) {
        pos = tmp_pos;
    }

tmp_pos = word.indexOf(QStringLiteral("mailto:/"));
    if ((tmp_pos < pos || pos == -1) && tmp_pos != -1) {
        pos = tmp_pos;
    }
    tmp_pos = word.indexOf(QStringLiteral("ftp://"));
    const int secureftp = word.indexOf(QStringLiteral("ftps://"));
    if (secureftp != -1 && tmp_pos == -1) {
        secure = true;
    }

if ((tmp_pos < pos || pos == -1) && tmp_pos != -1) {
        pos = tmp_pos;
    }
    tmp_pos = word.indexOf(QStringLiteral("ftp."));

if ((tmp_pos < pos || pos == -1) && tmp_pos != -1) {
        pos = tmp_pos;
        link_type = 3;
    }
    tmp_pos = word.indexOf(QStringLiteral("file:/"));
    if ((tmp_pos < pos || pos == -1) && tmp_pos != -1) {
        pos = tmp_pos;
    }
    tmp_pos = word.indexOf(QStringLiteral("news:"));
    if ((tmp_pos < pos || pos == -1) && tmp_pos != -1) {
        pos = tmp_pos;
    }
    tmp_pos = word.indexOf(QStringLiteral("www."));

if ((tmp_pos < pos || pos == -1) && tmp_pos != -1 && word.indexOf(QLatin1Char('.'), tmp_pos + 4) != -1) {
        pos = tmp_pos;
        link_type = 2;
    }
    tmp_pos = word.indexOf(QLatin1Char('@'));
    if (pos == -1 && tmp_pos != -1) {
        pos = tmp_pos - 1;
        QChar c;

while (pos >= 0) {
            c = word.at(pos);
            if (c.isPunct() && c != QLatin1Char('.') && c != QLatin1Char('_')) {
                break;
            } else {
                --pos;
            }
        }
        if (pos == tmp_pos - 1) { // not a valid address
            pos = -1;
        } else {
            ++pos;
        }
        link_type = 1;
    }

if (pos != -1) {
        // A URL inside e.g. quotes (like "http://www.calligra.org" with the quotes) shouldn't include the quote in the URL.
        while (!word.at(word.length() - 1).isLetter() && !word.at(word.length() - 1).isDigit() && word.at(word.length() - 1) != QLatin1Char('/')) {
            word.truncate(word.length() - 1);
        }
        word.remove(0, pos);
        QString newWord = word;

switch (link_type) {
        case 1:
            newWord = QLatin1String("mailto:") + word;
            break;
        case 2:
            newWord = (secure ? QStringLiteral("https://") : QStringLiteral("http://")) + word;
            break;
        case 3:
            newWord = (secure ? QStringLiteral("ftps://") : QStringLiteral("ftp://")) + word;
            break;
        }
        //qCDebug(PIMCOMMON_LOG) <<"newWord:" << newWord;
        return newWord;
    }

return QString();
}

void AutoCorrection::fixTwoUppercaseChars()
{
    if (!mFixTwoUppercaseChars) {
        return;
    }
    if (mWord.length() <= 2) {
        return;
    }

if (mTwoUpperLetterExceptions.contains(mWord.trimmed())) {
        return;
    }

const QChar firstChar = mWord.at(0);
    const QChar secondChar = mWord.at(1);

if (secondChar.isUpper() && firstChar.isUpper()) {
        const QChar thirdChar = mWord.at(2);

if (thirdChar.isLower()) {
            mWord.replace(1, 1, secondChar.toLower());
        }
    }
}

//Return true if we can add space
bool AutoCorrection::singleSpaces()
{
    if (!mSingleSpaces) {
        return true;
    }
    if (!mCursor.atBlockStart()) {
        // then when the prev char is also a space, don't insert one.
        const QTextBlock block = mCursor.block();
        const QString text = block.text();
        if (text.at(mCursor.position() - 1 - block.position()) == QLatin1Char(' ')) {
            return false;
        }
    }
    return true;
}

void AutoCorrection::capitalizeWeekDays()
{
    if (!mCapitalizeWeekDays) {
        return;
    }

const QString trimmed = mWord.trimmed();
    for (const QString &name : qAsConst(mCacheNameOfDays)) {
        if (trimmed == name) {
            const int pos = mWord.indexOf(name);
            mWord.replace(pos, 1, name.at(0).toUpper());
            return;
        }
    }
}

bool AutoCorrection::excludeToUppercase(const QString &word) const
{
    if (word.startsWith(QLatin1String("http://"))
        || word.startsWith(QLatin1String("www."))
        || word.startsWith(QLatin1String("mailto:"))
        || word.startsWith(QLatin1String("ftp://"))
        || word.startsWith(QLatin1String("https://"))
        || word.startsWith(QLatin1String("ftps://"))) {
        return true;
    }
    return false;
}

void AutoCorrection::setNonBreakingSpace(QChar nonBreakingSpace)
{
    mNonBreakingSpace = nonBreakingSpace;
}

void AutoCorrection::uppercaseFirstCharOfSentence()
{
    if (!mUppercaseFirstCharOfSentence) {
        return;
    }

int startPos = mCursor.selectionStart();
    QTextBlock block = mCursor.block();

mCursor.setPosition(block.position());
    mCursor.setPosition(startPos, QTextCursor::KeepAnchor);

int position = mCursor.selectionEnd();

const QString text = mCursor.selectedText();

if (text.isEmpty()) {// start of a paragraph
        if (!excludeToUppercase(mWord)) {
            mWord.replace(0, 1, mWord.at(0).toUpper());
        }
    } else {
        QString::ConstIterator constIter = text.constEnd();
        --constIter;

while (constIter != text.constBegin()) {
            while (constIter != text.begin() && constIter->isSpace()) {
                --constIter;
                --position;
            }

if (constIter != text.constBegin() && (*constIter == QLatin1Char('.') || *constIter == QLatin1Char('!') || *constIter == QLatin1Char('?'))) {
                constIter--;
                while (constIter != text.constBegin() && !(constIter->isLetter())) {
                    --position;
                    --constIter;
                }
                selectPreviousWord(mCursor, --position);
                const QString prevWord = mCursor.selectedText();

// search for exception
                if (mUpperCaseExceptions.contains(prevWord.trimmed())) {
                    break;
                }
                if (excludeToUppercase(mWord)) {
                    break;
                }

mWord.replace(0, 1, mWord.at(0).toUpper());
                break;
            } else {
                break;
            }
        }
    }

mCursor.setPosition(startPos);
    mCursor.setPosition(startPos + mWord.length(), QTextCursor::KeepAnchor);
}

bool AutoCorrection::autoFractions()
{
    if (!mAutoFractions) {
        return false;
    }

const QString trimmed = mWord.trimmed();
    if (trimmed.length() > 3) {
        const QChar x = trimmed.at(3);
        const uchar xunicode = x.unicode();
        if (!(xunicode == '.' || xunicode == ',' || xunicode == '?' || xunicode == '!'
              || xunicode == ':' || xunicode == ';')) {
            return false;
        }
    } else if (trimmed.length() < 3) {
        return false;
    }

if (trimmed.startsWith(QLatin1String("1/2"))) {
        mWord.replace(0, 3, QStringLiteral("½"));
    } else if (trimmed.startsWith(QLatin1String("1/4"))) {
        mWord.replace(0, 3, QStringLiteral("¼"));
    } else if (trimmed.startsWith(QLatin1String("3/4"))) {
        mWord.replace(0, 3, QStringLiteral("¾"));
    } else {
        return false;
    }

return true;
}

int AutoCorrection::advancedAutocorrect()
{
    if (!mAdvancedAutocorrect) {
        return -1;
    }
    if (mAutocorrectEntries.isEmpty()) {
        return -1;
    }

const QString trimmedWord = mWord.trimmed();
    if (trimmedWord.isEmpty()) {
        return -1;
    }

QString actualWord = trimmedWord;

const int actualWordLength(actualWord.length());
    if (actualWordLength < mMinFindStringLenght) {
        return -1;
    }
    if (actualWordLength > mMaxFindStringLenght) {
        return -1;
    }

const int startPos = mCursor.selectionStart();
    const int length = mWord.length();
    // If the last char is punctuation, drop it for now
    bool hasPunctuation = false;
    const QChar lastChar = actualWord.at(actualWord.length() - 1);
    const ushort charUnicode = lastChar.unicode();
    if (charUnicode == '.' || charUnicode == ',' || charUnicode == '?'
        || charUnicode == '!' || charUnicode == ':' || charUnicode == ';') {
        hasPunctuation = true;
        actualWord.chop(1);
    }

QString actualWordWithFirstUpperCase = actualWord;
    actualWordWithFirstUpperCase[0] = actualWordWithFirstUpperCase[0].toUpper();
    QHashIterator<QString, QString> i(mAutocorrectEntries);
    while (i.hasNext()) {
        i.next();
        if (i.key().length() > actualWordLength) {
            continue;
        }
        if (actualWord.endsWith(i.key())
            || actualWord.toLower().endsWith(i.key())
            || actualWordWithFirstUpperCase.endsWith(i.key())) {
            int pos = mWord.lastIndexOf(i.key());
            if (pos == -1) {
                pos = actualWord.toLower().lastIndexOf(i.key());
            }
            if (pos == -1) {
                pos = actualWordWithFirstUpperCase.lastIndexOf(i.key());
            }
            QString replacement = i.value();

// Keep capitalized words capitalized.
            // (Necessary to make sure the first letters match???)
            const QChar actualWordFirstChar = actualWord.at(pos);
            const QChar replacementFirstChar = replacement[0];
            if (actualWordFirstChar.isUpper() && replacementFirstChar.isLower()) {
                replacement[0] = replacementFirstChar.toUpper();
            } else if (actualWordFirstChar.isLower() && replacementFirstChar.isUpper()) {
                replacement[0] = replacementFirstChar.toLower();
            }

// If a punctuation mark was on the end originally, add it back on
            if (hasPunctuation) {
                replacement.append(lastChar);
            }

mWord.replace(pos, pos + trimmedWord.length(), replacement);

// We do replacement here, since the length of new word might be different from length of
            // the old world. Length difference might affect other type of autocorrection
            mCursor.setPosition(startPos);
            mCursor.setPosition(startPos + length, QTextCursor::KeepAnchor);
            mCursor.insertText(mWord);
            mCursor.setPosition(startPos); // also restore the selection
            const int newPosition = startPos + mWord.length();
            mCursor.setPosition(newPosition, QTextCursor::KeepAnchor);
            return newPosition;
        }
    }
    return -1;
}

void AutoCorrection::replaceTypographicQuotes()
{
    /* this method is ported from lib/kotext/KoAutoFormat.cpp KoAutoFormat::doTypographicQuotes
     * from Calligra 1.x branch */

if (!(mReplaceDoubleQuotes && mWord.contains(QLatin1Char('"')))
        && !(mReplaceSingleQuotes && mWord.contains(QLatin1Char('\'')))) {
        return;
    }

const bool addNonBreakingSpace = (isFrenchLanguage() && isAddNonBreakingSpace());

// Need to determine if we want a starting or ending quote.
    // we use a starting quote in three cases:
    //  1. if the previous character is a space
    //  2. if the previous character is some kind of opening punctuation (e.g., "(", "[", or "{")
    //     a. and the character before that is not an opening quote (so that we get quotations of single characters
    //        right)
    //  3. if the previous character is an opening quote (so that we get nested quotations right)
    //     a. and the character before that is not an opening quote (so that we get quotations of single characters
    //         right)
    //     b. and the previous quote of a different kind (so that we get empty quotations right)

bool ending = true;
    for (int i = mWord.length(); i > 1; --i) {
        const QChar c = mWord.at(i - 1);
        if (c == QLatin1Char('"') || c == QLatin1Char('\'')) {
            const bool doubleQuotes = (c == QLatin1Char('"'));
            if (i > 2) {
                QChar::Category c1 = mWord.at(i - 1).category();

// case 1 and 2
                if (c1 == QChar::Separator_Space || c1 == QChar::Separator_Line || c1 == QChar::Separator_Paragraph
                    || c1 == QChar::Punctuation_Open || c1 == QChar::Other_Control) {
                    ending = false;
                }

// case 3
                if (c1 == QChar::Punctuation_InitialQuote) {
                    QChar openingQuote;

if (doubleQuotes) {
                        openingQuote = mTypographicDoubleQuotes.begin;
                    } else {
                        openingQuote = mTypographicSingleQuotes.begin;
                    }

// case 3b
                    if (mWord.at(i - 1) != openingQuote) {
                        ending = false;
                    }
                }
            }
            // case 2a and 3a
            if (i > 3 && !ending) {
                const QChar::Category c2 = (mWord.at(i - 2)).category();
                ending = (c2 == QChar::Punctuation_InitialQuote);
            }

if (doubleQuotes && mReplaceDoubleQuotes) {
                if (ending) {
                    if (addNonBreakingSpace) {
                        mWord.replace(i - 1, 2, QString(mNonBreakingSpace + mTypographicDoubleQuotes.end));
                    } else {
                        mWord[i - 1] = mTypographicDoubleQuotes.end;
                    }
                } else {
                    if (addNonBreakingSpace) {
                        mWord.replace(i - 1, 2, QString(mNonBreakingSpace + mTypographicDoubleQuotes.begin));
                    } else {
                        mWord[i - 1] = mTypographicDoubleQuotes.begin;
                    }
                }
            } else if (mReplaceSingleQuotes) {
                if (ending) {
                    if (addNonBreakingSpace) {
                        mWord.replace(i - 1, 2, QString(mNonBreakingSpace + mTypographicSingleQuotes.end));
                    } else {
                        mWord[i - 1] = mTypographicSingleQuotes.end;
                    }
                } else {
                    if (addNonBreakingSpace) {
                        mWord.replace(i - 1, 2, QString(mNonBreakingSpace + mTypographicSingleQuotes.begin));
                    } else {
                        mWord[i - 1] = mTypographicSingleQuotes.begin;
                    }
                }
            }
        }
    }

// first character
    if (mWord.at(0) == QLatin1Char('"') && mReplaceDoubleQuotes) {
        mWord[0] = mTypographicDoubleQuotes.begin;
        if (addNonBreakingSpace) {
            mWord.insert(1, mNonBreakingSpace);
        }
    } else if (mWord.at(0) == QLatin1Char('\'') && mReplaceSingleQuotes) {
        mWord[0] = mTypographicSingleQuotes.begin;
        if (addNonBreakingSpace) {
            mWord.insert(1, mNonBreakingSpace);
        }
    }
}

void AutoCorrection::readAutoCorrectionXmlFile(bool forceGlobal)
{
    QString kdelang = QStringLiteral("en_US");
    const QStringList lst = QLocale::system().uiLanguages();
    if (!lst.isEmpty()) {
        kdelang = lst.at(0);
        if (kdelang == QLatin1String("C")) {
            kdelang = QStringLiteral("en_US");
        }
    }
    kdelang.remove(QRegularExpression(QStringLiteral("@.*")));

mUpperCaseExceptions.clear();
    mAutocorrectEntries.clear();
    mTwoUpperLetterExceptions.clear();
    mSuperScriptEntries.clear();

QString localFileName;
    //Look at local file:
    if (!forceGlobal) {
        if (!mAutoCorrectLang.isEmpty()) {
            localFileName = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/custom-") + mAutoCorrectLang + QLatin1String(".xml"));
        } else {
            if (!kdelang.isEmpty()) {
                localFileName = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/custom-") + kdelang + QLatin1String(".xml"));
            }
            if (localFileName.isEmpty() && kdelang.contains(QLatin1Char('_'))) {
                kdelang.remove(QRegularExpression(QStringLiteral("_.*")));
                localFileName = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/custom-") + kdelang + QLatin1String(".xml"));
            }
        }
    }
    QString fname;
    //Load Global directly
    if (!mAutoCorrectLang.isEmpty()) {
        if (mAutoCorrectLang == QLatin1String("en_US")) {
            fname = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/autocorrect.xml"));
        } else {
            fname = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/") + mAutoCorrectLang + QLatin1String(".xml"));
        }
    } else {
        if (fname.isEmpty() && !kdelang.isEmpty()) {
            fname = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/") + kdelang + QLatin1String(".xml"));
        }
        if (fname.isEmpty() && kdelang.contains(QLatin1Char('_'))) {
            kdelang.remove(QRegularExpression(QStringLiteral("_.*")));
            fname = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/") + kdelang + QLatin1String(".xml"));
        }
    }
    if (fname.isEmpty()) {
        fname = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("autocorrect/autocorrect.xml"));
    }

if (mAutoCorrectLang.isEmpty()) {
        mAutoCorrectLang = kdelang;
    }
    //qCDebug(PIMCOMMON_LOG)<<" fname :"<<fname;
    //qCDebug(PIMCOMMON_LOG)<<" LocalFile:"<<LocalFile;

if (localFileName.isEmpty()) {
        loadGlobalFileName(fname, forceGlobal);
    } else {
        loadLocalFileName(localFileName, fname);
    }
}

void AutoCorrection::loadGlobalFileName(const QString &fname, bool forceGlobal)
{
    if (fname.isEmpty()) {
        mTypographicSingleQuotes = typographicDefaultSingleQuotes();
        mTypographicDoubleQuotes = typographicDefaultDoubleQuotes();
    } else {
        ImportKMailAutocorrection import;
        if (import.import(fname, ImportAbstractAutocorrection::All)) {
            mUpperCaseExceptions = import.upperCaseExceptions();
            mTwoUpperLetterExceptions = import.twoUpperLetterExceptions();
            mAutocorrectEntries = import.autocorrectEntries();
            mTypographicSingleQuotes = import.typographicSingleQuotes();
            mTypographicDoubleQuotes = import.typographicDoubleQuotes();
            mSuperScriptEntries = import.superScriptEntries();
            if (forceGlobal) {
                mTypographicSingleQuotes = typographicDefaultSingleQuotes();
                mTypographicDoubleQuotes = typographicDefaultDoubleQuotes();
            }
            mMaxFindStringLenght = import.maxFindStringLenght();
            mMinFindStringLenght = import.minFindStringLenght();
        }
    }
}

void AutoCorrection::loadLocalFileName(const QString &localFileName, const QString &fname)
{
    ImportKMailAutocorrection import;
    if (import.import(localFileName, ImportAbstractAutocorrection::All)) {
        mUpperCaseExceptions = import.upperCaseExceptions();
        mTwoUpperLetterExceptions = import.twoUpperLetterExceptions();
        mAutocorrectEntries = import.autocorrectEntries();
        mTypographicSingleQuotes = import.typographicSingleQuotes();
        mTypographicDoubleQuotes = import.typographicDoubleQuotes();
        //Don't import it in local
        //mSuperScriptEntries = import.superScriptEntries();
    }
    if (!fname.isEmpty() && import.import(fname, ImportAbstractAutocorrection::SuperScript)) {
        mSuperScriptEntries = import.superScriptEntries();
    }
    mMaxFindStringLenght = import.maxFindStringLenght();
    mMinFindStringLenght = import.minFindStringLenght();
}

void AutoCorrection::writeAutoCorrectionXmlFile(const QString &filename)
{
    const QString fname = filename.isEmpty() ? QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1String("/autocorrect/custom-")
                          + (mAutoCorrectLang == QLatin1String("en_US") ? QStringLiteral("autocorrect") : mAutoCorrectLang) + QLatin1String(".xml") : filename;
    QFileInfo fileInfo(fname);
    QDir().mkpath(fileInfo.absolutePath());
    QFile file(fname);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        qCDebug(PIMCOMMON_LOG) << "We can't save in file :" << fname;
        return;
    }

QXmlStreamWriter streamWriter(&file);

streamWriter.setAutoFormatting(true);
    streamWriter.setAutoFormattingIndent(2);
    streamWriter.writeStartDocument();

streamWriter.writeDTD(QStringLiteral("<!DOCTYPE autocorrection>"));

streamWriter.writeStartElement(QStringLiteral("Word"));

streamWriter.writeStartElement(QStringLiteral("items"));
    QHashIterator<QString, QString> i(mAutocorrectEntries);
    while (i.hasNext()) {
        i.next();
        streamWriter.writeStartElement(QStringLiteral("item"));
        streamWriter.writeAttribute(QStringLiteral("find"), i.key());
        streamWriter.writeAttribute(QStringLiteral("replace"), i.value());
        streamWriter.writeEndElement();
    }
    streamWriter.writeEndElement();

streamWriter.writeStartElement(QStringLiteral("UpperCaseExceptions"));
    QSet<QString>::const_iterator upper = mUpperCaseExceptions.constBegin();
    while (upper != mUpperCaseExceptions.constEnd()) {
        streamWriter.writeStartElement(QStringLiteral("word"));
        streamWriter.writeAttribute(QStringLiteral("exception"), *upper);
        ++upper;
        streamWriter.writeEndElement();
    }
    streamWriter.writeEndElement();

streamWriter.writeStartElement(QStringLiteral("TwoUpperLetterExceptions"));
    QSet<QString>::const_iterator twoUpper = mTwoUpperLetterExceptions.constBegin();
    while (twoUpper != mTwoUpperLetterExceptions.constEnd()) {
        streamWriter.writeStartElement(QStringLiteral("word"));
        streamWriter.writeAttribute(QStringLiteral("exception"), *twoUpper);
        ++twoUpper;
        streamWriter.writeEndElement();
    }
    streamWriter.writeEndElement();

streamWriter.writeStartElement(QStringLiteral("DoubleQuote"));
    streamWriter.writeStartElement(QStringLiteral("doublequote"));
    streamWriter.writeAttribute(QStringLiteral("begin"), mTypographicDoubleQuotes.begin);
    streamWriter.writeAttribute(QStringLiteral("end"), mTypographicDoubleQuotes.end);
    streamWriter.writeEndElement();
    streamWriter.writeEndElement();

streamWriter.writeStartElement(QStringLiteral("SimpleQuote"));
    streamWriter.writeStartElement(QStringLiteral("simplequote"));
    streamWriter.writeAttribute(QStringLiteral("begin"), mTypographicSingleQuotes.begin);
    streamWriter.writeAttribute(QStringLiteral("end"), mTypographicSingleQuotes.end);
    streamWriter.writeEndElement();
    streamWriter.writeEndElement();

streamWriter.writeEndDocument();
}

QString AutoCorrection::language() const
{
    return mAutoCorrectLang;
}

AutoCorrection::TypographicQuotes AutoCorrection::typographicSingleQuotes() const
{
    return mTypographicSingleQuotes;
}

AutoCorrection::TypographicQuotes AutoCorrection::typographicDoubleQuotes() const
{
    return mTypographicDoubleQuotes;
}

void AutoCorrection::setLanguage(const QString &lang, bool forceGlobal)
{
    if (mAutoCorrectLang != lang || forceGlobal) {
        mAutoCorrectLang = lang;
        //Re-read xml file
        readAutoCorrectionXmlFile(forceGlobal);
    }
}

void AutoCorrection::setEnabledAutoCorrection(bool b)
{
    mEnabled = b;
}

void AutoCorrection::setUppercaseFirstCharOfSentence(bool b)
{
    mUppercaseFirstCharOfSentence = b;
}

void AutoCorrection::setFixTwoUppercaseChars(bool b)
{
    mFixTwoUppercaseChars = b;
}

void AutoCorrection::setSingleSpaces(bool b)
{
    mSingleSpaces = b;
}

void AutoCorrection::setAutoFractions(bool b)
{
    mAutoFractions = b;
}

void AutoCorrection::setCapitalizeWeekDays(bool b)
{
    mCapitalizeWeekDays = b;
}

void AutoCorrection::setReplaceDoubleQuotes(bool b)
{
    mReplaceDoubleQuotes = b;
}

void AutoCorrection::setReplaceSingleQuotes(bool b)
{
    mReplaceSingleQuotes = b;
}

void AutoCorrection::setAdvancedAutocorrect(bool b)
{
    mAdvancedAutocorrect = b;
}

void AutoCorrection::setTypographicSingleQuotes(AutoCorrection::TypographicQuotes singleQuote)
{
    mTypographicSingleQuotes = singleQuote;
}

void AutoCorrection::setTypographicDoubleQuotes(AutoCorrection::TypographicQuotes doubleQuote)
{
    mTypographicDoubleQuotes = doubleQuote;
}

bool AutoCorrection::isFrenchLanguage() const
{
    return mAutoCorrectLang == QLatin1String("FR_fr") || mAutoCorrectLang == QLatin1String("fr");
}
07070100000012000081A40000000200000002000000015CDAA394000016DE000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrection.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AutoCorrection_H
#define AutoCorrection_H

#include "pimcommon_export.h"
#include <QTextCursor>
#include <QHash>
#include <QSet>

namespace PimCommon {
class PIMCOMMON_EXPORT AutoCorrection
{
public:
    struct TypographicQuotes {
        QChar begin;
        QChar end;
    };

explicit AutoCorrection();
    ~AutoCorrection();

void setLanguage(const QString &lang, bool forceGlobal = false);
    void setEnabledAutoCorrection(bool b);
    void setUppercaseFirstCharOfSentence(bool b);
    void setFixTwoUppercaseChars(bool b);
    void setSingleSpaces(bool b);
    void setAutoFractions(bool b);
    void setCapitalizeWeekDays(bool b);
    void setReplaceDoubleQuotes(bool b);
    void setReplaceSingleQuotes(bool b);
    void setAdvancedAutocorrect(bool b);
    void setTypographicSingleQuotes(TypographicQuotes singleQuote);
    void setTypographicDoubleQuotes(TypographicQuotes doubleQuote);
    void setUpperCaseExceptions(const QSet<QString> &exceptions);
    void setTwoUpperLetterExceptions(const QSet<QString> &exceptions);
    void setAutocorrectEntries(const QHash<QString, QString> &entries);
    void setAutoFormatUrl(bool b);
    void setAutoBoldUnderline(bool b);
    void setSuperScript(bool b);
    void setAddNonBreakingSpace(bool b);

Q_REQUIRED_RESULT bool isEnabledAutoCorrection() const;
    Q_REQUIRED_RESULT bool isUppercaseFirstCharOfSentence() const;
    Q_REQUIRED_RESULT bool isFixTwoUppercaseChars() const;
    Q_REQUIRED_RESULT bool isSingleSpaces() const;
    Q_REQUIRED_RESULT bool isAutoFractions() const;
    Q_REQUIRED_RESULT bool isCapitalizeWeekDays() const;
    Q_REQUIRED_RESULT bool isReplaceDoubleQuotes() const;
    Q_REQUIRED_RESULT bool isReplaceSingleQuotes() const;
    Q_REQUIRED_RESULT bool isAdvancedAutocorrect() const;
    Q_REQUIRED_RESULT bool isAutoFormatUrl() const;
    Q_REQUIRED_RESULT bool isAutoBoldUnderline() const;
    Q_REQUIRED_RESULT bool isSuperScript() const;

Q_REQUIRED_RESULT bool isAddNonBreakingSpace() const;

Q_REQUIRED_RESULT QString language() const;
    Q_REQUIRED_RESULT TypographicQuotes typographicSingleQuotes() const;
    Q_REQUIRED_RESULT TypographicQuotes typographicDoubleQuotes() const;
    Q_REQUIRED_RESULT TypographicQuotes typographicDefaultSingleQuotes() const;
    Q_REQUIRED_RESULT TypographicQuotes typographicDefaultDoubleQuotes() const;
    Q_REQUIRED_RESULT QSet<QString> upperCaseExceptions() const;
    Q_REQUIRED_RESULT QSet<QString> twoUpperLetterExceptions() const;
    Q_REQUIRED_RESULT QHash<QString, QString> autocorrectEntries() const;

Q_REQUIRED_RESULT bool autocorrect(bool htmlMode, QTextDocument &document, int &position);
    void writeConfig();

Q_REQUIRED_RESULT bool addAutoCorrect(const QString &currentWord, const QString &replaceWord);

void writeAutoCorrectionXmlFile(const QString &filename = QString());

void setNonBreakingSpace(QChar nonBreakingSpace);

void loadGlobalFileName(const QString &fname, bool forceGlobal);
    void loadLocalFileName(const QString &localFileName, const QString &fname);
private:
    bool isFrenchLanguage() const;
    void readConfig();

void fixTwoUppercaseChars();
    bool singleSpaces();
    void capitalizeWeekDays();
    bool autoFractions();
    void uppercaseFirstCharOfSentence();
    int advancedAutocorrect();
    void replaceTypographicQuotes();
    void superscriptAppendix();
    void addNonBreakingSpace();

void selectPreviousWord(QTextCursor &cursor, int cursorPosition);
    void selectStringOnMaximumSearchString(QTextCursor &cursor, int cursorPosition);

bool autoFormatURLs();
    bool autoBoldUnderline();

QString autoDetectURL(const QString &_word) const;
    void readAutoCorrectionXmlFile(bool forceGlobal = false);
    bool excludeToUppercase(const QString &word) const;
    QColor linkColor();

bool mSingleSpaces; // suppress double spaces.
    bool mUppercaseFirstCharOfSentence; // convert first letter of a sentence automaticall to uppercase
    bool mFixTwoUppercaseChars;  // convert two uppercase characters to one upper and one lowercase.
    bool mAutoFractions; // replace 1/2 with ½
    bool mCapitalizeWeekDays;
    bool mAdvancedAutocorrect; // autocorrection from a list of entries

bool mReplaceDoubleQuotes;  // replace double quotes with typographical quotes
    bool mReplaceSingleQuotes;  // replace single quotes with typographical quotes

bool mAutoFormatUrl;
    bool mAutoBoldUnderline;
    bool mEnabled;
    bool mSuperScriptAppendix;

bool mAddNonBreakingSpace;
    int mMaxFindStringLenght;
    int mMinFindStringLenght;
    QString mWord;
    QTextCursor mCursor;
    QChar mNonBreakingSpace;

QString mAutoCorrectLang;
    QStringList mCacheNameOfDays;
    QSet<QString> mUpperCaseExceptions;
    QSet<QString> mTwoUpperLetterExceptions;
    QHash<QString, QString> mAutocorrectEntries;
    QHash<QString, QString> mSuperScriptEntries;
    TypographicQuotes mTypographicSingleQuotes;
    TypographicQuotes mTypographicDoubleQuotes;
    QColor mLinkColor;
};
}

#endif // AutoCorrection_H
07070100000013000081A40000000200000002000000015CDAA39400000BC7000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectionlanguage.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrectionlanguage.h"
#include <QLocale>
#include <QSet>

using namespace PimCommon;

static bool stripCountryCode(QString *languageCode)
{
    const int idx = languageCode->indexOf(QLatin1String("_"));
    if (idx != -1) {
        *languageCode = languageCode->left(idx);
        return true;
    }
    return false;
}

AutoCorrectionLanguage::AutoCorrectionLanguage(QWidget *parent)
    : QComboBox(parent)
{
    QLocale cLocale(QLocale::C);
    QSet<QString> insertedLanguages;
    const QList<QLocale> allLocales = QLocale::matchingLocales(QLocale::AnyLanguage, QLocale::AnyScript, QLocale::AnyCountry);
    for (const QLocale &lang : allLocales) {
        QString languageCode = lang.name();
        if (lang != cLocale) {
            const QString nativeName = lang.nativeLanguageName();
            // For some languages the native name might be empty.
            // In this case use the non native language name as fallback.
            // See: QTBUG-51323
            QString languageName = nativeName.isEmpty() ? QLocale::languageToString(lang.language()) : nativeName;
            languageName = languageName.toLower();
            if (!insertedLanguages.contains(languageName)) {
                addItem(languageName, languageCode);
                insertedLanguages << languageName;
            } else if (stripCountryCode(&languageCode)) {
                if (!insertedLanguages.contains(languageName)) {
                    addItem(languageName, languageCode);
                    insertedLanguages << languageName;
                }
            }
        }
    }

QString defaultLang;
    if (!QLocale::system().uiLanguages().isEmpty()) {
        defaultLang = QLocale::system().uiLanguages().at(0);
        if (defaultLang == QLatin1String("C")) {
            defaultLang = QStringLiteral("en_US");
        }
    }
    const int index = findData(defaultLang);
    setCurrentIndex(index);
    model()->sort(0);
}

AutoCorrectionLanguage::~AutoCorrectionLanguage()
{
}

QString AutoCorrectionLanguage::language() const
{
    return itemData(currentIndex()).toString();
}

void AutoCorrectionLanguage::setLanguage(const QString &language)
{
    const int index = findData(language);
    setCurrentIndex(index);
}
07070100000014000081A40000000200000002000000015CDAA39400000558000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectionlanguage.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AutoCorrectionLanguage_H
#define AutoCorrectionLanguage_H

#include <QComboBox>
#include "pimcommon_export.h"

namespace PimCommon {
class PIMCOMMON_EXPORT AutoCorrectionLanguage : public QComboBox
{
public:
    explicit AutoCorrectionLanguage(QWidget *parent);
    ~AutoCorrectionLanguage();

/**
    * @brief language
    * @return specified language
    */
    Q_REQUIRED_RESULT QString language() const;

/**
     * @brief setLanguage
     * @param language define specified language
     */
    void setLanguage(const QString &language);
};
}
#endif // AutoCorrectionLanguage_H
07070100000015000081A40000000200000002000000015CDAA394000004B8000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectionlistwidget.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrectionlistwidget.h"

#include <QKeyEvent>

using namespace PimCommon;

AutoCorrectionListWidget::AutoCorrectionListWidget(QWidget *parent)
    : QListWidget(parent)
{
}

AutoCorrectionListWidget::~AutoCorrectionListWidget()
{
}

void AutoCorrectionListWidget::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_Delete) {
        Q_EMIT deleteSelectedItems();
    }
    QListWidget::keyPressEvent(event);
}
07070100000016000081A40000000200000002000000015CDAA394000004C3000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectionlistwidget.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AutoCorrectionListWidget_H
#define AutoCorrectionListWidget_H

#include <QListWidget>

namespace PimCommon {
class AutoCorrectionListWidget : public QListWidget
{
    Q_OBJECT
public:
    explicit AutoCorrectionListWidget(QWidget *parent = nullptr);
    ~AutoCorrectionListWidget() override;

protected:
    void keyPressEvent(QKeyEvent *event) override;

Q_SIGNALS:
    void deleteSelectedItems();
};
}

#endif // AutoCorrectionListWidget_H
07070100000017000081A40000000200000002000000015CDAA394000004B8000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectiontreewidget.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrectiontreewidget.h"

#include <QKeyEvent>

using namespace PimCommon;

AutoCorrectionTreeWidget::AutoCorrectionTreeWidget(QWidget *parent)
    : QTreeWidget(parent)
{
}

AutoCorrectionTreeWidget::~AutoCorrectionTreeWidget()
{
}

void AutoCorrectionTreeWidget::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_Delete) {
        Q_EMIT deleteSelectedItems();
    }
    QTreeWidget::keyPressEvent(event);
}
07070100000018000081A40000000200000002000000015CDAA394000004C3000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectiontreewidget.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AutoCorrectionTreeWidget_H
#define AutoCorrectionTreeWidget_H

#include <QTreeWidget>

namespace PimCommon {
class AutoCorrectionTreeWidget : public QTreeWidget
{
    Q_OBJECT
public:
    explicit AutoCorrectionTreeWidget(QWidget *parent = nullptr);
    ~AutoCorrectionTreeWidget() override;

protected:
    void keyPressEvent(QKeyEvent *event) override;

Q_SIGNALS:
    void deleteSelectedItems();
};
}

#endif // AutoCorrectionTreeWidget_H
07070100000019000081A40000000200000002000000015CDAA3940000672C000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectionwidget.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrectionwidget.h"
#include "widgets/configureimmutablewidgetutils.h"
using namespace PimCommon::ConfigureImmutableWidgetUtils;
#include "autocorrection.h"
#include "ui_autocorrectionwidget.h"
#include "import/importlibreofficeautocorrection.h"
#include "import/importkmailautocorrection.h"
#include "import/importabstractautocorrection.h"

#include "settings/pimcommonsettings.h"
#include <kpimtextedit/selectspecialchardialog.h>

#include <KMessageBox>
#include <KLocalizedString>

#include <QTreeWidgetItem>
#include <QMenu>
#include <QFileDialog>

using namespace PimCommon;

Q_DECLARE_METATYPE(AutoCorrectionWidget::ImportFileType)
class PimCommon::AutoCorrectionWidgetPrivate
{
public:
    AutoCorrectionWidgetPrivate()
        : ui(new Ui::AutoCorrectionWidget)
    {
    }

~AutoCorrectionWidgetPrivate()
    {
        delete ui;
    }

AutoCorrection::TypographicQuotes m_singleQuotes;
    AutoCorrection::TypographicQuotes m_doubleQuotes;
    QSet<QString> m_upperCaseExceptions;
    QSet<QString> m_twoUpperLetterExceptions;
    QHash<QString, QString> m_autocorrectEntries;
    Ui::AutoCorrectionWidget *ui = nullptr;
    AutoCorrection *mAutoCorrection = nullptr;
    bool mWasChanged = false;
};

AutoCorrectionWidget::AutoCorrectionWidget(QWidget *parent)
    : QWidget(parent)
    , d(new PimCommon::AutoCorrectionWidgetPrivate)
{
    d->ui->setupUi(this);

d->ui->treeWidget->setSortingEnabled(true);
    d->ui->treeWidget->sortByColumn(0, Qt::AscendingOrder);

d->ui->add1->setEnabled(false);
    d->ui->add2->setEnabled(false);

connect(d->ui->autoChangeFormat, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->autoFormatUrl, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->upperCase, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->upperUpper, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->ignoreDoubleSpace, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->autoReplaceNumber, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->capitalizeDaysName, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->advancedAutocorrection, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->enabledAutocorrection, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->typographicSingleQuotes, &QCheckBox::clicked, this, &AutoCorrectionWidget::enableSingleQuotes);
    connect(d->ui->typographicDoubleQuotes, &QCheckBox::clicked, this, &AutoCorrectionWidget::enableDoubleQuotes);
    connect(d->ui->autoSuperScript, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->singleQuote1, &QPushButton::clicked, this, &AutoCorrectionWidget::selectSingleQuoteCharOpen);
    connect(d->ui->singleQuote2, &QPushButton::clicked, this, &AutoCorrectionWidget::selectSingleQuoteCharClose);
    connect(d->ui->singleDefault, &QPushButton::clicked, this, &AutoCorrectionWidget::setDefaultSingleQuotes);
    connect(d->ui->doubleQuote1, &QPushButton::clicked, this, &AutoCorrectionWidget::selectDoubleQuoteCharOpen);
    connect(d->ui->doubleQuote2, &QPushButton::clicked, this, &AutoCorrectionWidget::selectDoubleQuoteCharClose);
    connect(d->ui->doubleDefault, &QPushButton::clicked, this, &AutoCorrectionWidget::setDefaultDoubleQuotes);
    connect(d->ui->advancedAutocorrection, &QCheckBox::clicked, this, &AutoCorrectionWidget::enableAdvAutocorrection);
    connect(d->ui->addButton, &QPushButton::clicked, this, &AutoCorrectionWidget::addAutocorrectEntry);
    connect(d->ui->removeButton, &QPushButton::clicked, this, &AutoCorrectionWidget::removeAutocorrectEntry);
    connect(d->ui->treeWidget, &PimCommon::AutoCorrectionTreeWidget::itemClicked, this, &AutoCorrectionWidget::setFindReplaceText);
    connect(d->ui->treeWidget, &PimCommon::AutoCorrectionTreeWidget::deleteSelectedItems, this, &AutoCorrectionWidget::removeAutocorrectEntry);
    connect(d->ui->treeWidget, &PimCommon::AutoCorrectionTreeWidget::itemSelectionChanged, this, &AutoCorrectionWidget::updateAddRemoveButton);
    connect(d->ui->find, &KLineEdit::textChanged, this, &AutoCorrectionWidget::enableAddRemoveButton);
    connect(d->ui->replace, &KLineEdit::textChanged, this, &AutoCorrectionWidget::enableAddRemoveButton);
    connect(d->ui->abbreviation, &KLineEdit::textChanged, this, &AutoCorrectionWidget::abbreviationChanged);
    connect(d->ui->twoUpperLetter, &KLineEdit::textChanged, this, &AutoCorrectionWidget::twoUpperLetterChanged);
    connect(d->ui->add1, &QPushButton::clicked, this, &AutoCorrectionWidget::addAbbreviationEntry);
    connect(d->ui->remove1, &QPushButton::clicked, this, &AutoCorrectionWidget::removeAbbreviationEntry);
    connect(d->ui->add2, &QPushButton::clicked, this, &AutoCorrectionWidget::addTwoUpperLetterEntry);
    connect(d->ui->remove2, &QPushButton::clicked, this, &AutoCorrectionWidget::removeTwoUpperLetterEntry);
    connect(d->ui->typographicDoubleQuotes, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->typographicSingleQuotes, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->abbreviationList, &PimCommon::AutoCorrectionListWidget::itemSelectionChanged, this, &AutoCorrectionWidget::slotEnableDisableAbreviationList);
    connect(d->ui->abbreviationList, &PimCommon::AutoCorrectionListWidget::deleteSelectedItems, this, &AutoCorrectionWidget::removeAbbreviationEntry);
    connect(d->ui->twoUpperLetterList, &PimCommon::AutoCorrectionListWidget::itemSelectionChanged, this, &AutoCorrectionWidget::slotEnableDisableTwoUpperEntry);
    connect(d->ui->twoUpperLetterList, &PimCommon::AutoCorrectionListWidget::deleteSelectedItems, this, &AutoCorrectionWidget::removeTwoUpperLetterEntry);
    connect(d->ui->autocorrectionLanguage, QOverload<int>::of(&PimCommon::AutoCorrectionLanguage::activated), this, &AutoCorrectionWidget::changeLanguage);
    connect(d->ui->addNonBreakingSpaceInFrench, &QCheckBox::clicked, this, &AutoCorrectionWidget::emitChanged);
    connect(d->ui->twoUpperLetter, &KLineEdit::returnPressed, this, &AutoCorrectionWidget::addTwoUpperLetterEntry);
    connect(d->ui->abbreviation, &KLineEdit::returnPressed, this, &AutoCorrectionWidget::addAbbreviationEntry);
    slotEnableDisableAbreviationList();
    slotEnableDisableTwoUpperEntry();

QMenu *menu = new QMenu(this);
    d->ui->importAutoCorrection->setMenu(menu);

QAction *act = new QAction(i18n("LibreOffice Autocorrection"), this);
    act->setData(QVariant::fromValue(AutoCorrectionWidget::LibreOffice));
    menu->addAction(act);

act = new QAction(i18n("KMail/Calligra Autocorrection"), this);
    act->setData(QVariant::fromValue(AutoCorrectionWidget::KMail));
    menu->addAction(act);

connect(menu, &QMenu::triggered, this, &AutoCorrectionWidget::slotImportAutoCorrection);

connect(d->ui->exportAutoCorrection, &QPushButton::clicked, this, &AutoCorrectionWidget::slotExportAutoCorrection);
}

AutoCorrectionWidget::~AutoCorrectionWidget()
{
    delete d;
}

void AutoCorrectionWidget::setAutoCorrection(AutoCorrection *autoCorrect)
{
    d->mAutoCorrection = autoCorrect;
    setLanguage(d->ui->autocorrectionLanguage->language());
}

void AutoCorrectionWidget::loadConfig()
{
    if (!d->mAutoCorrection) {
        return;
    }

d->ui->autoChangeFormat->setChecked(d->mAutoCorrection->isAutoBoldUnderline());
    d->ui->autoFormatUrl->setChecked(d->mAutoCorrection->isAutoFormatUrl());
    d->ui->enabledAutocorrection->setChecked(d->mAutoCorrection->isEnabledAutoCorrection());
    d->ui->upperCase->setChecked(d->mAutoCorrection->isUppercaseFirstCharOfSentence());
    d->ui->upperUpper->setChecked(d->mAutoCorrection->isFixTwoUppercaseChars());
    d->ui->ignoreDoubleSpace->setChecked(d->mAutoCorrection->isSingleSpaces());
    d->ui->autoReplaceNumber->setChecked(d->mAutoCorrection->isAutoFractions());
    d->ui->capitalizeDaysName->setChecked(d->mAutoCorrection->isCapitalizeWeekDays());
    d->ui->advancedAutocorrection->setChecked(d->mAutoCorrection->isAdvancedAutocorrect());
    d->ui->autoSuperScript->setChecked(d->mAutoCorrection->isSuperScript());
    d->ui->typographicDoubleQuotes->setChecked(d->mAutoCorrection->isReplaceDoubleQuotes());
    d->ui->typographicSingleQuotes->setChecked(d->mAutoCorrection->isReplaceSingleQuotes());
    d->ui->addNonBreakingSpaceInFrench->setChecked(d->mAutoCorrection->isAddNonBreakingSpace());
    loadAutoCorrectionAndException();
    d->mWasChanged = false;
}

void AutoCorrectionWidget::loadAutoCorrectionAndException()
{
    /* tab 2 - Custom Quotes */
    d->m_singleQuotes = d->mAutoCorrection->typographicSingleQuotes();
    d->ui->singleQuote1->setText(d->m_singleQuotes.begin);
    d->ui->singleQuote2->setText(d->m_singleQuotes.end);
    d->m_doubleQuotes = d->mAutoCorrection->typographicDoubleQuotes();
    d->ui->doubleQuote1->setText(d->m_doubleQuotes.begin);
    d->ui->doubleQuote2->setText(d->m_doubleQuotes.end);
    enableSingleQuotes(d->ui->typographicSingleQuotes->isChecked());
    enableDoubleQuotes(d->ui->typographicDoubleQuotes->isChecked());

/* tab 3 - Advanced Autocorrection */
    d->m_autocorrectEntries = d->mAutoCorrection->autocorrectEntries();
    addAutoCorrectEntries();

enableAdvAutocorrection(d->ui->advancedAutocorrection->isChecked());
    /* tab 4 - Exceptions */
    d->m_upperCaseExceptions = d->mAutoCorrection->upperCaseExceptions();
    d->m_twoUpperLetterExceptions = d->mAutoCorrection->twoUpperLetterExceptions();

d->ui->twoUpperLetterList->clear();
    d->ui->twoUpperLetterList->addItems(d->m_twoUpperLetterExceptions.toList());

d->ui->abbreviationList->clear();
    d->ui->abbreviationList->addItems(d->m_upperCaseExceptions.toList());
}

void AutoCorrectionWidget::addAutoCorrectEntries()
{
    d->ui->treeWidget->clear();
    QHash<QString, QString>::const_iterator i = d->m_autocorrectEntries.constBegin();
    QTreeWidgetItem *item = nullptr;
    while (i != d->m_autocorrectEntries.constEnd()) {
        item = new QTreeWidgetItem(d->ui->treeWidget, item);
        item->setText(0, i.key());
        item->setText(1, i.value());
        ++i;
    }
    d->ui->treeWidget->setSortingEnabled(true);
    d->ui->treeWidget->sortByColumn(0, Qt::AscendingOrder);
}

void AutoCorrectionWidget::writeConfig()
{
    if (!d->mAutoCorrection) {
        return;
    }
    d->mAutoCorrection->setAutoBoldUnderline(d->ui->autoChangeFormat->isChecked());
    d->mAutoCorrection->setAutoFormatUrl(d->ui->autoFormatUrl->isChecked());
    d->mAutoCorrection->setEnabledAutoCorrection(d->ui->enabledAutocorrection->isChecked());
    d->mAutoCorrection->setUppercaseFirstCharOfSentence(d->ui->upperCase->isChecked());
    d->mAutoCorrection->setFixTwoUppercaseChars(d->ui->upperUpper->isChecked());
    d->mAutoCorrection->setSingleSpaces(d->ui->ignoreDoubleSpace->isChecked());
    d->mAutoCorrection->setCapitalizeWeekDays(d->ui->capitalizeDaysName->isChecked());
    d->mAutoCorrection->setAdvancedAutocorrect(d->ui->advancedAutocorrection->isChecked());
    d->mAutoCorrection->setSuperScript(d->ui->autoSuperScript->isChecked());

d->mAutoCorrection->setAutoFractions(d->ui->autoReplaceNumber->isChecked());

d->mAutoCorrection->setAutocorrectEntries(d->m_autocorrectEntries);
    d->mAutoCorrection->setUpperCaseExceptions(d->m_upperCaseExceptions);
    d->mAutoCorrection->setTwoUpperLetterExceptions(d->m_twoUpperLetterExceptions);

d->mAutoCorrection->setReplaceDoubleQuotes(d->ui->typographicDoubleQuotes->isChecked());
    d->mAutoCorrection->setReplaceSingleQuotes(d->ui->typographicSingleQuotes->isChecked());
    d->mAutoCorrection->setTypographicSingleQuotes(d->m_singleQuotes);
    d->mAutoCorrection->setTypographicDoubleQuotes(d->m_doubleQuotes);
    d->mAutoCorrection->setAddNonBreakingSpace(d->ui->addNonBreakingSpaceInFrench->isChecked());
    d->mAutoCorrection->writeConfig();
    d->mWasChanged = false;
}

void AutoCorrectionWidget::resetToDefault()
{
    d->ui->autoChangeFormat->setChecked(false);
    d->ui->autoFormatUrl->setChecked(false);
    d->ui->upperCase->setChecked(false);
    d->ui->upperUpper->setChecked(false);
    d->ui->ignoreDoubleSpace->setChecked(false);
    d->ui->capitalizeDaysName->setChecked(false);
    d->ui->advancedAutocorrection->setChecked(false);
    d->ui->typographicDoubleQuotes->setChecked(false);
    d->ui->typographicSingleQuotes->setChecked(false);
    d->ui->autoSuperScript->setChecked(false);
    d->ui->autoReplaceNumber->setChecked(false);
    d->ui->typographicDoubleQuotes->setChecked(false);
    d->ui->typographicSingleQuotes->setChecked(false);
    d->ui->addNonBreakingSpaceInFrench->setChecked(false);

loadGlobalAutoCorrectionAndException();
}

void AutoCorrectionWidget::enableSingleQuotes(bool state)
{
    d->ui->singleQuote1->setEnabled(state);
    d->ui->singleQuote2->setEnabled(state);
    d->ui->singleDefault->setEnabled(state);
}

void AutoCorrectionWidget::enableDoubleQuotes(bool state)
{
    d->ui->doubleQuote1->setEnabled(state);
    d->ui->doubleQuote2->setEnabled(state);
    d->ui->doubleDefault->setEnabled(state);
}

void AutoCorrectionWidget::selectSingleQuoteCharOpen()
{
    QPointer<KPIMTextEdit::SelectSpecialCharDialog> dlg = new KPIMTextEdit::SelectSpecialCharDialog(this);
    dlg->setCurrentChar(d->m_singleQuotes.begin);
    dlg->showSelectButton(false);
    dlg->autoInsertChar();
    if (dlg->exec()) {
        d->m_singleQuotes.begin = dlg->currentChar();
        d->ui->singleQuote1->setText(d->m_singleQuotes.begin);
        emitChanged();
    }
    delete dlg;
}

void AutoCorrectionWidget::selectSingleQuoteCharClose()
{
    QPointer<KPIMTextEdit::SelectSpecialCharDialog> dlg = new KPIMTextEdit::SelectSpecialCharDialog(this);
    dlg->showSelectButton(false);
    dlg->setCurrentChar(d->m_singleQuotes.end);
    dlg->autoInsertChar();
    if (dlg->exec()) {
        d->m_singleQuotes.end = dlg->currentChar();
        d->ui->singleQuote2->setText(d->m_singleQuotes.end);
        emitChanged();
    }
    delete dlg;
}

void AutoCorrectionWidget::setDefaultSingleQuotes()
{
    d->m_singleQuotes = d->mAutoCorrection->typographicDefaultSingleQuotes();
    d->ui->singleQuote1->setText(d->m_singleQuotes.begin);
    d->ui->singleQuote2->setText(d->m_singleQuotes.end);
    emitChanged();
}

void AutoCorrectionWidget::selectDoubleQuoteCharOpen()
{
    QPointer<KPIMTextEdit::SelectSpecialCharDialog> dlg = new KPIMTextEdit::SelectSpecialCharDialog(this);
    dlg->showSelectButton(false);
    dlg->setCurrentChar(d->m_doubleQuotes.begin);
    dlg->autoInsertChar();
    if (dlg->exec()) {
        d->m_doubleQuotes.begin = dlg->currentChar();
        d->ui->doubleQuote1->setText(d->m_doubleQuotes.begin);
        emitChanged();
    }
    delete dlg;
}

void AutoCorrectionWidget::selectDoubleQuoteCharClose()
{
    QPointer<KPIMTextEdit::SelectSpecialCharDialog> dlg = new KPIMTextEdit::SelectSpecialCharDialog(this);
    dlg->showSelectButton(false);
    dlg->setCurrentChar(d->m_doubleQuotes.end);
    dlg->autoInsertChar();
    if (dlg->exec()) {
        d->m_doubleQuotes.end = dlg->currentChar();
        d->ui->doubleQuote2->setText(d->m_doubleQuotes.end);
        emitChanged();
    }
    delete dlg;
}

void AutoCorrectionWidget::setDefaultDoubleQuotes()
{
    d->m_doubleQuotes = d->mAutoCorrection->typographicDefaultDoubleQuotes();
    d->ui->doubleQuote1->setText(d->m_doubleQuotes.begin);
    d->ui->doubleQuote2->setText(d->m_doubleQuotes.end);
    emitChanged();
}

void AutoCorrectionWidget::enableAdvAutocorrection(bool state)
{
    d->ui->findLabel->setEnabled(state);
    d->ui->find->setEnabled(state);
    d->ui->replaceLabel->setEnabled(state);
    d->ui->replace->setEnabled(state);

const QString find = d->ui->find->text();
    const QString replace = d->ui->replace->text();

d->ui->addButton->setEnabled(state && !find.isEmpty() && !replace.isEmpty());
    d->ui->removeButton->setEnabled(state && d->ui->treeWidget->currentItem());
    d->ui->treeWidget->setEnabled(state);
}

void AutoCorrectionWidget::addAutocorrectEntry()
{
    QTreeWidgetItem *item = d->ui->treeWidget->currentItem();
    const QString find = d->ui->find->text();
    const QString replace = d->ui->replace->text();
    if (find == replace) {
        KMessageBox::error(this, i18n("\"Replace\" string is the same as \"Find\" string."), i18n("Add Autocorrection Entry"));
        return;
    }

bool modify = false;

// Modify actually, not add, so we want to remove item from hash
    if (item && (find == item->text(0))) {
        d->m_autocorrectEntries.remove(find);
        modify = true;
    }

d->m_autocorrectEntries.insert(find, replace);
    d->ui->treeWidget->setSortingEnabled(false);
    if (modify) {
        item->setText(0, find);
        item->setText(1, replace);
    } else {
        item = new QTreeWidgetItem(d->ui->treeWidget, item);
        item->setText(0, find);
        item->setText(1, replace);
    }

d->ui->treeWidget->setSortingEnabled(true);
    d->ui->treeWidget->setCurrentItem(item);
    emitChanged();
}

void AutoCorrectionWidget::removeAutocorrectEntry()
{
    const QList<QTreeWidgetItem *> listItems = d->ui->treeWidget->selectedItems();
    if (listItems.isEmpty()) {
        return;
    }
    for (QTreeWidgetItem *item : listItems) {
        QTreeWidgetItem *below = d->ui->treeWidget->itemBelow(item);

QString findStr;
        if (below) {
            //qCDebug(PIMCOMMON_LOG) << "below";
            findStr = item->text(0);
            delete item;
            item = nullptr;
        } else if (d->ui->treeWidget->topLevelItemCount() > 0) {
            findStr = item->text(0);
            delete item;
            item = nullptr;
        }
        if (!findStr.isEmpty()) {
            d->m_autocorrectEntries.remove(findStr);
        }
    }
    d->ui->treeWidget->setSortingEnabled(false);

emitChanged();
}

void AutoCorrectionWidget::updateAddRemoveButton()
{
    QList<QTreeWidgetItem *> listItems = d->ui->treeWidget->selectedItems();
    d->ui->removeButton->setEnabled(!listItems.isEmpty());
}

void AutoCorrectionWidget::enableAddRemoveButton()
{
    const QString find = d->ui->find->text();
    const QString replace = d->ui->replace->text();

QTreeWidgetItem *item = nullptr;
    if (d->m_autocorrectEntries.contains(find)) {
        item = d->ui->treeWidget->findItems(find, Qt::MatchCaseSensitive).at(0);
    }

bool enable = false;
    if (find.isEmpty() || replace.isEmpty()) { // disable if no text in find/replace
        enable = !(find.isEmpty() || replace.isEmpty());
    } else if (item && find == item->text(0)) {
        // We disable add / remove button if no text for the replacement
        enable = !item->text(1).isEmpty();
        d->ui->addButton->setText(i18n("&Modify"));
    } else if (!item || !item->text(1).isEmpty()) {
        enable = true;
        d->ui->addButton->setText(i18n("&Add"));
    }

if (item && replace == item->text(1)) {
        d->ui->addButton->setEnabled(false);
    } else {
        d->ui->addButton->setEnabled(enable);
    }
    d->ui->removeButton->setEnabled(enable);
}

void AutoCorrectionWidget::setFindReplaceText(QTreeWidgetItem *item, int column)
{
    Q_UNUSED(column);
    d->ui->find->setText(item->text(0));
    d->ui->replace->setText(item->text(1));
}

void AutoCorrectionWidget::abbreviationChanged(const QString &text)
{
    d->ui->add1->setEnabled(!text.isEmpty());
}

void AutoCorrectionWidget::twoUpperLetterChanged(const QString &text)
{
    d->ui->add2->setEnabled(!text.isEmpty());
}

void AutoCorrectionWidget::addAbbreviationEntry()
{
    const QString text = d->ui->abbreviation->text();
    if (text.isEmpty()) {
        return;
    }
    if (!d->m_upperCaseExceptions.contains(text)) {
        d->m_upperCaseExceptions.insert(text);
        d->ui->abbreviationList->addItem(text);
    }
    d->ui->abbreviation->clear();
    slotEnableDisableAbreviationList();
    emitChanged();
}

void AutoCorrectionWidget::removeAbbreviationEntry()
{
    const QList<QListWidgetItem *> listItem = d->ui->abbreviationList->selectedItems();
    if (listItem.isEmpty()) {
        return;
    }
    for (QListWidgetItem *item : listItem) {
        d->m_upperCaseExceptions.remove(item->text());
        delete item;
    }
    slotEnableDisableAbreviationList();
    emitChanged();
}

void AutoCorrectionWidget::addTwoUpperLetterEntry()
{
    const QString text = d->ui->twoUpperLetter->text();
    if (text.isEmpty()) {
        return;
    }
    if (!d->m_twoUpperLetterExceptions.contains(text)) {
        d->m_twoUpperLetterExceptions.insert(text);
        d->ui->twoUpperLetterList->addItem(text);
        emitChanged();
    }
    slotEnableDisableTwoUpperEntry();
    d->ui->twoUpperLetter->clear();
}

void AutoCorrectionWidget::removeTwoUpperLetterEntry()
{
    const QList<QListWidgetItem *> listItem = d->ui->twoUpperLetterList->selectedItems();
    if (listItem.isEmpty()) {
        return;
    }
    for (QListWidgetItem *item : listItem) {
        d->m_twoUpperLetterExceptions.remove(item->text());
        delete item;
    }
    slotEnableDisableTwoUpperEntry();
    emitChanged();
}

void AutoCorrectionWidget::slotEnableDisableAbreviationList()
{
    const bool enable = (!d->ui->abbreviationList->selectedItems().isEmpty());
    d->ui->add1->setEnabled(!d->ui->abbreviation->text().isEmpty());
    d->ui->remove1->setEnabled(enable);
}

void AutoCorrectionWidget::slotEnableDisableTwoUpperEntry()
{
    const bool enable = (!d->ui->twoUpperLetterList->selectedItems().isEmpty());
    d->ui->add2->setEnabled(!d->ui->twoUpperLetter->text().isEmpty());
    d->ui->remove2->setEnabled(enable);
}

void AutoCorrectionWidget::slotImportAutoCorrection(QAction *act)
{
    if (act) {
        AutoCorrectionWidget::ImportFileType type = act->data().value<AutoCorrectionWidget::ImportFileType>();
        QString title;
        QString filter;
        switch (type) {
        case AutoCorrectionWidget::LibreOffice:
            title = i18n("Import LibreOffice Autocorrection");
            filter = i18n("LibreOffice Autocorrection File (*.data)");
            break;
        case AutoCorrectionWidget::KMail:
            title = i18n("Import KMail Autocorrection");
            filter = i18n("KMail Autocorrection File (*.xml)");
            break;
        }
        const QString fileName = QFileDialog::getOpenFileName(this, title, QString(), filter);
        if (!fileName.isEmpty()) {
            PimCommon::ImportAbstractAutocorrection *importAutoCorrection = nullptr;
            switch (type) {
            case AutoCorrectionWidget::LibreOffice:
                importAutoCorrection = new PimCommon::ImportLibreOfficeAutocorrection(this);
                break;
            case AutoCorrectionWidget::KMail:
                importAutoCorrection = new PimCommon::ImportKMailAutocorrection(this);
                break;
            default:
                return;
            }
            if (importAutoCorrection->import(fileName, ImportAbstractAutocorrection::All)) {
                d->m_autocorrectEntries = importAutoCorrection->autocorrectEntries();
                addAutoCorrectEntries();

enableAdvAutocorrection(d->ui->advancedAutocorrection->isChecked());

d->m_upperCaseExceptions = importAutoCorrection->upperCaseExceptions();
                d->m_twoUpperLetterExceptions = importAutoCorrection->twoUpperLetterExceptions();

d->ui->twoUpperLetterList->clear();
                d->ui->twoUpperLetterList->addItems(d->m_twoUpperLetterExceptions.toList());

d->ui->abbreviationList->clear();
                d->ui->abbreviationList->addItems(d->m_upperCaseExceptions.toList());
            }
            delete importAutoCorrection;
        }
    }
}

void AutoCorrectionWidget::setLanguage(const QString &lang)
{
    d->mAutoCorrection->setLanguage(lang);
    loadAutoCorrectionAndException();
    d->mWasChanged = false;
}

void AutoCorrectionWidget::changeLanguage(int index)
{
    if (index == -1) {
        return;
    }
    if (d->mWasChanged) {
        const int rc = KMessageBox::warningYesNo(this, i18n("Language was changed, do you want to save config for previous language?"), i18n("Save config"));
        if (rc == KMessageBox::Yes) {
            writeConfig();
        }
    }
    const QString lang = d->ui->autocorrectionLanguage->itemData(index).toString();
    d->mAutoCorrection->setLanguage(lang);
    loadAutoCorrectionAndException();
    d->mWasChanged = false;
}

void AutoCorrectionWidget::emitChanged()
{
    d->mWasChanged = true;
    Q_EMIT changed();
}

void AutoCorrectionWidget::loadGlobalAutoCorrectionAndException()
{
    const QString lang = d->ui->autocorrectionLanguage->itemData(d->ui->autocorrectionLanguage->currentIndex()).toString();
    d->mAutoCorrection->setLanguage(lang, true);
    loadAutoCorrectionAndException();
    d->mWasChanged = true;
    Q_EMIT changed();
}

void AutoCorrectionWidget::slotExportAutoCorrection()
{
    if (d->mWasChanged) {
        KMessageBox::error(this, i18n("Please save changes before exporting settings."), i18n("Export Autocorrection File"));
        return;
    }
    const QString saveUrl = QFileDialog::getSaveFileName(this, i18n("Export Autocorrection File"), QDir::homePath());
    if (saveUrl.isEmpty()) {
        return;
    }
    d->mAutoCorrection->writeAutoCorrectionXmlFile(saveUrl);
}
0707010000001A000081A40000000200000002000000015CDAA39400000AF2000000000000000000000000000000000000006100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autocorrectionwidget.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AutoCorrectionWidget_H
#define AutoCorrectionWidget_H

#include "pimcommon_export.h"
#include "pimcommon/autocorrection.h"
#include <QWidget>

class QTreeWidgetItem;

namespace Ui {
class AutoCorrectionWidget;
}

namespace PimCommon {
class AutoCorrectionWidgetPrivate;
class PIMCOMMON_EXPORT AutoCorrectionWidget : public QWidget
{
    Q_OBJECT

public:
    enum ImportFileType {
        LibreOffice,
        KMail
    };

explicit AutoCorrectionWidget(QWidget *parent = nullptr);
    ~AutoCorrectionWidget();
    void setAutoCorrection(AutoCorrection *autoCorrect);
    void loadConfig();
    void writeConfig();
    void resetToDefault();

private Q_SLOTS:
    /* tab 2 */
    void enableSingleQuotes(bool state);
    void enableDoubleQuotes(bool state);
    void selectSingleQuoteCharOpen();
    void selectSingleQuoteCharClose();
    void setDefaultSingleQuotes();
    void selectDoubleQuoteCharOpen();
    void selectDoubleQuoteCharClose();
    void setDefaultDoubleQuotes();

/* tab 3 */
    void enableAdvAutocorrection(bool state);
    void addAutocorrectEntry();
    void removeAutocorrectEntry();
    void setFindReplaceText(QTreeWidgetItem *, int);
    void enableAddRemoveButton();

/* tab 4 */
    void abbreviationChanged(const QString &text);
    void twoUpperLetterChanged(const QString &text);
    void addAbbreviationEntry();
    void removeAbbreviationEntry();
    void addTwoUpperLetterEntry();
    void removeTwoUpperLetterEntry();

void slotEnableDisableAbreviationList();
    void slotEnableDisableTwoUpperEntry();

void slotImportAutoCorrection(QAction *act);

void changeLanguage(int);
    void updateAddRemoveButton();

void slotExportAutoCorrection();

Q_SIGNALS:
    void changed();

private:
    void emitChanged();
    void addAutoCorrectEntries();
    void loadAutoCorrectionAndException();
    void loadGlobalAutoCorrectionAndException();
    void setLanguage(const QString &lang);

AutoCorrectionWidgetPrivate *const d;
};
}

#endif // AutoCorrectionWidget_H
0707010000001B000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests0707010000001C000081A40000000200000002000000015CDAA394000002DE000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/CMakeLists.txtadd_definitions( -DAUTOCORRECTION_DATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data" )

macro(add_pimcommon_autocorrect_unittest _source)
  set(_test ${_source})
  get_filename_component(_name ${_source} NAME_WE)
  add_executable( ${_name} ${_test} )
  add_test(NAME ${_name} COMMAND ${_name} )
  set_tests_properties(${_name} PROPERTIES ENVIRONMENT "QT_HASH_SEED=0;QT_NO_CPU_FEATURE=sse4.2")
  ecm_mark_as_test(pimcommon-autocorrection-${_name})
  target_link_libraries(${_name}  Qt5::Test KF5::PimCommon KF5::PimTextEdit)
endmacro()

add_pimcommon_autocorrect_unittest(autocorrectiontest.cpp)
add_pimcommon_autocorrect_unittest(lineeditwithautocorrectiontest.cpp)
add_pimcommon_autocorrect_unittest(richtexteditwithautocorrectiontest.cpp)
0707010000001D000081A40000000200000002000000015CDAA39400006C30000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/autocorrectiontest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrectiontest.h"
#include "../autocorrection.h"
#include "settings/pimcommonsettings.h"
#include <QTest>
#include "pimcommon_debug.h"
#include <QTextDocument>
#include <QStandardPaths>
#include <QProcess>

#ifndef Q_OS_WIN
void initLocale()
{
    setenv("LC_ALL", "en_US.utf-8", 1);
}

Q_CONSTRUCTOR_FUNCTION(initLocale)
#endif

AutoCorrectionTest::AutoCorrectionTest()
{
    QStandardPaths::setTestModeEnabled(true);
    mConfig = KSharedConfig::openConfig(QStringLiteral("autocorrectiontestrc"));
    PimCommon::PimCommonSettings::self()->setSharedConfig(mConfig);
    PimCommon::PimCommonSettings::self()->load();
}

AutoCorrectionTest::~AutoCorrectionTest()
{
}

void AutoCorrectionTest::shouldHaveDefaultValue()
{
    PimCommon::AutoCorrection autocorrection;
    QVERIFY(!autocorrection.isEnabledAutoCorrection());
    QVERIFY(!autocorrection.isUppercaseFirstCharOfSentence());
    QVERIFY(!autocorrection.isFixTwoUppercaseChars());
    QVERIFY(!autocorrection.isSingleSpaces());
    QVERIFY(!autocorrection.isAutoFractions());
    QVERIFY(!autocorrection.isCapitalizeWeekDays());
    QVERIFY(!autocorrection.isReplaceDoubleQuotes());
    QVERIFY(!autocorrection.isReplaceSingleQuotes());
    QVERIFY(!autocorrection.isAdvancedAutocorrect());
    QVERIFY(!autocorrection.isAutoFormatUrl());
    QVERIFY(!autocorrection.isAutoBoldUnderline());
    QVERIFY(!autocorrection.isSuperScript());
    QVERIFY(!autocorrection.isAddNonBreakingSpace());
}

void AutoCorrectionTest::shouldRestoreValue()
{
    PimCommon::AutoCorrection autocorrection;
    //TODO
}

void AutoCorrectionTest::shouldUpperCaseFirstCharOfSentence()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setUppercaseFirstCharOfSentence(true);

//Uppercase here.
    QTextDocument doc;
    QString text = QStringLiteral("foo");
    doc.setPlainText(text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QStringLiteral("Foo"));

//IT's not first char -> not uppercase
    text = QStringLiteral(" foo");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);

//It's already uppercase
    text = QStringLiteral("Foo");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);

//Word is after a ". "
    text = QStringLiteral("Foo. foo");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QStringLiteral("Foo. Foo"));
    QCOMPARE(position, text.length());
}

void AutoCorrectionTest::shouldFixTwoUpperCaseChars()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setFixTwoUppercaseChars(true);

//Remove two uppercases
    QTextDocument doc;
    QString text = QStringLiteral("FOo");
    doc.setPlainText(text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QStringLiteral("Foo"));

//There is not two uppercase
    text = QStringLiteral("foo");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);

text = QStringLiteral("Foo");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);

//There is a uppercase word
    text = QStringLiteral("FOO");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);

//Exclude 2 upper letter
    text = QStringLiteral("ABc");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QStringLiteral("Abc"));

QSet<QString> exception;
    exception.insert(QStringLiteral("ABc"));
    autocorrection.setTwoUpperLetterExceptions(exception);
    text = QStringLiteral("ABc");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);
}

void AutoCorrectionTest::shouldReplaceSingleQuote()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setReplaceSingleQuotes(true);
    PimCommon::AutoCorrection::TypographicQuotes simpleQuote;
    simpleQuote.begin = QLatin1Char('A');
    simpleQuote.end = QLatin1Char('B');

autocorrection.setTypographicSingleQuotes(simpleQuote);

QTextDocument doc;
    QString text = QStringLiteral("sss");
    doc.setPlainText(QStringLiteral("'") + text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(simpleQuote.begin + text));

text = QStringLiteral("sss");
    doc.setPlainText(text + QStringLiteral("'"));
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(text + simpleQuote.end));

text = QStringLiteral("sss");
    doc.setPlainText(QStringLiteral("'") + text + QStringLiteral("'"));
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(simpleQuote.begin + text + simpleQuote.end));
}

void AutoCorrectionTest::shouldReplaceDoubleQuote()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setReplaceDoubleQuotes(true);
    PimCommon::AutoCorrection::TypographicQuotes doubleQuote;
    doubleQuote.begin = QLatin1Char('A');
    doubleQuote.end = QLatin1Char('B');

autocorrection.setTypographicDoubleQuotes(doubleQuote);

QTextDocument doc;
    QString text = QStringLiteral("sss");

doc.setPlainText(QLatin1Char('"') + text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(doubleQuote.begin + text));

text = QStringLiteral("sss");
    doc.setPlainText(text + QStringLiteral("\""));
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(text + doubleQuote.end));

text = QStringLiteral("sss");
    doc.setPlainText(QStringLiteral("\"") + text + QStringLiteral("\""));
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(doubleQuote.begin + text + doubleQuote.end));
}

void AutoCorrectionTest::shouldNotReplaceUppercaseLetter()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setFixTwoUppercaseChars(true);
    QSet<QString> exceptions;
    exceptions.insert(QStringLiteral("ABc"));
    autocorrection.setTwoUpperLetterExceptions(exceptions);

QTextDocument doc;
    QString text = QStringLiteral("foo ABc");
    doc.setPlainText(text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);
}

void AutoCorrectionTest::shouldReplaceToTextFormat()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setAutoBoldUnderline(true);

QTextDocument doc;
    //We don't use html => don't change it.
    QString text = QStringLiteral("*foo*");
    doc.setHtml(text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);

QString result = QStringLiteral("foo");
    doc.setHtml(text);
    position = text.length();
    autocorrection.autocorrect(true, doc, position);
    QCOMPARE(doc.toPlainText(), result);

text = QStringLiteral("*foo*");
    doc.setHtml(text);
    position = text.length();
    autocorrection.autocorrect(true, doc, position);
    QCOMPARE(doc.toPlainText(), result);
    QTextCursor cursor(&doc);
    cursor.setPosition(2);
    QTextCharFormat charFormat = cursor.charFormat();
    QCOMPARE(charFormat.font().underline(), false);
    QCOMPARE(charFormat.font().bold(), true);
    QCOMPARE(charFormat.font().strikeOut(), false);

text = QStringLiteral("_foo_");
    doc.setHtml(text);
    position = text.length();
    autocorrection.autocorrect(true, doc, position);
    QCOMPARE(doc.toPlainText(), result);
    cursor = QTextCursor(&doc);
    cursor.setPosition(2);
    charFormat = cursor.charFormat();
    QCOMPARE(charFormat.font().underline(), true);
    QCOMPARE(charFormat.font().bold(), false);
    QCOMPARE(charFormat.font().strikeOut(), false);

text = QStringLiteral("-foo-");
    doc.setHtml(text);
    position = text.length();
    autocorrection.autocorrect(true, doc, position);
    QCOMPARE(doc.toPlainText(), result);
    cursor = QTextCursor(&doc);
    cursor.setPosition(2);
    charFormat = cursor.charFormat();
    QCOMPARE(charFormat.font().underline(), false);
    QCOMPARE(charFormat.font().bold(), false);
    QCOMPARE(charFormat.font().strikeOut(), true);

//Don't convert it.
    text = QStringLiteral("-foo1");
    doc.setHtml(text);
    position = text.length();
    autocorrection.autocorrect(true, doc, position);
    QCOMPARE(doc.toPlainText(), text);

text = QStringLiteral("*foo* blabla");
    position = 5;
    doc.setHtml(text);
    autocorrection.autocorrect(true, doc, position);
    result = QStringLiteral("foo blabla");
    QCOMPARE(doc.toPlainText(), result);
    QCOMPARE(position, 3);

//TODO QCOMPARE(doc.toHtml(), text);
}

void AutoCorrectionTest::shouldReplaceAutoFraction()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setAutoFractions(true);

QTextDocument doc;
    QString text = QStringLiteral("1/2");
    doc.setPlainText(text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);

QCOMPARE(doc.toPlainText(), QStringLiteral("½"));

QString suffix = QStringLiteral(" after");
    text = QStringLiteral("1/2");
    position = 3;
    text += suffix;
    doc.setPlainText(text);
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(QStringLiteral("½") + suffix));
    QCOMPARE(position, 1);
}

void AutoCorrectionTest::shouldNotAddSpaceWhenWeAlreadyHaveASpace()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setSingleSpaces(true);
    QTextDocument doc;
    //We already a space => don't allow to add more
    QString text = QStringLiteral("FOO ");
    doc.setPlainText(text);
    int position = text.length();
    bool result = autocorrection.autocorrect(false, doc, position);
    QCOMPARE(result, false);

//We can add a space
    text = QStringLiteral("FOO");
    doc.setPlainText(text);
    position = text.length();
    result = autocorrection.autocorrect(false, doc, position);
    QCOMPARE(result, true);

//We have a space => don't add it.
    text = QStringLiteral("FOO ");
    position = text.length();
    QString fullText = text + QStringLiteral("FOO");
    doc.setPlainText(fullText);
    result = autocorrection.autocorrect(false, doc, position);
    QCOMPARE(result, false);
}

void AutoCorrectionTest::shouldAutocorrectWord()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setAdvancedAutocorrect(true);

QTextDocument doc;
    //No changes
    QString text = QStringLiteral("FOO");
    doc.setPlainText(text);
    int position = text.length();
    int oldPosition = position;
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);
    QCOMPARE(position, oldPosition);

//Convert word
    QHash<QString, QString> entries;
    const QString convertWord = QStringLiteral("BLABLA");
    entries.insert(text, convertWord);
    autocorrection.setAutocorrectEntries(entries);
    text = QStringLiteral("FOO");
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), convertWord);
    QCOMPARE(position, convertWord.length());

QString suffix = QStringLiteral(" TOTO");
    text = QStringLiteral("FOO");
    position = text.length();
    text += suffix;
    doc.setPlainText(text);
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(convertWord + suffix));
    //FIXME ? QCOMPARE(position, convertWord.length());
}

void AutoCorrectionTest::shouldNotUpperCaseFirstCharOfSentence()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setUppercaseFirstCharOfSentence(true);
    QSet<QString> lst;
    lst.insert(QStringLiteral("Foo."));
    autocorrection.setUpperCaseExceptions(lst);

//Uppercase here.
    QTextDocument doc;
    QString text = QStringLiteral("foo. blabla Foo. tt");
    doc.setPlainText(text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), text);

autocorrection.setUpperCaseExceptions(QSet<QString>());
    doc.setPlainText(text);
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QString result = QStringLiteral("foo. blabla Foo. Tt");
    QCOMPARE(doc.toPlainText(), result);
}

typedef QHash<QString, QString> mapAutoCorrect;
Q_DECLARE_METATYPE(mapAutoCorrect)

void AutoCorrectionTest::shouldAutocorrectMultiWord_data()
{
    QTest::addColumn<QString>("originalString");
    QTest::addColumn<QString>("convertedString");
    QTest::addColumn<mapAutoCorrect>("convertStringHash");

mapAutoCorrect map;
    map.insert(QStringLiteral("boo"), QStringLiteral("bla"));
    QTest::newRow("simpleReplace") << QStringLiteral("boo") << QStringLiteral("bla") << map;

map.clear();
    map.insert(QStringLiteral("a boo"), QStringLiteral("b bla"));
    QTest::newRow("multiword") << QStringLiteral("a boo") << QStringLiteral("b bla") << map;

map.clear();
    map.insert(QStringLiteral("a boo"), QStringLiteral("b bla"));
    map.insert(QStringLiteral("a booeeeeeeeeeeeeeeeeeee"), QStringLiteral("b blaeee"));
    QTest::newRow("multiword-2") << QStringLiteral("toto. a boo") << QStringLiteral("toto. b bla") << map;

map.clear();
    QTest::newRow("multiword-2 without replace") << QStringLiteral("toto. a boo") << QStringLiteral("toto. a boo") << map;

map.clear();
    map.insert(QStringLiteral("a boo"), QStringLiteral("b bla"));
    QTest::newRow("multiword-2 with uppercase") << QStringLiteral("toto. A boo") << QStringLiteral("toto. B bla") << map;

map.clear();
    map.insert(QStringLiteral("a boo1111111111"), QStringLiteral("b bla"));
    QTest::newRow("multiword-3") << QStringLiteral("a boo") << QStringLiteral("a boo") << map;

map.clear();
    map.insert(QStringLiteral("boo"), QStringLiteral("Bla"));
    QTest::newRow("withuppercase") << QStringLiteral("Boo") << QStringLiteral("Bla") << map;

map.clear();
    map.insert(QStringLiteral("boo"), QStringLiteral("bla"));
    QTest::newRow("withuppercase-2") << QStringLiteral("Boo") << QStringLiteral("Bla") << map;

map.clear();
    map.insert(QStringLiteral("boo"), QStringLiteral("Bla"));
    QTest::newRow("withuppercase-3") << QStringLiteral("Boo") << QStringLiteral("Bla") << map;

map.clear();
    map.insert(QStringLiteral("boo"), QStringLiteral("Bla"));
    QTest::newRow("withuppercase-4") << QStringLiteral("boo") << QStringLiteral("bla") << map;

map.clear();
    map.insert(QStringLiteral("booooo"), QStringLiteral("bla"));
    QTest::newRow("nofindtext") << QStringLiteral("boo") << QStringLiteral("boo") << map;

map.clear();
    map.insert(QStringLiteral("boosss"), QStringLiteral("Blasss"));
    map.insert(QStringLiteral("boo"), QStringLiteral("bla"));
    QTest::newRow("withponct") << QStringLiteral("boo!") << QStringLiteral("bla!") << map;

map.clear();
    map.insert(QStringLiteral("boosss"), QStringLiteral("Blasss"));
    map.insert(QStringLiteral("boo"), QStringLiteral("bla"));
    QTest::newRow("withponct-2") << QStringLiteral("lolo. boo!") << QStringLiteral("lolo. bla!") << map;

map.clear();
    map.insert(QStringLiteral("boo"), QStringLiteral("bla"));
    QTest::newRow("dontreplaceinpieceofword") << QStringLiteral("voitureboo") << QStringLiteral("voitureboo") << map;

map.clear();
    map.insert(QStringLiteral("boo"), QStringLiteral("bla"));
    map.insert(QStringLiteral("booOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOo"), QStringLiteral("bla"));
    QTest::newRow("dontreplaceall") << QStringLiteral("Boo boo boo") << QStringLiteral("Boo boo bla") << map;
}

void AutoCorrectionTest::shouldAutocorrectMultiWord()
{
    QFETCH(QString, originalString);
    QFETCH(QString, convertedString);
    QFETCH(mapAutoCorrect, convertStringHash);

PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setAdvancedAutocorrect(true);
    autocorrection.setAutocorrectEntries(convertStringHash);

QTextDocument doc;
    doc.setPlainText(originalString);
    int position = originalString.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), convertedString);
}

void AutoCorrectionTest::shouldAddNonBreakingSpace_data()
{
    QTest::addColumn<QString>("originalString");
    QTest::addColumn<QString>("convertedString");
    QTest::addColumn<QString>("language");
    QTest::addColumn<bool>("enableAddNonBreakingSpace");
    QTest::newRow("convert1") << QStringLiteral("boo !") << QStringLiteral("boob!") << QStringLiteral("fr") << true;
    QTest::newRow("disable") << QStringLiteral("boo !") << QStringLiteral("boo !") << QStringLiteral("fr") << false;
    QTest::newRow("nonchanges") << QStringLiteral("boo") << QStringLiteral("boo") << QStringLiteral("fr") << true;
    QTest::newRow("convert2") << QStringLiteral("boo ;") << QStringLiteral("boob;") << QStringLiteral("fr") << true;
    QTest::newRow("convert3") << QStringLiteral("boo ?") << QStringLiteral("boob?") << QStringLiteral("fr") << true;
    QTest::newRow("convert4") << QStringLiteral("boo :") << QStringLiteral("boob:") << QStringLiteral("fr") << true;
    QTest::newRow("nonfrenchlanguage") << QStringLiteral("boo :") << QStringLiteral("boo :") << QStringLiteral("ge") << true;
    QTest::newRow("onecharacter") << QStringLiteral(":") << QStringLiteral(":") << QStringLiteral("fr") << true;
    QTest::newRow("onecharacter2") << QStringLiteral(" ") << QStringLiteral(" ") << QStringLiteral("fr") << true;
    QTest::newRow("percentage") << QStringLiteral("50 %") << QStringLiteral("50b%") << QStringLiteral("fr") << true;
    QTest::newRow("degres") << QStringLiteral("50 °C") << QStringLiteral("50b°C") << QStringLiteral("fr") << true;
    QTest::newRow("simplespace") << QStringLiteral(" ") << QStringLiteral(" ") << QStringLiteral("fr") << true;
}

void AutoCorrectionTest::shouldAddNonBreakingSpace()
{
    QFETCH(QString, originalString);
    QFETCH(QString, convertedString);
    QFETCH(QString, language);
    QFETCH(bool, enableAddNonBreakingSpace);

PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setAddNonBreakingSpace(enableAddNonBreakingSpace);
    autocorrection.setLanguage(language);
    autocorrection.setNonBreakingSpace(QChar(QLatin1Char('b')));

void AutoCorrectionTest::shouldReplaceWithMultiOption_data()
{
    QTest::addColumn<QString>("originalString");
    QTest::addColumn<QString>("convertedString");
    QTest::addColumn<mapAutoCorrect>("convertStringHash");

QTest::addColumn<bool>("enable");
    QTest::addColumn<bool>("uppercaseFirstCharOfSentence");
    QTest::addColumn<bool>("advancedAutocorrect");
    QTest::addColumn<bool>("fixtoouppercase");
    mapAutoCorrect map;
    map.insert(QStringLiteral("boo"), QStringLiteral("bla"));

QTest::newRow("disable") << QStringLiteral("Boo boo boo") << QStringLiteral("Boo boo boo") << map << false << false << false << false;
    QTest::newRow("enablebutdisablealloptions") << QStringLiteral("Boo boo boo") << QStringLiteral("Boo boo boo") << map << true << false << false << false;
    QTest::newRow("enableandenableuppercase") << QStringLiteral("Boo boo boo") << QStringLiteral("Boo boo boo") << map << true << true << false << false;
    QTest::newRow("enableandenableuppercaseandadvanced") << QStringLiteral("Boo boo boo") << QStringLiteral("Boo boo bla") << map << true << true << true << false;

QTest::newRow("enableandenableuppercaseandadvanced-2") << QStringLiteral("Boo boo. boo") << QStringLiteral("Boo boo. Bla") << map << true << true << true << false;
    QTest::newRow("enableandenableuppercaseandadvanced-3") << QStringLiteral("blablobli") << QStringLiteral("Blablobli") << map << true << true << true << false;
    QTest::newRow("enableandenableuppercaseandadvanced-4") << QStringLiteral("blablobli. foo") << QStringLiteral("blablobli. Foo") << map << true << true << true << false;

QTest::newRow("enableandenablefixtouppercase") << QStringLiteral("Boo boo. BOo") << QStringLiteral("Boo boo. Boo") << map << true << true << false << true;
    QTest::newRow("enableandenablefixtouppercase-2") << QStringLiteral("Boo BOo") << QStringLiteral("Boo Boo") << map << true << true << false << true;
    //TODO add more
}

void AutoCorrectionTest::shouldReplaceWithMultiOption()
{
    QFETCH(QString, originalString);
    QFETCH(QString, convertedString);
    QFETCH(mapAutoCorrect, convertStringHash);
    QFETCH(bool, enable);
    QFETCH(bool, uppercaseFirstCharOfSentence);
    QFETCH(bool, advancedAutocorrect);
    QFETCH(bool, fixtoouppercase);

PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(enable);
    autocorrection.setAdvancedAutocorrect(advancedAutocorrect);
    autocorrection.setAutocorrectEntries(convertStringHash);
    autocorrection.setUppercaseFirstCharOfSentence(uppercaseFirstCharOfSentence);
    autocorrection.setFixTwoUppercaseChars(fixtoouppercase);

void AutoCorrectionTest::shouldAddNonBreakingSpaceBeforeAfterQuote()
{
    PimCommon::AutoCorrection autocorrection;
    autocorrection.setEnabledAutoCorrection(true);
    autocorrection.setReplaceDoubleQuotes(true);
    autocorrection.setReplaceSingleQuotes(true);
    autocorrection.setLanguage(QStringLiteral("fr"));
    autocorrection.setAddNonBreakingSpace(true);
    //TODO fix me verify why it doesn't use no breaking space
    const QChar nbsp = QChar(/*QChar::Nbsp*/ QLatin1Char('b'));
    autocorrection.setNonBreakingSpace(nbsp);

PimCommon::AutoCorrection::TypographicQuotes doubleQuote;
    doubleQuote.begin = QLatin1Char('A');
    doubleQuote.end = QLatin1Char('B');
    autocorrection.setTypographicDoubleQuotes(doubleQuote);

PimCommon::AutoCorrection::TypographicQuotes simpleQuote;
    simpleQuote.begin = QLatin1Char('A');
    simpleQuote.end = QLatin1Char('B');

autocorrection.setTypographicSingleQuotes(simpleQuote);

QTextDocument doc;
    QString text = QStringLiteral("sss");

doc.setPlainText(QLatin1Char('"') + text);
    int position = text.length();
    autocorrection.autocorrect(false, doc, position);

QCOMPARE(doc.toPlainText(), QString(doubleQuote.begin + nbsp + text));

//Simple quote
    text = QStringLiteral("sss");
    doc.setPlainText(text + QStringLiteral("\'"));
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(text + nbsp + simpleQuote.end));

//Simple quote
    text = QStringLiteral("sss");
    doc.setPlainText(QStringLiteral("\'") + text + QStringLiteral("\'"));
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(simpleQuote.begin + nbsp + text + nbsp + simpleQuote.end));

text = QLatin1Char('(');
    doc.setPlainText(QStringLiteral("\"") + text + QStringLiteral("\""));
    position = text.length();
    autocorrection.autocorrect(false, doc, position);
    QCOMPARE(doc.toPlainText(), QString(doubleQuote.begin + nbsp + text + nbsp + doubleQuote.end));
}

void AutoCorrectionTest::shouldLoadSaveAutocorrection_data()
{
    QTest::addColumn<QString>("filename");
    QTest::newRow("empty") << QStringLiteral("empty");
    QTest::newRow("custom-fr") << QStringLiteral("custom-fr");
}

void AutoCorrectionTest::shouldLoadSaveAutocorrection()
{
    QFETCH(QString, filename);
    PimCommon::AutoCorrection autocorrection;
    PimCommon::AutoCorrection autocorrectionReference;
    const QString originalFile = QLatin1String(AUTOCORRECTION_DATA_DIR) + QLatin1Char('/') + filename + QStringLiteral(".xml");
    const QString refFile = QLatin1String(AUTOCORRECTION_DATA_DIR) + QLatin1Char('/') + filename + QStringLiteral("-ref.xml");
    const QString generatedFile = QLatin1String(AUTOCORRECTION_DATA_DIR) + QLatin1Char('/') + filename + QStringLiteral("-generated.xml");

autocorrection.loadGlobalFileName(originalFile, true);
    autocorrection.writeAutoCorrectionXmlFile(generatedFile);

//make sure the xml is valid and we can feed ourself with our own generated file
    autocorrection.loadGlobalFileName(generatedFile, true);

autocorrectionReference.loadGlobalFileName(refFile, true);

QCOMPARE(autocorrection.autocorrectEntries(), autocorrectionReference.autocorrectEntries());
    QCOMPARE(autocorrection.upperCaseExceptions(), autocorrectionReference.upperCaseExceptions());
    QCOMPARE(autocorrection.twoUpperLetterExceptions(), autocorrectionReference.twoUpperLetterExceptions());
}

QTEST_MAIN(AutoCorrectionTest)
0707010000001E000081A40000000200000002000000015CDAA3940000076F000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/autocorrectiontest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AUTOCORRECTIONTEST_H
#define AUTOCORRECTIONTEST_H

#include <QObject>
#include <KSharedConfig>
class AutoCorrectionTest : public QObject
{
    Q_OBJECT
public:
    AutoCorrectionTest();
    ~AutoCorrectionTest();

private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldRestoreValue();
    void shouldUpperCaseFirstCharOfSentence();
    void shouldFixTwoUpperCaseChars();
    void shouldReplaceSingleQuote();
    void shouldReplaceDoubleQuote();
    void shouldNotReplaceUppercaseLetter();
    void shouldReplaceToTextFormat();
    void shouldReplaceAutoFraction();
    void shouldNotAddSpaceWhenWeAlreadyHaveASpace();
    void shouldAutocorrectWord();
    void shouldNotUpperCaseFirstCharOfSentence();

void shouldAutocorrectMultiWord_data();
    void shouldAutocorrectMultiWord();

void shouldAddNonBreakingSpace_data();
    void shouldAddNonBreakingSpace();

void shouldReplaceWithMultiOption_data();
    void shouldReplaceWithMultiOption();

void shouldAddNonBreakingSpaceBeforeAfterQuote();

void shouldLoadSaveAutocorrection_data();
    void shouldLoadSaveAutocorrection();

private:
    KSharedConfig::Ptr mConfig;
};

#endif // AUTOCORRECTIONTEST_H
0707010000001F000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/data07070100000020000081A40000000200000002000000015CDAA3940000F270000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/data/custom-fr-ref.xml<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE autocorrection>
<Word>
  <items>
    <item find="baptème" replace="baptême"/>
    <item find="garde fou" replace="garde-fou"/>
    <item find="acosté" replace="accosté"/>
    <item find="ausi" replace="aussi"/>
    <item find="sotire" replace="sortie"/>
    <item find="connection" replace="connexion"/>
    <item find="grand père" replace="grand-père"/>
    <item find="groseiller" replace="groseillier"/>
    <item find="Magreb" replace="Maghreb"/>
    <item find="ça dépends" replace="ça dépend"/>
    <item find="le publique" replace="le public"/>
    <item find="plein-pied" replace="plain-pied"/>
    <item find="rafraichir" replace="rafraîchir"/>
    <item find="financiaire" replace="financière"/>
    <item find="Et oui" replace="Eh oui"/>
    <item find="changemetn" replace="changement"/>
    <item find="ayant suivit" replace="ayant suivi"/>
    <item find="optionels" replace="optionnels"/>
    <item find="rhyume" replace="rhume"/>
    <item find="instatn" replace="instant"/>
    <item find="libre échange" replace="libre-échange"/>
    <item find="super-ordinateurs" replace="superordinateurs"/>
    <item find="un travaille" replace="un travail"/>
    <item find="baffouillé" replace="bafouillé"/>
    <item find="guadeloupe" replace="Guadeloupe"/>
    <item find="la planisphère" replace="le planisphère"/>
    <item find="baches" replace="bâches"/>
    <item find="mal habile" replace="malhabile"/>
    <item find="totu" replace="tout"/>
    <item find="il suis" replace="il suit"/>
    <item find="quote part" replace="quote-part"/>
    <item find="quelque soit" replace="quel que soit"/>
    <item find="vasy" replace="vas-y"/>
    <item find="hotel" replace="hôtel"/>
    <item find="otées" replace="ôtées"/>
    <item find="mali" replace="Mali"/>
    <item find="consonnance" replace="consonance"/>
    <item find="au moment ou" replace="au moment où"/>
    <item find="apperçue" replace="aperçue"/>
    <item find="ellaborée" replace="élaborée"/>
    <item find="autrment" replace="autrement"/>
    <item find="Pyrennées" replace="Pyrénées"/>
    <item find="leru" replace="leur"/>
    <item find="cable" replace="câble"/>
    <item find="minitel" replace="Minitel"/>
    <item find="lse" replace="les"/>
    <item find="canada" replace="Canada"/>
    <item find="je suit" replace="je suis"/>
    <item find="encâblure" replace="encablure"/>
    <item find="nu propriétaire" replace="nu-propriétaire"/>
    <item find="programeur" replace="programmeur"/>
    <item find="bèches" replace="bêches"/>
    <item find="programes" replace="programmes"/>
    <item find="elle même" replace="elle-même"/>
    <item find="chein" replace="chien"/>
    <item find="ban de poissons" replace="banc de poissons"/>
    <item find="valloir" replace="valoir"/>
    <item find="demie-heure" replace="demi-heure"/>
    <item find="n'ia" replace="n'ai"/>
    <item find="gouté" replace="goûté"/>
    <item find="petit-suisses" replace="petits-suisses"/>
    <item find="ceal" replace="cela"/>
    <item find="exepté" replace="excepté"/>
    <item find="un expédiant" replace="un expédient"/>
    <item find="pare-brises" replace="pare-brise"/>
    <item find="tempète" replace="tempête"/>
    <item find="conslutation" replace="consultation"/>
    <item find="flêche" replace="flèche"/>
    <item find="le notre" replace="le nôtre"/>
    <item find="dannemark" replace="Danemark"/>
    <item find="le votre" replace="le vôtre"/>
    <item find="gabon" replace="Gabon"/>
    <item find="batard" replace="bâtard"/>
    <item find="à peu pré" replace="à peu près"/>
    <item find="rectifié le tire" replace="rectifié le tir"/>
    <item find="pèse lettres" replace="pèse-lettres"/>
    <item find="sotn" replace="sont"/>
    <item find="la suis" replace="la suie"/>
    <item find="sépcifiques" replace="spécifiques"/>
    <item find="incomodé" replace="incommodé"/>
    <item find="terre plein" replace="terre-plein"/>
    <item find="mayotte" replace="Mayotte"/>
    <item find="exessivement" replace="excessivement"/>
    <item find="japon" replace="Japon"/>
    <item find="en fabricant" replace="en fabriquant"/>
    <item find="navigateru" replace="navigateur"/>
    <item find="friut" replace="fruit"/>
    <item find="pation" replace="passion"/>
    <item find="italie" replace="Italie"/>
    <item find="il aperçu" replace="il aperçut"/>
    <item find="ambigüité" replace="ambiguïté"/>
    <item find="guyane" replace="Guyane"/>
    <item find="maroc" replace="Maroc"/>
    <item find="rèver" replace="rêver"/>
    <item find="stastitiques" replace="statistiques"/>
    <item find="bècher" replace="bêcher"/>
    <item find="controlé" replace="contrôlé"/>
    <item find="COMpuTer" replace="computer"/>
    <item find="est faut" replace="est faux"/>
    <item find="bas-flanc" replace="bat-flanc"/>
    <item find="polynésie" replace="Polynésie"/>
    <item find="en adhérent" replace="en adhérant"/>
    <item find="utilsateurs" replace="utilisateurs"/>
    <item find="réveille matin" replace="réveille-matin"/>
    <item find="Il mais" replace="Il met"/>
    <item find="multi-tâche" replace="multitâche"/>
    <item find="sus dit" replace="susdit"/>
    <item find="c'est a vous" replace="c'est à vous"/>
    <item find="partouts" replace="partout"/>
    <item find="le permit de conduire" replace="le permis de conduire"/>
    <item find="petit-beurres" replace="petits-beurres"/>
    <item find="donnes-moi" replace="donne-moi"/>
    <item find="ban d'essais" replace="banc d'essais"/>
    <item find="tunisie" replace="Tunisie"/>
    <item find="pous" replace="plus"/>
    <item find="au grès des" replace="au gré des"/>
    <item find="haut commissaire" replace="haut-commissaire"/>
    <item find="guinée" replace="Guinée"/>
    <item find="procesus" replace="processus"/>
    <item find="enquèter" replace="enquêter"/>
    <item find="ce pendant" replace="cependant"/>
    <item find="croitre" replace="croître"/>
    <item find="elle conseil" replace="elle conseille"/>
    <item find="pret" replace="prêt"/>
    <item find="traine" replace="traîne"/>
    <item find="imge" replace="image"/>
    <item find="arete" replace="arête"/>
    <item find="mêches" replace="mèches"/>
    <item find="précosses" replace="précoces"/>
    <item find="appats" replace="appâts"/>
    <item find="nos cotés" replace="nos côtés"/>
    <item find="a peu près" replace="à peu près"/>
    <item find="je veut" replace="je veux"/>
    <item find="serat-il" replace="sera-t-il"/>
    <item find="paitre" replace="paître"/>
    <item find="platre" replace="plâtre"/>
    <item find="courrant" replace="courant"/>
    <item find="rèves" replace="rêves"/>
    <item find="poeles" replace="poêles"/>
    <item find="parebrise" replace="pare-brise"/>
    <item find="main d'oeuvre" replace="main-d'oeuvre"/>
    <item find="intéret" replace="intérêt"/>
    <item find="joaliers" replace="joailliers"/>
    <item find="vosu" replace="vous"/>
    <item find="une alvéole" replace="un alvéole"/>
    <item find="ficheir" replace="fichier"/>
    <item find="abisses" replace="abysses"/>
    <item find="Nouvelle Calédonie" replace="Nouvelle-Calédonie"/>
    <item find="antrée" replace="entrée"/>
    <item find="martinique" replace="Martinique"/>
    <item find="a la fois" replace="à la fois"/>
    <item find="des fabriquants" replace="des fabricants"/>
    <item find="hollande" replace="Hollande"/>
    <item find="olécrânes" replace="olécranes"/>
    <item find="soit même" replace="soi-même"/>
    <item find="crûe" replace="crue"/>
    <item find="pluton" replace="Pluton"/>
    <item find="Sera-t'il" replace="Sera-t-il"/>
    <item find="une plait" replace="une plaie"/>
    <item find="fesant" replace="faisant"/>
    <item find="multi-tâches" replace="multitâche"/>
    <item find="aficher" replace="afficher"/>
    <item find="optionel" replace="optionnel"/>
    <item find="nouvelle-calédonie" replace="Nouvelle-Calédonie"/>
    <item find="ciclysme" replace="cyclisme"/>
    <item find="chèr" replace="cher"/>
    <item find="parechoc" replace="pare-chocs"/>
    <item find="identé" replace="indenté"/>
    <item find="microporcesseur" replace="microprocesseur"/>
    <item find="controle" replace="contrôle"/>
    <item find="norvège" replace="Norvège"/>
    <item find="apotres" replace="apôtres"/>
    <item find="adanboner" replace="abandonner"/>
    <item find="ban des accusés" replace="banc des accusés"/>
    <item find="souffre douleur" replace="souffre-douleur"/>
    <item find="melée" replace="mêlée"/>
    <item find="ainés" replace="aînés"/>
    <item find="Noel" replace="Noël"/>
    <item find="a-t'il" replace="a-t-il"/>
    <item find="les adhérants" replace="les adhérents"/>
    <item find="reve" replace="rêve"/>
    <item find="sage femme" replace="sage-femme"/>
    <item find="appui tête" replace="appui-tête"/>
    <item find="grèle" replace="grêle"/>
    <item find="pince monseigneur" replace="pince-monseigneur"/>
    <item find="pillule" replace="pilule"/>
    <item find="Magrébin" replace="Maghrébin"/>
    <item find="nouriture" replace="nourriture"/>
    <item find="parlotte" replace="parlote"/>
    <item find="cales-pieds" replace="cale-pieds"/>
    <item find="normallement" replace="normalement"/>
    <item find="couluer" replace="couleur"/>
    <item find="oter" replace="ôter"/>
    <item find="ont aperçut" replace="ont aperçu"/>
    <item find="je mais" replace="je mets"/>
    <item find="celles là" replace="celles-là"/>
    <item find="apotre" replace="apôtre"/>
    <item find="ceux là" replace="ceux-là"/>
    <item find="honnètes" replace="honnêtes"/>
    <item find="annnée" replace="année"/>
    <item find="sensé être" replace="censé être"/>
    <item find="Il mets" replace="Il met"/>
    <item find="chefs-d'oeuvres" replace="chefs-d'oeuvre"/>
    <item find="bruler" replace="brûler"/>
    <item find="changments" replace="changements"/>
    <item find="pinguin" replace="pingouin"/>
    <item find="controleur" replace="contrôleur"/>
    <item find="luxembourg" replace="Luxembourg"/>
    <item find="jacintes" replace="jacinthes"/>
    <item find="contre-ordre" replace="contrordre"/>
    <item find="sorite" replace="sortie"/>
    <item find="cheins" replace="chiens"/>
    <item find="giffler" replace="gifler"/>
    <item find="bolc" replace="bloc"/>
    <item find="quitances" replace="quittances"/>
    <item find="ognon" replace="oignon"/>
    <item find="un équivoque" replace="une équivoque"/>
    <item find="bacler" replace="bâcler"/>
    <item find="tempètes" replace="tempêtes"/>
    <item find="infromatique" replace="informatique"/>
    <item find="mâçon" replace="maçon"/>
    <item find="moi même" replace="moi-même"/>
    <item find="sénégal" replace="Sénégal"/>
    <item find="ficier" replace="fichier"/>
    <item find="tempette" replace="tempête"/>
    <item find="remplire" replace="remplir"/>
    <item find="Quelque soit" replace="Quel que soit"/>
    <item find="contrejour" replace="contre-jour"/>
    <item find="décus" replace="déçus"/>
    <item find="jetéé" replace="jetée"/>
    <item find="baptèmes" replace="baptêmes"/>
    <item find="francais" replace="français"/>
    <item find="va et vient" replace="va-et-vient"/>
    <item find="exhorbitants" replace="exorbitants"/>
    <item find="les notres" replace="les nôtres"/>
    <item find="pallier à" replace="pallier"/>
    <item find="prudhommes" replace="prud'hommes"/>
    <item find="marseille" replace="Marseille"/>
    <item find="courier" replace="courrier"/>
    <item find="coulerus" replace="couleurs"/>
    <item find="sans-gène" replace="sans-gêne"/>
    <item find="parlementères" replace="parlementaires"/>
    <item find="ils sons" replace="ils sont"/>
    <item find="pois lourd" replace="poids lourd"/>
    <item find="machoire" replace="mâchoire"/>
    <item find="On a pas" replace="On n'a pas"/>
    <item find="COMPUTer" replace="computer"/>
    <item find="erronnés" replace="erronés"/>
    <item find="pilône" replace="pylône"/>
    <item find="poele" replace="poêle"/>
    <item find="environnment" replace="environnement"/>
    <item find="héroine" replace="héroïne"/>
    <item find="on a pas" replace="on n'a pas"/>
    <item find="hopital" replace="hôpital"/>
    <item find="un champs" replace="un champ"/>
    <item find="chaine" replace="chaîne"/>
    <item find="acre" replace="âcre"/>
    <item find="vous faîtes" replace="vous faites"/>
    <item find="une denticule" replace="un denticule"/>
    <item find="antécédants" replace="antécédents"/>
    <item find="crûs" replace="crus"/>
    <item find="hètre" replace="hêtre"/>
    <item find="déviser" replace="dévisser"/>
    <item find="fuire" replace="fuir"/>
    <item find="baggages" replace="bagages"/>
    <item find="mêche" replace="mèche"/>
    <item find="fourmie" replace="fourmi"/>
    <item find="brulures" replace="brûlures"/>
    <item find="la sourie" replace="la souris"/>
    <item find="les anales" replace="les annales"/>
    <item find="astérique" replace="astérisque"/>
    <item find="cuissse" replace="cuisse"/>
    <item find="a t'on" replace="a-t-on"/>
    <item find="inquiette" replace="inquiète"/>
    <item find="au dessous" replace="au-dessous"/>
    <item find="multi-utilisateur" replace="multiutilisateur"/>
    <item find="veulliez" replace="veuillez"/>
    <item find="aprés" replace="après"/>
    <item find="colones" replace="colonnes"/>
    <item find="au delà" replace="au-delà"/>
    <item find="bec de lièvre" replace="bec-de-lièvre"/>
    <item find="terre neuve" replace="terre-neuve"/>
    <item find="ayant conçut" replace="ayant conçu"/>
    <item find="enquète" replace="enquête"/>
    <item find="astérix" replace="astérisque"/>
    <item find="rape" replace="râpe"/>
    <item find="chnagements" replace="changements"/>
    <item find="fios" replace="fois"/>
    <item find="une aphte" replace="un aphte"/>
    <item find="dépot" replace="dépôt"/>
    <item find="language" replace="langage"/>
    <item find="résidances" replace="résidences"/>
    <item find="indépendemment" replace="indépendamment"/>
    <item find="notres" replace="nôtres"/>
    <item find="Ce pendant" replace="Cependant"/>
    <item find="paralèlles" replace="parallèles"/>
    <item find="ellaborer" replace="élaborer"/>
    <item find="pique nique" replace="pique-nique"/>
    <item find="sorte à ce que" replace="sorte que"/>
    <item find="coline" replace="colline"/>
    <item find="main morte" replace="mainmorte"/>
    <item find="inquièter" replace="inquiéter"/>
    <item find="Le publique" replace="Le public"/>
    <item find="bienvenu" replace="bienvenue"/>
    <item find="chausse-trappe" replace="chausse-trape"/>
    <item find="gout" replace="goût"/>
    <item find="naviguer au prêt" replace="naviguer au près"/>
    <item find="buttin" replace="butin"/>
    <item find="tout puissant" replace="tout-puissant"/>
    <item find="un anagramme" replace="une anagramme"/>
    <item find="paroide" replace="parodie"/>
    <item find="parallèlle" replace="parallèle"/>
    <item find="apelé" replace="appelé"/>
    <item find="déja" replace="déjà"/>
    <item find="liserés" replace="lisérés"/>
    <item find="condanmé" replace="condamné"/>
    <item find="burkina faso" replace="Burkina Faso"/>
    <item find="haut le coeur" replace="haut-le-coeur"/>
    <item find="pallié à" replace="pallié"/>
    <item find="tu peut" replace="tu peux"/>
    <item find="danemark" replace="Danemark"/>
    <item find="un apostrophe" replace="une apostrophe"/>
    <item find="c'est-à dire" replace="c'est-à-dire"/>
    <item find="faience" replace="faïence"/>
    <item find="Charente Maritime" replace="Charente-Maritime"/>
    <item find="une abaque" replace="un abaque"/>
    <item find="par acquis" replace="par acquit"/>
    <item find="vis a vis" replace="vis-à-vis"/>
    <item find="répèter" replace="répéter"/>
    <item find="mon du" replace="mon dû"/>
    <item find="accroitre" replace="accroître"/>
    <item find="mammelles" replace="mamelles"/>
    <item find="elle choisi" replace="elle choisit"/>
    <item find="là bas" replace="là-bas"/>
    <item find="apperçues" replace="aperçues"/>
    <item find="la boite" replace="la boîte"/>
    <item find="par dessous" replace="par-dessous"/>
    <item find="lieu dit" replace="lieu-dit"/>
    <item find="Méditerrannée" replace="Méditerranée"/>
    <item find="bas flanc" replace="bat-flanc"/>
    <item find="soi même" replace="soi-même"/>
    <item find="Des lors" replace="Dès lors"/>
    <item find="a conclut" replace="a conclu"/>
    <item find="Qui peux" replace="Qui peut"/>
    <item find="mithe" replace="mythe"/>
    <item find="mort né" replace="mort-né"/>
    <item find="publier les bancs" replace="publier les bans"/>
    <item find="perce neige" replace="perce-neige"/>
    <item find="quelle que soie" replace="quelle que soit"/>
    <item find="mourrir" replace="mourir"/>
    <item find="babord" replace="bâbord"/>
    <item find="est définit" replace="est défini"/>
    <item find="Par acquis" replace="Par acquit"/>
    <item find="jusqu'a" replace="jusqu'à"/>
    <item find="décidemment" replace="décidément"/>
    <item find="exédents" replace="excédents"/>
    <item find="elle survie" replace="elle survit"/>
    <item find="tête bêche" replace="tête-bêche"/>
    <item find="repaire" replace="repère"/>
    <item find="éceuil" replace="écueil"/>
    <item find="uqi" replace="qui"/>
    <item find="l'équivalant" replace="l'équivalent"/>
    <item find="giraffe" replace="girafe"/>
    <item find="coq à l'âne" replace="coq-à-l'âne"/>
    <item find="de son plein grès" replace="de son plein gré"/>
    <item find="piqure" replace="piqûre"/>
    <item find="baggage" replace="bagage"/>
    <item find="tatons" replace="tâtons"/>
    <item find="extrème" replace="extrême"/>
    <item find="quète" replace="quête"/>
    <item find="d'en train" replace="d'entrain"/>
    <item find="personalisé" replace="personnalisé"/>
    <item find="etre" replace="être"/>
    <item find="acumuler" replace="accumuler"/>
    <item find="suffir" replace="suffire"/>
    <item find="pèse acide" replace="pèse-acides"/>
    <item find="la mêle chose" replace="la même chose"/>
    <item find="sous estimées" replace="sous-estimées"/>
    <item find="une foie" replace="une fois"/>
    <item find="réveil matin" replace="réveille-matin"/>
    <item find="liseré" replace="liséré"/>
    <item find="points-virgule" replace="points-virgules"/>
    <item find="la plait" replace="la plaie"/>
    <item find="une après-midi" replace="un après-midi"/>
    <item find="courronne" replace="couronne"/>
    <item find="gite" replace="gîte"/>
    <item find="C'st" replace="C'est"/>
    <item find="paralèlle" replace="parallèle"/>
    <item find="ici-même" replace="ici même"/>
    <item find="atr" replace="art"/>
    <item find="haut parleur" replace="haut-parleur"/>
    <item find="prudamment" replace="prudemment"/>
    <item find="mammelle" replace="mamelle"/>
    <item find="Ayant suivit" replace="Ayant suivi"/>
    <item find="écrna" replace="écran"/>
    <item find="rafraichis" replace="rafraîchis"/>
    <item find="peid" replace="pied"/>
    <item find="règlé" replace="réglé"/>
    <item find="il mets" replace="il met"/>
    <item find="avior" replace="avoir"/>
    <item find="batêmes" replace="baptêmes"/>
    <item find="ci devant" replace="ci-devant"/>
    <item find="ivoir" replace="ivoire"/>
    <item find="arret" replace="arrêt"/>
    <item find="pologne" replace="Pologne"/>
    <item find="main forte" replace="main-forte"/>
    <item find="porte fenêtre" replace="porte-fenêtre"/>
    <item find="soi disant" replace="soi-disant"/>
    <item find="extention" replace="extension"/>
    <item find="meme" replace="même"/>
    <item find="modme" replace="modem"/>
    <item find="lancer de pois" replace="lancer de poids"/>
    <item find="différend du" replace="différent du"/>
    <item find="vert de gris" replace="vert-de-gris"/>
    <item find="identer" replace="indenter"/>
    <item find="un emise" replace="une mise"/>
    <item find="Haiti" replace="Haïti"/>
    <item find="petit beurre" replace="petit-beurre"/>
    <item find="poçible" replace="possible"/>
    <item find="grand mère" replace="grand-mère"/>
    <item find="sous estimés" replace="sous-estimés"/>
    <item find="à priori" replace="a priori"/>
    <item find="par derrière" replace="par-derrière"/>
    <item find="inclue" replace="incluse"/>
    <item find="ainées" replace="aînées"/>
    <item find="trainés" replace="traînés"/>
    <item find="station service" replace="station-service"/>
    <item find="mouffles" replace="moufles"/>
    <item find="aujourdh'ui" replace="aujourd'hui"/>
    <item find="arreter" replace="arrêter"/>
    <item find="gouter" replace="goûter"/>
    <item find="elles sons" replace="elles sont"/>
    <item find="prudhomme" replace="prud'homme"/>
    <item find="sera t'il" replace="sera-t-il"/>
    <item find="siphilys" replace="syphilis"/>
    <item find="paramètré" replace="paramétré"/>
    <item find="théillère" replace="théière"/>
    <item find="il mais" replace="il met"/>
    <item find="optionelles" replace="optionnelles"/>
    <item find="algérie" replace="Algérie"/>
    <item find="mes cotés" replace="mes côtés"/>
    <item find="exès" replace="excès"/>
    <item find="sous marin" replace="sous-marin"/>
    <item find="un on dit" replace="un on-dit"/>
    <item find="renouveller" replace="renouveler"/>
    <item find="dure mère" replace="dure-mère"/>
    <item find="faché" replace="fâché"/>
    <item find="cnet" replace="cent"/>
    <item find="des conseilles" replace="des conseils"/>
    <item find="pas tord" replace="pas tort"/>
    <item find="anerie" replace="ânerie"/>
    <item find="navigue au pré" replace="navigue au près"/>
    <item find="persiffler" replace="persifler"/>
    <item find="appéritif" replace="apéritif"/>
    <item find="brulantes" replace="brûlantes"/>
    <item find="carreaus" replace="carreaux"/>
    <item find="controler" replace="contrôler"/>
    <item find="fenètre" replace="fenêtre"/>
    <item find="fius" replace="fois"/>
    <item find="il boîte" replace="il boite"/>
    <item find="dexu" replace="deux"/>
    <item find="asssis" replace="assis"/>
    <item find="ordinateru" replace="ordinateur"/>
    <item find="gagnatn" replace="gagnant"/>
    <item find="des lors" replace="dès lors"/>
    <item find="noyeau" replace="noyau"/>
    <item find="porbablement" replace="probablement"/>
    <item find="navigue au prêt" replace="navigue au près"/>
    <item find="une sourie" replace="une souris"/>
    <item find="chnagement" replace="changement"/>
    <item find="de plein grès" replace="de plein gré"/>
    <item find="crète" replace="crête"/>
    <item find="icone" replace="icône"/>
    <item find="courrone" replace="couronne"/>
    <item find="annullé" replace="annulé"/>
    <item find="monoindustrie" replace="mono-industrie"/>
    <item find="attaindre" replace="atteindre"/>
    <item find="sanglotter" replace="sangloter"/>
    <item find="annullés" replace="annulés"/>
    <item find="Bienvenu" replace="Bienvenue"/>
    <item find="pécunier" replace="pécuniaire"/>
    <item find="noyeaux" replace="noyaux"/>
    <item find="recomande" replace="recommande"/>
    <item find="nouritures" replace="nourritures"/>
    <item find="impot" replace="impôt"/>
    <item find="ane" replace="âne"/>
    <item find="bétises" replace="bêtises"/>
    <item find="les une" replace="les unes"/>
    <item find="asssise" replace="assise"/>
    <item find="license" replace="licence"/>
    <item find="dûs" replace="dus"/>
    <item find="une antidote" replace="un antidote"/>
    <item find="nue propriété" replace="nue-propriété"/>
    <item find="passports" replace="passeports"/>
    <item find="super-oxyde" replace="superoxyde"/>
    <item find="http:/" replace="http://"/>
    <item find="cad" replace="c.-à-d."/>
    <item find="Pour acquis" replace="Pour acquit"/>
    <item find="est fournit" replace="est fourni"/>
    <item find="jacynthe" replace="jacinthe"/>
    <item find="au grès de" replace="au gré de"/>
    <item find="toujour" replace="toujours"/>
    <item find="peaus" replace="peaux"/>
    <item find="cloture" replace="clôture"/>
    <item find="allemagne" replace="Allemagne"/>
    <item find="maurice" replace="Maurice"/>
    <item find="ambigue" replace="ambiguë"/>
    <item find="ainé" replace="aîné"/>
    <item find="ame" replace="âme"/>
    <item find="votres" replace="vôtres"/>
    <item find="courament" replace="couramment"/>
    <item find="sous marine" replace="sous-marine"/>
    <item find="pourir" replace="pourrir"/>
    <item find="brulant" replace="brûlant"/>
    <item find="une armistice" replace="un armistice"/>
    <item find="pils" replace="plis"/>
    <item find="sait il" replace="sait-il"/>
    <item find="va de paire" replace="va de pair"/>
    <item find="haïti" replace="Haïti"/>
    <item find="son permit de conduire" replace="son permis de conduire"/>
    <item find="X Windows" replace="X Window"/>
    <item find="haut contre" replace="haut-contre"/>
    <item find="courrir" replace="courir"/>
    <item find="fenetre" replace="fenêtre"/>
    <item find="est-ce-que" replace="est-ce que"/>
    <item find="soutien gorge" replace="soutien-gorge"/>
    <item find="mirroir" replace="miroir"/>
    <item find="pâques" replace="Pâques"/>
    <item find="dnas" replace="dans"/>
    <item find="une fébricule" replace="un fébricule"/>
    <item find="friod" replace="froid"/>
    <item find="un espèce" replace="une espèce"/>
    <item find="une crois" replace="une croix"/>
    <item find="infromaticien" replace="informaticien"/>
    <item find="Dés lors" replace="Dès lors"/>
    <item find="astériques" replace="astérisques"/>
    <item find="contre-partie" replace="contrepartie"/>
    <item find="a suivit" replace="a suivi"/>
    <item find="on calcul" replace="on calcule"/>
    <item find="Marseilles" replace="Marseille"/>
    <item find="poids cassés" replace="pois cassés"/>
    <item find="tole" replace="tôle"/>
    <item find="verre de terre" replace="ver de terre"/>
    <item find="bache" replace="bâche"/>
    <item find="giffle" replace="gifle"/>
    <item find="haut de forme" replace="haut-de-forme"/>
    <item find="dnot" replace="dont"/>
    <item find="fihcier" replace="fichier"/>
    <item find="une dote" replace="une dot"/>
    <item find="la foie" replace="la fois"/>
    <item find="plutot" replace="plutôt"/>
    <item find="résoud il" replace="résout-il"/>
    <item find="pylone" replace="pylône"/>
    <item find="ficheirs" replace="fichiers"/>
    <item find="partisant" replace="partisan"/>
    <item find="concourrir" replace="concourir"/>
    <item find="court-circuits" replace="courts-circuits"/>
    <item find="Prés de" replace="Près de"/>
    <item find="dse" replace="des"/>
    <item find="suède" replace="Suède"/>
    <item find="porgramme" replace="programme"/>
    <item find="passes-partout" replace="passe-partout"/>
    <item find="la votre" replace="la vôtre"/>
    <item find="ouie" replace="ouïe"/>
    <item find="celle-la" replace="celle-là"/>
    <item find="liu" replace="lui"/>
    <item find="accolyte" replace="acolyte"/>
    <item find="aillant" replace="ayant"/>
    <item find="tatonner" replace="tâtonner"/>
    <item find="À pirori" replace="A priori"/>
    <item find="une plais" replace="une plaie"/>
    <item find="sauf conduits" replace="sauf-conduits"/>
    <item find="plateforme" replace="plate-forme"/>
    <item find="pare-choc" replace="pare-chocs"/>
    <item find="bonour" replace="bonjour"/>
    <item find="renouvellées" replace="renouvelées"/>
    <item find="un jouer" replace="un jour"/>
    <item find="chène" replace="chêne"/>
    <item find="il vous permets" replace="il vous permet"/>
    <item find="aucunes" replace="aucune"/>
    <item find="sthétoscope" replace="stéthoscope"/>
    <item find="aigües" replace="aiguës"/>
    <item find="a permit" replace="a permis"/>
    <item find="annuller" replace="annuler"/>
    <item find="etc..." replace="etc."/>
    <item find="mions" replace="moins"/>
    <item find="orielle" replace="oreille"/>
    <item find="maos" replace="mais"/>
    <item find="seychelles" replace="Seychelles"/>
    <item find="l'en train" replace="l'entrain"/>
    <item find="logicile" replace="logiciel"/>
    <item find="torvalds" replace="Torvalds"/>
    <item find="à posteriori" replace="a posteriori"/>
    <item find="cambodge" replace="Cambodge"/>
    <item find="brulé" replace="brûlé"/>
    <item find="icones" replace="icônes"/>
    <item find="inconditionelle" replace="inconditionnelle"/>
    <item find="appéritifs" replace="apéritifs"/>
    <item find="un transfère" replace="un transfert"/>
    <item find="elle investi" replace="elle investit"/>
    <item find="leur équivalant" replace="leur équivalent"/>
    <item find="exeption" replace="exception"/>
    <item find="arpès" replace="après"/>
    <item find="participassion" replace="participation"/>
    <item find="au grès du" replace="au gré du"/>
    <item find="chènes" replace="chênes"/>
    <item find="haut fond" replace="haut-fond"/>
    <item find="la notre" replace="la nôtre"/>
    <item find="Antrée" replace="Entrée"/>
    <item find="exellents" replace="excellents"/>
    <item find="tater" replace="tâter"/>
    <item find="l'adhérant" replace="l'adhérent"/>
    <item find="reast" replace="vide de test"/>
    <item find="est conçut" replace="est conçu"/>
    <item find="baclé" replace="bâclé"/>
    <item find="Quelques soient" replace="Quels que soient"/>
    <item find="cauchemard" replace="cauchemar"/>
    <item find="trop plein" replace="trop-plein"/>
    <item find="condanmer" replace="condamner"/>
    <item find="fenètres" replace="fenêtres"/>
    <item find="un adhérant" replace="un adhérent"/>
    <item find="super-marché" replace="supermarché"/>
    <item find="vanuatu" replace="Vanuatu"/>
    <item find="pillules" replace="pilules"/>
    <item find="demie heure" replace="demi-heure"/>
    <item find="patietn" replace="patient"/>
    <item find="il calcul" replace="il calcule"/>
    <item find="quatres" replace="quatre"/>
    <item find="tobogan" replace="toboggan"/>
    <item find="de bon grès" replace="de bon gré"/>
    <item find="laors" replace="alors"/>
    <item find="diplome" replace="diplôme"/>
    <item find="défence" replace="défense"/>
    <item find="poitn" replace="point"/>
    <item find="par dessus" replace="par-dessus"/>
    <item find="ellaborées" replace="élaborées"/>
    <item find="vers d'eau" replace="verre d'eau"/>
    <item find="renouvellée" replace="renouvelé"/>
    <item find="antécédant" replace="antécédent"/>
    <item find="ajourd'hui" replace="aujourd'hui"/>
    <item find="otée" replace="ôtée"/>
    <item find="sourd muet" replace="sourd-muet"/>
    <item find="comores" replace="Comores"/>
    <item find="bétise" replace="bêtise"/>
    <item find="exessif" replace="excessif"/>
    <item find="un calcule" replace="un calcul"/>
    <item find="ellaborés" replace="élaborés"/>
    <item find="porgrammes" replace="programmes"/>
    <item find="fachée" replace="fâchée"/>
    <item find="haut relief" replace="haut-relief"/>
    <item find="sous estimée" replace="sous-estimée"/>
    <item find="eau de chaud" replace="eau de chaux"/>
    <item find="un fabriquant" replace="un fabricant"/>
    <item find="wallis" replace="Wallis"/>
    <item find="Allo" replace="Allô"/>
    <item find="jacinte" replace="jacinthe"/>
    <item find="quand à" replace="quant à"/>
    <item find="imobile" replace="immobile"/>
    <item find="logitiel" replace="logiciel"/>
    <item find="facher" replace="fâcher"/>
    <item find="boitiers" replace="boîtiers"/>
    <item find="acoster" replace="accoster"/>
    <item find="aex" replace="axe"/>
    <item find="fachées" replace="fâchées"/>
    <item find="vos cotés" replace="vos côtés"/>
    <item find="chaines" replace="chaînes"/>
    <item find="trainé" replace="traîné"/>
    <item find="meler" replace="mêler"/>
    <item find="pipe line" replace="pipe-line"/>
    <item find="toi même" replace="toi-même"/>
    <item find="dixaine" replace="dizaine"/>
    <item find="grand peine" replace="grand-peine"/>
    <item find="microproceseur" replace="microprocesseur"/>
    <item find="super-utilisateur" replace="superutilisateur"/>
    <item find="Je mais" replace="Je mets"/>
    <item find="c'est à-dire" replace="c'est-à-dire"/>
    <item find="c.à.d." replace="c.-à-d."/>
    <item find="sinonimes" replace="synonymes"/>
    <item find="rotir" replace="rôtir"/>
    <item find="muffle" replace="mufle"/>
    <item find="chacuns" replace="chacun"/>
    <item find="aujurd'hui" replace="aujourd'hui"/>
    <item find="allo" replace="allô"/>
    <item find="autatn" replace="autant"/>
    <item find="virsu" replace="virus"/>
    <item find="çette" replace="cette"/>
    <item find="mittes" replace="mites"/>
    <item find="parceque" replace="parce que"/>
    <item find="fchiers" replace="fichiers"/>
    <item find="rez de chaussée" replace="rez-de-chaussée"/>
    <item find="sous estimer" replace="sous-estimer"/>
    <item find="resoud il" replace="résout-il"/>
    <item find="esse-que" replace="est-ce que"/>
    <item find="parlementare" replace="parlementaire"/>
    <item find="mal en point" replace="mal-en-point"/>
    <item find="Hors," replace="Or,"/>
    <item find="avsi" replace="avis"/>
    <item find="exellent" replace="excellent"/>
    <item find="couremment" replace="couramment"/>
    <item find="Dés que" replace="Dès que"/>
    <item find="melé" replace="mêlé"/>
    <item find="brulante" replace="brûlante"/>
    <item find="trapèse" replace="trapèze"/>
    <item find="un insère" replace="un insert"/>
    <item find="changemetns" replace="changements"/>
    <item find="cerf-volants" replace="cerfs-volants"/>
    <item find="parrin" replace="parrain"/>
    <item find="régél" replace="réglé"/>
    <item find="oté" replace="ôté"/>
    <item find="Blumenal" replace="Blumenau"/>
    <item find="siphylis" replace="syphilis"/>
    <item find="recomander" replace="recommander"/>
    <item find="soit disant" replace="soi-disant"/>
    <item find="glof" replace="golf"/>
    <item find="aller de paire" replace="aller de pair"/>
    <item find="le foi" replace="le foie"/>
    <item find="Met avis" replace="M'est avis"/>
    <item find="environment" replace="environnement"/>
    <item find="abimés" replace="abîmés"/>
    <item find="point-virgules" replace="points-virgules"/>
    <item find="peids" replace="pieds"/>
    <item find="vis à vis" replace="vis-à-vis"/>
    <item find="libre échangiste" replace="libre-échangiste"/>
    <item find="bosi" replace="bois"/>
    <item find="piques-niques" replace="pique-niques"/>
    <item find="celle là" replace="celle-là"/>
    <item find="htp://" replace="http://"/>
    <item find="elle transfert" replace="elle transfère"/>
    <item find="optionelle" replace="optionnelle"/>
    <item find="fraicheur" replace="fraîcheur"/>
    <item find="Irladne" replace="Irlande"/>
    <item find="trainer" replace="traîner"/>
    <item find="bolcs" replace="blocs"/>
    <item find="burundi" replace="Burundi"/>
    <item find="une animalcule" replace="un animalcule"/>
    <item find="tes cotés" replace="tes côtés"/>
    <item find="agraffe" replace="agrafe"/>
    <item find="continuement" replace="continûment"/>
    <item find="maréchal ferrant" replace="maréchal-ferrant"/>
    <item find="pare brise" replace="pare-brise"/>
    <item find="le souffre" replace="le soufre"/>
    <item find="super-marchés" replace="supermarchés"/>
    <item find="appui-têtes" replace="appuis-tête"/>
    <item find="différend de" replace="différent de"/>
    <item find="un précédant" replace="un précédent"/>
    <item find="Etant" replace="Étant"/>
    <item find="les résidants" replace="les résidents"/>
    <item find="trone" replace="trône"/>
    <item find="baffouiller" replace="bafouiller"/>
    <item find="http:\\" replace="http://"/>
    <item find="il sans va" replace="il s'en va"/>
    <item find="au dépens" replace="aux dépens"/>
    <item find="boitier" replace="boîtier"/>
    <item find="accolytes" replace="acolytes"/>
    <item find="lesson" replace="leçon"/>
    <item find="axu" replace="aux"/>
    <item find="tepms" replace="temps"/>
    <item find="le sucés" replace="le succès"/>
    <item find="flêches" replace="flèches"/>
    <item find="guet apens" replace="guet-apens"/>
    <item find="celui-la" replace="celui-là"/>
    <item find="de tel sorte" replace="de telle sorte"/>
    <item find="ont investit" replace="ont investi"/>
    <item find="prud homme" replace="prud'homme"/>
    <item find="une haltère" replace="un haltère"/>
    <item find="cauchemards" replace="cauchemars"/>
    <item find="soleil" replace="Soleil"/>
    <item find="garde barrière" replace="garde-barrière"/>
    <item find="rafraichissement" replace="rafraîchissement"/>
    <item find="tantot" replace="tantôt"/>
    <item find="pantouffle" replace="pantoufle"/>
    <item find="plein pied" replace="plain-pied"/>
    <item find="dûe" replace="due"/>
    <item find="prud hommes" replace="prud'hommes"/>
    <item find="il transfert" replace="il transfère"/>
    <item find="Ile de France" replace="Île-de-France"/>
    <item find="décroitre" replace="décroître"/>
    <item find="est choisit" replace="est choisi"/>
    <item find="congo" replace="Congo"/>
    <item find="dixaines" replace="dizaines"/>
    <item find="anévrysmes" replace="anévrismes"/>
    <item find="imobiles" replace="immobiles"/>
    <item find="il survie" replace="il survit"/>
    <item find="côte d'ivoire" replace="Côte d'Ivoire"/>
    <item find="un détaille" replace="un détail"/>
    <item find="avrli" replace="avril"/>
    <item find="exigues" replace="exiguës"/>
    <item find="naviguer au pré" replace="naviguer au près"/>
    <item find="appuis-têtes" replace="appuis-tête"/>
    <item find="francaises" replace="françaises"/>
    <item find="htpp://" replace="http://"/>
    <item find="appellé" replace="appelé"/>
    <item find="demi heure" replace="demi-heure"/>
    <item find="fraiche" replace="fraîche"/>
    <item find="il fourni" replace="il fournit"/>
    <item find="soutiens-gorges" replace="soutiens-gorge"/>
    <item find="quand-même" replace="quand même"/>
    <item find="identation" replace="indentation"/>
    <item find="recomandées" replace="recommandées"/>
    <item find="canoé" replace="canoë"/>
    <item find="précosse" replace="précoce"/>
    <item find="couluers" replace="couleurs"/>
    <item find="Basses Pyrénées" replace="Basses-Pyrénées"/>
    <item find="chef d'oeuvre" replace="chef-d'oeuvre"/>
    <item find="Torvald" replace="Torvalds"/>
    <item find="acumulé" replace="accumulé"/>
    <item find="asssises" replace="assises"/>
    <item find="sinonymes" replace="synonymes"/>
    <item find="acceuil" replace="accueil"/>
    <item find="erronnée" replace="erronée"/>
    <item find="Au moment ou" replace="Au moment où"/>
    <item find="elle fourni" replace="elle fournit"/>
    <item find="fachés" replace="fâchés"/>
    <item find="laisser-passer" replace="laissez-passer"/>
    <item find="cetrain" replace="certain"/>
    <item find="le fois" replace="le foie"/>
    <item find="le résidant" replace="le résident"/>
    <item find="un ecchymose" replace="une ecchymose"/>
    <item find="Tu mais" replace="Tu mets"/>
    <item find="honnète" replace="honnête"/>
    <item find="amortissment" replace="amortissement"/>
    <item find="il choisi" replace="il choisit"/>
    <item find="annullée" replace="annulée"/>
    <item find="encâblures" replace="encablures"/>
    <item find="demandes-lui" replace="demande-lui"/>
    <item find="les un" replace="les uns"/>
    <item find="pantomine" replace="pantomime"/>
    <item find="hopitaux" replace="hôpitaux"/>
    <item find="acr" replace="arc"/>
    <item find="aieul" replace="aïeul"/>
    <item find="un équivalant" replace="un équivalent"/>
    <item find="indû" replace="indu"/>
    <item find="Mr" replace="M."/>
    <item find="super utilisateur" replace="superutilisateur"/>
    <item find="courronnes" replace="couronnes"/>
    <item find="chaques" replace="chaque"/>
    <item find="autoinduction" replace="auto-induction"/>
    <item find="celui-çi" replace="celui-ci"/>
    <item find="Esquimeau" replace="Esquimau"/>
    <item find="un pronostique" replace="un pronostic"/>
    <item find="super-ordinateur" replace="superordinateur"/>
    <item find="afiche" replace="affiche"/>
    <item find="hair" replace="haïr"/>
    <item find="brulants" replace="brûlants"/>
    <item find="aller entrain" replace="aller en train"/>
    <item find="ralongés" replace="rallongés"/>
    <item find="un épistaxis" replace="une épistaxis"/>
    <item find="copu" replace="coup"/>
    <item find="cette après-midi" replace="cet après-midi"/>
    <item find="règlée" replace="réglée"/>
    <item find="c'est-a-dire" replace="c'est-à-dire"/>
    <item find="sori" replace="soir"/>
    <item find="Http://" replace="http://"/>
    <item find="c'est à dire" replace="c'est-à-dire"/>
    <item find="une planisphère" replace="un planisphère"/>
    <item find="voute" replace="voûte"/>
    <item find="une astérisque" replace="un astérisque"/>
    <item find="elle boîte" replace="elle boite"/>
    <item find="suffisemment" replace="suffisamment"/>
    <item find="tannières" replace="tanières"/>
    <item find="angleterre" replace="Angleterre"/>
    <item find="remue ménage" replace="remue-ménage"/>
    <item find="recomandée" replace="recommandée"/>
    <item find="près salés" replace="prés salés"/>
    <item find="règler" replace="régler"/>
    <item find="empiètement" replace="empiétement"/>
    <item find="Cepedant" replace="Cependant"/>
    <item find="ontario" replace="Ontario"/>
    <item find="rwanda" replace="Rwanda"/>
    <item find="faisnat" replace="faisant"/>
    <item find="parlementares" replace="parlementaires"/>
    <item find="accés" replace="accès"/>
    <item find="masi" replace="mais"/>
    <item find="il conseil" replace="il conseille"/>
    <item find="pie mère" replace="pie-mère"/>
    <item find="une anathème" replace="un anathème"/>
    <item find="infractus" replace="infarctus"/>
    <item find="règlage" replace="réglage"/>
    <item find="taindre" replace="teindre"/>
    <item find="bonne après-midi" replace="bon après-midi"/>
    <item find="joaillers" replace="joailliers"/>
    <item find="sursoir" replace="surseoir"/>
    <item find="Thorvalds" replace="Torvalds"/>
    <item find="ognons" replace="oignons"/>
    <item find="poitns" replace="points"/>
    <item find="adanboné" replace="abandonné"/>
    <item find="tout a fait" replace="tout à fait"/>
    <item find="tannière" replace="tanière"/>
    <item find="colone" replace="colonne"/>
    <item find="Cependatn" replace="Cependant"/>
    <item find="brucelle" replace="brucelles"/>
    <item find="boute en train" replace="boute-en-train"/>
    <item find="utilsateur" replace="utilisateur"/>
    <item find="nourir" replace="nourrir"/>
    <item find="trait de faction" replace="trait de fraction"/>
    <item find="que un" replace="qu'un"/>
    <item find="aréodromes" replace="aérodromes"/>
    <item find="mea culpa" replace="mea-culpa"/>
    <item find="sépcifique" replace="spécifique"/>
    <item find="male" replace="mâle"/>
    <item find="kioske" replace="kiosque"/>
    <item find="pèriode" replace="période"/>
    <item find="ban de sable" replace="banc de sable"/>
    <item find="boite" replace="boîte"/>
    <item find="sous marins" replace="sous-marins"/>
    <item find="des on dit" replace="des on-dit"/>
    <item find="batards" replace="bâtards"/>
    <item find="impots" replace="impôts"/>
    <item find="irlande" replace="Irlande"/>
    <item find="aux dépend" replace="aux dépens"/>
    <item find="gnôme" replace="gnome"/>
    <item find="ralongé" replace="rallongé"/>
    <item find="lotto" replace="loto"/>
    <item find="aigüe" replace="aiguë"/>
    <item find="ua" replace="au"/>
    <item find="diplomes" replace="diplômes"/>
    <item find="ambigüe" replace="ambiguë"/>
    <item find="garde boue" replace="garde-boue"/>
    <item find="exhorbitant" replace="exorbitant"/>
    <item find="tempettes" replace="tempêtes"/>
    <item find="exigant" replace="exigeant"/>
    <item find="parlementère" replace="parlementaire"/>
    <item find="on y survie" replace="on y survit"/>
    <item find="celulle" replace="cellule"/>
    <item find="bèche" replace="bêche"/>
    <item find="languages" replace="langages"/>
    <item find="occurences" replace="occurrences"/>
    <item find="mouffle" replace="moufle"/>
    <item find="est suffisent" replace="est suffisant"/>
    <item find="nosu" replace="nous"/>
    <item find="pèse bébé" replace="pèse-bébés"/>
    <item find="bien disant" replace="bien-disant"/>
    <item find="charète" replace="charrette"/>
    <item find="saturne" replace="Saturne"/>
    <item find="bas fond" replace="bas-fond"/>
    <item find="arc en ciel" replace="arc-en-ciel"/>
    <item find="va nu pieds" replace="va-nu-pieds"/>
    <item find="afiché" replace="affiché"/>
    <item find="celle-çi" replace="celle-ci"/>
    <item find="pê" replace="peut-être"/>
    <item find="jamias" replace="jamais"/>
    <item find="dilemne" replace="dilemme"/>
    <item find="annullées" replace="annulées"/>
    <item find="tu mais" replace="tu mets"/>
    <item find="pares-brise" replace="pare-brise"/>
    <item find="appercevoir" replace="apercevoir"/>
    <item find="mio" replace="moi"/>
    <item find="suprème" replace="suprême"/>
    <item find="espagne" replace="Espagne"/>
    <item find="une sourit" replace="une souris"/>
    <item find="on en a pas" replace="on n'en a pas"/>
    <item find="je peut" replace="je peux"/>
    <item find="apperçus" replace="aperçus"/>
    <item find="crètes" replace="crêtes"/>
    <item find="celui là" replace="celui-là"/>
    <item find="accajou" replace="acajou"/>
    <item find="epnse" replace="pense"/>
    <item find="a définit" replace="a défini"/>
    <item find="vous plaie" replace="vous plaît"/>
    <item find="que que soie" replace="quel que soit"/>
    <item find="quitance" replace="quittance"/>
    <item find="france" replace="France"/>
    <item find="Sera t'il" replace="Sera-t-il"/>
    <item find="dégats" replace="dégâts"/>
    <item find="jupiter" replace="Jupiter"/>
    <item find="allieurs" replace="ailleurs"/>
    <item find="règlages" replace="réglages"/>
    <item find="incomoder" replace="incommoder"/>
    <item find="renouvellé" replace="renouvelé"/>
    <item find="belgique" replace="Belgique"/>
    <item find="trouble fête" replace="trouble-fête"/>
    <item find="exédent" replace="excédent"/>
    <item find="à peu prêt" replace="à peu près"/>
    <item find="elle calcul" replace="elle calcule"/>
    <item find="petit suisse" replace="petit-suisse"/>
    <item find="Par contre" replace="En revanche"/>
    <item find="soul" replace="saoul"/>
    <item find="apperçu" replace="aperçu"/>
    <item find="décu" replace="déçu"/>
    <item find="futuna" replace="Futuna"/>
    <item find="intérets" replace="intérêts"/>
    <item find="multi-utilisateurs" replace="multiutilisateur"/>
    <item find="suisse" replace="Suisse"/>
    <item find="parmis" replace="parmi"/>
    <item find="ralonger" replace="rallonge"/>
    <item find="ouies" replace="ouïes"/>
    <item find="fxa" replace="fax"/>
    <item find="je ne sais quoi" replace="je-ne-sais-quoi"/>
    <item find="Paques" replace="Pâques"/>
    <item find="batarde" replace="bâtarde"/>
    <item find="pince nez" replace="pince-nez"/>
    <item find="aretes" replace="arêtes"/>
    <item find="francaise" replace="française"/>
    <item find="contre jour" replace="contre-jour"/>
    <item find="neptune" replace="Neptune"/>
    <item find="qu'en dira-t'on" replace="qu'en-dira-t-on"/>
    <item find="je suie" replace="je suis"/>
    <item find="au dessus" replace="au-dessus"/>
    <item find="ambigüité " replace="ambiguïté "/>
    <item find="une boite" replace="une boîte"/>
    <item find="point virgule" replace="point-virgule"/>
    <item find="haut le corps" replace="haut-le-corps"/>
    <item find="les votres" replace="les vôtres"/>
    <item find="à peu prés" replace="à peu près"/>
    <item find="inconditionel" replace="inconditionnel"/>
    <item find="a conçut" replace="a conçu"/>
    <item find="A-t'il" replace="A-t-il"/>
    <item find="anée" replace="année"/>
    <item find="Bonne après-midi" replace="Bon après-midi"/>
    <item find="pantouffles" replace="pantoufles"/>
    <item find="enquètes" replace="enquêtes"/>
    <item find="collinne" replace="colline"/>
    <item find="une acrostiche" replace="un acrostiche"/>
    <item find="courrones" replace="couronnes"/>
    <item find="résidance" replace="résidence"/>
    <item find="a reçut" replace="a reçu"/>
    <item find="par devant" replace="par-devant"/>
    <item find="colines" replace="collines"/>
    <item find="chausse trape" replace="chausse-trape"/>
    <item find="auto induction" replace="autoinduction"/>
    <item find="cameroun" replace="Cameroun"/>
    <item find="hate" replace="hâte"/>
    <item find="financiaires" replace="financières"/>
    <item find="batême" replace="baptêmes"/>
    <item find="niger" replace="Niger"/>
    <item find="sous estimé" replace="sous-estimé"/>
    <item find="joalier" replace="joaillier"/>
    <item find="polygône" replace="polygone"/>
    <item find="pique assiette" replace="pique-assiette"/>
    <item find="du souffre" replace="du soufre"/>
    <item find="aconte" replace="acompte"/>
    <item find="isl" replace="ils"/>
    <item find="jutse" replace="juste"/>
    <item find="erronnées" replace="erronées"/>
    <item find="maitre" replace="maître"/>
    <item find="a investit" replace="a investi"/>
    <item find="tio" replace="toi"/>
    <item find="Allemange" replace="Allemagne"/>
    <item find="une arcane" replace="un arcane"/>
    <item find="lune" replace="Lune"/>
    <item find="hors la loi" replace="hors-la-loi"/>
    <item find="continument" replace="continûment"/>
    <item find="portugal" replace="Portugal"/>
    <item find="artisna" replace="artisan"/>
    <item find="oui-dire" replace="ouï-dire"/>
    <item find="parteau" replace="marteau"/>
    <item find="cerf volant" replace="cerf-volant"/>
    <item find="oui dire" replace="ouï-dire"/>
    <item find="un diagnostique" replace="un diagnostic"/>
    <item find="ralongées" replace="rallongées"/>
    <item find="abscent" replace="absent"/>
    <item find="voutes" replace="voûtes"/>
    <item find="fihciers" replace="fichiers"/>
    <item find="changment" replace="changement"/>
    <item find="À posteriori" replace="A posteriori"/>
    <item find="fils a papa" replace="fils à papa"/>
    <item find="jacynthes" replace="jacinthes"/>
    <item find="dégat" replace="dégât"/>
    <item find="ainée" replace="aînée"/>
    <item find="mardi gras" replace="Mardi gras"/>
    <item find="exigue" replace="exiguë"/>
    <item find="brulure" replace="brûlure"/>
    <item find="exeptions" replace="exceptions"/>
    <item find="elle aperçu" replace="elle aperçut"/>
    <item find="appat" replace="appât"/>
    <item find="comportment" replace="comportement"/>
    <item find="lui même" replace="lui-même"/>
    <item find="il investi" replace="il investit"/>
    <item find="noël" replace="Noël"/>
    <item find="Et bien," replace="Eh bien,"/>
    <item find="occurence" replace="occurrence"/>
    <item find="aréodrome" replace="aérodrome"/>
    <item find="héroisme" replace="héroïsme"/>
    <item find="aieux" replace="aïeux"/>
    <item find="elles mêmes" replace="elles-mêmes"/>
    <item find="impresions" replace="impressions"/>
    <item find="Ceci sont" replace="Ceux-ci sont"/>
    <item find="se vente" replace="se vante"/>
    <item find="a subit" replace="a subi"/>
    <item find="poids de senteur" replace="pois de senteur"/>
    <item find="pole" replace="pôle"/>
    <item find="guèpe" replace="guêpe"/>
    <item find="sinonyme" replace="synonyme"/>
    <item find="tout à fais" replace="tout à fait"/>
    <item find="compotte" replace="compote"/>
    <item find="anévrysme" replace="anévrisme"/>
    <item find="crèpes" replace="crêpes"/>
    <item find="mian" replace="main"/>
    <item find="Bien sur" replace="Bien sûr"/>
    <item find="batardes" replace="bâtardes"/>
    <item find="baclés" replace="bâclés"/>
    <item find="quel que soie" replace="quel que soit"/>
    <item find="débur" replace="début"/>
    <item find="autremnt" replace="autrement"/>
    <item find="alosr" replace="alors"/>
    <item find="artisant" replace="artisan"/>
    <item find="trainée" replace="traînée"/>
    <item find="laissé pour compte" replace="laissé-pour-compte"/>
    <item find="Irelande" replace="Irlande"/>
    <item find="raper" replace="râper"/>
    <item find="grand chose" replace="grand-chose"/>
    <item find="bas relief" replace="bas-relief"/>
    <item find="fchier" replace="fichier"/>
    <item find="lerus" replace="leurs"/>
    <item find="bon grès mal grès" replace="bon gré mal gré"/>
    <item find="vénus" replace="Vénus"/>
    <item find="une effluve" replace="un effluve"/>
    <item find="lyon" replace="Lyon"/>
    <item find="ils son" replace="ils sont"/>
    <item find="distention" replace="distension"/>
    <item find="acomte" replace="acompte"/>
    <item find="que une" replace="qu'une"/>
    <item find="auto-correction" replace="autocorrection"/>
    <item find="ABC1" replace="test test test"/>
    <item find="rond-points" replace="ronds-points"/>
    <item find="par delà" replace="par-delà"/>
    <item find="un travestit" replace="un travesti"/>
    <item find="étainte" replace="éteinte"/>
    <item find="otés" replace="ôtés"/>
    <item find="rapes" replace="râpes"/>
    <item find="finlande" replace="Finlande"/>
    <item find="rève" replace="rêve"/>
    <item find="sinonime" replace="synonyme"/>
    <item find="façon à ce que" replace="façon que"/>
    <item find="mauritanie" replace="Mauritanie"/>
    <item find="diner" replace="dîner"/>
    <item find="crèpe" replace="crêpe"/>
    <item find="sosu" replace="sous"/>
    <item find="aolrs" replace="alors"/>
    <item find="super-forme" replace="superforme"/>
    <item find="erronné" replace="erroné"/>
    <item find="bec de cane" replace="bec-de-cane"/>
    <item find="avatn" replace="avant"/>
    <item find="exeptés" replace="exceptés"/>
    <item find="dépots" replace="dépôts"/>
    <item find="accompte" replace="acompte"/>
    <item find="pétrol" replace="pétrole"/>
    <item find="un escarre" replace="une escarre"/>
    <item find="qu'en dira-t-on" replace="qu'en-dira-t-on"/>
    <item find="On est pas" replace="On n'est pas"/>
    <item find="informatitien" replace="informaticien"/>
    <item find="exhorbitante" replace="exorbitante"/>
    <item find="il travail" replace="il travaille"/>
    <item find="ellaboré" replace="élaboré"/>
    <item find="haut commissariat" replace="haut-commissariat"/>
    <item find="de mon plein grès" replace="de mon plein gré"/>
    <item find="leurs cotés" replace="leurs côtés"/>
    <item find="nues propriétés" replace="nues-propriétés"/>
    <item find="la plais" replace="la plaie"/>
    <item find="saurait il" replace="saurait-il"/>
    <item find="probleme" replace="problème"/>
    <item find="cables" replace="câbles"/>
    <item find="amortisement" replace="amortissement"/>
    <item find="le champs" replace="le champ"/>
    <item find="rectifier le tire" replace="rectifier le tir"/>
    <item find="prè salé" replace="pré-salé"/>
    <item find="un mets" replace="un met"/>
    <item find="a propos" replace="à propos"/>
    <item find="impresion" replace="impression"/>
    <item find="pitare" replace="pirate"/>
    <item find="fraiches" replace="fraîches"/>
    <item find="exhorbitantes" replace="exorbitantes"/>
    <item find="passport" replace="passeport"/>
    <item find="chef lieu" replace="chef-lieu"/>
    <item find="maraton" replace="marathon"/>
    <item find="eux mêmes" replace="eux-mêmes"/>
    <item find="groseillers" replace="groseilliers"/>
    <item find="je travail" replace="je travaille"/>
    <item find="moi qui suit" replace="moi qui suis"/>
    <item find="utilser" replace="utiliser"/>
    <item find="amre" replace="arme"/>
    <item find="hètres" replace="hêtres"/>
    <item find="ficiers" replace="fichiers"/>
    <item find="là-même" replace="là même"/>
    <item find="russie" replace="Russie"/>
    <item find="programe" replace="programme"/>
    <item find="au-dela" replace="au-delà"/>
    <item find="cou de pied" replace="cou-de-pied"/>
    <item find="il peux" replace="il peut"/>
    <item find="mitte" replace="mite"/>
    <item find="reine claude" replace="reine-claude"/>
    <item find="arreté" replace="arrêté"/>
    <item find="hatu" replace="haut"/>
    <item find="àla" replace="à la"/>
    <item find="Cependent" replace="Cependant"/>
    <item find="une apogée" replace="un apogée"/>
    <item find="porbable" replace="probable"/>
    <item find="on est pas" replace="on n'est pas"/>
    <item find="sous main" replace="sous-main"/>
    <item find="recomandé" replace="recommandé"/>
    <item find="ralonge" replace="rallonge"/>
    <item find="défault" replace="défaut"/>
    <item find="atôme" replace="atome"/>
    <item find="utliser" replace="utiliser"/>
    <item find="sauf conduit" replace="sauf-conduit"/>
    <item find="obélix" replace="obélisque"/>
    <item find="une hémisphère" replace="un hémisphère"/>
    <item find="monoiodé" replace="mono-iodé"/>
    <item find="celà" replace="cela"/>
    <item find="monaco" replace="Monaco"/>
    <item find="trainées" replace="traînées"/>
    <item find="Quand à" replace="Quant à"/>
    <item find="joailler" replace="joaillier"/>
    <item find="controleurs" replace="contrôleurs"/>
    <item find="ici bas" replace="ici-bas"/>
    <item find="québec" replace="Québec"/>
    <item find="c'st" replace="c'est"/>
    <item find="au devant" replace="au-devant"/>
    <item find="un conseille" replace="un conseil"/>
    <item find="deça" replace="deçà"/>
    <item find="couleru" replace="couleur"/>
    <item find="la-bas" replace="là-bas"/>
    <item find="hors d'oeuvre" replace="hors-d'oeuvre"/>
    <item find="ralongée" replace="rallongée"/>
    <item find="plateformes" replace="plates-formes"/>
    <item find="guinée-conakry" replace="Guinée-Conakry"/>
    <item find="s'insert" replace="s'insère"/>
    <item find="abscice" replace="abscisse"/>
    <item find="singature" replace="signature"/>
    <item find="agraffes" replace="agrafes"/>
    <item find="presqu'ile" replace="presqu'île"/>
  </items>
  <UpperCaseExceptions>
    <word exception="env."/>
    <word exception="op."/>
    <word exception="F."/>
    <word exception="e."/>
    <word exception="r."/>
    <word exception="min."/>
    <word exception="ex."/>
    <word exception="inf."/>
    <word exception="g."/>
    <word exception="id."/>
    <word exception="n."/>
    <word exception="ndlr."/>
    <word exception="apr."/>
    <word exception="max."/>
    <word exception="cf."/>
    <word exception="O."/>
    <word exception="N."/>
    <word exception="T."/>
    <word exception="ch."/>
    <word exception="d."/>
    <word exception="av."/>
    <word exception="V."/>
    <word exception="P."/>
    <word exception="p."/>
    <word exception="à."/>
    <word exception="-l."/>
    <word exception="cit."/>
    <word exception="M."/>
    <word exception="B."/>
    <word exception="t."/>
    <word exception="chap."/>
    <word exception="loc."/>
    <word exception="c."/>
    <word exception="ndt."/>
    <word exception="tél."/>
    <word exception="-O."/>
    <word exception="MM."/>
    <word exception="i."/>
    <word exception="s."/>
    <word exception="U."/>
    <word exception="hab."/>
    <word exception="J."/>
    <word exception="C."/>
    <word exception="I."/>
    <word exception="-C."/>
  </UpperCaseExceptions>
  <TwoUpperLetterExceptions>
    <word exception="GWh"/>
    <word exception="KPrinter"/>
    <word exception="OOo"/>
    <word exception="GW"/>
    <word exception="MT"/>
    <word exception="MJ"/>
    <word exception="KDevelop"/>
    <word exception="KMail"/>
    <word exception="MHz"/>
    <word exception="GHz"/>
    <word exception="KSpread"/>
    <word exception="KPat"/>
    <word exception="MWh"/>
    <word exception="KStars"/>
    <word exception="KPresenter"/>
    <word exception="KBabel"/>
    <word exception="KWord"/>
    <word exception="KTuberling"/>
    <word exception="KOffice"/>
    <word exception="MW"/>
    <word exception="KNode"/>
  </TwoUpperLetterExceptions>
  <DoubleQuote>
    <doublequote begin="“" end="”"/>
  </DoubleQuote>
  <SimpleQuote>
    <simplequote begin="‘" end="’"/>
  </SimpleQuote>
</Word>
07070100000021000081A40000000200000002000000015CDAA3940000F270000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/data/custom-fr.xml<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE autocorrection>
<Word>
  <items>
    <item find="ainé" replace="aîné"/>
    <item find="mes cotés" replace="mes côtés"/>
    <item find="presqu'ile" replace="presqu'île"/>
    <item find="tempètes" replace="tempêtes"/>
    <item find="mourrir" replace="mourir"/>
    <item find="hopital" replace="hôpital"/>
    <item find="accolytes" replace="acolytes"/>
    <item find="poeles" replace="poêles"/>
    <item find="Quelques soient" replace="Quels que soient"/>
    <item find="mithe" replace="mythe"/>
    <item find="baclé" replace="bâclé"/>
    <item find="parrin" replace="parrain"/>
    <item find="je ne sais quoi" replace="je-ne-sais-quoi"/>
    <item find="bas relief" replace="bas-relief"/>
    <item find="déviser" replace="dévisser"/>
    <item find="c'est-à dire" replace="c'est-à-dire"/>
    <item find="multi-tâche" replace="multitâche"/>
    <item find="pétrol" replace="pétrole"/>
    <item find="gouter" replace="goûter"/>
    <item find="prudamment" replace="prudemment"/>
    <item find="enquèter" replace="enquêter"/>
    <item find="aréodrome" replace="aérodrome"/>
    <item find="optionels" replace="optionnels"/>
    <item find="sorte à ce que" replace="sorte que"/>
    <item find="quitances" replace="quittances"/>
    <item find="mort né" replace="mort-né"/>
    <item find="informatitien" replace="informaticien"/>
    <item find="rond-points" replace="ronds-points"/>
    <item find="pois lourd" replace="poids lourd"/>
    <item find="haut commissariat" replace="haut-commissariat"/>
    <item find="la plait" replace="la plaie"/>
    <item find="comores" replace="Comores"/>
    <item find="super-utilisateur" replace="superutilisateur"/>
    <item find="mêche" replace="mèche"/>
    <item find="porte fenêtre" replace="porte-fenêtre"/>
    <item find="chaines" replace="chaînes"/>
    <item find="de plein grès" replace="de plein gré"/>
    <item find="celle là" replace="celle-là"/>
    <item find="a conclut" replace="a conclu"/>
    <item find="ouie" replace="ouïe"/>
    <item find="soit disant" replace="soi-disant"/>
    <item find="participassion" replace="participation"/>
    <item find="Ceci sont" replace="Ceux-ci sont"/>
    <item find="Cependent" replace="Cependant"/>
    <item find="Dés lors" replace="Dès lors"/>
    <item find="oter" replace="ôter"/>
    <item find="Quelque soit" replace="Quel que soit"/>
    <item find="exessivement" replace="excessivement"/>
    <item find="extrème" replace="extrême"/>
    <item find="bolcs" replace="blocs"/>
    <item find="pas tord" replace="pas tort"/>
    <item find="il calcul" replace="il calcule"/>
    <item find="elle survie" replace="elle survit"/>
    <item find="une abaque" replace="un abaque"/>
    <item find="le fois" replace="le foie"/>
    <item find="fihcier" replace="fichier"/>
    <item find="l'équivalant" replace="l'équivalent"/>
    <item find="tempettes" replace="tempêtes"/>
    <item find="son permit de conduire" replace="son permis de conduire"/>
    <item find="dilemne" replace="dilemme"/>
    <item find="bon grès mal grès" replace="bon gré mal gré"/>
    <item find="soi disant" replace="soi-disant"/>
    <item find="C'st" replace="C'est"/>
    <item find="vis a vis" replace="vis-à-vis"/>
    <item find="celulle" replace="cellule"/>
    <item find="trainées" replace="traînées"/>
    <item find="programes" replace="programmes"/>
    <item find="sous marins" replace="sous-marins"/>
    <item find="vis à vis" replace="vis-à-vis"/>
    <item find="petit-suisses" replace="petits-suisses"/>
    <item find="la mêle chose" replace="la même chose"/>
    <item find="il vous permets" replace="il vous permet"/>
    <item find="occurences" replace="occurrences"/>
    <item find="au dessus" replace="au-dessus"/>
    <item find="irlande" replace="Irlande"/>
    <item find="elles sons" replace="elles sont"/>
    <item find="fils a papa" replace="fils à papa"/>
    <item find="france" replace="France"/>
    <item find="francais" replace="français"/>
    <item find="francaises" replace="françaises"/>
    <item find="meler" replace="mêler"/>
    <item find="l'adhérant" replace="l'adhérent"/>
    <item find="ognons" replace="oignons"/>
    <item find="aconte" replace="acompte"/>
    <item find="un travaille" replace="un travail"/>
    <item find="alosr" replace="alors"/>
    <item find="sotn" replace="sont"/>
    <item find="ont aperçut" replace="ont aperçu"/>
    <item find="lieu dit" replace="lieu-dit"/>
    <item find="saurait il" replace="saurait-il"/>
    <item find="etre" replace="être"/>
    <item find="a subit" replace="a subi"/>
    <item find="une alvéole" replace="un alvéole"/>
    <item find="baches" replace="bâches"/>
    <item find="rèver" replace="rêver"/>
    <item find="règlage" replace="réglage"/>
    <item find="laissé pour compte" replace="laissé-pour-compte"/>
    <item find="ci devant" replace="ci-devant"/>
    <item find="de son plein grès" replace="de son plein gré"/>
    <item find="trainer" replace="traîner"/>
    <item find="oui-dire" replace="ouï-dire"/>
    <item find="remue ménage" replace="remue-ménage"/>
    <item find="cerf volant" replace="cerf-volant"/>
    <item find="pê" replace="peut-être"/>
    <item find="est fournit" replace="est fourni"/>
    <item find="vanuatu" replace="Vanuatu"/>
    <item find="chaine" replace="chaîne"/>
    <item find="Ayant suivit" replace="Ayant suivi"/>
    <item find="boitier" replace="boîtier"/>
    <item find="quand à" replace="quant à"/>
    <item find="tout a fait" replace="tout à fait"/>
    <item find="chaques" replace="chaque"/>
    <item find="ici-même" replace="ici même"/>
    <item find="bosi" replace="bois"/>
    <item find="une effluve" replace="un effluve"/>
    <item find="d'en train" replace="d'entrain"/>
    <item find="a propos" replace="à propos"/>
    <item find="joailler" replace="joaillier"/>
    <item find="fchiers" replace="fichiers"/>
    <item find="tempette" replace="tempête"/>
    <item find="exhorbitants" replace="exorbitants"/>
    <item find="facher" replace="fâcher"/>
    <item find="une apogée" replace="un apogée"/>
    <item find="sorite" replace="sortie"/>
    <item find="baffouillé" replace="bafouillé"/>
    <item find="dégat" replace="dégât"/>
    <item find="afiché" replace="affiché"/>
    <item find="russie" replace="Russie"/>
    <item find="courier" replace="courrier"/>
    <item find="est définit" replace="est défini"/>
    <item find="nouriture" replace="nourriture"/>
    <item find="mâçon" replace="maçon"/>
    <item find="conslutation" replace="consultation"/>
    <item find="super-ordinateur" replace="superordinateur"/>
    <item find="melé" replace="mêlé"/>
    <item find="Tu mais" replace="Tu mets"/>
    <item find="condanmé" replace="condamné"/>
    <item find="contre-ordre" replace="contrordre"/>
    <item find="acoster" replace="accoster"/>
    <item find="tatonner" replace="tâtonner"/>
    <item find="au moment ou" replace="au moment où"/>
    <item find="le permit de conduire" replace="le permis de conduire"/>
    <item find="passport" replace="passeport"/>
    <item find="bien disant" replace="bien-disant"/>
    <item find="identation" replace="indentation"/>
    <item find="ayant suivit" replace="ayant suivi"/>
    <item find="bècher" replace="bêcher"/>
    <item find="elle même" replace="elle-même"/>
    <item find="côte d'ivoire" replace="Côte d'Ivoire"/>
    <item find="précosse" replace="précoce"/>
    <item find="controlé" replace="contrôlé"/>
    <item find="haïti" replace="Haïti"/>
    <item find="tater" replace="tâter"/>
    <item find="ralongés" replace="rallongés"/>
    <item find="réveille matin" replace="réveille-matin"/>
    <item find="moi qui suit" replace="moi qui suis"/>
    <item find="tannière" replace="tanière"/>
    <item find="rectifié le tire" replace="rectifié le tir"/>
    <item find="couremment" replace="couramment"/>
    <item find="Je mais" replace="Je mets"/>
    <item find="agraffe" replace="agrafe"/>
    <item find="guadeloupe" replace="Guadeloupe"/>
    <item find="Irladne" replace="Irlande"/>
    <item find="apperçues" replace="aperçues"/>
    <item find="voute" replace="voûte"/>
    <item find="de mon plein grès" replace="de mon plein gré"/>
    <item find="haut le coeur" replace="haut-le-coeur"/>
    <item find="garde boue" replace="garde-boue"/>
    <item find="annullés" replace="annulés"/>
    <item find="ils son" replace="ils sont"/>
    <item find="est conçut" replace="est conçu"/>
    <item find="ça dépends" replace="ça dépend"/>
    <item find="libre échange" replace="libre-échange"/>
    <item find="accés" replace="accès"/>
    <item find="Bienvenu" replace="Bienvenue"/>
    <item find="apperçue" replace="aperçue"/>
    <item find="flêches" replace="flèches"/>
    <item find="leurs cotés" replace="leurs côtés"/>
    <item find="grand mère" replace="grand-mère"/>
    <item find="financiaires" replace="financières"/>
    <item find="renouvellé" replace="renouvelé"/>
    <item find="boitiers" replace="boîtiers"/>
    <item find="controleurs" replace="contrôleurs"/>
    <item find="sthétoscope" replace="stéthoscope"/>
    <item find="Ce pendant" replace="Cependant"/>
    <item find="on en a pas" replace="on n'en a pas"/>
    <item find="porbablement" replace="probablement"/>
    <item find="acumulé" replace="accumulé"/>
    <item find="poitn" replace="point"/>
    <item find="controler" replace="contrôler"/>
    <item find="A-t'il" replace="A-t-il"/>
    <item find="il boîte" replace="il boite"/>
    <item find="c'est à-dire" replace="c'est-à-dire"/>
    <item find="auto induction" replace="autoinduction"/>
    <item find="amortissment" replace="amortissement"/>
    <item find="ban de sable" replace="banc de sable"/>
    <item find="porgramme" replace="programme"/>
    <item find="cauchemards" replace="cauchemars"/>
    <item find="Met avis" replace="M'est avis"/>
    <item find="à peu pré" replace="à peu près"/>
    <item find="brulantes" replace="brûlantes"/>
    <item find="tu peut" replace="tu peux"/>
    <item find="la votre" replace="la vôtre"/>
    <item find="inquièter" replace="inquiéter"/>
    <item find="brulants" replace="brûlants"/>
    <item find="apperçu" replace="aperçu"/>
    <item find="probleme" replace="problème"/>
    <item find="est suffisent" replace="est suffisant"/>
    <item find="peids" replace="pieds"/>
    <item find="arpès" replace="après"/>
    <item find="condanmer" replace="condamner"/>
    <item find="extention" replace="extension"/>
    <item find="nue propriété" replace="nue-propriété"/>
    <item find="une denticule" replace="un denticule"/>
    <item find="logitiel" replace="logiciel"/>
    <item find="un pronostique" replace="un pronostic"/>
    <item find="inconditionelle" replace="inconditionnelle"/>
    <item find="Http://" replace="http://"/>
    <item find="celle-la" replace="celle-là"/>
    <item find="attaindre" replace="atteindre"/>
    <item find="muffle" replace="mufle"/>
    <item find="sursoir" replace="surseoir"/>
    <item find="jacintes" replace="jacinthes"/>
    <item find="exigues" replace="exiguës"/>
    <item find="verre de terre" replace="ver de terre"/>
    <item find="par dessus" replace="par-dessus"/>
    <item find="un transfère" replace="un transfert"/>
    <item find="sage femme" replace="sage-femme"/>
    <item find="àla" replace="à la"/>
    <item find="fxa" replace="fax"/>
    <item find="antrée" replace="entrée"/>
    <item find="un diagnostique" replace="un diagnostic"/>
    <item find="pilône" replace="pylône"/>
    <item find="suffir" replace="suffire"/>
    <item find="ciclysme" replace="cyclisme"/>
    <item find="sait il" replace="sait-il"/>
    <item find="encâblure" replace="encablure"/>
    <item find="aprés" replace="après"/>
    <item find="portugal" replace="Portugal"/>
    <item find="mouffle" replace="moufle"/>
    <item find="gout" replace="goût"/>
    <item find="poele" replace="poêle"/>
    <item find="ordinateru" replace="ordinateur"/>
    <item find="va et vient" replace="va-et-vient"/>
    <item find="chèr" replace="cher"/>
    <item find="sinonimes" replace="synonymes"/>
    <item find="prudhomme" replace="prud'homme"/>
    <item find="prè salé" replace="pré-salé"/>
    <item find="sous main" replace="sous-main"/>
    <item find="un adhérant" replace="un adhérent"/>
    <item find="a suivit" replace="a suivi"/>
    <item find="uqi" replace="qui"/>
    <item find="navigue au pré" replace="navigue au près"/>
    <item find="aolrs" replace="alors"/>
    <item find="exigant" replace="exigeant"/>
    <item find="courrone" replace="couronne"/>
    <item find="quand-même" replace="quand même"/>
    <item find="Par contre" replace="En revanche"/>
    <item find="je suie" replace="je suis"/>
    <item find="est-ce-que" replace="est-ce que"/>
    <item find="comportment" replace="comportement"/>
    <item find="ici bas" replace="ici-bas"/>
    <item find="bétise" replace="bêtise"/>
    <item find="astérique" replace="astérisque"/>
    <item find="erronnés" replace="erronés"/>
    <item find="chef lieu" replace="chef-lieu"/>
    <item find="bèche" replace="bêche"/>
    <item find="grèle" replace="grêle"/>
    <item find="faisnat" replace="faisant"/>
    <item find="pils" replace="plis"/>
    <item find="encâblures" replace="encablures"/>
    <item find="inquiette" replace="inquiète"/>
    <item find="courronnes" replace="couronnes"/>
    <item find="une plais" replace="une plaie"/>
    <item find="Au moment ou" replace="Au moment où"/>
    <item find="on calcul" replace="on calcule"/>
    <item find="inclue" replace="incluse"/>
    <item find="terre neuve" replace="terre-neuve"/>
    <item find="elle boîte" replace="elle boite"/>
    <item find="bonour" replace="bonjour"/>
    <item find="trainée" replace="traînée"/>
    <item find="prudhommes" replace="prud'hommes"/>
    <item find="chnagement" replace="changement"/>
    <item find="super utilisateur" replace="superutilisateur"/>
    <item find="c'est-a-dire" replace="c'est-à-dire"/>
    <item find="autrment" replace="autrement"/>
    <item find="arreté" replace="arrêté"/>
    <item find="language" replace="langage"/>
    <item find="quel que soie" replace="quel que soit"/>
    <item find="tio" replace="toi"/>
    <item find="la notre" replace="la nôtre"/>
    <item find="celui-la" replace="celui-là"/>
    <item find="nouvelle-calédonie" replace="Nouvelle-Calédonie"/>
    <item find="patietn" replace="patient"/>
    <item find="maraton" replace="marathon"/>
    <item find="coline" replace="colline"/>
    <item find="maroc" replace="Maroc"/>
    <item find="super-marchés" replace="supermarchés"/>
    <item find="héroisme" replace="héroïsme"/>
    <item find="une arcane" replace="un arcane"/>
    <item find="apperçus" replace="aperçus"/>
    <item find="otées" replace="ôtées"/>
    <item find="accajou" replace="acajou"/>
    <item find="procesus" replace="processus"/>
    <item find="Prés de" replace="Près de"/>
    <item find="polynésie" replace="Polynésie"/>
    <item find="dégats" replace="dégâts"/>
    <item find="saturne" replace="Saturne"/>
    <item find="meme" replace="même"/>
    <item find="nosu" replace="nous"/>
    <item find="liseré" replace="liséré"/>
    <item find="accompte" replace="acompte"/>
    <item find="fraiches" replace="fraîches"/>
    <item find="par acquis" replace="par acquit"/>
    <item find="cambodge" replace="Cambodge"/>
    <item find="tu mais" replace="tu mets"/>
    <item find="Par acquis" replace="Par acquit"/>
    <item find="une foie" replace="une fois"/>
    <item find="dixaines" replace="dizaines"/>
    <item find="ce pendant" replace="cependant"/>
    <item find="parteau" replace="marteau"/>
    <item find="mian" replace="main"/>
    <item find="tepms" replace="temps"/>
    <item find="c'est a vous" replace="c'est à vous"/>
    <item find="ouies" replace="ouïes"/>
    <item find="lotto" replace="loto"/>
    <item find="honnète" replace="honnête"/>
    <item find="dûe" replace="due"/>
    <item find="totu" replace="tout"/>
    <item find="COMPUTer" replace="computer"/>
    <item find="piques-niques" replace="pique-niques"/>
    <item find="appat" replace="appât"/>
    <item find="masi" replace="mais"/>
    <item find="petit suisse" replace="petit-suisse"/>
    <item find="crûe" replace="crue"/>
    <item find="pitare" replace="pirate"/>
    <item find="je peut" replace="je peux"/>
    <item find="elle calcul" replace="elle calcule"/>
    <item find="obélix" replace="obélisque"/>
    <item find="Pyrennées" replace="Pyrénées"/>
    <item find="le votre" replace="le vôtre"/>
    <item find="contre-partie" replace="contrepartie"/>
    <item find="une planisphère" replace="un planisphère"/>
    <item find="elle fourni" replace="elle fournit"/>
    <item find="accolyte" replace="acolyte"/>
    <item find="parallèlle" replace="parallèle"/>
    <item find="haut commissaire" replace="haut-commissaire"/>
    <item find="mardi gras" replace="Mardi gras"/>
    <item find="le champs" replace="le champ"/>
    <item find="vers d'eau" replace="verre d'eau"/>
    <item find="trouble fête" replace="trouble-fête"/>
    <item find="des lors" replace="dès lors"/>
    <item find="navigue au prêt" replace="navigue au près"/>
    <item find="a reçut" replace="a reçu"/>
    <item find="taindre" replace="teindre"/>
    <item find="groseiller" replace="groseillier"/>
    <item find="algérie" replace="Algérie"/>
    <item find="cables" replace="câbles"/>
    <item find="un on dit" replace="un on-dit"/>
    <item find="intérets" replace="intérêts"/>
    <item find="sépcifiques" replace="spécifiques"/>
    <item find="concourrir" replace="concourir"/>
    <item find="erronnées" replace="erronées"/>
    <item find="chef d'oeuvre" replace="chef-d'oeuvre"/>
    <item find="colines" replace="collines"/>
    <item find="sépcifique" replace="spécifique"/>
    <item find="vosu" replace="vous"/>
    <item find="compotte" replace="compote"/>
    <item find="mali" replace="Mali"/>
    <item find="ficiers" replace="fichiers"/>
    <item find="résidances" replace="résidences"/>
    <item find="noyeau" replace="noyau"/>
    <item find="pare-brises" replace="pare-brise"/>
    <item find="ralongé" replace="rallongé"/>
    <item find="vasy" replace="vas-y"/>
    <item find="maos" replace="mais"/>
    <item find="donnes-moi" replace="donne-moi"/>
    <item find="impresion" replace="impression"/>
    <item find="htp://" replace="http://"/>
    <item find="courronne" replace="couronne"/>
    <item find="traine" replace="traîne"/>
    <item find="maurice" replace="Maurice"/>
    <item find="utilsateurs" replace="utilisateurs"/>
    <item find="défence" replace="défense"/>
    <item find="le publique" replace="le public"/>
    <item find="tout à fais" replace="tout à fait"/>
    <item find="fihciers" replace="fichiers"/>
    <item find="çette" replace="cette"/>
    <item find="haut fond" replace="haut-fond"/>
    <item find="exeptés" replace="exceptés"/>
    <item find="abscent" replace="absent"/>
    <item find="batard" replace="bâtard"/>
    <item find="rape" replace="râpe"/>
    <item find="super-oxyde" replace="superoxyde"/>
    <item find="bolc" replace="bloc"/>
    <item find="que que soie" replace="quel que soit"/>
    <item find="mon du" replace="mon dû"/>
    <item find="abisses" replace="abysses"/>
    <item find="aller entrain" replace="aller en train"/>
    <item find="astériques" replace="astérisques"/>
    <item find="appercevoir" replace="apercevoir"/>
    <item find="Haiti" replace="Haïti"/>
    <item find="ellaborées" replace="élaborées"/>
    <item find="sera t'il" replace="sera-t-il"/>
    <item find="amortisement" replace="amortissement"/>
    <item find="Marseilles" replace="Marseille"/>
    <item find="un expédiant" replace="un expédient"/>
    <item find="bruler" replace="brûler"/>
    <item find="Méditerrannée" replace="Méditerranée"/>
    <item find="pantouffle" replace="pantoufle"/>
    <item find="un insère" replace="un insert"/>
    <item find="une anathème" replace="un anathème"/>
    <item find="nu propriétaire" replace="nu-propriétaire"/>
    <item find="va de paire" replace="va de pair"/>
    <item find="identer" replace="indenter"/>
    <item find="pèse acide" replace="pèse-acides"/>
    <item find="libre échangiste" replace="libre-échangiste"/>
    <item find="main forte" replace="main-forte"/>
    <item find="changment" replace="changement"/>
    <item find="s'insert" replace="s'insère"/>
    <item find="arreter" replace="arrêter"/>
    <item find="batarde" replace="bâtarde"/>
    <item find="il survie" replace="il survit"/>
    <item find="appats" replace="appâts"/>
    <item find="wallis" replace="Wallis"/>
    <item find="mitte" replace="mite"/>
    <item find="asssis" replace="assis"/>
    <item find="pourir" replace="pourrir"/>
    <item find="Qui peux" replace="Qui peut"/>
    <item find="a conçut" replace="a conçu"/>
    <item find="la planisphère" replace="le planisphère"/>
    <item find="persiffler" replace="persifler"/>
    <item find="ils sons" replace="ils sont"/>
    <item find="au delà" replace="au-delà"/>
    <item find="anévrysmes" replace="anévrismes"/>
    <item find="parebrise" replace="pare-brise"/>
    <item find="qu'en dira-t-on" replace="qu'en-dira-t-on"/>
    <item find="ainées" replace="aînées"/>
    <item find="cales-pieds" replace="cale-pieds"/>
    <item find="gite" replace="gîte"/>
    <item find="le notre" replace="le nôtre"/>
    <item find="baffouiller" replace="bafouiller"/>
    <item find="gnôme" replace="gnome"/>
    <item find="bacler" replace="bâcler"/>
    <item find="melée" replace="mêlée"/>
    <item find="carreaus" replace="carreaux"/>
    <item find="partisant" replace="partisan"/>
    <item find="haut relief" replace="haut-relief"/>
    <item find="vénus" replace="Vénus"/>
    <item find="appui tête" replace="appui-tête"/>
    <item find="sous estimées" replace="sous-estimées"/>
    <item find="appéritifs" replace="apéritifs"/>
    <item find="pipe line" replace="pipe-line"/>
    <item find="renouvellées" replace="renouvelées"/>
    <item find="dépots" replace="dépôts"/>
    <item find="annuller" replace="annuler"/>
    <item find="ficheir" replace="fichier"/>
    <item find="réveil matin" replace="réveille-matin"/>
    <item find="recomande" replace="recommande"/>
    <item find="imobile" replace="immobile"/>
    <item find="fenetre" replace="fenêtre"/>
    <item find="tunisie" replace="Tunisie"/>
    <item find="Torvald" replace="Torvalds"/>
    <item find="porbable" replace="probable"/>
    <item find="allieurs" replace="ailleurs"/>
    <item find="Dés que" replace="Dès que"/>
    <item find="un apostrophe" replace="une apostrophe"/>
    <item find="crète" replace="crête"/>
    <item find="acceuil" replace="accueil"/>
    <item find="mal en point" replace="mal-en-point"/>
    <item find="olécrânes" replace="olécranes"/>
    <item find="se vente" replace="se vante"/>
    <item find="abscice" replace="abscisse"/>
    <item find="déja" replace="déjà"/>
    <item find="autatn" replace="autant"/>
    <item find="il sans va" replace="il s'en va"/>
    <item find="optionelle" replace="optionnelle"/>
    <item find="super-marché" replace="supermarché"/>
    <item find="continuement" replace="continûment"/>
    <item find="quète" replace="quête"/>
    <item find="au dessous" replace="au-dessous"/>
    <item find="allo" replace="allô"/>
    <item find="crûs" replace="crus"/>
    <item find="rwanda" replace="Rwanda"/>
    <item find="burundi" replace="Burundi"/>
    <item find="acumuler" replace="accumuler"/>
    <item find="sourd muet" replace="sourd-muet"/>
    <item find="points-virgule" replace="points-virgules"/>
    <item find="annullé" replace="annulé"/>
    <item find="pinguin" replace="pingouin"/>
    <item find="demandes-lui" replace="demande-lui"/>
    <item find="belgique" replace="Belgique"/>
    <item find="ficheirs" replace="fichiers"/>
    <item find="aujourdh'ui" replace="aujourd'hui"/>
    <item find="etc..." replace="etc."/>
    <item find="aujurd'hui" replace="aujourd'hui"/>
    <item find="Pour acquis" replace="Pour acquit"/>
    <item find="asssise" replace="assise"/>
    <item find="brulure" replace="brûlure"/>
    <item find="aller de paire" replace="aller de pair"/>
    <item find="flêche" replace="flèche"/>
    <item find="sinonime" replace="synonyme"/>
    <item find="icone" replace="icône"/>
    <item find="faché" replace="fâché"/>
    <item find="atr" replace="art"/>
    <item find="soit même" replace="soi-même"/>
    <item find="accroitre" replace="accroître"/>
    <item find="celà" replace="cela"/>
    <item find="antécédant" replace="antécédent"/>
    <item find="au grès des" replace="au gré des"/>
    <item find="boite" replace="boîte"/>
    <item find="un champs" replace="un champ"/>
    <item find="voutes" replace="voûtes"/>
    <item find="glof" replace="golf"/>
    <item find="pare-choc" replace="pare-chocs"/>
    <item find="régél" replace="réglé"/>
    <item find="garde barrière" replace="garde-barrière"/>
    <item find="raper" replace="râper"/>
    <item find="bec de lièvre" replace="bec-de-lièvre"/>
    <item find="consonnance" replace="consonance"/>
    <item find="erronné" replace="erroné"/>
    <item find="pole" replace="pôle"/>
    <item find="optionel" replace="optionnel"/>
    <item find="exédents" replace="excédents"/>
    <item find="canada" replace="Canada"/>
    <item find="acosté" replace="accosté"/>
    <item find="Noel" replace="Noël"/>
    <item find="On est pas" replace="On n'est pas"/>
    <item find="haut parleur" replace="haut-parleur"/>
    <item find="celui là" replace="celui-là"/>
    <item find="changemetn" replace="changement"/>
    <item find="il peux" replace="il peut"/>
    <item find="on a pas" replace="on n'a pas"/>
    <item find="tannières" replace="tanières"/>
    <item find="mammelles" replace="mamelles"/>
    <item find="théillère" replace="théière"/>
    <item find="resoud il" replace="résout-il"/>
    <item find="imobiles" replace="immobiles"/>
    <item find="n'ia" replace="n'ai"/>
    <item find="ausi" replace="aussi"/>
    <item find="aux dépend" replace="aux dépens"/>
    <item find="décu" replace="déçu"/>
    <item find="une plait" replace="une plaie"/>
    <item find="règlages" replace="réglages"/>
    <item find="elle conseil" replace="elle conseille"/>
    <item find="fchier" replace="fichier"/>
    <item find="soutiens-gorges" replace="soutiens-gorge"/>
    <item find="brucelle" replace="brucelles"/>
    <item find="ambigüe" replace="ambiguë"/>
    <item find="croitre" replace="croître"/>
    <item find="vos cotés" replace="vos côtés"/>
    <item find="astérix" replace="astérisque"/>
    <item find="on y survie" replace="on y survit"/>
    <item find="les adhérants" replace="les adhérents"/>
    <item find="fraiche" replace="fraîche"/>
    <item find="Il mais" replace="Il met"/>
    <item find="utliser" replace="utiliser"/>
    <item find="règlée" replace="réglée"/>
    <item find="à peu prés" replace="à peu près"/>
    <item find="martinique" replace="Martinique"/>
    <item find="naviguer au pré" replace="naviguer au près"/>
    <item find="décus" replace="déçus"/>
    <item find="sinonyme" replace="synonyme"/>
    <item find="courament" replace="couramment"/>
    <item find="serat-il" replace="sera-t-il"/>
    <item find="seychelles" replace="Seychelles"/>
    <item find="super-ordinateurs" replace="superordinateurs"/>
    <item find="là-même" replace="là même"/>
    <item find="icones" replace="icônes"/>
    <item find="À posteriori" replace="A posteriori"/>
    <item find="est choisit" replace="est choisi"/>
    <item find="friut" replace="fruit"/>
    <item find="pret" replace="prêt"/>
    <item find="a définit" replace="a défini"/>
    <item find="moi même" replace="moi-même"/>
    <item find="male" replace="mâle"/>
    <item find="soutien gorge" replace="soutien-gorge"/>
    <item find="multi-tâches" replace="multitâche"/>
    <item find="microproceseur" replace="microprocesseur"/>
    <item find="votres" replace="vôtres"/>
    <item find="polygône" replace="polygone"/>
    <item find="annnée" replace="année"/>
    <item find="paramètré" replace="paramétré"/>
    <item find="le souffre" replace="le soufre"/>
    <item find="honnètes" replace="honnêtes"/>
    <item find="je veut" replace="je veux"/>
    <item find="exepté" replace="excepté"/>
    <item find="exigue" replace="exiguë"/>
    <item find="mions" replace="moins"/>
    <item find="joaillers" replace="joailliers"/>
    <item find="paralèlle" replace="parallèle"/>
    <item find="cad" replace="c.-à-d."/>
    <item find="Allo" replace="Allô"/>
    <item find="rève" replace="rêve"/>
    <item find="super-forme" replace="superforme"/>
    <item find="tatons" replace="tâtons"/>
    <item find="pince nez" replace="pince-nez"/>
    <item find="financiaire" replace="financière"/>
    <item find="groseillers" replace="groseilliers"/>
    <item find="décidemment" replace="décidément"/>
    <item find="instatn" replace="instant"/>
    <item find="nouritures" replace="nourritures"/>
    <item find="enquètes" replace="enquêtes"/>
    <item find="htpp://" replace="http://"/>
    <item find="exeptions" replace="exceptions"/>
    <item find="sous marin" replace="sous-marin"/>
    <item find="fenètre" replace="fenêtre"/>
    <item find="exellents" replace="excellents"/>
    <item find="sus dit" replace="susdit"/>
    <item find="indépendemment" replace="indépendamment"/>
    <item find="il suis" replace="il suit"/>
    <item find="haut de forme" replace="haut-de-forme"/>
    <item find="jamias" replace="jamais"/>
    <item find="prud homme" replace="prud'homme"/>
    <item find="espagne" replace="Espagne"/>
    <item find="fachés" replace="fâchés"/>
    <item find="un calcule" replace="un calcul"/>
    <item find="mittes" replace="mites"/>
    <item find="différend du" replace="différent du"/>
    <item find="minitel" replace="Minitel"/>
    <item find="mayotte" replace="Mayotte"/>
    <item find="un espèce" replace="une espèce"/>
    <item find="otée" replace="ôtée"/>
    <item find="ajourd'hui" replace="aujourd'hui"/>
    <item find="autremnt" replace="autrement"/>
    <item find="poitns" replace="points"/>
    <item find="parceque" replace="parce que"/>
    <item find="québec" replace="Québec"/>
    <item find="le sucés" replace="le succès"/>
    <item find="pantouffles" replace="pantoufles"/>
    <item find="différend de" replace="différent de"/>
    <item find="bonne après-midi" replace="bon après-midi"/>
    <item find="siphylis" replace="syphilis"/>
    <item find="aréodromes" replace="aérodromes"/>
    <item find="colone" replace="colonne"/>
    <item find="fachées" replace="fâchées"/>
    <item find="un épistaxis" replace="une épistaxis"/>
    <item find="bas flanc" replace="bat-flanc"/>
    <item find="courrones" replace="couronnes"/>
    <item find="ontario" replace="Ontario"/>
    <item find="chein" replace="chien"/>
    <item find="lse" replace="les"/>
    <item find="exhorbitant" replace="exorbitant"/>
    <item find="écrna" replace="écran"/>
    <item find="incomoder" replace="incommoder"/>
    <item find="renouvellée" replace="renouvelé"/>
    <item find="ralongées" replace="rallongées"/>
    <item find="ivoir" replace="ivoire"/>
    <item find="a peu près" replace="à peu près"/>
    <item find="hètres" replace="hêtres"/>
    <item find="monaco" replace="Monaco"/>
    <item find="gabon" replace="Gabon"/>
    <item find="cerf-volants" replace="cerfs-volants"/>
    <item find="eau de chaud" replace="eau de chaux"/>
    <item find="paralèlles" replace="parallèles"/>
    <item find="avior" replace="avoir"/>
    <item find="une sourit" replace="une souris"/>
    <item find="quote part" replace="quote-part"/>
    <item find="vous plaie" replace="vous plaît"/>
    <item find="peaus" replace="peaux"/>
    <item find="a investit" replace="a investi"/>
    <item find="par delà" replace="par-delà"/>
    <item find="un équivoque" replace="une équivoque"/>
    <item find="controleur" replace="contrôleur"/>
    <item find="pèse bébé" replace="pèse-bébés"/>
    <item find="giffle" replace="gifle"/>
    <item find="jacynthe" replace="jacinthe"/>
    <item find="un emise" replace="une mise"/>
    <item find="a permit" replace="a permis"/>
    <item find="epnse" replace="pense"/>
    <item find="appellé" replace="appelé"/>
    <item find="license" replace="licence"/>
    <item find="au grès du" replace="au gré du"/>
    <item find="distention" replace="distension"/>
    <item find="la suis" replace="la suie"/>
    <item find="tantot" replace="tantôt"/>
    <item find="utilser" replace="utiliser"/>
    <item find="haut contre" replace="haut-contre"/>
    <item find="un précédant" replace="un précédent"/>
    <item find="celles là" replace="celles-là"/>
    <item find="hatu" replace="haut"/>
    <item find="enquète" replace="enquête"/>
    <item find="main morte" replace="mainmorte"/>
    <item find="ane" replace="âne"/>
    <item find="passports" replace="passeports"/>
    <item find="lerus" replace="leurs"/>
    <item find="point-virgules" replace="points-virgules"/>
    <item find="suprème" replace="suprême"/>
    <item find="sous estimer" replace="sous-estimer"/>
    <item find="diner" replace="dîner"/>
    <item find="infromaticien" replace="informaticien"/>
    <item find="le foi" replace="le foie"/>
    <item find="programeur" replace="programmeur"/>
    <item find="des on dit" replace="des on-dit"/>
    <item find="ambigue" replace="ambiguë"/>
    <item find="pous" replace="plus"/>
    <item find="anévrysme" replace="anévrisme"/>
    <item find="en fabricant" replace="en fabriquant"/>
    <item find="pique assiette" replace="pique-assiette"/>
    <item find="trainés" replace="traînés"/>
    <item find="parechoc" replace="pare-chocs"/>
    <item find="tes cotés" replace="tes côtés"/>
    <item find="giraffe" replace="girafe"/>
    <item find="ban d'essais" replace="banc d'essais"/>
    <item find="qu'en dira-t'on" replace="qu'en-dira-t-on"/>
    <item find="diplomes" replace="diplômes"/>
    <item find="pince monseigneur" replace="pince-monseigneur"/>
    <item find="diplome" replace="diplôme"/>
    <item find="occurence" replace="occurrence"/>
    <item find="exessif" replace="excessif"/>
    <item find="virsu" replace="virus"/>
    <item find="un fabriquant" replace="un fabricant"/>
    <item find="sous estimée" replace="sous-estimée"/>
    <item find="la plais" replace="la plaie"/>
    <item find="hollande" replace="Hollande"/>
    <item find="ABC1" replace="test test test"/>
    <item find="par devant" replace="par-devant"/>
    <item find="axu" replace="aux"/>
    <item find="cauchemard" replace="cauchemar"/>
    <item find="kioske" replace="kiosque"/>
    <item find="quelle que soie" replace="quelle que soit"/>
    <item find="reast" replace="vide de test"/>
    <item find="niger" replace="Niger"/>
    <item find="ban des accusés" replace="banc des accusés"/>
    <item find="ua" replace="au"/>
    <item find="une dote" replace="une dot"/>
    <item find="plateformes" replace="plates-formes"/>
    <item find="Quand à" replace="Quant à"/>
    <item find="couleru" replace="couleur"/>
    <item find="lui même" replace="lui-même"/>
    <item find="boute en train" replace="boute-en-train"/>
    <item find="sori" replace="soir"/>
    <item find="acre" replace="âcre"/>
    <item find="laors" replace="alors"/>
    <item find="impot" replace="impôt"/>
    <item find="finlande" replace="Finlande"/>
    <item find="au-dela" replace="au-delà"/>
    <item find="optionelles" replace="optionnelles"/>
    <item find="aficher" replace="afficher"/>
    <item find="c'st" replace="c'est"/>
    <item find="Sera t'il" replace="Sera-t-il"/>
    <item find="station service" replace="station-service"/>
    <item find="la-bas" replace="là-bas"/>
    <item find="rèves" replace="rêves"/>
    <item find="éceuil" replace="écueil"/>
    <item find="les notres" replace="les nôtres"/>
    <item find="paroide" replace="parodie"/>
    <item find="soleil" replace="Soleil"/>
    <item find="avrli" replace="avril"/>
    <item find="il travail" replace="il travaille"/>
    <item find="baggage" replace="bagage"/>
    <item find="à peu prêt" replace="à peu près"/>
    <item find="dexu" replace="deux"/>
    <item find="une animalcule" replace="un animalcule"/>
    <item find="suède" replace="Suède"/>
    <item find="monoindustrie" replace="mono-industrie"/>
    <item find="nourir" replace="nourrir"/>
    <item find="exhorbitantes" replace="exorbitantes"/>
    <item find="que une" replace="qu'une"/>
    <item find="grand chose" replace="grand-chose"/>
    <item find="guinée" replace="Guinée"/>
    <item find="Sera-t'il" replace="Sera-t-il"/>
    <item find="porgrammes" replace="programmes"/>
    <item find="microporcesseur" replace="microprocesseur"/>
    <item find="ellaborés" replace="élaborés"/>
    <item find="luxembourg" replace="Luxembourg"/>
    <item find="lesson" replace="leçon"/>
    <item find="http:/" replace="http://"/>
    <item find="dse" replace="des"/>
    <item find="modme" replace="modem"/>
    <item find="hètre" replace="hêtre"/>
    <item find="eux mêmes" replace="eux-mêmes"/>
    <item find="plateforme" replace="plate-forme"/>
    <item find="infromatique" replace="informatique"/>
    <item find="baggages" replace="bagages"/>
    <item find="bétises" replace="bêtises"/>
    <item find="une haltère" replace="un haltère"/>
    <item find="leru" replace="leur"/>
    <item find="rectifier le tire" replace="rectifier le tir"/>
    <item find="Etant" replace="Étant"/>
    <item find="Antrée" replace="Entrée"/>
    <item find="jusqu'a" replace="jusqu'à"/>
    <item find="indû" replace="indu"/>
    <item find="machoire" replace="mâchoire"/>
    <item find="une acrostiche" replace="un acrostiche"/>
    <item find="veulliez" replace="veuillez"/>
    <item find="Esquimeau" replace="Esquimau"/>
    <item find="plutot" replace="plutôt"/>
    <item find="à posteriori" replace="a posteriori"/>
    <item find="trainé" replace="traîné"/>
    <item find="avsi" replace="avis"/>
    <item find="les votres" replace="les vôtres"/>
    <item find="les une" replace="les unes"/>
    <item find="une sourie" replace="une souris"/>
    <item find="intéret" replace="intérêt"/>
    <item find="hair" replace="haïr"/>
    <item find="pillule" replace="pilule"/>
    <item find="rafraichis" replace="rafraîchis"/>
    <item find="bienvenu" replace="bienvenue"/>
    <item find="appéritif" replace="apéritif"/>
    <item find="sénégal" replace="Sénégal"/>
    <item find="mammelle" replace="mamelle"/>
    <item find="ban de poissons" replace="banc de poissons"/>
    <item find="guyane" replace="Guyane"/>
    <item find="atôme" replace="atome"/>
    <item find="apelé" replace="appelé"/>
    <item find="décroitre" replace="décroître"/>
    <item find="crèpe" replace="crêpe"/>
    <item find="tole" replace="tôle"/>
    <item find="suffisemment" replace="suffisamment"/>
    <item find="une fébricule" replace="un fébricule"/>
    <item find="cette après-midi" replace="cet après-midi"/>
    <item find="singature" replace="signature"/>
    <item find="Irelande" replace="Irlande"/>
    <item find="toujour" replace="toujours"/>
    <item find="pèse lettres" replace="pèse-lettres"/>
    <item find="a t'on" replace="a-t-on"/>
    <item find="terre plein" replace="terre-plein"/>
    <item find="copu" replace="coup"/>
    <item find="agraffes" replace="agrafes"/>
    <item find="pâques" replace="Pâques"/>
    <item find="reine claude" replace="reine-claude"/>
    <item find="coq à l'âne" replace="coq-à-l'âne"/>
    <item find="giffler" replace="gifler"/>
    <item find="cnet" replace="cent"/>
    <item find="garde fou" replace="garde-fou"/>
    <item find="nos cotés" replace="nos côtés"/>
    <item find="ont investit" replace="ont investi"/>
    <item find="suisse" replace="Suisse"/>
    <item find="un détaille" replace="un détail"/>
    <item find="tout puissant" replace="tout-puissant"/>
    <item find="passes-partout" replace="passe-partout"/>
    <item find="partouts" replace="partout"/>
    <item find="impresions" replace="impressions"/>
    <item find="cameroun" replace="Cameroun"/>
    <item find="aillant" replace="ayant"/>
    <item find="marseille" replace="Marseille"/>
    <item find="sans-gène" replace="sans-gêne"/>
    <item find="futuna" replace="Futuna"/>
    <item find="remplire" replace="remplir"/>
    <item find="bas fond" replace="bas-fond"/>
    <item find="mea culpa" replace="mea-culpa"/>
    <item find="plein pied" replace="plain-pied"/>
    <item find="lyon" replace="Lyon"/>
    <item find="tête bêche" replace="tête-bêche"/>
    <item find="dure mère" replace="dure-mère"/>
    <item find="publier les bancs" replace="publier les bans"/>
    <item find="Cepedant" replace="Cependant"/>
    <item find="brulé" replace="brûlé"/>
    <item find="danemark" replace="Danemark"/>
    <item find="rafraichissement" replace="rafraîchissement"/>
    <item find="aucunes" replace="aucune"/>
    <item find="sous marine" replace="sous-marine"/>
    <item find="fachée" replace="fâchée"/>
    <item find="je mais" replace="je mets"/>
    <item find="héroine" replace="héroïne"/>
    <item find="crèpes" replace="crêpes"/>
    <item find="empiètement" replace="empiétement"/>
    <item find="il aperçu" replace="il aperçut"/>
    <item find="chnagements" replace="changements"/>
    <item find="infractus" replace="infarctus"/>
    <item find="lune" replace="Lune"/>
    <item find="Magrébin" replace="Maghrébin"/>
    <item find="chène" replace="chêne"/>
    <item find="peid" replace="pied"/>
    <item find="il conseil" replace="il conseille"/>
    <item find="couluer" replace="couleur"/>
    <item find="couluers" replace="couleurs"/>
    <item find="prud hommes" replace="prud'hommes"/>
    <item find="un jouer" replace="un jour"/>
    <item find="appui-têtes" replace="appuis-tête"/>
    <item find="des conseilles" replace="des conseils"/>
    <item find="perce neige" replace="perce-neige"/>
    <item find="exeption" replace="exception"/>
    <item find="une hémisphère" replace="un hémisphère"/>
    <item find="faience" replace="faïence"/>
    <item find="auto-correction" replace="autocorrection"/>
    <item find="jacynthes" replace="jacinthes"/>
    <item find="batême" replace="baptêmes"/>
    <item find="étainte" replace="éteinte"/>
    <item find="Thorvalds" replace="Torvalds"/>
    <item find="de tel sorte" replace="de telle sorte"/>
    <item find="des fabriquants" replace="des fabricants"/>
    <item find="au devant" replace="au-devant"/>
    <item find="chacuns" replace="chacun"/>
    <item find="apotres" replace="apôtres"/>
    <item find="ainée" replace="aînée"/>
    <item find="pallier à" replace="pallier"/>
    <item find="siphilys" replace="syphilis"/>
    <item find="neptune" replace="Neptune"/>
    <item find="rez de chaussée" replace="rez-de-chaussée"/>
    <item find="cou de pied" replace="cou-de-pied"/>
    <item find="batards" replace="bâtards"/>
    <item find="adanboner" replace="abandonner"/>
    <item find="de bon grès" replace="de bon gré"/>
    <item find="pallié à" replace="pallié"/>
    <item find="un escarre" replace="une escarre"/>
    <item find="afiche" replace="affiche"/>
    <item find="ame" replace="âme"/>
    <item find="Allemange" replace="Allemagne"/>
    <item find="languages" replace="langages"/>
    <item find="ainés" replace="aînés"/>
    <item find="une antidote" replace="un antidote"/>
    <item find="une aphte" replace="un aphte"/>
    <item find="une boite" replace="une boîte"/>
    <item find="tempète" replace="tempête"/>
    <item find="noël" replace="Noël"/>
    <item find="Le publique" replace="Le public"/>
    <item find="souffre douleur" replace="souffre-douleur"/>
    <item find="recomandé" replace="recommandé"/>
    <item find="pare brise" replace="pare-brise"/>
    <item find="joalier" replace="joaillier"/>
    <item find="impots" replace="impôts"/>
    <item find="mêches" replace="mèches"/>
    <item find="une après-midi" replace="un après-midi"/>
    <item find="cuissse" replace="cuisse"/>
    <item find="un mets" replace="un met"/>
    <item find="colones" replace="colonnes"/>
    <item find="controle" replace="contrôle"/>
    <item find="une crois" replace="une croix"/>
    <item find="autoinduction" replace="auto-induction"/>
    <item find="sensé être" replace="censé être"/>
    <item find="je suit" replace="je suis"/>
    <item find="un conseille" replace="un conseil"/>
    <item find="Il mets" replace="Il met"/>
    <item find="buttin" replace="butin"/>
    <item find="arete" replace="arête"/>
    <item find="en adhérent" replace="en adhérant"/>
    <item find="il choisi" replace="il choisit"/>
    <item find="ellaboré" replace="élaboré"/>
    <item find="baptème" replace="baptême"/>
    <item find="aex" replace="axe"/>
    <item find="exédent" replace="excédent"/>
    <item find="il mais" replace="il met"/>
    <item find="résidance" replace="résidence"/>
    <item find="grand père" replace="grand-père"/>
    <item find="ralonge" replace="rallonge"/>
    <item find="pécunier" replace="pécuniaire"/>
    <item find="imge" replace="image"/>
    <item find="apotre" replace="apôtre"/>
    <item find="oui dire" replace="ouï-dire"/>
    <item find="les anales" replace="les annales"/>
    <item find="l'en train" replace="l'entrain"/>
    <item find="là bas" replace="là-bas"/>
    <item find="dûs" replace="dus"/>
    <item find="recomandée" replace="recommandée"/>
    <item find="ayant conçut" replace="ayant conçu"/>
    <item find="répèter" replace="répéter"/>
    <item find="mouffles" replace="moufles"/>
    <item find="par derrière" replace="par-derrière"/>
    <item find="appuis-têtes" replace="appuis-tête"/>
    <item find="mirroir" replace="miroir"/>
    <item find="cable" replace="câble"/>
    <item find="je travail" replace="je travaille"/>
    <item find="X Windows" replace="X Window"/>
    <item find="italie" replace="Italie"/>
    <item find="programe" replace="programme"/>
    <item find="précosses" replace="précoces"/>
    <item find="ambigüité" replace="ambiguïté"/>
    <item find="bec de cane" replace="bec-de-cane"/>
    <item find="grand peine" replace="grand-peine"/>
    <item find="défault" replace="défaut"/>
    <item find="incomodé" replace="incommodé"/>
    <item find="burkina faso" replace="Burkina Faso"/>
    <item find="fraicheur" replace="fraîcheur"/>
    <item find="brulante" replace="brûlante"/>
    <item find="Bonne après-midi" replace="Bon après-midi"/>
    <item find="du souffre" replace="du soufre"/>
    <item find="près salés" replace="prés salés"/>
    <item find="mio" replace="moi"/>
    <item find="allemagne" replace="Allemagne"/>
    <item find="sotire" replace="sortie"/>
    <item find="vert de gris" replace="vert-de-gris"/>
    <item find="bache" replace="bâche"/>
    <item find="poids cassés" replace="pois cassés"/>
    <item find="esse-que" replace="est-ce que"/>
    <item find="parlementare" replace="parlementaire"/>
    <item find="Paques" replace="Pâques"/>
    <item find="par dessous" replace="par-dessous"/>
    <item find="trait de faction" replace="trait de fraction"/>
    <item find="sauf conduits" replace="sauf-conduits"/>
    <item find="liu" replace="lui"/>
    <item find="stastitiques" replace="statistiques"/>
    <item find="leur équivalant" replace="leur équivalent"/>
    <item find="piqure" replace="piqûre"/>
    <item find="contrejour" replace="contre-jour"/>
    <item find="ceal" replace="cela"/>
    <item find="normallement" replace="normalement"/>
    <item find="personalisé" replace="personnalisé"/>
    <item find="exellent" replace="excellent"/>
    <item find="le résidant" replace="le résident"/>
    <item find="a la fois" replace="à la fois"/>
    <item find="environnment" replace="environnement"/>
    <item find="c'est à dire" replace="c'est-à-dire"/>
    <item find="quatres" replace="quatre"/>
    <item find="Bien sur" replace="Bien sûr"/>
    <item find="fius" replace="fois"/>
    <item find="abimés" replace="abîmés"/>
    <item find="poçible" replace="possible"/>
    <item find="guèpe" replace="guêpe"/>
    <item find="liserés" replace="lisérés"/>
    <item find="changemetns" replace="changements"/>
    <item find="fios" replace="fois"/>
    <item find="valloir" replace="valoir"/>
    <item find="platre" replace="plâtre"/>
    <item find="rafraichir" replace="rafraîchir"/>
    <item find="japon" replace="Japon"/>
    <item find="erronnée" replace="erronée"/>
    <item find="continument" replace="continûment"/>
    <item find="batardes" replace="bâtardes"/>
    <item find="collinne" replace="colline"/>
    <item find="va nu pieds" replace="va-nu-pieds"/>
    <item find="utilsateur" replace="utilisateur"/>
    <item find="annullées" replace="annulées"/>
    <item find="sous estimé" replace="sous-estimé"/>
    <item find="hors la loi" replace="hors-la-loi"/>
    <item find="guinée-conakry" replace="Guinée-Conakry"/>
    <item find="norvège" replace="Norvège"/>
    <item find="Et bien," replace="Eh bien,"/>
    <item find="inconditionel" replace="inconditionnel"/>
    <item find="aigüe" replace="aiguë"/>
    <item find="contre jour" replace="contre-jour"/>
    <item find="Basses Pyrénées" replace="Basses-Pyrénées"/>
    <item find="a-t'il" replace="a-t-il"/>
    <item find="À pirori" replace="A priori"/>
    <item find="lancer de pois" replace="lancer de poids"/>
    <item find="changments" replace="changements"/>
    <item find="brulures" replace="brûlures"/>
    <item find="Et oui" replace="Eh oui"/>
    <item find="règlé" replace="réglé"/>
    <item find="il fourni" replace="il fournit"/>
    <item find="connection" replace="connexion"/>
    <item find="COMpuTer" replace="computer"/>
    <item find="guet apens" replace="guet-apens"/>
    <item find="jacinte" replace="jacinthe"/>
    <item find="chefs-d'oeuvres" replace="chefs-d'oeuvre"/>
    <item find="acr" replace="arc"/>
    <item find="à priori" replace="a priori"/>
    <item find="batêmes" replace="baptêmes"/>
    <item find="noyeaux" replace="noyaux"/>
    <item find="une astérisque" replace="un astérisque"/>
    <item find="monoiodé" replace="mono-iodé"/>
    <item find="soi même" replace="soi-même"/>
    <item find="petit beurre" replace="petit-beurre"/>
    <item find="trapèse" replace="trapèze"/>
    <item find="deça" replace="deçà"/>
    <item find="trone" replace="trône"/>
    <item find="pèriode" replace="période"/>
    <item find="au dépens" replace="aux dépens"/>
    <item find="identé" replace="indenté"/>
    <item find="jutse" replace="juste"/>
    <item find="aretes" replace="arêtes"/>
    <item find="logicile" replace="logiciel"/>
    <item find="un équivalant" replace="un équivalent"/>
    <item find="cetrain" replace="certain"/>
    <item find="otés" replace="ôtés"/>
    <item find="sanglotter" replace="sangloter"/>
    <item find="babord" replace="bâbord"/>
    <item find="artisant" replace="artisan"/>
    <item find="trop plein" replace="trop-plein"/>
    <item find="exès" replace="excès"/>
    <item find="pique nique" replace="pique-nique"/>
    <item find="celle-çi" replace="celle-ci"/>
    <item find="ellaborée" replace="élaborée"/>
    <item find="poids de senteur" replace="pois de senteur"/>
    <item find="c.à.d." replace="c.-à-d."/>
    <item find="pluton" replace="Pluton"/>
    <item find="parlementères" replace="parlementaires"/>
    <item find="petit-beurres" replace="petits-beurres"/>
    <item find="parmis" replace="parmi"/>
    <item find="demie-heure" replace="demi-heure"/>
    <item find="ficier" replace="fichier"/>
    <item find="rapes" replace="râpes"/>
    <item find="la boite" replace="la boîte"/>
    <item find="baptèmes" replace="baptêmes"/>
    <item find="un ecchymose" replace="une ecchymose"/>
    <item find="charète" replace="charrette"/>
    <item find="Des lors" replace="Dès lors"/>
    <item find="rhyume" replace="rhume"/>
    <item find="asssises" replace="assises"/>
    <item find="il mets" replace="il met"/>
    <item find="il transfert" replace="il transfère"/>
    <item find="chausse trape" replace="chausse-trape"/>
    <item find="anerie" replace="ânerie"/>
    <item find="laisser-passer" replace="laissez-passer"/>
    <item find="elle aperçu" replace="elle aperçut"/>
    <item find="pares-brise" replace="pare-brise"/>
    <item find="parlotte" replace="parlote"/>
    <item find="on est pas" replace="on n'est pas"/>
    <item find="court-circuits" replace="courts-circuits"/>
    <item find="ambigüité " replace="ambiguïté "/>
    <item find="baclés" replace="bâclés"/>
    <item find="torvalds" replace="Torvalds"/>
    <item find="arret" replace="arrêt"/>
    <item find="Mr" replace="M."/>
    <item find="une armistice" replace="un armistice"/>
    <item find="angleterre" replace="Angleterre"/>
    <item find="règler" replace="régler"/>
    <item find="chausse-trappe" replace="chausse-trape"/>
    <item find="sous estimés" replace="sous-estimés"/>
    <item find="artisna" replace="artisan"/>
    <item find="navigateru" replace="navigateur"/>
    <item find="soul" replace="saoul"/>
    <item find="mal habile" replace="malhabile"/>
    <item find="brulant" replace="brûlant"/>
    <item find="ralonger" replace="rallonge"/>
    <item find="coulerus" replace="couleurs"/>
    <item find="Ile de France" replace="Île-de-France"/>
    <item find="demie heure" replace="demi-heure"/>
    <item find="les un" replace="les uns"/>
    <item find="joaliers" replace="joailliers"/>
    <item find="friod" replace="froid"/>
    <item find="les résidants" replace="les résidents"/>
    <item find="dannemark" replace="Danemark"/>
    <item find="fuire" replace="fuir"/>
    <item find="dnot" replace="dont"/>
    <item find="congo" replace="Congo"/>
    <item find="ognon" replace="oignon"/>
    <item find="multi-utilisateur" replace="multiutilisateur"/>
    <item find="oté" replace="ôté"/>
    <item find="nues propriétés" replace="nues-propriétés"/>
    <item find="environment" replace="environnement"/>
    <item find="pie mère" replace="pie-mère"/>
    <item find="plein-pied" replace="plain-pied"/>
    <item find="sauf conduit" replace="sauf-conduit"/>
    <item find="arc en ciel" replace="arc-en-ciel"/>
    <item find="Magreb" replace="Maghreb"/>
    <item find="que un" replace="qu'un"/>
    <item find="recomander" replace="recommander"/>
    <item find="courrir" replace="courir"/>
    <item find="chènes" replace="chênes"/>
    <item find="haut le corps" replace="haut-le-corps"/>
    <item find="annullée" replace="annulée"/>
    <item find="ellaborer" replace="élaborer"/>
    <item find="isl" replace="ils"/>
    <item find="recomandées" replace="recommandées"/>
    <item find="fenètres" replace="fenêtres"/>
    <item find="reve" replace="rêve"/>
    <item find="renouveller" replace="renouveler"/>
    <item find="cheins" replace="chiens"/>
    <item find="fesant" replace="faisant"/>
    <item find="gagnatn" replace="gagnant"/>
    <item find="jetéé" replace="jetée"/>
    <item find="paitre" replace="paître"/>
    <item find="aigües" replace="aiguës"/>
    <item find="façon à ce que" replace="façon que"/>
    <item find="celui-çi" replace="celui-ci"/>
    <item find="gouté" replace="goûté"/>
    <item find="courrant" replace="courant"/>
    <item find="pologne" replace="Pologne"/>
    <item find="adanboné" replace="abandonné"/>
    <item find="pillules" replace="pilules"/>
    <item find="ceux là" replace="ceux-là"/>
    <item find="sosu" replace="sous"/>
    <item find="elle transfert" replace="elle transfère"/>
    <item find="hate" replace="hâte"/>
    <item find="hopitaux" replace="hôpitaux"/>
    <item find="au grès de" replace="au gré de"/>
    <item find="fourmie" replace="fourmi"/>
    <item find="la sourie" replace="la souris"/>
    <item find="repaire" replace="repère"/>
    <item find="Charente Maritime" replace="Charente-Maritime"/>
    <item find="elle investi" replace="elle investit"/>
    <item find="aieul" replace="aïeul"/>
    <item find="un anagramme" replace="une anagramme"/>
    <item find="Blumenal" replace="Blumenau"/>
    <item find="dnas" replace="dans"/>
    <item find="dixaine" replace="dizaine"/>
    <item find="parlementares" replace="parlementaires"/>
    <item find="anée" replace="année"/>
    <item find="canoé" replace="canoë"/>
    <item find="avatn" replace="avant"/>
    <item find="quitance" replace="quittance"/>
    <item find="aieux" replace="aïeux"/>
    <item find="maréchal ferrant" replace="maréchal-ferrant"/>
    <item find="orielle" replace="oreille"/>
    <item find="point virgule" replace="point-virgule"/>
    <item find="pation" replace="passion"/>
    <item find="hors d'oeuvre" replace="hors-d'oeuvre"/>
    <item find="acomte" replace="acompte"/>
    <item find="jupiter" replace="Jupiter"/>
    <item find="amre" replace="arme"/>
    <item find="crètes" replace="crêtes"/>
    <item find="hotel" replace="hôtel"/>
    <item find="Hors," replace="Or,"/>
    <item find="débur" replace="début"/>
    <item find="naviguer au prêt" replace="naviguer au près"/>
    <item find="ralongée" replace="rallongée"/>
    <item find="la foie" replace="la fois"/>
    <item find="quelque soit" replace="quel que soit"/>
    <item find="maitre" replace="maître"/>
    <item find="pantomine" replace="pantomime"/>
    <item find="mauritanie" replace="Mauritanie"/>
    <item find="parlementère" replace="parlementaire"/>
    <item find="tobogan" replace="toboggan"/>
    <item find="demi heure" replace="demi-heure"/>
    <item find="toi même" replace="toi-même"/>
    <item find="cloture" replace="clôture"/>
    <item find="multi-utilisateurs" replace="multiutilisateur"/>
    <item find="On a pas" replace="On n'a pas"/>
    <item find="notres" replace="nôtres"/>
    <item find="http:\\" replace="http://"/>
    <item find="Cependatn" replace="Cependant"/>
    <item find="main d'oeuvre" replace="main-d'oeuvre"/>
    <item find="sinonymes" replace="synonymes"/>
    <item find="un travestit" replace="un travesti"/>
    <item find="est faut" replace="est faux"/>
    <item find="résoud il" replace="résout-il"/>
    <item find="Nouvelle Calédonie" replace="Nouvelle-Calédonie"/>
    <item find="rotir" replace="rôtir"/>
    <item find="elle choisi" replace="elle choisit"/>
    <item find="vous faîtes" replace="vous faites"/>
    <item find="exhorbitante" replace="exorbitante"/>
    <item find="il investi" replace="il investit"/>
    <item find="elles mêmes" replace="elles-mêmes"/>
    <item find="antécédants" replace="antécédents"/>
    <item find="dépot" replace="dépôt"/>
    <item find="pylone" replace="pylône"/>
    <item find="bèches" replace="bêches"/>
    <item find="bas-flanc" replace="bat-flanc"/>
    <item find="francaise" replace="française"/>
  </items>
  <UpperCaseExceptions>
    <word exception="J."/>
    <word exception="d."/>
    <word exception="cf."/>
    <word exception="t."/>
    <word exception="loc."/>
    <word exception="max."/>
    <word exception="r."/>
    <word exception="P."/>
    <word exception="e."/>
    <word exception="op."/>
    <word exception="-l."/>
    <word exception="inf."/>
    <word exception="c."/>
    <word exception="id."/>
    <word exception="ex."/>
    <word exception="-C."/>
    <word exception="B."/>
    <word exception="ch."/>
    <word exception="i."/>
    <word exception="g."/>
    <word exception="U."/>
    <word exception="tél."/>
    <word exception="apr."/>
    <word exception="V."/>
    <word exception="s."/>
    <word exception="chap."/>
    <word exception="min."/>
    <word exception="hab."/>
    <word exception="n."/>
    <word exception="cit."/>
    <word exception="à."/>
    <word exception="env."/>
    <word exception="C."/>
    <word exception="ndlr."/>
    <word exception="av."/>
    <word exception="p."/>
    <word exception="F."/>
    <word exception="O."/>
    <word exception="MM."/>
    <word exception="-O."/>
    <word exception="T."/>
    <word exception="N."/>
    <word exception="M."/>
    <word exception="ndt."/>
    <word exception="I."/>
  </UpperCaseExceptions>
  <TwoUpperLetterExceptions>
    <word exception="KTuberling"/>
    <word exception="KPrinter"/>
    <word exception="KSpread"/>
    <word exception="MHz"/>
    <word exception="GWh"/>
    <word exception="KStars"/>
    <word exception="GHz"/>
    <word exception="MJ"/>
    <word exception="KPat"/>
    <word exception="MT"/>
    <word exception="MWh"/>
    <word exception="KWord"/>
    <word exception="MW"/>
    <word exception="KDevelop"/>
    <word exception="OOo"/>
    <word exception="KPresenter"/>
    <word exception="KBabel"/>
    <word exception="GW"/>
    <word exception="KMail"/>
    <word exception="KOffice"/>
    <word exception="KNode"/>
  </TwoUpperLetterExceptions>
  <DoubleQuote>
    <doublequote begin="“" end="”"/>
  </DoubleQuote>
  <SimpleQuote>
    <simplequote begin="‘" end="’"/>
  </SimpleQuote>
</Word>
07070100000022000081A40000000200000002000000015CDAA39400000126000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/data/empty-ref.xml<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE autocorrection>
<Word>
  <items/>
  <UpperCaseExceptions/>
  <TwoUpperLetterExceptions/>
  <DoubleQuote>
    <doublequote begin="“" end="”"/>
  </DoubleQuote>
  <SimpleQuote>
    <simplequote begin="‘" end="’"/>
  </SimpleQuote>
</Word>
07070100000023000081A40000000200000002000000015CDAA39400000126000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/data/empty.xml<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE autocorrection>
<Word>
  <items/>
  <UpperCaseExceptions/>
  <TwoUpperLetterExceptions/>
  <DoubleQuote>
    <doublequote begin="“" end="”"/>
  </DoubleQuote>
  <SimpleQuote>
    <simplequote begin="‘" end="’"/>
  </SimpleQuote>
</Word>
07070100000024000081A40000000200000002000000015CDAA39400000F58000000000000000000000000000000000000007700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/lineeditwithautocorrectiontest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "lineeditwithautocorrectiontest.h"
#include <PimCommon/LineEditWithAutoCorrection>
#include "../autocorrection.h"
#include <QTest>
#include <qtestkeyboard.h>

LineEditWithAutocorrectionTest::LineEditWithAutocorrectionTest()
{
}

void LineEditWithAutocorrectionTest::shouldNotAutocorrectWhenDisabled()
{
    PimCommon::LineEditWithAutoCorrection lineedit(nullptr, QStringLiteral("lineeditwithautocorrecttestrc"));
    QHash<QString, QString> entries;
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    entries.insert(originalWord, replaceWord);
    lineedit.autocorrection()->setAutocorrectEntries(entries);
    lineedit.show();
    QVERIFY(QTest::qWaitForWindowExposed(&lineedit));
    QTest::keyClicks(&lineedit, originalWord);
    QTest::keyClick(&lineedit, ' ');
    QCOMPARE(lineedit.toPlainText(), QString(originalWord + QLatin1Char(' ')));
}

void LineEditWithAutocorrectionTest::shouldReplaceWordWhenExactText()
{
    PimCommon::LineEditWithAutoCorrection lineedit(nullptr, QStringLiteral("lineeditwithautocorrecttestrc"));
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    QHash<QString, QString> entries;
    entries.insert(originalWord, replaceWord);
    lineedit.autocorrection()->setAutocorrectEntries(entries);
    lineedit.autocorrection()->setEnabledAutoCorrection(true);
    lineedit.autocorrection()->setAdvancedAutocorrect(true);
    lineedit.show();
    QVERIFY(QTest::qWaitForWindowExposed(&lineedit));
    QTest::keyClicks(&lineedit, originalWord);
    QTest::keyClick(&lineedit, ' ');
    QCOMPARE(lineedit.toPlainText(), QString(replaceWord + QLatin1Char(' ')));
}

void LineEditWithAutocorrectionTest::shouldNotReplaceWordWhenInexactText()
{
    PimCommon::LineEditWithAutoCorrection lineedit(nullptr, QStringLiteral("lineeditwithautocorrecttestrc"));
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    QHash<QString, QString> entries;
    entries.insert(originalWord, replaceWord);
    lineedit.autocorrection()->setAutocorrectEntries(entries);
    lineedit.autocorrection()->setEnabledAutoCorrection(true);
    lineedit.autocorrection()->setAdvancedAutocorrect(true);
    lineedit.show();
    const QString nonExactText = QStringLiteral("BLIBLI");
    QVERIFY(QTest::qWaitForWindowExposed(&lineedit));
    QTest::keyClicks(&lineedit, nonExactText);
    QTest::keyClick(&lineedit, ' ');
    QCOMPARE(lineedit.toPlainText(), QString(nonExactText + QLatin1Char(' ')));
}

void LineEditWithAutocorrectionTest::shouldNotAddTwoSpace()
{
    PimCommon::LineEditWithAutoCorrection lineedit(nullptr, QStringLiteral("lineeditwithautocorrecttestrc"));
    const QString originalWord = QStringLiteral("FOOFOO ");
    lineedit.autocorrection()->setSingleSpaces(true);
    lineedit.autocorrection()->setEnabledAutoCorrection(true);
    lineedit.show();
    QVERIFY(QTest::qWaitForWindowExposed(&lineedit));
    QTest::keyClicks(&lineedit, originalWord);
    QTest::keyClick(&lineedit, ' ');
    QCOMPARE(lineedit.toPlainText(), originalWord);
}

QTEST_MAIN(LineEditWithAutocorrectionTest)
07070100000025000081A40000000200000002000000015CDAA39400000487000000000000000000000000000000000000007500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/lineeditwithautocorrectiontest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LINEEDITWITHAUTOCORRECTIONTEST_H
#define LINEEDITWITHAUTOCORRECTIONTEST_H

#include <QObject>

class LineEditWithAutocorrectionTest : public QObject
{
    Q_OBJECT
public:
    LineEditWithAutocorrectionTest();

private Q_SLOTS:
    void shouldNotAutocorrectWhenDisabled();
    void shouldReplaceWordWhenExactText();
    void shouldNotReplaceWordWhenInexactText();
    void shouldNotAddTwoSpace();
};

#endif // LINEEDITWITHAUTOCORRECTIONTEST_H
07070100000026000081A40000000200000002000000015CDAA394000012D7000000000000000000000000000000000000007B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/richtexteditwithautocorrectiontest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "richtexteditwithautocorrectiontest.h"
#include <QTest>
#include "../widgets/richtexteditwithautocorrection.h"
#include "../autocorrection.h"
#include <qtestkeyboard.h>

RichTextEditWithAutoCorrectionTest::RichTextEditWithAutoCorrectionTest()
{
}

void RichTextEditWithAutoCorrectionTest::shouldNotAutocorrectWhenDisabled()
{
    PimCommon::RichTextEditWithAutoCorrection richtext(nullptr);
    QHash<QString, QString> entries;
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    entries.insert(originalWord, replaceWord);
    richtext.autocorrection()->setAutocorrectEntries(entries);
    richtext.show();
    QVERIFY(QTest::qWaitForWindowExposed(&richtext));
    QTest::keyClicks(&richtext, originalWord);
    QTest::keyClick(&richtext, ' ');
    QCOMPARE(richtext.toPlainText(), QString(originalWord + QLatin1Char(' ')));
}

void RichTextEditWithAutoCorrectionTest::shouldReplaceWordWhenExactText()
{
    PimCommon::RichTextEditWithAutoCorrection richtext(nullptr);
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    QHash<QString, QString> entries;
    entries.insert(originalWord, replaceWord);
    richtext.autocorrection()->setAutocorrectEntries(entries);
    richtext.autocorrection()->setEnabledAutoCorrection(true);
    richtext.autocorrection()->setAdvancedAutocorrect(true);
    richtext.show();
    QVERIFY(QTest::qWaitForWindowExposed(&richtext));
    QTest::keyClicks(&richtext, originalWord);
    QTest::keyClick(&richtext, ' ');
    QCOMPARE(richtext.toPlainText(), QString(replaceWord + QLatin1Char(' ')));
}

void RichTextEditWithAutoCorrectionTest::shouldNotReplaceWordWhenInexactText()
{
    PimCommon::RichTextEditWithAutoCorrection richtext(nullptr);
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    QHash<QString, QString> entries;
    entries.insert(originalWord, replaceWord);
    richtext.autocorrection()->setAutocorrectEntries(entries);
    richtext.autocorrection()->setEnabledAutoCorrection(true);
    richtext.autocorrection()->setAdvancedAutocorrect(true);
    richtext.show();
    const QString nonExactText = QStringLiteral("BLIBLI");
    QVERIFY(QTest::qWaitForWindowExposed(&richtext));
    QTest::keyClicks(&richtext, nonExactText);
    QTest::keyClick(&richtext, ' ');
    QCOMPARE(richtext.toPlainText(), QString(nonExactText + QLatin1Char(' ')));
}

void RichTextEditWithAutoCorrectionTest::shouldReplaceWhenPressEnter()
{
    PimCommon::RichTextEditWithAutoCorrection richtext(nullptr);
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    QHash<QString, QString> entries;
    entries.insert(originalWord, replaceWord);
    richtext.autocorrection()->setAutocorrectEntries(entries);
    richtext.autocorrection()->setEnabledAutoCorrection(true);
    richtext.autocorrection()->setAdvancedAutocorrect(true);
    richtext.show();
    QVERIFY(QTest::qWaitForWindowExposed(&richtext));
    QTest::keyClicks(&richtext, originalWord);
    QTest::keyPress(&richtext, Qt::Key_Enter);
    QCOMPARE(richtext.toPlainText(), QString(replaceWord + QLatin1Char('\n')));
}

void RichTextEditWithAutoCorrectionTest::shouldReplaceWhenPressReturn()
{
    PimCommon::RichTextEditWithAutoCorrection richtext(nullptr);
    const QString originalWord = QStringLiteral("FOOFOO");
    const QString replaceWord = QStringLiteral("BLABLA");
    QHash<QString, QString> entries;
    entries.insert(originalWord, replaceWord);
    richtext.autocorrection()->setAutocorrectEntries(entries);
    richtext.autocorrection()->setEnabledAutoCorrection(true);
    richtext.autocorrection()->setAdvancedAutocorrect(true);
    richtext.show();
    QVERIFY(QTest::qWaitForWindowExposed(&richtext));
    QTest::keyClicks(&richtext, originalWord);
    QTest::keyPress(&richtext, Qt::Key_Return);
    QCOMPARE(richtext.toPlainText(), QString(replaceWord + QLatin1Char('\n')));
}

QTEST_MAIN(RichTextEditWithAutoCorrectionTest)
07070100000027000081A40000000200000002000000015CDAA394000004C9000000000000000000000000000000000000007900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/autotests/richtexteditwithautocorrectiontest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef RICHTEXTEDITWITHAUTOCORRECTIONTEST_H
#define RICHTEXTEDITWITHAUTOCORRECTIONTEST_H
#include <QObject>

class RichTextEditWithAutoCorrectionTest : public QObject
{
    Q_OBJECT
public:
    RichTextEditWithAutoCorrectionTest();
private Q_SLOTS:
    void shouldNotAutocorrectWhenDisabled();
    void shouldReplaceWordWhenExactText();
    void shouldNotReplaceWordWhenInexactText();
    void shouldReplaceWhenPressEnter();
    void shouldReplaceWhenPressReturn();
};

#endif // RICHTEXTEDITWITHAUTOCORRECTIONTEST_H
07070100000028000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/import07070100000029000081A40000000200000002000000015CDAA3940000079F000000000000000000000000000000000000007200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/import/importabstractautocorrection.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "importabstractautocorrection.h"

using namespace PimCommon;

ImportAbstractAutocorrection::ImportAbstractAutocorrection(QWidget *parent)
    : mParent(parent)
{
}

ImportAbstractAutocorrection::~ImportAbstractAutocorrection()
{
}

QSet<QString> ImportAbstractAutocorrection::upperCaseExceptions() const
{
    return mUpperCaseExceptions;
}

QSet<QString> ImportAbstractAutocorrection::twoUpperLetterExceptions() const
{
    return mTwoUpperLetterExceptions;
}

QHash<QString, QString> ImportAbstractAutocorrection::autocorrectEntries() const
{
    return mAutocorrectEntries;
}

AutoCorrection::TypographicQuotes ImportAbstractAutocorrection::typographicSingleQuotes() const
{
    return mTypographicSingleQuotes;
}

AutoCorrection::TypographicQuotes ImportAbstractAutocorrection::typographicDoubleQuotes() const
{
    return mTypographicDoubleQuotes;
}

int ImportAbstractAutocorrection::maxFindStringLenght() const
{
    return mMaxFindStringLenght;
}

int ImportAbstractAutocorrection::minFindStringLenght() const
{
    return mMinFindStringLenght;
}

QHash<QString, QString> ImportAbstractAutocorrection::superScriptEntries() const
{
    return mSuperScriptEntries;
}
0707010000002A000081A40000000200000002000000015CDAA39400000957000000000000000000000000000000000000007000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/import/importabstractautocorrection.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef IMPORTABSTRACTAUTOCORRECTION_H
#define IMPORTABSTRACTAUTOCORRECTION_H

#include <QSet>
#include <QString>
#include <QHash>

#include "autocorrection/autocorrection.h"

namespace PimCommon {
class ImportAbstractAutocorrection
{
    Q_GADGET
public:
    enum LoadAttribute {
        All = 0,
        SuperScript
    };
    Q_ENUM(LoadAttribute)

explicit ImportAbstractAutocorrection(QWidget *parent);
    virtual ~ImportAbstractAutocorrection();

virtual bool import(const QString &fileName, ImportAbstractAutocorrection::LoadAttribute loadAttribute = All) = 0;

Q_REQUIRED_RESULT QSet<QString> upperCaseExceptions() const;
    Q_REQUIRED_RESULT QSet<QString> twoUpperLetterExceptions() const;
    Q_REQUIRED_RESULT QHash<QString, QString> autocorrectEntries() const;
    Q_REQUIRED_RESULT QHash<QString, QString> superScriptEntries() const;

Q_REQUIRED_RESULT AutoCorrection::TypographicQuotes typographicSingleQuotes() const;
    Q_REQUIRED_RESULT AutoCorrection::TypographicQuotes typographicDoubleQuotes() const;

Q_REQUIRED_RESULT int maxFindStringLenght() const;

Q_REQUIRED_RESULT int minFindStringLenght() const;

protected:
    int mMaxFindStringLenght = 0;
    int mMinFindStringLenght = 0;
    QSet<QString> mUpperCaseExceptions;
    QSet<QString> mTwoUpperLetterExceptions;
    QHash<QString, QString> mAutocorrectEntries;
    QHash<QString, QString> mSuperScriptEntries;
    AutoCorrection::TypographicQuotes mTypographicSingleQuotes;
    AutoCorrection::TypographicQuotes mTypographicDoubleQuotes;
    QWidget *mParent = nullptr;
};
}

#endif // IMPORTABSTRACTAUTOCORRECTION_H
0707010000002B000081A40000000200000002000000015CDAA39400001B4A000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/import/importkmailautocorrection.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "importkmailautocorrection.h"

#include <QFile>
#include <QXmlStreamReader>
#include "pimcommon_debug.h"
using namespace PimCommon;

ImportKMailAutocorrection::ImportKMailAutocorrection(QWidget *parent)
    : ImportAbstractAutocorrection(parent)
{
}

ImportKMailAutocorrection::~ImportKMailAutocorrection()
{
}

bool ImportKMailAutocorrection::import(const QString &fileName, LoadAttribute loadAttribute)
{
    QFile xmlFile(fileName);
    if (!xmlFile.open(QIODevice::ReadOnly)) {
        return false;
    }
    QXmlStreamReader xml(&xmlFile);
    mMaxFindStringLenght = 0;
    mMinFindStringLenght = 0;
    if (xml.readNextStartElement()) {
        while (xml.readNextStartElement()) {
            if (xml.name() == QLatin1String("UpperCaseExceptions")) {
                if (loadAttribute == All) {
                    while (xml.readNextStartElement()) {
                        const QStringRef tagname = xml.name();
                        if (tagname == QLatin1String("word")) {
                            if (xml.attributes().hasAttribute(QStringLiteral("exception"))) {
                                const QString exception = xml.attributes().value(QStringLiteral("exception")).toString();
                                mUpperCaseExceptions += exception;
                                xml.skipCurrentElement();
                            }
                        }
                    }
                } else {
                    xml.skipCurrentElement();
                }
            } else if (xml.name() == QLatin1String("TwoUpperLetterExceptions")) {
                if (loadAttribute == All) {
                    while (xml.readNextStartElement()) {
                        const QStringRef tagname = xml.name();
                        if (tagname == QLatin1String("word")) {
                            if (xml.attributes().hasAttribute(QStringLiteral("exception"))) {
                                const QString exception = xml.attributes().value(QStringLiteral("exception")).toString();
                                mTwoUpperLetterExceptions += exception;
                                xml.skipCurrentElement();
                            }
                        } else {
                            xml.skipCurrentElement();
                        }
                    }
                } else {
                    xml.skipCurrentElement();
                }
            } else if (xml.name() == QLatin1String("DoubleQuote")) {
                if (loadAttribute == All) {
                    if (xml.readNextStartElement()) {
                        const QStringRef tagname = xml.name();
                        if (tagname == QLatin1String("doublequote")) {
                            mTypographicDoubleQuotes.begin = xml.attributes().value(QStringLiteral("begin")).toString().at(0);
                            mTypographicDoubleQuotes.end = xml.attributes().value(QStringLiteral("end")).toString().at(0);
                            xml.skipCurrentElement();
                        } else {
                            xml.skipCurrentElement();
                        }
                    }
                } else {
                    xml.skipCurrentElement();
                }
            } else if (xml.name() == QLatin1String("SimpleQuote")) {
                if (loadAttribute == All) {
                    if (xml.readNextStartElement()) {
                        const QStringRef tagname = xml.name();
                        if (tagname == QLatin1String("simplequote")) {
                            mTypographicSingleQuotes.begin = xml.attributes().value(QStringLiteral("begin")).toString().at(0);
                            mTypographicSingleQuotes.end = xml.attributes().value(QStringLiteral("end")).toString().at(0);
                            xml.skipCurrentElement();
                        } else {
                            xml.skipCurrentElement();
                        }
                    }
                } else {
                    xml.skipCurrentElement();
                }
            } else if (xml.name() == QLatin1String("SuperScript")) {
                if (loadAttribute == All || loadAttribute == SuperScript) {
                    while (xml.readNextStartElement()) {
                        const QStringRef tagname = xml.name();
                        if (tagname == QLatin1String("item")) {
                            const QString find = xml.attributes().value(QStringLiteral("find")).toString();
                            const QString super = xml.attributes().value(QStringLiteral("super")).toString();
                            mSuperScriptEntries.insert(find, super);
                            xml.skipCurrentElement();
                        } else {
                            xml.skipCurrentElement();
                        }
                    }
                } else {
                    xml.skipCurrentElement();
                }
            } else if (xml.name() == QLatin1String("items")) {
                if (loadAttribute == All) {
                    while (xml.readNextStartElement()) {
                        const QStringRef tagname = xml.name();
                        if (tagname == QLatin1String("item")) {
                            const QString find = xml.attributes().value(QStringLiteral("find")).toString();
                            const QString replace = xml.attributes().value(QStringLiteral("replace")).toString();
                            const int findLenght(find.length());
                            mMaxFindStringLenght = qMax(findLenght, mMaxFindStringLenght);
                            mMinFindStringLenght = qMin(findLenght, mMinFindStringLenght);
                            mAutocorrectEntries.insert(find, replace);
                            xml.skipCurrentElement();
                        } else {
                            xml.skipCurrentElement();
                        }
                    }
                } else {
                    xml.skipCurrentElement();
                }
            } else {
                //TODO verify
                xml.skipCurrentElement();
            }
        }
    }
    return true;
}
0707010000002C000081A40000000200000002000000015CDAA394000004FB000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/import/importkmailautocorrection.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef IMPORTKMAILAUTOCORRECTION_H
#define IMPORTKMAILAUTOCORRECTION_H

#include "importabstractautocorrection.h"

namespace PimCommon {
class ImportKMailAutocorrection : public ImportAbstractAutocorrection
{
public:
    explicit ImportKMailAutocorrection(QWidget *parent = nullptr);
    ~ImportKMailAutocorrection() override;
    Q_REQUIRED_RESULT bool import(const QString &fileName, ImportAbstractAutocorrection::LoadAttribute loadAttribute = All) override;
};
}

#endif // IMPORTKMAILAUTOCORRECTION_H
0707010000002D000081A40000000200000002000000015CDAA394000015CF000000000000000000000000000000000000007500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/import/importlibreofficeautocorrection.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "importlibreofficeautocorrection.h"
#include <QFile>
#include <KZip>
#include <KLocalizedString>
#include <KMessageBox>
#include <QTemporaryDir>
#include "pimcommon_debug.h"
#include <QDomDocument>
#include <QDir>

using namespace PimCommon;

ImportLibreOfficeAutocorrection::ImportLibreOfficeAutocorrection(QWidget *parent)
    : ImportAbstractAutocorrection(parent)
{
}

ImportLibreOfficeAutocorrection::~ImportLibreOfficeAutocorrection()
{
    closeArchive();
}

void ImportLibreOfficeAutocorrection::closeArchive()
{
    if (mArchive) {
        if (mArchive->isOpen()) {
            mArchive->close();
        }
        delete mArchive;
        mArchive = nullptr;
    }

delete mTempDir;
    mTempDir = nullptr;
}

bool ImportLibreOfficeAutocorrection::import(const QString &fileName, LoadAttribute loadAttribute)
{
    //We Don't have it in LibreOffice
    if (loadAttribute == SuperScript) {
        return false;
    }
    closeArchive();
    mArchive = new KZip(fileName);
    const bool result = mArchive->open(QIODevice::ReadOnly);
    if (result) {
        importAutoCorrectionFile();
        return true;
    } else {
        KMessageBox::error(mParent, i18n("Archive cannot be opened in read mode."), i18n("Import LibreOffice Autocorrection File"));
        return false;
    }
}

void ImportLibreOfficeAutocorrection::importAutoCorrectionFile()
{
    mTempDir = new QTemporaryDir();
    const KArchiveDirectory *archiveDirectory = mArchive->directory();
    //Replace word
    importFile(DOCUMENT, archiveDirectory);

//No tread as end of line
    importFile(SENTENCE, archiveDirectory);

//Two upper letter
    importFile(WORD, archiveDirectory);
}

bool ImportLibreOfficeAutocorrection::importFile(Type type, const KArchiveDirectory *archiveDirectory)
{
    const KArchiveEntry *documentList = nullptr;

QString archiveFileName;
    switch (type) {
    case DOCUMENT:
        archiveFileName = QStringLiteral("DocumentList.xml");
        break;
    case SENTENCE:
        archiveFileName = QStringLiteral("SentenceExceptList.xml");
        break;
    case WORD:
        archiveFileName = QStringLiteral("WordExceptList.xml");
        break;
    default:
        return false;
    }
    documentList = archiveDirectory->entry(archiveFileName);
    if (documentList && documentList->isFile()) {
        const KArchiveFile *archiveFile = static_cast<const KArchiveFile *>(documentList);
        archiveFile->copyTo(mTempDir->path());
        QFile file(mTempDir->path() + QDir::separator() + archiveFileName);
        QDomDocument doc;
        if (loadDomElement(doc, &file)) {
            QDomElement list = doc.documentElement();
            if (list.isNull()) {
                qCDebug(PIMCOMMON_LOG) << "No list defined in " << type;
            } else {
                for (QDomElement e = list.firstChildElement(); !e.isNull(); e = e.nextSiblingElement()) {
                    const QString tag = e.tagName();
                    if (tag == QLatin1String("block-list:block")) {
                        switch (type) {
                        case DOCUMENT:
                            if (e.hasAttribute(QStringLiteral("block-list:abbreviated-name")) && e.hasAttribute(QStringLiteral("block-list:name"))) {
                                mAutocorrectEntries.insert(e.attribute(QStringLiteral("block-list:abbreviated-name")), e.attribute(QStringLiteral("block-list:name")));
                            }
                            break;
                        case SENTENCE:
                            if (e.hasAttribute(QStringLiteral("block-list:abbreviated-name"))) {
                                mTwoUpperLetterExceptions.insert(e.attribute(QStringLiteral("block-list:abbreviated-name")));
                            }

break;
                        case WORD:
                            if (e.hasAttribute(QStringLiteral("block-list:abbreviated-name"))) {
                                mUpperCaseExceptions.insert(e.attribute(QStringLiteral("block-list:abbreviated-name")));
                            }
                            break;
                        }
                    } else {
                        qCDebug(PIMCOMMON_LOG) << " unknown tag " << tag;
                    }
                }
            }
        }
    } else {
        return false;
    }
    return true;
}

bool ImportLibreOfficeAutocorrection::loadDomElement(QDomDocument &doc, QFile *file)
{
    QString errorMsg;
    int errorRow;
    int errorCol;
    if (!doc.setContent(file, &errorMsg, &errorRow, &errorCol)) {
        qCDebug(PIMCOMMON_LOG) << "Unable to load document.Parse error in line " << errorRow
                               << ", col " << errorCol << ": " << errorMsg;
        return false;
    }
    return true;
}
0707010000002E000081A40000000200000002000000015CDAA394000006D6000000000000000000000000000000000000007300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/import/importlibreofficeautocorrection.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef IMPORTLIBREOFFICEAUTOCORRECTION_H
#define IMPORTLIBREOFFICEAUTOCORRECTION_H

#include "importabstractautocorrection.h"

class QTemporaryDir;
class KZip;
class QDomDocument;
class QFile;
class KArchiveDirectory;

namespace PimCommon {
class ImportLibreOfficeAutocorrection : public ImportAbstractAutocorrection
{
public:
    explicit ImportLibreOfficeAutocorrection(QWidget *parent = nullptr);
    ~ImportLibreOfficeAutocorrection() override;

Q_REQUIRED_RESULT bool import(const QString &fileName, ImportAbstractAutocorrection::LoadAttribute loadAttribute = All) override;

private:
    enum Type {
        DOCUMENT,
        SENTENCE,
        WORD
    };

void importAutoCorrectionFile();
    void closeArchive();
    bool loadDomElement(QDomDocument &doc, QFile *file);
    bool importFile(Type type, const KArchiveDirectory *archiveDirectory);
    KZip *mArchive = nullptr;
    QTemporaryDir *mTempDir = nullptr;
};
}

#endif // IMPORTLIBREOFFICEAUTOCORRECTION_H
0707010000002F000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/tests07070100000030000081A40000000200000002000000015CDAA3940000020B000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/tests/CMakeLists.txtset(autocorrection_gui_SRCS autocorrection_gui.cpp)
add_executable(autocorrection_gui ${autocorrection_gui_SRCS})
target_link_libraries(autocorrection_gui
  KF5::KIOCore
  KF5::PimCommon
  KF5::PimTextEdit
  KF5::I18n
)

set(richtexteditwithautocorrection_gui_SRCS richtexteditwithautocorrection_gui.cpp)
add_executable(richtexteditwithautocorrection_gui ${richtexteditwithautocorrection_gui_SRCS})
target_link_libraries(richtexteditwithautocorrection_gui
  KF5::KIOCore
  KF5::PimCommon
  KF5::PimTextEdit
  KF5::I18n
)

07070100000031000081A40000000200000002000000015CDAA3940000150E000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/tests/autocorrection_gui.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrection_gui.h"
#include "autocorrection/autocorrection.h"
#include "autocorrection/autocorrectionwidget.h"
#include "autocorrection/widgets/lineeditwithautocorrection.h"
#include "settings/pimcommonsettings.h"

#include "pimcommon_debug.h"

#include <KSharedConfig>

#include <QPointer>
#include <QVBoxLayout>
#include <QPushButton>
#include <QKeyEvent>
#include <QToolBar>
#include <QAction>
#include <QApplication>
#include <QCommandLineParser>
#include <QDialogButtonBox>

ConfigureTestDialog::ConfigureTestDialog(PimCommon::AutoCorrection *autoCorrection, QWidget *parent)
    : QDialog(parent)
{
    setWindowTitle(QStringLiteral("Configure Autocorrection"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
    QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setDefault(true);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &ConfigureTestDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &ConfigureTestDialog::reject);

buttonBox->button(QDialogButtonBox::Ok)->setDefault(true);

mWidget = new PimCommon::AutoCorrectionWidget(this);
    mainLayout->addWidget(mWidget);
    mainLayout->addWidget(buttonBox);

mWidget->setAutoCorrection(autoCorrection);
    mWidget->loadConfig();
    connect(okButton, &QPushButton::clicked, this, &ConfigureTestDialog::slotSaveSettings);
}

ConfigureTestDialog::~ConfigureTestDialog()
{
}

void ConfigureTestDialog::slotSaveSettings()
{
    mWidget->writeConfig();
}

TextEditAutoCorrectionWidget::TextEditAutoCorrectionWidget(PimCommon::AutoCorrection *autoCorrection, QWidget *parent)
    : QTextEdit(parent)
    , mAutoCorrection(autoCorrection)
{
    setAcceptRichText(false);
}

TextEditAutoCorrectionWidget::~TextEditAutoCorrectionWidget()
{
}

void TextEditAutoCorrectionWidget::keyPressEvent(QKeyEvent *e)
{
    if ((e->key() == Qt::Key_Space) || (e->key() == Qt::Key_Enter) || (e->key() == Qt::Key_Return)) {
        if (mAutoCorrection && mAutoCorrection->isEnabledAutoCorrection()) {
            const QTextCharFormat initialTextFormat = textCursor().charFormat();
            int position = textCursor().position();
            mAutoCorrection->autocorrect(acceptRichText(), *document(), position);
            QTextCursor cur = textCursor();
            cur.setPosition(position);

const QChar insertChar = (e->key() == Qt::Key_Space) ? QLatin1Char(' ') : QLatin1Char('\n');
            cur.insertText(insertChar, initialTextFormat);
            setTextCursor(cur);
            return;
        }
    }
    QTextEdit::keyPressEvent(e);
}

AutocorrectionTestWidget::AutocorrectionTestWidget(QWidget *parent)
    : QWidget(parent)
{
    mConfig = KSharedConfig::openConfig(QStringLiteral("autocorrectionguirc"));
    PimCommon::PimCommonSettings::self()->setSharedConfig(mConfig);
    PimCommon::PimCommonSettings::self()->load();

mAutoCorrection = new PimCommon::AutoCorrection;
    QVBoxLayout *lay = new QVBoxLayout(this);
    QToolBar *bar = new QToolBar;
    lay->addWidget(bar);
    bar->addAction(QStringLiteral("Configure..."), this, &AutocorrectionTestWidget::slotConfigure);
    QAction *richText = new QAction(QStringLiteral("HTML mode"), this);
    richText->setCheckable(true);
    connect(richText, &QAction::toggled, this, &AutocorrectionTestWidget::slotChangeMode);
    bar->addAction(richText);

mSubject = new PimCommon::LineEditWithAutoCorrection(this, QStringLiteral("autocorrectionguirc"));
    mSubject->setAutocorrection(mAutoCorrection);
    lay->addWidget(mSubject);

mEdit = new TextEditAutoCorrectionWidget(mAutoCorrection);
    lay->addWidget(mEdit);
}

AutocorrectionTestWidget::~AutocorrectionTestWidget()
{
    mAutoCorrection->writeConfig();
    delete mAutoCorrection;
}

void AutocorrectionTestWidget::slotChangeMode(bool mode)
{
    mEdit->setAcceptRichText(mode);
}

void AutocorrectionTestWidget::slotConfigure()
{
    QPointer<ConfigureTestDialog> dlg = new ConfigureTestDialog(mAutoCorrection, this);
    if (dlg->exec()) {
        PimCommon::PimCommonSettings::self()->save();
    }
    delete dlg;
}

AutocorrectionTestWidget *w = new AutocorrectionTestWidget();
    w->resize(800, 600);

w->show();
    const int ret = app.exec();
    delete w;
    return ret;
}
07070100000032000081A40000000200000002000000015CDAA3940000084B000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/tests/autocorrection_gui.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TEST_AUTOCORRECTION_GUI_H
#define TEST_AUTOCORRECTION_GUI_H

#include <QWidget>
#include <KSharedConfig>
#include <QDialog>

#include <QTextEdit>

namespace PimCommon {
class AutoCorrection;
class AutoCorrectionWidget;
class LineEditWithAutoCorrection;
}

class ConfigureTestDialog : public QDialog
{
    Q_OBJECT
public:
    explicit ConfigureTestDialog(PimCommon::AutoCorrection *autoCorrection, QWidget *parent = nullptr);
    ~ConfigureTestDialog();

private Q_SLOTS:
    void slotSaveSettings();

private:
    PimCommon::AutoCorrectionWidget *mWidget = nullptr;
};

class TextEditAutoCorrectionWidget : public QTextEdit
{
    Q_OBJECT
public:
    explicit TextEditAutoCorrectionWidget(PimCommon::AutoCorrection *autoCorrection, QWidget *parent = nullptr);
    ~TextEditAutoCorrectionWidget() override;

protected:
    void keyPressEvent(QKeyEvent *e) override;

private:
    PimCommon::AutoCorrection *mAutoCorrection = nullptr;
};

class AutocorrectionTestWidget : public QWidget
{
    Q_OBJECT
public:
    explicit AutocorrectionTestWidget(QWidget *parent = nullptr);
    ~AutocorrectionTestWidget();

private Q_SLOTS:
    void slotConfigure();
    void slotChangeMode(bool);

private:
    TextEditAutoCorrectionWidget *mEdit = nullptr;
    PimCommon::LineEditWithAutoCorrection *mSubject = nullptr;
    PimCommon::AutoCorrection *mAutoCorrection = nullptr;
    KSharedConfig::Ptr mConfig;
};

#endif
07070100000033000081A40000000200000002000000015CDAA394000004FC000000000000000000000000000000000000007700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/tests/richtexteditwithautocorrection_gui.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrection/widgets/richtexteditwithautocorrection.h"

#include "pimcommon_debug.h"

#include <QApplication>
#include <QCommandLineParser>
#include <QStandardPaths>

PimCommon::RichTextEditWithAutoCorrection *w = new PimCommon::RichTextEditWithAutoCorrection;

w->show();
    app.exec();
    delete w;
    return 0;
}
07070100000034000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/ui07070100000035000081A40000000200000002000000015CDAA394000050E0000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/ui/autocorrectionwidget.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>AutoCorrectionWidget</class>
 <widget class="QWidget" name="AutoCorrectionWidget">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>587</width>
    <height>572</height>
   </rect>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <item row="0" column="0">
    <widget class="QCheckBox" name="enabledAutocorrection">
     <property name="text">
      <string>Enable autocorrection</string>
     </property>
    </widget>
   </item>
   <item row="1" column="0">
    <layout class="QHBoxLayout" name="horizontalLayout">
     <item>
      <widget class="QLabel" name="label">
       <property name="text">
        <string>Replacement and exception for language:</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="PimCommon::AutoCorrectionLanguage" name="autocorrectionLanguage"/>
     </item>
    </layout>
   </item>
   <item row="2" column="0">
    <widget class="QTabWidget" name="tabWidget">
     <property name="currentIndex">
      <number>0</number>
     </property>
     <widget class="QWidget" name="tab_1">
      <attribute name="title">
       <string>Si&amp;mple Autocorrection</string>
      </attribute>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <item>
        <widget class="QCheckBox" name="upperCase">
         <property name="whatsThis">
          <string>Detect when a new sentence is started and always ensure that the first character is an uppercase character</string>
         </property>
         <property name="text">
          <string>Convert &amp;first letter of a sentence automatically to uppercase
(e.g. &quot;my house. in this town&quot; to &quot;my house. In this town&quot;)</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="upperUpper">
         <property name="toolTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string>All words are checked for the common mistake of holding the shift key down a bit too long. If some words must have two uppercase characters, then those exceptions should be added in the 'Exceptions' tab.</string>
         </property>
         <property name="text">
          <string>Convert &amp;two uppercase characters to one uppercase and one lowercase character
 (e.g. PErfect to Perfect)</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="ignoreDoubleSpace">
         <property name="whatsThis">
          <string>Make sure that more than one space cannot be typed, as this is a common mistake which is quite hard to find in formatted text.</string>
         </property>
         <property name="text">
          <string>&amp;Suppress double spaces</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="autoReplaceNumber">
         <property name="whatsThis">
          <string>Most standard fraction notations will be converted when available</string>
         </property>
         <property name="text">
          <string>Re&amp;place 1/2... with ½...</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="capitalizeDaysName">
         <property name="text">
          <string>Capitalize name of days</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="autoFormatUrl">
         <property name="whatsThis">
          <string>Detect when a URL (Uniform Resource Locator) is typed and provide formatting that matches the way an Internet browser would show a URL.</string>
         </property>
         <property name="text">
          <string>Autoformat &amp;URLs (HTML mode)</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="autoChangeFormat">
         <property name="whatsThis">
          <string>When you use _underline_ or *bold*, the text between the underscores or asterisks will be converted to underlined or bold text.</string>
         </property>
         <property name="text">
          <string>Automatically do &amp;bold, strikeout and underline formatting (HTML mode)</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="autoSuperScript">
         <property name="text">
          <string>Replace 1st... with 1^st... (HTML mode)</string>
         </property>
        </widget>
       </item>
       <item>
        <spacer>
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="tab_2">
      <attribute name="title">
       <string>Custom &amp;Quotes</string>
      </attribute>
      <layout class="QGridLayout" name="_3">
       <item row="2" column="0" colspan="2">
        <widget class="QCheckBox" name="typographicSingleQuotes">
         <property name="text">
          <string>Replace &amp;single quotes with typographical quotes</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0" colspan="2">
        <widget class="QCheckBox" name="typographicDoubleQuotes">
         <property name="text">
          <string>Replace &amp;double quotes with typographical quotes</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <layout class="QHBoxLayout" name="_4">
         <property name="spacing">
          <number>0</number>
         </property>
         <property name="leftMargin">
          <number>20</number>
         </property>
         <item>
          <widget class="QPushButton" name="doubleQuote1">
           <property name="text">
            <string/>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QPushButton" name="doubleQuote2">
           <property name="text">
            <string/>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item row="1" column="1">
        <layout class="QHBoxLayout" name="_5">
         <item>
          <widget class="QPushButton" name="doubleDefault">
           <property name="text">
            <string>Default</string>
           </property>
          </widget>
         </item>
         <item>
          <spacer>
           <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 row="3" column="0">
        <layout class="QHBoxLayout" name="_6">
         <property name="spacing">
          <number>0</number>
         </property>
         <property name="leftMargin">
          <number>20</number>
         </property>
         <item>
          <widget class="QPushButton" name="singleQuote1">
           <property name="text">
            <string/>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QPushButton" name="singleQuote2">
           <property name="text">
            <string/>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item row="3" column="1">
        <layout class="QHBoxLayout" name="_7">
         <item>
          <widget class="QPushButton" name="singleDefault">
           <property name="text">
            <string>Default</string>
           </property>
          </widget>
         </item>
         <item>
          <spacer>
           <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 row="5" column="1">
        <spacer>
         <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 row="4" column="0" colspan="2">
        <widget class="QCheckBox" name="addNonBreakingSpaceInFrench">
         <property name="text">
          <string>Add non breaking space before specific punctuation marks in French text</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="tab_3">
      <attribute name="title">
       <string>Ad&amp;vanced Autocorrection</string>
      </attribute>
      <layout class="QGridLayout" name="_8">
       <item row="1" column="1" rowspan="2">
        <layout class="QVBoxLayout" name="_11">
         <item>
          <widget class="QPushButton" name="addButton">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="text">
            <string>&amp;Add</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QPushButton" name="removeButton">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="text">
            <string>Remove</string>
           </property>
          </widget>
         </item>
         <item>
          <spacer>
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>40</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </item>
       <item row="0" column="0">
        <widget class="QCheckBox" name="advancedAutocorrection">
         <property name="text">
          <string>&amp;Enable word replacement</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <layout class="QHBoxLayout" name="_10">
         <item>
          <widget class="QLabel" name="findLabel">
           <property name="text">
            <string>&amp;Find</string>
           </property>
           <property name="buddy">
            <cstring>find</cstring>
           </property>
          </widget>
         </item>
         <item>
          <widget class="KLineEdit" name="find">
           <property name="trapEnterKeyEvent" stdset="0">
            <bool>true</bool>
           </property>
           <property name="showClearButton" stdset="0">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="replaceLabel">
           <property name="text">
            <string>Re&amp;place</string>
           </property>
           <property name="buddy">
            <cstring>replace</cstring>
           </property>
          </widget>
         </item>
         <item>
          <widget class="KLineEdit" name="replace">
           <property name="trapEnterKeyEvent" stdset="0">
            <bool>true</bool>
           </property>
           <property name="showClearButton" stdset="0">
            <bool>true</bool>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item row="2" column="0">
        <widget class="PimCommon::AutoCorrectionTreeWidget" name="treeWidget">
         <property name="editTriggers">
          <set>QAbstractItemView::NoEditTriggers</set>
         </property>
         <property name="alternatingRowColors">
          <bool>true</bool>
         </property>
         <property name="selectionMode">
          <enum>QAbstractItemView::ExtendedSelection</enum>
         </property>
         <property name="selectionBehavior">
          <enum>QAbstractItemView::SelectRows</enum>
         </property>
         <property name="rootIsDecorated">
          <bool>false</bool>
         </property>
         <column>
          <property name="text">
           <string>Find</string>
          </property>
         </column>
         <column>
          <property name="text">
           <string>Replace</string>
          </property>
         </column>
        </widget>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="tab_4">
      <attribute name="title">
       <string>E&amp;xceptions</string>
      </attribute>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <layout class="QGridLayout" name="gridLayout_3">
         <item row="0" column="0" colspan="2">
          <widget class="QLabel" name="label_4">
           <property name="text">
            <string>Do not treat as the end of a sentence:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
          <widget class="KLineEdit" name="abbreviation">
           <property name="trapEnterKeyEvent" stdset="0">
            <bool>true</bool>
           </property>
           <property name="showClearButton" stdset="0">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="1" column="1" rowspan="2">
          <layout class="QVBoxLayout" name="_14">
           <item>
            <widget class="QPushButton" name="add1">
             <property name="text">
              <string>&amp;Add</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="remove1">
             <property name="text">
              <string>R&amp;emove</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer>
             <property name="orientation">
              <enum>Qt::Vertical</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>40</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item row="2" column="0">
          <widget class="PimCommon::AutoCorrectionListWidget" name="abbreviationList">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="selectionMode">
            <enum>QAbstractItemView::ExtendedSelection</enum>
           </property>
           <property name="sortingEnabled">
            <bool>true</bool>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item>
        <layout class="QGridLayout" name="gridLayout_2">
         <item row="0" column="0">
          <widget class="QLabel" name="label_5">
           <property name="text">
            <string>Accept two uppercase letters in:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
          <widget class="KLineEdit" name="twoUpperLetter">
           <property name="trapEnterKeyEvent" stdset="0">
            <bool>true</bool>
           </property>
           <property name="showClearButton" stdset="0">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="1" column="1" rowspan="2">
          <layout class="QVBoxLayout" name="_16">
           <item>
            <widget class="QPushButton" name="add2">
             <property name="text">
              <string>Add</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="remove2">
             <property name="text">
              <string>Remove</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer>
             <property name="orientation">
              <enum>Qt::Vertical</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>40</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item row="2" column="0">
          <widget class="PimCommon::AutoCorrectionListWidget" name="twoUpperLetterList">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="selectionMode">
            <enum>QAbstractItemView::ExtendedSelection</enum>
           </property>
           <property name="sortingEnabled">
            <bool>true</bool>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </widget>
   </item>
   <item row="3" column="0">
    <layout class="QHBoxLayout" name="horizontalLayout_2">
     <item>
      <widget class="QPushButton" name="exportAutoCorrection">
       <property name="text">
        <string>Export...</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QPushButton" name="importAutoCorrection">
       <property name="text">
        <string>Import...</string>
       </property>
      </widget>
     </item>
     <item>
      <spacer name="horizontalSpacer">
       <property name="orientation">
        <enum>Qt::Horizontal</enum>
       </property>
       <property name="sizeHint" stdset="0">
        <size>
         <width>469</width>
         <height>20</height>
        </size>
       </property>
      </spacer>
     </item>
    </layout>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>QComboBox</class>
   <extends>QComboBox</extends>
   <header>kcombobox.h</header>
  </customwidget>
  <customwidget>
   <class>KLineEdit</class>
   <extends>QLineEdit</extends>
   <header>klineedit.h</header>
  </customwidget>
  <customwidget>
   <class>PimCommon::AutoCorrectionListWidget</class>
   <extends>QListWidget</extends>
   <header>autocorrection/autocorrectionlistwidget.h</header>
  </customwidget>
  <customwidget>
   <class>PimCommon::AutoCorrectionTreeWidget</class>
   <extends>QTreeWidget</extends>
   <header>autocorrection/autocorrectiontreewidget.h</header>
  </customwidget>
  <customwidget>
   <class>PimCommon::AutoCorrectionLanguage</class>
   <extends>QComboBox</extends>
   <header>autocorrection/autocorrectionlanguage.h</header>
  </customwidget>
 </customwidgets>
 <tabstops>
  <tabstop>enabledAutocorrection</tabstop>
  <tabstop>autocorrectionLanguage</tabstop>
  <tabstop>tabWidget</tabstop>
  <tabstop>upperCase</tabstop>
  <tabstop>upperUpper</tabstop>
  <tabstop>ignoreDoubleSpace</tabstop>
  <tabstop>autoReplaceNumber</tabstop>
  <tabstop>capitalizeDaysName</tabstop>
  <tabstop>autoFormatUrl</tabstop>
  <tabstop>autoChangeFormat</tabstop>
  <tabstop>autoSuperScript</tabstop>
  <tabstop>typographicDoubleQuotes</tabstop>
  <tabstop>doubleQuote1</tabstop>
  <tabstop>doubleQuote2</tabstop>
  <tabstop>doubleDefault</tabstop>
  <tabstop>typographicSingleQuotes</tabstop>
  <tabstop>singleQuote1</tabstop>
  <tabstop>singleQuote2</tabstop>
  <tabstop>singleDefault</tabstop>
  <tabstop>addNonBreakingSpaceInFrench</tabstop>
  <tabstop>advancedAutocorrection</tabstop>
  <tabstop>find</tabstop>
  <tabstop>replace</tabstop>
  <tabstop>addButton</tabstop>
  <tabstop>removeButton</tabstop>
  <tabstop>treeWidget</tabstop>
  <tabstop>abbreviation</tabstop>
  <tabstop>add1</tabstop>
  <tabstop>remove1</tabstop>
  <tabstop>abbreviationList</tabstop>
  <tabstop>twoUpperLetter</tabstop>
  <tabstop>add2</tabstop>
  <tabstop>remove2</tabstop>
  <tabstop>twoUpperLetterList</tabstop>
  <tabstop>exportAutoCorrection</tabstop>
  <tabstop>importAutoCorrection</tabstop>
 </tabstops>
 <resources/>
 <connections/>
</ui>
07070100000036000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/widgets07070100000037000081A40000000200000002000000015CDAA39400000BD0000000000000000000000000000000000000007100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/widgets/lineeditwithautocorrection.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "autocorrection/widgets/lineeditwithautocorrection.h"
#include "autocorrection/autocorrection.h"

#include <QKeyEvent>

using namespace PimCommon;
class PimCommon::LineEditWithAutoCorrectionPrivate
{
public:
    LineEditWithAutoCorrectionPrivate()
        : mAutoCorrection(new PimCommon::AutoCorrection())
    {
    }

~LineEditWithAutoCorrectionPrivate()
    {
        if (mNeedToDeleteAutoCorrection) {
            delete mAutoCorrection;
        }
    }

PimCommon::AutoCorrection *mAutoCorrection = nullptr;
    bool mNeedToDeleteAutoCorrection = true;
};

LineEditWithAutoCorrection::LineEditWithAutoCorrection(QWidget *parent, const QString &configFile)
    : PimCommon::SpellCheckLineEdit(parent, configFile)
    , d(new PimCommon::LineEditWithAutoCorrectionPrivate)
{
}

LineEditWithAutoCorrection::~LineEditWithAutoCorrection()
{
    delete d;
}

AutoCorrection *LineEditWithAutoCorrection::autocorrection() const
{
    return d->mAutoCorrection;
}

void LineEditWithAutoCorrection::setAutocorrection(PimCommon::AutoCorrection *autocorrect)
{
    d->mNeedToDeleteAutoCorrection = false;
    delete d->mAutoCorrection;
    d->mAutoCorrection = autocorrect;
}

void LineEditWithAutoCorrection::setAutocorrectionLanguage(const QString &language)
{
    d->mAutoCorrection->setLanguage(language);
}

void LineEditWithAutoCorrection::keyPressEvent(QKeyEvent *e)
{
    if (d->mAutoCorrection && d->mAutoCorrection->isEnabledAutoCorrection()) {
        if ((e->key() == Qt::Key_Space) || (e->key() == Qt::Key_Enter) || (e->key() == Qt::Key_Return)) {
            if (!textCursor().hasSelection()) {
                // no Html format in subject.
                int position = textCursor().position();
                const bool addSpace = d->mAutoCorrection->autocorrect(false, *document(), position);
                QTextCursor cur = textCursor();
                cur.setPosition(position);
                if (e->key() == Qt::Key_Space) {
                    if (addSpace) {
                        cur.insertText(QStringLiteral(" "));
                        setTextCursor(cur);
                    }
                    return;
                }
            }
        }
    }
    PimCommon::SpellCheckLineEdit::keyPressEvent(e);
}
07070100000038000081A40000000200000002000000015CDAA3940000065D000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/widgets/lineeditwithautocorrection.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef SUBJECTLINEEDITWITHAUTOCORRECTION_H
#define SUBJECTLINEEDITWITHAUTOCORRECTION_H

#include "pimcommon_export.h"

#include <PimCommon/SpellCheckLineEdit>

namespace PimCommon {
class AutoCorrection;
class LineEditWithAutoCorrectionPrivate;
class PIMCOMMON_EXPORT LineEditWithAutoCorrection : public PimCommon::SpellCheckLineEdit
{
    Q_OBJECT
public:
    explicit LineEditWithAutoCorrection(QWidget *parent, const QString &configFile);
    ~LineEditWithAutoCorrection() override;

Q_REQUIRED_RESULT PimCommon::AutoCorrection *autocorrection() const;

void setAutocorrection(PimCommon::AutoCorrection *autocorrect);
    void setAutocorrectionLanguage(const QString &language);

protected:
    void keyPressEvent(QKeyEvent *e) override;

private:
    LineEditWithAutoCorrectionPrivate *const d;
};
}

#endif // SUBJECTLINEEDITWITHAUTOCORRECTION_H
07070100000039000081A40000000200000002000000015CDAA39400000E68000000000000000000000000000000000000007500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/widgets/richtexteditwithautocorrection.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "richtexteditwithautocorrection.h"
#include "autocorrection/autocorrection.h"

#include <QKeyEvent>

using namespace PimCommon;

class PimCommon::RichTextEditWithAutoCorrectionPrivate
{
public:
    RichTextEditWithAutoCorrectionPrivate()
        : mAutoCorrection(new PimCommon::AutoCorrection())
    {
    }

~RichTextEditWithAutoCorrectionPrivate()
    {
        if (mNeedToDelete) {
            delete mAutoCorrection;
        }
    }

PimCommon::AutoCorrection *mAutoCorrection = nullptr;
    bool mNeedToDelete = true;
};

RichTextEditWithAutoCorrection::RichTextEditWithAutoCorrection(QWidget *parent)
    : KPIMTextEdit::RichTextEditor(parent)
    , d(new PimCommon::RichTextEditWithAutoCorrectionPrivate)
{
}

RichTextEditWithAutoCorrection::~RichTextEditWithAutoCorrection()
{
    delete d;
}

void RichTextEditWithAutoCorrection::setAutocorrection(PimCommon::AutoCorrection *autocorrect)
{
    d->mNeedToDelete = false;
    delete d->mAutoCorrection;
    d->mAutoCorrection = autocorrect;
}

AutoCorrection *RichTextEditWithAutoCorrection::autocorrection() const
{
    return d->mAutoCorrection;
}

void RichTextEditWithAutoCorrection::setAutocorrectionLanguage(const QString &language)
{
    d->mAutoCorrection->setLanguage(language);
}

static bool isSpecial(const QTextCharFormat &charFormat)
{
    return charFormat.isFrameFormat() || charFormat.isImageFormat()
           || charFormat.isListFormat() || charFormat.isTableFormat() || charFormat.isTableCellFormat();
}

void RichTextEditWithAutoCorrection::keyPressEvent(QKeyEvent *e)
{
    if (d->mAutoCorrection && d->mAutoCorrection->isEnabledAutoCorrection()) {
        if ((e->key() == Qt::Key_Space) || (e->key() == Qt::Key_Enter) || (e->key() == Qt::Key_Return)) {
            if (!textCursor().hasSelection()) {
                const QTextCharFormat initialTextFormat = textCursor().charFormat();
                const bool richText = acceptRichText();
                int position = textCursor().position();
                const bool addSpace = d->mAutoCorrection->autocorrect(richText, *document(), position);
                QTextCursor cur = textCursor();
                cur.setPosition(position);
                const bool spacePressed = (e->key() == Qt::Key_Space);
                const QChar insertChar = spacePressed ? QLatin1Char(' ') : QLatin1Char('\n');
                if (richText && !isSpecial(initialTextFormat)) {
                    if ((spacePressed && addSpace) || !spacePressed) {
                        cur.insertText(insertChar, initialTextFormat);
                    }
                } else {
                    if ((spacePressed && addSpace) || !spacePressed) {
                        cur.insertText(insertChar);
                    }
                }
                setTextCursor(cur);
                return;
            }
        }
    }
    KPIMTextEdit::RichTextEditor::keyPressEvent(e);
}
0707010000003A000081A40000000200000002000000015CDAA39400000657000000000000000000000000000000000000007300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autocorrection/widgets/richtexteditwithautocorrection.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef RICHTEXTEDITWITHAUTOCORRECTION_H
#define RICHTEXTEDITWITHAUTOCORRECTION_H

#include "pimcommon_export.h"
#include "kpimtextedit/richtexteditor.h"

namespace PimCommon {
class AutoCorrection;
class RichTextEditWithAutoCorrectionPrivate;
class PIMCOMMON_EXPORT RichTextEditWithAutoCorrection : public KPIMTextEdit::RichTextEditor
{
    Q_OBJECT
public:
    explicit RichTextEditWithAutoCorrection(QWidget *parent = nullptr);
    ~RichTextEditWithAutoCorrection() override;

Q_REQUIRED_RESULT PimCommon::AutoCorrection *autocorrection() const;

void setAutocorrection(PimCommon::AutoCorrection *autocorrect);

void setAutocorrectionLanguage(const QString &language);

protected:
    void keyPressEvent(QKeyEvent *e) override;

private:
    RichTextEditWithAutoCorrectionPrivate *const d;
};
}

#endif // RICHTEXTEDITWITHAUTOCORRECTION_H
0707010000003B000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autotests0707010000003C000081A40000000200000002000000015CDAA39400000144000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autotests/CMakeLists.txtmacro(add_pimcommon_regularexpression_unittest _name)
    ecm_add_test(${ARGN}
        TEST_NAME ${_name}
        NAME_PREFIX "pimcommon-regularexpression-"
        LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::PimCommon
    )
endmacro()

add_pimcommon_regularexpression_unittest(regularexpressiontests regularexpressiontests.cpp)
0707010000003D000081A40000000200000002000000015CDAA3940000740B000000000000000000000000000000000000006000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autotests/regularexpressiontests.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "regularexpressiontests.h"

#include <QTest>
#include <QRegExp>
#include <QRegularExpression>

RegularExpressionTests::RegularExpressionTests(QObject *parent)
    : QObject(parent)
{
}

RegularExpressionTests::~RegularExpressionTests()
{
}

// verify all pattern used as <word><space><a less one digit> => QStringLiteral("ArchiveMailCollection \\d+");
void RegularExpressionTests::shouldVerifyQStringListFilterConversion_data()
{
    QTest::addColumn<QStringList>("input");
    QTest::addColumn<QStringList>("expected");
    QTest::addColumn<QString>("regexp");
    QTest::newRow("empty") <<  QStringList() << QStringList() << QStringLiteral("ArchiveMailCollection \\d+");
    QTest::newRow("nocatcher") << (QStringList() << QStringLiteral("ArchiveMailCollection DD") << QStringLiteral("ArchiveMailCollection") << QStringLiteral("ArchiveMailCollection ") << QString())
                               << QStringList() << QStringLiteral("ArchiveMailCollection \\d+");
    QTest::newRow("catch") << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
                           << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
                           << QStringLiteral("ArchiveMailCollection \\d+");
    QTest::newRow("catch with several space")
        << (QStringList() << QStringLiteral("ArchiveMailCollection   12") << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78")) << QStringLiteral(
        "ArchiveMailCollection \\d+");
    QTest::newRow("catch with empty")
        << (QStringList() << QString() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
        << QStringLiteral("ArchiveMailCollection \\d+");

QTest::newRow("catch with not invalid string")
        << (QStringList() << QStringLiteral("rchiveMailCollection 54") << QStringLiteral("ArchiveMailCollection 12")
            << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58")
        << QStringLiteral("ArchiveMailCollection 78")) << QStringLiteral("ArchiveMailCollection \\d+");

QTest::newRow("lowercase")
        << (QStringList() << QStringLiteral("archiveMailCollection 54") << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
        << QStringLiteral("ArchiveMailCollection \\d+");

QTest::newRow("invalid")
        << (QStringList() << QStringLiteral("ArchiveMailCollection VV") << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
        << QStringLiteral("ArchiveMailCollection \\d+");

QTest::newRow("missing space")
        << (QStringList() << QStringLiteral("ArchiveMailCollection55") << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
        << QStringLiteral("ArchiveMailCollection \\d+");
}

void RegularExpressionTests::shouldVerifyQStringListFilterConversion()
{
    QFETCH(QStringList, input);
    QFETCH(QStringList, expected);
    QFETCH(QString, regexp);

QStringList newList = input.filter(QRegExp(regexp));
    QCOMPARE(newList, expected);
    newList = input.filter(QRegularExpression(regexp));
    QCOMPARE(newList, expected);
}

// verify all pattern used as <word><space><a less one digit> => QStringLiteral("ArchiveMailCollection\\s\\d+");
void RegularExpressionTests::shouldVerifyQStringListFilterSpaceConversion_data()
{
    QTest::addColumn<QStringList>("input");
    QTest::addColumn<QStringList>("expected");
    QTest::addColumn<QString>("regexp");
    const QString regExpStr = QStringLiteral("ArchiveMailCollection\\s\\d+");
    QTest::newRow("empty") <<  QStringList() << QStringList() << regExpStr;
    QTest::newRow("nocatcher") << (QStringList() << QStringLiteral("ArchiveMailCollection DD") << QStringLiteral("ArchiveMailCollection") << QStringLiteral("ArchiveMailCollection ") << QString())
                               << QStringList() << QStringLiteral("ArchiveMailCollection \\d+");
    QTest::newRow("catch") << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
                           << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78")) << regExpStr;
    QTest::newRow("catch with several space")
        << (QStringList() << QStringLiteral("ArchiveMailCollection   12") << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78")) << QStringLiteral(
        "ArchiveMailCollection \\d+");
    QTest::newRow("catch with empty")
        << (QStringList() << QString() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58")
            << QStringLiteral("ArchiveMailCollection 78"))
        << (QStringList() << QStringLiteral("ArchiveMailCollection 12") << QStringLiteral("ArchiveMailCollection 58") << QStringLiteral("ArchiveMailCollection 78"))
        << regExpStr;

void RegularExpressionTests::shouldVerifyQStringListFilterSpaceConversion()
{
    QFETCH(QStringList, input);
    QFETCH(QStringList, expected);
    QFETCH(QString, regexp);

QStringList newList = input.filter(QRegExp(regexp));
    QCOMPARE(newList, expected);
    newList = input.filter(QRegularExpression(regexp));
    QCOMPARE(newList, expected);
}

//QRegExp("mailbox-") //balsasettings.cpp
void RegularExpressionTests::shouldVerifyQStringListFilterTwoConversion_data()
{
    QTest::addColumn<QStringList>("input");
    QTest::addColumn<QStringList>("expected");
    QTest::addColumn<QString>("regexp");
    const QString regExpStr = QStringLiteral("mailbox-");
    QTest::newRow("empty") <<  QStringList() << QStringList() << regExpStr;
    QTest::newRow("nocatcher") << (QStringList() << QStringLiteral("ArchiveMailCollection DD") << QStringLiteral("ArchiveMailCollection") << QStringLiteral("ArchiveMailCollection ") << QString())
                               << QStringList() << regExpStr;
    QTest::newRow("catch") << (QStringList() << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QStringLiteral("mailbox-8"))
                           << (QStringList() << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QStringLiteral("mailbox-8")) << regExpStr;
    QTest::newRow("catch with empty") << (QStringList() << QString() << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QString() << QStringLiteral("mailbox-8"))
                                      << (QStringList() << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QStringLiteral("mailbox-8")) << regExpStr;

QTest::newRow("catch with not invalid string")
        << (QStringList() << QStringLiteral("mailbox12") << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QString()
            << QStringLiteral("mailbox-8"))
        << (QStringList() << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QStringLiteral("mailbox-8")) << regExpStr;

QTest::newRow("uppercase") << (QStringList() << QStringLiteral("Mailbox-12") << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QString() << QStringLiteral("mailbox-8"))
                               << (QStringList() << QStringLiteral("mailbox-12") << QStringLiteral("mailbox-5") << QStringLiteral("mailbox-8")) << regExpStr;

QTest::newRow("invalid") << (QStringList() << QStringLiteral("Mailbox-AA") << QStringLiteral("mailbox-5") << QString() << QStringLiteral("mailbox-8"))
                             << (QStringList() << QStringLiteral("mailbox-5") << QStringLiteral("mailbox-8")) << regExpStr;
}

void RegularExpressionTests::shouldVerifyQStringListFilterTwoConversion()
{
    QFETCH(QStringList, input);
    QFETCH(QStringList, expected);
    QFETCH(QString, regexp);

QStringList newList = input.filter(QRegExp(regexp));
    QCOMPARE(newList, expected);
    newList = input.filter(QRegularExpression(regexp));
    QCOMPARE(newList, expected);
}

//QRegExp("Account: \\d+") see clawsmailsettings
void RegularExpressionTests::shouldVerifyQStringListFilterDoublePointConversion_data()
{
    QTest::addColumn<QStringList>("input");
    QTest::addColumn<QStringList>("expected");
    QTest::addColumn<QString>("regexp");
    const QString regExpStr = QStringLiteral("Account: \\d+");
    QTest::newRow("empty") <<  QStringList() << QStringList() << regExpStr;
    QTest::newRow("nocatcher") << (QStringList() << QStringLiteral("ArchiveMailCollection DD") << QStringLiteral("ArchiveMailCollection") << QStringLiteral("ArchiveMailCollection ") << QString())
                               << QStringList() << regExpStr;
    QTest::newRow("catch") << (QStringList() << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QStringLiteral("Account: 8"))
                           << (QStringList() << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QStringLiteral("Account: 8")) << regExpStr;
    QTest::newRow("catch with empty") << (QStringList() << QString() << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QString() << QStringLiteral("Account: 8"))
                                      << (QStringList() << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QStringLiteral("Account: 8")) << regExpStr;

QTest::newRow("catch with not invalid string")
        << (QStringList() << QStringLiteral("mailbox12") << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QString()
            << QStringLiteral("Account: 8"))
        << (QStringList() << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QStringLiteral("Account: 8")) << regExpStr;

QTest::newRow("lower") << (QStringList() << QStringLiteral("account: 12") << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QString() << QStringLiteral("Account: 8"))
                           << (QStringList() << QStringLiteral("Account: 12") << QStringLiteral("Account: 5") << QStringLiteral("Account: 8")) << regExpStr;

QTest::newRow("invalid") << (QStringList() << QStringLiteral("Account: AA") << QStringLiteral("Account: 5") << QString() << QStringLiteral("Account: 8"))
                             << (QStringList() << QStringLiteral("Account: 5") << QStringLiteral("Account: 8")) << regExpStr;
}

void RegularExpressionTests::shouldVerifyQStringListFilterDoublePointConversion()
{
    QFETCH(QStringList, input);
    QFETCH(QStringList, expected);
    QFETCH(QString, regexp);

QStringList newList = input.filter(QRegExp(regexp));
    QCOMPARE(newList, expected);
    newList = input.filter(QRegularExpression(regexp));
    QCOMPARE(newList, expected);
}

//QRegExp("^ServerSieve (.+)$") see sieveeditorutils
void RegularExpressionTests::shouldVerifyQStringListFilterWithStartCharAndEndConversion_data()
{
    QTest::addColumn<QStringList>("input");
    QTest::addColumn<QStringList>("expected");
    QTest::addColumn<QString>("regexp");
    const QString regExpStr = QStringLiteral("^ServerSieve (.+)$");
    QTest::newRow("empty") <<  QStringList() << QStringList() << regExpStr;
    QTest::newRow("nocatcher") << (QStringList() << QStringLiteral("ArchiveMailCollection DD") << QStringLiteral("ArchiveMailCollection") << QStringLiteral("ArchiveMailCollection ") << QString())
                               << QStringList() << regExpStr;
    QTest::newRow("catch") << (QStringList() << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QStringLiteral("ServerSieve 8"))
                           << (QStringList() << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QStringLiteral("ServerSieve 8")) << regExpStr;
    QTest::newRow("catch with empty") << (QStringList() << QString() << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QString() << QStringLiteral("ServerSieve 8"))
                                      << (QStringList() << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QStringLiteral("ServerSieve 8")) << regExpStr;

QTest::newRow("catch with not invalid string")
        << (QStringList() << QStringLiteral("mailbox12") << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QString()
            << QStringLiteral("ServerSieve 8"))
        << (QStringList() << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QStringLiteral("ServerSieve 8")) << regExpStr;

QTest::newRow("lower") << (QStringList() << QStringLiteral("serverSieve 12") << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QString() << QStringLiteral("ServerSieve 8"))
                           << (QStringList() << QStringLiteral("ServerSieve 12") << QStringLiteral("ServerSieve 5") << QStringLiteral("ServerSieve 8")) << regExpStr;

QTest::newRow("invalid") << (QStringList() << QStringLiteral("erverSieve AA") << QStringLiteral("ServerSieve 5") << QString() << QStringLiteral("ServerSieve 8"))
                             << (QStringList() << QStringLiteral("ServerSieve 5") << QStringLiteral("ServerSieve 8")) << regExpStr;
    QTest::newRow("text before start") << (QStringList() << QStringLiteral("  ServerSieve AA") << QStringLiteral("ServerSieve 5") << QString() << QStringLiteral("ServerSieve 8"))
                                       << (QStringList() << QStringLiteral("ServerSieve 5") << QStringLiteral("ServerSieve 8")) << regExpStr;
}

void RegularExpressionTests::shouldVerifyQStringListFilterWithStartCharAndEndConversion()
{
    QFETCH(QStringList, input);
    QFETCH(QStringList, expected);
    QFETCH(QString, regexp);

QStringList newList = input.filter(QRegExp(regexp));
    QCOMPARE(newList, expected);
    newList = input.filter(QRegularExpression(regexp));
    QCOMPARE(newList, expected);
}

//QRegExp("Filter #\\d+") see filterimporterexporter.cpp
void RegularExpressionTests::shouldVerifyQStringListFilterWithSharpConversion_data()
{
    QTest::addColumn<QStringList>("input");
    QTest::addColumn<QStringList>("expected");
    QTest::addColumn<QString>("regexp");
    const QString regExpStr = QStringLiteral("Filter #\\d+");
    QTest::newRow("empty") <<  QStringList() << QStringList() << regExpStr;
    QTest::newRow("nocatcher") << (QStringList() << QStringLiteral("ArchiveMailCollection DD") << QStringLiteral("ArchiveMailCollection") << QStringLiteral("ArchiveMailCollection ") << QString())
                               << QStringList() << regExpStr;
    QTest::newRow("catch") << (QStringList() << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QStringLiteral("Filter #8"))
                           << (QStringList() << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QStringLiteral("Filter #8")) << regExpStr;
    QTest::newRow("catch with empty") << (QStringList() << QString() << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QString() << QStringLiteral("Filter #8"))
                                      << (QStringList() << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QStringLiteral("Filter #8")) << regExpStr;

QTest::newRow("catch with not invalid string")
        << (QStringList() << QStringLiteral("mailbox12") << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QString()
            << QStringLiteral("Filter #8"))
        << (QStringList() << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QStringLiteral("Filter #8")) << regExpStr;

QTest::newRow("lower") << (QStringList() << QStringLiteral("filter #12") << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QString() << QStringLiteral("Filter #8"))
                           << (QStringList() << QStringLiteral("Filter #12") << QStringLiteral("Filter #5") << QStringLiteral("Filter #8")) << regExpStr;

QTest::newRow("invalid") << (QStringList() << QStringLiteral("Filter #AA") << QStringLiteral("Filter #5") << QString() << QStringLiteral("Filter #8"))
                             << (QStringList() << QStringLiteral("Filter #5") << QStringLiteral("Filter #8")) << regExpStr;
}

void RegularExpressionTests::shouldVerifyQStringListFilterWithSharpConversion()
{
    QFETCH(QStringList, input);
    QFETCH(QStringList, expected);
    QFETCH(QString, regexp);

QStringList newList = input.filter(QRegExp(regexp));
    QCOMPARE(newList, expected);
    newList = input.filter(QRegularExpression(regexp));
    QCOMPARE(newList, expected);
}

void RegularExpressionTests::shouldReplaceString_data()
{
    QTest::addColumn<QString>("input");
    QTest::addColumn<QString>("expected");
    QTest::addColumn<QString>("replacewith");
    QTest::addColumn<QString>("regexp");
    QTest::newRow("email with at") << QStringLiteral("foo (at) kde.org") << QStringLiteral("foo@kde.org") << QStringLiteral("@") << QStringLiteral("\\s*\$at\$\\s*");
    QTest::newRow("endline one") << QStringLiteral("\n") << QStringLiteral("<br/>") << QStringLiteral("<br/>") << QStringLiteral("\n+");
    QTest::newRow("endline multiple") << QStringLiteral("\n\n") << QStringLiteral("<br/>") << QStringLiteral("<br/>") << QStringLiteral("\n+");
    QTest::newRow("endline multiple with space") << QStringLiteral("\n  \n") << QStringLiteral("<br/>  <br/>") << QStringLiteral("<br/>") << QStringLiteral("\n+");
    QTest::newRow("replace end file") << QStringLiteral("foo.mbx") << QStringLiteral("foo.png") << QStringLiteral("png") << QStringLiteral("mbx$");
    QTest::newRow("replace end file invalid") << QStringLiteral("foo.mbx1") << QStringLiteral("foo.mbx1") << QStringLiteral("png") << QStringLiteral("mbx$");
}

void RegularExpressionTests::shouldReplaceString()
{
    QFETCH(QString, input);
    QFETCH(QString, expected);
    QFETCH(QString, replacewith);
    QFETCH(QString, regexp);

QCOMPARE(input.replace(QRegExp(regexp), replacewith), expected);
    QCOMPARE(input.replace(QRegularExpression(regexp), replacewith), expected);
}

//QRegExp("WinPMail Identity - *") see pmailsettings
void RegularExpressionTests::shouldVerifyQStringListFilterWithPmailSettingsConversion_data()
{
    QTest::addColumn<QStringList>("input");
    QTest::addColumn<QStringList>("expected");
    QTest::addColumn<QString>("regexp");
    const QString regExpStr = QStringLiteral("WinPMail Identity - *");
    QTest::newRow("empty") <<  QStringList() << QStringList() << regExpStr;
    QTest::newRow("nocatcher") << (QStringList() << QStringLiteral("ArchiveMailCollection DD") << QStringLiteral("ArchiveMailCollection") << QStringLiteral("ArchiveMailCollection ") << QString())
                               << QStringList() << regExpStr;
    QTest::newRow("catch") << (QStringList() << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5") << QStringLiteral("WinPMail Identity - 8"))
                           << (QStringList() << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5") << QStringLiteral("WinPMail Identity - 8")) << regExpStr;
    QTest::newRow("catch with empty")
        << (QStringList() << QString() << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5") << QString()
            << QStringLiteral("WinPMail Identity - 8"))
        << (QStringList() << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5") << QStringLiteral("WinPMail Identity - 8")) << regExpStr;

QTest::newRow("catch with not invalid string")
        << (QStringList() << QStringLiteral("mailbox12") << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5")
            << QString() << QStringLiteral("WinPMail Identity - 8"))
        << (QStringList() << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5")
        << QStringLiteral("WinPMail Identity - 8")) << regExpStr;

QTest::newRow("lower")
        << (QStringList() << QStringLiteral("winPMail Identity - 12") << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5") << QString()
            << QStringLiteral("WinPMail Identity - 8"))
        << (QStringList() << QStringLiteral("WinPMail Identity - 12") << QStringLiteral("WinPMail Identity - 5") << QStringLiteral("WinPMail Identity - 8")) << regExpStr;
}

void RegularExpressionTests::shouldContainsString_data()
{
    QTest::addColumn<QString>("input");
    QTest::addColumn<bool>("contains");
    QTest::addColumn<QString>("regexp");
    QTest::newRow("valid ipv4") << QStringLiteral("123.125.44.12") << true << QStringLiteral("\\b[0-9]{1,3}\\.[0-9]{1,3}(?:\\.[0-9]{0,3})?(?:\\.[0-9]{0,3})?");
    QTest::newRow("not valid ipv4") << QStringLiteral("NOVALID") << false << QStringLiteral("\\b[0-9]{1,3}\\.[0-9]{1,3}(?:\\.[0-9]{0,3})?(?:\\.[0-9]{0,3})?");
}

void RegularExpressionTests::shouldContainsString()
{
    QFETCH(QString, input);
    QFETCH(bool, contains);
    QFETCH(QString, regexp);
    QCOMPARE(contains, input.contains(QRegExp(regexp)));
    QCOMPARE(contains, input.contains(QRegularExpression(regexp)));
}

void RegularExpressionTests::shouldCaptureValue_data()
{
    QTest::addColumn<QString>("input");
    QTest::addColumn<bool>("match");
    QTest::addColumn<QString>("regexp");
    QTest::addColumn<QStringList>("matchedElements");
    QTest::addColumn<bool>("insensitiveCase");
    QTest::newRow("cyrus") << QStringLiteral("Cyrus timsieved v2.2.12-ww")
                           << true
                           << QStringLiteral("Cyrus\\stimsieved\\sv(\\d+)\\.(\\d+)\\.(\\d+)([-\\w]*)")
                           << (QStringList() << QStringLiteral("2") << QStringLiteral("2") << QStringLiteral("12") << QStringLiteral("-ww"))
                           << true;

QTest::newRow("no match") << QStringLiteral("ww timsieved v2.2.12-ww")
                              << false
                              << QStringLiteral("Cyrus\\stimsieved\\sv(\\d+)\\.(\\d+)\\.(\\d+)([-\\w]*)")
                              << (QStringList())
                              << true;

QTest::newRow("without name") << QStringLiteral("Cyrus timsieved v2.2.12")
                                  << true
                                  << QStringLiteral("Cyrus\\stimsieved\\sv(\\d+)\\.(\\d+)\\.(\\d+)([-\\w]*)")
                                  << (QStringList() << QStringLiteral("2") << QStringLiteral("2") << QStringLiteral("12") << QString())
                                  << true;

QTest::newRow("insensitive case") << QStringLiteral("CYRUS timsieveD v2.2.12")
                                      << true
                                      << QStringLiteral("Cyrus\\stimsieved\\sv(\\d+)\\.(\\d+)\\.(\\d+)([-\\w]*)")
                                      << (QStringList() << QStringLiteral("2") << QStringLiteral("2") << QStringLiteral("12") << QString())
                                      << true;
}

void RegularExpressionTests::shouldCaptureValue()
{
    QFETCH(QString, input);
    QFETCH(bool, match);
    QFETCH(QString, regexp);
    QFETCH(QStringList, matchedElements);
    QFETCH(bool, insensitiveCase);

QRegExp regExp(regexp, insensitiveCase ? Qt::CaseInsensitive : Qt::CaseSensitive);
    bool hasMatch = (regExp.indexIn(input) >= 0);
    QCOMPARE(hasMatch, match);
    if (match) {
        const int major = regExp.cap(1).toInt();
        const int minor = regExp.cap(2).toInt();
        const int patch = regExp.cap(3).toInt();
        const QString vendor = regExp.cap(4);
        QCOMPARE(major, matchedElements.at(0).toInt());
        QCOMPARE(minor, matchedElements.at(1).toInt());
        QCOMPARE(patch, matchedElements.at(2).toInt());
        QCOMPARE(vendor, matchedElements.at(3));
    }

QRegularExpression expression(regexp, insensitiveCase ? QRegularExpression::CaseInsensitiveOption : QRegularExpression::NoPatternOption);
    QRegularExpressionMatch matchExpression = expression.match(input);
    hasMatch = matchExpression.hasMatch();
    QCOMPARE(hasMatch, match);
    if (match) {
        const int major = matchExpression.captured(1).toInt();
        const int minor = matchExpression.captured(2).toInt();
        const int patch = matchExpression.captured(3).toInt();
        const QString vendor = matchExpression.captured(4);
        QCOMPARE(major, matchedElements.at(0).toInt());
        QCOMPARE(minor, matchedElements.at(1).toInt());
        QCOMPARE(patch, matchedElements.at(2).toInt());
        QCOMPARE(vendor, matchedElements.at(3));
    }
}

void RegularExpressionTests::shouldVerifyQStringListFilterWithPmailSettingsConversion()
{
    QFETCH(QStringList, input);
    QFETCH(QStringList, expected);
    QFETCH(QString, regexp);

QStringList newList = input.filter(QRegExp(regexp));
    QCOMPARE(newList, expected);
    newList = input.filter(QRegularExpression(regexp));
    QCOMPARE(newList, expected);
}

void RegularExpressionTests::shouldRemoveString_data()
{
    QTest::addColumn<QString>("input");
    QTest::addColumn<QString>("expected");
    QTest::addColumn<QString>("regexp");
    QTest::newRow("email at") << QStringLiteral("foo@kde.org") << QStringLiteral("foo") << QStringLiteral("@.*");
    QTest::newRow("email at not valid") << QStringLiteral("foo(at)kde.org") << QStringLiteral("foo(at)kde.org") << QStringLiteral("@.*");
    QTest::newRow("email with underscore") << QStringLiteral("foo_blable") << QStringLiteral("foo") << QStringLiteral("_.*");
}

void RegularExpressionTests::shouldRemoveString()
{
    QFETCH(QString, input);
    QFETCH(QString, expected);
    QFETCH(QString, regexp);

QCOMPARE(input.remove(QRegExp(regexp)), expected);
    QCOMPARE(input.remove(QRegularExpression(regexp)), expected);
}

QTEST_MAIN(RegularExpressionTests)
0707010000003E000081A40000000200000002000000015CDAA3940000088D000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/autotests/regularexpressiontests.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef REGULAREXPRESSIONTESTS_H
#define REGULAREXPRESSIONTESTS_H

#include <QObject>

class RegularExpressionTests : public QObject
{
    Q_OBJECT
public:
    explicit RegularExpressionTests(QObject *parent = nullptr);
    ~RegularExpressionTests();
private Q_SLOTS:
    void shouldVerifyQStringListFilterConversion_data();
    void shouldVerifyQStringListFilterConversion();

void shouldVerifyQStringListFilterTwoConversion_data();
    void shouldVerifyQStringListFilterTwoConversion();

void shouldVerifyQStringListFilterSpaceConversion();
    void shouldVerifyQStringListFilterSpaceConversion_data();

void shouldVerifyQStringListFilterDoublePointConversion();
    void shouldVerifyQStringListFilterDoublePointConversion_data();

void shouldVerifyQStringListFilterWithSharpConversion();
    void shouldVerifyQStringListFilterWithSharpConversion_data();

void shouldReplaceString_data();
    void shouldReplaceString();

void shouldRemoveString_data();
    void shouldRemoveString();

void shouldVerifyQStringListFilterWithStartCharAndEndConversion_data();
    void shouldVerifyQStringListFilterWithStartCharAndEndConversion();

void shouldVerifyQStringListFilterWithPmailSettingsConversion();
    void shouldVerifyQStringListFilterWithPmailSettingsConversion_data();

void shouldContainsString_data();
    void shouldContainsString();

void shouldCaptureValue_data();
    void shouldCaptureValue();
};

#endif // REGULAREXPRESSIONTESTS_H
0707010000003F000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins07070100000040000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/autotests07070100000041000081A40000000200000002000000015CDAA394000003A1000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/autotests/CMakeLists.txtset( pimcommon_configureplugins_source_SRCS configurepluginswidgettest.cpp )
add_executable( configurepluginswidgettest ${pimcommon_configureplugins_source_SRCS} )
add_test(NAME configurepluginswidgettest COMMAND configurepluginswidgettest )
ecm_mark_as_test(kmail-configurepluginswidgettest)
target_link_libraries( configurepluginswidgettest Qt5::Test KF5::I18n Qt5::Widgets
    KF5::ConfigCore KF5::TextWidgets KF5::WidgetsAddons KF5::PimCommon)

set( pimcommon_configurepluginslist_source_SRCS configurepluginslistwidgettest.cpp)
add_executable( configurepluginslistwidgettest ${pimcommon_configurepluginslist_source_SRCS} )
add_test(NAME configurepluginslistwidgettest COMMAND configurepluginslistwidgettest )
ecm_mark_as_test(kmail-configurepluginslistwidgettest)
target_link_libraries( configurepluginslistwidgettest Qt5::Test KF5::I18n Qt5::Widgets
    KF5::ConfigCore KF5::TextWidgets KF5::WidgetsAddons KF5::PimCommon)
07070100000042000081A40000000200000002000000015CDAA39400000615000000000000000000000000000000000000007900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/autotests/configurepluginslistwidgettest.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "configurepluginslistwidgettest.h"
#include "../configurepluginslistwidget.h"
#include "kdepimtest_layout.h"
#include <QTest>
#include <QTreeWidget>
#include <QVBoxLayout>

ConfigurePluginsListWidgetTest::ConfigurePluginsListWidgetTest(QObject *parent)
    : QObject(parent)
{
}

ConfigurePluginsListWidgetTest::~ConfigurePluginsListWidgetTest()
{
}

void ConfigurePluginsListWidgetTest::shouldHaveDefaultValue()
{
    PimCommon::ConfigurePluginsListWidget w;

QVBoxLayout *mainLayout = w.findChild<QVBoxLayout *>(QStringLiteral("mainlayout"));
    QVERIFY(mainLayout);
    KdepimTestLayout::checkContentsMargins(0, mainLayout);

QTreeWidget *mListWidget = w.findChild<QTreeWidget *>(QStringLiteral("listwidget"));
    QVERIFY(mListWidget);
    QVERIFY(mListWidget->isSortingEnabled());
}

QTEST_MAIN(ConfigurePluginsListWidgetTest)
07070100000043000081A40000000200000002000000015CDAA39400000449000000000000000000000000000000000000007700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/autotests/configurepluginslistwidgettest.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CONFIGUREPLUGINSLISTWIDGETTEST_H
#define CONFIGUREPLUGINSLISTWIDGETTEST_H

#include <QObject>

class ConfigurePluginsListWidgetTest : public QObject
{
    Q_OBJECT
public:
    explicit ConfigurePluginsListWidgetTest(QObject *parent = nullptr);
    ~ConfigurePluginsListWidgetTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
};

#endif // CONFIGUREPLUGINSLISTWIDGETTEST_H
07070100000044000081A40000000200000002000000015CDAA39400000823000000000000000000000000000000000000007500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/autotests/configurepluginswidgettest.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "configurepluginswidgettest.h"
#include "../configurepluginswidget.h"
#include "../configurepluginslistwidget.h"
#include <QTextEdit>
#include <KMessageWidget>
#include <QSplitter>
#include <QTest>
#include <QStandardPaths>

ConfigurePluginsWidgetTest::ConfigurePluginsWidgetTest(QObject *parent)
    : QObject(parent)
{
    QStandardPaths::setTestModeEnabled(true);
}

ConfigurePluginsWidgetTest::~ConfigurePluginsWidgetTest()
{
}

void ConfigurePluginsWidgetTest::shouldHaveDefaultValue()
{
    PimCommon::ConfigurePluginsWidget w;

KMessageWidget *messageWidget = w.findChild<KMessageWidget *>(QStringLiteral("messagewidget"));
    QVERIFY(messageWidget);
    QVERIFY(!messageWidget->isCloseButtonVisible());
    QVERIFY(!messageWidget->text().isEmpty());

QSplitter *mSplitter = w.findChild<QSplitter *>(QStringLiteral("splitter"));
    QVERIFY(mSplitter);
    QCOMPARE(mSplitter->count(), 2);

PimCommon::ConfigurePluginsListWidget *mConfigureListWidget = mSplitter->findChild<PimCommon::ConfigurePluginsListWidget *>(QStringLiteral("configureListWidget"));
    QVERIFY(mConfigureListWidget);

QTextEdit *mDescription = mSplitter->findChild<QTextEdit *>(QStringLiteral("description"));
    QVERIFY(mDescription);
    QVERIFY(mDescription->isReadOnly());
    QVERIFY(mDescription->document()->isEmpty());
}

QTEST_MAIN(ConfigurePluginsWidgetTest)
07070100000045000081A40000000200000002000000015CDAA39400000431000000000000000000000000000000000000007300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/autotests/configurepluginswidgettest.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CONFIGUREPLUGINSWIDGETTEST_H
#define CONFIGUREPLUGINSWIDGETTEST_H

#include <QObject>

class ConfigurePluginsWidgetTest : public QObject
{
    Q_OBJECT
public:
    explicit ConfigurePluginsWidgetTest(QObject *parent = nullptr);
    ~ConfigurePluginsWidgetTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
};

#endif // CONFIGUREPLUGINSWIDGETTEST_H
07070100000046000081A40000000200000002000000015CDAA394000004DE000000000000000000000000000000000000006A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/autotests/kdepimtest_layout.h/*
   Copyright (C) 2019 Montel Laurent <montel@kde.org>

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; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#ifndef KDEPIMTEST_LAYOUT_H
#define KDEPIMTEST_LAYOUT_H
#include <QTest>
#include <QLayout>
namespace KdepimTestLayout
{
void checkContentsMargins(int margin, QLayout *layout)
{
    int top = -1;
    int bottom = -1;
    int left = -1;
    int right = -1;
    layout->getContentsMargins(&left, &top, &right, &bottom);
    QCOMPARE(top, margin);
    QCOMPARE(left, margin);
    QCOMPARE(bottom, margin);
    QCOMPARE(right, margin);
}
}

#endif
07070100000047000081A40000000200000002000000015CDAA39400000BD8000000000000000000000000000000000000006600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/configureplugindialog.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "configureplugindialog.h"
#include <QVBoxLayout>
#include <QDialogButtonBox>
#include <QPushButton>
#include <KConfigGroup>
#include <KSharedConfig>
#include <PimCommon/PimUtil>

using namespace PimCommon;

ConfigurePluginDialog::ConfigurePluginDialog(QWidget *parent)
    : QDialog(parent)
{
}

ConfigurePluginDialog::~ConfigurePluginDialog()
{
    saveConfig();
}

void ConfigurePluginDialog::initLayout(bool addSpacer)
{
    QVBoxLayout *layout = new QVBoxLayout(this);
    layout->addWidget(createLayout());
    if (addSpacer) {
        layout->addStretch(1);
    }

mButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults | QDialogButtonBox::Help, this);
    mButtonBox->setObjectName(QStringLiteral("buttonBox"));
    layout->addWidget(mButtonBox);
    connect(mButtonBox, &QDialogButtonBox::accepted, this, &ConfigurePluginDialog::slotAccepted);
    connect(mButtonBox, &QDialogButtonBox::rejected, this, &ConfigurePluginDialog::reject);
    connect(mButtonBox, &QDialogButtonBox::helpRequested, this, &ConfigurePluginDialog::slotHelpClicked);
    connect(mButtonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked, this, &ConfigurePluginDialog::slotRestoreDefaultClicked);
    readConfig();
    load();
}

void ConfigurePluginDialog::reset()
{
    //Reimplement it.
}

void ConfigurePluginDialog::help()
{
}

QDialogButtonBox *ConfigurePluginDialog::buttonBox() const
{
    return mButtonBox;
}

void ConfigurePluginDialog::showHelp(const QString &name, const QString &anchor)
{
    PimCommon::Util::invokeHelp(name, anchor);
}

void ConfigurePluginDialog::slotHelpClicked()
{
    help();
}

void ConfigurePluginDialog::slotRestoreDefaultClicked()
{
    reset();
}

void ConfigurePluginDialog::slotAccepted()
{
    save();
    accept();
}

void ConfigurePluginDialog::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "ConfigurePluginDialog");
    const QSize size = group.readEntry("Size", QSize(600, 400));
    if (size.isValid()) {
        resize(size);
    }
}

void ConfigurePluginDialog::saveConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "ConfigurePluginDialog");
    group.writeEntry("Size", size());
    group.sync();
}
07070100000048000081A40000000200000002000000015CDAA39400000685000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/configureplugindialog.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CONFIGUREPLUGINDIALOG_H
#define CONFIGUREPLUGINDIALOG_H

#include <QDialog>
#include "pimcommon_export.h"
class QDialogButtonBox;
namespace PimCommon {
class PIMCOMMON_EXPORT ConfigurePluginDialog : public QDialog
{
    Q_OBJECT
public:
    explicit ConfigurePluginDialog(QWidget *parent = nullptr);
    ~ConfigurePluginDialog();

void initLayout(bool addSpacer = false);

protected:
    void showHelp(const QString &name, const QString &anchor);
    virtual QWidget *createLayout() = 0;
    virtual void save() = 0;
    virtual void load() = 0;
    virtual void reset();

virtual void help();

Q_REQUIRED_RESULT QDialogButtonBox *buttonBox() const;

private:
    void slotHelpClicked();
    void slotAccepted();
    void slotRestoreDefaultClicked();
    void saveConfig();
    void readConfig();
    QDialogButtonBox *mButtonBox = nullptr;
};
}
#endif // CONFIGUREPLUGINDIALOG_H
07070100000049000081A40000000200000002000000015CDAA3940000195C000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/configurepluginslistwidget.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "configurepluginslistwidget.h"

#include <KSharedConfig>
#include <KLocalizedString>

#include <QPushButton>
#include <QToolButton>
#include <QTreeWidget>
#include <QHeaderView>
#include <QAction>
#include <QVBoxLayout>

using namespace PimCommon;
ConfigurePluginsListWidget::ConfigurePluginsListWidget(QWidget *parent)
    : QWidget(parent)
{
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->setObjectName(QStringLiteral("mainlayout"));
    mainLayout->setContentsMargins(0, 0, 0, 0);

mListWidget = new QTreeWidget(this);
    mListWidget->setSortingEnabled(true);
    mListWidget->sortItems(0, Qt::AscendingOrder);
    mListWidget->setObjectName(QStringLiteral("listwidget"));
    mListWidget->setHeaderHidden(true);
    mListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
    mListWidget->setColumnCount(2);
    mListWidget->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);

connect(mListWidget, &QTreeWidget::itemSelectionChanged, this, &ConfigurePluginsListWidget::slotItemSelectionChanged);
    connect(mListWidget, &QTreeWidget::itemChanged, this, &ConfigurePluginsListWidget::slotItemChanged);

mainLayout->addWidget(mListWidget);
}

ConfigurePluginsListWidget::~ConfigurePluginsListWidget()
{
}

void ConfigurePluginsListWidget::slotItemChanged(QTreeWidgetItem *item, int column)
{
    Q_UNUSED(item);
    if (column == 0) {
        Q_EMIT changed();
    }
}

void ConfigurePluginsListWidget::slotItemSelectionChanged()
{
    QTreeWidgetItem *item = mListWidget->currentItem();
    if (PluginItem *pluginItem = dynamic_cast<PluginItem *>(item)) {
        Q_EMIT descriptionChanged(pluginItem->mDescription);
    }
}

void ConfigurePluginsListWidget::save()
{
}

void ConfigurePluginsListWidget::doLoadFromGlobalSettings()
{
    initialize();
}

void ConfigurePluginsListWidget::doResetToDefaultsOther()
{
}

void ConfigurePluginsListWidget::defaults()
{
}

void ConfigurePluginsListWidget::initialize()
{
}

void ConfigurePluginsListWidget::savePlugins(const QString &groupName, const QString &prefixSettingKey, const QList<PluginItem *> &listItems)
{
    if (listItems.isEmpty()) {
        return;
    }
    QStringList enabledPlugins;
    QStringList disabledPlugins;
    for (PluginItem *item : listItems) {
        if (item->checkState(0) == Qt::Checked) {
            enabledPlugins << item->mIdentifier;
        } else {
            disabledPlugins << item->mIdentifier;
        }
    }
    PimCommon::PluginUtil::savePluginSettings(groupName,
                                              prefixSettingKey,
                                              enabledPlugins, disabledPlugins);
}

void ConfigurePluginsListWidget::fillTopItems(const QVector<PimCommon::PluginUtilData> &lst, const QString &topLevelItemName, const QString &groupName, const QString &prefixKey,
                                              QList<PluginItem *> &itemsList, const QString &configureGroupName, bool checkable)
{
    itemsList.clear();
    if (!lst.isEmpty()) {
        QTreeWidgetItem *topLevel = new QTreeWidgetItem(mListWidget, QStringList() << topLevelItemName);
        topLevel->setFlags(topLevel->flags() & ~Qt::ItemIsSelectable);
        const QPair<QStringList, QStringList> pair = PimCommon::PluginUtil::loadPluginSetting(groupName, prefixKey);
        for (const PimCommon::PluginUtilData &data : lst) {
            PluginItem *subItem = new PluginItem(topLevel);
            subItem->setText(0, data.mName);
            subItem->mIdentifier = data.mIdentifier;
            subItem->mDescription = data.mDescription;
            subItem->mEnableByDefault = data.mEnableByDefault;
            subItem->mHasConfigureSupport = data.mHasConfigureDialog;
            if (checkable) {
                const bool isPluginActivated = PimCommon::PluginUtil::isPluginActivated(pair.first, pair.second, data.mEnableByDefault, data.mIdentifier);
                subItem->mEnableFromUserSettings = isPluginActivated;
                subItem->setCheckState(0, isPluginActivated ? Qt::Checked : Qt::Unchecked);
            }
            if (data.mHasConfigureDialog) {
                QToolButton *but = new QToolButton(mListWidget);
                QAction *act = new QAction(but);
                const QStringList actData {
                    configureGroupName, data.mIdentifier
                };
                act->setData(actData);
                but->setDefaultAction(act);
                but->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
                but->setText(i18n("..."));
                but->setFixedWidth(28);
                but->setToolTip(i18n("Configure"));
                but->setAutoFillBackground(true);
                but->setEnabled(subItem->mHasConfigureSupport);
                mListWidget->setItemWidget(subItem, 1, but);
                connect(but, &QToolButton::triggered, this, &ConfigurePluginsListWidget::slotConfigureClicked);
            }
            itemsList.append(subItem);
        }
    }
}

void ConfigurePluginsListWidget::slotConfigureClicked(QAction *act)
{
    if (act) {
        const QStringList lst = act->data().toStringList();
        if (lst.count() == 2) {
            Q_EMIT configureClicked(lst.at(0), lst.at(1));
        }
    }
}

void ConfigurePluginsListWidget::changeState(const QList<PluginItem *> &items)
{
    for (PluginItem *item : items) {
        item->setCheckState(0, item->mEnableByDefault ? Qt::Checked : Qt::Unchecked);
    }
}

void ConfigurePluginsListWidget::resetToUserSettings(const QList<PluginItem *> &items)
{
    for (PluginItem *item : items) {
        item->setCheckState(0, item->mEnableFromUserSettings ? Qt::Checked : Qt::Unchecked);
    }
}
0707010000004A000081A40000000200000002000000015CDAA39400000AE9000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/configurepluginslistwidget.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CONFIGUREPLUGINSLISTWIDGET_H
#define CONFIGUREPLUGINSLISTWIDGET_H

#include <QWidget>
#include "pimcommon_export.h"
#include <PimCommon/PluginUtil>

#include <QTreeWidgetItem>
class QTreeWidget;
class QAction;
namespace PimCommon {
class PIMCOMMON_EXPORT ConfigurePluginsListWidget : public QWidget
{
    Q_OBJECT
public:
    explicit ConfigurePluginsListWidget(QWidget *parent = nullptr);
    ~ConfigurePluginsListWidget();

virtual void save();
    virtual void doLoadFromGlobalSettings();
    virtual void doResetToDefaultsOther();
    virtual void defaults();
    virtual void initialize();
Q_SIGNALS:
    void descriptionChanged(const QString &description);
    void changed();
    void configureClicked(const QString &configureGroupName, const QString &identifier);

private:
    void slotItemSelectionChanged();
    void slotItemChanged(QTreeWidgetItem *item, int column);

protected:
    class PluginItem : public QTreeWidgetItem
    {
    public:
        PluginItem(QTreeWidgetItem *parent)
            : QTreeWidgetItem(parent)
            , mEnableByDefault(false)
            , mHasConfigureSupport(false)
            , mEnableFromUserSettings(false)
        {
        }

QString mIdentifier;
        QString mDescription;
        bool mEnableByDefault;
        bool mHasConfigureSupport;
        bool mEnableFromUserSettings;
    };
    void savePlugins(const QString &groupName, const QString &prefixSettingKey, const QList<PluginItem *> &listItems);
    void fillTopItems(const QVector<PimCommon::PluginUtilData> &lst, const QString &topLevelItemName, const QString &groupName, const QString &prefixKey, QList<PluginItem *> &itemsList,
                      const QString &configureGroupName = QString(), bool checkable = true);
    void resetToUserSettings(const QList<PluginItem *> &items);
    void changeState(const QList<PluginItem *> &items);

QTreeWidget *mListWidget = nullptr;
private:
    void slotConfigureClicked(QAction *act);
};
}

#endif // CONFIGUREPLUGINSLISTWIDGET_H
0707010000004B000081A40000000200000002000000015CDAA39400000E91000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/configurepluginswidget.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "configurepluginswidget.h"
#include "configurepluginslistwidget.h"

#include <KConfigGroup>
#include <KLocalizedString>
#include <KMessageWidget>
#include <KSharedConfig>

#include <QSplitter>
#include <QTextEdit>
#include <QVBoxLayout>

using namespace PimCommon;

ConfigurePluginsWidget::ConfigurePluginsWidget(QWidget *parent)
    : QWidget(parent)
{
    initLayout();
}

ConfigurePluginsWidget::ConfigurePluginsWidget(ConfigurePluginsListWidget *configurePluginListWidget, QWidget *parent)
    : QWidget(parent)
{
    initLayout(configurePluginListWidget);
}

ConfigurePluginsWidget::~ConfigurePluginsWidget()
{
    writeConfig();
}

void ConfigurePluginsWidget::initLayout(ConfigurePluginsListWidget *configurePluginListWidget)
{
    QVBoxLayout *layout = new QVBoxLayout(this);
    layout->setContentsMargins(0, 0, 0, 0);

KMessageWidget *messageWidget = new KMessageWidget(this);
    messageWidget->setObjectName(QStringLiteral("messagewidget"));
    messageWidget->setText(i18n("Restart is necessary for applying the changes."));
    messageWidget->setCloseButtonVisible(false);
    layout->addWidget(messageWidget);

mSplitter = new QSplitter(this);
    mSplitter->setObjectName(QStringLiteral("splitter"));
    mSplitter->setChildrenCollapsible(false);
    layout->addWidget(mSplitter);

if (!configurePluginListWidget) {
        mConfigureListWidget = new ConfigurePluginsListWidget(this);
    } else {
        mConfigureListWidget = configurePluginListWidget;
    }
    mConfigureListWidget->setObjectName(QStringLiteral("configureListWidget"));
    mSplitter->addWidget(mConfigureListWidget);

mDescription = new QTextEdit(this);
    mDescription->setObjectName(QStringLiteral("description"));
    mDescription->setReadOnly(true);

mSplitter->addWidget(mDescription);

connect(mConfigureListWidget, &ConfigurePluginsListWidget::descriptionChanged, mDescription, &QTextEdit::setText);
    connect(mConfigureListWidget, &ConfigurePluginsListWidget::changed, this, &ConfigurePluginsWidget::changed);

initialize();
    readConfig();
}

void ConfigurePluginsWidget::save()
{
    mConfigureListWidget->save();
}

void ConfigurePluginsWidget::defaults()
{
    mConfigureListWidget->defaults();
}

void ConfigurePluginsWidget::doLoadFromGlobalSettings()
{
    mConfigureListWidget->doLoadFromGlobalSettings();
}

void ConfigurePluginsWidget::doResetToDefaultsOther()
{
    mConfigureListWidget->doResetToDefaultsOther();
}

void ConfigurePluginsWidget::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "ConfigurePluginsWidget");
    const QList<int> size = {400, 100};
    mSplitter->setSizes(group.readEntry("splitter", size));
}

void ConfigurePluginsWidget::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "ConfigurePluginsWidget");
    group.writeEntry("splitter", mSplitter->sizes());
}

void ConfigurePluginsWidget::initialize()
{
    mConfigureListWidget->initialize();
}
0707010000004C000081A40000000200000002000000015CDAA394000006E4000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/configureplugins/configurepluginswidget.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CONFIGUREPLUGINSWIDGET_H
#define CONFIGUREPLUGINSWIDGET_H

#include <QWidget>
#include "pimcommon_export.h"
class QSplitter;
class QTextEdit;
namespace PimCommon {
class ConfigurePluginsListWidget;
class PIMCOMMON_EXPORT ConfigurePluginsWidget : public QWidget
{
    Q_OBJECT
public:
    explicit ConfigurePluginsWidget(QWidget *parent = nullptr);
    explicit ConfigurePluginsWidget(ConfigurePluginsListWidget *configurePluginListWidget, QWidget *parent = nullptr);
    ~ConfigurePluginsWidget();

void save();
    void defaults();
    void doLoadFromGlobalSettings();
    void doResetToDefaultsOther();

Q_SIGNALS:
    void changed();

private:
    void initialize();
    void readConfig();
    void writeConfig();
    void initLayout(ConfigurePluginsListWidget *configurePluginListWidget = nullptr);

QSplitter *mSplitter = nullptr;
    ConfigurePluginsListWidget *mConfigureListWidget = nullptr;
    QTextEdit *mDescription = nullptr;
};
}
#endif // CONFIGUREPLUGINSWIDGET_H
0707010000004D000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools0707010000004E000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/autotests0707010000004F000081A40000000200000002000000015CDAA394000000AE000000000000000000000000000000000000006000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/autotests/CMakeLists.txtecm_add_test(customtoolswidgetngtest.cpp
    TEST_NAME customtoolswidgetngtest
    NAME_PREFIX pimcommon-
    LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::PimCommon KF5::XmlGui
)

07070100000050000081A40000000200000002000000015CDAA3940000055C000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/autotests/customtoolswidgetngtest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "customtoolswidgetngtest.h"
#include "customtools/customtoolswidgetng.h"
#include <QStackedWidget>
#include <QTest>
#include <QStandardPaths>
#include <KActionCollection>

CustomToolsWidgetNgTest::CustomToolsWidgetNgTest(QObject *parent)
    : QObject(parent)
{
    QStandardPaths::setTestModeEnabled(true);
}

CustomToolsWidgetNgTest::~CustomToolsWidgetNgTest()
{
}

void CustomToolsWidgetNgTest::shouldHaveDefaultValue()
{
    PimCommon::CustomToolsWidgetNg widget;
    widget.show();

QStackedWidget *stackWidget = widget.findChild<QStackedWidget *>(QStringLiteral("stackedwidget"));
    QVERIFY(stackWidget);
}

QTEST_MAIN(CustomToolsWidgetNgTest)
07070100000051000081A40000000200000002000000015CDAA39400000420000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/autotests/customtoolswidgetngtest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CUSTOMTOOLSWIDGETNGTEST_H
#define CUSTOMTOOLSWIDGETNGTEST_H

#include <QObject>

class CustomToolsWidgetNgTest : public QObject
{
    Q_OBJECT
public:
    explicit CustomToolsWidgetNgTest(QObject *parent = nullptr);
    ~CustomToolsWidgetNgTest();

private Q_SLOTS:
    void shouldHaveDefaultValue();
};

#endif // CUSTOMTOOLSWIDGETNGTEST_H
07070100000052000081A40000000200000002000000015CDAA394000005F4000000000000000000000000000000000000005D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolsplugin.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "customtoolsplugin.h"

using namespace PimCommon;

class PimCommon::CustomToolsPluginPrivate
{
public:
    CustomToolsPluginPrivate()
    {
    }
    bool enabled = false;
};

CustomToolsPlugin::CustomToolsPlugin(QObject *parent)
    : QObject(parent)
    , d(new PimCommon::CustomToolsPluginPrivate)
{
}

CustomToolsPlugin::~CustomToolsPlugin()
{
    delete d;
}

bool CustomToolsPlugin::hasConfigureDialog() const
{
    return false;
}

void CustomToolsPlugin::showConfigureDialog(QWidget *parent)
{
    Q_UNUSED(parent);
}

QString CustomToolsPlugin::description() const
{
    return {};
}

void CustomToolsPlugin::setIsEnabled(bool enabled)
{
    d->enabled = enabled;
}

bool CustomToolsPlugin::isEnabled() const
{
    return d->enabled;
}
07070100000053000081A40000000200000002000000015CDAA394000006D7000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolsplugin.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CUSTOMTOOLSPLUGIN_H
#define CUSTOMTOOLSPLUGIN_H

#include "pimcommon_export.h"
#include <QObject>
class KActionCollection;
namespace PimCommon {
class CustomToolsWidgetNg;
class CustomToolsViewInterface;
class CustomToolsPluginPrivate;
class PIMCOMMON_EXPORT CustomToolsPlugin : public QObject
{
    Q_OBJECT
public:
    explicit CustomToolsPlugin(QObject *parent = nullptr);
    ~CustomToolsPlugin();

virtual PimCommon::CustomToolsViewInterface *createView(KActionCollection *ac, CustomToolsWidgetNg *parent = nullptr) = 0;
    Q_REQUIRED_RESULT virtual QString customToolName() const = 0;

Q_REQUIRED_RESULT virtual bool hasConfigureDialog() const;
    virtual void showConfigureDialog(QWidget *parent);

void emitConfigChanged();

Q_REQUIRED_RESULT virtual QString description() const;

void setIsEnabled(bool enabled);
    Q_REQUIRED_RESULT bool isEnabled() const;

private:
    CustomToolsPluginPrivate *const d;
};
}
#endif // CUSTOMTOOLSPLUGIN_H
07070100000054000081A40000000200000002000000015CDAA39400001089000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolspluginmanager.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "customtoolspluginmanager.h"
#include "customtoolsplugin.h"

#include <KPluginFactory>
#include <KPluginLoader>
#include <KPluginMetaData>

#include <QDebug>
#include <QFileInfo>
#include <QSet>

using namespace PimCommon;

class CustomToolsPluginInfo
{
public:
    CustomToolsPluginInfo()
        : plugin(nullptr)
    {
    }

QString saveName() const;

KPluginMetaData metaData;
    PimCommon::CustomToolsPlugin *plugin = nullptr;
};

QString CustomToolsPluginInfo::saveName() const
{
    return QFileInfo(metaData.fileName()).baseName();
}

namespace {
QString pluginVersion()
{
    return QStringLiteral("1.0");
}
}

class PimCommon::CustomToolsPluginManagerPrivate
{
public:
    CustomToolsPluginManagerPrivate(CustomToolsPluginManager *qq)
        : q(qq)
    {
    }

QVector<PimCommon::CustomToolsPlugin *> pluginsList() const;
    void initializePluginList();
    void loadPlugin(CustomToolsPluginInfo *item);
    QVector<CustomToolsPluginInfo> mPluginList;
    CustomToolsPluginManager *q;
};

void CustomToolsPluginManagerPrivate::initializePluginList()
{
    const QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(QStringLiteral("pimcommon"), [](const KPluginMetaData &md) {
        return md.serviceTypes().contains(QLatin1String("PimCommonCustomTools/Plugin"));
    });

QVectorIterator<KPluginMetaData> i(plugins);
    i.toBack();
    QSet<QString> unique;
    while (i.hasPrevious()) {
        CustomToolsPluginInfo info;
        info.metaData = i.previous();
        if (info.metaData.version() == pluginVersion()) {
            // only load plugins once, even if found multiple times!
            if (unique.contains(info.saveName())) {
                continue;
            }
            info.plugin = nullptr;
            mPluginList.push_back(info);
            unique.insert(info.saveName());
        } else {
            qWarning() << "Plugin " << info.metaData.name() << " doesn't have correction plugin version. It will not be loaded.";
        }
    }
    QVector<CustomToolsPluginInfo>::iterator end(mPluginList.end());
    for (QVector<CustomToolsPluginInfo>::iterator it = mPluginList.begin(); it != end; ++it) {
        loadPlugin(&(*it));
    }
}

QVector<PimCommon::CustomToolsPlugin *> CustomToolsPluginManagerPrivate::pluginsList() const
{
    QVector<PimCommon::CustomToolsPlugin *> lst;
    QVector<CustomToolsPluginInfo>::ConstIterator end(mPluginList.constEnd());
    for (QVector<CustomToolsPluginInfo>::ConstIterator it = mPluginList.constBegin(); it != end; ++it) {
        if (auto plugin = (*it).plugin) {
            lst << plugin;
        }
    }
    return lst;
}

void CustomToolsPluginManagerPrivate::loadPlugin(CustomToolsPluginInfo *item)
{
    KPluginLoader pluginLoader(item->metaData.fileName());
    if (pluginLoader.factory()) {
        item->plugin = pluginLoader.factory()->create<PimCommon::CustomToolsPlugin>(q, QVariantList() << item->saveName());
    }
}

CustomToolsPluginManager *CustomToolsPluginManager::self()
{
    static CustomToolsPluginManager s_self;
    return &s_self;
}

CustomToolsPluginManager::CustomToolsPluginManager(QObject *parent)
    : QObject(parent)
    , d(new PimCommon::CustomToolsPluginManagerPrivate(this))
{
    d->initializePluginList();
}

CustomToolsPluginManager::~CustomToolsPluginManager()
{
    delete d;
}

QVector<PimCommon::CustomToolsPlugin *> CustomToolsPluginManager::pluginsList() const
{
    return d->pluginsList();
}
07070100000055000081A40000000200000002000000015CDAA3940000056D000000000000000000000000000000000000006200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolspluginmanager.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CUSTOMTOOLSPLUGINMANAGER_H
#define CUSTOMTOOLSPLUGINMANAGER_H

#include <QObject>
#include "pimcommon_export.h"
namespace PimCommon {
class CustomToolsPlugin;
class CustomToolsPluginManagerPrivate;
class PIMCOMMON_EXPORT CustomToolsPluginManager : public QObject
{
    Q_OBJECT
public:
    static CustomToolsPluginManager *self();

explicit CustomToolsPluginManager(QObject *parent = nullptr);
    ~CustomToolsPluginManager();

Q_REQUIRED_RESULT QVector<PimCommon::CustomToolsPlugin *> pluginsList() const;
private:
    CustomToolsPluginManagerPrivate *const d;
};
}
#endif // CUSTOMTOOLSPLUGINMANAGER_H
07070100000056000081A40000000200000002000000015CDAA39400000469000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolsviewinterface.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "customtoolsviewinterface.h"
using namespace PimCommon;
CustomToolsViewInterface::CustomToolsViewInterface(QWidget *parent)
    : QWidget(parent)
{
}

CustomToolsViewInterface::~CustomToolsViewInterface()
{
}

void CustomToolsViewInterface::setText(const QString &)
{
}

KToggleAction *CustomToolsViewInterface::action() const
{
    return nullptr;
}
07070100000057000081A40000000200000002000000015CDAA39400000561000000000000000000000000000000000000006200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolsviewinterface.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CUSTOMTOOLSVIEWINTERFACE_H
#define CUSTOMTOOLSVIEWINTERFACE_H

#include "pimcommon_export.h"

#include <QWidget>
class KToggleAction;
namespace PimCommon {
class PIMCOMMON_EXPORT CustomToolsViewInterface : public QWidget
{
    Q_OBJECT
public:
    explicit CustomToolsViewInterface(QWidget *parent = nullptr);
    ~CustomToolsViewInterface() override;

virtual void setText(const QString &text);
    virtual KToggleAction *action() const;

Q_SIGNALS:
    void insertText(const QString &text);
    void toolsWasClosed();
    void activateView(QWidget *);
};
}
#endif // CUSTOMTOOLSVIEWINTERFACE_H
07070100000058000081A40000000200000002000000015CDAA39400000DED000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolswidgetng.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "customtoolswidgetng.h"
#include "customtoolsplugin.h"
#include "customtoolspluginmanager.h"
#include "customtoolsviewinterface.h"

#include <KToggleAction>

#include <QHBoxLayout>
#include <QStackedWidget>

using namespace PimCommon;

class PimCommon::CustomToolsWidgetNgPrivate
{
public:
    CustomToolsWidgetNgPrivate()
    {
    }

QStackedWidget *mStackedWidget = nullptr;
    QList<PimCommon::CustomToolsViewInterface *> mListInterfaceView;
};

CustomToolsWidgetNg::CustomToolsWidgetNg(QWidget *parent)
    : QWidget(parent)
    , d(new PimCommon::CustomToolsWidgetNgPrivate)
{
    QHBoxLayout *lay = new QHBoxLayout(this);
    d->mStackedWidget = new QStackedWidget;
    d->mStackedWidget->setObjectName(QStringLiteral("stackedwidget"));
    lay->addWidget(d->mStackedWidget);
    hide();
}

CustomToolsWidgetNg::~CustomToolsWidgetNg()
{
    delete d;
}

void CustomToolsWidgetNg::addCustomToolViewInterface(PimCommon::CustomToolsViewInterface *plugin)
{
    d->mListInterfaceView.append(plugin);
    d->mStackedWidget->addWidget(plugin);
}

void CustomToolsWidgetNg::initializeView(KActionCollection *ac, const QVector<CustomToolsPlugin *> &localPluginsList)
{
    for (CustomToolsPlugin *plugin : localPluginsList) {
        PimCommon::CustomToolsViewInterface *localCreateView = plugin->createView(ac, this);
        d->mListInterfaceView.append(localCreateView);
        d->mStackedWidget->addWidget(localCreateView);
    }
}

void CustomToolsWidgetNg::slotToolsWasClosed()
{
    for (PimCommon::CustomToolsViewInterface *interface : qAsConst(d->mListInterfaceView)) {
        interface->action()->setChecked(false);
    }
    hide();
}

void CustomToolsWidgetNg::slotActivateView(QWidget *w)
{
    if (w) {
        d->mStackedWidget->setCurrentWidget(w);
        setVisible(true);
        for (PimCommon::CustomToolsViewInterface *interface : qAsConst(d->mListInterfaceView)) {
            if (interface != w) {
                interface->action()->setChecked(false);
            }
        }
        Q_EMIT toolActivated();
    } else {
        setVisible(false);
        slotToolsWasClosed();
    }
}

QList<KToggleAction *> CustomToolsWidgetNg::actionList() const
{
    QList<KToggleAction *> lstActions;
    lstActions.reserve(d->mListInterfaceView.count());
    for (PimCommon::CustomToolsViewInterface *interface : qAsConst(d->mListInterfaceView)) {
        lstActions << interface->action();
    }
    return lstActions;
}

void CustomToolsWidgetNg::setText(const QString &text)
{
    if (isVisible()) {
        for (PimCommon::CustomToolsViewInterface *interface : qAsConst(d->mListInterfaceView)) {
            if (interface == d->mStackedWidget->currentWidget()) {
                interface->setText(text);
                break;
            }
        }
    }
}
07070100000059000081A40000000200000002000000015CDAA394000006DB000000000000000000000000000000000000005D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/customtools/customtoolswidgetng.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CUSTOMTOOLSWIDGETNG_H
#define CUSTOMTOOLSWIDGETNG_H

#include <QWidget>
#include "pimcommon_export.h"
class KToggleAction;
class KActionCollection;
namespace PimCommon {
class CustomToolsWidgetNgPrivate;
class CustomToolsPlugin;
class CustomToolsViewInterface;
class PIMCOMMON_EXPORT CustomToolsWidgetNg : public QWidget
{
    Q_OBJECT
public:
    explicit CustomToolsWidgetNg(QWidget *parent = nullptr);
    ~CustomToolsWidgetNg();

Q_REQUIRED_RESULT QList<KToggleAction *> actionList() const;
    void initializeView(KActionCollection *ac, const QVector<CustomToolsPlugin *> &localPluginsList);

void setText(const QString &text);

void addCustomToolViewInterface(PimCommon::CustomToolsViewInterface *plugin);

public Q_SLOTS:
    void slotToolsWasClosed();
    void slotActivateView(QWidget *w);

Q_SIGNALS:
    void insertText(const QString &url);
    void toolActivated();

private:
    CustomToolsWidgetNgPrivate *const d;
};
}
#endif // CUSTOMTOOLSWIDGETNG_H
0707010000005A000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/designer0707010000005B000081A40000000200000002000000015CDAA39400000292000000000000000000000000000000000000005300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/designer/CMakeLists.txtif (KF5DesignerPlugin_FOUND)
    kf5designerplugin_add_plugin(pimcommonwidgets pimcommon.widgets)
    target_link_libraries(pimcommonwidgets
        KF5::PimCommon KF5::PimTextEdit
    )
    if(NOT WIN32)
        # Since there are no libraries provided by this module,
        # there is no point including the build tree in RPath,
        # and then having to edit it at install time.
        set_target_properties(pimcommonwidgets PROPERTIES
            SKIP_BUILD_RPATH TRUE
            BUILD_WITH_INSTALL_RPATH TRUE
        )
    endif()

install(TARGETS
        pimcommonwidgets
        DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/designer
    )
endif()
0707010000005C000081A40000000200000002000000015CDAA394000001C2000000000000000000000000000000000000005600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/designer/pimcommon.widgets[Global]
PluginName=PimCommonWidgets

[PimCommon::SimpleStringListEditor]
ToolTip=A listbox with add/remove/move up/down button (KDE-PIM)
WhatsThis=A listbox which lets organize list order.
IncludeFile=pimcommon/simplestringlisteditor.h
Group=Input (KDE-PIM)

[PimCommon::TranslatorWidget]
ToolTip=A widget to make translate string (KDE-PIM)
WhatsThis=A widget to make translate string
IncludeFile=pimcommon/translatorwidget.h
Group=Input (KDE-PIM)

0707010000005D000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins0707010000005E000081A40000000200000002000000015CDAA39400000630000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/abstractgenericplugin.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "abstractgenericplugin.h"

using namespace PimCommon;

AbstractGenericPlugin::AbstractGenericPlugin(QObject *parent)
    : QObject(parent)
    , mIsEnabled(true)
{
}

AbstractGenericPlugin::~AbstractGenericPlugin()
{
}

bool AbstractGenericPlugin::hasPopupMenuSupport() const
{
    return false;
}

bool AbstractGenericPlugin::hasToolBarSupport() const
{
    return false;
}

bool AbstractGenericPlugin::hasConfigureDialog() const
{
    return false;
}

bool AbstractGenericPlugin::hasStatusBarSupport() const
{
    return false;
}

void AbstractGenericPlugin::showConfigureDialog(QWidget *parent)
{
    Q_UNUSED(parent);
    //Reimplement it.
}

void AbstractGenericPlugin::setIsEnabled(bool enabled)
{
    mIsEnabled = enabled;
}

bool AbstractGenericPlugin::isEnabled() const
{
    return mIsEnabled;
}
0707010000005F000081A40000000200000002000000015CDAA394000006BB000000000000000000000000000000000000006200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/abstractgenericplugin.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AbstractGENERICPLUGIN_H
#define AbstractGENERICPLUGIN_H

#include <QObject>
#include "pimcommon_export.h"
class KActionCollection;
namespace PimCommon {
class AbstractGenericPluginInterface;
class PIMCOMMON_EXPORT AbstractGenericPlugin : public QObject
{
    Q_OBJECT
public:
    explicit AbstractGenericPlugin(QObject *parent = nullptr);
    ~AbstractGenericPlugin();

virtual PimCommon::AbstractGenericPluginInterface *createInterface(QObject *parent = nullptr) = 0;
    Q_REQUIRED_RESULT virtual bool hasPopupMenuSupport() const;
    Q_REQUIRED_RESULT virtual bool hasToolBarSupport() const;
    Q_REQUIRED_RESULT virtual bool hasConfigureDialog() const;
    Q_REQUIRED_RESULT virtual bool hasStatusBarSupport() const;

virtual void showConfigureDialog(QWidget *parent = nullptr);

void setIsEnabled(bool enabled);
    Q_REQUIRED_RESULT bool isEnabled() const;

private:
    bool mIsEnabled;
};
}
#endif // AbstractGENERICPLUGIN_H
07070100000060000081A40000000200000002000000015CDAA39400000711000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/abstractgenericplugininterface.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "abstractgenericplugininterface.h"

using namespace PimCommon;

class PimCommon::AbstractGenericPluginInterfacePrivate
{
public:
    AbstractGenericPluginInterfacePrivate()
    {
    }

AbstractGenericPlugin *plugin = nullptr;
    QWidget *parentWidget = nullptr;
};

AbstractGenericPluginInterface::AbstractGenericPluginInterface(QObject *parent)
    : QObject(parent)
    , d(new AbstractGenericPluginInterfacePrivate)
{
}

AbstractGenericPluginInterface::~AbstractGenericPluginInterface()
{
    delete d;
}

void AbstractGenericPluginInterface::setParentWidget(QWidget *parent)
{
    d->parentWidget = parent;
}

QWidget *AbstractGenericPluginInterface::parentWidget() const
{
    return d->parentWidget;
}

void AbstractGenericPluginInterface::setPlugin(AbstractGenericPlugin *plugin)
{
    d->plugin = plugin;
}

AbstractGenericPlugin *AbstractGenericPluginInterface::plugin() const
{
    return d->plugin;
}

void AbstractGenericPluginInterface::showConfigureDialog(QWidget *parentWidget)
{
    Q_UNUSED(parentWidget);
}
07070100000061000081A40000000200000002000000015CDAA3940000091E000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/abstractgenericplugininterface.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef AbstractGENERICPLUGININTERFACE_H
#define AbstractGENERICPLUGININTERFACE_H
#include <QObject>
#include "pimcommon_export.h"
class QAction;
class KActionCollection;
namespace PimCommon {
class AbstractGenericPlugin;
class GenericPlugin;
class PIMCOMMON_EXPORT ActionType
{
public:
    enum Type {
        Tools = 0,
        Edit = 1,
        File = 2,
        Action = 3,
        PopupMenu = 4,
        ToolBar = 5,
        Message = 6,
        Folder = 7
    };
    ActionType()
    {
    }

ActionType(QAction *action, Type type);
    Q_REQUIRED_RESULT QAction *action() const;
    Q_REQUIRED_RESULT Type type() const;

private:
    QAction *mAction = nullptr;
    Type mType = Tools;
};

class AbstractGenericPluginInterfacePrivate;
class PIMCOMMON_EXPORT AbstractGenericPluginInterface : public QObject
{
    Q_OBJECT
public:
    explicit AbstractGenericPluginInterface(QObject *parent = nullptr);
    ~AbstractGenericPluginInterface();

void setParentWidget(QWidget *parent);
    Q_REQUIRED_RESULT QWidget *parentWidget() const;

void setPlugin(AbstractGenericPlugin *plugin);
    Q_REQUIRED_RESULT AbstractGenericPlugin *plugin() const;

virtual void createAction(KActionCollection *ac) = 0;
    virtual void exec() = 0;

virtual void showConfigureDialog(QWidget *parentWidget = nullptr);

Q_SIGNALS:
    void emitPluginActivated(PimCommon::AbstractGenericPluginInterface *interface);
    void message(const QString &str);

private:
    AbstractGenericPluginInterfacePrivate *const d;
};
}
#endif // AbstractGENERICPLUGININTERFACE_H
07070100000062000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests07070100000063000081A40000000200000002000000015CDAA39400000191000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests/CMakeLists.txtecm_add_test(genericpluginmanagertest.cpp
    NAME_PREFIX "pimcommon-genericplugins-"
    LINK_LIBRARIES Qt5::Test KF5::PimCommonAkonadi
)

ecm_add_test(actiontypetest.cpp
    NAME_PREFIX "pimcommon-genericplugins-"
    LINK_LIBRARIES Qt5::Test KF5::PimCommonAkonadi
)

ecm_add_test(pluginutiltest.cpp
    NAME_PREFIX "pimcommon-genericplugins-"
    LINK_LIBRARIES Qt5::Test KF5::PimCommonAkonadi
)

07070100000064000081A40000000200000002000000015CDAA3940000059A000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests/actiontypetest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "actiontypetest.h"
#include <PimCommonAkonadi/GenericPluginInterface>
#include <QAction>
#include <QTest>

ActionTypeTest::ActionTypeTest(QObject *parent)
    : QObject(parent)
{
}

ActionTypeTest::~ActionTypeTest()
{
}

void ActionTypeTest::shouldHaveDefaultValue()
{
    PimCommon::ActionType actionType;
    QVERIFY(!actionType.action());
    QCOMPARE(actionType.type(), PimCommon::ActionType::Tools);
}

void ActionTypeTest::shouldAssignValue()
{
    QAction *act = new QAction(nullptr);
    PimCommon::ActionType::Type type = PimCommon::ActionType::File;
    PimCommon::ActionType actionType(act, type);
    QCOMPARE(actionType.action(), act);
    QCOMPARE(actionType.type(), type);
}

QTEST_MAIN(ActionTypeTest)
07070100000065000081A40000000200000002000000015CDAA39400000407000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests/actiontypetest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef ACTIONTYPETEST_H
#define ACTIONTYPETEST_H

#include <QObject>

class ActionTypeTest : public QObject
{
    Q_OBJECT
public:
    explicit ActionTypeTest(QObject *parent = nullptr);
    ~ActionTypeTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldAssignValue();
};

#endif // ACTIONTYPETEST_H
07070100000066000081A40000000200000002000000015CDAA394000005F2000000000000000000000000000000000000007100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests/genericpluginmanagertest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "genericpluginmanagertest.h"
#include "../genericpluginmanager.h"
#include <QTest>

GenericPluginManagerTest::GenericPluginManagerTest(QObject *parent)
    : QObject(parent)
{
}

GenericPluginManagerTest::~GenericPluginManagerTest()
{
}

void GenericPluginManagerTest::shouldHaveDefaultValue()
{
    PimCommon::GenericPluginManager pluginManager;
    QVERIFY(!pluginManager.initializePlugins());
}

void GenericPluginManagerTest::shouldInitialized()
{
    PimCommon::GenericPluginManager pluginManager;
    QVERIFY(!pluginManager.initializePlugins());
    pluginManager.setServiceTypeName(QStringLiteral("foo"));
    QVERIFY(!pluginManager.initializePlugins());
    pluginManager.setPluginName(QStringLiteral("foo"));
    QVERIFY(pluginManager.initializePlugins());
}

QTEST_MAIN(GenericPluginManagerTest)
07070100000067000081A40000000200000002000000015CDAA39400000443000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests/genericpluginmanagertest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef GENERICPLUGINMANAGERTEST_H
#define GENERICPLUGINMANAGERTEST_H

#include <QObject>

class GenericPluginManagerTest : public QObject
{
    Q_OBJECT
public:
    explicit GenericPluginManagerTest(QObject *parent = nullptr);
    ~GenericPluginManagerTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldInitialized();
};

#endif // GENERICPLUGINMANAGERTEST_H
07070100000068000081A40000000200000002000000015CDAA39400000A9E000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests/pluginutiltest.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "pluginutiltest.h"
#include <PimCommon/PluginUtil>
#include <QTest>

PluginUtilTest::PluginUtilTest(QObject *parent)
    : QObject(parent)
{
}

PluginUtilTest::~PluginUtilTest()
{
}

void PluginUtilTest::shouldTestIsEnabled_data()
{
    QTest::addColumn<QStringList>("enabledPluginsList");
    QTest::addColumn<QStringList>("disabledPluginsList");
    QTest::addColumn<bool>("isEnabledByDefault");
    QTest::addColumn<QString>("pluginId");
    QTest::addColumn<bool>("result");

//Use default value
    QTest::newRow("emptysettings") << QStringList() << QStringList() << true << QStringLiteral("foo") << true;
    QTest::newRow("emptysettings-2") << QStringList() << QStringList() << false << QStringLiteral("foo") << false;

//Return false each time that pluginid is empty
    QTest::newRow("pluginidempty") << QStringList() << QStringList() << true << QString() << false;
    QTest::newRow("pluginidempty-2") << QStringList() << QStringList() << false << QString() << false;

//Use setting from user settings
    QStringList disabled{
        QStringLiteral("foo")
    };
    QTest::newRow("usersettingdisabled") << QStringList() << disabled << true << QStringLiteral("foo") << false;
    QTest::newRow("usersettingdisabled-2") << QStringList() << disabled << false << QStringLiteral("foo") << false;

QStringList enabled{
        QStringLiteral("foo")
    };
    QTest::newRow("usersettingenabled") << enabled << QStringList() << true << QStringLiteral("foo") << true;
    QTest::newRow("usersettingenabled-2") << enabled << QStringList() << false << QStringLiteral("foo") << true;
}

void PluginUtilTest::shouldTestIsEnabled()
{
    QFETCH(QStringList, enabledPluginsList);
    QFETCH(QStringList, disabledPluginsList);
    QFETCH(bool, isEnabledByDefault);
    QFETCH(QString, pluginId);
    QFETCH(bool, result);

QCOMPARE(PimCommon::PluginUtil::isPluginActivated(enabledPluginsList, disabledPluginsList, isEnabledByDefault, pluginId), result);
}

QTEST_MAIN(PluginUtilTest)
07070100000069000081A40000000200000002000000015CDAA3940000040B000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/autotests/pluginutiltest.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef PluginUtilTest_H
#define PluginUtilTest_H

#include <QObject>

class PluginUtilTest : public QObject
{
    Q_OBJECT
public:
    explicit PluginUtilTest(QObject *parent = nullptr);
    ~PluginUtilTest();
private Q_SLOTS:
    void shouldTestIsEnabled_data();
    void shouldTestIsEnabled();
};

#endif // PluginUtilTest_H
0707010000006A000081A40000000200000002000000015CDAA394000003B4000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/genericplugin.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "genericplugin.h"

using namespace PimCommon;

GenericPlugin::GenericPlugin(QObject *parent)
    : AbstractGenericPlugin(parent)
{
}

GenericPlugin::~GenericPlugin()
{
}
0707010000006B000081A40000000200000002000000015CDAA39400000450000000000000000000000000000000000000005A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/genericplugin.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef GENERICPLUGIN_H
#define GENERICPLUGIN_H

#include "abstractgenericplugin.h"
#include "pimcommon_export.h"
namespace PimCommon {
class PIMCOMMON_EXPORT GenericPlugin : public AbstractGenericPlugin
{
    Q_OBJECT
public:
    explicit GenericPlugin(QObject *parent = nullptr);
    ~GenericPlugin();
};
}
#endif // GENERICPLUGIN_H
0707010000006C000081A40000000200000002000000015CDAA39400001A7C000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/genericpluginmanager.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "genericpluginmanager.h"
#include "genericplugin.h"
#include "pimcommon_debug.h"

#include <KPluginFactory>
#include <KPluginLoader>

#include <QFileInfo>

using namespace PimCommon;

class GenericPluginInfo
{
public:
    GenericPluginInfo()
    {
    }

QString metaDataFileNameBaseName;
    QString metaDataFileName;
    PimCommon::PluginUtilData pluginData;
    PimCommon::GenericPlugin *plugin = nullptr;
    bool isEnabled = true;
};

namespace {
QString pluginVersion()
{
    return QStringLiteral("1.0");
}
}

class PimCommon::GenericPluginManagerPrivate
{
public:
    GenericPluginManagerPrivate(GenericPluginManager *qq)
        : q(qq)
    {
    }

void loadPlugin(GenericPluginInfo *item);
    QVector<GenericPlugin *> pluginsList() const;
    bool initializePlugins();
    QString serviceTypeName;
    QString pluginName;
    QVector<GenericPluginInfo> mPluginList;

QVector<PluginUtilData> pluginsDataList() const;
    QString configGroupName() const;
    QString configPrefixSettingKey() const;
    GenericPlugin *pluginFromIdentifier(const QString &id);
private:
    QVector<PluginUtilData> mPluginDataList;
    GenericPluginManager *q;
};

QString GenericPluginManagerPrivate::configGroupName() const
{
    return QStringLiteral("GenericPlugin-%1").arg(pluginName);
}

QString GenericPluginManagerPrivate::configPrefixSettingKey() const
{
    return QStringLiteral("%1Plugin").arg(pluginName);
}

bool GenericPluginManagerPrivate::initializePlugins()
{
    if (!mPluginList.isEmpty()) {
        return true;
    }

if (serviceTypeName.isEmpty() || pluginName.isEmpty()) {
        return false;
    }
    const QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(pluginName, [this](const KPluginMetaData &md) {
        return md.serviceTypes().contains(serviceTypeName);
    });

const QPair<QStringList, QStringList> pair = PimCommon::PluginUtil::loadPluginSetting(configGroupName(), configPrefixSettingKey());
    QVectorIterator<KPluginMetaData> i(plugins);
    i.toBack();
    QSet<QString> unique;
    while (i.hasPrevious()) {
        GenericPluginInfo info;
        const KPluginMetaData data = i.previous();

//1) get plugin data => name/description etc.
        info.pluginData = PimCommon::PluginUtil::createPluginMetaData(data);
        //2) look at if plugin is activated
        const bool isPluginActivated = PimCommon::PluginUtil::isPluginActivated(pair.first, pair.second, info.pluginData.mEnableByDefault, info.pluginData.mIdentifier);
        info.isEnabled = isPluginActivated;
        info.metaDataFileNameBaseName = QFileInfo(data.fileName()).baseName();
        info.metaDataFileName = data.fileName();

if (pluginVersion() == data.version()) {
            // only load plugins once, even if found multiple times!
            if (unique.contains(info.metaDataFileNameBaseName)) {
                continue;
            }
            info.plugin = nullptr;
            mPluginList.push_back(info);
            unique.insert(info.metaDataFileNameBaseName);
        } else {
            qCWarning(PIMCOMMON_LOG) << "Plugin " << data.name() << " doesn't have correction plugin version. It will not be loaded.";
        }
    }
    QVector<GenericPluginInfo>::iterator end(mPluginList.end());
    for (QVector<GenericPluginInfo>::iterator it = mPluginList.begin(); it != end; ++it) {
        loadPlugin(&(*it));
    }
    return true;
}

QVector<PluginUtilData> GenericPluginManagerPrivate::pluginsDataList() const
{
    return mPluginDataList;
}

QVector<GenericPlugin *> GenericPluginManagerPrivate::pluginsList() const
{
    QVector<PimCommon::GenericPlugin *> lst;
    QVector<GenericPluginInfo>::ConstIterator end(mPluginList.constEnd());
    for (QVector<GenericPluginInfo>::ConstIterator it = mPluginList.constBegin(); it != end; ++it) {
        if (auto plugin = (*it).plugin) {
            lst << plugin;
        }
    }
    return lst;
}

void GenericPluginManagerPrivate::loadPlugin(GenericPluginInfo *item)
{
    KPluginLoader pluginLoader(item->metaDataFileName);
    if (pluginLoader.factory()) {
        item->plugin = pluginLoader.factory()->create<PimCommon::GenericPlugin>(q, QVariantList() << item->metaDataFileNameBaseName);
        item->plugin->setIsEnabled(item->isEnabled);
        item->pluginData.mHasConfigureDialog = item->plugin->hasConfigureDialog();
        mPluginDataList.append(item->pluginData);
    }
}

GenericPlugin *GenericPluginManagerPrivate::pluginFromIdentifier(const QString &id)
{
    QVector<GenericPluginInfo>::ConstIterator end(mPluginList.constEnd());
    for (QVector<GenericPluginInfo>::ConstIterator it = mPluginList.constBegin(); it != end; ++it) {
        if ((*it).pluginData.mIdentifier == id) {
            return (*it).plugin;
        }
    }
    return {};
}

GenericPluginManager::GenericPluginManager(QObject *parent)
    : QObject(parent)
    , d(new GenericPluginManagerPrivate(this))
{
}

GenericPluginManager::~GenericPluginManager()
{
    delete d;
}

bool GenericPluginManager::initializePlugins()
{
    return d->initializePlugins();
}

void GenericPluginManager::setServiceTypeName(const QString &serviceName)
{
    d->serviceTypeName = serviceName;
}

QString GenericPluginManager::serviceTypeName() const
{
    return d->serviceTypeName;
}

void GenericPluginManager::setPluginName(const QString &pluginName)
{
    d->pluginName = pluginName;
}

QString GenericPluginManager::pluginName() const
{
    return d->pluginName;
}

QVector<GenericPlugin *> GenericPluginManager::pluginsList() const
{
    return d->pluginsList();
}

QVector<PluginUtilData> GenericPluginManager::pluginsDataList() const
{
    return d->pluginsDataList();
}

QString GenericPluginManager::configGroupName() const
{
    return d->configGroupName();
}

QString GenericPluginManager::configPrefixSettingKey() const
{
    return d->configPrefixSettingKey();
}

GenericPlugin *GenericPluginManager::pluginFromIdentifier(const QString &id)
{
    return d->pluginFromIdentifier(id);
}
0707010000006D000081A40000000200000002000000015CDAA3940000086A000000000000000000000000000000000000006100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/genericpluginmanager.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef GENERICPLUGINMANAGER_H
#define GENERICPLUGINMANAGER_H

#include <QObject>
#include <QVector>
#include "pimcommon_export.h"
#include <PimCommon/PluginUtil>

namespace PimCommon {
class GenericPluginManagerPrivate;
class GenericPlugin;
class PIMCOMMON_EXPORT GenericPluginManager : public QObject
{
    Q_OBJECT
public:
    class GenericPluginData
    {
    public:
        GenericPluginData()
            : mEnableByDefault(false)
        {
        }

QString mDescription;
        QString mName;
        QString mIdentifier;
        bool mEnableByDefault;
    };

explicit GenericPluginManager(QObject *parent = nullptr);
    ~GenericPluginManager();

Q_REQUIRED_RESULT bool initializePlugins();

void setServiceTypeName(const QString &serviceName);
    Q_REQUIRED_RESULT QString serviceTypeName() const;

void setPluginName(const QString &pluginName);
    Q_REQUIRED_RESULT QString pluginName() const;

Q_REQUIRED_RESULT QVector<PimCommon::GenericPlugin *> pluginsList() const;
    Q_REQUIRED_RESULT QVector<PimCommon::PluginUtilData> pluginsDataList() const;

Q_REQUIRED_RESULT QString configGroupName() const;
    Q_REQUIRED_RESULT QString configPrefixSettingKey() const;

Q_REQUIRED_RESULT GenericPlugin *pluginFromIdentifier(const QString &id);

private:
    GenericPluginManagerPrivate *const d;
};
}

#endif // GENERICPLUGINMANAGER_H
0707010000006E000081A40000000200000002000000015CDAA39400000C06000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/pluginutil.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "pluginutil.h"
#include <KConfigGroup>
#include <KSharedConfig>

namespace {
inline QString pluginConfigFile()
{
    return QStringLiteral("pimpluginsrc");
}
}

bool PimCommon::PluginUtil::isPluginActivated(const QStringList &enabledPluginsList, const QStringList &disabledPluginsList, bool isEnabledByDefault, const QString &pluginId)
{
    if (pluginId.isEmpty()) {
        return false;
    }
    const bool pluginEnabledByUser = enabledPluginsList.contains(pluginId);
    const bool pluginDisabledByUser = disabledPluginsList.contains(pluginId);
    if ((isEnabledByDefault && !pluginDisabledByUser)
        || (!isEnabledByDefault && pluginEnabledByUser)) {
        return true;
    }
    return false;
}

QPair<QStringList, QStringList> PimCommon::PluginUtil::loadPluginSetting(const QString &groupName, const QString &prefixSettingKey)
{
    QPair<QStringList, QStringList> pair;
    KSharedConfigPtr config = KSharedConfig::openConfig(pluginConfigFile());
    QStringList enabledPlugins;
    QStringList disabledPlugins;
    if (config->hasGroup(groupName)) {
        KConfigGroup grp = config->group(groupName);
        enabledPlugins = grp.readEntry(QStringLiteral("%1Enabled").arg(prefixSettingKey), QStringList());
        disabledPlugins = grp.readEntry(QStringLiteral("%1Disabled").arg(prefixSettingKey), QStringList());
    }

pair.first = enabledPlugins;
    pair.second = disabledPlugins;
    return pair;
}

void PimCommon::PluginUtil::savePluginSettings(const QString &groupName, const QString &prefixSettingKey, const QStringList &enabledPluginsList, const QStringList &disabledPluginsList)
{
    KSharedConfigPtr config = KSharedConfig::openConfig(pluginConfigFile());
    KConfigGroup grp = config->group(groupName);
    grp.writeEntry(QStringLiteral("%1Enabled").arg(prefixSettingKey), enabledPluginsList);
    grp.writeEntry(QStringLiteral("%1Disabled").arg(prefixSettingKey), disabledPluginsList);
}

PimCommon::PluginUtilData PimCommon::PluginUtil::createPluginMetaData(const KPluginMetaData &metaData)
{
    PluginUtilData pluginData;
    pluginData.mDescription = metaData.description();
    pluginData.mName = metaData.name();
    pluginData.mIdentifier = metaData.pluginId();
    pluginData.mEnableByDefault = metaData.isEnabledByDefault();
    return pluginData;
}
0707010000006F000081A40000000200000002000000015CDAA3940000079A000000000000000000000000000000000000005700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/genericplugins/pluginutil.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef PLUGINUTIL_H
#define PLUGINUTIL_H

#include "pimcommon_export.h"

#include <QString>
#include <QStringList>
#include <QPair>
#include <kpluginmetadata.h>

namespace PimCommon {
class PIMCOMMON_EXPORT PluginUtilData
{
public:
    PluginUtilData()
        : mEnableByDefault(false)
        , mHasConfigureDialog(false)
    {
    }

QStringList mExtraInfo;
    QString mDescription;
    QString mIdentifier;
    QString mName;
    bool mEnableByDefault;
    bool mHasConfigureDialog;
};

namespace PluginUtil {
Q_REQUIRED_RESULT PIMCOMMON_EXPORT bool isPluginActivated(const QStringList &enabledPluginsList, const QStringList &disabledPluginsList, bool isEnabledByDefault, const QString &pluginId);
Q_REQUIRED_RESULT PIMCOMMON_EXPORT QPair<QStringList, QStringList> loadPluginSetting(const QString &groupName, const QString &prefixSettingKey);
PIMCOMMON_EXPORT void savePluginSettings(const QString &groupName, const QString &prefixSettingKey, const QStringList &enabledPluginsList, const QStringList &disabledPluginsList);
Q_REQUIRED_RESULT PIMCOMMON_EXPORT PimCommon::PluginUtilData createPluginMetaData(const KPluginMetaData &metaData);
}
}

#endif // PLUGINUTIL_H
07070100000070000041ED0000000200000002000000045CDAA39400000000000000000000000000000000000000000000004900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities07070100000071000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests07070100000072000081A40000000200000002000000015CDAA394000001BC000000000000000000000000000000000000006200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/CMakeLists.txtecm_add_test(logactivitiesmanagertest.cpp
    NAME_PREFIX "pimcommon-logactivities-"
    LINK_LIBRARIES Qt5::Test KF5::PimCommon KF5::PimTextEdit
)

ecm_add_test(logactivitieswidgettest.cpp
    NAME_PREFIX "pimcommon-logactivities-"
    LINK_LIBRARIES Qt5::Test KF5::PimCommon KF5::PimTextEdit
)

ecm_add_test(logactivitiesdialogtest.cpp
    NAME_PREFIX "pimcommon-logactivities-"
    LINK_LIBRARIES Qt5::Test KF5::PimCommon KF5::PimTextEdit
)
07070100000073000081A40000000200000002000000015CDAA394000004DE000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/kdepimtest_layout.h/*
   Copyright (C) 2019 Montel Laurent <montel@kde.org>

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.

#endif
07070100000074000081A40000000200000002000000015CDAA39400000E7A000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/logactivitiesdialogtest.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "logactivitiesdialogtest.h"
#include "../logactivitiesdialog.h"
#include "../logactivitieswidget.h"
#include "../logactivitiesmanager.h"
#include <QAbstractButton>
#include <QDialogButtonBox>
#include <QTest>
#include <QVBoxLayout>
#include <qtestmouse.h>
#include <QSignalSpy>
#include <QCheckBox>
#include <QStandardPaths>

LogActivitiesDialogTest::LogActivitiesDialogTest(QObject *parent)
    : QObject(parent)
{
    QStandardPaths::setTestModeEnabled(true);
}

LogActivitiesDialogTest::~LogActivitiesDialogTest()
{
}

void LogActivitiesDialogTest::shouldHaveDefaultValue()
{
    PimCommon::LogActivitiesDialog w;
    QVBoxLayout *mainLayout = w.findChild<QVBoxLayout *>(QStringLiteral("mainLayout"));
    QVERIFY(mainLayout);

PimCommon::LogActivitiesWidget *mLogWidget = w.findChild<PimCommon::LogActivitiesWidget *>(QStringLiteral("logwidget"));
    QVERIFY(mLogWidget);

QCheckBox *mEnableLogActivities = w.findChild<QCheckBox *>(QStringLiteral("enablelogactivities"));
    QVERIFY(mEnableLogActivities);
    QVERIFY(!mEnableLogActivities->text().isEmpty());
    QVERIFY(!mEnableLogActivities->isChecked());

QDialogButtonBox *buttonBox = w.findChild<QDialogButtonBox *>(QStringLiteral("buttonbox"));
    QVERIFY(buttonBox);

const QList<QAbstractButton *> lstButtonBox = buttonBox->buttons();
    bool hasClearButton = false;
    for (QAbstractButton *b : lstButtonBox) {
        if (b->objectName() == QLatin1String("clearbutton")) {
            hasClearButton = true;
            QVERIFY(!b->text().isEmpty());
        } else if (b->objectName() == QLatin1String("savebutton")) {
            QVERIFY(!b->isEnabled());
        }
    }
    QVERIFY(hasClearButton);
}

void LogActivitiesDialogTest::shouldClearLog()
{
    PimCommon::LogActivitiesDialog w;
    QDialogButtonBox *buttonBox = w.findChild<QDialogButtonBox *>(QStringLiteral("buttonbox"));

PimCommon::LogActivitiesWidget *mLogWidget = w.findChild<PimCommon::LogActivitiesWidget *>(QStringLiteral("logwidget"));

QVERIFY(mLogWidget->log().isEmpty());

mLogWidget->setLog(QStringLiteral("FOOO"));
    QVERIFY(!mLogWidget->log().isEmpty());

const QList<QAbstractButton *> lstButtonBox = buttonBox->buttons();
    QAbstractButton *clearButton = nullptr;
    for (QAbstractButton *b : lstButtonBox) {
        if (b->objectName() == QLatin1String("clearbutton")) {
            clearButton = b;
            break;
        }
    }
    QSignalSpy spy(&w, &PimCommon::LogActivitiesDialog::logCleared);
    QTest::mouseClick(clearButton, Qt::LeftButton);
    QCOMPARE(spy.count(), 1);
    QVERIFY(mLogWidget->log().isEmpty());
}

void LogActivitiesDialogTest::shouldHaveCorrectLogActivities()
{
    PimCommon::LogActivitiesManager::self()->setEnableLogActivities(true);
    PimCommon::LogActivitiesDialog w;
    QCheckBox *mEnableLogActivities = w.findChild<QCheckBox *>(QStringLiteral("enablelogactivities"));
    QVERIFY(mEnableLogActivities->isChecked());
}

QTEST_MAIN(LogActivitiesDialogTest)
07070100000075000081A40000000200000002000000015CDAA39400000465000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/logactivitiesdialogtest.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LOGACTIVITIESDIALOGTEST_H
#define LOGACTIVITIESDIALOGTEST_H

#include <QObject>

class LogActivitiesDialogTest : public QObject
{
    Q_OBJECT
public:
    explicit LogActivitiesDialogTest(QObject *parent = nullptr);
    ~LogActivitiesDialogTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldClearLog();
    void shouldHaveCorrectLogActivities();
};

#endif // LOGACTIVITIESDIALOGTEST_H
07070100000076000081A40000000200000002000000015CDAA39400000970000000000000000000000000000000000000007000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/logactivitiesmanagertest.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
#include "logactivitiesmanagertest.h"
#include "../logactivitiesmanager.h"

#include <QTest>
#include <QStandardPaths>

LogActivitiesManagerTest::LogActivitiesManagerTest(QObject *parent)
    : QObject(parent)
{
    QStandardPaths::setTestModeEnabled(true);
}

LogActivitiesManagerTest::~LogActivitiesManagerTest()
{
}

void LogActivitiesManagerTest::shouldHaveDefaultValue()
{
    PimCommon::LogActivitiesManager manager;
    QVERIFY(manager.log().isEmpty());
    QVERIFY(!manager.enableLogActivities());
}

void LogActivitiesManagerTest::shouldAppendLog()
{
    PimCommon::LogActivitiesManager manager;
    manager.setEnableLogActivities(false);
    manager.appendLog(QStringLiteral("ff"));
    QVERIFY(manager.log().isEmpty());

manager.setEnableLogActivities(true);
    QVERIFY(manager.log().isEmpty());
    manager.appendLog(QStringLiteral("ff"));
    QVERIFY(!manager.log().isEmpty());
    manager.appendLog(QStringLiteral("ff"));
    QVERIFY(!manager.log().isEmpty());

manager.clear();
    QVERIFY(manager.log().isEmpty());
}

void LogActivitiesManagerTest::shouldEnableActivities()
{
    PimCommon::LogActivitiesManager manager;
    QVERIFY(!manager.enableLogActivities());
    manager.setEnableLogActivities(true);
    QVERIFY(manager.enableLogActivities());
    manager.setEnableLogActivities(false);
    QVERIFY(!manager.enableLogActivities());
}

void LogActivitiesManagerTest::shouldClearLog()
{
    PimCommon::LogActivitiesManager manager;
    manager.setEnableLogActivities(true);
    manager.appendLog(QStringLiteral("ff"));
    QVERIFY(!manager.log().isEmpty());
    manager.setEnableLogActivities(false);
    QVERIFY(manager.log().isEmpty());
}

QTEST_MAIN(LogActivitiesManagerTest)
07070100000077000081A40000000200000002000000015CDAA39400000480000000000000000000000000000000000000006E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/logactivitiesmanagertest.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LOGACTIVITIESMANAGERTEST_H
#define LOGACTIVITIESMANAGERTEST_H

#include <QObject>

class LogActivitiesManagerTest : public QObject
{
    Q_OBJECT
public:
    explicit LogActivitiesManagerTest(QObject *parent = nullptr);
    ~LogActivitiesManagerTest();

private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldAppendLog();
    void shouldEnableActivities();
    void shouldClearLog();
};

#endif // LOGACTIVITIESMANAGERTEST_H
07070100000078000081A40000000200000002000000015CDAA394000005FA000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/logactivitieswidgettest.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "logactivitieswidgettest.h"
#include "../logactivitieswidget.h"
#include "kdepimtest_layout.h"
#include <KPIMTextEdit/PlainTextEditorWidget>
#include <QTest>
#include <QVBoxLayout>

LogActivitiesWidgetTest::LogActivitiesWidgetTest(QObject *parent)
    : QObject(parent)
{
}

LogActivitiesWidgetTest::~LogActivitiesWidgetTest()
{
}

void LogActivitiesWidgetTest::shouldHaveDefaultValue()
{
    PimCommon::LogActivitiesWidget w;
    QVBoxLayout *mainLayout = w.findChild<QVBoxLayout *>(QStringLiteral("mainLayout"));
    QVERIFY(mainLayout);
    KdepimTestLayout::checkContentsMargins(0, mainLayout);

KPIMTextEdit::PlainTextEditorWidget *mLog = w.findChild<KPIMTextEdit::PlainTextEditorWidget *>(QStringLiteral("log"));
    QVERIFY(mLog);
    QVERIFY(mLog->isReadOnly());
}

QTEST_MAIN(LogActivitiesWidgetTest)
07070100000079000081A40000000200000002000000015CDAA3940000041F000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/autotests/logactivitieswidgettest.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LOGACTIVITIESWIDGETTEST_H
#define LOGACTIVITIESWIDGETTEST_H

#include <QObject>

class LogActivitiesWidgetTest : public QObject
{
    Q_OBJECT
public:
    explicit LogActivitiesWidgetTest(QObject *parent = nullptr);
    ~LogActivitiesWidgetTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
};

#endif // LOGACTIVITIESWIDGETTEST_H
0707010000007A000081A40000000200000002000000015CDAA39400001434000000000000000000000000000000000000006100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitiesdialog.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "logactivitiesdialog.h"
#include "logactivitieswidget.h"
#include "logactivitiesmanager.h"
#include "logactivitiespurposemenuwidget.h"
#include <PimCommon/PimUtil>
#include <KLocalizedString>
#include <KConfigGroup>
#include <KSharedConfig>
#include <QVBoxLayout>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QCheckBox>
#include <QDebug>

using namespace PimCommon;

LogActivitiesDialog::LogActivitiesDialog(QWidget *parent)
    : QDialog(parent)
{
    setWindowTitle(i18n("Log activities"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->setObjectName(QStringLiteral("mainLayout"));

mLogWidget = new LogActivitiesWidget(this);
    mLogWidget->setObjectName(QStringLiteral("logwidget"));
    mainLayout->addWidget(mLogWidget);

mEnableLogActivities = new QCheckBox(i18n("Log activities"), this);
    mEnableLogActivities->setObjectName(QStringLiteral("enablelogactivities"));
    mainLayout->addWidget(mEnableLogActivities);
    connect(mEnableLogActivities, &QCheckBox::toggled, this, &LogActivitiesDialog::slotEnableLogActivities);

QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close | QDialogButtonBox::Save, this);
    buttonBox->setObjectName(QStringLiteral("buttonbox"));

mClearButton = new QPushButton(i18n("Clear"), this);
    mClearButton->setObjectName(QStringLiteral("clearbutton"));
    buttonBox->addButton(mClearButton, QDialogButtonBox::ActionRole);
    connect(mClearButton, &QPushButton::clicked, this, &LogActivitiesDialog::slotClear);
    mSaveButton = buttonBox->button(QDialogButtonBox::Save);
    mSaveButton->setObjectName(QStringLiteral("savebutton"));
    mSaveButton->setEnabled(false);

LogactivitiesPurposeMenuWidget *purposeMenu = new LogactivitiesPurposeMenuWidget(this, this);
    mShareButton = new QPushButton(i18n("Share..."), this);
    mShareButton->setMenu(purposeMenu->menu());
    mShareButton->setIcon(QIcon::fromTheme(QStringLiteral("document-share")));
    purposeMenu->setEditorWidget(mLogWidget->editor());
    buttonBox->addButton(mShareButton, QDialogButtonBox::ActionRole);
    mShareButton->setEnabled(false);

connect(mSaveButton, &QPushButton::clicked, this, &LogActivitiesDialog::slotSave);

mainLayout->addWidget(buttonBox);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &LogActivitiesDialog::reject);
    readConfig();

connect(PimCommon::LogActivitiesManager::self(), &LogActivitiesManager::logEntryAdded, this, &LogActivitiesDialog::slotLogEntryAdded);
    connect(PimCommon::LogActivitiesManager::self(), &LogActivitiesManager::logEntryCleared, this, &LogActivitiesDialog::slotLogEntryCleared);
    connect(mLogWidget, &LogActivitiesWidget::textChanged, this, &LogActivitiesDialog::slotActivityTextChanged);
    mEnableLogActivities->setChecked(PimCommon::LogActivitiesManager::self()->enableLogActivities());
}

LogActivitiesDialog::~LogActivitiesDialog()
{
    disconnect(mLogWidget, &LogActivitiesWidget::textChanged, this, &LogActivitiesDialog::slotActivityTextChanged);
    writeConfig();
}

void LogActivitiesDialog::slotActivityTextChanged(bool changed)
{
    mSaveButton->setEnabled(changed);
    mShareButton->setEnabled(changed);
}

void LogActivitiesDialog::slotSave()
{
    const QString filter = i18n("All Files (*)");
    PimCommon::Util::saveTextAs(PimCommon::LogActivitiesManager::self()->log(), filter, this, QUrl(),
                                i18nc("@title:window", "Save Log"));
}

void LogActivitiesDialog::slotEnableLogActivities(bool state)
{
    PimCommon::LogActivitiesManager::self()->setEnableLogActivities(state);
}

void LogActivitiesDialog::setLog(const QString &str)
{
    mLogWidget->setLog(str);
}

void LogActivitiesDialog::slotLogEntryAdded(const QString &entry)
{
    mLogWidget->addLogEntry(entry);
}

void LogActivitiesDialog::slotLogEntryCleared()
{
    mLogWidget->clear();
}

void LogActivitiesDialog::slotClear()
{
    mLogWidget->clear();
    Q_EMIT logCleared();
}

void LogActivitiesDialog::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "LogActivitiesDialog");
    const QSize sizeDialog = group.readEntry("Size", QSize(800, 600));
    if (sizeDialog.isValid()) {
        resize(sizeDialog);
    }
}

void LogActivitiesDialog::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "LogActivitiesDialog");
    group.writeEntry("Size", size());
}
0707010000007B000081A40000000200000002000000015CDAA394000006DA000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitiesdialog.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LOGACTIVITIESDIALOG_H
#define LOGACTIVITIESDIALOG_H

#include <QDialog>
#include "pimcommon_private_export.h"
class QPushButton;
class QCheckBox;
namespace PimCommon {
class LogActivitiesWidget;
class PIMCOMMON_TESTS_EXPORT LogActivitiesDialog : public QDialog
{
    Q_OBJECT
public:
    explicit LogActivitiesDialog(QWidget *parent = nullptr);
    ~LogActivitiesDialog();

void setLog(const QString &str);

Q_SIGNALS:
    void logCleared();

private:
    void slotSave();
    void slotClear();
    void readConfig();
    void writeConfig();
    void slotLogEntryCleared();
    void slotLogEntryAdded(const QString &entry);
    void slotEnableLogActivities(bool state);
    void slotActivityTextChanged(bool changed);

LogActivitiesWidget *mLogWidget = nullptr;
    QPushButton *mClearButton = nullptr;
    QCheckBox *mEnableLogActivities = nullptr;
    QPushButton *mSaveButton = nullptr;
    QPushButton *mShareButton = nullptr;
};
}

#endif // LOGACTIVITIESDIALOG_H
0707010000007C000081A40000000200000002000000015CDAA39400000AC1000000000000000000000000000000000000006200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitiesmanager.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "logactivitiesmanager.h"
#include "logactivitiesdialog.h"
#include <QTime>
#include <QDebug>
#include <QPointer>

using namespace PimCommon;

Q_GLOBAL_STATIC(LogActivitiesManager, s_pLogActivitiesSelf)

class PimCommon::LogActivitiesManagerPrivate
{
public:
    LogActivitiesManagerPrivate()
        : mDialog{nullptr}
        , mEnableLogActivities{false}
    {
    }

~LogActivitiesManagerPrivate()
    {
        //Disable delete it.
        //delete mDialog;
    }

QStringList mLog;
    QPointer<PimCommon::LogActivitiesDialog> mDialog = nullptr;
    bool mEnableLogActivities = false;
};

LogActivitiesManager::LogActivitiesManager(QObject *parent)
    : QObject(parent)
    , d(new LogActivitiesManagerPrivate)
{
}

LogActivitiesManager::~LogActivitiesManager()
{
    delete d;
}

LogActivitiesManager *LogActivitiesManager::self()
{
    return s_pLogActivitiesSelf;
}

void LogActivitiesManager::appendLog(const QString &str)
{
    if (d->mEnableLogActivities) {
        const QString timedLog = QLatin1Char('[') + QTime::currentTime().toString() + QLatin1String("] ") + str;
        d->mLog.append(timedLog);
        Q_EMIT logEntryAdded(timedLog);
    }
}

QString LogActivitiesManager::log() const
{
    return d->mLog.join(QLatin1Char('\n'));
}

void LogActivitiesManager::clear()
{
    d->mLog.clear();
    Q_EMIT logEntryCleared();
}

void LogActivitiesManager::showLogActivitiesDialog()
{
    if (!d->mDialog) {
        d->mDialog = new PimCommon::LogActivitiesDialog();
        d->mDialog->setAttribute(Qt::WA_DeleteOnClose, true);
        connect(d->mDialog.data(), &LogActivitiesDialog::logCleared, this, &LogActivitiesManager::clear);
    }
    d->mDialog->setLog(log());
    d->mDialog->show();
}

void LogActivitiesManager::setEnableLogActivities(bool b)
{
    d->mEnableLogActivities = b;
    if (!d->mEnableLogActivities) {
        clear();
    }
}

bool LogActivitiesManager::enableLogActivities() const
{
    return d->mEnableLogActivities;
}
0707010000007D000081A40000000200000002000000015CDAA39400000610000000000000000000000000000000000000006000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitiesmanager.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LOGACTIVITIESMANAGER_H
#define LOGACTIVITIESMANAGER_H

#include <QObject>
#include "pimcommon_export.h"
namespace PimCommon {
class LogActivitiesManagerPrivate;
class PIMCOMMON_EXPORT LogActivitiesManager : public QObject
{
    Q_OBJECT
public:
    explicit LogActivitiesManager(QObject *parent = nullptr);
    ~LogActivitiesManager();

static LogActivitiesManager *self();

void appendLog(const QString &str);

Q_REQUIRED_RESULT QString log() const;

void clear();

void showLogActivitiesDialog();

void setEnableLogActivities(bool b);
    bool enableLogActivities() const;

Q_SIGNALS:
    void logEntryAdded(const QString &entry);
    void logEntryCleared();

private:
    LogActivitiesManagerPrivate *const d;
};
}
#endif // LOGACTIVITIESMANAGER_H
0707010000007E000081A40000000200000002000000015CDAA394000005A3000000000000000000000000000000000000006C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitiespurposemenuwidget.cpp/*
   Copyright (C) 2018-2019 Laurent Montel <montel@kde.org>

This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

This library 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
   Library General Public License for more details.

You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
#include "logactivitiespurposemenuwidget.h"
#include <KPIMTextEdit/PlainTextEditor>

using namespace PimCommon;
LogactivitiesPurposeMenuWidget::LogactivitiesPurposeMenuWidget(QWidget *parentWidget, QObject *parent)
    : PimCommon::PurposeMenuWidget(parentWidget, parent)
{
}

LogactivitiesPurposeMenuWidget::~LogactivitiesPurposeMenuWidget()
{
}

QByteArray LogactivitiesPurposeMenuWidget::text()
{
    if (mEditor) {
        return mEditor->toPlainText().toUtf8();
    }
    return {};
}

void LogactivitiesPurposeMenuWidget::setEditorWidget(KPIMTextEdit::PlainTextEditor *editor)
{
    mEditor = editor;
}
0707010000007F000081A40000000200000002000000015CDAA394000005C8000000000000000000000000000000000000006A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitiespurposemenuwidget.h/*
   Copyright (C) 2018-2019 Laurent Montel <montel@kde.org>

This library 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
   Library General Public License for more details.

#ifndef LOGACTIVITIESPURPOSEMENUWIDGET_H
#define LOGACTIVITIESPURPOSEMENUWIDGET_H

#include "widgets/purposemenuwidget.h"
namespace KPIMTextEdit {
class PlainTextEditor;
}
namespace PimCommon {
class LogactivitiesPurposeMenuWidget : public PimCommon::PurposeMenuWidget
{
    Q_OBJECT
public:
    explicit LogactivitiesPurposeMenuWidget(QWidget *parentWidget, QObject *parent = nullptr);
    ~LogactivitiesPurposeMenuWidget() override;

QByteArray text() override;
    void setEditorWidget(KPIMTextEdit::PlainTextEditor *editor);
private:
    KPIMTextEdit::PlainTextEditor *mEditor = nullptr;
};
}

#endif // LOGACTIVITIESPURPOSEMENUWIDGET_H
07070100000080000081A40000000200000002000000015CDAA39400000893000000000000000000000000000000000000006100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitieswidget.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "logactivitieswidget.h"
#include <QVBoxLayout>
#include <KPIMTextEdit/PlainTextEditorWidget>
#include <KPIMTextEdit/PlainTextEditor>
#include <QDebug>
using namespace PimCommon;

LogActivitiesWidget::LogActivitiesWidget(QWidget *parent)
    : QWidget(parent)
{
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->setContentsMargins(0, 0, 0, 0);
    mainLayout->setObjectName(QStringLiteral("mainLayout"));

mLog = new KPIMTextEdit::PlainTextEditorWidget(this);
    mLog->setObjectName(QStringLiteral("log"));
    mLog->setReadOnly(true);
    mainLayout->addWidget(mLog);
    connect(mLog->editor(), &KPIMTextEdit::PlainTextEditor::textChanged, this, &LogActivitiesWidget::slotTextChanged);
}

LogActivitiesWidget::~LogActivitiesWidget()
{
    disconnect(mLog->editor(), &KPIMTextEdit::PlainTextEditor::textChanged, this, &LogActivitiesWidget::slotTextChanged);
}

void LogActivitiesWidget::slotTextChanged()
{
    Q_EMIT textChanged(!mLog->editor()->document()->isEmpty());
}

void LogActivitiesWidget::addLogEntry(const QString &entry)
{
    mLog->editor()->appendHtml(entry);
}

void LogActivitiesWidget::setLog(const QString &str)
{
    mLog->setPlainText(str);
}

QString LogActivitiesWidget::log() const
{
    return mLog->toPlainText();
}

void LogActivitiesWidget::clear()
{
    mLog->clear();
}

KPIMTextEdit::PlainTextEditor *LogActivitiesWidget::editor()
{
    return mLog->editor();
}
07070100000081000081A40000000200000002000000015CDAA3940000060F000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/logactivitieswidget.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LOGACTIVITIESWIDGET_H
#define LOGACTIVITIESWIDGET_H

#include <QWidget>
#include "pimcommon_private_export.h"
namespace KPIMTextEdit {
class PlainTextEditorWidget;
class PlainTextEditor;
}
namespace PimCommon {
class PIMCOMMON_TESTS_EXPORT LogActivitiesWidget : public QWidget
{
    Q_OBJECT
public:
    explicit LogActivitiesWidget(QWidget *parent = nullptr);
    ~LogActivitiesWidget();
    void setLog(const QString &str);
    Q_REQUIRED_RESULT QString log() const;
    void clear();
    void addLogEntry(const QString &entry);
    Q_REQUIRED_RESULT KPIMTextEdit::PlainTextEditor *editor();
Q_SIGNALS:
    void textChanged(bool changed);

private:
    void slotTextChanged();
    KPIMTextEdit::PlainTextEditorWidget *mLog = nullptr;
};
}

#endif // LOGACTIVITIESWIDGET_H
07070100000082000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/tests07070100000083000081A40000000200000002000000015CDAA394000000C5000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/tests/CMakeLists.txtset(logactivities_gui_SRCS main.cpp logactivitiesmainwidget.cpp)
add_executable(logactivities_gui ${logactivities_gui_SRCS})
target_link_libraries(logactivities_gui
  KF5::PimCommon
  KF5::I18n
)

07070100000084000081A40000000200000002000000015CDAA39400000AB3000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/tests/logactivitiesmainwidget.cpp/*
   Copyright (C) 2017-2019 Laurent Montel <montel@kde.org>

This library 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
   Library General Public License for more details.

#include "logactivitiesmainwidget.h"
#include "logactivities/logactivitiesdialog.h"
#include "logactivities/logactivitiesmanager.h"
#include <QPushButton>
#include <QHBoxLayout>
#include <QCheckBox>

LogActivitiesMainWidget::LogActivitiesMainWidget(QWidget *parent)
    : QWidget(parent)
{
    QHBoxLayout *mainLayout = new QHBoxLayout(this);
    QPushButton *button = new QPushButton(QStringLiteral("Open Log"), this);
    connect(button, &QPushButton::clicked, this, &LogActivitiesMainWidget::slotOpenDialog);
    mainLayout->addWidget(button);

QPushButton *addLog = new QPushButton(QStringLiteral("Append Log"), this);
    connect(addLog, &QPushButton::clicked, this, &LogActivitiesMainWidget::slotAddLog);
    mainLayout->addWidget(addLog);

QPushButton *clearLogButton = new QPushButton(QStringLiteral("Clear log"), this);
    connect(clearLogButton, &QPushButton::clicked, this, &LogActivitiesMainWidget::slotClearLog);
    mainLayout->addWidget(clearLogButton);

QCheckBox *enableLog = new QCheckBox(QStringLiteral("Enable Log Activities"), this);
    connect(enableLog, &QPushButton::toggled, this, &LogActivitiesMainWidget::slotEnableLogActivities);
    enableLog->setChecked(true);
    mainLayout->addWidget(enableLog);

PimCommon::LogActivitiesManager::self()->setEnableLogActivities(true);
    PimCommon::LogActivitiesManager::self()->appendLog(QStringLiteral("foo"));
}

void LogActivitiesMainWidget::slotOpenDialog()
{
    PimCommon::LogActivitiesManager::self()->showLogActivitiesDialog();
}

void LogActivitiesMainWidget::slotClearLog()
{
    PimCommon::LogActivitiesManager::self()->clear();
}

void LogActivitiesMainWidget::slotEnableLogActivities(bool enable)
{
    PimCommon::LogActivitiesManager::self()->setEnableLogActivities(enable);
}

void LogActivitiesMainWidget::slotAddLog()
{
    PimCommon::LogActivitiesManager::self()->appendLog(QStringLiteral("Foo"));
}
07070100000085000081A40000000200000002000000015CDAA394000004F9000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/tests/logactivitiesmainwidget.h/*
   Copyright (C) 2017-2019 Laurent Montel <montel@kde.org>

This library 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
   Library General Public License for more details.

#ifndef LOGACTIVITIESMAINWIDGET_H
#define LOGACTIVITIESMAINWIDGET_H

#include <QWidget>

class LogActivitiesMainWidget : public QWidget
{
    Q_OBJECT
public:
    explicit LogActivitiesMainWidget(QWidget *parent = nullptr);
    ~LogActivitiesMainWidget() = default;

private:
    void slotOpenDialog();
    void slotClearLog();
    void slotEnableLogActivities(bool enable);
    void slotAddLog();
};

#endif // LOGACTIVITIESMAINWIDGET_H
07070100000086000081A40000000200000002000000015CDAA3940000050D000000000000000000000000000000000000005800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/logactivities/tests/main.cpp/*
   Copyright (C) 2017-2019 Laurent Montel <montel@kde.org>

This library 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
   Library General Public License for more details.

#include <QStandardPaths>
#include <QApplication>
#include <QCommandLineParser>
#include "logactivitiesmainwidget.h"

parser.process(app);

LogActivitiesMainWidget *w = new LogActivitiesMainWidget;
    w->show();
    app.exec();
    return 0;
}
07070100000087000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration07070100000088000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests07070100000089000081A40000000200000002000000015CDAA3940000019F000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/CMakeLists.txtadd_definitions(-DMIGRATION_DATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data")

macro(add_pimcommon_migration_unittest _source)
    ecm_add_test(${_source}
        NAME_PREFIX "pimcommon-migration-"
        LINK_LIBRARIES Qt5::Test KF5::CoreAddons KF5::ConfigCore KF5::PimCommon
    )
endmacro()

add_pimcommon_migration_unittest(migrateapplicationfilestest.cpp)
add_pimcommon_migration_unittest(migratefileinfotest.cpp)
0707010000008A000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/data0707010000008B000081A40000000200000002000000015CDAA39400000000000000000000000000000000000000000000005A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/data/file10707010000008C000081A40000000200000002000000015CDAA39400000000000000000000000000000000000000000000005A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/data/file20707010000008D000081A40000000200000002000000015CDAA39400000000000000000000000000000000000000000000005D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/data/text.txt0707010000008E000081A40000000200000002000000015CDAA39400000000000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/data/text2.txt0707010000008F000081A40000000200000002000000015CDAA39400003B3C000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/migrateapplicationfilestest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "migrateapplicationfilestest.h"
#include "../migrateapplicationfiles.h"
#include <QTest>
#include <QStandardPaths>
#include <QDebug>
#include <QDir>
#include <QTemporaryDir>

using namespace PimCommon;
MigrateApplicationFilesTest::MigrateApplicationFilesTest(QObject *parent)
    : QObject(parent)
{
}

MigrateApplicationFilesTest::~MigrateApplicationFilesTest()
{
}

void MigrateApplicationFilesTest::initTestCase()
{
    //qDebug() << " QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)" <<QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
    QStandardPaths::setTestModeEnabled(true);
    const QString applicationHome = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
    //qDebug() << "application data" << applicationHome;
    QDir(applicationHome).removeRecursively();
}

void MigrateApplicationFilesTest::shouldHaveDefaultValue()
{
    MigrateApplicationFiles migrate;
    QVERIFY(!migrate.start());
    QVERIFY(migrate.configFileName().isEmpty());
    QVERIFY(migrate.applicationName().isEmpty());
}

void MigrateApplicationFilesTest::shouldVerifyIfCheckIsNecessary()
{
    MigrateApplicationFiles migrate;
    //Invalid before config file is not set.
    QVERIFY(!migrate.checkIfNecessary());
    migrate.setConfigFileName(QStringLiteral("foorc"));
    // If config file doesn't exist we need to check migrate
    QVERIFY(migrate.checkIfNecessary());
}

void MigrateApplicationFilesTest::shouldNotMigrateIfKdehomeDoNotExist()
{
    qputenv("KDEHOME", "");
    MigrateApplicationFiles migrate;
    migrate.setConfigFileName(QStringLiteral("foorc"));

QCOMPARE(migrate.start(), false);
}

void MigrateApplicationFilesTest::shouldMigrateIfKde4HomeDirExist()
{
    QTemporaryDir kdehomeDir;
    QVERIFY(kdehomeDir.isValid());
    const QString kdehome = kdehomeDir.path();
    qputenv("KDEHOME", QFile::encodeName(kdehome));
    MigrateApplicationFiles migrate;
    QCOMPARE(migrate.start(), false);

migrate.setConfigFileName(QStringLiteral("foorc"));

MigrateFileInfo info;
    info.setPath(QStringLiteral("foo/foo"));
    info.setType(QStringLiteral("data"));

migrate.insertMigrateInfo(info);
    QCOMPARE(migrate.start(), true);
}

void MigrateApplicationFilesTest::shouldMigrateFolders()
{
    QTemporaryDir kdehomeDir;
    QVERIFY(kdehomeDir.isValid());
    const QString kdehome = kdehomeDir.path();
    qputenv("KDEHOME", QFile::encodeName(kdehome));

//Generate kde4 apps dir
    const QString folderName = QStringLiteral("foo/folder1/");
    const QString appsPath = kdehome + QLatin1Char('/') + QLatin1String("share/apps/") + folderName;
    QDir().mkpath(appsPath);
    QVERIFY(QDir(appsPath).exists());

QStringList files;
    files << QStringLiteral("file1") << QStringLiteral("file2");
    const QString xdgDatahome = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + folderName;
    for (const QString &file : qAsConst(files)) {
        QFile fooFile(QLatin1String(MIGRATION_DATA_DIR) + QLatin1Char('/') + file);
        QVERIFY(fooFile.exists());
        const QString storedConfigFilePath = appsPath + QLatin1Char('/') + file;
        QVERIFY(QFile::copy(fooFile.fileName(), storedConfigFilePath));

const QString xdgFile = xdgDatahome + file;
        QVERIFY(!QFile::exists(xdgFile));
    }
    MigrateApplicationFiles migrate;
    migrate.setConfigFileName(QStringLiteral("foorc"));

MigrateFileInfo info;
    info.setFolder(true);
    info.setPath(folderName);
    info.setType(QStringLiteral("data"));
    info.setVersion(1);
    migrate.insertMigrateInfo(info);

QVERIFY(migrate.checkIfNecessary());

QVERIFY(migrate.start());
    for (const QString &file : qAsConst(files)) {
        QVERIFY(QFile(xdgDatahome + file).exists());
    }
}

void MigrateApplicationFilesTest::shouldNotMigrateFoldersIfAlreadyDone()
{
    QTemporaryDir kdehomeDir;
    QVERIFY(kdehomeDir.isValid());
    const QString kdehome = kdehomeDir.path();
    qputenv("KDEHOME", QFile::encodeName(kdehome));

const QString xdgFile = xdgDatahome + file;
        QVERIFY(!QFile::exists(xdgFile));
    }
    MigrateApplicationFiles migrate;
    migrate.setConfigFileName(QStringLiteral("foorc"));
    QVERIFY(migrate.checkIfNecessary());

//We have a current version == 2 => don't migrate old info. Put after checkIfNecessary to override value
    migrate.setCurrentConfigVersion(3);

MigrateFileInfo info;
    info.setFolder(true);
    info.setPath(folderName);
    info.setType(QStringLiteral("data"));
    info.setVersion(2);
    migrate.insertMigrateInfo(info);

QVERIFY(migrate.start());
    for (const QString &file : qAsConst(files)) {
        QVERIFY(!QFile(xdgDatahome + file).exists());
    }
}

void MigrateApplicationFilesTest::shouldMigrateFoldersWithSubFolders()
{
    QTemporaryDir kdehomeDir;
    QVERIFY(kdehomeDir.isValid());
    const QString kdehome = kdehomeDir.path();
    qputenv("KDEHOME", QFile::encodeName(kdehome));

const QString xdgFile = xdgDatahome + file;
        QVERIFY(!QFile::exists(xdgFile));
    }

//SubFolder.
    const QString subFolder = QStringLiteral("foo/folder1/subfolder/");
    const QString appsPathSubfolder = kdehome + QLatin1Char('/') + QLatin1String("share/apps/") + subFolder;
    QDir().mkpath(appsPathSubfolder);
    QVERIFY(QDir(appsPathSubfolder).exists());
    const QString xdgDatahomeSubfolder = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + subFolder;
    for (const QString &file : qAsConst(files)) {
        QFile fooFile(QLatin1String(MIGRATION_DATA_DIR) + QLatin1Char('/') + file);
        QVERIFY(fooFile.exists());
        const QString storedConfigFilePath = appsPathSubfolder + QLatin1Char('/') + file;
        QVERIFY(QFile::copy(fooFile.fileName(), storedConfigFilePath));

const QString xdgFile = xdgDatahomeSubfolder + file;
        QVERIFY(!QFile::exists(xdgFile));
    }

MigrateApplicationFiles migrate;
    migrate.setConfigFileName(QStringLiteral("foorc"));

MigrateFileInfo info;
    info.setFolder(true);
    info.setPath(folderName);
    info.setType(QStringLiteral("data"));
    info.setVersion(2);
    migrate.insertMigrateInfo(info);

QVERIFY(migrate.checkIfNecessary());
    migrate.setCurrentConfigVersion(1);

QVERIFY(migrate.start());
    for (const QString &file : qAsConst(files)) {
        QVERIFY(QFile(xdgDatahome + file).exists());
        QVERIFY(QFile(xdgDatahomeSubfolder + file).exists());
    }
}

void MigrateApplicationFilesTest::shouldNotMigrateIfAlreadyDone()
{
    QTemporaryDir kdehomeDir;
    QVERIFY(kdehomeDir.isValid());
    const QString kdehome = kdehomeDir.path();
    qputenv("KDEHOME", QFile::encodeName(kdehome));

const QString xdgDatahome = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + folderName;

QStringList files;
    files << QStringLiteral("file1") << QStringLiteral("file2");
    for (const QString &file : qAsConst(files)) {
        QFile fooFile(QLatin1String(MIGRATION_DATA_DIR) + QLatin1Char('/') + file);
        QVERIFY(fooFile.exists());
        const QString storedConfigFilePath = appsPath + QLatin1Char('/') + file;
        QVERIFY(QFile::copy(fooFile.fileName(), storedConfigFilePath));

const QString xdgFile = xdgDatahome + file;
        QVERIFY(!QFile::exists(xdgFile));
    }
    MigrateApplicationFiles migrate;
    migrate.setConfigFileName(QStringLiteral("foorc"));

MigrateFileInfo info;
    info.setPath(folderName + QStringLiteral("file1"));
    info.setType(QStringLiteral("data"));
    info.setVersion(2);
    migrate.insertMigrateInfo(info);

MigrateFileInfo info2;
    info2.setPath(folderName + QStringLiteral("file2"));
    info2.setType(QStringLiteral("data"));
    info2.setVersion(2);
    migrate.insertMigrateInfo(info2);

QVERIFY(migrate.checkIfNecessary());
    //We have a current version == 3 => don't migrate old info.
    migrate.setCurrentConfigVersion(3);
    QVERIFY(migrate.start());
    for (const QString &file : qAsConst(files)) {
        QVERIFY(!QFile(xdgDatahome + file).exists());
    }
}

void MigrateApplicationFilesTest::shouldMigrateFiles()
{
    QTemporaryDir kdehomeDir;
    QVERIFY(kdehomeDir.isValid());
    const QString kdehome = kdehomeDir.path();
    qputenv("KDEHOME", QFile::encodeName(kdehome));

const QString xdgDatahome = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + folderName;

QStringList files;
    files << QStringLiteral("file1") << QStringLiteral("file2");
    for (const QString &file : qAsConst(files)) {
        QFile fooFile(QLatin1String(MIGRATION_DATA_DIR) + QLatin1Char('/') + file);
        QVERIFY(fooFile.exists());
        const QString storedConfigFilePath = appsPath + QLatin1Char('/') + file;
        //qDebug()<<" storedConfigFilePath"<<storedConfigFilePath;
        QVERIFY(QFile::copy(fooFile.fileName(), storedConfigFilePath));

const QString xdgFile = xdgDatahome + file;
        QVERIFY(!QFile::exists(xdgFile));
    }
    MigrateApplicationFiles migrate;
    migrate.setConfigFileName(QStringLiteral("foorc"));

MigrateFileInfo info;
    info.setPath(folderName + QStringLiteral("file1"));
    info.setType(QStringLiteral("data"));
    migrate.insertMigrateInfo(info);

MigrateFileInfo info2;
    info2.setPath(folderName + QStringLiteral("file2"));
    info2.setType(QStringLiteral("data"));
    migrate.insertMigrateInfo(info2);

QVERIFY(migrate.checkIfNecessary());
    QVERIFY(migrate.start());
    for (const QString &file : qAsConst(files)) {
        QVERIFY(QFile(xdgDatahome + file).exists());
    }
}

void MigrateApplicationFilesTest::shouldMigrateFilesWithPattern()
{
    QTemporaryDir kdehomeDir;
    QVERIFY(kdehomeDir.isValid());
    const QString kdehome = kdehomeDir.path();
    qputenv("KDEHOME", QFile::encodeName(kdehome));

//Generate kde4 apps dir
    const QString folderName = QStringLiteral("foo/");
    const QString appsPath = kdehome + QLatin1Char('/') + QLatin1String("share/apps/") + folderName;
    QDir().mkpath(appsPath);
    QVERIFY(QDir(appsPath).exists());
    const QString xdgDatahome = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + folderName;

//Copy files.
    QStringList files;
    QStringList filesMustBeMigrated;
    filesMustBeMigrated << QStringLiteral("text2.txt") << QStringLiteral("text.txt");
    QStringList filesMustNotBeMigrated;
    filesMustNotBeMigrated << QStringLiteral("file1") << QStringLiteral("file2");

files << filesMustBeMigrated << filesMustNotBeMigrated;
    for (const QString &file : qAsConst(files)) {
        QFile fooFile(QLatin1String(MIGRATION_DATA_DIR) + QLatin1Char('/') + file);
        QVERIFY(fooFile.exists());
        const QString storedConfigFilePath = appsPath + QLatin1Char('/') + file;
        //qDebug()<<" storedConfigFilePath"<<storedConfigFilePath;
        QVERIFY(QFile::copy(fooFile.fileName(), storedConfigFilePath));

const QString xdgFile = xdgDatahome + file;
        QVERIFY(!QFile::exists(xdgFile));
    }

MigrateApplicationFiles migrate;
    migrate.setConfigFileName(QStringLiteral("foorc"));

MigrateFileInfo info;
    info.setPath(folderName);
    info.setType(QStringLiteral("data"));
    info.setFolder(false);
    info.setFilePatterns(QStringList() << QStringLiteral("*.txt"));
    migrate.insertMigrateInfo(info);

QVERIFY(migrate.checkIfNecessary());
    QVERIFY(migrate.start());
    for (const QString &file : qAsConst(filesMustBeMigrated)) {
        QVERIFY(QFile(xdgDatahome + file).exists());
    }
    for (const QString &file : qAsConst(filesMustNotBeMigrated)) {
        QVERIFY(!QFile(xdgDatahome + file).exists());
    }
}

void MigrateApplicationFilesTest::cleanup()
{
    QStandardPaths::setTestModeEnabled(true);
    const QString applicationHome = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
    QDir applicationDir(applicationHome);
    applicationDir.removeRecursively();
    const QString configHome = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
    QDir configDir(configHome);
    configDir.removeRecursively();
}

QTEST_MAIN(MigrateApplicationFilesTest)
07070100000090000081A40000000200000002000000015CDAA394000005E0000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/migrateapplicationfilestest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MIGRATEAPPLICATIONFILESTEST_H
#define MIGRATEAPPLICATIONFILESTEST_H

#include <QObject>

class MigrateApplicationFilesTest : public QObject
{
    Q_OBJECT
public:
    explicit MigrateApplicationFilesTest(QObject *parent = nullptr);
    ~MigrateApplicationFilesTest();
private Q_SLOTS:
    void initTestCase();
    void shouldHaveDefaultValue();
    void shouldVerifyIfCheckIsNecessary();
    void shouldNotMigrateIfKdehomeDoNotExist();
    void shouldMigrateIfKde4HomeDirExist();
    void shouldMigrateFolders();
    void shouldNotMigrateFoldersIfAlreadyDone();
    void shouldMigrateFoldersWithSubFolders();

void shouldMigrateFiles();
    void shouldMigrateFilesWithPattern();
    void cleanup();
    void shouldNotMigrateIfAlreadyDone();
};

#endif // MIGRATEAPPLICATIONFILESTEST_H
07070100000091000081A40000000200000002000000015CDAA39400000BD4000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/migratefileinfotest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "migratefileinfotest.h"
#include "../migratefileinfo.h"
#include <QTest>
using namespace PimCommon;
MigrateFileInfoTest::MigrateFileInfoTest(QObject *parent)
    : QObject(parent)
{
}

MigrateFileInfoTest::~MigrateFileInfoTest()
{
}

void MigrateFileInfoTest::shouldHaveDefaultValue()
{
    MigrateFileInfo info;
    QVERIFY(!info.folder());
    QVERIFY(info.path().isEmpty());
    QVERIFY(info.type().isEmpty());
    QVERIFY(info.filePatterns().isEmpty());
    QCOMPARE(info.version(), -1);
}

void MigrateFileInfoTest::shouldAssignValue()
{
    MigrateFileInfo info;
    bool isFolder = false;
    info.setFolder(isFolder);
    QCOMPARE(info.folder(), isFolder);
    isFolder = true;
    info.setFolder(isFolder);
    QCOMPARE(info.folder(), isFolder);
    isFolder = false;
    info.setFolder(isFolder);
    QCOMPARE(info.folder(), isFolder);

QString path;
    info.setPath(path);
    QCOMPARE(info.path(), path);
    path = QStringLiteral("foo");
    info.setPath(path);
    QCOMPARE(info.path(), path);
    path.clear();
    info.setPath(path);
    QCOMPARE(info.path(), path);

QString type;
    info.setType(type);
    QCOMPARE(info.type(), type);
    type = QStringLiteral("foo");
    info.setType(type);
    QCOMPARE(info.type(), type);
    type.clear();
    info.setType(type);
    QCOMPARE(info.type(), type);

int version = -1;
    info.setVersion(version);
    QCOMPARE(info.version(), version);
    version = 6;
    info.setVersion(version);
    QCOMPARE(info.version(), version);

QStringList pattern;
    info.setFilePatterns(pattern);
    QCOMPARE(info.filePatterns(), pattern);
    pattern = QStringList() << QStringLiteral("foo");
    info.setFilePatterns(pattern);
    QCOMPARE(info.filePatterns(), pattern);
    pattern.clear();
    info.setFilePatterns(pattern);
    QCOMPARE(info.filePatterns(), pattern);
}

void MigrateFileInfoTest::shouldBeEmpty()
{
    MigrateFileInfo info;
    QVERIFY(!info.isValid());
    info.setFolder(true);
    QVERIFY(!info.isValid());

const QString type = QStringLiteral("foo");
    info.setType(type);
    QVERIFY(!info.isValid());

QString path = QStringLiteral("foo");
    info.setPath(path);
    QVERIFY(info.isValid());

path.clear();
    info.setPath(path);
    QVERIFY(!info.isValid());
}

QTEST_MAIN(MigrateFileInfoTest)
07070100000092000081A40000000200000002000000015CDAA39400000440000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/autotests/migratefileinfotest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MIGRATEFILEINFOTEST_H
#define MIGRATEFILEINFOTEST_H

#include <QObject>

class MigrateFileInfoTest : public QObject
{
    Q_OBJECT
public:
    explicit MigrateFileInfoTest(QObject *parent = nullptr);
    ~MigrateFileInfoTest();

private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldAssignValue();
    void shouldBeEmpty();
};

#endif // MIGRATEFilEINFOTEST_H
07070100000093000081A40000000200000002000000015CDAA39400001FCD000000000000000000000000000000000000006100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/migrateapplicationfiles.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "migrateapplicationfiles.h"
#include "pimcommon_debug.h"

#include <kdelibs4migration.h>
#include <KSharedConfig>
#include <KConfigGroup>
#include <QFile>
#include <QFileInfo>
#include <QDir>

using namespace PimCommon;

class PimCommon::MigrateApplicationFilesPrivate
{
public:
    MigrateApplicationFilesPrivate()
        : mMigrateApplicationVersion(1)
        , mCurrentConfigVersion(0)
    {
    }

QVector<MigrateFileInfo> mMigrateInfoList;
    QString mConfigFileName;
    QString mApplicationName;
    Kdelibs4Migration mMigration;
    int mMigrateApplicationVersion;
    int mCurrentConfigVersion;
};

MigrateApplicationFiles::MigrateApplicationFiles(QObject *parent)
    : QObject(parent)
    , d(new PimCommon::MigrateApplicationFilesPrivate)
{
}

MigrateApplicationFiles::~MigrateApplicationFiles()
{
    delete d;
}

void MigrateApplicationFiles::finished()
{
    writeConfig();
    Q_EMIT migrateDone();
}

bool MigrateApplicationFiles::start()
{
    if (d->mApplicationName.isEmpty()) {
        qCDebug(PIMCOMMON_LOG) << "Missing application name";
    }
    // Testing for kdehome
    if (!d->mMigration.kdeHomeFound()) {
        finished();
        return false;
    }

if (d->mMigrateInfoList.isEmpty()) {
        finished();
        return false;
    }

if (d->mConfigFileName.isEmpty()) {
        qCDebug(PIMCOMMON_LOG) << " config file name not defined.";
        finished();
        return false;
    }
    return migrateConfig();
}

bool MigrateApplicationFiles::migrateConfig()
{
    qCDebug(PIMCOMMON_LOG) << "Start migration...";
    for (const MigrateFileInfo &info : qAsConst(d->mMigrateInfoList)) {
        if ((info.version() == -1) || (info.version() > d->mCurrentConfigVersion)) {
            if (info.folder()) {
                migrateFolder(info);
            } else {
                migrateFile(info);
            }
        }
    }
    qCDebug(PIMCOMMON_LOG) << "Migration finished.";
    finished();
    return true;
}

QString MigrateApplicationFiles::applicationName() const
{
    return d->mApplicationName;
}

void MigrateApplicationFiles::setApplicationName(const QString &applicationName)
{
    d->mApplicationName = applicationName;
}

int MigrateApplicationFiles::currentConfigVersion() const
{
    return d->mCurrentConfigVersion;
}

void MigrateApplicationFiles::setCurrentConfigVersion(int currentConfigVersion)
{
    d->mCurrentConfigVersion = currentConfigVersion;
}

QString MigrateApplicationFiles::configFileName() const
{
    return d->mConfigFileName;
}

void MigrateApplicationFiles::setConfigFileName(const QString &configFileName)
{
    d->mConfigFileName = configFileName;
}

void MigrateApplicationFiles::writeConfig()
{
    KSharedConfig::Ptr config = KSharedConfig::openConfig(d->mConfigFileName, KConfig::SimpleConfig);
    KConfigGroup grp = config->group(QStringLiteral("Migratekde4"));
    grp.writeEntry(QStringLiteral("Version"), d->mMigrateApplicationVersion);
    grp.sync();
}

void MigrateApplicationFiles::migrateFolder(const MigrateFileInfo &info)
{
    QString originalPath;
    QString newPath;
    if (info.type() == QLatin1String("data")) {
        originalPath = d->mMigration.locateLocal("data", info.path());
        newPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + info.path();
        QFileInfo fileInfo(newPath);
        QDir().mkpath(fileInfo.absolutePath());
    } else {
        qCDebug(PIMCOMMON_LOG) << "Type not supported: " << info.type();
    }
    if (!originalPath.isEmpty()) {
        copyRecursively(originalPath, newPath);
    }
}

bool MigrateApplicationFiles::copyRecursively(const QString &srcFilePath, const QString &tgtFilePath)
{
    QFileInfo srcFileInfo(srcFilePath);
    if (srcFileInfo.isDir()) {
        QDir targetDir(tgtFilePath);
        targetDir.cdUp();
        if (!targetDir.mkpath(QFileInfo(tgtFilePath).path())) {
            return false;
        }
        QDir sourceDir(srcFilePath);
        const QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
        for (const QString &fileName : fileNames) {
            const QString newSrcFilePath = srcFilePath + QLatin1Char('/') + fileName;
            const QString newTgtFilePath = tgtFilePath + QLatin1Char('/') + fileName;
            if (!copyRecursively(newSrcFilePath, newTgtFilePath)) {
                return false;
            }
        }
    } else {
        if (!QDir().mkpath(QFileInfo(tgtFilePath).absolutePath())) {
            qCDebug(PIMCOMMON_LOG) << "Can not create path " << srcFileInfo.absolutePath();
            return false;
        }
        if (!QFileInfo::exists(tgtFilePath) && !QFile::copy(srcFilePath, tgtFilePath)) {
            qCDebug(PIMCOMMON_LOG) << " can't copy" << srcFilePath << " tgtFilePath" << tgtFilePath;
            return false;
        }
    }
    return true;
}

void MigrateApplicationFiles::migrateFile(const MigrateFileInfo &info)
{
    QString originalPath;
    QString newPath;
    if (info.type() == QLatin1String("data")) {
        originalPath = d->mMigration.locateLocal("data", info.path());
        newPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + info.path();
        QFileInfo fileInfo(newPath);
        QDir().mkpath(fileInfo.absolutePath());
    } else {
        qCDebug(PIMCOMMON_LOG) << "Type not supported: " << info.type();
    }

if (!originalPath.isEmpty()) {
        if (info.filePatterns().isEmpty()) {
            if (!QFileInfo::exists(newPath)) {
                QFile copyFile(originalPath);
                if (!copyFile.copy(newPath)) {
                    qCDebug(PIMCOMMON_LOG) << "impossible to copy " << originalPath << " to " << newPath;
                }
            }
        } else {
            QDir sourceDir(originalPath);
            const QStringList fileNames = sourceDir.entryList(info.filePatterns(), QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
            for (const QString &file : fileNames) {
                QFile copyFile(originalPath + QLatin1Char('/') + file);
                if (!copyFile.copy(newPath + QLatin1Char('/') + file)) {
                    qCDebug(PIMCOMMON_LOG) << "impossible to copy " << copyFile.fileName() << " to " << newPath;
                }
            }
        }
    }
}

int MigrateApplicationFiles::version() const
{
    return d->mMigrateApplicationVersion;
}

void MigrateApplicationFiles::setVersion(int version)
{
    d->mMigrateApplicationVersion = version;
}

bool MigrateApplicationFiles::checkIfNecessary()
{
    if (d->mConfigFileName.isEmpty()) {
        qCDebug(PIMCOMMON_LOG) << " config file name not defined.";
        return false;
    }
    KSharedConfig::Ptr config = KSharedConfig::openConfig(d->mConfigFileName, KConfig::SimpleConfig);
    if (config->hasGroup(QStringLiteral("Migratekde4"))) {
        KConfigGroup grp = config->group(QStringLiteral("Migratekde4"));
        d->mCurrentConfigVersion = grp.readEntry(QStringLiteral("Version"), 0);
        if (d->mCurrentConfigVersion < d->mMigrateApplicationVersion) {
            return true;
        } else {
            return false;
        }
    }
    return true;
}

void MigrateApplicationFiles::insertMigrateInfo(const MigrateFileInfo &info)
{
    if (info.isValid()) {
        d->mMigrateInfoList.append(info);
    }
}
07070100000094000081A40000000200000002000000015CDAA39400000860000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/migrateapplicationfiles.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MIGRATEAPPLICATIONFILE_H
#define MIGRATEAPPLICATIONFILE_H

#include <QObject>
#include <kdelibs4migration.h>
#include "migratefileinfo.h"
#include "pimcommon_export.h"
namespace PimCommon {
class MigrateApplicationFilesPrivate;
class PIMCOMMON_EXPORT MigrateApplicationFiles : public QObject
{
    Q_OBJECT
public:
    explicit MigrateApplicationFiles(QObject *parent = nullptr);
    ~MigrateApplicationFiles();

Q_REQUIRED_RESULT bool start();
    Q_REQUIRED_RESULT bool checkIfNecessary();
    void insertMigrateInfo(const MigrateFileInfo &info);

Q_REQUIRED_RESULT int version() const;
    void setVersion(int version);

Q_REQUIRED_RESULT QString configFileName() const;
    void setConfigFileName(const QString &configFileName);

Q_REQUIRED_RESULT int currentConfigVersion() const;
    void setCurrentConfigVersion(int currentConfigVersion);

Q_REQUIRED_RESULT QString applicationName() const;
    void setApplicationName(const QString &applicationName);

Q_SIGNALS:
    void migrateDone();

private:
    bool copyRecursively(const QString &srcFilePath, const QString &tgtFilePath);
    void finished();
    void writeConfig();
    void migrateFolder(const MigrateFileInfo &info);
    void migrateFile(const MigrateFileInfo &info);
    bool migrateConfig();
    MigrateApplicationFilesPrivate *const d;
};
}
#endif // MIGRATEAPPLICATIONFILE_H
07070100000095000081A40000000200000002000000015CDAA394000006BE000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/migratefileinfo.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "migratefileinfo.h"
using namespace PimCommon;

MigrateFileInfo::MigrateFileInfo()
    : mVersion(-1)
    , mFolder(false)
{
}

bool MigrateFileInfo::isValid() const
{
    return !mType.isEmpty() && !mPath.isEmpty();
}

int MigrateFileInfo::version() const
{
    return mVersion;
}

void MigrateFileInfo::setVersion(int version)
{
    mVersion = version;
}

QString MigrateFileInfo::type() const
{
    return mType;
}

void MigrateFileInfo::setType(const QString &type)
{
    mType = type;
}

QString MigrateFileInfo::path() const
{
    return mPath;
}

void MigrateFileInfo::setPath(const QString &path)
{
    mPath = path;
}

bool MigrateFileInfo::folder() const
{
    return mFolder;
}

void MigrateFileInfo::setFolder(bool folder)
{
    mFolder = folder;
}

QStringList MigrateFileInfo::filePatterns() const
{
    return mFilePattern;
}

void MigrateFileInfo::setFilePatterns(const QStringList &filePattern)
{
    mFilePattern = filePattern;
}
07070100000096000081A40000000200000002000000015CDAA39400000655000000000000000000000000000000000000005700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/migration/migratefileinfo.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MIGRATEFILEINFO_H
#define MIGRATEFILEINFO_H

#include <QString>
#include <QStringList>

#include "pimcommon_export.h"
namespace PimCommon {
class PIMCOMMON_EXPORT MigrateFileInfo
{
public:
    MigrateFileInfo();

Q_REQUIRED_RESULT QString type() const;
    void setType(const QString &type);

Q_REQUIRED_RESULT QString path() const;
    void setPath(const QString &path);

Q_REQUIRED_RESULT bool folder() const;
    void setFolder(bool folder);

Q_REQUIRED_RESULT bool isValid() const;

Q_REQUIRED_RESULT int version() const;
    void setVersion(int version);

Q_REQUIRED_RESULT QStringList filePatterns() const;
    void setFilePatterns(const QStringList &filePatterns);

private:
    QStringList mFilePattern;
    QString mType;
    QString mPath;
    int mVersion;
    bool mFolder;
};
}

#endif // MIGRATEFILEINFO_H
07070100000097000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/network07070100000098000081A40000000200000002000000015CDAA3940000053A000000000000000000000000000000000000005600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/network/networkmanager.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "networkmanager.h"
#include <QNetworkConfigurationManager>
using namespace PimCommon;

Q_GLOBAL_STATIC(NetworkManager, s_pNetworkManagerSelf)

NetworkManager::NetworkManager(QObject *parent)
    : QObject(parent)
{
    mNetworkConfigureManager = new QNetworkConfigurationManager();
}

NetworkManager::~NetworkManager()
{
    delete mNetworkConfigureManager;
}

NetworkManager *NetworkManager::self()
{
    return s_pNetworkManagerSelf();
}

QNetworkConfigurationManager *NetworkManager::networkConfigureManager() const
{
    return mNetworkConfigureManager;
}
07070100000099000081A40000000200000002000000015CDAA39400000526000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/network/networkmanager.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef NetworkManager_H
#define NetworkManager_H

#include <QObject>
#include "pimcommon_export.h"
class QNetworkConfigurationManager;
namespace PimCommon {
class PIMCOMMON_EXPORT NetworkManager : public QObject
{
    Q_OBJECT
public:
    explicit NetworkManager(QObject *parent = nullptr);
    ~NetworkManager();
    static NetworkManager *self();

Q_REQUIRED_RESULT QNetworkConfigurationManager *networkConfigureManager() const;

private:
    QNetworkConfigurationManager *mNetworkConfigureManager = nullptr;
};
}

#endif // NetworkManager_H
0707010000009A000081A40000000200000002000000015CDAA394000004CD000000000000000000000000000000000000005600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/pimcommon_private_export.h/*  This file is part of the KDE project
    Copyright (C) 2017-2019 Laurent Montel <montel@kde.org>

This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef PIMCOMMONPRIVATE_EXPORT_H
#define PIMCOMMONPRIVATE_EXPORT_H

#include "pimcommon_export.h"

/* Classes which are exported only for unit tests */
#ifdef BUILD_TESTING
# ifndef PIMCOMMON_TESTS_EXPORT
#  define PIMCOMMON_TESTS_EXPORT PIMCOMMON_EXPORT
# endif
#else /* not compiling tests */
# define PIMCOMMON_TESTS_EXPORT
#endif

#endif
0707010000009B000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/settings0707010000009C000081A40000000200000002000000015CDAA39400000756000000000000000000000000000000000000005300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/settings/pimcommon.kcfg<?xml version="1.0" encoding="utf-8"?>
<kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0 http://www.kde.org/standards/kcfg/1.0/kcfg.xsd">

<kcfgfile name="pimcommonrc" />
  <group name="Autocorrect">
    <entry name="Enabled" type="Bool" key="enabled">
      <default>false</default>
    </entry>
    <entry name="UppercaseFirstCharOfSentence" type="Bool" key="upper-case-first-char-of-sentence">
      <default>false</default>
    </entry>
    <entry name="FixTwoUppercaseChars" type="Bool" key="fix-two-upper-case-chars">
      <default>false</default>
    </entry>
    <entry name="SingleSpaces" type="Bool" key="single-spaces">
      <default>false</default>
    </entry>
    <entry name="AutoFractions" type="Bool" key="auto-fractions">
      <default>false</default>
    </entry>
    <entry name="CapitalizeWeekDays" type="Bool" key="capitalize-week-days">
      <default>false</default>
    </entry>
    <entry name="AdvancedAutocorrect" type="Bool" key="advanced-autocorrect">
      <default>false</default>
    </entry>
    <entry name="ReplaceDoubleQuotes" type="Bool" key="replace-double-quotes">
      <default>false</default>
    </entry>
    <entry name="ReplaceSingleQuotes" type="Bool" key="replace-single-quotes">
      <default>false</default>
    </entry>
    <entry name="AutoFormatUrl" type="Bool" key="autoformat-url">
      <default>false</default>
    </entry>
    <entry name="AutoBoldUnderline" type="Bool" key="auto-bold-underline">
      <default>false</default>
    </entry>
    <entry name="SuperScript" type="Bool" key="super-script">
      <default>false</default>
    </entry>
    <entry name="AddNonBreakingSpaceInFrench" type="Bool" key="add-non-breaking-space">
      <default>false</default>
    </entry>
  </group>
</kcfg>

0707010000009D000081A40000000200000002000000015CDAA394000000C4000000000000000000000000000000000000006000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/settings/pimcommonsetting_base.kcfgcFile=pimcommon.kcfg
ClassName=PimCommonSettingsBase
NameSpace=PimCommon
Visibility=PIMCOMMON_EXPORT
Mutators=true
Singleton=true
ItemAccessors=true
IncludeFiles=qapplication.h,pimcommon_export.h

0707010000009E000081A40000000200000002000000015CDAA394000005E7000000000000000000000000000000000000005A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/settings/pimcommonsettings.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "pimcommonsettings.h"
#include <QTimer>

using namespace PimCommon;

PimCommonSettings *PimCommonSettings::mSelf = nullptr;

PimCommonSettings *PimCommonSettings::self()
{
    if (!mSelf) {
        mSelf = new PimCommonSettings();
        mSelf->load();
    }

return mSelf;
}

PimCommonSettings::PimCommonSettings()
{
    mConfigSyncTimer = new QTimer(this);
    mConfigSyncTimer->setSingleShot(true);
    connect(mConfigSyncTimer, &QTimer::timeout, this, &PimCommonSettings::slotSyncNow);
}

void PimCommonSettings::requestSync()
{
    if (!mConfigSyncTimer->isActive()) {
        mConfigSyncTimer->start(0);
    }
}

void PimCommonSettings::slotSyncNow()
{
    config()->sync();
}

PimCommonSettings::~PimCommonSettings()
{
}
0707010000009F000081A40000000200000002000000015CDAA39400000666000000000000000000000000000000000000005800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/settings/pimcommonsettings.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef PIMCOMMON_SETTINGS_H
#define PIMCOMMON_SETTINGS_H

#include "pimcommon_export.h"
#include "pimcommonsetting_base.h"

class QTimer;

namespace PimCommon {
class PIMCOMMON_EXPORT PimCommonSettings : public PimCommon::PimCommonSettingsBase
{
    Q_OBJECT
public:
    static PimCommonSettings *self();

/** Call this slot instead of directly @ref KConfig::sync() to
      minimize the overall config writes. Calling this slot will
      schedule a sync of the application config file using a timer, so
      that many consecutive calls can be condensed into a single
      sync, which is more efficient. */
    void requestSync();

private Q_SLOTS:
    void slotSyncNow();

private:
    PimCommonSettings();
    ~PimCommonSettings() override;
    static PimCommonSettings *mSelf;

QTimer *mConfigSyncTimer = nullptr;
};
}

#endif /* PIMCOMMON_SETTINGS_H */
070701000000A0000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/shareserviceurl070701000000A1000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/shareserviceurl/autotests070701000000A2000081A40000000200000002000000015CDAA39400000087000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/shareserviceurl/autotests/CMakeLists.txtecm_add_test(shareserviceurlmanagertest.cpp
    NAME_PREFIX "pimcommon-shareserviceurl-"
    LINK_LIBRARIES Qt5::Test KF5::PimCommon
)
070701000000A3000081A40000000200000002000000015CDAA39400001CCC000000000000000000000000000000000000007400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/shareserviceurl/autotests/shareserviceurlmanagertest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "shareserviceurlmanagertest.h"
#include "../shareserviceurlmanager.h"
#include <QTest>
#include <kactionmenu.h>
#include <QMenu>
ShareServiceUrlManagerTest::ShareServiceUrlManagerTest(QObject *parent)
    : QObject(parent)
{
}

ShareServiceUrlManagerTest::~ShareServiceUrlManagerTest()
{
}

void ShareServiceUrlManagerTest::shouldHaveDefaultValue()
{
    PimCommon::ShareServiceUrlManager manager;
    QVERIFY(manager.menu());
    QVERIFY(!manager.menu()->menu()->actions().isEmpty());

//Based on 0 => we need to look at PimCommon::ShareServiceUrlManager::ServiceEndType
    QCOMPARE(manager.menu()->menu()->actions().count(), (static_cast<int>(PimCommon::ShareServiceUrlManager::ServiceEndType)));
}

void ShareServiceUrlManagerTest::shouldGenerateServiceUrl_data()
{
    QTest::addColumn<QString>("title");
    QTest::addColumn<QString>("link");
    QTest::addColumn<PimCommon::ShareServiceUrlManager::ServiceType>("serviceType");
    QTest::addColumn<QUrl>("output");
    //Url is valid ?
    QTest::addColumn<bool>("valid");
    QTest::newRow("no title no link") << QString() << QString() << PimCommon::ShareServiceUrlManager::Fbook << QUrl() << false;
    QTest::newRow("no title but valid link (facebook)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Fbook
                                                        << QUrl(QStringLiteral("https://www.facebook.com/sharer.php?u=http://www.kde.org&t")) << true;
    QTest::newRow("title and valid link (facebook)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Fbook
                                                     << QUrl(QStringLiteral("https://www.facebook.com/sharer.php?u=http://www.kde.org&t=kde")) << true;

QTest::newRow("no title but valid link (twitter)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Twitter
                                                       << QUrl(QStringLiteral("https://twitter.com/share?url=http://www.kde.org&text")) << true;
    QTest::newRow("title and valid link (twitter)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Twitter
                                                    << QUrl(QStringLiteral("https://twitter.com/share?url=http://www.kde.org&text=kde")) << true;

QTest::newRow("no title but valid link (googleplus)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::GooglePlus
                                                          << QUrl(QStringLiteral("https://plus.google.com/share?url=http://www.kde.org")) << true;
    QTest::newRow("title and valid link (googleplus)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::GooglePlus
                                                       << QUrl(QStringLiteral("https://plus.google.com/share?url=http://www.kde.org")) << true;

QTest::newRow("no title but valid link (mailto)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::MailTo
                                                      << QUrl(QStringLiteral("mailto:?subject&body=http://www.kde.org")) << true;
    QTest::newRow("title and valid link (mailto)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::MailTo
                                                   << QUrl(QStringLiteral("mailto:?subject=kde&body=http://www.kde.org")) << true;

QTest::newRow("no title but valid link (linkedin)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::LinkedIn
                                                        << QUrl(QStringLiteral("http://www.linkedin.com/shareArticle?mini=true&url=http://www.kde.org&title")) << true;
    QTest::newRow("title and valid link (linkedin)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::LinkedIn
                                                     << QUrl(QStringLiteral("http://www.linkedin.com/shareArticle?mini=true&url=http://www.kde.org&title=kde")) << true;

QTest::newRow("no title but valid link (evernote)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Evernote
                                                        << QUrl(QStringLiteral("https://www.evernote.com/clip.action?url=http://www.kde.org&title")) << true;
    QTest::newRow("title and valid link (evernote)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Evernote
                                                     << QUrl(QStringLiteral("https://www.evernote.com/clip.action?url=http://www.kde.org&title=kde")) << true;

QTest::newRow("no title but valid link (pocket)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Pocket
                                                      << QUrl(QStringLiteral("https://getpocket.com/save?url=http://www.kde.org&title")) << true;
    QTest::newRow("title and valid link (pocket)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::Pocket
                                                   << QUrl(QStringLiteral("https://getpocket.com/save?url=http://www.kde.org&title=kde")) << true;

QTest::newRow("no title but valid link (livejournal)") << QString() << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::LiveJournal
                                                           << QUrl(QStringLiteral("http://www.livejournal.com/update.bml?event=http://www.kde.org&subject")) << true;
    QTest::newRow("title and valid link (livejournal)") << QStringLiteral("kde") << QStringLiteral("http://www.kde.org") << PimCommon::ShareServiceUrlManager::LiveJournal
                                                        << QUrl(QStringLiteral("http://www.livejournal.com/update.bml?event=http://www.kde.org&subject=kde")) << true;
}

void ShareServiceUrlManagerTest::shouldGenerateServiceUrl()
{
    QFETCH(QString, title);
    QFETCH(QString, link);
    QFETCH(PimCommon::ShareServiceUrlManager::ServiceType, serviceType);
    QFETCH(QUrl, output);
    QFETCH(bool, valid);

PimCommon::ShareServiceUrlManager manager;
    const QUrl urlGenerated = manager.generateServiceUrl(link, title, serviceType);
    QCOMPARE(urlGenerated, output);
    QCOMPARE(urlGenerated.isValid(), valid);
}

QTEST_MAIN(ShareServiceUrlManagerTest)
070701000000A4000081A40000000200000002000000015CDAA39400000482000000000000000000000000000000000000007200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/shareserviceurl/autotests/shareserviceurlmanagertest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef SHARESERVICEURLMANAGERTEST_H
#define SHARESERVICEURLMANAGERTEST_H

#include <QObject>

class ShareServiceUrlManagerTest : public QObject
{
    Q_OBJECT
public:
    explicit ShareServiceUrlManagerTest(QObject *parent = nullptr);
    ~ShareServiceUrlManagerTest();

private Q_SLOTS:
    void shouldHaveDefaultValue();

void shouldGenerateServiceUrl_data();
    void shouldGenerateServiceUrl();
};

#endif // SHARESERVICEURLMANAGERTEST_H
070701000000A5000081A40000000200000002000000015CDAA39400001DC2000000000000000000000000000000000000006600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/shareserviceurl/shareserviceurlmanager.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "shareserviceurlmanager.h"

#include "pimcommon_debug.h"
#include <KActionMenu>
#include <KLocalizedString>
#include <QMenu>
#include <QDesktopServices>
#include <QUrlQuery>

using namespace PimCommon;

class PimCommon::ShareServiceUrlManagerPrivate
{
public:
    explicit ShareServiceUrlManagerPrivate(ShareServiceUrlManager *qq)
        : mMenu(nullptr)
        , q(qq)
    {
    }

QIcon typeToIcon(ShareServiceUrlManager::ServiceType type) const;
    QString typeToI18n(ShareServiceUrlManager::ServiceType type) const;
    void initializeMenu();
    KActionMenu *mMenu = nullptr;
    ShareServiceUrlManager *q = nullptr;
};

void ShareServiceUrlManagerPrivate::initializeMenu()
{
    mMenu = new KActionMenu(QIcon::fromTheme(QStringLiteral("document-share")), i18n("Share On..."), q);
    for (int i = 0; i < ShareServiceUrlManager::ServiceEndType; ++i) {
        const ShareServiceUrlManager::ServiceType type = static_cast<ShareServiceUrlManager::ServiceType>(i);
        QAction *action = new QAction(i18nc("@action:inmenu Share On...", "%1", typeToI18n(type)), q);
        action->setData(QVariant::fromValue(type));
        const QIcon icon = typeToIcon(type);
        if (!icon.isNull()) {
            action->setIcon(icon);
        }
        mMenu->addAction(action);
    }
    q->connect(mMenu->menu(), &QMenu::triggered, q, &ShareServiceUrlManager::slotSelectServiceUrl);
}

QIcon ShareServiceUrlManagerPrivate::typeToIcon(ShareServiceUrlManager::ServiceType type) const
{
    QIcon icon;
    switch (type) {
    case ShareServiceUrlManager::Fbook:
        icon = QIcon::fromTheme(QStringLiteral("im-facebook"));
        break;
    case ShareServiceUrlManager::Twitter:
        icon = QIcon::fromTheme(QStringLiteral("im-twitter"));
        break;
    case ShareServiceUrlManager::GooglePlus:
        icon = QIcon::fromTheme(QStringLiteral("im-google"));
        break;
    case ShareServiceUrlManager::MailTo:
        icon = QIcon::fromTheme(QStringLiteral("kmail"));
        break;
    case ShareServiceUrlManager::LinkedIn:
        break;
    case ShareServiceUrlManager::Evernote:
        break;
    case ShareServiceUrlManager::Pocket:
        break;
    case ShareServiceUrlManager::LiveJournal:
        break;
    case ShareServiceUrlManager::ServiceEndType:
        qCWarning(PIMCOMMON_LOG) << "icon for unknow type requested. It's a bug.";
        break;
    }

return icon;
}

QString ShareServiceUrlManagerPrivate::typeToI18n(ShareServiceUrlManager::ServiceType type) const
{
    QString str;
    switch (type) {
    case ShareServiceUrlManager::Fbook:
        str = i18n("Facebook");
        break;
    case ShareServiceUrlManager::Twitter:
        str = i18n("Twitter");
        break;
    case ShareServiceUrlManager::GooglePlus:
        str = i18n("Google Plus");
        break;
    case ShareServiceUrlManager::MailTo:
        str = i18n("Mail");
        break;
    case ShareServiceUrlManager::LinkedIn:
        str = i18n("LinkedIn");
        break;
    case ShareServiceUrlManager::Evernote:
        str = i18n("Evernote");
        break;
    case ShareServiceUrlManager::Pocket:
        str = i18n("Pocket");
        break;
    case ShareServiceUrlManager::LiveJournal:
        str = i18n("LiveJournal");
        break;
    case ShareServiceUrlManager::ServiceEndType:
        qCWarning(PIMCOMMON_LOG) << "text for unknow type requested. It's a bug.";
        break;
    }
    return str;
}

ShareServiceUrlManager::ShareServiceUrlManager(QObject *parent)
    : QObject(parent)
    , d(new PimCommon::ShareServiceUrlManagerPrivate(this))
{
    d->initializeMenu();
}

ShareServiceUrlManager::~ShareServiceUrlManager()
{
    delete d;
}

KActionMenu *ShareServiceUrlManager::menu() const
{
    return d->mMenu;
}

void ShareServiceUrlManager::slotSelectServiceUrl(QAction *act)
{
    if (act) {
        const ServiceType type = act->data().value<PimCommon::ShareServiceUrlManager::ServiceType>();
        Q_EMIT serviceUrlSelected(type);
    }
}

QUrl ShareServiceUrlManager::generateServiceUrl(const QString &link, const QString &title, ServiceType type)
{
    QUrl url;
    if (link.isEmpty()) {
        return url;
    }
    switch (type) {
    case Fbook:
    {
        url.setUrl(QStringLiteral("https://www.facebook.com/sharer.php"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("u"), link);
        urlQuery.addQueryItem(QStringLiteral("t"), title);
        url.setQuery(urlQuery);
        break;
    }
    case Twitter:
    {
        url.setUrl(QStringLiteral("https://twitter.com/share"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("url"), link);
        urlQuery.addQueryItem(QStringLiteral("text"), title);
        url.setQuery(urlQuery);
        break;
    }
    case GooglePlus:
    {
        url.setUrl(QStringLiteral("https://plus.google.com/share"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("url"), link);
        url.setQuery(urlQuery);
        break;
    }
    case MailTo:
    {
        url.setUrl(QStringLiteral("mailto:"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("subject"), title);
        urlQuery.addQueryItem(QStringLiteral("body"), link);
        url.setQuery(urlQuery);
        break;
    }
    case LinkedIn:
    {
        url.setUrl(QStringLiteral("http://www.linkedin.com/shareArticle"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("mini"), QStringLiteral("true"));
        urlQuery.addQueryItem(QStringLiteral("url"), link);
        urlQuery.addQueryItem(QStringLiteral("title"), title);
        url.setQuery(urlQuery);
        break;
    }
    case Evernote:
    {
        url.setUrl(QStringLiteral("https://www.evernote.com/clip.action"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("url"), link);
        urlQuery.addQueryItem(QStringLiteral("title"), title);
        url.setQuery(urlQuery);
        break;
    }
    case Pocket:
    {
        url.setUrl(QStringLiteral("https://getpocket.com/save"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("url"), link);
        urlQuery.addQueryItem(QStringLiteral("title"), title);
        url.setQuery(urlQuery);
        break;
    }
    case LiveJournal:
    {
        url.setUrl(QStringLiteral("http://www.livejournal.com/update.bml"));
        QUrlQuery urlQuery;
        urlQuery.addQueryItem(QStringLiteral("event"), link);
        urlQuery.addQueryItem(QStringLiteral("subject"), title);
        url.setQuery(urlQuery);
        break;
    }
    case ServiceEndType:
        break;
    }
    return url;
}

void ShareServiceUrlManager::openUrl(const QUrl &url)
{
    if (url.isValid()) {
        QDesktopServices::openUrl(url);
    } else {
        qCDebug(PIMCOMMON_LOG) << "url is invalid.";
    }
}
070701000000A6000081A40000000200000002000000015CDAA3940000075E000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/shareserviceurl/shareserviceurlmanager.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef SHARESERVICEURLMANAGER_H
#define SHARESERVICEURLMANAGER_H

#include <QObject>
#include "pimcommon_export.h"
#include <QUrl>

class KActionMenu;
class QAction;
namespace PimCommon {
class ShareServiceUrlManagerPrivate;
class PIMCOMMON_EXPORT ShareServiceUrlManager : public QObject
{
    Q_OBJECT
public:
    explicit ShareServiceUrlManager(QObject *parent = nullptr);
    ~ShareServiceUrlManager();
    enum ServiceType {
        Fbook = 0,
        Twitter,
        GooglePlus,
        MailTo,
        LinkedIn,
        Evernote,
        Pocket,
        LiveJournal,
        ServiceEndType
    };

Q_REQUIRED_RESULT KActionMenu *menu() const;

Q_REQUIRED_RESULT QUrl generateServiceUrl(const QString &link, const QString &title, ServiceType type);

void openUrl(const QUrl &url);

public Q_SLOTS:
    void slotSelectServiceUrl(QAction *act);

Q_SIGNALS:
    void serviceUrlSelected(PimCommon::ShareServiceUrlManager::ServiceType type);

private:
    ShareServiceUrlManagerPrivate *const d;
};
}
Q_DECLARE_METATYPE(PimCommon::ShareServiceUrlManager::ServiceType)
#endif // SHARESERVICEURLMANAGER_H
070701000000A7000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/templatewidgets070701000000A8000081A40000000200000002000000015CDAA394000010C1000000000000000000000000000000000000006200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/templatewidgets/templateeditdialog.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "templateeditdialog.h"
#include "kpimtextedit/plaintexteditorwidget.h"
#include "kpimtextedit/plaintexteditor.h"

#include <KLocalizedString>
#include <KLineEdit>

#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QLabel>
#include <KSharedConfig>
#include <KConfigGroup>
#include <QDialogButtonBox>
#include <QPushButton>

using namespace PimCommon;

TemplateEditDialog::TemplateEditDialog(QWidget *parent, bool defaultTemplate)
    : QDialog(parent)
    , mOkButton(nullptr)
{
    setWindowTitle(defaultTemplate ? i18n("Default template") : i18n("Template"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QDialogButtonBox *buttonBox = nullptr;
    if (defaultTemplate) {
        buttonBox = new QDialogButtonBox(QDialogButtonBox::Close, this);
        connect(buttonBox, &QDialogButtonBox::rejected, this, &TemplateEditDialog::reject);
    } else {
        buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
        mOkButton = buttonBox->button(QDialogButtonBox::Ok);
        mOkButton->setDefault(true);
        mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
        connect(buttonBox, &QDialogButtonBox::accepted, this, &TemplateEditDialog::accept);
        connect(buttonBox, &QDialogButtonBox::rejected, this, &TemplateEditDialog::reject);
        mOkButton->setFocus();
    }
    QWidget *w = new QWidget;
    mainLayout->addWidget(w);
    mainLayout->addWidget(buttonBox);

QVBoxLayout *vbox = new QVBoxLayout;
    vbox->setContentsMargins(0, 0, 0, 0);

QHBoxLayout *hbox = new QHBoxLayout;
    QLabel *label = new QLabel(i18n("Name:"));
    hbox->addWidget(label);

mTemplateNameEdit = new KLineEdit;
    mTemplateNameEdit->setTrapReturnKey(true);
    mTemplateNameEdit->setClearButtonEnabled(!defaultTemplate);
    mTemplateNameEdit->setReadOnly(defaultTemplate);
    hbox->addWidget(mTemplateNameEdit);

vbox->addLayout(hbox);

mTextEdit = new KPIMTextEdit::PlainTextEditorWidget;
    mTextEdit->setReadOnly(defaultTemplate);
    vbox->addWidget(mTextEdit);

w->setLayout(vbox);
    if (!defaultTemplate) {
        if (mOkButton) {
            mOkButton->setEnabled(false);
        }
        connect(mTemplateNameEdit, &QLineEdit::textChanged, this, &TemplateEditDialog::slotTemplateChanged);
        connect(mTextEdit->editor(), &QPlainTextEdit::textChanged, this, &TemplateEditDialog::slotTemplateChanged);
        mTemplateNameEdit->setFocus();
    }
    readConfig();
}

TemplateEditDialog::~TemplateEditDialog()
{
    writeConfig();
}

void TemplateEditDialog::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "TemplateEditDialog");
    group.writeEntry("Size", size());
}

void TemplateEditDialog::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "TemplateEditDialog");
    const QSize sizeDialog = group.readEntry("Size", QSize(600, 400));
    if (sizeDialog.isValid()) {
        resize(sizeDialog);
    }
}

void TemplateEditDialog::slotTemplateChanged()
{
    mOkButton->setEnabled(!mTemplateNameEdit->text().trimmed().isEmpty() && !mTextEdit->editor()->toPlainText().trimmed().isEmpty());
}

void TemplateEditDialog::setScript(const QString &text)
{
    mTextEdit->setPlainText(text);
}

QString TemplateEditDialog::script() const
{
    return mTextEdit->toPlainText();
}

void TemplateEditDialog::setTemplateName(const QString &name)
{
    mTemplateNameEdit->setText(name);
}

QString TemplateEditDialog::templateName() const
{
    return mTemplateNameEdit->text();
}
070701000000A9000081A40000000200000002000000015CDAA39400000635000000000000000000000000000000000000006000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/templatewidgets/templateeditdialog.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef SIEVETEMPLATEEDITDIALOG_H
#define SIEVETEMPLATEEDITDIALOG_H

#include <QDialog>

class KLineEdit;
namespace KPIMTextEdit {
class PlainTextEditorWidget;
}
namespace PimCommon {
class TemplateEditDialog : public QDialog
{
    Q_OBJECT
public:
    explicit TemplateEditDialog(QWidget *parent = nullptr, bool defaultTemplate = false);
    ~TemplateEditDialog();

void setTemplateName(const QString &name);
    Q_REQUIRED_RESULT QString templateName() const;

void setScript(const QString &);
    Q_REQUIRED_RESULT QString script() const;

private:
    void slotTemplateChanged();
    void readConfig();
    void writeConfig();
    KPIMTextEdit::PlainTextEditorWidget *mTextEdit = nullptr;
    KLineEdit *mTemplateNameEdit = nullptr;
    QPushButton *mOkButton = nullptr;
};
}

#endif // TEMPLATEEDITDIALOG_H
070701000000AA000081A40000000200000002000000015CDAA39400003263000000000000000000000000000000000000006200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/templatewidgets/templatelistwidget.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "templatelistwidget.h"
#include "templateeditdialog.h"

#include <KConfigGroup>
#include <KSharedConfig>
#include <KMessageBox>
#include <KLocalizedString>
#include <QMenu>
#include <KNS3/DownloadDialog>
#include <KAuthorized>
#include <QIcon>

#include <QListWidgetItem>
#include <QPointer>
#include <QMimeData>
#include <QDropEvent>
#include <QFileDialog>

namespace PimCommon {
class TemplateListWidgetPrivate
{
public:
    TemplateListWidgetPrivate(const QString &configName, TemplateListWidget *qq)
        : dirty(false)
        , config(KSharedConfig::openConfig(configName, KConfig::NoGlobals))
        , q(qq)
    {
    }

~TemplateListWidgetPrivate()
    {
        save();
    }

void createListWidgetItem(const QString &name, const QString &text, bool isDefaultTemplate)
    {
        QListWidgetItem *item = new QListWidgetItem(name, q);
        item->setData(TemplateListWidget::Text, text);
        item->setData(TemplateListWidget::DefaultTemplate, isDefaultTemplate);
        q->setCurrentItem(item);
    }

void slotAdd()
    {
        QString templateName;
        QString templateScript;
        if (q->addNewTemplate(templateName, templateScript)) {
            createListWidgetItem(templateName, templateScript, false);
            dirty = true;
        }
    }

void slotInsertNewTemplate(const QString &newTemplateScript)
    {
        QString templateName;
        QString templateScript = newTemplateScript;
        if (q->modifyTemplate(templateName, templateScript, false)) {
            createListWidgetItem(templateName, templateScript, false);
            dirty = true;
        }
    }

void slotRemove()
    {
        if (KMessageBox::Yes == KMessageBox::questionYesNo(q, i18n("Do you want to delete selected template?"), i18n("Delete template"))) {
            const QList<QListWidgetItem *> lstSelectedItems = q->selectedItems();
            for (QListWidgetItem *item : lstSelectedItems) {
                if (item->data(TemplateListWidget::DefaultTemplate).toBool() == false) {
                    delete item;
                }
            }
            dirty = true;
        }
    }

void slotModify()
    {
        QListWidgetItem *item = q->currentItem();
        if (item) {
            const bool defaultTemplate = item->data(TemplateListWidget::DefaultTemplate).toBool();

QString templateName = item->text();
            QString templateScript = item->data(TemplateListWidget::Text).toString();
            if (q->modifyTemplate(templateName, templateScript, defaultTemplate)) {
                if (!defaultTemplate) {
                    item->setText(templateName);
                    item->setData(TemplateListWidget::Text, templateScript);
                    dirty = true;
                }
            }
        }
    }

void slotInsertTemplate()
    {
        QListWidgetItem *item = q->currentItem();
        if (item) {
            const QString templateScript = item->data(TemplateListWidget::Text).toString();
            Q_EMIT q->insertTemplate(templateScript);
        }
    }

void slotDuplicate()
    {
        QListWidgetItem *item = q->currentItem();
        if (item) {
            QStringList name;
            name.reserve(q->count());
            for (int i = 0; i < q->count(); ++i) {
                name.append(q->item(i)->text());
            }
            QString templateName = item->text() + QLatin1String(" (%1)");
            QString newName;
            int i = 1;
            do {
                newName = templateName.arg(i);
                i++;
            } while (name.contains(newName));

const QString templateScript = item->data(TemplateListWidget::Text).toString();
            createListWidgetItem(newName, templateScript, false);
            dirty = true;
            slotModify();
        }
    }

void slotImportTemplates()
    {
        const QString templateFile = QFileDialog::getOpenFileName(q, i18n("Import Template"));
        if (!templateFile.isEmpty()) {
            KConfig conf(templateFile, KConfig::SimpleConfig);
            loadTemplates(&conf);
        }
    }

void slotExportTemplates()
    {
        const QString templateFile = QFileDialog::getSaveFileName(q, i18n("Export Template"));
        if (!templateFile.isEmpty()) {
            KConfig conf(templateFile, KConfig::SimpleConfig);
            saveTemplates(&conf);
        }
    }

void slotContextMenu(const QPoint &pos)
    {
        const QList<QListWidgetItem *> lstSelectedItems = q->selectedItems();
        const bool listSelectedIsEmpty = lstSelectedItems.isEmpty();
        QMenu *menu = new QMenu(q);

if (!listSelectedIsEmpty) {
            menu->addAction(i18n("Insert template"), q, [this]() {
                    slotInsertTemplate();
                });
            menu->addSeparator();
        }

menu->addAction(i18n("Add..."), q, [this]() {
                slotAdd();
            });
        if (!listSelectedIsEmpty) {
            const bool defaultTemplate = lstSelectedItems.first()->data(TemplateListWidget::DefaultTemplate).toBool();
            if (lstSelectedItems.count() == 1) {
                menu->addAction(defaultTemplate ? i18n("Show...") : i18n("Modify..."), q, [this]() {
                        slotModify();
                    });
                menu->addAction(i18n("Duplicate"), q, [this]() {
                        slotDuplicate();
                    });
            }
            if (lstSelectedItems.count() == 1 && !defaultTemplate) {
                menu->addSeparator();
                menu->addAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18n("Remove"), q, [this]() {
                        slotRemove();
                    });
            }
        }
        menu->addSeparator();
        if (q->count() > 0) {
            menu->addAction(i18n("Export..."), q, [this]() {
                    slotExportTemplates();
                });
        }
        menu->addAction(i18n("Import..."), q, [this]() {
                slotImportTemplates();
            });

if (KAuthorized::authorize(QStringLiteral("ghns"))) {
            if (!knewstuffConfigName.isEmpty()) {
                menu->addSeparator();
                menu->addAction(QIcon::fromTheme(QStringLiteral("get-hot-new-stuff")), i18n("Download new Templates..."), q, [this]() {
                        slotDownloadTemplates();
                    });
            }
        }

menu->exec(q->mapToGlobal(pos));
        delete menu;
    }

void load()
    {
        q->clear();
        const QVector<PimCommon::defaultTemplate> templatesLst = q->defaultTemplates();
        for (const PimCommon::defaultTemplate &tmp : templatesLst) {
            createListWidgetItem(tmp.name, tmp.text, true);
        }
        KConfigGroup group = config.data()->group("template");
        if (group.hasKey(QStringLiteral("templateCount"))) {
            loadTemplates(config.data());
        }
        dirty = false;
    }

void loadTemplates(KConfig *configFile)
    {
        KConfigGroup group = configFile->group("template");
        if (group.hasKey(QStringLiteral("templateCount"))) {
            const int numberTemplate = group.readEntry("templateCount", 0);
            for (int i = 0; i < numberTemplate; ++i) {
                KConfigGroup group = configFile->group(QStringLiteral("templateDefine_%1").arg(i));
                const QString name = group.readEntry("Name", QString());
                const QString text = group.readEntry("Text", QString());

createListWidgetItem(name, text, false);
            }
        } else {
            KMessageBox::error(q, i18n("\'%1\' is not a template file", configFile->name()), i18n("Load Template"));
        }
    }

void saveTemplates(KConfig *configFile)
    {
        // clear everything
        const QStringList lst = configFile->groupList();
        for (const QString &group : lst) {
            configFile->deleteGroup(group);
        }
        int numberOfTemplate = 0;
        for (int i = 0; i < q->count(); ++i) {
            QListWidgetItem *templateItem = q->item(i);
            if (templateItem->data(TemplateListWidget::DefaultTemplate).toBool() == false) {
                KConfigGroup group = configFile->group(QStringLiteral("templateDefine_%1").arg(numberOfTemplate));
                group.writeEntry("Name", templateItem->text());
                group.writeEntry("Text", templateItem->data(TemplateListWidget::Text));
                ++numberOfTemplate;
            }
        }
        KConfigGroup group = configFile->group("template");
        group.writeEntry("templateCount", numberOfTemplate);
        configFile->sync();
    }

void slotDownloadTemplates()
    {
        QPointer<KNS3::DownloadDialog> downloadThemesDialog = new KNS3::DownloadDialog(knewstuffConfigName);
        downloadThemesDialog->exec();
        delete downloadThemesDialog;
    }

void save()
    {
        if (!dirty) {
            return;
        }

saveTemplates(config.data());
        dirty = false;
    }

QString knewstuffConfigName;
    bool dirty;
    KSharedConfig::Ptr config;
    TemplateListWidget *q;
};

TemplateListWidget::TemplateListWidget(const QString &configName, QWidget *parent)
    : QListWidget(parent)
    , d(new TemplateListWidgetPrivate(configName, this))
{
    setContextMenuPolicy(Qt::CustomContextMenu);
    setDragDropMode(QAbstractItemView::DragDrop);

connect(this, &TemplateListWidget::customContextMenuRequested, this, [this](const QPoint &p) {
            d->slotContextMenu(p);
        });
    connect(this, &TemplateListWidget::doubleClicked, this, [this]() {
            d->slotModify();
        });
    connect(this, &TemplateListWidget::insertNewTemplate, this, [this](const QString &tmp) {
            d->slotInsertNewTemplate(tmp);
        });
}

TemplateListWidget::~TemplateListWidget()
{
    delete d;
}

void TemplateListWidget::loadTemplates()
{
    d->load();
}

QVector<defaultTemplate> TemplateListWidget::defaultTemplates()
{
    return QVector<PimCommon::defaultTemplate>();
}

QStringList TemplateListWidget::mimeTypes() const
{
    const QStringList lst{
        QStringLiteral("text/plain")
    };
    return lst;
}

QMimeData *TemplateListWidget::mimeData(const QList<QListWidgetItem *> items) const
{
    if (items.isEmpty()) {
        return nullptr;
    }
    QMimeData *mimeData = new QMimeData();
    QListWidgetItem *item = items.first();
    mimeData->setText(item->data(TemplateListWidget::Text).toString());
    return mimeData;
}

bool TemplateListWidget::addNewTemplate(QString &templateName, QString &templateScript)
{
    QPointer<TemplateEditDialog> dlg = new TemplateEditDialog(this);
    bool result = false;
    if (dlg->exec()) {
        templateName = dlg->templateName();
        templateScript = dlg->script();
        result = true;
    }
    delete dlg;
    return result;
}

bool TemplateListWidget::modifyTemplate(QString &templateName, QString &templateScript, bool defaultTemplate)
{
    QPointer<TemplateEditDialog> dlg = new TemplateEditDialog(this, defaultTemplate);
    dlg->setTemplateName(templateName);
    dlg->setScript(templateScript);
    bool result = false;
    if (dlg->exec()) {
        if (!defaultTemplate) {
            templateName = dlg->templateName();
            templateScript = dlg->script();
        }
        result = true;
    }
    delete dlg;
    return result;
}

void TemplateListWidget::dropEvent(QDropEvent *event)
{
    if (event->source() == this) {
        event->ignore();
        return;
    }
    if (event->mimeData()->hasText()) {
        event->setDropAction(Qt::CopyAction);
        Q_EMIT insertNewTemplate(event->mimeData()->text());
        event->accept();
    }
    QListWidget::dropEvent(event);
}

void TemplateListWidget::setKNewStuffConfigFile(const QString &configName)
{
    d->knewstuffConfigName = configName;
}

void TemplateListWidget::addDefaultTemplate(const QString &templateName, const QString &templateScript)
{
    d->createListWidgetItem(templateName, templateScript, true);
}
}
070701000000AB000081A40000000200000002000000015CDAA39400000948000000000000000000000000000000000000006000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/templatewidgets/templatelistwidget.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TEMPLATELISTWIDGET_H
#define TEMPLATELISTWIDGET_H

#include "pimcommon_export.h"
#include <QListWidget>

namespace PimCommon {
class TemplateListWidgetPrivate;

struct defaultTemplate {
    QString name;
    QString text;
};

class PIMCOMMON_EXPORT TemplateListWidget : public QListWidget
{
    Q_OBJECT
public:
    explicit TemplateListWidget(const QString &configName, QWidget *parent = nullptr);
    ~TemplateListWidget() override;

//Need to load template in specific class to allow to use correct defaultTemplates function
    void loadTemplates();

Q_REQUIRED_RESULT virtual QVector<PimCommon::defaultTemplate> defaultTemplates();
    Q_REQUIRED_RESULT virtual bool addNewTemplate(QString &templateName, QString &templateScript);
    Q_REQUIRED_RESULT virtual bool modifyTemplate(QString &templateName, QString &templateScript, bool defaultTemplate);

void setKNewStuffConfigFile(const QString &configName);

void addDefaultTemplate(const QString &templateName, const QString &templateScript);

protected:
    QStringList mimeTypes() const override;
    QMimeData *mimeData(const QList<QListWidgetItem *> items) const override;

void dropEvent(QDropEvent *event) override;
    enum TemplateData {
        Text = Qt::UserRole + 1,
        DefaultTemplate = Qt::UserRole + 2
    };

Q_SIGNALS:
    void insertTemplate(const QString &);
    void insertNewTemplate(const QString &);

private:
    friend class TemplateListWidgetPrivate;
    TemplateListWidgetPrivate *const d;
};
}
Q_DECLARE_TYPEINFO(PimCommon::defaultTemplate, Q_MOVABLE_TYPE);
#endif // TEMPLATELISTWIDGET_H
070701000000AC000081A40000000200000002000000015CDAA394000010B1000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/templatewidgets/templatemanager.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "templatemanager.h"
#include "templatewidgets/templatelistwidget.h"
#include "pimcommon_debug.h"

#include <KDirWatch>

#include <KConfigGroup>
#include <KConfig>

#include <QDirIterator>
#include <QStandardPaths>

using namespace PimCommon;

class PimCommon::TemplateManagerPrivate
{
public:
    QStringList mTemplatesDirectories;
    PimCommon::TemplateListWidget *mTemplateListWidget = nullptr;
    KDirWatch *mDirWatch = nullptr;
};

TemplateManager::TemplateManager(const QString &relativeTemplateDir, PimCommon::TemplateListWidget *templateListWidget)
    : QObject(templateListWidget)
    , d(new PimCommon::TemplateManagerPrivate)
{
    d->mTemplateListWidget = templateListWidget;
    d->mDirWatch = new KDirWatch(this);
    initTemplatesDirectories(relativeTemplateDir);

connect(d->mDirWatch, &KDirWatch::dirty, this, &TemplateManager::slotDirectoryChanged);
    loadTemplates(true);
}

TemplateManager::~TemplateManager()
{
    delete d;
}

void TemplateManager::slotDirectoryChanged()
{
    d->mTemplateListWidget->loadTemplates();
    loadTemplates();
}

void TemplateManager::initTemplatesDirectories(const QString &templatesRelativePath)
{
    if (!templatesRelativePath.isEmpty()) {
        d->mTemplatesDirectories = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, templatesRelativePath, QStandardPaths::LocateDirectory);
        if (d->mTemplatesDirectories.count() < 2) {
            //Make sure to add local directory
            const QString localDirectory = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + templatesRelativePath;
            if (!d->mTemplatesDirectories.contains(localDirectory)) {
                d->mTemplatesDirectories.append(localDirectory);
            }
        }
    }
}

void TemplateManager::loadTemplates(bool init)
{
    if (!init) {
        if (!d->mTemplatesDirectories.isEmpty()) {
            for (const QString &directory : qAsConst(d->mTemplatesDirectories)) {
                d->mDirWatch->removeDir(directory);
            }
        } else {
            return;
        }
    }

for (const QString &directory : qAsConst(d->mTemplatesDirectories)) {
        QDirIterator dirIt(directory, QStringList(), QDir::AllDirs | QDir::NoDotAndDotDot);
        while (dirIt.hasNext()) {
            dirIt.next();
            TemplateInfo info = loadTemplate(dirIt.filePath(), QStringLiteral("template.desktop"));
            if (info.isValid()) {
                d->mTemplateListWidget->addDefaultTemplate(info.name, info.script);
            }
        }
        d->mDirWatch->addDir(directory);
    }
    d->mDirWatch->startScan();
}

TemplateInfo TemplateManager::loadTemplate(const QString &themePath, const QString &defaultDesktopFileName)
{
    TemplateInfo info;
    const QString themeInfoFile = themePath + QDir::separator() + defaultDesktopFileName;
    KConfig config(themeInfoFile);
    KConfigGroup group(&config, QStringLiteral("Desktop Entry"));

info.name = group.readEntry("Name", QString());
    const QString filename = group.readEntry("FileName", QString());
    if (!filename.isEmpty()) {
        QFile file(themePath + QDir::separator() + filename);
        if (file.exists()) {
            if (file.open(QIODevice::ReadOnly)) {
                info.script = QString::fromUtf8(file.readAll());
            }
        }
    }
    return info;
}

void TemplateInfo::debug() const
{
    qCDebug(PIMCOMMON_LOG) << " name :" << name << " script :" << script;
}
070701000000AD000081A40000000200000002000000015CDAA3940000069E000000000000000000000000000000000000005D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/templatewidgets/templatemanager.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TEMPLATEMANAGER_H
#define TEMPLATEMANAGER_H

#include "pimcommon_export.h"
#include <QObject>

namespace PimCommon {
class TemplateListWidget;
struct TemplateInfo {
    QString name;
    QString script;
    Q_REQUIRED_RESULT bool isValid() const
    {
        return !name.isEmpty() && !script.isEmpty();
    }

void debug() const;
};
class TemplateManagerPrivate;
class PIMCOMMON_EXPORT TemplateManager : public QObject
{
    Q_OBJECT
public:
    explicit TemplateManager(const QString &relativeTemplateDir, PimCommon::TemplateListWidget *sieveTemplateWidget);
    ~TemplateManager();

private:
    void slotDirectoryChanged();
    void loadTemplates(bool init = false);
    void initTemplatesDirectories(const QString &templatesRelativePath);
    TemplateInfo loadTemplate(const QString &themePath, const QString &defaultDesktopFileName);

TemplateManagerPrivate *const d;
};
}

#endif // TEMPLATEMANAGER_H
070701000000AE000041ED0000000200000002000000045CDAA39400000000000000000000000000000000000000000000004600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator070701000000AF000081A40000000200000002000000015CDAA39400000067000000000000000000000000000000000000004C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/DEBUGIf you want to debug it, you can export KDEPIM_TRANSLATE_DEBUG => you will show a button to debug json
070701000000B0000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/autotests070701000000B1000081A40000000200000002000000015CDAA39400000093000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/autotests/CMakeLists.txtecm_add_test(translatortest.cpp
    NAME_PREFIX "pimcommon-translator-"
    LINK_LIBRARIES KF5::PimCommon Qt5::Test KF5::XmlGui KF5::PimTextEdit
)
070701000000B2000081A40000000200000002000000015CDAA3940000130B000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/autotests/translatortest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "translatortest.h"
#include "translator/translatorwidget.h"
#include "kpimtextedit/plaintexteditorwidget.h"

#include <QPushButton>

#include <QTest>
#include <qtestkeyboard.h>
#include <qtestmouse.h>
#include <QComboBox>
#include <QSignalSpy>
#include <QStandardPaths>
TranslatorTest::TranslatorTest()
{
    QStandardPaths::setTestModeEnabled(true);
}

void TranslatorTest::shouldHaveDefaultValuesOnCreation()
{
    PimCommon::TranslatorWidget edit;
    QComboBox *from = edit.findChild<QComboBox *>(QStringLiteral("from"));
    QComboBox *to = edit.findChild<QComboBox *>(QStringLiteral("to"));

PimCommon::TranslatorTextEdit *inputtext = edit.findChild<PimCommon::TranslatorTextEdit *>(QStringLiteral("inputtext"));
    KPIMTextEdit::PlainTextEditorWidget *translatedText = edit.findChild<KPIMTextEdit::PlainTextEditorWidget *>(QStringLiteral("translatedtext"));
    QPushButton *translate = edit.findChild<QPushButton *>(QStringLiteral("translate-button"));
    QPushButton *clear = edit.findChild<QPushButton *>(QStringLiteral("clear-button"));
    QPushButton *invert = edit.findChild<QPushButton *>(QStringLiteral("invert-button"));
    QVERIFY(invert);
    QVERIFY(clear);
    QVERIFY(translate);
    QVERIFY(from);
    QVERIFY(to);
    QCOMPARE(from->count() > 0, true);
    QCOMPARE(to->count() > 0, true);
    QVERIFY(inputtext);
    QVERIFY(translatedText);
    QCOMPARE(inputtext->toPlainText(), QString());
    QCOMPARE(translatedText->toPlainText(), QString());
    QCOMPARE(translate->isEnabled(), false);
}

void TranslatorTest::shouldEnableTranslateButtonWhenTextToTranslateIsNotEmpty()
{
    PimCommon::TranslatorWidget edit;

PimCommon::TranslatorTextEdit *inputtext = edit.findChild<PimCommon::TranslatorTextEdit *>(QStringLiteral("inputtext"));
    QPushButton *translate = edit.findChild<QPushButton *>(QStringLiteral("translate-button"));
    inputtext->setPlainText(QStringLiteral("Foo"));
    QCOMPARE(translate->isEnabled(), true);
}

void TranslatorTest::shouldDisableTranslateButtonAndClearTextWhenClickOnClearButton()
{
    PimCommon::TranslatorWidget edit;
    PimCommon::TranslatorTextEdit *inputtext = edit.findChild<PimCommon::TranslatorTextEdit *>(QStringLiteral("inputtext"));
    QPushButton *translate = edit.findChild<QPushButton *>(QStringLiteral("translate-button"));
    KPIMTextEdit::PlainTextEditorWidget *translatedText = edit.findChild<KPIMTextEdit::PlainTextEditorWidget *>(QStringLiteral("translatedtext"));
    inputtext->setPlainText(QStringLiteral("Foo"));
    QPushButton *clear = edit.findChild<QPushButton *>(QStringLiteral("clear-button"));
    QTest::mouseClick(clear, Qt::LeftButton);
    QCOMPARE(inputtext->toPlainText(), QString());
    QCOMPARE(translatedText->toPlainText(), QString());
    QCOMPARE(translate->isEnabled(), false);
}

void TranslatorTest::shouldInvertLanguageWhenClickOnInvertButton()
{
    PimCommon::TranslatorWidget edit;
    QComboBox *from = edit.findChild<QComboBox *>(QStringLiteral("from"));
    QComboBox *to = edit.findChild<QComboBox *>(QStringLiteral("to"));

const int fromIndex = 5;
    const int toIndex = 7;
    from->setCurrentIndex(fromIndex);
    to->setCurrentIndex(toIndex);
    QPushButton *invert = edit.findChild<QPushButton *>(QStringLiteral("invert-button"));
    QCOMPARE(fromIndex != toIndex, true);
    QTest::mouseClick(invert, Qt::LeftButton);
    const int newFromIndex = from->currentIndex();
    const int newToIndex = to->currentIndex();
    QCOMPARE(fromIndex != newFromIndex, true);
    QCOMPARE(toIndex != newToIndex, true);
}

void TranslatorTest::shouldHideWidgetWhenPressEscape()
{
    PimCommon::TranslatorWidget edit;
    edit.show();
    QVERIFY(QTest::qWaitForWindowExposed(&edit));
    QTest::keyPress(&edit, Qt::Key_Escape);
    QCOMPARE(edit.isVisible(), false);
}

void TranslatorTest::shouldEmitTranslatorWasClosedSignalWhenCloseIt()
{
    PimCommon::TranslatorWidget edit;
    edit.show();
    QVERIFY(QTest::qWaitForWindowExposed(&edit));
    QSignalSpy spy(&edit, &PimCommon::TranslatorWidget::toolsWasClosed);
    QTest::keyClick(&edit, Qt::Key_Escape);
    QCOMPARE(spy.count(), 1);
}

QTEST_MAIN(TranslatorTest)
070701000000B3000081A40000000200000002000000015CDAA394000004EA000000000000000000000000000000000000006100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/autotests/translatortest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TRANSLATORTEST_H
#define TRANSLATORTEST_H
#include <QObject>

class TranslatorTest : public QObject
{
    Q_OBJECT
public:
    TranslatorTest();

private Q_SLOTS:
    void shouldHaveDefaultValuesOnCreation();
    void shouldEnableTranslateButtonWhenTextToTranslateIsNotEmpty();
    void shouldDisableTranslateButtonAndClearTextWhenClickOnClearButton();
    void shouldInvertLanguageWhenClickOnInvertButton();
    void shouldHideWidgetWhenPressEscape();
    void shouldEmitTranslatorWasClosedSignalWhenCloseIt();
};

#endif // TRANSLATORTEST_H
070701000000B4000081A40000000200000002000000015CDAA394000025D9000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/googletranslator.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "googletranslator.h"
#include "translatorutil.h"
#include "translatordebugdialog.h"
#include <KLocalizedString>
#include "pimcommon_debug.h"
#include <QJsonParseError>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QPointer>
#include <QUrlQuery>

using namespace PimCommon;

GoogleTranslator::GoogleTranslator(QObject *parent)
    : QObject(parent)
    , mNetworkAccessManager(new QNetworkAccessManager(this))
{
    mDebug = !qEnvironmentVariableIsEmpty("KDEPIM_DEBUGGING");
    connect(mNetworkAccessManager, &QNetworkAccessManager::finished, this, &GoogleTranslator::slotTranslateFinished);
}

GoogleTranslator::~GoogleTranslator()
{
}

void GoogleTranslator::setParentWidget(QWidget *parent)
{
    mParentWidget = parent;
}

void GoogleTranslator::setInputText(const QString &text)
{
    mInputText = text;
}

void GoogleTranslator::setFrom(const QString &language)
{
    mFrom = language;
}

void GoogleTranslator::setTo(const QString &language)
{
    mTo = language;
}

QString GoogleTranslator::resultTranslate() const
{
    return mResult;
}

QMap<QString, QMap<QString, QString> > GoogleTranslator::initListLanguage(QComboBox *from)
{
    QMap<QString, QMap<QString, QString> > listLanguage;

TranslatorUtil translatorUtil;
    QList<QPair<QString, QString> > fullListLanguage;
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::automatic));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::en));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::nl));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::fr));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::de));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::el));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::it));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ja));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ko));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::pt));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ru));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::es));

fullListLanguage.append(translatorUtil.pair(TranslatorUtil::af));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::sq));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ar));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::hy));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::az));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::eu));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::be));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::bg));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ca));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::zh_cn_google)); // For google only
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::zh_tw_google)); // For google only
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::hr));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::cs));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::da));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::et));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::tl));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::fi));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::gl));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ka));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ht));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::iw));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::hi));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::hu));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::is));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::id));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ga));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::lv));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::lt));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::mk));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ms));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::mt));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::no));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::fa));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::pl));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ro));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::sr));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::sk));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::sl));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::sw));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::sv));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::th));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::tr));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::uk));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::ur));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::vi));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::cy));
    fullListLanguage.append(translatorUtil.pair(TranslatorUtil::yi));
    const int fullListLanguageSize(fullListLanguage.count());
    for (int i = 0; i < fullListLanguageSize; ++i) {
        const QPair<QString, QString> currentLanguage = fullListLanguage.at(i);
        translatorUtil.addItemToFromComboBox(from, currentLanguage);

QMap<QString, QString> toList;
        for (int j = 0; j < fullListLanguageSize; ++j) {
            if (j != 0 && j != i) { //don't add auto and current language
                translatorUtil.addPairToMap(toList, fullListLanguage.at(j));
            }
        }
        listLanguage.insert(currentLanguage.second, toList);
    }

return listLanguage;
}

void GoogleTranslator::translate()
{
    if (mFrom == mTo) {
        Q_EMIT translateFailed(false, i18n("You used same language for from and to language."));
        return;
    }

mResult.clear();

QUrlQuery urlQuery;
    urlQuery.addQueryItem(QStringLiteral("client"), QStringLiteral("gtx"));
    urlQuery.addQueryItem(QStringLiteral("sl"), mFrom);
    urlQuery.addQueryItem(QStringLiteral("tl"), mTo);
    urlQuery.addQueryItem(QStringLiteral("dt"), QStringLiteral("t"));
    urlQuery.addQueryItem(QStringLiteral("q"), mInputText);

QUrl url;
    url.setQuery(urlQuery);
    url.setScheme(QStringLiteral("https"));
    url.setHost(QStringLiteral("translate.googleapis.com"));
    url.setPath(QStringLiteral("/translate_a/single"));
    const QNetworkRequest request(url);

QNetworkReply *reply = mNetworkAccessManager->get(request);
    connect(reply, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &GoogleTranslator::slotError);
}

void GoogleTranslator::slotError(QNetworkReply::NetworkError /*error*/)
{
    Q_EMIT translateFailed(false);
}

void GoogleTranslator::slotTranslateFinished(QNetworkReply *reply)
{
    mResult.clear();
    mJsonData = QString::fromUtf8(reply->readAll());
    reply->deleteLater();
    //  jsonData contains arrays like this: ["foo",,"bar"]
    //  but this is not valid JSON for QJSON, it expects empty strings: ["foo","","bar"]
    mJsonData = mJsonData.replace(QRegExp(QLatin1String(",{3,3}")), QStringLiteral(",\"\",\"\","));
    mJsonData = mJsonData.replace(QRegExp(QLatin1String(",{2,2}")), QStringLiteral(",\"\","));
    //qCDebug(PIMCOMMON_LOG) << mJsonData;

QJsonParseError parsingError;
    const QJsonDocument jsonDoc = QJsonDocument::fromJson(mJsonData.toUtf8(), &parsingError);
    if (parsingError.error != QJsonParseError::NoError || jsonDoc.isNull()) {
        Q_EMIT translateFailed(false);
        return;
    }
    const QVariantList json = jsonDoc.toVariant().toList();
    if (mDebug) {
        mJsonDebug = QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Indented));
    }
    for (const QVariant &level0 : json) {
        const QVariantList listLevel0 = level0.toList();
        if (listLevel0.isEmpty()) {
            continue;
        }
        for (const QVariant &level1 : listLevel0) {
            if (level1.toList().size() <= 2) {
                continue;
            }
            mResult += level1.toList().at(0).toString();
        }
    }
    Q_EMIT translateDone();
}

void GoogleTranslator::debug()
{
    if (mDebug) {
        QPointer<TranslatorDebugDialog> dlg = new TranslatorDebugDialog(mParentWidget);
        dlg->setDebug(mJsonDebug);
        dlg->exec();
        delete dlg;
    }
}

void GoogleTranslator::clear()
{
    mJsonData.clear();
}
070701000000B5000081A40000000200000002000000015CDAA394000007EB000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/googletranslator.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef GOOGLETRANSLATOR_H
#define GOOGLETRANSLATOR_H

#include <QObject>
#include <QNetworkReply>
class QNetworkAccessManager;
class QComboBox;
class QNetworkReply;

namespace PimCommon {
class GoogleTranslator : public QObject
{
    Q_OBJECT
public:
    explicit GoogleTranslator(QObject *parent = nullptr);
    ~GoogleTranslator();

void setParentWidget(QWidget *parent);

Q_REQUIRED_RESULT QMap<QString, QMap<QString, QString> > initListLanguage(QComboBox *from);
    void translate();
    void debug();
    void clear();

Q_REQUIRED_RESULT QString resultTranslate() const;
    void setInputText(const QString &text);
    void setFrom(const QString &language);
    void setTo(const QString &language);

private Q_SLOTS:
    void slotTranslateFinished(QNetworkReply *);
    void slotError(QNetworkReply::NetworkError /*error*/);

Q_SIGNALS:
    void translateDone();
    void translateFailed(bool result, const QString &errorMessage = QString());

private:
    QString mInputText;
    QString mFrom;
    QString mTo;
    QString mResult;
    QString mJsonData;
    QString mJsonDebug;
    QNetworkAccessManager *mNetworkAccessManager = nullptr;
    QWidget *mParentWidget = nullptr;
    bool mDebug = false;
};
}

#endif // GOOGLETRANSLATOR_H
070701000000B6000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/tests070701000000B7000081A40000000200000002000000015CDAA394000000B6000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/tests/CMakeLists.txtset(translator_gui_SRCS translator_gui.cpp)
add_executable(translator_gui ${translator_gui_SRCS})
target_link_libraries(translator_gui
  KF5::PimCommon KF5::PimTextEdit KF5::I18n
)

070701000000B8000081A40000000200000002000000015CDAA394000004A9000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/tests/translator_gui.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "translator/translatorwidget.h"

#include <QApplication>
#include <QCommandLineParser>
#include <QStandardPaths>

PimCommon::TranslatorWidget *w = new PimCommon::TranslatorWidget();
    w->show();
    app.exec();
    delete w;
    return 0;
}
070701000000B9000081A40000000200000002000000015CDAA39400000ADF000000000000000000000000000000000000006000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/translatordebugdialog.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "translatordebugdialog.h"
#include "util/pimutil.h"
#include "kpimtextedit/plaintexteditorwidget.h"

#include <KLocalizedString>
#include <KConfigGroup>
#include <KSharedConfig>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>

TranslatorDebugDialog::TranslatorDebugDialog(QWidget *parent)
    : QDialog(parent)
{
    setWindowTitle(i18n("Translator Debug"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);

QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close, this);
    mUser1Button = new QPushButton(this);
    buttonBox->addButton(mUser1Button, QDialogButtonBox::ActionRole);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &TranslatorDebugDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &TranslatorDebugDialog::reject);
    mUser1Button->setText(i18n("Save As..."));
    connect(mUser1Button, &QPushButton::clicked, this, &TranslatorDebugDialog::slotSaveAs);

mEdit = new KPIMTextEdit::PlainTextEditorWidget(this);
    mEdit->setReadOnly(true);
    mainLayout->addWidget(mEdit);
    mainLayout->addWidget(buttonBox);

readConfig();
    mUser1Button->setEnabled(!mEdit->isEmpty());
}

TranslatorDebugDialog::~TranslatorDebugDialog()
{
    writeConfig();
}

void TranslatorDebugDialog::setDebug(const QString &debugStr)
{
    mEdit->setPlainText(debugStr);
    mUser1Button->setEnabled(!debugStr.isEmpty());
}

void TranslatorDebugDialog::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "TranslatorDebugDialog");
    const QSize sizeDialog = group.readEntry("Size", QSize(800, 600));
    if (sizeDialog.isValid()) {
        resize(sizeDialog);
    }
}

void TranslatorDebugDialog::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "TranslatorDebugDialog");
    group.writeEntry("Size", size());
}

void TranslatorDebugDialog::slotSaveAs()
{
    const QString filter = i18n("All Files (*)");
    PimCommon::Util::saveTextAs(mEdit->toPlainText(), filter, this);
}
070701000000BA000081A40000000200000002000000015CDAA39400000535000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/translatordebugdialog.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TRANSLATORDEBUGDIALOG_H
#define TRANSLATORDEBUGDIALOG_H

#include <QDialog>

namespace KPIMTextEdit {
class PlainTextEditorWidget;
}
class TranslatorDebugDialog : public QDialog
{
    Q_OBJECT
public:
    explicit TranslatorDebugDialog(QWidget *parent = nullptr);
    ~TranslatorDebugDialog();

void setDebug(const QString &debugStr);

private:
    void slotSaveAs();
    void readConfig();
    void writeConfig();
    KPIMTextEdit::PlainTextEditorWidget *mEdit = nullptr;
    QPushButton *mUser1Button = nullptr;
};

#endif // TRANSLATORDEBUGDIALOG_H
070701000000BB000081A40000000200000002000000015CDAA39400001F6E000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/translatorutil.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "translatorutil.h"
#include <KLocalizedString>
#include <QComboBox>
using namespace PimCommon;

TranslatorUtil::TranslatorUtil()
{
}

QPair<QString, QString> TranslatorUtil::pair(TranslatorUtil::languages lang)
{
    QPair<QString, QString> ret;
    switch (lang) {
    case automatic:
        ret = QPair<QString, QString>(i18n("Detect language"), QStringLiteral("auto"));
        break;
    case en:
        ret = QPair<QString, QString>(i18n("English"), QStringLiteral("en"));
        break;
    case zh:
        ret = QPair<QString, QString>(i18n("Chinese (Simplified)"), QStringLiteral("zh"));
        break;
    case zt:
        ret = QPair<QString, QString>(i18n("Chinese (Traditional)"), QStringLiteral("zt"));
        break;
    case nl:
        ret = QPair<QString, QString>(i18n("Dutch"), QStringLiteral("nl"));
        break;
    case fr:
        ret = QPair<QString, QString>(i18n("French"), QStringLiteral("fr"));
        break;
    case de:
        ret = QPair<QString, QString>(i18n("German"), QStringLiteral("de"));
        break;
    case el:
        ret = QPair<QString, QString>(i18n("Greek"), QStringLiteral("el"));
        break;
    case it:
        ret = QPair<QString, QString>(i18n("Italian"), QStringLiteral("it"));
        break;
    case ja:
        ret = QPair<QString, QString>(i18n("Japanese"), QStringLiteral("ja"));
        break;
    case ko:
        ret = QPair<QString, QString>(i18n("Korean"), QStringLiteral("ko"));
        break;
    case pt:
        ret = QPair<QString, QString>(i18n("Portuguese"), QStringLiteral("pt"));
        break;
    case ru:
        ret = QPair<QString, QString>(i18n("Russian"), QStringLiteral("ru"));
        break;
    case es:
        ret = QPair<QString, QString>(i18n("Spanish"), QStringLiteral("es"));
        break;
    case af:
        ret = QPair<QString, QString>(i18n("Afrikaans"), QStringLiteral("af"));
        break;
    case sq:
        ret = QPair<QString, QString>(i18n("Albanian"), QStringLiteral("sq"));
        break;
    case ar:
        ret = QPair<QString, QString>(i18n("Arabic"), QStringLiteral("ar"));
        break;
    case hy:
        ret = QPair<QString, QString>(i18n("Armenian"), QStringLiteral("hy"));
        break;
    case az:
        ret = QPair<QString, QString>(i18n("Azerbaijani"), QStringLiteral("az"));
        break;
    case eu:
        ret = QPair<QString, QString>(i18n("Basque"), QStringLiteral("eu"));
        break;
    case be:
        ret = QPair<QString, QString>(i18n("Belarusian"), QStringLiteral("be"));
        break;
    case bg:
        ret = QPair<QString, QString>(i18n("Bulgarian"), QStringLiteral("bg"));
        break;
    case ca:
        ret = QPair<QString, QString>(i18n("Catalan"), QStringLiteral("ca"));
        break;
    case zh_cn_google: // For google only
        ret = QPair<QString, QString>(i18n("Chinese (Simplified)"), QStringLiteral("zh-CN")); // For google only
        break;
    case zh_tw_google: // For google only
        ret = QPair<QString, QString>(i18n("Chinese (Traditional)"), QStringLiteral("zh-TW")); // For google only
        break;
    case hr:
        ret = QPair<QString, QString>(i18n("Croatian"), QStringLiteral("hr"));
        break;
    case cs:
        ret = QPair<QString, QString>(i18n("Czech"), QStringLiteral("cs"));
        break;
    case da:
        ret = QPair<QString, QString>(i18n("Danish"), QStringLiteral("da"));
        break;
    case et:
        ret = QPair<QString, QString>(i18n("Estonian"), QStringLiteral("et"));
        break;
    case tl:
        ret = QPair<QString, QString>(i18n("Filipino"), QStringLiteral("tl"));
        break;
    case fi:
        ret = QPair<QString, QString>(i18n("Finnish"), QStringLiteral("fi"));
        break;
    case gl:
        ret = QPair<QString, QString>(i18n("Galician"), QStringLiteral("gl"));
        break;
    case ka:
        ret = QPair<QString, QString>(i18n("Georgian"), QStringLiteral("ka"));
        break;
    case ht:
        ret = QPair<QString, QString>(i18n("Haitian Creole"), QStringLiteral("ht"));
        break;
    case iw:
        ret = QPair<QString, QString>(i18n("Hebrew"), QStringLiteral("iw"));
        break;
    case hi:
        ret = QPair<QString, QString>(i18n("Hindi"), QStringLiteral("hi"));
        break;
    case hu:
        ret = QPair<QString, QString>(i18n("Hungarian"), QStringLiteral("hu"));
        break;
    case is:
        ret = QPair<QString, QString>(i18n("Icelandic"), QStringLiteral("is"));
        break;
    case id:
        ret = QPair<QString, QString>(i18n("Indonesian"), QStringLiteral("id"));
        break;
    case ga:
        ret = QPair<QString, QString>(i18n("Irish"), QStringLiteral("ga"));
        break;
    case lv:
        ret = QPair<QString, QString>(i18n("Latvian"), QStringLiteral("lv"));
        break;
    case lt:
        ret = QPair<QString, QString>(i18n("Lithuanian"), QStringLiteral("lt"));
        break;
    case mk:
        ret = QPair<QString, QString>(i18n("Macedonian"), QStringLiteral("mk"));
        break;
    case ms:
        ret = QPair<QString, QString>(i18n("Malay"), QStringLiteral("ms"));
        break;
    case mt:
        ret = QPair<QString, QString>(i18n("Maltese"), QStringLiteral("mt"));
        break;
    case no:
        ret = QPair<QString, QString>(i18n("Norwegian"), QStringLiteral("no"));
        break;
    case fa:
        ret = QPair<QString, QString>(i18n("Persian"), QStringLiteral("fa"));
        break;
    case pl:
        ret = QPair<QString, QString>(i18n("Polish"), QStringLiteral("pl"));
        break;
    case ro:
        ret = QPair<QString, QString>(i18n("Romanian"), QStringLiteral("ro"));
        break;
    case sr:
        ret = QPair<QString, QString>(i18n("Serbian"), QStringLiteral("sr"));
        break;
    case sk:
        ret = QPair<QString, QString>(i18n("Slovak"), QStringLiteral("sk"));
        break;
    case sl:
        ret = QPair<QString, QString>(i18n("Slovenian"), QStringLiteral("sl"));
        break;
    case sw:
        ret = QPair<QString, QString>(i18n("Swahili"), QStringLiteral("sw"));
        break;
    case sv:
        ret = QPair<QString, QString>(i18n("Swedish"), QStringLiteral("sv"));
        break;
    case th:
        ret = QPair<QString, QString>(i18n("Thai"), QStringLiteral("th"));
        break;
    case tr:
        ret = QPair<QString, QString>(i18n("Turkish"), QStringLiteral("tr"));
        break;
    case uk:
        ret = QPair<QString, QString>(i18n("Ukrainian"), QStringLiteral("uk"));
        break;
    case ur:
        ret = QPair<QString, QString>(i18n("Urdu"), QStringLiteral("ur"));
        break;
    case vi:
        ret = QPair<QString, QString>(i18n("Vietnamese"), QStringLiteral("vi"));
        break;
    case cy:
        ret = QPair<QString, QString>(i18n("Welsh"), QStringLiteral("cy"));
        break;
    case yi:
        ret = QPair<QString, QString>(i18n("Yiddish"), QStringLiteral("yi"));
        break;
    }
    return ret;
}

void PimCommon::TranslatorUtil::addPairToMap(QMap<QString, QString> &map, const QPair<QString, QString> &pair)
{
    map.insert(pair.first, pair.second);
}

void PimCommon::TranslatorUtil::addItemToFromComboBox(QComboBox *combo, const QPair<QString, QString> &pair)
{
    combo->addItem(pair.first, pair.second);
}
070701000000BC000081A40000000200000002000000015CDAA39400000853000000000000000000000000000000000000005700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/translatorutil.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TRANSLATORUTIL_H
#define TRANSLATORUTIL_H

#include <QMap>
#include <QPair>
#include <QString>

class QComboBox;

namespace PimCommon {
class TranslatorUtil
{
public:
    TranslatorUtil();

void addPairToMap(QMap<QString, QString> &map, const QPair<QString, QString> &pair);
    void addItemToFromComboBox(QComboBox *combo, const QPair<QString, QString> &pair);

enum translatorType {
        GoogleTranslator = 0
    };

enum languages {
        automatic,
        en,
        zh,
        zt,
        nl,
        fr,
        de,
        el,
        it,
        ja,
        ko,
        pt,
        ru,
        es,

af,
        sq,
        ar,
        hy,
        az,
        eu,
        be,
        bg,
        ca,
        zh_cn_google, // For google only
        zh_tw_google, // For google only
        hr,
        cs,
        da,
        et,
        tl,
        fi,
        gl,
        ka,
        ht,
        iw,
        hi,
        hu,
        is,
        id,
        ga,
        lv,
        lt,
        mk,
        ms,
        mt,
        no,
        fa,
        pl,
        ro,
        sr,
        sk,
        sl,
        sw,
        sv,
        th,
        tr,
        uk,
        ur,
        vi,
        cy,
        yi
    };
    QPair<QString, QString> pair(TranslatorUtil::languages lang);
};
}

#endif // TRANSLATORUTIL_H
070701000000BD000081A40000000200000002000000015CDAA39400003C05000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/translatorwidget.cpp/*

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "translatorwidget.h"
#include "translatorutil.h"
#include "googletranslator.h"
#include "kpimtextedit/plaintexteditorwidget.h"
#include "Libkdepim/ProgressIndicatorWidget"
#include <PimCommon/NetworkManager>

#include <QPushButton>
#include <KLocalizedString>
#include <kio/job.h>
#include <KConfigGroup>
#include <KSeparator>
#include <KMessageBox>

#include <QMimeData>
#include <QIcon>
#include <QComboBox>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QLabel>
#include <QToolButton>
#include <QKeyEvent>
#include <QShortcut>
#include <QPainter>
#include <QSplitter>
#include <KSharedConfig>
#include <QNetworkConfigurationManager>

using namespace PimCommon;

class Q_DECL_HIDDEN TranslatorWidget::TranslatorWidgetPrivate
{
public:
    TranslatorWidgetPrivate()
    {
    }

~TranslatorWidgetPrivate()
    {
        delete abstractTranslator;
    }

void initLanguage();
    void fillToCombobox(const QString &lang);

QMap<QString, QMap<QString, QString> > listLanguage;
    QByteArray data;
    TranslatorTextEdit *inputText = nullptr;
    KPIMTextEdit::PlainTextEditorWidget *translatedText = nullptr;
    TranslatorResultTextEdit *translatorResultTextEdit = nullptr;
    QComboBox *from = nullptr;
    QComboBox *to = nullptr;
    QPushButton *translate = nullptr;
    QPushButton *clear = nullptr;
    PimCommon::GoogleTranslator *abstractTranslator = nullptr;
    KPIM::ProgressIndicatorWidget *progressIndictor = nullptr;
    QPushButton *invert = nullptr;
    QSplitter *splitter = nullptr;
    bool languageSettingsChanged = false;
    bool standalone = true;
};

void TranslatorWidget::TranslatorWidgetPrivate::fillToCombobox(const QString &lang)
{
    to->clear();
    const QMap<QString, QString> list = listLanguage.value(lang);
    QMap<QString, QString>::const_iterator i = list.constBegin();
    QMap<QString, QString>::const_iterator end = list.constEnd();
    while (i != end) {
        to->addItem(i.key(), i.value());
        ++i;
    }
}

void TranslatorWidget::TranslatorWidgetPrivate::initLanguage()
{
    if (!abstractTranslator) {
        return;
    }
    listLanguage = abstractTranslator->initListLanguage(from);
}

TranslatorResultTextEdit::TranslatorResultTextEdit(QWidget *parent)
    : KPIMTextEdit::PlainTextEditor(parent)
    , mResultFailed(false)
{
    setReadOnly(true);
}

void TranslatorResultTextEdit::setResultFailed(bool failed)
{
    if (mResultFailed != failed) {
        mResultFailed = failed;
        update();
    }
}

void TranslatorResultTextEdit::paintEvent(QPaintEvent *event)
{
    if (mResultFailed) {
        QPainter p(viewport());

QFont font = p.font();
        font.setItalic(true);
        p.setFont(font);

p.setPen(Qt::red);

p.drawText(QRect(0, 0, width(), height()), Qt::AlignCenter, i18n("Problem when connecting to the translator web site."));
    } else {
        KPIMTextEdit::PlainTextEditor::paintEvent(event);
    }
}

TranslatorTextEdit::TranslatorTextEdit(QWidget *parent)
    : KPIMTextEdit::PlainTextEditor(parent)
{
}

void TranslatorTextEdit::dropEvent(QDropEvent *event)
{
    if (event->source() != this) {
        if (event->mimeData()->hasText()) {
            QTextCursor cursor = textCursor();
            cursor.beginEditBlock();
            cursor.insertText(event->mimeData()->text());
            cursor.endEditBlock();
            event->setDropAction(Qt::CopyAction);
            event->accept();
            Q_EMIT translateText();
            return;
        }
    }
    KPIMTextEdit::PlainTextEditor::dropEvent(event);
}

TranslatorWidget::TranslatorWidget(QWidget *parent)
    : QWidget(parent)
    , d(new TranslatorWidgetPrivate)
{
    init();
}

TranslatorWidget::TranslatorWidget(const QString &text, QWidget *parent)
    : QWidget(parent)
    , d(new TranslatorWidgetPrivate)
{
    init();
    d->inputText->setPlainText(text);
}

TranslatorWidget::~TranslatorWidget()
{
    disconnect(d->inputText, &TranslatorTextEdit::textChanged, this, &TranslatorWidget::slotTextChanged);
    disconnect(d->inputText, &TranslatorTextEdit::translateText, this, &TranslatorWidget::slotTranslate);
    writeConfig();
    delete d;
}

void TranslatorWidget::writeConfig()
{
    KConfigGroup myGroup(KSharedConfig::openConfig(), "TranslatorWidget");
    if (d->languageSettingsChanged) {
        myGroup.writeEntry(QStringLiteral("FromLanguage"), d->from->itemData(d->from->currentIndex()).toString());
        myGroup.writeEntry("ToLanguage", d->to->itemData(d->to->currentIndex()).toString());
    }
    myGroup.writeEntry("mainSplitter", d->splitter->sizes());
    myGroup.sync();
}

void TranslatorWidget::readConfig()
{
    KConfigGroup myGroup(KSharedConfig::openConfig(), "TranslatorWidget");
    const QString from = myGroup.readEntry(QStringLiteral("FromLanguage"));
    const QString to = myGroup.readEntry(QStringLiteral("ToLanguage"));
    if (from.isEmpty()) {
        return;
    }
    const int indexFrom = d->from->findData(from);
    if (indexFrom != -1) {
        d->from->setCurrentIndex(indexFrom);
    }
    const int indexTo = d->to->findData(to);
    if (indexTo != -1) {
        d->to->setCurrentIndex(indexTo);
    }
    const QList<int> size = {100, 400};
    d->splitter->setSizes(myGroup.readEntry("mainSplitter", size));
    d->invert->setEnabled(from != QLatin1String("auto"));
}

void TranslatorWidget::init()
{
    d->abstractTranslator = new GoogleTranslator();
    d->abstractTranslator->setParentWidget(this);
    connect(d->abstractTranslator, &PimCommon::GoogleTranslator::translateDone, this, &TranslatorWidget::slotTranslateDone);
    connect(d->abstractTranslator, &PimCommon::GoogleTranslator::translateFailed, this, &TranslatorWidget::slotTranslateFailed);

QVBoxLayout *layout = new QVBoxLayout(this);
    layout->setContentsMargins(0, 0, 0, 0);
    QHBoxLayout *hboxLayout = new QHBoxLayout;
    QToolButton *closeBtn = new QToolButton(this);
    closeBtn->setObjectName(QStringLiteral("close-button"));
    closeBtn->setIcon(QIcon::fromTheme(QStringLiteral("dialog-close")));
    closeBtn->setIconSize(QSize(16, 16));
    closeBtn->setToolTip(i18n("Close"));

#ifndef QT_NO_ACCESSIBILITY
    closeBtn->setAccessibleName(i18n("Close"));
#endif
    closeBtn->setAutoRaise(true);
    hboxLayout->addWidget(closeBtn);
    connect(closeBtn, &QToolButton::clicked, this, &TranslatorWidget::slotCloseWidget);

QLabel *label = new QLabel(i18nc("Translate from language", "From:"));
    hboxLayout->addWidget(label);
    d->from = new QComboBox;
    d->from->setMinimumWidth(50);
    d->from->setObjectName(QStringLiteral("from"));
    hboxLayout->addWidget(d->from);

label = new QLabel(i18nc("Translate to language", "To:"));
    hboxLayout->addWidget(label);
    d->to = new QComboBox;
    d->to->setMinimumWidth(50);
    d->to->setObjectName(QStringLiteral("to"));

hboxLayout->addWidget(d->to);

KSeparator *separator = new KSeparator;
    separator->setOrientation(Qt::Vertical);
    hboxLayout->addWidget(separator);

d->invert = new QPushButton(
        i18nc("Invert language choices so that from becomes to and to becomes from", "Invert"), this);
    d->invert->setObjectName(QStringLiteral("invert-button"));
    connect(d->invert, &QPushButton::clicked, this, &TranslatorWidget::slotInvertLanguage);
    hboxLayout->addWidget(d->invert);

d->clear = new QPushButton(i18n("Clear"), this);
    d->clear->setObjectName(QStringLiteral("clear-button"));
#ifndef QT_NO_ACCESSIBILITY
    d->clear->setAccessibleName(i18n("Clear"));
#endif
    connect(d->clear, &QPushButton::clicked, this, &TranslatorWidget::slotClear);
    hboxLayout->addWidget(d->clear);

d->translate = new QPushButton(i18n("Translate"));
    d->translate->setObjectName(QStringLiteral("translate-button"));
#ifndef QT_NO_ACCESSIBILITY
    d->translate->setAccessibleName(i18n("Translate"));
#endif

hboxLayout->addWidget(d->translate);
    connect(d->translate, &QPushButton::clicked, this, &TranslatorWidget::slotTranslate);

if (!qEnvironmentVariableIsEmpty("KDEPIM_DEBUGGING")) {
        QPushButton *debugButton = new QPushButton(i18n("Debug"));
        hboxLayout->addWidget(debugButton);
        connect(debugButton, &QPushButton::clicked, this, &TranslatorWidget::slotDebug);
    }

d->progressIndictor = new KPIM::ProgressIndicatorWidget(this);
    hboxLayout->addWidget(d->progressIndictor);

hboxLayout->addItem(new QSpacerItem(5, 5, QSizePolicy::MinimumExpanding, QSizePolicy::Minimum));

layout->addLayout(hboxLayout);

d->splitter = new QSplitter;
    d->splitter->setChildrenCollapsible(false);
    d->inputText = new TranslatorTextEdit(this);
    KPIMTextEdit::PlainTextEditorWidget *editorWidget = new KPIMTextEdit::PlainTextEditorWidget(d->inputText);
    d->inputText->setObjectName(QStringLiteral("inputtext"));
    d->inputText->setPlaceholderText(i18n("Drag text that you want to translate."));
    connect(d->inputText, &TranslatorTextEdit::textChanged, this, &TranslatorWidget::slotTextChanged);
    connect(d->inputText, &TranslatorTextEdit::translateText, this, &TranslatorWidget::slotTranslate);

d->splitter->addWidget(editorWidget);
    d->translatorResultTextEdit = new TranslatorResultTextEdit;
    d->translatedText = new KPIMTextEdit::PlainTextEditorWidget(d->translatorResultTextEdit, this);
    d->translatedText->setObjectName(QStringLiteral("translatedtext"));
    d->translatedText->setReadOnly(true);
    d->splitter->addWidget(d->translatedText);

layout->addWidget(d->splitter);

d->initLanguage();
    d->from->setCurrentIndex(0);   //Fill "to" combobox
    slotFromLanguageChanged(0, true);
    slotTextChanged();
    readConfig();
    connect(d->from, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this](int val) {
        slotFromLanguageChanged(val, false);
    });
    connect(d->from, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &TranslatorWidget::slotConfigChanged);

connect(d->to, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &TranslatorWidget::slotConfigChanged);
    connect(d->to, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &TranslatorWidget::slotTranslate);

hide();
    setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
    d->languageSettingsChanged = false;
}

void TranslatorWidget::slotConfigChanged()
{
    d->languageSettingsChanged = true;
}

void TranslatorWidget::slotTextChanged()
{
    d->translate->setEnabled(!d->inputText->document()->isEmpty());
    d->clear->setEnabled(!d->inputText->document()->isEmpty());
}

void TranslatorWidget::slotFromLanguageChanged(int index, bool initialize)
{
    const QString lang = d->from->itemData(index).toString();
    d->invert->setEnabled(lang != QLatin1String("auto"));
    const QString to = d->to->itemData(d->to->currentIndex()).toString();
    d->to->blockSignals(true);
    d->fillToCombobox(lang);
    d->to->blockSignals(false);
    const int indexTo = d->to->findData(to);
    if (indexTo != -1) {
        d->to->setCurrentIndex(indexTo);
    }
    if (!initialize) {
        slotTranslate();
    }
}

void TranslatorWidget::setTextToTranslate(const QString &text)
{
    d->inputText->setPlainText(text);
    slotTranslate();
}

void TranslatorWidget::slotTranslate()
{
    if (!PimCommon::NetworkManager::self()->networkConfigureManager()->isOnline()) {
        KMessageBox::information(this, i18n("No network connection detected, we cannot translate text."), i18n("No network"));
        return;
    }
    const QString textToTranslate = d->inputText->toPlainText();
    if (textToTranslate.trimmed().isEmpty()) {
        return;
    }

d->translatorResultTextEdit->clear();

const QString from = d->from->itemData(d->from->currentIndex()).toString();
    const QString to = d->to->itemData(d->to->currentIndex()).toString();
    d->translate->setEnabled(false);
    d->progressIndictor->start();

d->abstractTranslator->setFrom(from);
    d->abstractTranslator->setTo(to);
    d->abstractTranslator->setInputText(d->inputText->toPlainText());
    d->abstractTranslator->translate();
}

void TranslatorWidget::slotTranslateDone()
{
    d->translate->setEnabled(true);
    d->progressIndictor->stop();
    d->translatorResultTextEdit->setResultFailed(false);
    d->translatorResultTextEdit->setPlainText(d->abstractTranslator->resultTranslate());
}

void TranslatorWidget::slotTranslateFailed(bool signalFailed, const QString &message)
{
    d->translate->setEnabled(true);
    d->progressIndictor->stop();
    d->translatorResultTextEdit->setResultFailed(signalFailed);
    d->translatorResultTextEdit->clear();
    if (!message.isEmpty()) {
        KMessageBox::error(this, message, i18n("Translate error"));
    }
}

void TranslatorWidget::slotInvertLanguage()
{
    const QString fromLanguage = d->from->itemData(d->from->currentIndex()).toString();
    // don't invert when fromLanguage == auto
    if (fromLanguage == QLatin1String("auto")) {
        return;
    }

const QString toLanguage = d->to->itemData(d->to->currentIndex()).toString();
    const int indexFrom = d->from->findData(toLanguage);
    if (indexFrom != -1) {
        d->from->setCurrentIndex(indexFrom);
    }
    const int indexTo = d->to->findData(fromLanguage);
    if (indexTo != -1) {
        d->to->setCurrentIndex(indexTo);
    }
    slotTranslate();
}

void TranslatorWidget::setStandalone(bool b)
{
    d->standalone = b;
}

void TranslatorWidget::slotCloseWidget()
{
    if (isHidden()) {
        return;
    }
    d->inputText->clear();
    d->translatorResultTextEdit->clear();
    d->progressIndictor->stop();
    if (d->standalone) {
        hide();
    }
    Q_EMIT toolsWasClosed();
}

bool TranslatorWidget::event(QEvent *e)
{
    // Close the bar when pressing Escape.
    // Not using a QShortcut for this because it could conflict with
    // window-global actions (e.g. Emil Sedgh binds Esc to "close tab").
    // With a shortcut override we can catch this before it gets to kactions.
    if (e->type() == QEvent::ShortcutOverride || e->type() == QEvent::KeyPress) {
        QKeyEvent *kev = static_cast<QKeyEvent * >(e);
        if (kev->key() == Qt::Key_Escape) {
            e->accept();
            slotCloseWidget();
            return true;
        }
    }
    return QWidget::event(e);
}

void TranslatorWidget::slotClear()
{
    d->inputText->clear();
    d->translatorResultTextEdit->clear();
    d->translate->setEnabled(false);
    d->abstractTranslator->clear();
}

void TranslatorWidget::slotDebug()
{
    d->abstractTranslator->debug();
}
070701000000BE000081A40000000200000002000000015CDAA394000009FE000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/translator/translatorwidget.h/*

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TRANSLATORWIDGET_H
#define TRANSLATORWIDGET_H

#include "pimcommon_export.h"
#include "kpimtextedit/plaintexteditor.h"
#include <kio/job.h>
#include "kpimtextedit/plaintexteditorwidget.h"
namespace PimCommon {
class TranslatorResultTextEdit : public KPIMTextEdit::PlainTextEditor
{
    Q_OBJECT
public:
    explicit TranslatorResultTextEdit(QWidget *parent = nullptr);

void setResultFailed(bool failed);

protected:
    void paintEvent(QPaintEvent *event) override;

private:
    bool mResultFailed;
};

class PIMCOMMON_EXPORT TranslatorTextEdit : public KPIMTextEdit::PlainTextEditor
{
    Q_OBJECT
public:
    explicit TranslatorTextEdit(QWidget *parent = nullptr);

Q_SIGNALS:
    void translateText();

protected:
    void dropEvent(QDropEvent *) override;
};

class PIMCOMMON_EXPORT TranslatorWidget : public QWidget
{
    Q_OBJECT
public:
    explicit TranslatorWidget(QWidget *parent = nullptr);
    explicit TranslatorWidget(const QString &text, QWidget *parent = nullptr);
    ~TranslatorWidget() override;

void setTextToTranslate(const QString &);
    void writeConfig();
    void readConfig();
    void setStandalone(bool b);

public Q_SLOTS:
    void slotTranslate();
    void slotCloseWidget();

private Q_SLOTS:
    void slotFromLanguageChanged(int, bool initialize = false);
    void slotTextChanged();
    void slotInvertLanguage();
    void slotClear();
    void slotTranslateDone();
    void slotTranslateFailed(bool result, const QString &message);
    void slotDebug();
    void slotConfigChanged();

protected:
    bool event(QEvent *e) override;

Q_SIGNALS:
    void toolsWasClosed();

private:
    void init();
    void initLanguage();
    class TranslatorWidgetPrivate;
    TranslatorWidgetPrivate *const d;
};
}

#endif /* TRANSLATORWIDGET_H */
070701000000BF000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util070701000000C0000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/autotests070701000000C1000081A40000000200000002000000015CDAA3940000011B000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/autotests/CMakeLists.txtmacro(add_pimcommon_util_unittest _name)
    ecm_add_test(${ARGN}
        TEST_NAME ${_name}
        NAME_PREFIX "pimcommon-util-"
        LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::PimCommon
        GUI
    )
endmacro()

add_pimcommon_util_unittest(networkutiltest networkutiltest.cpp)
070701000000C2000081A40000000200000002000000015CDAA3940000054E000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/autotests/networkutiltest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "networkutiltest.h"
#include <QTest>
#include "../networkutil.h"

NetworkUtilTest::NetworkUtilTest(QObject *parent)
    : QObject(parent)
{
}

NetworkUtilTest::~NetworkUtilTest()
{
}

void NetworkUtilTest::shouldHaveDefaultValue()
{
    PimCommon::NetworkUtil util;
    QVERIFY(!util.lowBandwidth());
}

void NetworkUtilTest::shouldApplyChanges()
{
    PimCommon::NetworkUtil util;
    bool lowBandwith = false;
    util.setLowBandwidth(lowBandwith);
    QCOMPARE(util.lowBandwidth(), lowBandwith);

lowBandwith = true;
    util.setLowBandwidth(lowBandwith);
    QCOMPARE(util.lowBandwidth(), lowBandwith);
}

QTEST_MAIN(NetworkUtilTest)
070701000000C3000081A40000000200000002000000015CDAA3940000040E000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/autotests/networkutiltest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef NETWORKUTILTEST_H
#define NETWORKUTILTEST_H

#include <QObject>

class NetworkUtilTest : public QObject
{
    Q_OBJECT
public:
    explicit NetworkUtilTest(QObject *parent = nullptr);
    ~NetworkUtilTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldApplyChanges();
};

#endif // NETWORKUTILTEST_H
070701000000C4000081A40000000200000002000000015CDAA394000011E8000000000000000000000000000000000000005200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/imapresource.kcfg<?xml version="1.0" encoding="UTF-8"?>
<kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
      xmlns:kcfg="http://www.kde.org/standards/kcfg/1.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
      http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
  <kcfgfile/>
  <group name="network">
    <entry name="ImapServer" type="String">
      <label>IMAP server</label>
    </entry>
    <entry name="ImapPort"  type="Int">
      <label>Defines the port the IMAP service is running on</label>
      <default>993</default>
    </entry>
    <entry name="UserName" type="String">
      <label>Username</label>
    </entry>
    <entry name="Safety" type="String">
      <label>Defines the encryption type to use</label>
      <default>SSL</default>
    </entry>
    <entry name="OverrideEncryption" type="String">
      <label>Override configured encryption mode</label>
    </entry>
    <entry name="Authentication" type="Int">
      <label>Defines the authentication type to use</label>
      <default>1</default>
    </entry>
    <entry name="SubscriptionEnabled" type="Bool">
      <label>Defines if the server side subscription is enabled</label>
      <default>false</default>
    </entry>
    <entry name="SessionTimeout" type="Int">
      <default>30</default>
    </entry>
  </group>
  <group name="cache">
    <entry name="DisconnectedModeEnabled" type="Bool">
      <label>Defines if all the IMAP data should be cached locally all the time</label>
      <default>false</default>
    </entry>
    <entry name="IntervalCheckEnabled" type="Bool">
       <label>Defines if interval checking is enabled.</label>
       <default>true</default>
     </entry>
    <entry name="IntervalCheckTime" type="Int">
      <label>Check interval in minutes</label>
      <default>5</default>
    </entry>
    <entry name="RetrieveMetadataOnFolderListing" type="Bool">
      <label>Defines if the annotations, ACLs and quota information of mailboxes should
             also be retrieved when the mailboxes get listed.</label>
      <default>true</default>
    </entry>
    <entry name="AutomaticExpungeEnabled" type="Bool">
      <label>Defines if the expunge command is issued automatically, otherwise it should be
             triggered manually through the D-Bus interface.</label>
      <default>true</default>
    </entry>
    <entry name="TrashCollection" type="LongLong">
       <label>Define which folder is used for trash</label>
       <default>-1</default>
    </entry>
    <entry name="TrashCollectionMigrated" type="Bool">
       <label>Define if the trash collection received the special attribute</label>
       <default>false</default>
    </entry>
    <entry name="UseDefaultIdentity" type="Bool">
       <label>Define if account uses the default identity</label>
       <default>true</default>
    </entry>
    <entry name="AccountIdentity" type="Int">
       <label>Identity account</label>
    </entry>
    <entry name="KnownMailBoxes" type="StringList">
      <label>List of mailbox names reported by the server the last time</label>
    </entry>
  </group>
  <group name="idle">
    <entry name="IdleRidPath" type="StringList">
      <label>RID path to the mailbox to watch for changes</label>
    </entry>
  </group>
  <group name="siever">
    <entry name="SieveSupport" type="Bool">
      <label>Define if server supports sieve</label>
      <default>false</default>
    </entry>
    <entry name="SieveReuseConfig" type="Bool">
      <label>Define if we reuse host and login configuration</label>
      <default>true</default>
    </entry>
    <entry name="SievePort" type="Int">
      <label>Define sieve port</label>
      <default>4190</default>
    </entry>
    <entry name="SieveAlternateUrl" type="String">
      <label>Define alternate URL</label>
    </entry>
    <entry name="AlternateAuthentication" type="Int">
      <label>Defines the authentication type to use for alternate server</label>
      <default>1</default>
    </entry>
    <entry name="SieveVacationFilename" type="String">
      <label>Define default sieve vacation filename</label>
      <default>kmail-vacation.siv</default>
    </entry>
    <entry name="SieveCustomUsername" type="String">
      <label>Define username used from custom server sieve url</label>
      <default></default>
    </entry>
    <entry name="SieveCustomAuthentification" type="String">
      <label>Defines the type of identification used by custom sieve server</label>
      <default>ImapUserPassword</default>
    </entry>
  </group>
</kcfg>
070701000000C5000081A40000000200000002000000015CDAA39400000493000000000000000000000000000000000000005000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/networkutil.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "networkutil.h"
#include <qglobal.h>

using namespace PimCommon;

Q_GLOBAL_STATIC(NetworkUtil, s_networkUtil)

NetworkUtil *NetworkUtil::self()
{
    return s_networkUtil;
}

NetworkUtil::NetworkUtil()
    : mLowBandwidth(false)
{
}

bool NetworkUtil::lowBandwidth() const
{
    return mLowBandwidth;
}

void NetworkUtil::setLowBandwidth(bool lowBandwidh)
{
    mLowBandwidth = lowBandwidh;
}
070701000000C6000081A40000000200000002000000015CDAA3940000044F000000000000000000000000000000000000004E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/networkutil.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef NETWORKUTIL_H
#define NETWORKUTIL_H
#include "pimcommon_export.h"
namespace PimCommon {
class PIMCOMMON_EXPORT NetworkUtil
{
public:
    static NetworkUtil *self();

NetworkUtil();

bool lowBandwidth() const;
    void setLowBandwidth(bool lowBandwidth);

private:
    bool mLowBandwidth;
};
}

#endif // NETWORKUTIL_H
070701000000C7000081A40000000200000002000000015CDAA394000017B4000000000000000000000000000000000000004C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/pimutil.cpp/*******************************************************************************
**
** Filename   : util
** Created on : 03 April, 2005
** Copyright  : (c) 2005 Till Adam
** Email      : <adam@kde.org>
**
*******************************************************************************/

/*******************************************************************************
**
**   This program is free software; you can redistribute it and/or modify
**   it under the terms of the GNU General Public License as published by
**   the Free Software Foundation; either version 2 of the License, or
**   (at your option) any later version.
**
**   It is distributed in the hope that it will be useful, but
**   WITHOUT ANY WARRANTY; without even the implied warranty of
**   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
**   General Public License for more details.
**
**   You should have received a copy of the GNU General Public License
**   along with this program; if not, write to the Free Software
**   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
**
**   In addition, as a special exception, the copyright holders give
**   permission to link the code of this program with any edition of
**   the Qt library by Trolltech AS, Norway (or with modified versions
**   of Qt that use the same license as Qt), and distribute linked
**   combinations including the two.  You must obey the GNU General
**   Public License in all respects for all of the code used other than
**   Qt.  If you modify this file, you may extend this exception to
**   your version of the file, but you are not obligated to do so.  If
**   you do not wish to do so, delete this exception statement from
**   your version.
**
*******************************************************************************/

#include "pimutil.h"

#include "imapresourcesettings.h"

#include <QFileDialog>
#include <QDesktopServices>
#include <KMessageBox>
#include <KLocalizedString>
#include <KEmailAddress>

#include <QTextStream>
#include <QWidget>
#include <QPointer>
#include <QUrlQuery>

#include <errno.h>

OrgKdeAkonadiImapSettingsInterface *PimCommon::Util::createImapSettingsInterface(const QString &ident)
{
    if (isImapResource(ident)) {
        return
            new OrgKdeAkonadiImapSettingsInterface(
            QLatin1String("org.freedesktop.Akonadi.Resource.") + ident, QStringLiteral("/Settings"), QDBusConnection::sessionBus());
    } else {
        return nullptr;
    }
}

void PimCommon::Util::saveTextAs(const QString &text, const QString &filter, QWidget *parent, const QUrl &url, const QString &caption)
{
    QPointer<QFileDialog> fdlg(new QFileDialog(parent, QString(), url.path(), filter));
    if (!caption.isEmpty()) {
        fdlg->setWindowTitle(caption);
    }
    fdlg->setAcceptMode(QFileDialog::AcceptSave);
    if (fdlg->exec() == QDialog::Accepted) {
        const QString fileName = fdlg->selectedFiles().at(0);
        if (!saveToFile(fileName, text)) {
            KMessageBox::error(parent,
                               i18n("Could not write the file %1:\n"
                                    "\"%2\" is the detailed error description.",
                                    fileName,
                                    QString::fromLocal8Bit(strerror(errno))),
                               i18n("Save File Error"));
        }
    }
    delete fdlg;
}

bool PimCommon::Util::saveToFile(const QString &filename, const QString &text)
{
    QFile file(filename);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        return false;
    }
    QTextStream out(&file);
    out.setCodec("UTF-8");
    out << text;
    file.close();
    return true;
}

QString PimCommon::Util::loadToFile(const QString &filter, QWidget *parent, const QUrl &url, const QString &caption)
{
    QPointer<QFileDialog> fdlg(new QFileDialog(parent, QString(), url.path(), filter));
    if (!caption.isEmpty()) {
        fdlg->setWindowTitle(caption);
    }
    fdlg->setAcceptDrops(QFileDialog::AcceptOpen);
    QString result;
    if (fdlg->exec() == QDialog::Accepted) {
        const QString fileName = fdlg->selectedFiles().at(0);
        QFile file(fileName);
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            KMessageBox::error(parent,
                               i18n("Could not read the file %1:\n"
                                    "\"%2\" is the detailed error description.",
                                    fileName,
                                    QString::fromLocal8Bit(strerror(errno))),
                               i18n("Load File Error"));
        } else {
            result = QString::fromUtf8(file.readAll());
            file.close();
        }
    }
    delete fdlg;
    return result;
}

bool PimCommon::Util::isImapResource(const QString &identifier)
{
    return identifier.startsWith(KOLAB_RESOURCE_IDENTIFIER)
           || identifier.startsWith(IMAP_RESOURCE_IDENTIFIER)
           || identifier.startsWith(GMAIL_RESOURCE_IDENTIFIER);
}

void PimCommon::Util::invokeHelp(const QString &docfile, const QString &anchor)
{
    if (!docfile.isEmpty()) {
        QUrl url;
        url = QUrl(QStringLiteral("help:/")).resolved(QUrl(docfile));
        if (!anchor.isEmpty()) {
            QUrlQuery query(url);
            query.addQueryItem(QStringLiteral("anchor"), anchor);
            url.setQuery(query);
        }
        // launch khelpcenter, or a browser for URIs not handled by khelpcenter
        QDesktopServices::openUrl(url);
    }
}

QStringList PimCommon::Util::generateEmailList(const QStringList &list)
{
    QString str;
    const int numberOfElement{
        list.count()
    };
    for (int i = 0; i < numberOfElement; i++) {
        QString tmpStr = list.at(i);
        if (!tmpStr.trimmed().isEmpty()) {
            if (!str.isEmpty()) {
                str.append(QLatin1String(", "));
            }
            str.append(tmpStr);
        }
    }
    const QStringList emails = KEmailAddress::splitAddressList(str);
    return emails;
}
070701000000C8000081A40000000200000002000000015CDAA39400000CEE000000000000000000000000000000000000004A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/util/pimutil.h/*******************************************************************************
**
** Filename   : util
** Created on : 03 April, 2005
** Copyright  : (c) 2005 Till Adam
** Email      : <adam@kde.org>
**
*******************************************************************************/

#include "pimcommon_export.h"
#include <QUrl>
class OrgKdeAkonadiImapSettingsInterface;
class QWidget;

#define IMAP_RESOURCE_IDENTIFIER QStringLiteral("akonadi_imap_resource")
#define KOLAB_RESOURCE_IDENTIFIER QStringLiteral("akonadi_kolab_resource")
#define POP3_RESOURCE_IDENTIFIER QStringLiteral("akonadi_pop3_resource")
#define MBOX_RESOURCE_IDENTIFIER QStringLiteral("akonadi_mbox_resource")
#define GMAIL_RESOURCE_IDENTIFIER QStringLiteral("akonadi_gmail_resource")
namespace PimCommon {
/**
 * The Util namespace contains a collection of helper functions use in
 * various places.
 */
namespace Util {
Q_REQUIRED_RESULT PIMCOMMON_EXPORT OrgKdeAkonadiImapSettingsInterface *createImapSettingsInterface(const QString &ident);
PIMCOMMON_EXPORT void saveTextAs(const QString &text, const QString &filter, QWidget *parent, const QUrl &url = QUrl(), const QString &caption = QString());
Q_REQUIRED_RESULT PIMCOMMON_EXPORT bool saveToFile(const QString &filename, const QString &text);
Q_REQUIRED_RESULT PIMCOMMON_EXPORT QString loadToFile(const QString &filter, QWidget *parent, const QUrl &url = QUrl(), const QString &caption = QString());
PIMCOMMON_EXPORT void invokeHelp(const QString &docfile, const QString &anchor = QString());
Q_REQUIRED_RESULT PIMCOMMON_EXPORT bool isImapResource(const QString &identifier);
Q_REQUIRED_RESULT PIMCOMMON_EXPORT QStringList generateEmailList(const QStringList &list);
}
}

#endif
070701000000C9000041ED0000000200000002000000055CDAA39400000000000000000000000000000000000000000000004300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets070701000000CA000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests070701000000CB000081A40000000200000002000000015CDAA39400000287000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests/CMakeLists.txtecm_add_test(kactionmenuchangecasetest.cpp
    TEST_NAME kactionmenuchangecasetest
    NAME_PREFIX pimcommon-widget
    LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::WidgetsAddons KF5::I18n KF5::XmlGui KF5::PimCommon
)

ecm_add_test(lineeditwithcompleterngtest.cpp
    TEST_NAME lineeditwithcompleterngtest
    NAME_PREFIX pimcommon-widget
    LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::WidgetsAddons KF5::I18n KF5::PimCommon
)

ecm_add_test(purposemenuwidgettest.cpp
    TEST_NAME purposemenuwidgettest
    NAME_PREFIX pimcommon-widget
    LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::WidgetsAddons KF5::I18n KF5::PimCommon KF5::Purpose KF5::PurposeWidgets
    )
070701000000CC000081A40000000200000002000000015CDAA39400000806000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests/kactionmenuchangecasetest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "kactionmenuchangecasetest.h"
#include "../src/pimcommon/widgets/kactionmenuchangecase.h"
#include <QTest>
#include <QSignalSpy>
#include <QMenu>
using namespace PimCommon;
KActionMenuChangeCaseTest::KActionMenuChangeCaseTest(QObject *parent)
    : QObject(parent)
{
}

KActionMenuChangeCaseTest::~KActionMenuChangeCaseTest()
{
}

void KActionMenuChangeCaseTest::shouldHaveDefaultValue()
{
    KActionMenuChangeCase menu;
    QVERIFY(menu.upperCaseAction());
    QVERIFY(menu.sentenceCaseAction());
    QVERIFY(menu.lowerCaseAction());
    QVERIFY(menu.reverseCaseAction());
    QCOMPARE(menu.menu()->actions().count(), 4);
}

void KActionMenuChangeCaseTest::shouldEmitSignals()
{
    KActionMenuChangeCase menu;
    QSignalSpy spyUpper(&menu, &KActionMenuChangeCase::upperCase);
    QSignalSpy spyLower(&menu, &KActionMenuChangeCase::lowerCase);
    QSignalSpy spySentence(&menu, &KActionMenuChangeCase::sentenceCase);
    QSignalSpy spyReverse(&menu, &KActionMenuChangeCase::reverseCase);
    menu.upperCaseAction()->trigger();
    menu.lowerCaseAction()->trigger();
    menu.sentenceCaseAction()->trigger();
    menu.reverseCaseAction()->trigger();
    QCOMPARE(spyUpper.count(), 1);
    QCOMPARE(spyLower.count(), 1);
    QCOMPARE(spySentence.count(), 1);
    QCOMPARE(spyReverse.count(), 1);
}

QTEST_MAIN(KActionMenuChangeCaseTest)
070701000000CD000081A40000000200000002000000015CDAA39400000449000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests/kactionmenuchangecasetest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef KACTIONMENUCHANGECASETEST_H
#define KACTIONMENUCHANGECASETEST_H

#include <QObject>

class KActionMenuChangeCaseTest : public QObject
{
    Q_OBJECT
public:
    explicit KActionMenuChangeCaseTest(QObject *parent = nullptr);
    ~KActionMenuChangeCaseTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldEmitSignals();
};

#endif // KACTIONMENUCHANGECASETEST_H
070701000000CE000081A40000000200000002000000015CDAA394000007B3000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests/lineeditwithcompleterngtest.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "lineeditwithcompleterngtest.h"
#include "../lineeditwithcompleterng.h"
#include <QCompleter>
#include <QTest>

QTEST_MAIN(LineEditWithCompleterNgTest)

LineEditWithCompleterNgTest::LineEditWithCompleterNgTest(QObject *parent)
    : QObject(parent)
{
}

void LineEditWithCompleterNgTest::shouldHaveDefaultValue()
{
    PimCommon::LineEditWithCompleterNg w;
    QVERIFY(w.completer());
    QVERIFY(w.completer()->model());
    QCOMPARE(w.completer()->model()->rowCount(), 0);
}

void LineEditWithCompleterNgTest::shouldAddCompletionItem()
{
    PimCommon::LineEditWithCompleterNg w;
    w.addCompletionItem(QStringLiteral("ff"));
    QCOMPARE(w.completer()->model()->rowCount(), 1);

//Don't add same element
    w.addCompletionItem(QStringLiteral("ff"));
    QCOMPARE(w.completer()->model()->rowCount(), 1);

w.addCompletionItem(QStringLiteral("ffss"));
    QCOMPARE(w.completer()->model()->rowCount(), 2);
}

void LineEditWithCompleterNgTest::shouldClearCompleter()
{
    PimCommon::LineEditWithCompleterNg w;
    for (int i = 0; i < 10; ++i) {
        w.addCompletionItem(QStringLiteral("ff%1").arg(i));
    }
    QCOMPARE(w.completer()->model()->rowCount(), 10);
    w.slotClearHistory();
    QCOMPARE(w.completer()->model()->rowCount(), 0);
}
070701000000CF000081A40000000200000002000000015CDAA39400000487000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests/lineeditwithcompleterngtest.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LINEEDITWITHCOMPLETERNGTEST_H
#define LINEEDITWITHCOMPLETERNGTEST_H

#include <QObject>

class LineEditWithCompleterNgTest : public QObject
{
    Q_OBJECT
public:
    explicit LineEditWithCompleterNgTest(QObject *parent = nullptr);
    ~LineEditWithCompleterNgTest() = default;

private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldAddCompletionItem();
    void shouldClearCompleter();
};

#endif // LINEEDITWITHCOMPLETERNGTEST_H
070701000000D0000081A40000000200000002000000015CDAA3940000043A000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests/purposemenuwidgettest.cpp/*
  Copyright (c) 2018-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "purposemenuwidgettest.h"

#include <QMenu>
#include <QTest>

QTEST_MAIN(PurposeMenuWidgetTest)

PurposeMenuWidgetTest::PurposeMenuWidgetTest(QObject *parent)
    : QObject(parent)
{
}

void PurposeMenuWidgetTest::shouldHaveDefaultValues()
{
    TestMenu w(nullptr);
    QVERIFY(w.menu());
    QCOMPARE(w.menu()->objectName(), QStringLiteral("purposesharemenu"));
}
070701000000D1000081A40000000200000002000000015CDAA3940000055B000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/autotests/purposemenuwidgettest.h/*
  Copyright (c) 2018-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef PURPOSEMENUWIDGETTEST_H
#define PURPOSEMENUWIDGETTEST_H

#include <QObject>
#include "widgets/purposemenuwidget.h"
class TestMenu : public PimCommon::PurposeMenuWidget
{
    Q_OBJECT
public:
    TestMenu(QWidget *parentWidget, QObject *parent = nullptr)
        : PimCommon::PurposeMenuWidget(parentWidget, parent)
    {
    }

QByteArray text() override
    {
        return "";
    }
};

class PurposeMenuWidgetTest : public QObject
{
    Q_OBJECT
public:
    explicit PurposeMenuWidgetTest(QObject *parent = nullptr);
    ~PurposeMenuWidgetTest() = default;
private Q_SLOTS:
    void shouldHaveDefaultValues();
};

#endif // PURPOSEMENUWIDGETTEST_H
070701000000D2000081A40000000200000002000000015CDAA39400001544000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/configureimmutablewidgetutils.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "configureimmutablewidgetutils.h"
#include "simplestringlisteditor.h"

#include <KLocalizedString>
#include <KUrlRequester>

#include <QWidget>
#include <QLineEdit>
#include <QGroupBox>
#include <QButtonGroup>
#include <QCheckBox>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QRadioButton>
#include <QSpinBox>
#include <QComboBox>

using namespace PimCommon;

static const char lockedDownWarning[]
    = I18N_NOOP("<qt><p>This setting has been fixed by your administrator.</p>"
                "<p>If you think this is an error, please contact him.</p></qt>");

void ConfigureImmutableWidgetUtils::checkLockDown(QWidget *w, const KConfigSkeletonItem *item)
{
    if (item->isImmutable()) {
        w->setEnabled(false);
        w->setToolTip(i18n(lockedDownWarning));
    }
}

void ConfigureImmutableWidgetUtils::populateButtonGroup(QGroupBox *box, QButtonGroup *group, int orientation, const KCoreConfigSkeleton::ItemEnum *e)
{
    box->setTitle(e->label());
    if (orientation == Qt::Horizontal) {
        box->setLayout(new QHBoxLayout());
    } else {
        box->setLayout(new QVBoxLayout());
    }
    const int numberChoices(e->choices().size());
    for (int i = 0; i < numberChoices; ++i) {
        QRadioButton *button = new QRadioButton(e->choices().at(i).label, box);
        group->addButton(button, i);
        box->layout()->addWidget(button);
    }
}

void ConfigureImmutableWidgetUtils::populateCheckBox(QCheckBox *b, const KCoreConfigSkeleton::ItemBool *e)
{
    b->setText(e->label());
}

void ConfigureImmutableWidgetUtils::loadWidget(QLineEdit *b, const KCoreConfigSkeleton::ItemString *e)
{
    checkLockDown(b, e);
    b->setText(e->value());
}

void ConfigureImmutableWidgetUtils::loadWidget(QCheckBox *b, const KCoreConfigSkeleton::ItemBool *e)
{
    checkLockDown(b, e);
    b->setChecked(e->value());
}

void ConfigureImmutableWidgetUtils::loadWidget(PimCommon::SimpleStringListEditor *b, const KCoreConfigSkeleton::ItemStringList *e)
{
    checkLockDown(b, e);
    b->setStringList(e->value());
}

void ConfigureImmutableWidgetUtils::loadWidget(QGroupBox *box, QButtonGroup *group, const KCoreConfigSkeleton::ItemEnum *e)
{
    Q_ASSERT(group->buttons().size() == e->choices().size());
    checkLockDown(box, e);
    group->buttons().at(e->value())->setChecked(true);
}

void ConfigureImmutableWidgetUtils::loadWidget(QSpinBox *b, const KCoreConfigSkeleton::ItemInt *e)
{
    checkLockDown(b, e);
    b->setValue(e->value());
}

void ConfigureImmutableWidgetUtils::saveSpinBox(QSpinBox *b, KCoreConfigSkeleton::ItemInt *e)
{
    e->setValue(b->value());
}

void ConfigureImmutableWidgetUtils::saveSpinBox(QSpinBox *b, KCoreConfigSkeleton::ItemUInt *e)
{
    e->setValue(b->value());
}

void ConfigureImmutableWidgetUtils::loadWidget(QSpinBox *b, const KCoreConfigSkeleton::ItemUInt *e)
{
    checkLockDown(b, e);
    b->setValue(e->value());
}

void ConfigureImmutableWidgetUtils::saveCheckBox(QCheckBox *b, KCoreConfigSkeleton::ItemBool *e)
{
    e->setValue(b->isChecked());
}

void ConfigureImmutableWidgetUtils::saveLineEdit(QLineEdit *b, KCoreConfigSkeleton::ItemString *e)
{
    e->setValue(b->text());
}

void ConfigureImmutableWidgetUtils::saveUrlRequester(KUrlRequester *b, KCoreConfigSkeleton::ItemString *e)
{
    e->setValue(b->text());
}

void ConfigureImmutableWidgetUtils::saveGroupBox(QGroupBox *b, KCoreConfigSkeleton::ItemBool *e)
{
    if (b->isCheckable()) {
        e->setValue(b->isChecked());
    }
}

void ConfigureImmutableWidgetUtils::loadWidget(KUrlRequester *b, const KCoreConfigSkeleton::ItemString *e)
{
    checkLockDown(b, e);
    b->setText(e->value());
}

void ConfigureImmutableWidgetUtils::saveButtonGroup(QButtonGroup *group, KCoreConfigSkeleton::ItemEnum *e)
{
    Q_ASSERT(group->buttons().size() == e->choices().size());
    if (group->checkedId() != -1) {
        e->setValue(group->checkedId());
    }
}

void ConfigureImmutableWidgetUtils::saveSimpleStringListEditor(PimCommon::SimpleStringListEditor *b, KCoreConfigSkeleton::ItemStringList *e)
{
    e->setValue(b->stringList());
}

void ConfigureImmutableWidgetUtils::loadWidget(QGroupBox *b, const KCoreConfigSkeleton::ItemBool *e)
{
    checkLockDown(b, e);
    if (b->isCheckable()) {
        b->setChecked(e->value());
    }
}

void ConfigureImmutableWidgetUtils::loadWidget(QComboBox *b, const KCoreConfigSkeleton::ItemEnum *e)
{
    checkLockDown(b, e);
    b->setCurrentIndex(e->value());
}

void ConfigureImmutableWidgetUtils::saveComboBox(QComboBox *b, KCoreConfigSkeleton::ItemEnum *e)
{
    Q_ASSERT(b->count() == e->choices().size());
    if (b->currentIndex() != -1) {
        e->setValue(b->currentIndex());
    }
}
070701000000D3000081A40000000200000002000000015CDAA39400000C72000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/configureimmutablewidgetutils.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CONFIGUREIMMUTABLEWIDGETUTILS_H
#define CONFIGUREIMMUTABLEWIDGETUTILS_H

#include "pimcommon_export.h"

#include <KCoreConfigSkeleton>

class QWidget;
class QGroupBox;
class QCheckBox;
class QButtonGroup;
class QLineEdit;
class KConfigSkeletonItem;
class KUrlRequester;
class QSpinBox;
class QComboBox;

namespace PimCommon {
class SimpleStringListEditor;
namespace ConfigureImmutableWidgetUtils {
void checkLockDown(QWidget *w, const KConfigSkeletonItem *item);
PIMCOMMON_EXPORT void populateButtonGroup(QGroupBox *box, QButtonGroup *group, int orientation, const KCoreConfigSkeleton::ItemEnum *e);
PIMCOMMON_EXPORT void populateCheckBox(QCheckBox *b, const KCoreConfigSkeleton::ItemBool *e);
PIMCOMMON_EXPORT void loadWidget(QCheckBox *b, const KCoreConfigSkeleton::ItemBool *e);
PIMCOMMON_EXPORT void loadWidget(QGroupBox *box, QButtonGroup *group, const KCoreConfigSkeleton::ItemEnum *e);
PIMCOMMON_EXPORT void loadWidget(QLineEdit *b, const KCoreConfigSkeleton::ItemString *e);
PIMCOMMON_EXPORT void loadWidget(KUrlRequester *b, const KCoreConfigSkeleton::ItemString *e);
PIMCOMMON_EXPORT void loadWidget(QSpinBox *b, const KCoreConfigSkeleton::ItemInt *e);
PIMCOMMON_EXPORT void loadWidget(PimCommon::SimpleStringListEditor *b, const KCoreConfigSkeleton::ItemStringList *e);
PIMCOMMON_EXPORT void loadWidget(QSpinBox *b, const KCoreConfigSkeleton::ItemUInt *e);
PIMCOMMON_EXPORT void loadWidget(QComboBox *b, const KCoreConfigSkeleton::ItemEnum *e);
PIMCOMMON_EXPORT void loadWidget(QGroupBox *b, const KCoreConfigSkeleton::ItemBool *e);

PIMCOMMON_EXPORT void saveComboBox(QComboBox *b, KCoreConfigSkeleton::ItemEnum *e);
PIMCOMMON_EXPORT void saveSpinBox(QSpinBox *b, KCoreConfigSkeleton::ItemUInt *e);
PIMCOMMON_EXPORT void saveSpinBox(QSpinBox *b, KCoreConfigSkeleton::ItemInt *e);
PIMCOMMON_EXPORT void saveCheckBox(QCheckBox *b, KCoreConfigSkeleton::ItemBool *e);
PIMCOMMON_EXPORT void saveLineEdit(QLineEdit *b, KCoreConfigSkeleton::ItemString *e);
PIMCOMMON_EXPORT void saveUrlRequester(KUrlRequester *b, KCoreConfigSkeleton::ItemString *e);
PIMCOMMON_EXPORT void saveSimpleStringListEditor(PimCommon::SimpleStringListEditor *b, KCoreConfigSkeleton::ItemStringList *e);
PIMCOMMON_EXPORT void saveGroupBox(QGroupBox *b, KCoreConfigSkeleton::ItemBool *e);

PIMCOMMON_EXPORT void saveButtonGroup(QButtonGroup *group, KCoreConfigSkeleton::ItemEnum *e);
}
}
#endif // CONFIGUREIMMUTABLEWIDGETUTILS_H
070701000000D4000081A40000000200000002000000015CDAA3940000099F000000000000000000000000000000000000005600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/customtreeview.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "customtreeview.h"

#include <QPainter>
#include <QFontDatabase>
#include <QEvent>

using namespace PimCommon;

CustomTreeView::CustomTreeView(QWidget *parent)
    : QTreeWidget(parent)
    , mShowDefaultText(true)
{
}

CustomTreeView::~CustomTreeView()
{
}

void CustomTreeView::changeEvent(QEvent *event)
{
    if (event->type() == QEvent::PaletteChange) {
        generalPaletteChanged();
    } else if (event->type() == QEvent::FontChange) {
        generalFontChanged();
    }
    QTreeWidget::changeEvent(event);
}

void CustomTreeView::setShowDefaultText(bool b)
{
    if (mShowDefaultText != b) {
        mShowDefaultText = b;
        update();
    }
}

bool CustomTreeView::showDefaultText() const
{
    return mShowDefaultText;
}

void CustomTreeView::setDefaultText(const QString &text)
{
    if (mDefaultText != text) {
        mDefaultText = text;
        update();
    }
}

void CustomTreeView::generalPaletteChanged()
{
    const QPalette palette = viewport()->palette();
    QColor color = palette.text().color();
    color.setAlpha(128);
    mTextColor = color;
}

void CustomTreeView::generalFontChanged()
{
    setFont(QFontDatabase::systemFont(QFontDatabase::GeneralFont));
}

void CustomTreeView::paintEvent(QPaintEvent *event)
{
    if (mShowDefaultText && !mDefaultText.isEmpty()) {
        QPainter p(viewport());

QFont font = p.font();
        font.setItalic(true);
        p.setFont(font);

if (!mTextColor.isValid()) {
            generalPaletteChanged();
        }
        p.setPen(mTextColor);

p.drawText(QRect(0, 0, width(), height()), Qt::AlignCenter, mDefaultText);
    } else {
        QTreeWidget::paintEvent(event);
    }
}
070701000000D5000081A40000000200000002000000015CDAA394000005F9000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/customtreeview.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CUSTOMTREEVIEW_H
#define CUSTOMTREEVIEW_H

#include <QTreeWidget>
#include "pimcommon_export.h"
class QPaintEvent;
class QEvent;
namespace PimCommon {
class PIMCOMMON_EXPORT CustomTreeView : public QTreeWidget
{
    Q_OBJECT
public:
    explicit CustomTreeView(QWidget *parent = nullptr);
    ~CustomTreeView() override;

void setDefaultText(const QString &text);

Q_REQUIRED_RESULT bool showDefaultText() const;
    void setShowDefaultText(bool b);

private:
    void generalPaletteChanged();
    void generalFontChanged();

protected:
    void paintEvent(QPaintEvent *event) override;
    void changeEvent(QEvent *event) override;

protected:
    bool mShowDefaultText;

private:
    QColor mTextColor;
    QString mDefaultText;
};
}

#endif
070701000000D6000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/icons070701000000D7000081A40000000200000002000000015CDAA39400000087000000000000000000000000000000000000004D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/icons.qrc<!DOCTYPE RCC><RCC version="1.0">
<qresource>
    <file>icons/visibility.svg</file>
    <file>icons/hint.svg</file>
</qresource>
</RCC>070701000000D8000081A40000000200000002000000015CDAA39400001426000000000000000000000000000000000000005200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/icons/hint.svg<?xml version="1.0" encoding="UTF-8" standalone="no"?>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "kactionmenuchangecase.h"
#include <KLocalizedString>
#include <KActionCollection>
#include <QAction>
using namespace PimCommon;
class PimCommon::KActionMenuChangeCasePrivate
{
public:
    KActionMenuChangeCasePrivate()
    {
    }

QAction *mUpperCase = nullptr;
    QAction *mSentenceCase = nullptr;
    QAction *mLowerCase = nullptr;
    QAction *mReverseCase = nullptr;
};

KActionMenuChangeCase::KActionMenuChangeCase(QObject *parent)
    : KActionMenu(parent)
    , d(new PimCommon::KActionMenuChangeCasePrivate)
{
    setText(i18n("Change Case"));
    d->mUpperCase = new QAction(i18n("Uppercase"), this);
    connect(d->mUpperCase, &QAction::triggered, this, &KActionMenuChangeCase::upperCase);

d->mSentenceCase = new QAction(i18n("Sentence case"), this);
    connect(d->mSentenceCase, &QAction::triggered, this, &KActionMenuChangeCase::sentenceCase);

d->mLowerCase = new QAction(i18n("Lowercase"), this);
    connect(d->mLowerCase, &QAction::triggered, this, &KActionMenuChangeCase::lowerCase);

d->mReverseCase = new QAction(i18n("Reverse Case"), this);
    connect(d->mReverseCase, &QAction::triggered, this, &KActionMenuChangeCase::reverseCase);

addAction(d->mUpperCase);
    addAction(d->mLowerCase);
    addAction(d->mSentenceCase);
    addAction(d->mReverseCase);
}

KActionMenuChangeCase::~KActionMenuChangeCase()
{
    delete d;
}

QAction *KActionMenuChangeCase::upperCaseAction() const
{
    return d->mUpperCase;
}

QAction *KActionMenuChangeCase::sentenceCaseAction() const
{
    return d->mSentenceCase;
}

QAction *KActionMenuChangeCase::lowerCaseAction() const
{
    return d->mLowerCase;
}

QAction *KActionMenuChangeCase::reverseCaseAction() const
{
    return d->mReverseCase;
}

void KActionMenuChangeCase::appendInActionCollection(KActionCollection *ac)
{
    if (ac) {
        ac->addAction(QStringLiteral("change_to_uppercase"), d->mUpperCase);
        ac->addAction(QStringLiteral("change_to_sentencecase"), d->mSentenceCase);
        ac->addAction(QStringLiteral("change_to_lowercase"), d->mLowerCase);
        ac->addAction(QStringLiteral("change_to_reversecase"), d->mReverseCase);
    }
}
070701000000DB000081A40000000200000002000000015CDAA39400000679000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/kactionmenuchangecase.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef KACTIONMENUCHANGECASE_H
#define KACTIONMENUCHANGECASE_H

#include <KActionMenu>
#include "pimcommon_export.h"
class QAction;
class KActionCollection;
namespace PimCommon {
class KActionMenuChangeCasePrivate;
class PIMCOMMON_EXPORT KActionMenuChangeCase : public KActionMenu
{
    Q_OBJECT
public:
    explicit KActionMenuChangeCase(QObject *parent = nullptr);
    ~KActionMenuChangeCase();

Q_REQUIRED_RESULT QAction *upperCaseAction() const;

Q_REQUIRED_RESULT QAction *sentenceCaseAction() const;

Q_REQUIRED_RESULT QAction *lowerCaseAction() const;

Q_REQUIRED_RESULT QAction *reverseCaseAction() const;

void appendInActionCollection(KActionCollection *ac);

Q_SIGNALS:
    void upperCase();
    void sentenceCase();
    void lowerCase();
    void reverseCase();

private:
    KActionMenuChangeCasePrivate *const d;
};
}

#endif // KACTIONMENUCHANGECASE_H
070701000000DC000081A40000000200000002000000015CDAA39400000676000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/kpimprintpreviewdialog.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "kpimprintpreviewdialog.h"
#include <KConfigGroup>
#include <KSharedConfig>

using namespace PimCommon;

KPimPrintPreviewDialog::KPimPrintPreviewDialog(QWidget *parent)
    : QPrintPreviewDialog(parent)
{
    readConfig();
}

KPimPrintPreviewDialog::KPimPrintPreviewDialog(QPrinter *printer, QWidget *parent)
    : QPrintPreviewDialog(printer, parent)
{
    readConfig();
}

KPimPrintPreviewDialog::~KPimPrintPreviewDialog()
{
    writeConfig();
}

void KPimPrintPreviewDialog::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "KPimPrintPreviewDialog");
    const QSize size = group.readEntry("Size", QSize(800, 600));
    if (size.isValid()) {
        resize(size);
    }
}

void KPimPrintPreviewDialog::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "KPimPrintPreviewDialog");
    group.writeEntry("Size", size());
    group.sync();
}
070701000000DD000081A40000000200000002000000015CDAA39400000500000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/kpimprintpreviewdialog.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef KPIMPRINTPREVIEWDIALOG_H
#define KPIMPRINTPREVIEWDIALOG_H

#include <QPrintPreviewDialog>
#include "pimcommon_export.h"

namespace PimCommon {
class PIMCOMMON_EXPORT KPimPrintPreviewDialog : public QPrintPreviewDialog
{
public:
    explicit KPimPrintPreviewDialog(QWidget *parent = nullptr);
    explicit KPimPrintPreviewDialog(QPrinter *printer, QWidget *parent = nullptr);
    ~KPimPrintPreviewDialog();
private:
    void readConfig();
    void writeConfig();
};
}

#endif // KPIMPRINTPREVIEWDIALOG_H
070701000000DE000081A40000000200000002000000015CDAA39400000876000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/lineeditwithcompleterng.cpp/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "lineeditwithcompleterng.h"
#include <KLocalizedString>
#include <QCompleter>
#include <QContextMenuEvent>
#include <QMenu>
#include <QStringListModel>

using namespace PimCommon;
#define MAX_COMPLETION_ITEMS 20
LineEditWithCompleterNg::LineEditWithCompleterNg(QWidget *parent)
    : QLineEdit(parent)
{
    QCompleter *completer = new QCompleter(this);
    mCompleterListModel = new QStringListModel(this);
    completer->setModel(mCompleterListModel);
    setCompleter(completer);
}

LineEditWithCompleterNg::~LineEditWithCompleterNg()
{
}

void LineEditWithCompleterNg::addCompletionItem(const QString &str)
{
    mListCompetion.removeAll(str);
    mListCompetion.prepend(str);
    while (mListCompetion.size() > MAX_COMPLETION_ITEMS) {
        mListCompetion.removeLast();
    }
    mCompleterListModel->setStringList(mListCompetion);
}

void LineEditWithCompleterNg::contextMenuEvent(QContextMenuEvent *e)
{
    QMenu *popup = QLineEdit::createStandardContextMenu();
    if (popup) {
        popup->addSeparator();
        popup->addAction(QIcon::fromTheme(QStringLiteral("edit-clear-locationbar-rtl")), i18n("Clear History"), this, &LineEditWithCompleterNg::slotClearHistory);
        popup->exec(e->globalPos());
        delete popup;
    }
}

void LineEditWithCompleterNg::slotClearHistory()
{
    mListCompetion.clear();
    mCompleterListModel->setStringList(mListCompetion);
}
070701000000DF000081A40000000200000002000000015CDAA39400000595000000000000000000000000000000000000005D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/lineeditwithcompleterng.h/*
  Copyright (C) 2017-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef LINEEDITWITHCOMPLETERNG_H
#define LINEEDITWITHCOMPLETERNG_H

#include <QLineEdit>
#include "pimcommon_export.h"
class QStringListModel;
namespace PimCommon {
class PIMCOMMON_EXPORT LineEditWithCompleterNg : public QLineEdit
{
    Q_OBJECT
public:
    explicit LineEditWithCompleterNg(QWidget *parent = nullptr);
    ~LineEditWithCompleterNg() override;

void addCompletionItem(const QString &str);

protected:
    void contextMenuEvent(QContextMenuEvent *e) override;

public Q_SLOTS:
    void slotClearHistory();

private:
    QStringListModel *mCompleterListModel = nullptr;
    QStringList mListCompetion;
};
}
#endif // LINEEDITWITHCOMPLETER_H
070701000000E0000081A40000000200000002000000015CDAA39400000BA5000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/purposemenuwidget.cpp/*
  Copyright (c) 2018-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "purposemenuwidget.h"
#include <Purpose/AlternativesModel>
#include <PurposeWidgets/Menu>
#include <QJsonArray>
#include <QTemporaryFile>
#include <KMessageBox>
#include <KLocalizedString>
#include <QUrl>

using namespace PimCommon;
PurposeMenuWidget::PurposeMenuWidget(QWidget *parentWidget, QObject *parent)
    : QObject(parent)
    , mParentWidget(parentWidget)
{
    mShareMenu = new Purpose::Menu(mParentWidget);
    mShareMenu->setObjectName(QStringLiteral("purposesharemenu"));
    mShareMenu->model()->setPluginType(QStringLiteral("Export"));
    connect(mShareMenu, &Purpose::Menu::aboutToShow, this, &PurposeMenuWidget::slotInitializeShareMenu);
    connect(mShareMenu, &Purpose::Menu::finished, this, &PurposeMenuWidget::slotShareActionFinished);
}

PurposeMenuWidget::~PurposeMenuWidget()
{
    delete mTemporaryShareFile;
}

QMenu *PurposeMenuWidget::menu() const
{
    return mShareMenu;
}

void PurposeMenuWidget::slotInitializeShareMenu()
{
    delete mTemporaryShareFile;
    mTemporaryShareFile = new QTemporaryFile();
    mTemporaryShareFile->open();
    mTemporaryShareFile->setPermissions(QFile::ReadUser);
    mTemporaryShareFile->write(text());
    mTemporaryShareFile->close();
    mShareMenu->model()->setInputData(QJsonObject {
        { QStringLiteral("urls"), QJsonArray { {QUrl::fromLocalFile(mTemporaryShareFile->fileName()).toString()} } },
        { QStringLiteral("mimeType"), { QStringLiteral("text/plain") } }
    });
    mShareMenu->reload();
}

void PurposeMenuWidget::slotShareActionFinished(const QJsonObject &output, int error, const QString &message)
{
    if (error) {
        KMessageBox::error(mParentWidget, i18n("There was a problem sharing the document: %1", message),
                           i18n("Share"));
    } else {
        const QString url = output[QLatin1String("url")].toString();
        if (url.isEmpty()) {
            KMessageBox::information(mParentWidget, i18n("File was shared."));
        } else {
            KMessageBox::information(mParentWidget, i18n("<qt>You can find the new request at:<br /><a href='%1'>%1</a> </qt>", url),
                                     QString(), QString(), KMessageBox::AllowLink);
        }
    }
}
070701000000E1000081A40000000200000002000000015CDAA394000005FC000000000000000000000000000000000000005700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/purposemenuwidget.h/*
  Copyright (c) 2018-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef PURPOSEMENUWIDGET_H
#define PURPOSEMENUWIDGET_H

#include <QObject>
#include "pimcommon_export.h"
namespace Purpose {
class Menu;
}
class QMenu;
class QTemporaryFile;
namespace PimCommon {
class PIMCOMMON_EXPORT PurposeMenuWidget : public QObject
{
    Q_OBJECT
public:
    explicit PurposeMenuWidget(QWidget *parentWidget, QObject *parent = nullptr);
    ~PurposeMenuWidget() override;

virtual QByteArray text() = 0;
    QMenu *menu() const;
private:
    void slotInitializeShareMenu();
    void slotShareActionFinished(const QJsonObject &output, int error, const QString &message);
    Purpose::Menu *mShareMenu = nullptr;
    QTemporaryFile *mTemporaryShareFile = nullptr;
    QWidget *mParentWidget = nullptr;
};
}

#endif // PURPOSEMENUWIDGET_H
070701000000E2000081A40000000200000002000000015CDAA39400001F8A000000000000000000000000000000000000005800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/renamefiledialog.cpp/*
 * Copyright (c) 2011-2019 Montel Laurent <montel@kde.org>
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of this program with any edition of
 *  the Qt library by Trolltech AS, Norway (or with modified versions
 *  of Qt that use the same license as Qt), and distribute linked
 *  combinations including the two.  You must obey the GNU General
 *  Public License in all respects for all of the code used other than
 *  Qt.  If you modify this file, you may extend this exception to
 *  your version of the file, but you are not obligated to do so.  If
 *  you do not wish to do so, delete this exception statement from
 *  your version.
 */
#include "renamefiledialog.h"

#include <kseparator.h>
#include <QLineEdit>
#include <QPushButton>
#include <KLocalizedString>
#include <KIO/StatJob>
#include <KJobWidgets>
#include <KMessageBox>
#include <KStandardGuiItem>

#include <QHBoxLayout>
#include <QCheckBox>
#include <QLabel>
#include <QVBoxLayout>
#include <QFileInfo>

using namespace PimCommon;

class Q_DECL_HIDDEN PimCommon::RenameFileDialog::RenameFileDialogPrivate
{
public:
    RenameFileDialogPrivate(const QUrl &_url, RenameFileDialog *qq)
        : url(_url)
        , applyAll(nullptr)
        , renameBtn(nullptr)
        , suggestNewNameBtn(nullptr)
        , nameEdit(nullptr)
        , q(qq)
    {
    }

QString suggestName(const QUrl &baseURL, const QString &oldName);

QUrl url;
    QCheckBox *applyAll = nullptr;
    QPushButton *renameBtn = nullptr;
    QPushButton *suggestNewNameBtn = nullptr;
    QLineEdit *nameEdit = nullptr;
    RenameFileDialog *q = nullptr;
};

QString PimCommon::RenameFileDialog::RenameFileDialogPrivate::suggestName(const QUrl &baseURL, const QString &oldName)
{
    QString dotSuffix, suggestedName;
    QString basename = oldName;
    const QChar spacer(QLatin1Char(' '));

//ignore dots at the beginning, that way "..aFile.tar.gz" will become "..aFile 1.tar.gz" instead of " 1..aFile.tar.gz"
    int index = basename.indexOf(QLatin1Char('.'));
    int continuous = 0;
    while (continuous == index) {
        index = basename.indexOf(QLatin1Char('.'), index + 1);
        ++continuous;
    }

if (index != -1) {
        dotSuffix = basename.mid(index);
        basename.truncate(index);
    }

const int pos = basename.lastIndexOf(spacer);

if (pos != -1) {
        const QString tmp = basename.mid(pos + 1);
        bool ok;
        const int number = tmp.toInt(&ok);

if (!ok) {  // ok there is no number
            suggestedName = basename + spacer + QLatin1Char('1') + dotSuffix;
        } else {
            // yes there's already a number behind the spacer so increment it by one
            basename.replace(pos + 1, tmp.length(), QString::number(number + 1));
            suggestedName = basename + dotSuffix;
        }
    } else { // no spacer yet
        suggestedName = basename + spacer + QLatin1Char('1') + dotSuffix;
    }

// Check if suggested name already exists
    bool exists = false;
    // TODO: network transparency. However, using NetAccess from a modal dialog
    // could be a problem, no? (given that it uses a modal widget itself....)
    if (baseURL.isLocalFile()) {
        exists = QFileInfo::exists(baseURL.toLocalFile() + QLatin1Char('/') + suggestedName);
    }

if (!exists) {
        return suggestedName;
    } else { // already exists -> recurse
        return suggestName(baseURL, suggestedName);
    }
}

RenameFileDialog::RenameFileDialog(const QUrl &url, bool multiFiles, QWidget *parent)
    : QDialog(parent)
    , d(new RenameFileDialogPrivate(url, this))
{
    setWindowTitle(i18n("File Already Exists"));
    QVBoxLayout *pLayout = new QVBoxLayout(this);

QLabel *label = new QLabel(xi18n("A file named <filename>%1</filename> already exists. Do you want to overwrite it?", url.fileName()), this);
    pLayout->addWidget(label);

QHBoxLayout *renameLayout = new QHBoxLayout();
    pLayout->addLayout(renameLayout);

d->nameEdit = new QLineEdit(this);
    renameLayout->addWidget(d->nameEdit);
    d->nameEdit->setClearButtonEnabled(true);
    d->nameEdit->setText(url.fileName());
    d->suggestNewNameBtn = new QPushButton(i18n("Suggest New &Name"), this);
    renameLayout->addWidget(d->suggestNewNameBtn);
    connect(d->suggestNewNameBtn, &QPushButton::clicked, this, &RenameFileDialog::slotSuggestNewNamePressed);

QPushButton *overWrite = new QPushButton(this);
    KStandardGuiItem::assign(overWrite, KStandardGuiItem::Overwrite);
    connect(overWrite, &QPushButton::clicked, this, &RenameFileDialog::slotOverwritePressed);

QPushButton *ignore = new QPushButton(i18n("&Ignore"), this);
    connect(ignore, &QPushButton::clicked, this, &RenameFileDialog::slotIgnorePressed);

d->renameBtn = new QPushButton(i18n("&Rename"), this);
    connect(d->renameBtn, &QPushButton::clicked, this, &RenameFileDialog::slotRenamePressed);

KSeparator *separator = new KSeparator(this);
    pLayout->addWidget(separator);

QHBoxLayout *layout = new QHBoxLayout();
    pLayout->addLayout(layout);

if (multiFiles) {
        d->applyAll = new QCheckBox(i18n("Appl&y to All"), this);
        connect(d->applyAll, &QCheckBox::clicked, this, &RenameFileDialog::slotApplyAllPressed);
        layout->addWidget(d->applyAll);
        slotApplyAllPressed();
    }
    layout->addWidget(d->renameBtn);
    layout->addWidget(overWrite);
    layout->addWidget(ignore);
}

RenameFileDialog::~RenameFileDialog()
{
    delete d;
}

void RenameFileDialog::slotOverwritePressed()
{
    if (d->applyAll && d->applyAll->isChecked()) {
        done(RENAMEFILE_OVERWRITEALL);
    } else {
        done(RENAMEFILE_OVERWRITE);
    }
}

void RenameFileDialog::slotIgnorePressed()
{
    if (d->applyAll && d->applyAll->isChecked()) {
        done(RENAMEFILE_IGNOREALL);
    } else {
        done(RENAMEFILE_IGNORE);
    }
}

void RenameFileDialog::slotRenamePressed()
{
    if (d->nameEdit->text().isEmpty()) {
        return;
    }

bool fileExists = false;
    if (newName().isLocalFile()) {
        fileExists = QFile::exists(newName().path());
    } else {
        auto job = KIO::stat(newName(), KIO::StatJob::DestinationSide, 0);
        KJobWidgets::setWindow(job, this);
        fileExists = job->exec();
    }

if (fileExists) {
        KMessageBox::error(this, i18n("This filename \"%1\" already exists.", newName().toDisplayString(QUrl::PreferLocalFile)), i18n("File already exists"));
        return;
    }
    done(RENAMEFILE_RENAME);
}

void RenameFileDialog::slotApplyAllPressed()
{
    const bool enabled(!d->applyAll->isChecked());
    d->nameEdit->setEnabled(enabled);
    d->suggestNewNameBtn->setEnabled(enabled);
    d->renameBtn->setEnabled(enabled);
}

void RenameFileDialog::slotSuggestNewNamePressed()
{
    if (d->nameEdit->text().isEmpty()) {
        return;
    }

auto destDirectory = d->url.adjusted(QUrl::RemoveFilename);
    d->nameEdit->setText(d->suggestName(destDirectory, d->nameEdit->text()));
}

QUrl RenameFileDialog::newName() const
{
    const QString fileName = d->nameEdit->text();

auto newDest = d->url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
    newDest.setPath(newDest.path() + QLatin1Char('/') + KIO::encodeFileName(fileName));

return newDest;
}
070701000000E3000081A40000000200000002000000015CDAA39400000931000000000000000000000000000000000000005600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/renamefiledialog.h/*
 * Copyright (c) 2011-2019 Montel Laurent <montel@kde.org>
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of this program with any edition of
 *  the Qt library by Trolltech AS, Norway (or with modified versions
 *  of Qt that use the same license as Qt), and distribute linked
 *  combinations including the two.  You must obey the GNU General
 *  Public License in all respects for all of the code used other than
 *  Qt.  If you modify this file, you may extend this exception to
 *  your version of the file, but you are not obligated to do so.  If
 *  you do not wish to do so, delete this exception statement from
 *  your version.
 */

#ifndef RENAMEFILEDIALOG_H
#define RENAMEFILEDIALOG_H

#include <QDialog>
#include <QUrl>

#include "pimcommon_export.h"

namespace PimCommon {
class RenameFileDialogPrivate;
class PIMCOMMON_EXPORT RenameFileDialog : public QDialog
{
    Q_OBJECT
public:
    explicit RenameFileDialog(const QUrl &url, bool multiFiles, QWidget *parent);
    ~RenameFileDialog();

enum RenameFileDialogResult {
        RENAMEFILE_IGNORE = 0,
        RENAMEFILE_IGNOREALL = 1,
        RENAMEFILE_RENAME = 2,
        RENAMEFILE_OVERWRITE = 3,
        RENAMEFILE_OVERWRITEALL = 4
    };

Q_REQUIRED_RESULT QUrl newName() const;

private:
    void slotOverwritePressed();
    void slotIgnorePressed();
    void slotRenamePressed();
    void slotApplyAllPressed();
    void slotSuggestNewNamePressed();
    //@cond PRIVATE
    class RenameFileDialogPrivate;
    RenameFileDialogPrivate *const d;
};
}

#endif /* RENAMEFILEDIALOG_H */
070701000000E4000081A40000000200000002000000015CDAA39400003EB0000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/simplestringlisteditor.cpp/*
    simplestringlisteditor.cpp

This file is part of KMail, the KDE mail client.
    Copyright (c) 2001 Marc Mutz <mutz@kde.org>

KMail is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

KMail 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.

In addition, as a special exception, the copyright holders give
    permission to link the code of this program with any edition of
    the Qt library by Trolltech AS, Norway (or with modified versions
    of Qt that use the same license as Qt), and distribute linked
    combinations including the two.  You must obey the GNU General
    Public License in all respects for all of the code used other than
    Qt.  If you modify this file, you may extend this exception to
    your version of the file, but you are not obligated to do so.  If
    you do not wish to do so, delete this exception statement from
    your version.
*/

#include "simplestringlisteditor.h"

#include <QInputDialog>
#include <kiconloader.h>
#include <QIcon>
#include <KLocalizedString>
#include <KMessageBox>
#include "pimcommon_debug.h"
#include <QPushButton>
#include <QMenu>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QListWidget>

//********************************************************
// SimpleStringListEditor
//********************************************************
using namespace PimCommon;

class PimCommon::SimpleStringListEditorPrivate
{
public:
    SimpleStringListEditorPrivate()
    {
    }

QListWidget *mListBox = nullptr;
    QPushButton *mAddButton = nullptr;
    QPushButton *mRemoveButton = nullptr;
    QPushButton *mModifyButton = nullptr;
    QPushButton *mUpButton = nullptr;
    QPushButton *mDownButton = nullptr;
    QVBoxLayout *mButtonLayout = nullptr;
    QString mAddDialogLabel;
};

SimpleStringListEditor::SimpleStringListEditor(QWidget *parent, ButtonCode buttons, const QString &addLabel, const QString &removeLabel, const QString &modifyLabel, const QString &addDialogLabel)
    : QWidget(parent)
    , d(new SimpleStringListEditorPrivate)
{
    setAddDialogLabel(addDialogLabel);
    setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
    QHBoxLayout *hlay = new QHBoxLayout(this);
    hlay->setContentsMargins(0, 0, 0, 0);

d->mListBox = new QListWidget(this);

d->mListBox->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(d->mListBox, &QListWidget::customContextMenuRequested, this, &SimpleStringListEditor::slotContextMenu);

d->mListBox->setSelectionMode(QAbstractItemView::ExtendedSelection);
    hlay->addWidget(d->mListBox, 1);

if (buttons == None) {
        qCDebug(PIMCOMMON_LOG) << "SimpleStringListBox called with no buttons."
                                  "Consider using a plain QListBox instead!";
    }

d->mButtonLayout = new QVBoxLayout(); // inherits spacing
    hlay->addLayout(d->mButtonLayout);

if (buttons & Add) {
        if (addLabel.isEmpty()) {
            d->mAddButton = new QPushButton(i18n("&Add..."), this);
        } else {
            d->mAddButton = new QPushButton(addLabel, this);
        }
        d->mAddButton->setAutoDefault(false);
        d->mButtonLayout->addWidget(d->mAddButton);
        connect(d->mAddButton, &QPushButton::clicked, this, &SimpleStringListEditor::slotAdd);
    }

if (buttons & Modify) {
        if (modifyLabel.isEmpty()) {
            d->mModifyButton = new QPushButton(i18n("&Modify..."), this);
        } else {
            d->mModifyButton = new QPushButton(modifyLabel, this);
        }
        d->mModifyButton->setAutoDefault(false);
        d->mModifyButton->setEnabled(false);   // no selection yet
        d->mButtonLayout->addWidget(d->mModifyButton);
        connect(d->mModifyButton, &QPushButton::clicked, this, &SimpleStringListEditor::slotModify);
        connect(d->mListBox, &QListWidget::itemDoubleClicked, this, &SimpleStringListEditor::slotModify);
    }

if (buttons & Remove) {
        if (removeLabel.isEmpty()) {
            d->mRemoveButton = new QPushButton(i18n("&Remove"), this);
        } else {
            d->mRemoveButton = new QPushButton(removeLabel, this);
        }
        d->mRemoveButton->setAutoDefault(false);
        d->mRemoveButton->setEnabled(false);   // no selection yet
        d->mButtonLayout->addWidget(d->mRemoveButton);
        connect(d->mRemoveButton, &QPushButton::clicked, this, &SimpleStringListEditor::slotRemove);
    }

if (buttons & Up) {
        if (!(buttons & Down)) {
            qCDebug(PIMCOMMON_LOG) << "Are you sure you want to use an Up button"
                                      "without a Down button??";
        }
        d->mUpButton = new QPushButton(QString(), this);
        d->mUpButton->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
        d->mUpButton->setIconSize(QSize(KIconLoader::SizeSmall, KIconLoader::SizeSmall));
        d->mUpButton->setAutoDefault(false);
        d->mUpButton->setEnabled(false);   // no selection yet
        d->mButtonLayout->addWidget(d->mUpButton);
        connect(d->mUpButton, &QPushButton::clicked, this, &SimpleStringListEditor::slotUp);
    }

if (buttons & Down) {
        if (!(buttons & Up)) {
            qCDebug(PIMCOMMON_LOG) << "Are you sure you want to use a Down button"
                                      "without an Up button??";
        }
        d->mDownButton = new QPushButton(QString(), this);
        d->mDownButton->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
        d->mDownButton->setIconSize(QSize(KIconLoader::SizeSmall, KIconLoader::SizeSmall));
        d->mDownButton->setAutoDefault(false);
        d->mDownButton->setEnabled(false);   // no selection yet
        d->mButtonLayout->addWidget(d->mDownButton);
        connect(d->mDownButton, &QPushButton::clicked, this, &SimpleStringListEditor::slotDown);
    }

d->mButtonLayout->addStretch(1);   // spacer

connect(d->mListBox, &QListWidget::currentItemChanged, this, &SimpleStringListEditor::slotSelectionChanged);
    connect(d->mListBox, &QListWidget::itemSelectionChanged, this, &SimpleStringListEditor::slotSelectionChanged);
}

SimpleStringListEditor::~SimpleStringListEditor()
{
    delete d;
}

void SimpleStringListEditor::setUpDownAutoRepeat(bool b)
{
    if (d->mUpButton) {
        d->mUpButton->setAutoRepeat(b);
    }
    if (d->mDownButton) {
        d->mDownButton->setAutoRepeat(b);
    }
}

void SimpleStringListEditor::setStringList(const QStringList &strings)
{
    d->mListBox->clear();
    d->mListBox->addItems(strings);
}

void SimpleStringListEditor::appendStringList(const QStringList &strings)
{
    d->mListBox->addItems(strings);
}

QStringList SimpleStringListEditor::stringList() const
{
    QStringList result;
    const int numberOfItem(d->mListBox->count());
    result.reserve(numberOfItem);
    for (int i = 0; i < numberOfItem; ++i) {
        result << (d->mListBox->item(i)->text());
    }
    return result;
}

bool SimpleStringListEditor::containsString(const QString &str)
{
    const int numberOfItem(d->mListBox->count());
    for (int i = 0; i < numberOfItem; ++i) {
        if (d->mListBox->item(i)->text() == str) {
            return true;
        }
    }
    return false;
}

void SimpleStringListEditor::setButtonText(ButtonCode button, const QString &text)
{
    switch (button) {
    case Add:
        if (!d->mAddButton) {
            break;
        }
        d->mAddButton->setText(text);
        return;
    case Remove:
        if (!d->mRemoveButton) {
            break;
        }
        d->mRemoveButton->setText(text);
        return;
    case Modify:
        if (!d->mModifyButton) {
            break;
        }
        d->mModifyButton->setText(text);
        return;
    case Up:
    case Down:
        qCDebug(PIMCOMMON_LOG) << "SimpleStringListEditor: Cannot change text of"
                                  "Up and Down buttons: they don't contains text!";
        return;
    default:
        if (button & All) {
            qCDebug(PIMCOMMON_LOG) << "No such button!";
        } else {
            qCDebug(PIMCOMMON_LOG) << "Can only set text for one button at a time!";
        }
        return;
    }

qCDebug(PIMCOMMON_LOG) << "The requested button has not been created!";
}

void SimpleStringListEditor::addNewEntry()
{
    bool ok = false;
    const QString newEntry = QInputDialog::getText(this, i18n("New Value"),
                                                   d->mAddDialogLabel, QLineEdit::Normal, QString(),
                                                   &ok);
    if (ok && !newEntry.trimmed().isEmpty()) {
        insertNewEntry(newEntry);
    }
}

void SimpleStringListEditor::insertNewEntry(const QString &entry)
{
    QString newEntry = entry;
    // let the user verify the string before adding
    Q_EMIT aboutToAdd(newEntry);
    if (!newEntry.isEmpty() && !containsString(newEntry)) {
        d->mListBox->addItem(newEntry);
        slotSelectionChanged();
        Q_EMIT changed();
    }
}

void SimpleStringListEditor::slotAdd()
{
    addNewEntry();
}

void SimpleStringListEditor::slotRemove()
{
    const QList<QListWidgetItem *> selectedItems = d->mListBox->selectedItems();
    if (selectedItems.isEmpty()) {
        return;
    }
    if (KMessageBox::Yes == KMessageBox::warningYesNo(this, i18n("Do you want to remove selected text?"), i18n("Remove"))) {
        for (QListWidgetItem *item : selectedItems) {
            delete d->mListBox->takeItem(d->mListBox->row(item));
        }
        slotSelectionChanged();
        Q_EMIT changed();
    }
}

QString SimpleStringListEditor::modifyEntry(const QString &text)
{
    bool ok = false;
    QString newText = QInputDialog::getText(this, i18n("Change Value"),
                                            d->mAddDialogLabel, QLineEdit::Normal, text,
                                            &ok);
    Q_EMIT aboutToAdd(newText);

if (!ok || newText.trimmed().isEmpty() || newText == text) {
        return QString();
    }

return newText;
}

void SimpleStringListEditor::slotModify()
{
    QListWidgetItem *item = d->mListBox->currentItem();
    if (!item) {
        return;
    }
    const QString newText = modifyEntry(item->text());
    if (!newText.isEmpty()) {
        item->setText(newText);
        Q_EMIT changed();
    }
}

QList<QListWidgetItem *> SimpleStringListEditor::selectedItems() const
{
    QList<QListWidgetItem *> listWidgetItem;
    const int numberOfFilters = d->mListBox->count();
    for (int i = 0; i < numberOfFilters; ++i) {
        if (d->mListBox->item(i)->isSelected()) {
            listWidgetItem << d->mListBox->item(i);
        }
    }
    return listWidgetItem;
}

void SimpleStringListEditor::setAddDialogLabel(const QString &addDialogLabel)
{
    d->mAddDialogLabel = addDialogLabel.isEmpty() ? i18n("New entry:") : addDialogLabel;
}

void SimpleStringListEditor::slotUp()
{
    QList<QListWidgetItem *> listWidgetItem = selectedItems();
    if (listWidgetItem.isEmpty()) {
        return;
    }

const int numberOfItem(listWidgetItem.count());
    const int currentRow = d->mListBox->currentRow();
    if ((numberOfItem == 1) && (currentRow == 0)) {
        qCDebug(PIMCOMMON_LOG) << "Called while the _topmost_ filter is selected, ignoring.";
        return;
    }
    bool wasMoved = false;

for (int i = 0; i < numberOfItem; ++i) {
        const int posItem = d->mListBox->row(listWidgetItem.at(i));
        if (posItem == i) {
            continue;
        }
        QListWidgetItem *item = d->mListBox->takeItem(posItem);
        d->mListBox->insertItem(posItem - 1, item);

wasMoved = true;
    }
    if (wasMoved) {
        Q_EMIT changed();
        d->mListBox->setCurrentRow(currentRow - 1);
    }
}

void SimpleStringListEditor::slotDown()
{
    QList<QListWidgetItem *> listWidgetItem = selectedItems();
    if (listWidgetItem.isEmpty()) {
        return;
    }

const int numberOfElement(d->mListBox->count());
    const int numberOfItem(listWidgetItem.count());
    const int currentRow = d->mListBox->currentRow();
    if ((numberOfItem == 1) && (currentRow == numberOfElement - 1)) {
        qCDebug(PIMCOMMON_LOG) << "Called while the _last_ filter is selected, ignoring.";
        return;
    }

int j = 0;
    bool wasMoved = false;
    for (int i = numberOfItem - 1; i >= 0; --i, j++) {
        const int posItem = d->mListBox->row(listWidgetItem.at(i));
        if (posItem == (numberOfElement - 1 - j)) {
            continue;
        }
        QListWidgetItem *item = d->mListBox->takeItem(posItem);
        d->mListBox->insertItem(posItem + 1, item);
        wasMoved = true;
    }
    if (wasMoved) {
        Q_EMIT changed();
        d->mListBox->setCurrentRow(currentRow + 1);
    }
}

void SimpleStringListEditor::slotSelectionChanged()
{
    QList<QListWidgetItem *> lstSelectedItems = d->mListBox->selectedItems();
    const int numberOfItemSelected(lstSelectedItems.count());
    const bool uniqItemSelected = (numberOfItemSelected == 1);
    // if there is one, item will be non-null (ie. true), else 0
    // (ie. false):
    if (d->mRemoveButton) {
        d->mRemoveButton->setEnabled(!lstSelectedItems.isEmpty());
    }

if (d->mModifyButton) {
        d->mModifyButton->setEnabled(uniqItemSelected);
    }

const int currentIndex = d->mListBox->currentRow();

const bool aItemIsSelected = !lstSelectedItems.isEmpty();
    const bool allItemSelected = (d->mListBox->count() == numberOfItemSelected);
    const bool theLast = (currentIndex >= d->mListBox->count() - 1);
    const bool theFirst = (currentIndex == 0);

if (d->mUpButton) {
        d->mUpButton->setEnabled(aItemIsSelected && ((uniqItemSelected && !theFirst)
                                                     || (!uniqItemSelected)) && !allItemSelected);
    }
    if (d->mDownButton) {
        d->mDownButton->setEnabled(aItemIsSelected
                                   && ((uniqItemSelected && !theLast)
                                       || (!uniqItemSelected)) && !allItemSelected);
    }
}

void SimpleStringListEditor::slotContextMenu(const QPoint &pos)
{
    QList<QListWidgetItem *> lstSelectedItems = d->mListBox->selectedItems();
    const bool hasItemsSelected = !lstSelectedItems.isEmpty();
    QMenu menu(this);
    if (d->mAddButton) {
        QAction *act = menu.addAction(d->mAddButton->text(), this, &SimpleStringListEditor::slotAdd);
        act->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
    }
    if (d->mModifyButton && (lstSelectedItems.count() == 1)) {
        QAction *act = menu.addAction(d->mModifyButton->text(), this, &SimpleStringListEditor::slotModify);
        act->setIcon(QIcon::fromTheme(QStringLiteral("document-edit")));
    }
    if (d->mRemoveButton && hasItemsSelected) {
        menu.addSeparator();
        QAction *act = menu.addAction(d->mRemoveButton->text(), this, &SimpleStringListEditor::slotRemove);
        act->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
    }
    if (!menu.isEmpty()) {
        menu.exec(d->mListBox->mapToGlobal(pos));
    }
}

QSize SimpleStringListEditor::sizeHint() const
{
    // Override height because we want the widget to be tall enough to fit the
    // button columns, but we want to allow it to be made smaller than list
    // sizeHint().height()
    QSize sh = QWidget::sizeHint();
    sh.setHeight(d->mButtonLayout->minimumSize().height());
    return sh;
}
070701000000E5000081A40000000200000002000000015CDAA39400000F7E000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/simplestringlisteditor.h/*  -*- c++ -*-
    simplestringlisteditor.h

This file is part of KMail, the KDE mail client.
    Copyright (c) 2001 Marc Mutz <mutz@kde.org>

#ifndef SIMPLESTRINGLISTEDITOR_H
#define SIMPLESTRINGLISTEDITOR_H

#include <QWidget>
#include <QStringList>

#include "pimcommon_export.h"

class QListWidget;
class QListWidgetItem;

//
//
// SimpleStringListEditor (a listbox with "add..." and "remove" buttons)
//
//
namespace PimCommon {
class SimpleStringListEditorPrivate;
class PIMCOMMON_EXPORT SimpleStringListEditor : public QWidget
{
    Q_OBJECT
public:
    enum ButtonCode {
        None = 0x00,
        Add = 0x01,
        Remove = 0x02,
        Modify = 0x04,
        Up = 0x08,
        Down = 0x10,
        All = Add | Remove | Modify | Up | Down,
        Unsorted = Add | Remove | Modify
    };

/** Constructor. Populates the list with @p strings. */
    explicit SimpleStringListEditor(QWidget *parent = nullptr, ButtonCode buttons = Unsorted, const QString &addLabel = QString(),
                                    const QString &removeLabel = QString(), const QString &modifyLabel = QString(), const QString &addDialogLabel = QString());

~SimpleStringListEditor() override;
    /** Sets the list of strings displayed to @p strings */
    void setStringList(const QStringList &strings);

/** Adds @p strings to the list of displayed strings */
    void appendStringList(const QStringList &strings);

/** Retrieves the current list of strings */
    Q_REQUIRED_RESULT QStringList stringList() const;

/** Sets the text of button @p button to @p text */
    void setButtonText(ButtonCode button, const QString &text);

void setUpDownAutoRepeat(bool b);
    Q_REQUIRED_RESULT QSize sizeHint() const override;

virtual void addNewEntry();
    Q_REQUIRED_RESULT virtual QString modifyEntry(const QString &text);
    void setAddDialogLabel(const QString &addDialogLabel);

Q_SIGNALS:
    /** Connected slots can alter the argument to be added or set the
      argument to QString() to suppress adding.
    */
    void aboutToAdd(QString &);
    void changed();

protected:
    void insertNewEntry(const QString &newEntry);

protected Q_SLOTS:
    void slotAdd();
    void slotRemove();
    void slotModify();
    void slotUp();
    void slotDown();

void slotSelectionChanged();

private:
    void slotContextMenu(const QPoint &);
    bool containsString(const QString &str);
    QList<QListWidgetItem *> selectedItems() const;
    SimpleStringListEditorPrivate *const d;
};
}

#endif // SIMPLESTRINGLISTEDITOR_H
070701000000E6000081A40000000200000002000000015CDAA39400001156000000000000000000000000000000000000005A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/spellchecklineedit.cpp/*
 * Copyright (c) 2011-2019 Montel Laurent <montel@kde.org>
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of this program with any edition of
 *  the Qt library by Trolltech AS, Norway (or with modified versions
 *  of Qt that use the same license as Qt), and distribute linked
 *  combinations including the two.  You must obey the GNU General
 *  Public License in all respects for all of the code used other than
 *  Qt.  If you modify this file, you may extend this exception to
 *  your version of the file, but you are not obligated to do so.  If
 *  you do not wish to do so, delete this exception statement from
 *  your version.
 */

#include "spellchecklineedit.h"
#include <QStyleOptionFrame>
#include <QKeyEvent>
#include <QStyle>
#include <QApplication>
#include <QMimeData>

using namespace PimCommon;

SpellCheckLineEdit::SpellCheckLineEdit(QWidget *parent, const QString &configFile)
    : KPIMTextEdit::RichTextEditor(parent)
{
    setSpellCheckingConfigFileName(configFile);
    setSearchSupport(false);
    setAllowTabSupport(false);
    setAcceptRichText(false);
    setTabChangesFocus(true);
    // widget may not be resized vertically
    setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
    setLineWrapMode(NoWrap);
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setCheckSpellingEnabled(true);
    document()->adjustSize();

document()->setDocumentMargin(2);
}

SpellCheckLineEdit::~SpellCheckLineEdit()
{
}

void SpellCheckLineEdit::keyPressEvent(QKeyEvent *e)
{
    if (e->key() == Qt::Key_Enter
        || e->key() == Qt::Key_Return
        || e->key() == Qt::Key_Down) {
        Q_EMIT focusDown();
        return;
    } else if (e->key() == Qt::Key_Up) {
        Q_EMIT focusUp();
        return;
    }
    RichTextEditor::keyPressEvent(e);
}

QSize SpellCheckLineEdit::sizeHint() const
{
    QFontMetrics fm(font());

const int h = document()->size().toSize().height() - fm.descent() + 2 * frameWidth();

QStyleOptionFrame opt;
    opt.initFrom(this);
    opt.rect = QRect(0, 0, 100, h);
    opt.lineWidth = lineWidth();
    opt.midLineWidth = 0;
    opt.state |= QStyle::State_Sunken;

QSize s = style()->sizeFromContents(QStyle::CT_LineEdit, &opt, QSize(100, h).expandedTo(QApplication::globalStrut()), this);

return s;
}

QSize SpellCheckLineEdit::minimumSizeHint() const
{
    return sizeHint();
}

void SpellCheckLineEdit::insertFromMimeData(const QMimeData *source)
{
    if (!source) {
        return;
    }

setFocus();

// Copy text from the clipboard (paste)
    QString pasteText = source->text();

// is there any text in the clipboard?
    if (!pasteText.isEmpty()) {
        // replace \r with \n to make xterm pastes happy
        pasteText.replace(QLatin1Char('\r'), QLatin1Char('\n'));
        // remove blank lines
        while (pasteText.contains(QLatin1String("\n\n"))) {
            pasteText.replace(QLatin1String("\n\n"), QLatin1String("\n"));
        }

QRegExp reTopSpace(QStringLiteral("^ *\n"));
        while (pasteText.contains(reTopSpace)) {
            pasteText.remove(reTopSpace);
        }

QRegExp reBottomSpace(QStringLiteral("\n *$"));
        while (pasteText.contains(reBottomSpace)) {
            pasteText.remove(reBottomSpace);
        }

// does the text contain at least one newline character?
        pasteText.replace(QLatin1Char('\n'), QLatin1Char(' '));

insertPlainText(pasteText);
        ensureCursorVisible();
        return;
    } else {
        RichTextEditor::insertFromMimeData(source);
    }
}
070701000000E7000081A40000000200000002000000015CDAA3940000099E000000000000000000000000000000000000005800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/spellchecklineedit.h/*
 * Copyright (c) 2011-2019 Montel Laurent <montel@kde.org>
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of this program with any edition of
 *  the Qt library by Trolltech AS, Norway (or with modified versions
 *  of Qt that use the same license as Qt), and distribute linked
 *  combinations including the two.  You must obey the GNU General
 *  Public License in all respects for all of the code used other than
 *  Qt.  If you modify this file, you may extend this exception to
 *  your version of the file, but you are not obligated to do so.  If
 *  you do not wish to do so, delete this exception statement from
 *  your version.
 */

#ifndef SpellCheckLineEdit_H
#define SpellCheckLineEdit_H
#include "pimcommon_export.h"
#include "kpimtextedit/richtexteditor.h"

class QMimeData;
namespace PimCommon {
class PIMCOMMON_EXPORT SpellCheckLineEdit : public KPIMTextEdit::RichTextEditor
{
    Q_OBJECT

public:
    /**
    * Constructs a SpellCheckLineEdit object.
    * @param parent of widget
    * @param configFile config file name for spell checking
    */
    explicit SpellCheckLineEdit(QWidget *parent, const QString &configFile);
    /**
    * Destructor
    */
    ~SpellCheckLineEdit() override;

protected:
    QSize sizeHint() const override;
    QSize minimumSizeHint() const override;
    void keyPressEvent(QKeyEvent *) override;
    void insertFromMimeData(const QMimeData *source) override;

Q_SIGNALS:
    /**
    * Emitted when the user uses the up arrow in the first line. The application
    * should then put the focus on the widget above the text edit.
    */
    void focusUp();

void focusDown();
};
}
#endif /* SpellCheckLineEdit_H */
070701000000E8000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/tests070701000000E9000081A40000000200000002000000015CDAA394000001F5000000000000000000000000000000000000005800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/tests/CMakeLists.txt######
set(testspellchecklineedit_SRCS testspellchecklineedit.cpp)

add_executable(testspellchecklineedit ${testspellchecklineedit_SRCS})
ecm_mark_as_test(testspellchecklineedit)

target_link_libraries(testspellchecklineedit KF5::PimCommon KF5::PimTextEdit KF5::I18n)
######
set(customtoolswidgetng_gui_SRCS customtoolswidgetng_gui.cpp)
add_executable(customtoolswidgetng_gui ${customtoolswidgetng_gui_SRCS})
target_link_libraries(customtoolswidgetng_gui
  KF5::PimCommon
  KF5::XmlGui
  KF5::I18n
)

070701000000EA000081A40000000200000002000000015CDAA394000007FD000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/tests/customtoolswidgetng_gui.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "customtoolswidgetng_gui.h"
#include "customtools/customtoolswidgetng.h"
#include "customtools/customtoolspluginmanager.h"
#include <QStandardPaths>
#include <KToggleAction>

#include <QVBoxLayout>
#include <QApplication>
#include <QCommandLineParser>
#include <QToolBar>

#include <KXmlGui/kactioncollection.h>

CustomToolWidgetNgTest::CustomToolWidgetNgTest(QWidget *parent)
    : QWidget(parent)
{
    QVBoxLayout *lay = new QVBoxLayout(this);

QToolBar *menu = new QToolBar(this);
    lay->addWidget(menu);

mCustomTools = new PimCommon::CustomToolsWidgetNg(this);
    mCustomTools->initializeView(new KActionCollection(this), PimCommon::CustomToolsPluginManager::self()->pluginsList());
    const QList<KToggleAction *> lst = mCustomTools->actionList();
    for (KToggleAction *act : lst) {
        menu->addAction(act);
    }

lay->addWidget(mCustomTools);
}

CustomToolWidgetNgTest::~CustomToolWidgetNgTest()
{
}

CustomToolWidgetNgTest *w = new CustomToolWidgetNgTest();
    w->resize(800, 200);
    w->show();
    const int ret = app.exec();
    delete w;
    return ret;
}
070701000000EB000081A40000000200000002000000015CDAA39400000444000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/tests/customtoolswidgetng_gui.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef TEST_CUSTOMTOOLSWIDGETNG_GUI_H
#define TEST_CUSTOMTOOLSWIDGETNG_GUI_H

#include <QWidget>
namespace PimCommon {
class CustomToolsWidgetNg;
}

class CustomToolWidgetNgTest : public QWidget
{
    Q_OBJECT
public:
    explicit CustomToolWidgetNgTest(QWidget *parent = nullptr);
    ~CustomToolWidgetNgTest();

private:
    PimCommon::CustomToolsWidgetNg *mCustomTools;
};

#endif
070701000000EC000081A40000000200000002000000015CDAA39400000556000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommon/widgets/tests/testspellchecklineedit.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <QWidget>
#include <QVBoxLayout>

#include <QApplication>
#include <QCommandLineParser>

#include "../spellchecklineedit.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QCommandLineParser parser;
    parser.addVersionOption();
    parser.addHelpOption();
    parser.process(app);

QWidget *w = new QWidget;
    QVBoxLayout *vbox = new QVBoxLayout(w);

PimCommon::SpellCheckLineEdit *spellCheckLineEdit = new PimCommon::SpellCheckLineEdit(w, QStringLiteral("testspecklineeditrc"));
    vbox->addWidget(spellCheckLineEdit);
    vbox->addStretch();

w->resize(400, 400);
    w->show();

return app.exec();
}
070701000000ED000041ED00000002000000020000000A5CDAA39400000000000000000000000000000000000000000000004200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi070701000000EE000081A40000000200000002000000015CDAA39400001F8C000000000000000000000000000000000000005100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/CMakeLists.txtinclude_directories(${CMAKE_CURRENT_SOURCE_DIR})

set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5PimCommonAkonadi")

configure_package_config_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/KF5PimCommonAkonadiConfig.cmake.in"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonAkonadiConfig.cmake"
    INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
    )

ecm_setup_version(PROJECT VARIABLE_PREFIX PIMCOMMON
    VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/pimcommonakonadi_version.h"
    PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonAkonadiConfigVersion.cmake"
    SOVERSION 5
    )

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonAkonadiConfig.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5PimCommonAkonadiConfigVersion.cmake"
    DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
    COMPONENT Devel
    )

install(EXPORT KF5PimCommonAkonadiTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE KF5PimCommonAkonadiTargets.cmake NAMESPACE KF5::)

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/pimcommonakonadi_version.h
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5} COMPONENT Devel
    )

set(libpimcommonakonadi_folderdialog_SRCS
    folderdialog/selectmulticollectionwidget.cpp
    folderdialog/selectmulticollectiondialog.cpp
    folderdialog/checkedcollectionwidget.cpp
    )

set(libpimcommonakonadi_generericplugin_SRCS
    genericplugins/genericplugininterface.cpp
    genericplugins/plugininterface.cpp
    )

set(libpimcommonakonadi_acl_SRCS
    acl/aclentrydialog.cpp
    acl/aclmanager.cpp
    acl/aclutils.cpp
    acl/collectionaclpage.cpp
    acl/imapaclattribute.cpp
    acl/collectionaclwidget.cpp
    acl/acllistview.cpp
    acl/aclmodifyjob.cpp
    )

set(libpimcommonakonadi_manageserversidesubscription_SRCS
    manageserversidesubscription/manageserversidesubscriptionjob.cpp
    )

set(libpimcommonakonadi_widgets_SRCS
    widgets/annotationdialog.cpp
    )

set(libpimcommon_job_SRCS
    job/fetchrecursivecollectionsjob.cpp
    )

set(libpimcommonakonadi_util_SRCS
    util/createresource.cpp
    util/imapresourcecapabilitiesmanager.cpp
    util/mailutil.cpp
    )

set(libpimcommonakonadi_collection_SRCS
  collectionpage/collectiontypeutil.cpp
  collectionpage/attributeregistrar.cpp
  collectionpage/attributes/collectionannotationsattribute.cpp
  collectionpage/incidencesforwidget.cpp
  collectionpage/contenttypewidget.cpp
)

set(libpimcommonakonadi_SRCS
    ${libpimcommonakonadi_collection_SRCS}
    ${libpimcommonakonadi_acl_SRCS}
    ${libpimcommonakonadi_folderdialog_SRCS}
    ${libpimcommonakonadi_generericplugin_SRCS}
    ${libpimcommonakonadi_configure_plugins_SRCS}
    ${libpimcommonakonadi_manageserversidesubscription_SRCS}
    ${libpimcommonakonadi_widgets_SRCS}
    ${libpimcommonakonadi_util_SRCS}
    ${libpimcommon_job_SRCS}
    )

ecm_qt_declare_logging_category(libpimcommonakonadi_SRCS HEADER pimcommonakonadi_debug.h IDENTIFIER PIMCOMMONAKONADI_LOG CATEGORY_NAME org.kde.pim.pimcommonakonadi)

add_library(KF5PimCommonAkonadi ${libpimcommonakonadi_SRCS})
generate_export_header(KF5PimCommonAkonadi BASE_NAME pimcommonakonadi)
add_library(KF5::PimCommonAkonadi ALIAS KF5PimCommonAkonadi)

target_link_libraries(KF5PimCommonAkonadi
    PUBLIC
    KF5::PimCommon
    KF5::AkonadiCore
    KF5::AkonadiWidgets
    KF5::Contacts
    KF5::AkonadiContact
    KF5::KIOCore
    KF5::ConfigWidgets
    KF5::IMAP
    PRIVATE
    KF5::I18n
    KF5::LibkdepimAkonadi
    KF5::Codecs
    KF5::PimTextEdit
    KF5::DBusAddons
    KF5::XmlGui
    KF5::PimTextEdit
    KF5::Completion
    KF5::KIOWidgets
    )

target_include_directories(KF5PimCommonAkonadi INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/PimCommonAkonadi/;${KDE_INSTALL_INCLUDEDIR_KF5}/pimcommonakonadi>")

target_include_directories(KF5PimCommonAkonadi PUBLIC "$<BUILD_INTERFACE:${pimcommon_SOURCE_DIR}/src;${pimcommon_BINARY_DIR}/src>")

set_target_properties(KF5PimCommonAkonadi PROPERTIES
    VERSION ${PIMCOMMON_VERSION_STRING}
    SOVERSION ${PIMCOMMON_SOVERSION}
    EXPORT_NAME PimCommonAkonadi
    )

install(TARGETS
    KF5PimCommonAkonadi
    EXPORT KF5PimCommonAkonadiTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS}  ${LIBRARY_NAMELINK}
    )

if (BUILD_TESTING)
    add_subdirectory(acl/autotests)
    add_subdirectory(folderdialog/tests/)
    add_subdirectory(collectionpage/autotests/)
endif()

ecm_generate_headers(PimCommonAkonadi_Camelcasecollectionpage_HEADERS
  HEADER_NAMES
  IncidencesForWidget
  CollectionTypeUtil
  ContentTypeWidget
  REQUIRED_HEADERS PimCommonAkonadi_collectionpage_HEADERS
  PREFIX PimCommonAkonadi
  RELATIVE collectionpage
)

ecm_generate_headers(PimCommonAkonadi_Camelcasecollectionpageattributes_HEADERS
  HEADER_NAMES
  CollectionAnnotationsAttribute
  REQUIRED_HEADERS PimCommonAkonadi_collectionpageattributes_HEADERS
  PREFIX PimCommonAkonadi
  RELATIVE collectionpage/attributes
)

ecm_generate_headers(PimCommonAkonadiUtil_CamelCase_HEADERS
    HEADER_NAMES
    CreateResource
    ImapResourceCapabilitiesManager
    MailUtil
    REQUIRED_HEADERS PimCommonAkonadiUtil_HEADERS
    PREFIX PimCommonAkonadi
    RELATIVE util
    )

ecm_generate_headers(PimCommon_CamelCasejob_HEADERS
    HEADER_NAMES
    FetchRecursiveCollectionsJob
    REQUIRED_HEADERS PimCommon_job_HEADERS
    PREFIX PimCommonAkonadi
    RELATIVE job
    )

ecm_generate_headers(PimCommonAkonadi_Camelcasewidgets_HEADERS
    HEADER_NAMES
    AnnotationDialog
    REQUIRED_HEADERS PimCommonAkonadi_widgets_HEADERS
    PREFIX PimCommonAkonadi
    RELATIVE widgets
    )

ecm_generate_headers(PimCommon_Camelcasemanagerserversidesubscription_HEADERS
    HEADER_NAMES
    ManageServerSideSubscriptionJob
    REQUIRED_HEADERS PimCommon_managerserversidesubscription_HEADERS
    PREFIX PimCommonAkonadi
    RELATIVE manageserversidesubscription
    )

ecm_generate_headers(PimCommon_Camelcaseacl_HEADERS
    HEADER_NAMES
    CollectionAclPage
    ImapAclAttribute
    REQUIRED_HEADERS PimCommon_acl_HEADERS
    PREFIX PimCommonAkonadi
    RELATIVE acl
    )

ecm_generate_headers(PimCommon_Camelcasefolderdialog_HEADERS
    HEADER_NAMES
    CheckedCollectionWidget
    SelectMultiCollectionDialog
    REQUIRED_HEADERS PimCommon_folderdialog_HEADERS
    PREFIX PimCommonAkonadi
    RELATIVE folderdialog
    )

ecm_generate_headers(PimCommonAkonadi_CamelCasegenericplugins_HEADERS
    HEADER_NAMES
    PluginInterface
    GenericPluginInterface
    REQUIRED_HEADERS PimCommonAkonadi_genericplugins_HEADERS
    PREFIX PimCommonAkonadi
    RELATIVE genericplugins
    )

ecm_generate_pri_file(BASE_NAME PimCommonAkonadi
    LIB_NAME KF5PimCommonAkonadi
    DEPS "AkonadiCore AkonadiWidgets Contacts AkonadiContact Network KIOCore ConfigWidgets" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/PimCommonAkonadi
    )

install(FILES
    ${PimCommonAkonadi_Camelcasecollectionpage_HEADERS}
    ${PimCommonAkonadi_Camelcasecollectionpageattributes_HEADERS}
    ${PimCommon_CamelCasejob_HEADERS}
    ${PimCommon_Camelcaseacl_HEADERS}
    ${PimCommon_Camelcasefolderdialog_HEADERS}
    ${PimCommonAkonadi_CamelCasegenericplugins_HEADERS}
    ${PimCommon_Camelcasemanagerserversidesubscription_HEADERS}
    ${PimCommonAkonadi_Camelcasewidgets_HEADERS}
    ${PimCommonAkonadiUtil_CamelCase_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/PimCommonAkonadi
    COMPONENT Devel
    )

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/pimcommonakonadi_export.h
    ${PimCommon_acl_HEADERS}
    ${PimCommonAkonadi_collectionpage_HEADERS}
    ${PimCommonAkonadi_collectionpageattributes_HEADERS}
    ${PimCommon_folderdialog_HEADERS}
    ${PimCommonAkonadi_genericplugins_HEADERS}
    ${PimCommon_serversidesubscription_HEADERS}
    ${PimCommonAkonadi_casewidgets_HEADERS}
    ${PimCommonAkonadi_widgets_HEADERS}
    ${PimCommon_managerserversidesubscription_HEADERS}
    ${PimCommon_job_HEADERS}
    ${PimCommonAkonadiUtil_HEADERS}

DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/pimcommonakonadi
    COMPONENT Devel
    )

install(FILES
    ${PRI_FILENAME}
    DESTINATION ${ECM_MKSPECS_INSTALL_DIR})
070701000000EF000081A40000000200000002000000015CDAA394000001AD000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/KF5PimCommonAkonadiConfig.cmake.in@PACKAGE_INIT@
include(CMakeFindDependencyMacro)
find_dependency(KF5Akonadi "@AKONADI_VERSION@")
find_dependency(KF5Contacts "@KCONTACTS_LIB_VERSION@")
find_dependency(KF5AkonadiContact "@AKONADICONTACT_LIB_VERSION@")
find_dependency(KF5Config "@KF5_MIN_VERSION@")
find_dependency(KF5PimCommon "@PIM_VERSION@")
find_dependency(KF5IMAP "@KIMAP_LIB_VERSION@")

include("${CMAKE_CURRENT_LIST_DIR}/KF5PimCommonAkonadiTargets.cmake")
070701000000F0000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl070701000000F1000081A40000000200000002000000015CDAA3940000189D000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclentrydialog.cpp/*
 * Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
 * Copyright (c) 2010 Tobias Koenig <tokoe@kdab.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "aclentrydialog_p.h"
#include "aclutils_p.h"

#include <LibkdepimAkonadi/AddresseeLineEdit>

#include <Akonadi/Contact/EmailAddressSelectionDialog>

#include <KLocalizedString>

#include <QButtonGroup>
#include <QGridLayout>
#include <QGroupBox>
#include <QLabel>
#include <QPushButton>
#include <QRadioButton>
#include <QVBoxLayout>
#include <QDialogButtonBox>

using namespace PimCommon;

class AclEntryDialog::Private
{
public:
    Private(AclEntryDialog *qq)
        : q(qq)
        , mButtonGroup(nullptr)
        , mUserIdLineEdit(nullptr)
        , mButtonLayout(nullptr)
        , mOkButton(nullptr)
    {
    }

void slotChanged();
    void slotSelectAddresses();

AclEntryDialog *q = nullptr;
    QButtonGroup *mButtonGroup = nullptr;
    KPIM::AddresseeLineEdit *mUserIdLineEdit = nullptr;
    QVBoxLayout *mButtonLayout = nullptr;
    KIMAP::Acl::Rights mCustomPermissions;
    QPushButton *mOkButton = nullptr;
};

void AclEntryDialog::Private::slotChanged()
{
    mOkButton->setEnabled(!mUserIdLineEdit->text().trimmed().isEmpty() && mButtonGroup->checkedButton() != nullptr);
}

void AclEntryDialog::Private::slotSelectAddresses()
{
    Akonadi::EmailAddressSelectionDialog dlg;

if (!dlg.exec()) {
        return;
    }

const QString text = !dlg.selectedAddresses().isEmpty()
                         ? dlg.selectedAddresses().at(0).quotedEmail()
                         : QString();

mUserIdLineEdit->setText(text);
}

AclEntryDialog::AclEntryDialog(QWidget *parent)
    : QDialog(parent)
    , d(new Private(this))
{
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
    d->mOkButton = buttonBox->button(QDialogButtonBox::Ok);
    d->mOkButton->setDefault(true);
    d->mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &AclEntryDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &AclEntryDialog::reject);

QWidget *page = new QWidget(this);
    mainLayout->addWidget(page);
    mainLayout->addWidget(buttonBox);

QGridLayout *layout = new QGridLayout(page);
    layout->setContentsMargins(0, 0, 0, 0);

QLabel *label = new QLabel(i18n("&User identifier:"), page);
    layout->addWidget(label, 0, 0);

d->mUserIdLineEdit = new KPIM::AddresseeLineEdit(page);
    layout->addWidget(d->mUserIdLineEdit, 0, 1);
    label->setBuddy(d->mUserIdLineEdit);
    d->mUserIdLineEdit->setWhatsThis(
        i18nc("@info:whatsthis",
              "The User Identifier is the login of the user on the IMAP server. "
              "This can be a simple user name or the full email address of the user; "
              "the login for your own account on the server will tell you which one it is."));

QPushButton *button = new QPushButton(i18nc("select an email address", "Se&lect..."), page);
    layout->addWidget(button, 0, 2);

QGroupBox *groupBox = new QGroupBox(i18n("Permissions"), page);
    d->mButtonLayout = new QVBoxLayout(groupBox);

d->mButtonGroup = new QButtonGroup(groupBox);

for (unsigned int i = 0; i < AclUtils::standardPermissionsCount(); ++i) {
        const KIMAP::Acl::Rights permissions = AclUtils::permissionsForIndex(i);

QRadioButton *radioButton
            = new QRadioButton(AclUtils::permissionsToUserString(permissions), groupBox);
        d->mButtonLayout->addWidget(radioButton);
        d->mButtonGroup->addButton(radioButton, permissions);
    }

d->mButtonLayout->addStretch(1);
    layout->addWidget(groupBox, 1, 0, 1, 3);

label
        = new QLabel(
              i18n("<b>Note: </b>Renaming requires write permissions on the parent folder."), page);
    layout->addWidget(label, 2, 0, 1, 3);
    layout->setRowStretch(2, 10);

connect(d->mUserIdLineEdit, &KPIM::AddresseeLineEdit::textChanged, this, [this]() {
        d->slotChanged();
    });
    connect(button, &QPushButton::clicked, this, [this]() {
        d->slotSelectAddresses();
    });
    connect(d->mButtonGroup, QOverload<QAbstractButton *>::of(&QButtonGroup::buttonClicked), this, [this]() {
        d->slotChanged();
    });

d->mOkButton->setEnabled(false);

d->mUserIdLineEdit->setFocus();
}

AclEntryDialog::~AclEntryDialog()
{
    delete d;
}

void AclEntryDialog::setUserId(const QString &userId)
{
    d->mUserIdLineEdit->setText(userId);

d->mOkButton->setEnabled(!userId.isEmpty());
}

QString AclEntryDialog::userId() const
{
    return d->mUserIdLineEdit->text();
}

void AclEntryDialog::setPermissions(KIMAP::Acl::Rights permissions)
{
    QAbstractButton *button = d->mButtonGroup->button(KIMAP::Acl::normalizedRights(permissions));

if (button) {
        button->setChecked(true);
    } else {
        QRadioButton *radioButton
            = new QRadioButton(AclUtils::permissionsToUserString(permissions));

d->mButtonLayout->addWidget(radioButton);
        d->mButtonGroup->addButton(radioButton, permissions);
    }

d->mCustomPermissions = permissions;
}

KIMAP::Acl::Rights AclEntryDialog::permissions() const
{
    QAbstractButton *button = d->mButtonGroup->checkedButton();

if (!button) {
        return d->mCustomPermissions;
    }

return KIMAP::Acl::denormalizedRights(
        static_cast<KIMAP::Acl::Rights>(d->mButtonGroup->id(button)));
}

#include "moc_aclentrydialog_p.cpp"
070701000000F2000081A40000000200000002000000015CDAA39400000783000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclentrydialog_p.h/*
 * Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
 * Copyright (c) 2010 Tobias Koenig <tokoe@kdab.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef PIMCOMMON_ACLENTRYDIALOG_P_H
#define PIMCOMMON_ACLENTRYDIALOG_P_H

#include <KIMAP/Acl>

#include <QDialog>

namespace PimCommon {
/**
 * @short A dialog for editing an IMAP ACL entry.
 */
class AclEntryDialog : public QDialog
{
    Q_OBJECT

public:
    /**
     * Creates a new ACL entry dialog.
     *
     * @param parent The parent widget.
     */
    explicit AclEntryDialog(QWidget *parent = nullptr);

/**
     * Destroys the ACL entry dialog.
     */
    ~AclEntryDialog();

/**
     * Sets the user @p id of the ACL entry.
     */
    void setUserId(const QString &id);

/**
     * Returns the user id of the ACL entry.
     */
    Q_REQUIRED_RESULT QString userId() const;

/**
     * Sets the permissions of the ACL entry.
     */
    void setPermissions(KIMAP::Acl::Rights permissions);

/**
     * Returns the permissions of the ACL entry.
     */
    Q_REQUIRED_RESULT KIMAP::Acl::Rights permissions() const;

private:
    //@cond PRIVATE
    class Private;
    Private *const d;

//@endcond
};
}

#endif
070701000000F3000081A40000000200000002000000015CDAA39400000732000000000000000000000000000000000000005600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/acllistview.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "acllistview.h"
#include <KLocalizedString>
#include <QPainter>

using namespace PimCommon;

AclListView::AclListView(QWidget *parent)
    : QListView(parent)
    , mCanBeAdministrated(true)
{
}

AclListView::~AclListView()
{
}

void AclListView::slotCollectionCanBeAdministrated(bool b)
{
    if (mCanBeAdministrated != b) {
        mCanBeAdministrated = b;
        update();
    }
}

void AclListView::generalPaletteChanged()
{
    const QPalette palette = viewport()->palette();
    QColor color = palette.text().color();
    color.setAlpha(128);
    mTextColor = color;
}

void AclListView::paintEvent(QPaintEvent *event)
{
    if (!mCanBeAdministrated) {
        QPainter p(viewport());

QFont font = p.font();
        font.setItalic(true);
        p.setFont(font);

if (!mTextColor.isValid()) {
            generalPaletteChanged();
        }
        p.setPen(mTextColor);

p.drawText(QRect(0, 0, width(), height()), Qt::AlignCenter, i18n("Folder cannot be administrated."));
    } else {
        QListView::paintEvent(event);
    }
}
070701000000F4000081A40000000200000002000000015CDAA39400000532000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/acllistview.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef ACLLISTVIEW_H
#define ACLLISTVIEW_H

#include <QListView>
#include "pimcommonakonadi_private_export.h"
namespace PimCommon {
class PIMCOMMONAKONADI_TESTS_EXPORT AclListView : public QListView
{
    Q_OBJECT
public:
    explicit AclListView(QWidget *parent = nullptr);
    ~AclListView() override;

public Q_SLOTS:
    void slotCollectionCanBeAdministrated(bool b);

protected:
    void paintEvent(QPaintEvent *event) override;

private:
    void generalPaletteChanged();
    QColor mTextColor;
    bool mCanBeAdministrated;
};
}
#endif // ACLLISTVIEW_H
070701000000F5000081A40000000200000002000000015CDAA39400003A42000000000000000000000000000000000000005500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclmanager.cpp/*
 * Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
 * Copyright (c) 2010 Tobias Koenig <tokoe@kdab.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "aclmanager.h"
#include "aclentrydialog_p.h"
#include "aclutils_p.h"
#include "aclmodifyjob.h"
#include "imapaclattribute.h"
#include "imapresourcesettings.h"
#include "pimcommonakonadi_debug.h"
#include "util/pimutil.h"

#include <AkonadiCore/CollectionFetchJob>
#include <AkonadiCore/ServerManager>

#include <KEmailAddress>
#include <KLocalizedString>
#include <KMessageBox>

#include <QAbstractListModel>
#include <QAction>
#include <QDBusInterface>
#include <QDBusReply>
#include <QItemSelectionModel>

using namespace PimCommon;

class AclModel : public QAbstractListModel
{
public:
    enum Role {
        UserIdRole = Qt::UserRole + 1,
        PermissionsRole,
        PermissionsTextRole
    };

AclModel(QObject *parent = nullptr)
        : QAbstractListModel(parent)
    {
    }

QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override
    {
        if (index.row() < 0 || index.row() >= mRights.count()) {
            return QVariant();
        }

const QPair<QByteArray, KIMAP::Acl::Rights> right = mRights.at(index.row());
        switch (role) {
        case Qt::DisplayRole:
            return QStringLiteral("%1: %2").
                   arg(QString::fromLatin1(right.first), AclUtils::permissionsToUserString(right.second));
        case UserIdRole:
            return QString::fromLatin1(right.first);
        case PermissionsRole:
            return QVariant(static_cast<int>(right.second));
        case PermissionsTextRole:
            return AclUtils::permissionsToUserString(right.second);
        default:
            return QVariant();
        }
    }

bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override
    {
        if (index.row() < 0 || index.row() >= mRights.count()) {
            return false;
        }

QPair<QByteArray, KIMAP::Acl::Rights> &right = mRights[ index.row() ];
        switch (role) {
        case UserIdRole:
            right.first = value.toByteArray();
            Q_EMIT dataChanged(index, index);
            return true;
        case PermissionsRole:
            right.second = static_cast<KIMAP::Acl::Rights>(value.toInt());
            Q_EMIT dataChanged(index, index);
            return true;
        default:
            return false;
        }

return false;
    }

int rowCount(const QModelIndex &parent = QModelIndex()) const override
    {
        if (parent.isValid()) {
            return 0;
        } else {
            return mRights.count();
        }
    }

void setRights(const QMap<QByteArray, KIMAP::Acl::Rights> &rights)
    {
        beginResetModel();

mRights.clear();

QMap<QByteArray, KIMAP::Acl::Rights>::const_iterator it = rights.cbegin();
        const QMap<QByteArray, KIMAP::Acl::Rights>::const_iterator itEnd = rights.cend();
        for (; it != itEnd; ++it) {
            mRights.append(qMakePair(it.key(), it.value()));
        }

endResetModel();
    }

QMap<QByteArray, KIMAP::Acl::Rights> rights() const
    {
        QMap<QByteArray, KIMAP::Acl::Rights> result;

typedef QPair<QByteArray, KIMAP::Acl::Rights> RightPair;
        for (const RightPair &right : qAsConst(mRights)) {
            result.insert(right.first, right.second);
        }

return result;
    }

protected:
    bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex()) override
    {
        beginInsertRows(parent, row, row + count - 1);
        for (int i = 0; i < count; ++i) {
            mRights.insert(row, qMakePair(QByteArray(), KIMAP::Acl::Rights()));
        }
        endInsertRows();

return true;
    }

bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override
    {
        beginRemoveRows(parent, row, row + count - 1);
        for (int i = 0; i < count; ++i) {
            mRights.remove(row, count);
        }
        endRemoveRows();

return true;
    }

private:
    QVector<QPair<QByteArray, KIMAP::Acl::Rights> > mRights;
};

class Q_DECL_HIDDEN PimCommon::AclManager::Private
{
public:
    Private(AclManager *qq)
        : q(qq)
        , mChanged(false)
    {
        mAddAction = new QAction(i18n("Add Entry..."), q);
        q->connect(mAddAction, &QAction::triggered, q, [this]() {
            addAcl();
        });

mEditAction = new QAction(i18n("Edit Entry..."), q);
        mEditAction->setEnabled(false);
        q->connect(mEditAction, &QAction::triggered, q, [this]() {
            editAcl();
        });

mDeleteAction = new QAction(i18n("Remove Entry"), q);
        mDeleteAction->setEnabled(false);
        q->connect(mDeleteAction, &QAction::triggered, q, [this]() {
            deleteAcl();
        });

mModel = new AclModel(q);

mSelectionModel = new QItemSelectionModel(mModel);
        q->connect(mSelectionModel, &QItemSelectionModel::selectionChanged, q, [this]() {
            selectionChanged();
        });
    }

~Private()
    {
    }

void selectionChanged()
    {
        const bool itemSelected = !mSelectionModel->selectedIndexes().isEmpty();

bool canAdmin = (mUserRights & KIMAP::Acl::Admin);

bool canAdminThisItem = canAdmin;
        if (canAdmin && itemSelected) {
            const QModelIndex index = mSelectionModel->selectedIndexes().first();
            const QString userId = index.data(AclModel::UserIdRole).toString();
            const KIMAP::Acl::Rights rights
                = static_cast<KIMAP::Acl::Rights>(index.data(AclModel::PermissionsRole).toInt());

// Don't allow users to remove their own admin permissions - there's no way back
            if (mImapUserName == userId && (rights & KIMAP::Acl::Admin)) {
                canAdminThisItem = false;
            }
        }

mAddAction->setEnabled(canAdmin);
        mEditAction->setEnabled(itemSelected && canAdminThisItem);
        mDeleteAction->setEnabled(itemSelected && canAdminThisItem);
    }

void addAcl()
    {
        AclEntryDialog dlg;
        dlg.setWindowTitle(i18n("Add ACL"));

if (!dlg.exec()) {
            return;
        }
        const QString userId = dlg.userId();
        const QStringList lstAddresses = KEmailAddress::splitAddressList(dlg.userId());
        for (const QString &addr : lstAddresses) {
            if (mModel->insertRow(mModel->rowCount())) {
                const QModelIndex index = mModel->index(mModel->rowCount() - 1, 0);
                mModel->setData(index, addr, AclModel::UserIdRole);
                mModel->setData(index, static_cast<int>(dlg.permissions()), AclModel::PermissionsRole);

mChanged = true;
            }
        }
    }

void editAcl()
    {
        if (mEditAction->isEnabled()) {
            const QModelIndex index = mSelectionModel->selectedIndexes().first();
            const QString userId = index.data(AclModel::UserIdRole).toString();
            const KIMAP::Acl::Rights permissions
                = static_cast<KIMAP::Acl::Rights>(index.data(AclModel::PermissionsRole).toInt());

AclEntryDialog dlg;
            dlg.setWindowTitle(i18n("Edit ACL"));
            dlg.setUserId(userId);
            dlg.setPermissions(permissions);

if (!dlg.exec()) {
                return;
            }
            const QStringList lstAddresses = KEmailAddress::splitAddressList(dlg.userId());
            if (lstAddresses.count() == 1) {
                mModel->setData(index, lstAddresses.at(0), AclModel::UserIdRole);
                mModel->setData(index, static_cast<int>(dlg.permissions()), AclModel::PermissionsRole);
                mChanged = true;
            } else {
                bool firstElement = true;
                for (const QString &addr : lstAddresses) {
                    if (firstElement) {
                        mModel->setData(index, lstAddresses.at(0), AclModel::UserIdRole);
                        mModel->setData(index, static_cast<int>(dlg.permissions()), AclModel::PermissionsRole);
                        firstElement = false;
                    } else {
                        if (mModel->insertRow(mModel->rowCount())) {
                            const QModelIndex index = mModel->index(mModel->rowCount() - 1, 0);
                            mModel->setData(index, addr, AclModel::UserIdRole);
                            mModel->setData(index, static_cast<int>(dlg.permissions()), AclModel::PermissionsRole);
                        }
                    }
                }
                mChanged = true;
            }
        }
    }

void deleteAcl()
    {
        const QModelIndex index = mSelectionModel->selectedIndexes().first();
        const QString userId = index.data(AclModel::UserIdRole).toString();

if (mImapUserName == userId) {
            if (KMessageBox::Cancel == KMessageBox::warningContinueCancel(
                    nullptr,
                    i18n("Do you really want to remove your own permissions for this folder? "
                         "You will not be able to access it afterwards."),
                    i18n("Remove"))) {
                return;
            }
        } else {
            if (KMessageBox::Cancel == KMessageBox::warningContinueCancel(
                    nullptr,
                    i18n("Do you really want to remove these permissions for this folder?"),
                    i18n("Remove"))) {
                return;
            }
        }

mModel->removeRow(index.row(), QModelIndex());
        mChanged = true;
    }

void setCollection(const Akonadi::Collection &collection)
    {
        mCollection = collection;
        mChanged = false;

const PimCommon::ImapAclAttribute *attribute
            = collection.attribute<PimCommon::ImapAclAttribute>();
        const QMap<QByteArray, KIMAP::Acl::Rights> rights = attribute->rights();

QDBusInterface interface(basename, QStringLiteral("/KolabProxy"));
            if (interface.isValid()) {
                QDBusReply<QString> reply = interface.call(QStringLiteral("imapResourceForCollection"), collection.remoteId().toLongLong());
                if (reply.isValid()) {
                    resource = reply;
                }
            }
        }
        OrgKdeAkonadiImapSettingsInterface *imapSettingsInterface
            = PimCommon::Util::createImapSettingsInterface(resource);

QString loginName;
        QString serverName;
        if (imapSettingsInterface && imapSettingsInterface->isValid()) {
            QDBusReply<QString> reply = imapSettingsInterface->userName();
            if (reply.isValid()) {
                loginName = reply;
            }

reply = imapSettingsInterface->imapServer();
            if (reply.isValid()) {
                serverName = reply;
            }
        } else {
            qCDebug(PIMCOMMONAKONADI_LOG) << " collection has not imap as resources: " << collection.resource();
        }
        delete imapSettingsInterface;

mImapUserName = loginName;
        if (!rights.contains(loginName.toUtf8())) {
            const QString guessedUserName = AclUtils::guessUserName(loginName, serverName);
            if (rights.contains(guessedUserName.toUtf8())) {
                mImapUserName = guessedUserName;
            }
        }

mUserRights = rights[ mImapUserName.toUtf8() ];

mModel->setRights(rights);
        selectionChanged();
    }

AclManager *q = nullptr;
    AclModel *mModel = nullptr;
    QItemSelectionModel *mSelectionModel = nullptr;
    QAction *mAddAction = nullptr;
    QAction *mEditAction = nullptr;
    QAction *mDeleteAction = nullptr;

Akonadi::Collection mCollection;
    QString mImapUserName;
    KIMAP::Acl::Rights mUserRights;
    bool mChanged;
};

AclManager::AclManager(QObject *parent)
    : QObject(parent)
    , d(new Private(this))
{
}

AclManager::~AclManager()
{
    delete d;
}

void AclManager::setCollection(const Akonadi::Collection &collection)
{
    d->setCollection(collection);
    Q_EMIT collectionChanged(d->mCollection);
    Q_EMIT collectionCanBeAdministrated(d->mUserRights & KIMAP::Acl::Admin);
}

Akonadi::Collection AclManager::collection() const
{
    return d->mCollection;
}

QAbstractItemModel *AclManager::model() const
{
    return d->mModel;
}

QItemSelectionModel *AclManager::selectionModel() const
{
    return d->mSelectionModel;
}

QAction *AclManager::addAction() const
{
    return d->mAddAction;
}

QAction *AclManager::editAction() const
{
    return d->mEditAction;
}

QAction *AclManager::deleteAction() const
{
    return d->mDeleteAction;
}

void AclManager::save(bool recursive)
{
    if (!d->mCollection.isValid() || !d->mChanged) {
        return;
    }

// refresh the collection, it might be outdated in the meantime
    Akonadi::CollectionFetchJob *job
        = new Akonadi::CollectionFetchJob(d->mCollection, Akonadi::CollectionFetchJob::Base);
    if (!job->exec()) {
        qCDebug(PIMCOMMONAKONADI_LOG) << " collection Fetch error" << job->errorString();
        return;
    }

if (job->collections().isEmpty()) {
        qCDebug(PIMCOMMONAKONADI_LOG) << " collection list Fetched is Empty ";
        return;
    }

d->mCollection = job->collections().at(0);

d->mChanged = false;

PimCommon::AclModifyJob *modifyAclJob = new PimCommon::AclModifyJob;
    modifyAclJob->setCurrentRight(d->mModel->rights());
    modifyAclJob->setTopLevelCollection(d->mCollection);
    modifyAclJob->setRecursive(recursive);
    modifyAclJob->start();
}

void AclManager::setChanged(bool b)
{
    d->mChanged = b;
}

#include "moc_aclmanager.cpp"
070701000000F6000081A40000000200000002000000015CDAA39400000D1A000000000000000000000000000000000000005300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclmanager.h/*
 * Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
 * Copyright (c) 2010 Tobias Koenig <tokoe@kdab.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef PIMCOMMON_ACLMANAGER_H
#define PIMCOMMON_ACLMANAGER_H

#include "pimcommonakonadi_private_export.h"

#include <Collection>

#include <QObject>

class QAbstractItemModel;
class QAction;
class QItemSelectionModel;

namespace PimCommon {
class PIMCOMMONAKONADI_TESTS_EXPORT AclManager : public QObject
{
    Q_OBJECT

Q_PROPERTY(Akonadi::Collection collection READ collection WRITE setCollection NOTIFY collectionChanged)
    Q_PROPERTY(QAbstractItemModel *model READ model)
    Q_PROPERTY(QItemSelectionModel *selectionModel READ selectionModel)
    Q_PROPERTY(QAction *addAction READ addAction)
    Q_PROPERTY(QAction *editAction READ editAction)
    Q_PROPERTY(QAction *deleteAction READ deleteAction)

public:
    /**
     * Creates a new ACL manager.
     *
     * @param parent The parent object.
     */
    explicit AclManager(QObject *parent = nullptr);

/**
     * Destroys the ACL manager.
     */
    ~AclManager();

/**
     * Sets the @p collection whose ACL will be managed.
     */
    void setCollection(const Akonadi::Collection &collection);

/**
     * Sets the @p collection whose ACL are managed.
     */
    Q_REQUIRED_RESULT Akonadi::Collection collection() const;

/**
     * Returns the model that represents the ACL of the managed collection.
     */
    Q_REQUIRED_RESULT QAbstractItemModel *model() const;

/**
     * Returns the selection model that is used by the manager to select the
     * ACL entry to work on.
     */
    Q_REQUIRED_RESULT QItemSelectionModel *selectionModel() const;

/**
     * Returns the action that handles adding new ACL entries.
     */
    Q_REQUIRED_RESULT QAction *addAction() const;

/**
     * Returns the action that handles editing the currently selected ACL entry.
     */
    Q_REQUIRED_RESULT QAction *editAction() const;

/**
     * Returns the action that handles deleting the currently selected ACL entry.
     */
    Q_REQUIRED_RESULT QAction *deleteAction() const;

void setChanged(bool b);
public Q_SLOTS:
    /**
     * Saves the changes of the ACL back to the collection.
     */
    void save(bool recursive);

Q_SIGNALS:
    /**
     * This signal is emitted whenever the collection whose ACL will
     * be managed has changed.
     */
    void collectionChanged(const Akonadi::Collection &collection);

void collectionCanBeAdministrated(bool canAdmin);

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
}

#endif
070701000000F7000081A40000000200000002000000015CDAA394000028AD000000000000000000000000000000000000005700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclmodifyjob.cpp/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#include "aclmodifyjob.h"
#include "imapresourcesettings.h"
#include "util/pimutil.h"
#include "aclutils_p.h"
#include "pimcommonakonadi_debug.h"
#include <AkonadiCore/ServerManager>
#include <KEmailAddress>

#include "imapaclattribute.h"
#include "job/fetchrecursivecollectionsjob.h"
#include <KMessageBox>
#include <KLocalizedString>
#include <QDBusInterface>
#include <QDBusReply>
#include <ContactGroupSearchJob>
#include <ContactGroupExpandJob>
#include <AkonadiCore/CollectionModifyJob>
#include <KContacts/Addressee>

using namespace PimCommon;
//#define SEARCHCONTACT_AKONADI 1

AclModifyJob::AclModifyJob(QObject *parent)
    : QObject(parent)
{
    connect(this, &AclModifyJob::searchContactDone, this, &AclModifyJob::slotModifyAcl);
    connect(this, &AclModifyJob::searchNextContact, this, &AclModifyJob::searchContact);
}

AclModifyJob::~AclModifyJob()
{
}

void AclModifyJob::searchContact()
{
    const QMap<QByteArray, KIMAP::Acl::Rights>::const_iterator itEnd = mCurrentRight.cend();
    if (mIt != itEnd) {
        Akonadi::ContactGroupSearchJob *searchJob = new Akonadi::ContactGroupSearchJob(this);
        searchJob->setQuery(Akonadi::ContactGroupSearchJob::Name, QString::fromLatin1(mIt.key()));
        searchJob->setLimit(1);
        connect(searchJob, &Akonadi::ContactGroupSearchJob::result, this, &AclModifyJob::slotGroupSearchResult);
    } else {
        Q_EMIT searchContactDone();
    }
}

void AclModifyJob::slotGroupSearchResult(KJob *job)
{
    Akonadi::ContactGroupSearchJob *searchJob = qobject_cast<Akonadi::ContactGroupSearchJob *>(job);
    if (!searchJob->contactGroups().isEmpty()) {   // it has been a distribution list
        Akonadi::ContactGroupExpandJob *expandJob
            = new Akonadi::ContactGroupExpandJob(searchJob->contactGroups().at(0), this);
        if (expandJob->exec()) {
            const KContacts::Addressee::List lstContacts = expandJob->contacts();
            for (const KContacts::Addressee &contact : lstContacts) {
                const QByteArray rawEmail
                    = KEmailAddress::extractEmailAddress(contact.preferredEmail().toUtf8());
                if (!rawEmail.isEmpty()) {
                    mNewRight[ rawEmail ] = mIt.value();
                }
            }
        }
    } else { // it has been a normal contact
        const QByteArray rawEmail = KEmailAddress::extractEmailAddress(mIt.key());
        if (!rawEmail.isEmpty()) {
            mNewRight[ rawEmail ] = mIt.value();
        }
    }
    mIt++;
    Q_EMIT searchNextContact();
}

void AclModifyJob::start()
{
    if (!mTopLevelCollection.isValid()) {
        deleteLater();
        return;
    }
#ifdef SEARCHCONTACT_AKONADI
    mIt = mCurrentRight.cbegin();
    searchContact();
#else
    const QMap<QByteArray, KIMAP::Acl::Rights> rights = mCurrentRight;
    QMap<QByteArray, KIMAP::Acl::Rights>::const_iterator it = rights.cbegin();
    const QMap<QByteArray, KIMAP::Acl::Rights>::const_iterator itEnd = rights.cend();
    for (; it != itEnd; ++it) {
        const QByteArray rawEmail = KEmailAddress::extractEmailAddress(it.key());
        if (!rawEmail.isEmpty()) {
            mNewRight[rawEmail] = it.value();
        }
    }
    slotModifyAcl();
#endif
}

void AclModifyJob::slotModifyAcl()
{
    mCurrentIndex = 0;
    if (mRecursive) {
        PimCommon::FetchRecursiveCollectionsJob *fetchJob = new PimCommon::FetchRecursiveCollectionsJob(this);
        fetchJob->setTopCollection(mTopLevelCollection);
        connect(fetchJob, &FetchRecursiveCollectionsJob::fetchCollectionFailed, this, &AclModifyJob::slotFetchCollectionFailed);
        connect(fetchJob, &FetchRecursiveCollectionsJob::fetchCollectionFinished, this, &AclModifyJob::slotFetchCollectionFinished);
        fetchJob->start();
    } else {
        changeAcl(mTopLevelCollection);
    }
}

bool AclModifyJob::canAdministrate(const PimCommon::ImapAclAttribute *attribute, const Akonadi::Collection &collection) const
{
    if (!attribute || !collection.isValid()) {
        return false;
    }
    const QMap<QByteArray, KIMAP::Acl::Rights> rights = attribute->rights();

QString resource = collection.resource();
    if (resource.contains(QLatin1String("akonadi_kolabproxy_resource"))) {
        const QString basename = Akonadi::ServerManager::agentServiceName(Akonadi::ServerManager::Agent,
                                                                          QStringLiteral("akonadi_kolabproxy_resource"));
        QDBusInterface interface(basename, QStringLiteral("/KolabProxy"));
        if (interface.isValid()) {
            QDBusReply<QString> reply = interface.call(QStringLiteral("imapResourceForCollection"), collection.remoteId().toLongLong());
            if (reply.isValid()) {
                resource = reply;
            }
        }
    }
    OrgKdeAkonadiImapSettingsInterface *imapSettingsInterface
        = PimCommon::Util::createImapSettingsInterface(resource);

QString loginName;
    QString serverName;
    if (imapSettingsInterface->isValid()) {
        QDBusReply<QString> reply = imapSettingsInterface->userName();
        if (reply.isValid()) {
            loginName = reply;
        }

reply = imapSettingsInterface->imapServer();
        if (reply.isValid()) {
            serverName = reply;
        }
    } else {
        qCDebug(PIMCOMMONAKONADI_LOG) << " collection has not imap as resources: " << collection.resource();
    }
    delete imapSettingsInterface;

QString imapUserName = loginName;
    if (!rights.contains(loginName.toUtf8())) {
        const QString guessedUserName = AclUtils::guessUserName(loginName, serverName);
        if (rights.contains(guessedUserName.toUtf8())) {
            imapUserName = guessedUserName;
        }
    }
    return rights[ imapUserName.toUtf8() ] & KIMAP::Acl::Admin;
}

void AclModifyJob::setCurrentRight(const QMap<QByteArray, KIMAP::Acl::Rights> &currentRight)
{
    mCurrentRight = currentRight;
}

void AclModifyJob::changeAcl(const Akonadi::Collection &collection)
{
    if (collection.hasAttribute<PimCommon::ImapAclAttribute>()) {
        Akonadi::Collection mutableCollection = collection;
        PimCommon::ImapAclAttribute *attribute = mutableCollection.attribute<PimCommon::ImapAclAttribute>();
        if (canAdministrate(attribute, mutableCollection)) {
            attribute->setRights(mNewRight);
            Akonadi::CollectionModifyJob *modifyJob = new Akonadi::CollectionModifyJob(mutableCollection);
            connect(modifyJob, &KJob::result, this, &AclModifyJob::slotModifyDone);
        }
    } else {
        checkNewCollection();
    }
}

void AclModifyJob::checkNewCollection()
{
    mCurrentIndex++;
    if (mCurrentIndex < mRecursiveCollection.count()) {
        changeAcl(mRecursiveCollection.at(mCurrentIndex));
    } else {
        deleteLater();
    }
}

void AclModifyJob::slotModifyDone(KJob *job)
{
    if (job->error()) {
        qCDebug(PIMCOMMONAKONADI_LOG) << " Error during modify collection " << job->errorString();
    }
    checkNewCollection();
}

void AclModifyJob::slotFetchCollectionFinished(const Akonadi::Collection::List &collectionList)
{
    QStringList folderNames;
    for (const Akonadi::Collection &col : collectionList) {
        if (col.hasAttribute<PimCommon::ImapAclAttribute>()) {
            const PimCommon::ImapAclAttribute *attribute = col.attribute<PimCommon::ImapAclAttribute>();
            if (canAdministrate(attribute, col)) {
                QString fullName;
                bool parentFound;
                Akonadi::Collection cur = col;
                do {
                    parentFound = false;
                    // parentCollection() only returns the ID, but we have the
                    // collection in our list already because we've recursively
                    // fetched. So look it up in our list.
                    for (const Akonadi::Collection &it : collectionList) {
                        if (it.id() == cur.id()) {
                            fullName = QLatin1String("/") + it.displayName() + fullName;
                            parentFound = true;
                            cur = cur.parentCollection();
                            break;
                        }
                    }
                } while (parentFound);
                // Remove leading slash
                folderNames << fullName.right(fullName.size() - 1);
            } else {
                qCDebug(PIMCOMMONAKONADI_LOG) << "AclModifyJob: No rights to administer " << col.name();
            }
        } else {
            qCDebug(PIMCOMMONAKONADI_LOG) << "AclModifyJob: Collection " << col.name() << "has no ACL.";
        }
    }
    folderNames.sort();
    if (KMessageBox::warningContinueCancelList(nullptr,
                                               i18n("Do you really want to apply the folder's permissions to these subfolders?"),
                                               folderNames,
                                               i18n("Apply Permissions")) != KMessageBox::Continue) {
        deleteLater();
        qCDebug(PIMCOMMONAKONADI_LOG) << "AclModifyJob: User canceled .";
        return;
    }
    mRecursiveCollection = collectionList;
    changeAcl(mTopLevelCollection);
}

void AclModifyJob::slotFetchCollectionFailed()
{
    qCDebug(PIMCOMMONAKONADI_LOG) << "fetch collection failed";
    deleteLater();
}

void AclModifyJob::setTopLevelCollection(const Akonadi::Collection &topLevelCollection)
{
    mTopLevelCollection = topLevelCollection;
}

void AclModifyJob::setRecursive(bool recursive)
{
    mRecursive = recursive;
}
070701000000F8000081A40000000200000002000000015CDAA394000008D3000000000000000000000000000000000000005500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclmodifyjob.h/*
  Copyright (c) 2016-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

*/
#ifndef ACLMODIFYJOB_H
#define ACLMODIFYJOB_H

#include <QObject>
#include <KIMAP/Acl>
#include <AkonadiCore/collection.h>
class KJob;
namespace PimCommon {
class ImapAclAttribute;
class AclModifyJob : public QObject
{
    Q_OBJECT
public:
    explicit AclModifyJob(QObject *parent = nullptr);
    ~AclModifyJob();

void setTopLevelCollection(const Akonadi::Collection &topLevelCollection);
    void setRecursive(bool recursive);
    void start();

void setCurrentRight(const QMap<QByteArray, KIMAP::Acl::Rights> &currentRight);

Q_SIGNALS:
    void searchContactDone();
    void searchNextContact();

private:
    void slotModifyDone(KJob *job);
    void slotFetchCollectionFinished(const Akonadi::Collection::List &collectionList);
    void slotFetchCollectionFailed();
    void changeAcl(const Akonadi::Collection &collection);
    void checkNewCollection();
    bool canAdministrate(const PimCommon::ImapAclAttribute *attribute, const Akonadi::Collection &collection) const;
    void searchContact();
    void slotModifyAcl();
    void slotGroupSearchResult(KJob *job);

Akonadi::Collection mTopLevelCollection;
    Akonadi::Collection::List mRecursiveCollection;
    QMap<QByteArray, KIMAP::Acl::Rights> mNewRight;
    QMap<QByteArray, KIMAP::Acl::Rights> mCurrentRight;
    QMap<QByteArray, KIMAP::Acl::Rights>::const_iterator mIt;
    bool mRecursive = false;
    int mCurrentIndex = -1;
};
}
#endif // ACLMODIFYJOB_H
070701000000F9000081A40000000200000002000000015CDAA39400000FCE000000000000000000000000000000000000005300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclutils.cpp/*
 * Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
 * Copyright (c) 2010 Tobias Koenig <tokoe@kdab.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "aclutils_p.h"

#include <KLocalizedString>

using namespace PimCommon;

static const struct {
    KIMAP::Acl::Rights permissions;
    const char *userString;
} standardPermissions[] = {
    {
        KIMAP::Acl::None,
        I18N_NOOP2("Permissions", "None")
    },

{
        KIMAP::Acl::Lookup | KIMAP::Acl::Read | KIMAP::Acl::KeepSeen,
        I18N_NOOP2("Permissions", "Read")
    },

{
        KIMAP::Acl::Lookup | KIMAP::Acl::Read | KIMAP::Acl::KeepSeen
        |KIMAP::Acl::Insert | KIMAP::Acl::Post,
        I18N_NOOP2("Permissions", "Append")
    },

{
        KIMAP::Acl::Lookup | KIMAP::Acl::Read | KIMAP::Acl::KeepSeen
        |KIMAP::Acl::Insert | KIMAP::Acl::Post | KIMAP::Acl::Write
        |KIMAP::Acl::CreateMailbox | KIMAP::Acl::DeleteMailbox
        |KIMAP::Acl::DeleteMessage | KIMAP::Acl::Expunge,
        I18N_NOOP2("Permissions", "Write")
    },

{
        KIMAP::Acl::Lookup | KIMAP::Acl::Read | KIMAP::Acl::KeepSeen
        |KIMAP::Acl::Insert | KIMAP::Acl::Post | KIMAP::Acl::Write
        |KIMAP::Acl::CreateMailbox | KIMAP::Acl::DeleteMailbox
        |KIMAP::Acl::DeleteMessage | KIMAP::Acl::Expunge | KIMAP::Acl::Admin,
        I18N_NOOP2("Permissions", "All")
    }
};

uint AclUtils::standardPermissionsCount()
{
    return sizeof(standardPermissions) / sizeof(*standardPermissions);
}

KIMAP::Acl::Rights AclUtils::permissionsForIndex(uint index)
{
    Q_ASSERT(index < standardPermissionsCount());

return standardPermissions[ index ].permissions;
}

int AclUtils::indexForPermissions(KIMAP::Acl::Rights permissions)
{
    const uint maxSize(sizeof(standardPermissions) / sizeof(*standardPermissions));
    for (uint i = 0; i < maxSize; ++i) {
        if (KIMAP::Acl::normalizedRights(permissions) == standardPermissions[i].permissions) {
            return i;
        }
    }

return -1;
}

QString AclUtils::permissionsToUserString(KIMAP::Acl::Rights permissions)
{
    const uint maxSize(sizeof(standardPermissions) / sizeof(*standardPermissions));
    for (uint i = 0; i < maxSize; ++i) {
        if (KIMAP::Acl::normalizedRights(permissions) == standardPermissions[i].permissions) {
            return i18nc("Permissions", standardPermissions[ i ].userString);
        }
    }

return i18n("Custom Permissions (%1)",
                QString::fromLatin1(KIMAP::Acl::rightsToString(permissions)));
}

QString AclUtils::guessUserName(const QString &loginName, const QString &serverName)
{
    int pos = loginName.indexOf(QLatin1Char('@'));
    if (pos != -1) {
        // strip of the domain part and use user name only
        return loginName.left(pos);
    } else {
        pos = serverName.lastIndexOf(QLatin1Char('.'));
        if (pos == -1) {   // no qualified domain name, only hostname
            return QStringLiteral("%1@%2").arg(loginName, serverName);
        }

pos = serverName.lastIndexOf(QLatin1Char('.'), pos - 1);
        if (pos == -1) {   // a simple domain name e.g. mydomain.org
            return QStringLiteral("%1@%2").arg(loginName, serverName);
        } else {
            return QStringLiteral("%1@%2").arg(loginName, serverName.mid(pos + 1));
        }
    }
}
070701000000FA000081A40000000200000002000000015CDAA39400000785000000000000000000000000000000000000005300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/aclutils_p.h/*
 * Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
 * Copyright (c) 2010 Tobias Koenig <tokoe@kdab.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef PIMCOMMON_ACLUTILS_P_H
#define PIMCOMMON_ACLUTILS_P_H

#include <KIMAP/Acl>

namespace PimCommon {
namespace AclUtils {
/**
 * Returns the number of standard permissions available.
 */
uint standardPermissionsCount();

/**
 * Returns the standard permissions at the given @p index.
 */
KIMAP::Acl::Rights permissionsForIndex(uint index);

/**
 * Returns the index of the given standard @p permissions.
 *
 * If there are no matching permissions, @c -1 is returned.
 */
int indexForPermissions(KIMAP::Acl::Rights permissions);

/**
 * Returns the i18n'd representation of the given @p permissions.
 */
QString permissionsToUserString(KIMAP::Acl::Rights permissions);

/**
 * We call this method if our first try to get the ACLs for the user fails.
 * That's the case if the ACLs use a different user id than the login name.
 *
 * Examples:
 *   login: testuser                acls: testuser@mydomain.org
 *   login: testuser@mydomain.org   acls: testuser
 */
QString guessUserName(const QString &loginName, const QString &serverName);
}
}

#endif
070701000000FB000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/autotests070701000000FC000081A40000000200000002000000015CDAA394000001BA000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/autotests/CMakeLists.txtecm_add_test(imapaclattributetest.cpp
    TEST_NAME imapaclattributetest
    NAME_PREFIX "pimcommon-acl-"
    LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::AkonadiCore KF5::IMAP KF5::PimCommonAkonadi
    GUI
)

ecm_add_test(collectionaclwidgettest.cpp ../collectionaclwidget.cpp
    TEST_NAME collectionaclwidgettest
    NAME_PREFIX "pimcommon-acl-"
    LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::AkonadiCore KF5::IMAP KF5::PimCommonAkonadi KF5::I18n
)
070701000000FD000081A40000000200000002000000015CDAA394000005FB000000000000000000000000000000000000006C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/autotests/collectionaclwidgettest.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "collectionaclwidgettest.h"
#include "../collectionaclwidget.h"
#include <QListView>
#include <QPushButton>
#include <QTest>

CollectionAclWidgetTest::CollectionAclWidgetTest(QObject *parent)
    : QObject(parent)
{
}

CollectionAclWidgetTest::~CollectionAclWidgetTest()
{
}

void CollectionAclWidgetTest::shouldHaveDefaultValue()
{
    PimCommon::CollectionAclWidget w;
    QVERIFY(w.aclManager());
    QListView *listView = w.findChild<QListView *>(QStringLiteral("list_view"));
    QVERIFY(listView);
    QPushButton *button = w.findChild<QPushButton *>(QStringLiteral("add"));
    QVERIFY(button);
    button = w.findChild<QPushButton *>(QStringLiteral("edit"));
    QVERIFY(button);
    button = w.findChild<QPushButton *>(QStringLiteral("delete"));
    QVERIFY(button);
}

QTEST_MAIN(CollectionAclWidgetTest)
070701000000FE000081A40000000200000002000000015CDAA3940000041F000000000000000000000000000000000000006A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/autotests/collectionaclwidgettest.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef COLLECTIONACLWIDGETTEST_H
#define COLLECTIONACLWIDGETTEST_H

#include <QObject>

class CollectionAclWidgetTest : public QObject
{
    Q_OBJECT
public:
    explicit CollectionAclWidgetTest(QObject *parent = nullptr);
    ~CollectionAclWidgetTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
};

#endif // COLLECTIONACLWIDGETTEST_H
070701000000FF000081A40000000200000002000000015CDAA3940000205D000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/autotests/imapaclattributetest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "imapaclattributetest.h"
#include "../imapaclattribute.h"
#include <QTest>

typedef QMap<QByteArray, KIMAP::Acl::Rights> ImapAcl;
Q_DECLARE_METATYPE(ImapAcl)
Q_DECLARE_METATYPE(KIMAP::Acl::Rights)

using namespace PimCommon;

ImapAclAttributeTest::ImapAclAttributeTest(QObject *parent)
    : QObject(parent)
{
}

ImapAclAttributeTest::~ImapAclAttributeTest()
{
}

void ImapAclAttributeTest::shouldHaveDefaultValue()
{
    PimCommon::ImapAclAttribute attr;
    QVERIFY(attr.oldRights().isEmpty());
    QVERIFY(attr.rights().isEmpty());
    QVERIFY(!attr.myRights());
}

void ImapAclAttributeTest::shouldBuildAttribute()
{
    QMap<QByteArray, KIMAP::Acl::Rights> right;
    right.insert("test", KIMAP::Acl::Admin);
    right.insert("foo", KIMAP::Acl::Admin);

QMap<QByteArray, KIMAP::Acl::Rights> oldright;
    right.insert("test", KIMAP::Acl::Delete);
    right.insert("foo", KIMAP::Acl::Delete);
    PimCommon::ImapAclAttribute attr(right, oldright);
    QCOMPARE(attr.oldRights(), oldright);
    QCOMPARE(attr.rights(), right);
}

void ImapAclAttributeTest::shouldAssignValue()
{
    PimCommon::ImapAclAttribute attr;
    QMap<QByteArray, KIMAP::Acl::Rights> right;
    right.insert("test", KIMAP::Acl::Admin);
    right.insert("foo", KIMAP::Acl::Admin);
    attr.setRights(right);
    QCOMPARE(attr.rights(), right);
}

void ImapAclAttributeTest::shouldCloneAttr()
{
    PimCommon::ImapAclAttribute attr;
    QMap<QByteArray, KIMAP::Acl::Rights> right;
    right.insert("test", KIMAP::Acl::Admin);
    right.insert("foo", KIMAP::Acl::Admin);
    attr.setRights(right);
    ImapAclAttribute *clone = attr.clone();
    QVERIFY(attr == *clone);
    delete clone;
}

void ImapAclAttributeTest::shouldSerializedAttribute()
{
    QMap<QByteArray, KIMAP::Acl::Rights> right;
    right.insert("test", KIMAP::Acl::Admin);
    right.insert("foo", KIMAP::Acl::Admin);

QMap<QByteArray, KIMAP::Acl::Rights> oldright;
    right.insert("test", KIMAP::Acl::Delete);
    right.insert("foo", KIMAP::Acl::Delete);
    PimCommon::ImapAclAttribute attr(right, oldright);
    const QByteArray ba = attr.serialized();
    PimCommon::ImapAclAttribute result;
    result.deserialize(ba);
    QVERIFY(attr == result);
}

void ImapAclAttributeTest::shouldHaveType()
{
    PimCommon::ImapAclAttribute attr;
    QCOMPARE(attr.type(), QByteArray("imapacl"));
}

void ImapAclAttributeTest::testMyRights()
{
    ImapAclAttribute attr;
    KIMAP::Acl::Rights myRight = KIMAP::Acl::Admin;

attr.setMyRights(myRight);
    QCOMPARE(attr.myRights(), myRight);

ImapAclAttribute *clone = attr.clone();
    QCOMPARE(clone->myRights(), myRight);

QVERIFY(*clone == attr);

clone->setMyRights(KIMAP::Acl::Custom0);
    QVERIFY(!(*clone == attr));
    delete clone;
}

void ImapAclAttributeTest::testDeserialize_data()
{
    QTest::addColumn<ImapAcl>("rights");
    QTest::addColumn<KIMAP::Acl::Rights>("myRights");
    QTest::addColumn<QByteArray>("serialized");

KIMAP::Acl::Rights rights = KIMAP::Acl::None;

{
        ImapAcl acl;
        QTest::newRow("empty") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray(" %% ");
    }

{
        ImapAcl acl;
        acl.insert("user@host", rights);
        QTest::newRow("none") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray("user@host  %% ");
    }

{
        ImapAcl acl;
        acl.insert("user@host", KIMAP::Acl::Lookup);
        QTest::newRow("lookup") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray("user@host l %% ");
    }

{
        ImapAcl acl;
        acl.insert("user@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);
        QTest::newRow("lookup/read") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray("user@host lr %% ");
    }

{
        ImapAcl acl;
        acl.insert("user@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);
        acl.insert("otheruser@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);
        QTest::newRow("lookup/read") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray("otheruser@host lr % user@host lr %% ");
    }

{
        QTest::newRow("myrights") << ImapAcl() << KIMAP::Acl::rightsFromString("lrswipckxtdaen") << QByteArray(" %%  %% lrswipckxtdaen");
    }
}

void ImapAclAttributeTest::testDeserialize()
{
    QFETCH(ImapAcl, rights);
    QFETCH(KIMAP::Acl::Rights, myRights);
    QFETCH(QByteArray, serialized);

ImapAclAttribute deserializeAttr;
    deserializeAttr.deserialize(serialized);
    QCOMPARE(deserializeAttr.rights(), rights);
    QCOMPARE(deserializeAttr.myRights(), myRights);
}

void ImapAclAttributeTest::testSerializeDeserialize_data()
{
    QTest::addColumn<ImapAcl>("rights");
    QTest::addColumn<KIMAP::Acl::Rights>("myRights");
    QTest::addColumn<QByteArray>("serialized");
    QTest::addColumn<QByteArray>("oldSerialized");

ImapAcl acl;
    QTest::newRow("empty") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray(" %% ") << QByteArray("testme@host l %% ");

acl.insert("user@host", KIMAP::Acl::None);
    QTest::newRow("none") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray("user@host  %% ") << QByteArray("testme@host l %% user@host ");

acl.insert("user@host", KIMAP::Acl::Lookup);
    QTest::newRow("lookup") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray("user@host l %% ") << QByteArray("testme@host l %% user@host l");

acl.insert("user@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);
    QTest::newRow("lookup/read") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None)  << QByteArray("user@host lr %% ") << QByteArray("testme@host l %% user@host lr");

acl.insert("otheruser@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);
    QTest::newRow("lookup/read") << acl << KIMAP::Acl::Rights(KIMAP::Acl::None) << QByteArray("otheruser@host lr % user@host lr %% ")
                                 << QByteArray("testme@host l %% otheruser@host lr % user@host lr");

QTest::newRow("myrights") << acl << KIMAP::Acl::rightsFromString("lrswipckxtdaen") << QByteArray("otheruser@host lr % user@host lr %%  %% lrswipckxtdaen")
                              << QByteArray("testme@host l %% otheruser@host lr % user@host lr %% lrswipckxtdaen");
}

void ImapAclAttributeTest::testSerializeDeserialize()
{
    QFETCH(ImapAcl, rights);
    QFETCH(KIMAP::Acl::Rights, myRights);
    QFETCH(QByteArray, serialized);
    QFETCH(QByteArray, oldSerialized);

ImapAclAttribute *attr = new ImapAclAttribute();
    attr->setRights(rights);
    attr->setMyRights(myRights);
    QCOMPARE(attr->serialized(), serialized);

ImapAcl acl;
    acl.insert("testme@host", KIMAP::Acl::Lookup);
    attr->setRights(acl);

QCOMPARE(attr->serialized(), oldSerialized);

delete attr;

ImapAclAttribute deserializeAttr;
    deserializeAttr.deserialize(serialized);
    QCOMPARE(deserializeAttr.rights(), rights);
    QCOMPARE(deserializeAttr.myRights(), myRights);
}

void ImapAclAttributeTest::testOldRights()
{
    ImapAcl acls;
    acls.insert("first_user@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);
    acls.insert("second_user@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);
    acls.insert("third_user@host", KIMAP::Acl::Lookup | KIMAP::Acl::Read);

ImapAclAttribute *attr = new ImapAclAttribute();
    attr->setRights(acls);

ImapAcl oldAcls = acls;
    acls.remove("first_user@host");
    acls.remove("third_user@host");

attr->setRights(acls);

QCOMPARE(attr->oldRights(), oldAcls);

attr->setRights(acls);

QCOMPARE(attr->oldRights(), acls);
    delete attr;
}

QTEST_MAIN(ImapAclAttributeTest)
07070100000100000081A40000000200000002000000015CDAA39400000567000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/autotests/imapaclattributetest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
#ifndef IMAPACLATTRIBUTETEST_H
#define IMAPACLATTRIBUTETEST_H

#include <QObject>

class ImapAclAttributeTest : public QObject
{
    Q_OBJECT
public:
    explicit ImapAclAttributeTest(QObject *parent = nullptr);
    ~ImapAclAttributeTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldBuildAttribute();
    void shouldAssignValue();
    void shouldCloneAttr();
    void shouldSerializedAttribute();
    void shouldHaveType();
    void testMyRights();
    void testDeserialize_data();
    void testDeserialize();
    void testSerializeDeserialize_data();
    void testSerializeDeserialize();
    void testOldRights();
};

#endif // IMAPACLATTRIBUTETEST_H
07070100000101000081A40000000200000002000000015CDAA39400000C2F000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/collectionaclpage.cpp/**
 *
 * Copyright (c) 2004 David Faure <faure@kde.org>
 *
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of this program with any edition of
 *  the Qt library by Trolltech AS, Norway (or with modified versions
 *  of Qt that use the same license as Qt), and distribute linked
 *  combinations including the two.  You must obey the GNU General
 *  Public License in all respects for all of the code used other than
 *  Qt.  If you modify this file, you may extend this exception to
 *  your version of the file, but you are not obligated to do so.  If
 *  you do not wish to do so, delete this exception statement from
 *  your version.
 */

#include "collectionaclpage.h"
#include "collectionaclwidget.h"
#include "aclmanager.h"
#include "imapaclattribute.h"
#include <AkonadiCore/Collection>
#include <KLocalizedString>
#include <QHBoxLayout>

using namespace PimCommon;

class PimCommon::CollectionAclPagePrivate
{
public:
    CollectionAclPagePrivate()
    {
    }

CollectionAclWidget *mCollectionAclWidget = nullptr;
};

CollectionAclPage::CollectionAclPage(QWidget *parent)
    : CollectionPropertiesPage(parent)
    , d(new PimCommon::CollectionAclPagePrivate)
{
    setObjectName(QStringLiteral("PimCommon::CollectionAclPage"));

setPageTitle(i18n("Access Control"));
    init();
}

CollectionAclPage::~CollectionAclPage()
{
    delete d;
}

void CollectionAclPage::init()
{
    QHBoxLayout *layout = new QHBoxLayout(this);
    layout->setContentsMargins(0, 0, 0, 0);
    d->mCollectionAclWidget = new CollectionAclWidget(this);
    layout->addWidget(d->mCollectionAclWidget);
}

bool CollectionAclPage::canHandle(const Akonadi::Collection &collection) const
{
    return collection.hasAttribute<PimCommon::ImapAclAttribute>();
}

void CollectionAclPage::load(const Akonadi::Collection &collection)
{
    d->mCollectionAclWidget->aclManager()->setCollection(collection);
}

void CollectionAclPage::save(Akonadi::Collection &collection)
{
    d->mCollectionAclWidget->aclManager()->save(d->mCollectionAclWidget->recursive());

// The collection dialog expects the changed collection to run
    // its own ItemModifyJob, so make him happy...
    const auto origCol = d->mCollectionAclWidget->aclManager()->collection();
    collection.addAttribute(origCol.attribute<PimCommon::ImapAclAttribute>()->clone());
}
07070100000102000081A40000000200000002000000015CDAA39400000906000000000000000000000000000000000000005A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/collectionaclpage.h/**
 * folderdialogacltab.h
 *
 * Copyright (c) 2004 David Faure <faure@kde.org>
 *
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of this program with any edition of
 *  the Qt library by Trolltech AS, Norway (or with modified versions
 *  of Qt that use the same license as Qt), and distribute linked
 *  combinations including the two.  You must obey the GNU General
 *  Public License in all respects for all of the code used other than
 *  Qt.  If you modify this file, you may extend this exception to
 *  your version of the file, but you are not obligated to do so.  If
 *  you do not wish to do so, delete this exception statement from
 *  your version.
 */
#ifndef COLLECTIONACLPAGE_H
#define COLLECTIONACLPAGE_H

#include <AkonadiWidgets/CollectionPropertiesPage>
#include "pimcommonakonadi_export.h"

namespace PimCommon {
/**
 * "Access Control" tab in the folder dialog
 */
class CollectionAclPagePrivate;
class PIMCOMMONAKONADI_EXPORT CollectionAclPage : public Akonadi::CollectionPropertiesPage
{
    Q_OBJECT

public:
    explicit CollectionAclPage(QWidget *parent = nullptr);
    ~CollectionAclPage() override;

void load(const Akonadi::Collection &collection) override;
    void save(Akonadi::Collection &collection) override;

Q_REQUIRED_RESULT bool canHandle(const Akonadi::Collection &collection) const override;

protected:
    void init();

private:
    CollectionAclPagePrivate *const d;
};
AKONADI_COLLECTION_PROPERTIES_PAGE_FACTORY(CollectionAclPageFactory, CollectionAclPage)
}

#endif
07070100000103000081A40000000200000002000000015CDAA3940000133C000000000000000000000000000000000000005E00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/collectionaclwidget.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "collectionaclwidget.h"
#include "acllistview.h"
#include "aclmanager.h"

#include <KLocalizedString>

#include <QAction>
#include <QActionEvent>
#include <QCheckBox>
#include <QHBoxLayout>
#include <QPushButton>
#include <QVBoxLayout>

using namespace PimCommon;
/**
 * Unfortunately QPushButton doesn't support to plug in
 * a QAction like QToolButton does, so we have to reimplement it :(
 */
class ActionButton : public QPushButton
{
public:
    ActionButton(QWidget *parent = nullptr)
        : QPushButton(parent)
        , mDefaultAction(nullptr)
    {
    }

void setDefaultAction(QAction *action)
    {
        if (!actions().contains(action)) {
            addAction(action);
            connect(this, &QAbstractButton::clicked, action, &QAction::trigger);
        }

setText(action->text());
        setEnabled(action->isEnabled());

mDefaultAction = action;
    }

protected:
    void actionEvent(QActionEvent *event) override
    {
        QAction *action = event->action();
        switch (event->type()) {
        case QEvent::ActionChanged:
            if (action == mDefaultAction) {
                setDefaultAction(mDefaultAction);
            }
            return;
            break;
        default:
            break;
        }

QPushButton::actionEvent(event);
    }

private:
    QAction *mDefaultAction = nullptr;
};

CollectionAclWidget::CollectionAclWidget(QWidget *parent)
    : QWidget(parent)
    , mAclManager(new PimCommon::AclManager(this))
{
    QHBoxLayout *layout = new QHBoxLayout(this);
    QVBoxLayout *listViewLayout = new QVBoxLayout;
    layout->addLayout(listViewLayout);

AclListView *view = new AclListView;
    view->setObjectName(QStringLiteral("list_view"));
    listViewLayout->addWidget(view);
    mRecursiveChk = new QCheckBox(i18n("Apply permissions on all &subfolders."), this);
    listViewLayout->addWidget(mRecursiveChk);
    connect(mRecursiveChk, &QCheckBox::clicked, this, &CollectionAclWidget::slotRecursivePermissionChanged);

view->setAlternatingRowColors(true);
    view->setModel(mAclManager->model());
    view->setSelectionModel(mAclManager->selectionModel());

QWidget *buttonBox = new QWidget;
    QVBoxLayout *buttonBoxVBoxLayout = new QVBoxLayout(buttonBox);
    buttonBoxVBoxLayout->setContentsMargins(0, 0, 0, 0);
    layout->addWidget(buttonBox);

ActionButton *button = new ActionButton(buttonBox);
    buttonBoxVBoxLayout->addWidget(button);
    button->setObjectName(QStringLiteral("add"));
    button->setDefaultAction(mAclManager->addAction());

button = new ActionButton(buttonBox);
    buttonBoxVBoxLayout->addWidget(button);
    button->setObjectName(QStringLiteral("edit"));
    button->setDefaultAction(mAclManager->editAction());

button = new ActionButton(buttonBox);
    buttonBoxVBoxLayout->addWidget(button);
    button->setDefaultAction(mAclManager->deleteAction());
    button->setObjectName(QStringLiteral("delete"));

QWidget *spacer = new QWidget(buttonBox);
    buttonBoxVBoxLayout->addWidget(spacer);
    spacer->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
    connect(view, SIGNAL(doubleClicked(QModelIndex)), mAclManager->editAction(), SIGNAL(triggered()));
    connect(mAclManager, &AclManager::collectionCanBeAdministrated, this, &CollectionAclWidget::slotCollectionCanBeAdministrated);
    connect(mAclManager, &AclManager::collectionCanBeAdministrated, view, &AclListView::slotCollectionCanBeAdministrated);
}

CollectionAclWidget::~CollectionAclWidget()
{
}

void CollectionAclWidget::slotCollectionCanBeAdministrated(bool b)
{
    if (!b) {
        mRecursiveChk->setChecked(false);
    }
    mRecursiveChk->setEnabled(b);
}

AclManager *CollectionAclWidget::aclManager() const
{
    return mAclManager;
}

bool CollectionAclWidget::recursive() const
{
    return mRecursiveChk->isChecked();
}

void CollectionAclWidget::setEnableRecursiveCheckBox(bool enable)
{
    if (!enable) {
        mRecursiveChk->setChecked(false);
    }
    mRecursiveChk->setEnabled(enable);
}

void CollectionAclWidget::slotRecursivePermissionChanged()
{
    mAclManager->setChanged(true);
}
07070100000104000081A40000000200000002000000015CDAA394000005C1000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/collectionaclwidget.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef COLLECTIONACLWIDGET_H
#define COLLECTIONACLWIDGET_H

#include <QWidget>
class QCheckBox;
namespace PimCommon {
class AclManager;
class CollectionAclWidget : public QWidget
{
    Q_OBJECT
public:
    explicit CollectionAclWidget(QWidget *parent = nullptr);
    ~CollectionAclWidget();

Q_REQUIRED_RESULT PimCommon::AclManager *aclManager() const;
    Q_REQUIRED_RESULT bool recursive() const;
    void setEnableRecursiveCheckBox(bool enable);

private Q_SLOTS:
    void slotRecursivePermissionChanged();
    void slotCollectionCanBeAdministrated(bool b);

private:
    PimCommon::AclManager *mAclManager = nullptr;
    QCheckBox *mRecursiveChk = nullptr;
};
}

#endif // COLLECTIONACLWIDGET_H
07070100000105000081A40000000200000002000000015CDAA394000013FE000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/imapaclattribute.cpp/*
  Copyright (C) 2009 Kevin Ottens <ervin@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
*/

// THIS file should not exist and is only a copy of
// kdepim-runtime/resources/shared/singlefileresource

// Any improvements should be done at kdepim-runtime and
// than afterwards copy the new version

#include "imapaclattribute.h"

#include <QByteArray>

using namespace PimCommon;

class PimCommon::ImapAclAttributePrivate
{
public:
    ImapAclAttributePrivate()
    {
    }

QMap<QByteArray, KIMAP::Acl::Rights> mRights;
    QMap<QByteArray, KIMAP::Acl::Rights> mOldRights;
    KIMAP::Acl::Rights mMyRights;
};

ImapAclAttribute::ImapAclAttribute()
    : d(new PimCommon::ImapAclAttributePrivate)
{
}

ImapAclAttribute::ImapAclAttribute(const QMap<QByteArray, KIMAP::Acl::Rights> &rights, const QMap<QByteArray, KIMAP::Acl::Rights> &oldRights)
    : d(new PimCommon::ImapAclAttributePrivate)
{
    d->mRights = rights;
    d->mOldRights = oldRights;
}

ImapAclAttribute::~ImapAclAttribute()
{
    delete d;
}

void ImapAclAttribute::setRights(const QMap<QByteArray, KIMAP::Acl::Rights> &rights)
{
    d->mOldRights = d->mRights;
    d->mRights = rights;
}

QMap<QByteArray, KIMAP::Acl::Rights> ImapAclAttribute::rights() const
{
    return d->mRights;
}

QMap<QByteArray, KIMAP::Acl::Rights> ImapAclAttribute::oldRights() const
{
    return d->mOldRights;
}

void ImapAclAttribute::setMyRights(KIMAP::Acl::Rights rights)
{
    d->mMyRights = rights;
}

KIMAP::Acl::Rights ImapAclAttribute::myRights() const
{
    return d->mMyRights;
}

QByteArray ImapAclAttribute::type() const
{
    static const QByteArray sType("imapacl");
    return sType;
}

ImapAclAttribute *ImapAclAttribute::clone() const
{
    ImapAclAttribute *attr = new ImapAclAttribute(d->mRights, d->mOldRights);
    attr->setMyRights(d->mMyRights);
    return attr;
}

QByteArray ImapAclAttribute::serialized() const
{
    QByteArray result;

bool added = false;
    for (auto it = d->mRights.cbegin(), end = d->mRights.cend(); it != end; ++it) {
        result += it.key();
        result += ' ';
        result += KIMAP::Acl::rightsToString(it.value());
        result += " % "; // We use this separator as '%' is not allowed in keys or values
        added = true;
    }

if (added) {
        result.chop(3);
    }

result += " %% ";

added = false;
    for (auto it = d->mOldRights.cbegin(), end = d->mOldRights.cend(); it != end; ++it) {
        result += it.key();
        result += ' ';
        result += KIMAP::Acl::rightsToString(it.value());
        result += " % "; // We use this separator as '%' is not allowed in keys or values
        added = true;
    }

if (added) {
        result.chop(3);
    }

if (d->mMyRights) {
        result += " %% ";
        result += KIMAP::Acl::rightsToString(d->mMyRights);
    }

return result;
}

static void fillRightsMap(const QList<QByteArray> &rights, QMap <QByteArray, KIMAP::Acl::Rights> &map)
{
    for (const QByteArray &right : rights) {
        const QByteArray trimmed = right.trimmed();
        const int wsIndex = trimmed.indexOf(' ');
        const QByteArray id = trimmed.mid(0, wsIndex).trimmed();
        if (!id.isEmpty()) {
            const bool noValue = (wsIndex == -1);
            if (noValue) {
                map[id] = KIMAP::Acl::None;
            } else {
                const QByteArray value = trimmed.mid(wsIndex + 1, right.length() - wsIndex).trimmed();
                map[id] = KIMAP::Acl::rightsFromString(value);
            }
        }
    }
}

void ImapAclAttribute::deserialize(const QByteArray &data)
{
    d->mRights.clear();
    d->mOldRights.clear();
    d->mMyRights = KIMAP::Acl::None;

QList<QByteArray> parts;
    int lastPos = 0;
    int pos;
    while ((pos = data.indexOf(" %% ", lastPos)) != -1) {
        parts << data.mid(lastPos, pos - lastPos);
        lastPos = pos + 4;
    }
    parts << data.mid(lastPos);

if (parts.size() < 2) {
        return;
    }
    fillRightsMap(parts.at(0).split('%'), d->mRights);
    fillRightsMap(parts.at(1).split('%'), d->mOldRights);
    if (parts.size() >= 3) {
        d->mMyRights = KIMAP::Acl::rightsFromString(parts.at(2));
    }
}

bool ImapAclAttribute::operator==(const ImapAclAttribute &other) const
{
    return (oldRights() == other.oldRights())
           && (rights() == other.rights())
           && (myRights() == other.myRights());
}
07070100000106000081A40000000200000002000000015CDAA394000008BC000000000000000000000000000000000000005900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/acl/imapaclattribute.h/*
  Copyright (C) 2009 Kevin Ottens <ervin@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
*/

// THIS file should not exist and is only a copy of
// kdepim-runtime/resources/shared/singlefileresource

// Any improvements should be done at kdepim-runtime and
// than afterwards copy the new version

#ifndef PIMCOMMON_IMAPACLATTRIBUTE_H
#define PIMCOMMON_IMAPACLATTRIBUTE_H

#include "pimcommonakonadi_export.h"

#include <Attribute>

#include <KIMAP/Acl>

#include <QMap>

namespace PimCommon {
class ImapAclAttributePrivate;
class PIMCOMMONAKONADI_EXPORT ImapAclAttribute : public Akonadi::Attribute
{
public:
    ImapAclAttribute();
    ImapAclAttribute(const QMap<QByteArray, KIMAP::Acl::Rights> &rights, const QMap<QByteArray, KIMAP::Acl::Rights> &oldRights);
    ~ImapAclAttribute() override;
    void setRights(const QMap<QByteArray, KIMAP::Acl::Rights> &rights);
    QMap<QByteArray, KIMAP::Acl::Rights> rights() const;
    QMap<QByteArray, KIMAP::Acl::Rights> oldRights() const;
    void setMyRights(KIMAP::Acl::Rights rights);
    KIMAP::Acl::Rights myRights() const;
    QByteArray type() const override;
    ImapAclAttribute *clone() const override;
    QByteArray serialized() const override;
    void deserialize(const QByteArray &data) override;

bool operator==(const ImapAclAttribute &other) const;
private:
    ImapAclAttributePrivate *const d;
    QMap<QByteArray, KIMAP::Acl::Rights> mRights;
    QMap<QByteArray, KIMAP::Acl::Rights> mOldRights;
    KIMAP::Acl::Rights mMyRights;
};
}

#endif
07070100000107000041ED0000000200000002000000045CDAA39400000000000000000000000000000000000000000000005100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage07070100000108000081A40000000200000002000000015CDAA394000004EA000000000000000000000000000000000000006800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/attributeregistrar.cpp/*
    Copyright (c) 2009 Constantin Berzan <exit3219@gmail.com>

This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.

This library 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 Library General Public
    License for more details.

You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "collectionpage/attributes/collectionannotationsattribute.h"

#include <AkonadiCore/attributefactory.h>

namespace {
// Anonymous namespace; function is invisible outside this file.
bool dummy()
{
    Akonadi::AttributeFactory::registerAttribute<PimCommon::CollectionAnnotationsAttribute>();
    return true;
}

// Called when this library is loaded.
const bool registered = dummy();
} // namespace
07070100000109000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/attributes0707010000010A000081A40000000200000002000000015CDAA39400000BD1000000000000000000000000000000000000007F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/attributes/collectionannotationsattribute.cpp/*
  Copyright (C) 2008 Omat Holding B.V. <info@omat.nl>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
*/

#include "collectionannotationsattribute.h"

#include <QByteArray>

using namespace PimCommon;

CollectionAnnotationsAttribute::CollectionAnnotationsAttribute()
{
}

CollectionAnnotationsAttribute::CollectionAnnotationsAttribute(
    const QMap<QByteArray, QByteArray> &annotations)
    : mAnnotations(annotations)
{
}

void CollectionAnnotationsAttribute::setAnnotations(
    const QMap<QByteArray, QByteArray> &annotations)
{
    mAnnotations = annotations;
}

QMap<QByteArray, QByteArray> CollectionAnnotationsAttribute::annotations() const
{
    return mAnnotations;
}

QByteArray CollectionAnnotationsAttribute::type() const
{
    static const QByteArray sType("collectionannotations");
    return sType;
}

CollectionAnnotationsAttribute *CollectionAnnotationsAttribute::clone() const
{
    return new CollectionAnnotationsAttribute(mAnnotations);
}

QByteArray CollectionAnnotationsAttribute::serialized() const
{
    QByteArray result;
    for (auto it = mAnnotations.cbegin(), end = mAnnotations.cend(); it != end; ++it) {
        result += it.key();
        result += ' ';
        result += it.value();
        result += " % "; // We use this separator as '%' is not allowed in keys or values
    }
    result.chop(3);

return result;
}

void CollectionAnnotationsAttribute::deserialize(const QByteArray &data)
{
    mAnnotations.clear();
    const QList<QByteArray> lines = data.split('%');

for (int i = 0; i < lines.size(); ++i) {
        QByteArray line = lines[i];
        if (i != 0 && line.startsWith(' ')) {
            line = line.mid(1);
        }
        if (i != lines.size() - 1 && line.endsWith(' ')) {
            line.chop(1);
        }
        if (line.trimmed().isEmpty()) {
            continue;
        }
        int wsIndex = line.indexOf(' ');
        if (wsIndex > 0) {
            const QByteArray key = line.mid(0, wsIndex);
            const QByteArray value = line.mid(wsIndex + 1);
            mAnnotations[key] = value;
        } else {
            mAnnotations.insert(line, QByteArray());
        }
    }
}

bool CollectionAnnotationsAttribute::operator==(const CollectionAnnotationsAttribute &other) const
{
    return mAnnotations == other.annotations();
}
0707010000010B000081A40000000200000002000000015CDAA394000006E9000000000000000000000000000000000000007D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/attributes/collectionannotationsattribute.h/*
  Copyright (C) 2008 Omat Holding B.V. <info@omat.nl>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
*/

#ifndef PIMCOMMON_COLLECTIONANNOTATIONSATTRIBUTE_H
#define PIMCOMMON_COLLECTIONANNOTATIONSATTRIBUTE_H

#include <Attribute>
#include "pimcommonakonadi_export.h"

#include <QMap>

namespace PimCommon {
class PIMCOMMONAKONADI_EXPORT CollectionAnnotationsAttribute : public Akonadi::Attribute
{
public:
    CollectionAnnotationsAttribute();
    CollectionAnnotationsAttribute(const QMap<QByteArray, QByteArray> &annotations);
    ~CollectionAnnotationsAttribute() override = default;

void setAnnotations(const QMap<QByteArray, QByteArray> &annotations);
    QMap<QByteArray, QByteArray> annotations() const;

QByteArray type() const override;
    CollectionAnnotationsAttribute *clone() const override;
    QByteArray serialized() const override;
    void deserialize(const QByteArray &data) override;

bool operator==(const CollectionAnnotationsAttribute &other) const;

private:
    QMap<QByteArray, QByteArray> mAnnotations;
};
}

#endif
0707010000010C000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests0707010000010D000081A40000000200000002000000015CDAA3940000022C000000000000000000000000000000000000006A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests/CMakeLists.txtmacro(add_pimcommon_collectionpage_test _name)
    ecm_add_test(${ARGN}
        TEST_NAME ${_name}
        NAME_PREFIX "pimcommon-collectionpage-"
        LINK_LIBRARIES Qt5::Test Qt5::Gui KF5::AkonadiCore KF5::PimCommonAkonadi KF5::Completion
    )
endmacro()

add_pimcommon_collectionpage_test(collectionannotationsattributetest
    collectionannotationsattributetest.cpp
)
add_pimcommon_collectionpage_test(incidencesforwidgettest
    incidencesforwidgettest.cpp
)
add_pimcommon_collectionpage_test(contenttypewidgettest
    contenttypewidgettest.cpp
)
0707010000010E000081A40000000200000002000000015CDAA39400000A81000000000000000000000000000000000000008200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests/collectionannotationsattributetest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "collectionannotationsattributetest.h"
#include "../attributes/collectionannotationsattribute.h"
#include <QTest>
CollectionAnnotationsAttributeTest::CollectionAnnotationsAttributeTest(QObject *parent)
    : QObject(parent)
{
}

CollectionAnnotationsAttributeTest::~CollectionAnnotationsAttributeTest()
{
}

void CollectionAnnotationsAttributeTest::shouldHaveDefaultValue()
{
    PimCommon::CollectionAnnotationsAttribute attr;
    QVERIFY(attr.annotations().isEmpty());
}

void CollectionAnnotationsAttributeTest::shouldAssignAttribute()
{
    QMap<QByteArray, QByteArray> annotations;
    annotations.insert("foo", "foo");
    annotations.insert("bla", "bla");
    annotations.insert("foo2", "bli");
    PimCommon::CollectionAnnotationsAttribute attr(annotations);
    QCOMPARE(attr.annotations(), annotations);
}

void CollectionAnnotationsAttributeTest::shouldDeserializedAttribute()
{
    QMap<QByteArray, QByteArray> annotations;
    annotations.insert("foo", "foo");
    annotations.insert("bla", "bla");
    annotations.insert("foo2", "bli");
    PimCommon::CollectionAnnotationsAttribute attr(annotations);
    const QByteArray ba = attr.serialized();
    PimCommon::CollectionAnnotationsAttribute result;
    result.deserialize(ba);
    QVERIFY(attr == result);
}

void CollectionAnnotationsAttributeTest::shouldCloneAttribute()
{
    QMap<QByteArray, QByteArray> annotations;
    annotations.insert("foo", "foo");
    annotations.insert("bla", "bla");
    annotations.insert("foo2", "bli");
    PimCommon::CollectionAnnotationsAttribute attr(annotations);
    PimCommon::CollectionAnnotationsAttribute *result = static_cast<PimCommon::CollectionAnnotationsAttribute *>(attr.clone());
    QVERIFY(attr == *result);
    delete result;
}

void CollectionAnnotationsAttributeTest::shouldHaveType()
{
    PimCommon::CollectionAnnotationsAttribute attr;
    QCOMPARE(attr.type(), QByteArray("collectionannotations"));
}

QTEST_MAIN(CollectionAnnotationsAttributeTest)
0707010000010F000081A40000000200000002000000015CDAA394000004E7000000000000000000000000000000000000008000000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests/collectionannotationsattributetest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef COLLECTIONANNOTATIONSATTRIBUTETEST_H
#define COLLECTIONANNOTATIONSATTRIBUTETEST_H

#include <QObject>

class CollectionAnnotationsAttributeTest : public QObject
{
    Q_OBJECT
public:
    explicit CollectionAnnotationsAttributeTest(QObject *parent = nullptr);
    ~CollectionAnnotationsAttributeTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldAssignAttribute();
    void shouldDeserializedAttribute();
    void shouldCloneAttribute();
    void shouldHaveType();
};

#endif // COLLECTIONANNOTATIONSATTRIBUTETEST_H
07070100000110000081A40000000200000002000000015CDAA39400000A9C000000000000000000000000000000000000007500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests/contenttypewidgettest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#include "contenttypewidgettest.h"
#include "../contenttypewidget.h"
#include <kcombobox.h>
#include <QLabel>
#include <QTest>
#include <QSignalSpy>
ContentTypeWidgetTest::ContentTypeWidgetTest(QObject *parent)
    : QObject(parent)
{
}

ContentTypeWidgetTest::~ContentTypeWidgetTest()
{
}

void ContentTypeWidgetTest::shouldHaveDefaultValue()
{
    PimCommon::ContentTypeWidget widget;
    QLabel *label = widget.findChild<QLabel *>(QStringLiteral("contenttypewidgetlabel"));
    QVERIFY(label);
    QComboBox *combo = widget.findChild<QComboBox *>(QStringLiteral("contentcombobox"));
    QVERIFY(combo);
    QVERIFY(combo->count() > 0);
    QCOMPARE(widget.currentIndex(), 0);
}

void ContentTypeWidgetTest::shouldChangeComboBoxIndex()
{
    PimCommon::ContentTypeWidget contentType;
    QComboBox *combo = contentType.findChild<QComboBox *>(QStringLiteral("contentcombobox"));
    for (int i = 0; i < combo->count(); ++i) {
        contentType.setCurrentIndex(i);
        QCOMPARE(contentType.currentIndex(), i);
        QCOMPARE(combo->currentIndex(), i);
    }
}

void ContentTypeWidgetTest::shouldEmitSignalWhenIndexChanged()
{
    PimCommon::ContentTypeWidget contentType;
    contentType.show();
    QVERIFY(QTest::qWaitForWindowExposed(&contentType));
    QSignalSpy spy(&contentType, &PimCommon::ContentTypeWidget::activated);
    contentType.setCurrentIndex(1);
    //FIXME
    //QCOMPARE(spy.at(0).count(), 1);
}

void ContentTypeWidgetTest::shouldChangeItem()
{
    PimCommon::ContentTypeWidget contentType;
    contentType.show();
    QVERIFY(QTest::qWaitForWindowExposed(&contentType));
    QComboBox *combo = contentType.findChild<QComboBox *>(QStringLiteral("contentcombobox"));
    for (int i = 0; i < combo->count(); ++i) {
        contentType.setCurrentIndex(i);
        QCOMPARE(contentType.currentText(), combo->currentText());
    }
}

QTEST_MAIN(ContentTypeWidgetTest)
07070100000111000081A40000000200000002000000015CDAA394000004F7000000000000000000000000000000000000007300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests/contenttypewidgettest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#ifndef CONTENTTYPEWIDGETTEST_H
#define CONTENTTYPEWIDGETTEST_H

#include <QObject>

class ContentTypeWidgetTest : public QObject
{
    Q_OBJECT
public:
    explicit ContentTypeWidgetTest(QObject *parent = nullptr);
    ~ContentTypeWidgetTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldChangeComboBoxIndex();
    void shouldEmitSignalWhenIndexChanged();
    void shouldChangeItem();
};

#endif // CONTENTTYPEWIDGETTEST_H
07070100000112000081A40000000200000002000000015CDAA3940000091D000000000000000000000000000000000000007700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests/incidencesforwidgettest.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#include "incidencesforwidgettest.h"
#include "../incidencesforwidget.h"
#include <kcombobox.h>
#include <QLabel>
#include <QTest>
#include <QSignalSpy>

IncidencesForWidgetTest::IncidencesForWidgetTest(QObject *parent)
    : QObject(parent)
{
}

IncidencesForWidgetTest::~IncidencesForWidgetTest()
{
}

void IncidencesForWidgetTest::shouldHaveDefaultValue()
{
    PimCommon::IncidencesForWidget contentType;
    QLabel *label = contentType.findChild<QLabel *>(QStringLiteral("contentstypelabel"));
    QVERIFY(label);
    QComboBox *combo = contentType.findChild<QComboBox *>(QStringLiteral("contentstypecombobox"));
    QVERIFY(combo);
    QVERIFY(combo->count() > 0);
    QCOMPARE(contentType.currentIndex(), 0);
}

void IncidencesForWidgetTest::shouldChangeComboBoxIndex()
{
    PimCommon::IncidencesForWidget contentType;
    QComboBox *combo = contentType.findChild<QComboBox *>(QStringLiteral("contentstypecombobox"));
    for (int i = 0; i < combo->count(); ++i) {
        contentType.setCurrentIndex(i);
        QCOMPARE(contentType.currentIndex(), i);
        QCOMPARE(combo->currentIndex(), i);
    }
}

void IncidencesForWidgetTest::shouldEmitSignalWhenIndexChanged()
{
    PimCommon::IncidencesForWidget contentType;
    contentType.show();
    QVERIFY(QTest::qWaitForWindowExposed(&contentType));
    QSignalSpy spy(&contentType, &PimCommon::IncidencesForWidget::currentIndexChanged);
    contentType.setCurrentIndex(1);
    QCOMPARE(spy.at(0).count(), 1);
}

QTEST_MAIN(IncidencesForWidgetTest)
07070100000113000081A40000000200000002000000015CDAA394000004E5000000000000000000000000000000000000007500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/autotests/incidencesforwidgettest.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

*/
#ifndef INCIDENCESFORWIDGETTEST_H
#define INCIDENCESFORWIDGETTEST_H

#include <QObject>

class IncidencesForWidgetTest : public QObject
{
    Q_OBJECT
public:
    explicit IncidencesForWidgetTest(QObject *parent = nullptr);
    ~IncidencesForWidgetTest();
private Q_SLOTS:
    void shouldHaveDefaultValue();
    void shouldChangeComboBoxIndex();
    void shouldEmitSignalWhenIndexChanged();
};

#endif // INCIDENCESFORWIDGETTEST_H
07070100000114000081A40000000200000002000000015CDAA3940000229A000000000000000000000000000000000000006800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/collectiontypeutil.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#include "collectiontypeutil.h"
#include <KLocalizedString>

using namespace PimCommon;
CollectionTypeUtil::CollectionTypeUtil()
{
}

CollectionTypeUtil::~CollectionTypeUtil()
{
}

QByteArray CollectionTypeUtil::kolabFolderType()
{
    return "/shared/vendor/kolab/folder-type";
}

QByteArray CollectionTypeUtil::kolabIncidencesFor()
{
    return "/shared/vendor/kolab/incidences-for";
}

QByteArray CollectionTypeUtil::kolabSharedSeen()
{
    return "/shared/vendor/cmu/cyrus-imapd/sharedseen";
}

QString CollectionTypeUtil::folderContentDescription(CollectionTypeUtil::FolderContentsType type)
{
    switch (type) {
    case CollectionTypeUtil::ContentsTypeMail:
        return i18nc("type of folder content", "Mail");
    case CollectionTypeUtil::ContentsTypeCalendar:
        return i18nc("type of folder content", "Calendar");
    case CollectionTypeUtil::ContentsTypeContact:
        return i18nc("type of folder content", "Contacts");
    case CollectionTypeUtil::ContentsTypeNote:
        return i18nc("type of folder content", "Notes");
    case CollectionTypeUtil::ContentsTypeTask:
        return i18nc("type of folder content", "Tasks");
    case CollectionTypeUtil::ContentsTypeJournal:
        return i18nc("type of folder content", "Journal");
    case CollectionTypeUtil::ContentsTypeConfiguration:
        return i18nc("type of folder content", "Configuration");
    case CollectionTypeUtil::ContentsTypeFreebusy:
        return i18nc("type of folder content", "Freebusy");
    case CollectionTypeUtil::ContentsTypeFile:
        return i18nc("type of folder content", "Files");
    default:
        return i18nc("type of folder content", "Unknown");
    }
}

QString CollectionTypeUtil::incidencesForToString(CollectionTypeUtil::IncidencesFor type)
{
    switch (type) {
    case CollectionTypeUtil::IncForNobody:
        return QStringLiteral("nobody");
    case CollectionTypeUtil::IncForAdmins:
        return QStringLiteral("admins");
    case CollectionTypeUtil::IncForReaders:
        return QStringLiteral("readers");
    }

return QString(); // can't happen
}

CollectionTypeUtil::IncidencesFor CollectionTypeUtil::incidencesForFromString(const QString &string)
{
    if (string == QLatin1String("nobody")) {
        return CollectionTypeUtil::IncForNobody;
    } else if (string == QLatin1String("admins")) {
        return CollectionTypeUtil::IncForAdmins;
    } else if (string == QLatin1String("readers")) {
        return CollectionTypeUtil::IncForReaders;
    }

return CollectionTypeUtil::IncForAdmins; // by default
}

CollectionTypeUtil::FolderContentsType CollectionTypeUtil::typeFromKolabName(const QByteArray &name)
{
    if (name == "task" || name == "task.default") {
        return CollectionTypeUtil::ContentsTypeTask;
    }
    if (name == "event" || name == "event.default") {
        return CollectionTypeUtil::ContentsTypeCalendar;
    }
    if (name == "contact" || name == "contact.default") {
        return CollectionTypeUtil::ContentsTypeContact;
    }
    if (name == "note" || name == "note.default") {
        return CollectionTypeUtil::ContentsTypeNote;
    }
    if (name == "journal" || name == "journal.default") {
        return CollectionTypeUtil::ContentsTypeJournal;
    }
    if (name == "configuration" || name == "configuration.default") {
        return CollectionTypeUtil::ContentsTypeConfiguration;
    }
    if (name == "freebusy" || name == "freebusy.default") {
        return CollectionTypeUtil::ContentsTypeFreebusy;
    }
    if (name == "file" || name == "file.default") {
        return CollectionTypeUtil::ContentsTypeFile;
    }

return CollectionTypeUtil::ContentsTypeMail;
}

QByteArray CollectionTypeUtil::kolabNameFromType(CollectionTypeUtil::FolderContentsType type)
{
    switch (type) {
    case CollectionTypeUtil::ContentsTypeCalendar:
        return "event";
    case CollectionTypeUtil::ContentsTypeContact:
        return "contact";
    case CollectionTypeUtil::ContentsTypeNote:
        return "note";
    case CollectionTypeUtil::ContentsTypeTask:
        return "task";
    case CollectionTypeUtil::ContentsTypeJournal:
        return "journal";
    case CollectionTypeUtil::ContentsTypeConfiguration:
        return "configuration";
    case CollectionTypeUtil::ContentsTypeFreebusy:
        return "freebusy";
    case CollectionTypeUtil::ContentsTypeFile:
        return "file";
    default:
        return QByteArray();
    }
}

CollectionTypeUtil::FolderContentsType CollectionTypeUtil::contentsTypeFromString(const QString &type)
{
    if (type == i18nc("type of folder content", "Mail")) {
        return CollectionTypeUtil::ContentsTypeMail;
    }
    if (type == i18nc("type of folder content", "Calendar")) {
        return CollectionTypeUtil::ContentsTypeCalendar;
    }
    if (type == i18nc("type of folder content", "Contacts")) {
        return CollectionTypeUtil::ContentsTypeContact;
    }
    if (type == i18nc("type of folder content", "Notes")) {
        return CollectionTypeUtil::ContentsTypeNote;
    }
    if (type == i18nc("type of folder content", "Tasks")) {
        return CollectionTypeUtil::ContentsTypeTask;
    }
    if (type == i18nc("type of folder content", "Journal")) {
        return CollectionTypeUtil::ContentsTypeJournal;
    }
    if (type == i18nc("type of folder content", "Configuration")) {
        return CollectionTypeUtil::ContentsTypeConfiguration;
    }
    if (type == i18nc("type of folder content", "Freebusy")) {
        return CollectionTypeUtil::ContentsTypeFreebusy;
    }
    if (type == i18nc("type of folder content", "Files")) {
        return CollectionTypeUtil::ContentsTypeFile;
    }

return CollectionTypeUtil::ContentsTypeMail; //safety return value
}

QString CollectionTypeUtil::typeNameFromKolabType(const QByteArray &type)
{
    if (type == "task" || type == "task.default") {
        return i18nc("type of folder content", "Tasks");
    }
    if (type == "event" || type == "event.default") {
        return i18nc("type of folder content", "Calendar");
    }
    if (type == "contact" || type == "contact.default") {
        return i18nc("type of folder content", "Contacts");
    }
    if (type == "note" || type == "note.default") {
        return i18nc("type of folder content", "Notes");
    }
    if (type == "journal" || type == "journal.default") {
        return i18nc("type of folder content", "Journal");
    }
    if (type == "configuration" || type == "configuration.default") {
        return i18nc("type of folder content", "Configuration");
    }
    if (type == "freebusy" || type == "freebusy.default") {
        return i18nc("type of folder content", "Freebusy");
    }
    if (type == "file" || type == "file.default") {
        return i18nc("type of folder content", "Files");
    }

return i18nc("type of folder content", "Mail");
}

QString CollectionTypeUtil::iconNameFromContentsType(CollectionTypeUtil::FolderContentsType type)
{
    QString iconName;
    switch (type) {
    case CollectionTypeUtil::ContentsTypeCalendar:
        iconName = QStringLiteral("view-calendar");
        break;
    case CollectionTypeUtil::ContentsTypeContact:
        iconName = QStringLiteral("view-pim-contacts");
        break;
    case CollectionTypeUtil::ContentsTypeNote:
        iconName = QStringLiteral("view-pim-notes");
        break;
    case CollectionTypeUtil::ContentsTypeTask:
        iconName = QStringLiteral("view-pim-tasks");
        break;
    case CollectionTypeUtil::ContentsTypeJournal:
        iconName = QStringLiteral("view-pim-journal");
        break;
    case CollectionTypeUtil::ContentsTypeConfiguration:
        iconName = QStringLiteral("configure");
        break;
    case CollectionTypeUtil::ContentsTypeFreebusy:
        iconName = QStringLiteral("view-calendar-agenda");
        break;
    case CollectionTypeUtil::ContentsTypeFile:
        iconName = QStringLiteral("document-open");
        break;
    case CollectionTypeUtil::ContentsTypeMail:
    default:
        break;
    }

return iconName;
}
07070100000115000081A40000000200000002000000015CDAA394000009B3000000000000000000000000000000000000006600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/collectiontypeutil.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#ifndef COLLECTIONTYPEUTIL_H
#define COLLECTIONTYPEUTIL_H
#include "pimcommonakonadi_export.h"
#include <QByteArray>
#include <QString>

namespace PimCommon {
class PIMCOMMONAKONADI_EXPORT CollectionTypeUtil
{
public:
    CollectionTypeUtil();
    ~CollectionTypeUtil();

static QByteArray kolabFolderType();
    static QByteArray kolabIncidencesFor();
    static QByteArray kolabSharedSeen();

enum FolderContentsType {
        ContentsTypeMail = 0,
        ContentsTypeCalendar,
        ContentsTypeContact,
        ContentsTypeNote,
        ContentsTypeTask,
        ContentsTypeJournal,
        ContentsTypeConfiguration,
        ContentsTypeFreebusy,
        ContentsTypeFile,
        ContentsTypeLast = ContentsTypeFile
    };

enum IncidencesFor {
        IncForNobody,
        IncForAdmins,
        IncForReaders
    };

Q_REQUIRED_RESULT CollectionTypeUtil::IncidencesFor incidencesForFromString(const QString &string);
    Q_REQUIRED_RESULT CollectionTypeUtil::FolderContentsType typeFromKolabName(const QByteArray &name);
    Q_REQUIRED_RESULT QString folderContentDescription(CollectionTypeUtil::FolderContentsType type);
    Q_REQUIRED_RESULT QByteArray kolabNameFromType(CollectionTypeUtil::FolderContentsType type);
    Q_REQUIRED_RESULT QString incidencesForToString(CollectionTypeUtil::IncidencesFor type);
    Q_REQUIRED_RESULT CollectionTypeUtil::FolderContentsType contentsTypeFromString(const QString &type);
    Q_REQUIRED_RESULT QString typeNameFromKolabType(const QByteArray &type);
    Q_REQUIRED_RESULT QString iconNameFromContentsType(CollectionTypeUtil::FolderContentsType type);
};
}
#endif // COLLECTIONTYPEUTIL_H
07070100000116000081A40000000200000002000000015CDAA39400000DE4000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/contenttypewidget.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#include "contenttypewidget.h"
#include "collectiontypeutil.h"
#include <KLocalizedString>
#include <QComboBox>
#include <QHBoxLayout>
#include <QLabel>

using namespace PimCommon;

class PimCommon::ContentTypeWidgetPrivate
{
public:
    ContentTypeWidgetPrivate()
        : mContentsComboBox(nullptr)
    {
    }

QComboBox *mContentsComboBox = nullptr;
};

ContentTypeWidget::ContentTypeWidget(QWidget *parent)
    : QWidget(parent)
    , d(new PimCommon::ContentTypeWidgetPrivate)
{
    QHBoxLayout *hbox = new QHBoxLayout(this);
    hbox->setContentsMargins(0, 0, 0, 0);

QLabel *label = new QLabel(i18n("&Folder contents:"), this);
    label->setObjectName(QStringLiteral("contenttypewidgetlabel"));
    hbox->addWidget(label);
    d->mContentsComboBox = new QComboBox(this);
    d->mContentsComboBox->setObjectName(QStringLiteral("contentcombobox"));
    label->setBuddy(d->mContentsComboBox);
    hbox->addWidget(d->mContentsComboBox);
    PimCommon::CollectionTypeUtil collectionUtil;
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeMail));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeCalendar));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeContact));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeNote));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeTask));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeJournal));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeConfiguration));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeFreebusy));
    d->mContentsComboBox->addItem(collectionUtil.folderContentDescription(CollectionTypeUtil::ContentsTypeFile));

connect(d->mContentsComboBox, QOverload<int>::of(&QComboBox::activated), this, &ContentTypeWidget::activated);
}

ContentTypeWidget::~ContentTypeWidget()
{
    delete d;
}

int ContentTypeWidget::currentIndex() const
{
    return d->mContentsComboBox->currentIndex();
}

void ContentTypeWidget::setCurrentIndex(int index)
{
    d->mContentsComboBox->setCurrentIndex(index);
}

void ContentTypeWidget::setCurrentItem(const QString &name)
{
    const int pos = d->mContentsComboBox->findText(name);
    if (pos != -1) {
        d->mContentsComboBox->setCurrentIndex(pos);
    }
}

QString ContentTypeWidget::currentText() const
{
    return d->mContentsComboBox->currentText();
}
07070100000117000081A40000000200000002000000015CDAA394000005C2000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/contenttypewidget.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#ifndef CONTENTTYPEWIDGET_H
#define CONTENTTYPEWIDGET_H

#include <QWidget>
#include "pimcommonakonadi_export.h"
namespace PimCommon {
class ContentTypeWidgetPrivate;
class PIMCOMMONAKONADI_EXPORT ContentTypeWidget : public QWidget
{
    Q_OBJECT
public:
    explicit ContentTypeWidget(QWidget *parent = nullptr);
    ~ContentTypeWidget();

Q_REQUIRED_RESULT int currentIndex() const;
    void setCurrentIndex(int index);

void setCurrentItem(const QString &name);
    Q_REQUIRED_RESULT QString currentText() const;

Q_SIGNALS:
    void activated(int index);

private:
    ContentTypeWidgetPrivate *const d;
};
}
#endif // CONTENTTYPEWIDGET_H
07070100000118000081A40000000200000002000000015CDAA39400000DAD000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/incidencesforwidget.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#include "incidencesforwidget.h"
#include <QLabel>
#include <QHBoxLayout>
#include <KLocalizedString>
#include <QComboBox>

using namespace PimCommon;
class PimCommon::IncidencesForWidgetPrivate
{
public:
    IncidencesForWidgetPrivate()
    {
    }

QComboBox *mIncidencesForComboBox = nullptr;
};
IncidencesForWidget::IncidencesForWidget(QWidget *parent)
    : QWidget(parent)
    , d(new PimCommon::IncidencesForWidgetPrivate)
{
    QHBoxLayout *hbox = new QHBoxLayout(this);
    hbox->setContentsMargins(0, 0, 0, 0);

QLabel *label = new QLabel(i18n("Generate free/&busy and activate alarms for:"), this);
    label->setObjectName(QStringLiteral("contentstypelabel"));
    hbox->addWidget(label);

d->mIncidencesForComboBox = new QComboBox(this);
    label->setBuddy(d->mIncidencesForComboBox);
    hbox->addWidget(d->mIncidencesForComboBox);

d->mIncidencesForComboBox->addItem(i18n("Nobody"));
    d->mIncidencesForComboBox->addItem(i18n("Admins of This Folder"));
    d->mIncidencesForComboBox->addItem(i18n("All Readers of This Folder"));
    const QString whatsThisForMyOwnFolders
        = i18n("This setting defines which users sharing "
               "this folder should get \"busy\" periods in their freebusy lists "
               "and should see the alarms for the events or tasks in this folder. "
               "The setting applies to Calendar and Task folders only "
               "(for tasks, this setting is only used for alarms).\n\n"
               "Example use cases: if the boss shares a folder with his secretary, "
               "only the boss should be marked as busy for his meetings, so he should "
               "select \"Admins\", since the secretary has no admin rights on the folder.\n"
               "On the other hand if a working group shares a Calendar for "
               "group meetings, all readers of the folders should be marked "
               "as busy for meetings.\n"
               "A company-wide folder with optional events in it would use \"Nobody\" "
               "since it is not known who will go to those events.");

d->mIncidencesForComboBox->setObjectName(QStringLiteral("contentstypecombobox"));
    d->mIncidencesForComboBox->setWhatsThis(whatsThisForMyOwnFolders);
    connect(d->mIncidencesForComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &IncidencesForWidget::currentIndexChanged);
}

IncidencesForWidget::~IncidencesForWidget()
{
    delete d;
}

int IncidencesForWidget::currentIndex() const
{
    return d->mIncidencesForComboBox->currentIndex();
}

void IncidencesForWidget::setCurrentIndex(int index)
{
    d->mIncidencesForComboBox->setCurrentIndex(index);
}
07070100000119000081A40000000200000002000000015CDAA3940000057C000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/collectionpage/incidencesforwidget.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#ifndef INCIDENCESFORWIDGET_H
#define INCIDENCESFORWIDGET_H

#include "pimcommonakonadi_export.h"
#include <QWidget>

namespace PimCommon {
class IncidencesForWidgetPrivate;
class PIMCOMMONAKONADI_EXPORT IncidencesForWidget : public QWidget
{
    Q_OBJECT
public:
    explicit IncidencesForWidget(QWidget *parent = nullptr);
    ~IncidencesForWidget();

Q_REQUIRED_RESULT int currentIndex() const;
    void setCurrentIndex(int index);

Q_SIGNALS:
    void currentIndexChanged(int value);

private:
    IncidencesForWidgetPrivate *const d;
};
}

#endif // INCIDENCESFORWIDGET_H
0707010000011A000041ED0000000200000002000000035CDAA39400000000000000000000000000000000000000000000004F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog0707010000011B000081A40000000200000002000000015CDAA3940000124F000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/checkedcollectionwidget.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "checkedcollectionwidget.h"
#include <RecursiveCollectionFilterProxyModel>
#include <CollectionFilterProxyModel>

#include <Monitor>
#include <EntityTreeModel>
#include <EntityRightsFilterModel>
#include <QSortFilterProxyModel>

#include <KCheckableProxyModel>
#include <QLineEdit>
#include <KLocalizedString>

#include <QVBoxLayout>
#include <QTreeView>

using namespace PimCommon;

class PimCommon::CheckedCollectionWidgetPrivate
{
public:
    CheckedCollectionWidgetPrivate()
        : mFolderView(nullptr)
        , mSelectionModel(nullptr)
        , mCheckProxy(nullptr)
        , mCollectionFilter(nullptr)
        , mEntityTreeModel(nullptr)
    {
    }

QTreeView *mFolderView = nullptr;
    QItemSelectionModel *mSelectionModel = nullptr;
    KCheckableProxyModel *mCheckProxy = nullptr;
    QSortFilterProxyModel *mCollectionFilter = nullptr;

Akonadi::EntityTreeModel *mEntityTreeModel = nullptr;
};

CheckedCollectionWidget::CheckedCollectionWidget(const QString &mimetype, QWidget *parent)
    : QWidget(parent)
    , d(new PimCommon::CheckedCollectionWidgetPrivate)
{
    QVBoxLayout *vbox = new QVBoxLayout(this);
    vbox->setContentsMargins(0, 0, 0, 0);

// Create a new change recorder.
    Akonadi::Monitor *monitor = new Akonadi::Monitor(this);
    monitor->setObjectName(QStringLiteral("CheckedCollectionWidgetMonitor"));
    monitor->fetchCollection(true);
    monitor->setAllMonitored(true);
    monitor->setMimeTypeMonitored(mimetype);
    connect(monitor, &Akonadi::Monitor::collectionAdded, this, &CheckedCollectionWidget::collectionAdded);
    connect(monitor, &Akonadi::Monitor::collectionRemoved, this, &CheckedCollectionWidget::collectionRemoved);

d->mEntityTreeModel = new Akonadi::EntityTreeModel(monitor, this);
    // Set the model to show only collections, not items.
    d->mEntityTreeModel->setItemPopulationStrategy(Akonadi::EntityTreeModel::NoItemPopulation);

Akonadi::CollectionFilterProxyModel *mimeTypeProxy = new Akonadi::CollectionFilterProxyModel(this);
    mimeTypeProxy->setExcludeVirtualCollections(true);
    mimeTypeProxy->addMimeTypeFilters(QStringList() << mimetype);
    mimeTypeProxy->setSourceModel(d->mEntityTreeModel);

// Create the Check proxy model.
    d->mSelectionModel = new QItemSelectionModel(mimeTypeProxy);
    d->mCheckProxy = new KCheckableProxyModel(this);
    d->mCheckProxy->setSelectionModel(d->mSelectionModel);
    d->mCheckProxy->setSourceModel(mimeTypeProxy);
    d->mCollectionFilter = new QSortFilterProxyModel(this);
    d->mCollectionFilter->setRecursiveFilteringEnabled(true);
    d->mCollectionFilter->setSourceModel(d->mCheckProxy);
    d->mCollectionFilter->setFilterCaseSensitivity(Qt::CaseInsensitive);

QLineEdit *searchLine = new QLineEdit(this);
    searchLine->setPlaceholderText(i18n("Search..."));
    searchLine->setClearButtonEnabled(true);
    connect(searchLine, &QLineEdit::textChanged, this, &CheckedCollectionWidget::slotSetCollectionFilter);

vbox->addWidget(searchLine);

d->mFolderView = new QTreeView;
    d->mFolderView->setEditTriggers(QAbstractItemView::NoEditTriggers);
    d->mFolderView->setAlternatingRowColors(true);
    d->mFolderView->setModel(d->mCollectionFilter);

vbox->addWidget(d->mFolderView);
}

CheckedCollectionWidget::~CheckedCollectionWidget()
{
    delete d;
}

Akonadi::EntityTreeModel *CheckedCollectionWidget::entityTreeModel() const
{
    return d->mEntityTreeModel;
}

QTreeView *CheckedCollectionWidget::folderTreeView() const
{
    return d->mFolderView;
}

QItemSelectionModel *CheckedCollectionWidget::selectionModel() const
{
    return d->mSelectionModel;
}

KCheckableProxyModel *CheckedCollectionWidget::checkableProxy() const
{
    return d->mCheckProxy;
}

void CheckedCollectionWidget::slotSetCollectionFilter(const QString &filter)
{
    d->mCollectionFilter->setFilterWildcard(filter);
    d->mFolderView->expandAll();
}
0707010000011C000081A40000000200000002000000015CDAA3940000075C000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/checkedcollectionwidget.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CHECKEDCOLLECTIONWIDGET_H
#define CHECKEDCOLLECTIONWIDGET_H

#include <QWidget>
#include "pimcommonakonadi_export.h"

class QItemSelectionModel;
class QTreeView;
class KCheckableProxyModel;

namespace Akonadi {
class EntityTreeModel;
class Collection;
}

namespace PimCommon {
class CheckedCollectionWidgetPrivate;
class PIMCOMMONAKONADI_EXPORT CheckedCollectionWidget : public QWidget
{
    Q_OBJECT
public:
    explicit CheckedCollectionWidget(const QString &mimetype, QWidget *parent = nullptr);
    ~CheckedCollectionWidget();

Q_REQUIRED_RESULT Akonadi::EntityTreeModel *entityTreeModel() const;

Q_REQUIRED_RESULT QTreeView *folderTreeView() const;

Q_REQUIRED_RESULT QItemSelectionModel *selectionModel() const;

Q_REQUIRED_RESULT KCheckableProxyModel *checkableProxy() const;

Q_SIGNALS:
    void collectionAdded(const Akonadi::Collection &, const Akonadi::Collection &);
    void collectionRemoved(const Akonadi::Collection &);

private:
    void slotSetCollectionFilter(const QString &filter);
    CheckedCollectionWidgetPrivate *const d;
};
}

#endif // CHECKEDCOLLECTIONWIDGET_H
0707010000011D000081A40000000200000002000000015CDAA39400000D26000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/selectmulticollectiondialog.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "selectmulticollectiondialog.h"
#include "selectmulticollectionwidget.h"

#include <KLocalizedString>
#include <KConfigGroup>
#include <KSharedConfig>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>

using namespace PimCommon;

class PimCommon::SelectMultiCollectionDialogPrivate
{
public:
    SelectMultiCollectionDialogPrivate()
        : mSelectMultiCollection(nullptr)
    {
    }

SelectMultiCollectionWidget *mSelectMultiCollection = nullptr;
};

SelectMultiCollectionDialog::SelectMultiCollectionDialog(const QString &mimetype, const QList<Akonadi::Collection::Id> &selectedCollection, QWidget *parent)
    : QDialog(parent)
    , d(new PimCommon::SelectMultiCollectionDialogPrivate)
{
    initialize(mimetype, selectedCollection);
}

SelectMultiCollectionDialog::SelectMultiCollectionDialog(const QString &mimetype, QWidget *parent)
    : QDialog(parent)
    , d(new PimCommon::SelectMultiCollectionDialogPrivate)
{
    initialize(mimetype);
}

SelectMultiCollectionDialog::~SelectMultiCollectionDialog()
{
    writeConfig();
    delete d;
}

void SelectMultiCollectionDialog::initialize(const QString &mimetype, const QList<Akonadi::Collection::Id> &selectedCollection)
{
    setWindowTitle(i18n("Select Multiple Folders"));
    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Close, this);
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setDefault(true);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &SelectMultiCollectionDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &SelectMultiCollectionDialog::reject);

d->mSelectMultiCollection = new SelectMultiCollectionWidget(mimetype, selectedCollection, this);
    mainLayout->addWidget(d->mSelectMultiCollection);
    mainLayout->addWidget(buttonBox);
    readConfig();
}

void SelectMultiCollectionDialog::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "SelectMultiCollectionDialog");
    const QSize sizeDialog = group.readEntry("Size", QSize(800, 600));
    if (sizeDialog.isValid()) {
        resize(sizeDialog);
    }
}

void SelectMultiCollectionDialog::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "SelectMultiCollectionDialog");
    group.writeEntry("Size", size());
}

QVector<Akonadi::Collection> SelectMultiCollectionDialog::selectedCollection() const
{
    return d->mSelectMultiCollection->selectedCollection();
}
0707010000011E000081A40000000200000002000000015CDAA394000006CB000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/selectmulticollectiondialog.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef SELECTMULTICOLLECTIONDIALOG_H
#define SELECTMULTICOLLECTIONDIALOG_H
#include "pimcommonakonadi_export.h"
#include <QDialog>
#include <Collection>

namespace PimCommon {
class SelectMultiCollectionDialogPrivate;
class PIMCOMMONAKONADI_EXPORT SelectMultiCollectionDialog : public QDialog
{
    Q_OBJECT
public:
    explicit SelectMultiCollectionDialog(const QString &mimetype, const QList<Akonadi::Collection::Id> &selectedCollection, QWidget *parent = nullptr);
    explicit SelectMultiCollectionDialog(const QString &mimetype, QWidget *parent = nullptr);
    ~SelectMultiCollectionDialog();

Q_REQUIRED_RESULT QVector<Akonadi::Collection> selectedCollection() const;

private:
    void initialize(const QString &mimetype, const QList<Akonadi::Collection::Id> &selectedCollection = QList<Akonadi::Collection::Id>());
    void writeConfig();
    void readConfig();
    SelectMultiCollectionDialogPrivate *const d;
};
}

#endif // SELECTMULTICOLLECTIONDIALOG_H
0707010000011F000081A40000000200000002000000015CDAA39400000FCB000000000000000000000000000000000000006F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/selectmulticollectionwidget.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "selectmulticollectionwidget.h"
#include "folderdialog/checkedcollectionwidget.h"

#include <RecursiveCollectionFilterProxyModel>
#include <CollectionFilterProxyModel>

#include <ChangeRecorder>
#include <EntityTreeModel>
#include <EntityRightsFilterModel>

#include <KCheckableProxyModel>

#include <QVBoxLayout>
#include <QTreeView>

using namespace PimCommon;
SelectMultiCollectionWidget::SelectMultiCollectionWidget(const QString &mimetype, QWidget *parent)
    : QWidget(parent)
{
    initialize(mimetype);
}

SelectMultiCollectionWidget::SelectMultiCollectionWidget(const QString &mimetype, const QList<Akonadi::Collection::Id> &selectedCollection, QWidget *parent)
    : QWidget(parent)
    , mListCollection(selectedCollection)
{
    initialize(mimetype);
}

SelectMultiCollectionWidget::~SelectMultiCollectionWidget()
{
}

void SelectMultiCollectionWidget::initialize(const QString &mimetype)
{
    QVBoxLayout *vbox = new QVBoxLayout(this);
    vbox->setContentsMargins(0, 0, 0, 0);

mCheckedCollectionWidget = new PimCommon::CheckedCollectionWidget(mimetype);

connect(mCheckedCollectionWidget, &PimCommon::CheckedCollectionWidget::collectionAdded, this, &SelectMultiCollectionWidget::slotCollectionsTreeFetched);
    connect(mCheckedCollectionWidget, &PimCommon::CheckedCollectionWidget::collectionRemoved, this, &SelectMultiCollectionWidget::slotCollectionsTreeFetched);

connect(mCheckedCollectionWidget->entityTreeModel(), &Akonadi::EntityTreeModel::collectionTreeFetched, this, &SelectMultiCollectionWidget::slotCollectionsTreeFetched);
    vbox->addWidget(mCheckedCollectionWidget);
}

void SelectMultiCollectionWidget::updateStatus(const QModelIndex &parent)
{
    const int nbCol = mCheckedCollectionWidget->checkableProxy()->rowCount(parent);
    for (int i = 0; i < nbCol; ++i) {
        const QModelIndex child = mCheckedCollectionWidget->checkableProxy()->index(i, 0, parent);

const Akonadi::Collection col
            = mCheckedCollectionWidget->checkableProxy()->data(child, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();

if (mListCollection.contains(col.id())) {
            mCheckedCollectionWidget->checkableProxy()->setData(child, Qt::Checked, Qt::CheckStateRole);
        }
        updateStatus(child);
    }
}

void SelectMultiCollectionWidget::slotCollectionsTreeFetched()
{
    if (!mListCollection.isEmpty()) {
        updateStatus(QModelIndex());
    }
    mCheckedCollectionWidget->folderTreeView()->expandAll();
}

QVector<Akonadi::Collection> SelectMultiCollectionWidget::selectedCollection(const QModelIndex &parent) const
{
    QVector<Akonadi::Collection> lst;

const int nbCol = mCheckedCollectionWidget->checkableProxy()->rowCount(parent);
    for (int i = 0; i < nbCol; ++i) {
        const QModelIndex child = mCheckedCollectionWidget->checkableProxy()->index(i, 0, parent);

const Akonadi::Collection col
            = mCheckedCollectionWidget->checkableProxy()->data(child, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();

if (mCheckedCollectionWidget->checkableProxy()->data(child, Qt::CheckStateRole).value<int>()) {
            lst << col;
        }
        lst << selectedCollection(child);
    }
    return lst;
}
07070100000120000081A40000000200000002000000015CDAA394000006E0000000000000000000000000000000000000006D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/selectmulticollectionwidget.h/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef SELECTMULTICOLLECTIONWIDGET_H
#define SELECTMULTICOLLECTIONWIDGET_H

#include <QWidget>
#include <Collection>
#include <QModelIndex>

namespace PimCommon {
class CheckedCollectionWidget;
class SelectMultiCollectionWidget : public QWidget
{
    Q_OBJECT
public:
    explicit SelectMultiCollectionWidget(const QString &mimetype, const QList<Akonadi::Collection::Id> &selectedCollection, QWidget *parent = nullptr);
    explicit SelectMultiCollectionWidget(const QString &mimetype, QWidget *parent = nullptr);
    ~SelectMultiCollectionWidget();

Q_REQUIRED_RESULT QVector<Akonadi::Collection> selectedCollection(const QModelIndex &parent = QModelIndex()) const;

private:
    void slotCollectionsTreeFetched();
    void initialize(const QString &mimetype);
    void updateStatus(const QModelIndex &parent);
    PimCommon::CheckedCollectionWidget *mCheckedCollectionWidget = nullptr;
    QList<Akonadi::Collection::Id> mListCollection;
};
}

#endif // SELECTMULTICOLLECTIONWIDGET_H
07070100000121000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/tests07070100000122000081A40000000200000002000000015CDAA39400000109000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/tests/CMakeLists.txtset(selectmultiselectiondialog_gui_SRCS selectmultiselectiondialog_gui.cpp)
add_executable(selectmultiselectiondialog_gui ${selectmultiselectiondialog_gui_SRCS})
target_link_libraries(selectmultiselectiondialog_gui
  KF5::Mime
  KF5::PimCommonAkonadi
  KF5::I18n
)
07070100000123000081A40000000200000002000000015CDAA39400000521000000000000000000000000000000000000007800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/folderdialog/tests/selectmultiselectiondialog_gui.cpp/*
  Copyright (c) 2013-2019 Montel Laurent <montel@kde.org>

This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2, as
  published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "pimcommonakonadi_debug.h"

#include "folderdialog/selectmulticollectiondialog.h"
#include <KMime/Message>
#include <QApplication>
#include <QCommandLineParser>
#include <QStandardPaths>

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    QStandardPaths::setTestModeEnabled(true);
    QCommandLineParser parser;
    parser.addVersionOption();
    parser.addHelpOption();
    parser.process(app);
    PimCommon::SelectMultiCollectionDialog *dialog = new PimCommon::SelectMultiCollectionDialog(KMime::Message::mimeType());
    dialog->exec();
    delete dialog;
    return 0;
}
07070100000124000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/genericplugins07070100000125000081A40000000200000002000000015CDAA394000009C0000000000000000000000000000000000000006C00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/genericplugins/genericplugininterface.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "genericplugininterface.h"

using namespace PimCommon;

class PimCommon::GenericPluginInterfacePrivate
{
public:
    GenericPluginInterfacePrivate()
    {
    }

QVector<ActionType> actionTypes;
};

GenericPluginInterface::GenericPluginInterface(QObject *parent)
    : AbstractGenericPluginInterface(parent)
    , d(new GenericPluginInterfacePrivate)
{
}

GenericPluginInterface::~GenericPluginInterface()
{
    delete d;
}

void GenericPluginInterface::setActionTypes(const QVector<ActionType> &type)
{
    d->actionTypes = type;
}

void GenericPluginInterface::addActionType(ActionType type)
{
    //TODO check already existence ?
    d->actionTypes.append(type);
}

QVector<ActionType> GenericPluginInterface::actionTypes() const
{
    return d->actionTypes;
}

void GenericPluginInterface::updateActions(int numberOfSelectedItems, int numberOfSelectedCollections)
{
    Q_UNUSED(numberOfSelectedItems);
    Q_UNUSED(numberOfSelectedCollections);
}

void GenericPluginInterface::setCurrentItems(const Akonadi::Item::List &items)
{
    Q_UNUSED(items);
}

void GenericPluginInterface::setItems(const Akonadi::Item::List &items)
{
    Q_UNUSED(items);
}

void GenericPluginInterface::setCurrentCollection(const Akonadi::Collection &col)
{
    Q_UNUSED(col);
}

void GenericPluginInterface::setCollections(const Akonadi::Collection::List &cols)
{
    Q_UNUSED(cols);
}

PimCommon::GenericPluginInterface::RequireTypes GenericPluginInterface::requires() const
{
    return None;
}

ActionType::ActionType(QAction *action, ActionType::Type type)
    : mAction(action)
    , mType(type)
{
}

QAction *ActionType::action() const
{
    return mAction;
}

ActionType::Type ActionType::type() const
{
    return mType;
}
07070100000126000081A40000000200000002000000015CDAA394000008A5000000000000000000000000000000000000006A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/genericplugins/genericplugininterface.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef GENERICPLUGININTERFACE_H
#define GENERICPLUGININTERFACE_H

#include <QObject>
#include <PimCommon/AbstractGenericPluginInterface>
#include "pimcommonakonadi_export.h"
#include <AkonadiCore/Item>
namespace PimCommon {
class GenericPluginInterfacePrivate;
class PIMCOMMONAKONADI_EXPORT GenericPluginInterface : public AbstractGenericPluginInterface
{
    Q_OBJECT
public:
    explicit GenericPluginInterface(QObject *parent = nullptr);
    ~GenericPluginInterface();

enum RequireType {
        None = 0,
        CurrentItems = 1,
        Items = 2,
        CurrentCollection = 3,
        Collections = 4
    };
    Q_ENUMS(RequireType)
    Q_DECLARE_FLAGS(RequireTypes, RequireType)

void setActionTypes(const QVector<ActionType> &type);
    void addActionType(ActionType type);
    Q_REQUIRED_RESULT QVector<ActionType> actionTypes() const;

virtual void setCurrentItems(const Akonadi::Item::List &items);
    virtual void setItems(const Akonadi::Item::List &items);
    virtual void setCurrentCollection(const Akonadi::Collection &col);
    virtual void setCollections(const Akonadi::Collection::List &cols);

virtual GenericPluginInterface::RequireTypes requires() const;

virtual void updateActions(int numberOfSelectedItems, int numberOfSelectedCollections);

private:
    GenericPluginInterfacePrivate *const d;
};
}
Q_DECLARE_TYPEINFO(PimCommon::ActionType, Q_MOVABLE_TYPE);
#endif // GENERICPLUGININTERFACE_H
07070100000127000081A40000000200000002000000015CDAA39400001EFA000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/genericplugins/plugininterface.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "plugininterface.h"

#include <PimCommon/GenericPluginManager>
#include "pimcommonakonadi_debug.h"

#include <KActionCollection>
#include <KXMLGUIClient>
#include <QAction>

#include <PimCommon/GenericPlugin>

using namespace PimCommon;

class PimCommon::PluginInterfacePrivate
{
public:
    PluginInterfacePrivate()
        : mParentWidget(nullptr)
        , mActionCollection(nullptr)
        , mGenericPluginManager(nullptr)
    {
    }

QString mPluginName;
    QString mServiceTypeName;
    QWidget *mParentWidget = nullptr;
    KActionCollection *mActionCollection = nullptr;
    QVector<PimCommon::GenericPluginInterface *> mListGenericInterface;
    GenericPluginManager *mGenericPluginManager = nullptr;
};

PluginInterface::PluginInterface(QObject *parent)
    : QObject(parent)
    , d(new PimCommon::PluginInterfacePrivate)
{
    d->mGenericPluginManager = new GenericPluginManager(this);
}

PluginInterface::~PluginInterface()
{
    delete d;
}

void PimCommon::PluginInterface::setActionCollection(KActionCollection *ac)
{
    d->mActionCollection = ac;
}

void PluginInterface::initializePlugins()
{
    d->mGenericPluginManager->setPluginName(d->mPluginName);
    d->mGenericPluginManager->setServiceTypeName(d->mServiceTypeName);
    if (!d->mGenericPluginManager->initializePlugins()) {
        qCDebug(PIMCOMMONAKONADI_LOG) << " Impossible to initialize plugins";
    }
}

void PluginInterface::setPluginName(const QString &name)
{
    d->mPluginName = name;
}

void PluginInterface::setServiceTypeName(const QString &name)
{
    d->mServiceTypeName = name;
}

void PluginInterface::createPluginInterface()
{
    if (!d->mActionCollection) {
        qCWarning(PIMCOMMONAKONADI_LOG) << "Missing action collection";
        return;
    }
    for (PimCommon::GenericPlugin *plugin : d->mGenericPluginManager->pluginsList()) {
        if (plugin->isEnabled()) {
            PimCommon::GenericPluginInterface *interface = static_cast<PimCommon::GenericPluginInterface *>(plugin->createInterface(this));
            interface->setParentWidget(d->mParentWidget);
            //Add parent before creating action
            interface->createAction(d->mActionCollection);
            interface->setPlugin(plugin);
            connect(interface, &PimCommon::GenericPluginInterface::emitPluginActivated, this, &PluginInterface::slotPluginActivated);
            d->mListGenericInterface.append(interface);
        }
    }
}

void PluginInterface::initializeInterfaceRequires(PimCommon::AbstractGenericPluginInterface *interface)
{
    Q_UNUSED(interface)
}

QString PluginInterface::actionXmlExtension(ActionType::Type type)
{
    switch (type) {
    case PimCommon::ActionType::Tools:
        return QStringLiteral("_plugins_tools");
    case PimCommon::ActionType::Edit:
        return QStringLiteral("_plugins_edit");
    case PimCommon::ActionType::File:
        return QStringLiteral("_plugins_file");
    case PimCommon::ActionType::Action:
        return QStringLiteral("_plugins_actions");
    case PimCommon::ActionType::PopupMenu:
        return QStringLiteral("_popupmenu_actions");
    case PimCommon::ActionType::ToolBar:
        return QStringLiteral("_toolbar_actions");
    case PimCommon::ActionType::Message:
        return QStringLiteral("_plugins_message");
    case PimCommon::ActionType::Folder:
        return QStringLiteral("_plugins_folder");
    }
    return {};
}

void PluginInterface::slotPluginActivated(PimCommon::AbstractGenericPluginInterface *interface)
{
    initializeInterfaceRequires(interface);
    if (interface) {
        interface->exec();
    }
}

void PluginInterface::setParentWidget(QWidget *widget)
{
    d->mParentWidget = widget;
}

void PluginInterface::initializePluginActions(const QString &prefix, KXMLGUIClient *guiClient)
{
    if (guiClient->factory()) {
        QHashIterator<PimCommon::ActionType::Type, QList<QAction *> > localActionsType(actionsType());
        while (localActionsType.hasNext()) {
            localActionsType.next();
            QList<QAction *> lst = localActionsType.value();
            if (!lst.isEmpty()) {
                const QString actionlistname = prefix + PimCommon::PluginInterface::actionXmlExtension(localActionsType.key());
                guiClient->unplugActionList(actionlistname);
                guiClient->plugActionList(actionlistname, lst);
            }
        }
    }
}

void PluginInterface::updateActions(int numberOfSelectedItems, int numberOfSelectedCollections)
{
    for (PimCommon::GenericPluginInterface *interface : qAsConst(d->mListGenericInterface)) {
        interface->updateActions(numberOfSelectedItems, numberOfSelectedCollections);
    }
}

QHash<PimCommon::ActionType::Type, QList<QAction *> > PluginInterface::actionsType()
{
    QHash<PimCommon::ActionType::Type, QList<QAction *> > listType;
    for (PimCommon::GenericPluginInterface *interface : qAsConst(d->mListGenericInterface)) {
        for (const PimCommon::ActionType &actionType : interface->actionTypes()) {
            PimCommon::ActionType::Type type = actionType.type();
            QList<QAction *> lst = listType.value(type);
            if (!lst.isEmpty()) {
                QAction *act = new QAction(this);
                act->setSeparator(true);
                lst << act << actionType.action();
                listType.insert(type, lst);
            } else {
                listType.insert(type, QList<QAction *>() << actionType.action());
            }
            if (interface->plugin()->hasPopupMenuSupport()) {
                type = PimCommon::ActionType::PopupMenu;
                QList<QAction *> lst = listType.value(type);
                if (!lst.isEmpty()) {
                    QAction *act = new QAction(this);
                    act->setSeparator(true);
                    lst << act << actionType.action();
                    listType.insert(type, lst);
                } else {
                    listType.insert(type, QList<QAction *>() << actionType.action());
                }
            }
            if (interface->plugin()->hasToolBarSupport()) {
                type = PimCommon::ActionType::ToolBar;
                QList<QAction *> lst = listType.value(type);
                if (!lst.isEmpty()) {
                    QAction *act = new QAction(this);
                    act->setSeparator(true);
                    lst << act << actionType.action();
                    listType.insert(type, lst);
                } else {
                    listType.insert(type, QList<QAction *>() << actionType.action());
                }
            }
        }
    }

return listType;
}

QVector<PimCommon::PluginUtilData> PluginInterface::pluginsDataList() const
{
    return d->mGenericPluginManager->pluginsDataList();
}

QString PluginInterface::configGroupName() const
{
    return d->mGenericPluginManager->configGroupName();
}

QString PluginInterface::configPrefixSettingKey() const
{
    return d->mGenericPluginManager->configPrefixSettingKey();
}

PimCommon::GenericPlugin *PluginInterface::pluginFromIdentifier(const QString &id)
{
    return d->mGenericPluginManager->pluginFromIdentifier(id);
}
07070100000128000081A40000000200000002000000015CDAA39400000929000000000000000000000000000000000000006300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/genericplugins/plugininterface.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef PLUGININTERFACE_H
#define PLUGININTERFACE_H

#include <QObject>
#include <PimCommonAkonadi/GenericPluginInterface>
#include <PimCommon/PluginUtil>
#include "pimcommonakonadi_export.h"
class KActionCollection;
class QAction;
class KXMLGUIClient;
namespace PimCommon {
class PluginInterfacePrivate;
class PIMCOMMONAKONADI_EXPORT PluginInterface : public QObject
{
    Q_OBJECT
public:
    explicit PluginInterface(QObject *parent = nullptr);
    ~PluginInterface();

void setParentWidget(QWidget *widget);
    QHash<PimCommon::ActionType::Type, QList<QAction *> > actionsType();
    void createPluginInterface();

void setPluginName(const QString &name);
    void setServiceTypeName(const QString &name);
    void initializePlugins();
    virtual void initializeInterfaceRequires(AbstractGenericPluginInterface *interface);
    static QString actionXmlExtension(PimCommon::ActionType::Type type);

void initializePluginActions(const QString &prefix, KXMLGUIClient *guiClient);
    void updateActions(int numberOfSelectedItems, int numberOfSelectedCollections);

void setActionCollection(KActionCollection *ac);

Q_REQUIRED_RESULT QVector<PimCommon::PluginUtilData> pluginsDataList() const;
    Q_REQUIRED_RESULT QString configGroupName() const;
    Q_REQUIRED_RESULT QString configPrefixSettingKey() const;

PimCommon::GenericPlugin *pluginFromIdentifier(const QString &id);
private Q_SLOTS:
    void slotPluginActivated(AbstractGenericPluginInterface *interface);

private:
    PluginInterfacePrivate *const d;
};
}

#endif // PLUGININTERFACE_H
07070100000129000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004600000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/job0707010000012A000081A40000000200000002000000015CDAA39400000A02000000000000000000000000000000000000006700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/job/fetchrecursivecollectionsjob.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#include "fetchrecursivecollectionsjob.h"
#include "pimcommonakonadi_debug.h"
#include <CollectionFetchJob>
#include <AkonadiCore/CollectionFetchScope>
using namespace PimCommon;

class PimCommon::FetchRecursiveCollectionsJobPrivate
{
public:
    FetchRecursiveCollectionsJobPrivate()
    {
    }

Akonadi::Collection mTopCollection;
};

FetchRecursiveCollectionsJob::FetchRecursiveCollectionsJob(QObject *parent)
    : QObject(parent)
    , d(new PimCommon::FetchRecursiveCollectionsJobPrivate)
{
}

FetchRecursiveCollectionsJob::~FetchRecursiveCollectionsJob()
{
    delete d;
}

void FetchRecursiveCollectionsJob::start()
{
    if (!d->mTopCollection.isValid()) {
        qCWarning(PIMCOMMONAKONADI_LOG) << "Any collection is defined";
        Q_EMIT fetchCollectionFailed();
        deleteLater();
        return;
    }
    Akonadi::CollectionFetchJob *job = new Akonadi::CollectionFetchJob(d->mTopCollection, Akonadi::CollectionFetchJob::Recursive);
    job->fetchScope().setAncestorRetrieval(Akonadi::CollectionFetchScope::All);
    connect(job, &Akonadi::CollectionFetchJob::result, this, &FetchRecursiveCollectionsJob::slotInitialCollectionFetchingDone);
}

void FetchRecursiveCollectionsJob::setTopCollection(const Akonadi::Collection &col)
{
    d->mTopCollection = col;
}

void FetchRecursiveCollectionsJob::slotInitialCollectionFetchingDone(KJob *job)
{
    if (job->error()) {
        qCWarning(PIMCOMMONAKONADI_LOG) << job->errorString();
        Q_EMIT fetchCollectionFailed();
        deleteLater();
        return;
    }
    Akonadi::CollectionFetchJob *fetchJob = qobject_cast<Akonadi::CollectionFetchJob *>(job);
    Q_EMIT fetchCollectionFinished(fetchJob->collections() << d->mTopCollection);
    deleteLater();
}
0707010000012B000081A40000000200000002000000015CDAA39400000656000000000000000000000000000000000000006500000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/job/fetchrecursivecollectionsjob.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at your
  option) any later version.

This library 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 Library General Public
  License for more details.

You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

#ifndef FETCHRECURSIVECOLLECTIONSJOB_H
#define FETCHRECURSIVECOLLECTIONSJOB_H

#include <Collection>
#include <QObject>
#include "pimcommonakonadi_export.h"
class KJob;
namespace PimCommon {
class FetchRecursiveCollectionsJobPrivate;
class PIMCOMMONAKONADI_EXPORT FetchRecursiveCollectionsJob : public QObject
{
    Q_OBJECT
public:
    explicit FetchRecursiveCollectionsJob(QObject *parent = nullptr);
    ~FetchRecursiveCollectionsJob();

void setTopCollection(const Akonadi::Collection &col);

void start();

Q_SIGNALS:
    void fetchCollectionFinished(const Akonadi::Collection::List &list);
    void fetchCollectionFailed();

private:
    void slotInitialCollectionFetchingDone(KJob *job);
    FetchRecursiveCollectionsJobPrivate *const d;
};
}
#endif // FETCHRECURSIVECOLLECTIONSJOB_H
0707010000012C000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/manageserversidesubscription0707010000012D000081A40000000200000002000000015CDAA39400000F5F000000000000000000000000000000000000008300000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/manageserversidesubscription/manageserversidesubscriptionjob.cpp/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "manageserversidesubscriptionjob.h"
#include "util/mailutil.h"
#include "pimcommonakonadi_debug.h"

#include <AkonadiCore/ServerManager>

#include <KDBusConnectionPool>
#include <KLocalizedString>
#include <KMessageBox>

#include <QDBusInterface>
#include <QDBusPendingCall>
#include <QDBusPendingReply>

using namespace PimCommon;

class PimCommon::ManageServerSideSubscriptionJobPrivate
{
public:
    ManageServerSideSubscriptionJobPrivate()
        : mParentWidget(nullptr)
    {
    }

Akonadi::Collection mCurrentCollection;
    QWidget *mParentWidget = nullptr;
};

ManageServerSideSubscriptionJob::ManageServerSideSubscriptionJob(QObject *parent)
    : QObject(parent)
    , d(new PimCommon::ManageServerSideSubscriptionJobPrivate)
{
}

ManageServerSideSubscriptionJob::~ManageServerSideSubscriptionJob()
{
    delete d;
}

void ManageServerSideSubscriptionJob::start()
{
    if (!d->mCurrentCollection.isValid()) {
        qCDebug(PIMCOMMONAKONADI_LOG) << " collection not defined";
        deleteLater();
        return;
    }
    bool isImapOnline = false;
    if (PimCommon::MailUtil::isImapFolder(d->mCurrentCollection, isImapOnline)) {
        const QString service
            = Akonadi::ServerManager::agentServiceName(Akonadi::ServerManager::Resource,
                                                       d->mCurrentCollection.resource());
        QDBusInterface iface(service,
                             QStringLiteral("/"), QStringLiteral("org.kde.Akonadi.ImapResourceBase"),
                             KDBusConnectionPool::threadConnection(), this);
        if (!iface.isValid()) {
            qCDebug(PIMCOMMONAKONADI_LOG) << "Cannot create imap dbus interface for service " << service;
            deleteLater();
            return;
        }
        QDBusPendingCall call = iface.asyncCall(QStringLiteral("configureSubscription"), (qlonglong)d->mParentWidget->winId());
        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(call, this);
        connect(watcher, &QDBusPendingCallWatcher::finished, this, &ManageServerSideSubscriptionJob::slotConfigureSubscriptionFinished);
    }
}

void ManageServerSideSubscriptionJob::slotConfigureSubscriptionFinished(QDBusPendingCallWatcher *watcher)
{
    QDBusPendingReply<int> reply = *watcher;
    if (reply.isValid()) {
        if (reply == -2) {
            KMessageBox::error(d->mParentWidget, i18n("IMAP server not configured yet. Please configure the server in the IMAP account before setting up server-side subscription."));
        } else if (reply == -1) {
            KMessageBox::error(d->mParentWidget, i18n("Log in failed, please configure the IMAP account before setting up server-side subscription."));
        }
    } else {
        qCDebug(PIMCOMMONAKONADI_LOG) << "ManageServerSideSubscriptionJob return an invalid reply";
    }
    watcher->deleteLater();
    watcher = nullptr;
    deleteLater();
}

void ManageServerSideSubscriptionJob::setParentWidget(QWidget *parentWidget)
{
    d->mParentWidget = parentWidget;
}

void ManageServerSideSubscriptionJob::setCurrentCollection(const Akonadi::Collection &col)
{
    d->mCurrentCollection = col;
}
0707010000012E000081A40000000200000002000000015CDAA3940000064A000000000000000000000000000000000000008100000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/manageserversidesubscription/manageserversidesubscriptionjob.h/*
  Copyright (c) 2014-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MANAGESERVERSIDESUBSCRIPTIONJOB_H
#define MANAGESERVERSIDESUBSCRIPTIONJOB_H

#include <QObject>
#include "pimcommonakonadi_export.h"
#include <QSharedPointer>
#include <AkonadiCore/collection.h>
class QDBusPendingCallWatcher;
namespace PimCommon {
class ManageServerSideSubscriptionJobPrivate;
class PIMCOMMONAKONADI_EXPORT ManageServerSideSubscriptionJob : public QObject
{
    Q_OBJECT
public:
    explicit ManageServerSideSubscriptionJob(QObject *parent = nullptr);

~ManageServerSideSubscriptionJob();

void start();
    void setCurrentCollection(const Akonadi::Collection &col);

void setParentWidget(QWidget *parentWidget);

private:
    void slotConfigureSubscriptionFinished(QDBusPendingCallWatcher *watcher);
    ManageServerSideSubscriptionJobPrivate *const d;
};
}

#endif // MANAGESERVERSIDESUBSCRIPTIONJOB_H
0707010000012F000081A40000000200000002000000015CDAA394000004FE000000000000000000000000000000000000006400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/pimcommonakonadi_private_export.h/*  This file is part of the KDE project
    Copyright (C) 2017-2019 Laurent Montel <montel@kde.org>

This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef PIMCOMMONAKONADIPRIVATE_EXPORT_H
#define PIMCOMMONAKONADIPRIVATE_EXPORT_H

#include "pimcommonakonadi_export.h"

/* Classes which are exported only for unit tests */
#ifdef BUILD_TESTING
# ifndef PIMCOMMONAKONADI_TESTS_EXPORT
#  define PIMCOMMONAKONADI_TESTS_EXPORT PIMCOMMONAKONADI_EXPORT
# endif
#else /* not compiling tests */
# define PIMCOMMONAKONADI_TESTS_EXPORT
#endif

#endif
07070100000130000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004700000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/util07070100000131000081A40000000200000002000000015CDAA394000015F6000000000000000000000000000000000000005A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/util/createresource.cpp/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "createresource.h"

#include "pimcommonakonadi_debug.h"
#include <KLocalizedString>

#include <agenttype.h>
#include <agentmanager.h>
#include <agentinstancecreatejob.h>

#include <QDBusReply>
#include <QDBusInterface>
#include <QMetaMethod>

using namespace Akonadi;

using namespace PimCommon;

CreateResource::CreateResource(QObject *parent)
    : QObject(parent)
{
}

CreateResource::~CreateResource()
{
}

//code from accountwizard
static QVariant::Type argumentType(const QMetaObject *mo, const QString &method)
{
    QMetaMethod m;
    const int numberOfMethod(mo->methodCount());
    for (int i = 0; i < numberOfMethod; ++i) {
        const QString signature = QString::fromLatin1(mo->method(i).methodSignature());
        if (signature.contains(method + QLatin1Char('('))) {
            m = mo->method(i);
            break;
        }
    }

if (m.methodSignature().isEmpty()) {
        qCWarning(PIMCOMMONAKONADI_LOG) << "Did not find D-Bus method: " << method << " available methods are:";
        const int numberOfMethod(mo->methodCount());
        for (int i = 0; i < numberOfMethod; ++i) {
            qCWarning(PIMCOMMONAKONADI_LOG) << mo->method(i).methodSignature();
        }
        return QVariant::Invalid;
    }

const QList<QByteArray> argTypes = m.parameterTypes();
    if (argTypes.count() != 1) {
        return QVariant::Invalid;
    }

return QVariant::nameToType(argTypes.first().constData());
}

QString CreateResource::createResource(const QString &resources, const QString &name, const QMap<QString, QVariant> &settings, bool synchronizeTree)
{
    const AgentType type = AgentManager::self()->type(resources);
    if (!type.isValid()) {
        Q_EMIT createResourceError(i18n("Resource type '%1' is not available.", resources));
        return QString();
    }

// check if unique instance already exists
    qCDebug(PIMCOMMONAKONADI_LOG) << type.capabilities();
    if (type.capabilities().contains(QLatin1String("Unique"))) {
        const AgentInstance::List lstInstances = AgentManager::self()->instances();
        for (const AgentInstance &instance : lstInstances) {
            qCDebug(PIMCOMMONAKONADI_LOG) << instance.type().identifier() << (instance.type() == type);
            if (instance.type() == type) {
                Q_EMIT createResourceInfo(i18n("Resource '%1' is already set up.", type.name()));
                return QString();
            }
        }
    }

Q_EMIT createResourceInfo(i18n("Creating resource instance for '%1'...", type.name()));
    AgentInstanceCreateJob *job = new AgentInstanceCreateJob(type, this);
    if (job->exec()) {
        Akonadi::AgentInstance instance = job->instance();

if (!settings.isEmpty()) {
            Q_EMIT createResourceInfo(i18n("Configuring resource instance..."));
            QDBusInterface iface(QLatin1String("org.freedesktop.Akonadi.Resource.") + instance.identifier(), QStringLiteral("/Settings"));
            if (!iface.isValid()) {
                Q_EMIT createResourceError(i18n("Unable to configure resource instance."));
                return QString();
            }

// configure resource
            if (!name.isEmpty()) {
                instance.setName(name);
            }
            const QMap<QString, QVariant>::const_iterator end(settings.constEnd());
            for (QMap<QString, QVariant>::const_iterator it = settings.constBegin(); it != end; ++it) {
                qCDebug(PIMCOMMONAKONADI_LOG) << "Setting up " << it.key() << " for agent " << instance.identifier();
                const QString methodName = QStringLiteral("set%1").arg(it.key());
                QVariant arg = it.value();
                const QVariant::Type targetType = argumentType(iface.metaObject(), methodName);
                if (!arg.canConvert(targetType)) {
                    Q_EMIT createResourceError(i18n("Could not convert value of setting '%1' to required type %2.", it.key(), QString::fromLatin1(QVariant::typeToName(targetType))));
                    return QString();
                }
                arg.convert(targetType);
                QDBusReply<void> reply = iface.call(methodName, arg);
                if (!reply.isValid()) {
                    Q_EMIT createResourceError(i18n("Could not set setting '%1': %2", it.key(), reply.error().message()));
                    return QString();
                }
            }
            instance.reconfigure();
            if (synchronizeTree) {
                instance.synchronizeCollectionTree();
            }
        }

Q_EMIT createResourceInfo(i18n("Resource setup completed."));
        return instance.identifier();
    } else {
        if (job->error()) {
            Q_EMIT createResourceError(i18n("Failed to create resource instance: %1", job->errorText()));
        }
    }
    return QString();
}
07070100000132000081A40000000200000002000000015CDAA3940000058C000000000000000000000000000000000000005800000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/util/createresource.h/*
  Copyright (c) 2012-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef PIMCOMMONCREATERESOURCE_H
#define PIMCOMMONCREATERESOURCE_H

#include "pimcommonakonadi_export.h"
#include <QObject>
#include <QVariant>
#include <QMap>

namespace PimCommon {
class PIMCOMMONAKONADI_EXPORT CreateResource : public QObject
{
    Q_OBJECT
public:
    explicit CreateResource(QObject *parent = nullptr);
    ~CreateResource();

Q_REQUIRED_RESULT QString createResource(const QString &resources, const QString &name, const QMap<QString, QVariant> &settings, bool synchronizeTree = false);

Q_SIGNALS:
    void createResourceInfo(const QString &);
    void createResourceError(const QString &);
};
}

#endif // CREATERESOURCE_H
07070100000133000081A40000000200000002000000015CDAA39400000F65000000000000000000000000000000000000006B00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/util/imapresourcecapabilitiesmanager.cpp/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "imapresourcecapabilitiesmanager.h"
#include "pimcommonakonadi_debug.h"
#include "util/pimutil.h"

#include <AkonadiCore/AgentManager>
#include <AkonadiCore/ServerManager>

#include <KDBusConnectionPool>
#include <QDBusInterface>
#include <QDBusPendingCall>
#include <QDBusPendingReply>

using namespace PimCommon;
ImapResourceCapabilitiesManager::ImapResourceCapabilitiesManager(QObject *parent)
    : QObject(parent)
{
    init();
}

ImapResourceCapabilitiesManager::~ImapResourceCapabilitiesManager()
{
}

void ImapResourceCapabilitiesManager::slotInstanceAdded(const Akonadi::AgentInstance &instance)
{
    searchCapabilities(instance.identifier());
}

void ImapResourceCapabilitiesManager::slotInstanceRemoved(const Akonadi::AgentInstance &instance)
{
    mImapResource.remove(instance.identifier());
}

void ImapResourceCapabilitiesManager::searchCapabilities(const QString &identifier)
{
    //By default makes it as true.
    mImapResource.insert(identifier, true);
    const QString service
        = Akonadi::ServerManager::agentServiceName(Akonadi::ServerManager::Resource, identifier);
    QDBusInterface iface(service,
                         QStringLiteral("/"), QStringLiteral("org.kde.Akonadi.ImapResourceBase"),
                         KDBusConnectionPool::threadConnection(), this);

if (iface.isValid()) {
        QDBusPendingCall call = iface.asyncCall(QStringLiteral("serverCapabilities"));
        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(call, this);
        watcher->setProperty("identifier", identifier);
        connect(watcher, &QDBusPendingCallWatcher::finished, this, &ImapResourceCapabilitiesManager::slotCapabilities);
    } else {
        qCDebug(PIMCOMMONAKONADI_LOG) << "interface not valid";
    }
}

void ImapResourceCapabilitiesManager::slotCapabilities(QDBusPendingCallWatcher *watcher)
{
    QDBusPendingReply<QStringList> reply = *watcher;
    if (reply.isValid()) {
        if (watcher->property("identifier").isValid()) {
            const QStringList capabilities = reply.value();
            mImapResource.insert(watcher->property("identifier").toString(), capabilities.contains(QLatin1String("ANNOTATEMORE")));
        }
    }
    watcher->deleteLater();
    watcher = nullptr;
}

void ImapResourceCapabilitiesManager::init()
{
    const Akonadi::AgentInstance::List lstInstances = Akonadi::AgentManager::self()->instances();
    for (const Akonadi::AgentInstance &instance : lstInstances) {
        const QString identifier = instance.identifier();
        if (PimCommon::Util::isImapResource(identifier)) {
            searchCapabilities(identifier);
        }
    }
    connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceAdded, this, &ImapResourceCapabilitiesManager::slotInstanceAdded);
    connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceRemoved, this, &ImapResourceCapabilitiesManager::slotInstanceRemoved);
}

bool ImapResourceCapabilitiesManager::hasAnnotationSupport(const QString &identifier) const
{
    if (!PimCommon::Util::isImapResource(identifier)) {
        return false;
    }
    return mImapResource.value(identifier, true);
}
07070100000134000081A40000000200000002000000015CDAA3940000069F000000000000000000000000000000000000006900000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/util/imapresourcecapabilitiesmanager.h/*
  Copyright (c) 2015-2019 Montel Laurent <montel@kde.org>

This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef IMAPRESOURCECAPABILITIESMANAGER_H
#define IMAPRESOURCECAPABILITIESMANAGER_H

#include <QObject>
#include <QHash>

#include "pimcommonakonadi_export.h"
class QDBusPendingCallWatcher;
namespace Akonadi {
class AgentInstance;
}
namespace PimCommon {
class PIMCOMMONAKONADI_EXPORT ImapResourceCapabilitiesManager : public QObject
{
    Q_OBJECT
public:
    explicit ImapResourceCapabilitiesManager(QObject *parent = nullptr);
    ~ImapResourceCapabilitiesManager();

Q_REQUIRED_RESULT bool hasAnnotationSupport(const QString &identifier) const;

private:
    void slotInstanceAdded(const Akonadi::AgentInstance &instance);
    void slotInstanceRemoved(const Akonadi::AgentInstance &instance);
    void slotCapabilities(QDBusPendingCallWatcher *watcher);

void init();
    void searchCapabilities(const QString &identifier);
    QHash<QString, bool> mImapResource;
};
}

#endif // IMAPRESOURCECAPABILITIESMANAGER_H
07070100000135000081A40000000200000002000000015CDAA394000009E5000000000000000000000000000000000000005400000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/util/mailutil.cpp/*******************************************************************************
**
** Filename   : util
** Created on : 03 April, 2005
** Copyright  : (c) 2005 Till Adam
** Email      : <adam@kde.org>
**
*******************************************************************************/

#include "mailutil.h"
#include <PimCommon/PimUtil>

#include <AgentInstance>
#include <AkonadiCore/AgentManager>
#include <AkonadiCore/ServerManager>

bool PimCommon::MailUtil::isImapFolder(const Akonadi::Collection &col, bool &isOnline)
{
    const Akonadi::AgentInstance agentInstance = Akonadi::AgentManager::self()->instance(col.resource());
    isOnline = agentInstance.isOnline();

return PimCommon::Util::isImapResource(agentInstance.type().identifier());
}

QString PimCommon::MailUtil::indexerServiceName()
{
    return Akonadi::ServerManager::agentServiceName(Akonadi::ServerManager::Agent,
                                                    QStringLiteral("akonadi_indexing_agent"));
}
07070100000136000081A40000000200000002000000015CDAA39400000907000000000000000000000000000000000000005200000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/util/mailutil.h/*******************************************************************************
**
** Filename   : util
** Created on : 03 April, 2005
** Copyright  : (c) 2005 Till Adam
** Email      : <adam@kde.org>
**
*******************************************************************************/

#include "pimcommonakonadi_export.h"
#include <AkonadiCore/collection.h>

namespace PimCommon {
/**
 * The Util namespace contains a collection of helper functions use in
 * various places.
 */
namespace MailUtil {
Q_REQUIRED_RESULT PIMCOMMONAKONADI_EXPORT QString indexerServiceName();
Q_REQUIRED_RESULT PIMCOMMONAKONADI_EXPORT bool isImapFolder(const Akonadi::Collection &col, bool &isOnline);
}
}

#endif
07070100000137000041ED0000000200000002000000025CDAA39400000000000000000000000000000000000000000000004A00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/widgets07070100000138000081A40000000200000002000000015CDAA394000019A1000000000000000000000000000000000000005F00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/widgets/annotationdialog.cpp/*
   Copyright 2010 Thomas McGuire <mcguire@kde.org>
   Copyright 2014-2019 Laurent Montel <montel@kde.org>

This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License or (at your option) version 3 or any later version
   accepted by the membership of KDE e.V. (or its successor approved
   by the membership of KDE e.V.), which shall act as a proxy
   defined in Section 14 of version 3 of the license.

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/>.
*/

#include "annotationdialog.h"
#include "kpimtextedit/plaintexteditorwidget.h"

#include <KMessageBox>
#include <KLocalizedString>
#include <ItemModifyJob>
#include <KSharedConfig>
#include <KStandardGuiItem>
#include <item.h>
#include <entityannotationsattribute.h>

#include <QComboBox>
#include <QIcon>

#include <QLabel>
#include <KConfigGroup>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>

using namespace PimCommon;

class Q_DECL_HIDDEN AnnotationEditDialog::Private
{
public:
    Private()
    {
    }

Akonadi::Item mItem;
    KPIMTextEdit::PlainTextEditorWidget *mTextEdit = nullptr;
    QComboBox *mNoteType = nullptr;
    bool mHasAnnotation = false;
};

AnnotationEditDialog::AnnotationEditDialog(const Akonadi::Item &item, QWidget *parent)
    : QDialog(parent)
    , d(new Private)
{
    d->mItem = item;
    //check for correct key?
    d->mHasAnnotation = item.hasAttribute<Akonadi::EntityAnnotationsAttribute>();
    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
    QWidget *mainWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->addWidget(mainWidget);
    QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setDefault(true);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &AnnotationEditDialog::slotAccepted);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &AnnotationEditDialog::reject);

if (d->mHasAnnotation) {
        setWindowTitle(i18nc("@title:window", "Edit Note"));
        QPushButton *user1Button = new QPushButton;
        buttonBox->addButton(user1Button, QDialogButtonBox::ActionRole);
        user1Button->setText(i18nc("@action:button", "Delete Note"));
        user1Button->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
        connect(user1Button, &QPushButton::clicked, this, &AnnotationEditDialog::slotDeleteNote);
    } else {
        setWindowTitle(i18nc("@title:window", "Add Note"));
    }

buttonBox->button(QDialogButtonBox::Ok)->setDefault(true);

QLabel *label = new QLabel(i18n("Enter the text that should be stored as a note to the mail:"));
    QVBoxLayout *vbox = new QVBoxLayout(mainWidget);
    vbox->setContentsMargins(0, 0, 0, 0);
    d->mTextEdit = new KPIMTextEdit::PlainTextEditorWidget(this);
    vbox->addWidget(label);
    vbox->addWidget(d->mTextEdit);
    d->mTextEdit->setFocus();

QHBoxLayout *hbox = new QHBoxLayout;
    hbox->addStretch();
    label = new QLabel(i18nc("@label:listbox", "Note type:"));
    hbox->addWidget(label);
    d->mNoteType = new QComboBox;
    hbox->addWidget(d->mNoteType);
    d->mNoteType->addItem(i18nc("@item:inlistbox", "Private note"), QByteArrayLiteral("/private/comment"));
    d->mNoteType->addItem(i18nc("@item:inlistbox", "Shared note"), QByteArrayLiteral("/shared/comment"));

vbox->addLayout(hbox);
    if (d->mHasAnnotation && item.attribute<Akonadi::EntityAnnotationsAttribute>()) {
        if (item.attribute<Akonadi::EntityAnnotationsAttribute>()->contains("/private/comment")) {
            d->mNoteType->setCurrentIndex(d->mNoteType->findData(QStringLiteral("/private/comment")));
            d->mTextEdit->setPlainText(item.attribute<Akonadi::EntityAnnotationsAttribute>()->value("/private/comment"));
        } else {
            d->mNoteType->setCurrentIndex(d->mNoteType->findData(QStringLiteral("/shared/comment")));
            d->mTextEdit->setPlainText(item.attribute<Akonadi::EntityAnnotationsAttribute>()->value("/shared/comment"));
        }
    }
    mainLayout->addWidget(buttonBox);
    readConfig();
}

AnnotationEditDialog::~AnnotationEditDialog()
{
    writeConfig();
    delete d;
}

void AnnotationEditDialog::slotAccepted()
{
    bool textIsEmpty = d->mTextEdit->isEmpty();
    if (!textIsEmpty) {
        d->mItem.removeAttribute<Akonadi::EntityAnnotationsAttribute>();
        Akonadi::EntityAnnotationsAttribute *annotation = d->mItem.attribute<Akonadi::EntityAnnotationsAttribute>(Akonadi::Item::AddIfMissing);
        QMap<QByteArray, QByteArray> map;
        map.insert(d->mNoteType->itemData(d->mNoteType->currentIndex()).toByteArray(), d->mTextEdit->toPlainText().toUtf8());
        annotation->setAnnotations(map);
        d->mItem.addAttribute(annotation);
    } else if (d->mHasAnnotation && textIsEmpty) {
        d->mItem.removeAttribute<Akonadi::EntityAnnotationsAttribute>();
    }
    new Akonadi::ItemModifyJob(d->mItem);
    accept();
}

void AnnotationEditDialog::slotDeleteNote()
{
    const int answer = KMessageBox::warningContinueCancel(this,
                                                          i18n("Do you really want to delete this note?"),
                                                          i18nc("@title:window", "Delete Note?"),
                                                          KStandardGuiItem::del());
    if (answer == KMessageBox::Continue) {
        d->mItem.removeAttribute<Akonadi::EntityAnnotationsAttribute>();
        new Akonadi::ItemModifyJob(d->mItem);
        accept();
    }
}

void AnnotationEditDialog::readConfig()
{
    KSharedConfig::Ptr cfg = KSharedConfig::openConfig();
    KConfigGroup group(cfg, "AnnotationEditDialog");
    QSize size = group.readEntry("Size", QSize());
    if (!size.isEmpty()) {
        resize(size);
    }
}

void AnnotationEditDialog::writeConfig()
{
    KSharedConfig::Ptr cfg = KSharedConfig::openConfig();
    KConfigGroup group(cfg, "AnnotationEditDialog");
    group.writeEntry("Size", size());
}
07070100000139000081A40000000200000002000000015CDAA3940000070E000000000000000000000000000000000000005D00000000pimcommon-VERSIONgit.20190514T131636~0c3a7c5/src/pimcommonakonadi/widgets/annotationdialog.h/* Copyright 2010 Thomas McGuire <mcguire@kde.org>

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/>.
*/

#ifndef MESSAGECORE_ANNOTATIONDIALOG_H
#define MESSAGECORE_ANNOTATIONDIALOG_H

#include "pimcommonakonadi_export.h"

#include <QDialog>

namespace Akonadi {
class Item;
}

namespace PimCommon {
/**
 * @short A dialog for editing annotations of an email.
 *
 * @author Thomas McGuire <mcguire@kde.org>
 */
class PIMCOMMONAKONADI_EXPORT AnnotationEditDialog : public QDialog
{
    Q_OBJECT

public:
    /**
     * Creates a new annotation edit dialog.
     *
     * @param item The item.
     * @param parent The parent widget.
     */
    explicit AnnotationEditDialog(const Akonadi::Item &item, QWidget *parent = nullptr);

/**
     * Destroys the annotation edit dialog.
     */
    ~AnnotationEditDialog();

private:
    void readConfig();
    void writeConfig();
    void slotAccepted();
    void slotDeleteNote();
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
}

#endif
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!2035 blocks

Places

File _service:obs_scm:pimcommon-VERSIONgit.20190514T131636~0c3a7c5.obscpio of Package pimcommon (Revision 3ea20309fa21bc5d984bb9610c1e91ad)

Places