File _service:obs_scm:incidenceeditor-VERSIONgit.201... of Package incidenceeditor

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:incidenceeditor-VERSIONgit.20180311T173414~fbfddcd.obscpio of Package incidenceeditor (Revision 82f0bbe0a5edc96ade20f7588511225d)

Currently displaying revision 82f0bbe0a5edc96ade20f7588511225d , Show latest

070701115400DD000081A40000000200000002000000015AA55A860000004B000000FD0000001000000000000000000000003E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/.arcconfig{
  "phabricator.uri": "https://phabricator.kde.org/project/profile/34/"
}
070701115400E4000081A40000000200000002000000015AA55A8600000044000000FD0000001000000000000000000000003A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/.krazyEXTRA camelcase,defines,kdebug,null,qenums,tipsandthis
SKIP /tests/
070701115400E5000081A40000000200000002000000015AA55A8600001170000000FD0000001000000000000000000000004200000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/CMakeLists.txtcmake_minimum_required(VERSION 3.0)
set(PIM_VERSION "5.7.80")

project(incidenceeditor VERSION ${PIM_VERSION})

set(KF5_VERSION "5.44.0")

find_package(ECM ${KF5_VERSION} CONFIG REQUIRED)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
set(LIBRARY_NAMELINK)
if (POLICY CMP0053)
    cmake_policy(SET CMP0053 NEW)
endif()
include(GenerateExportHeader)
include(ECMSetupVersion)
include(ECMGenerateHeaders)
include(ECMGeneratePriFile)
include(CMakePackageConfigHelpers)
include(ECMSetupVersion)
include(FeatureSummary)
include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
include(ECMQtDeclareLoggingCategory)
include(ECMAddTests)
include(ECMCoverageOption)

set(INCIDENCEEDITOR_LIB_VERSION ${PIM_VERSION})
set(AKONADI_MIMELIB_VERSION "5.7.80")
set(KDEPIM_LIB_VERSION "5.7.80")
set(QT_REQUIRED_VERSION "5.8.0")
set(KMIME_LIB_VERSION "5.7.80")
set(KMAILTRANSPORT_LIB_VERSION "5.7.80")
set(KLDAP_LIB_VERSION "5.7.80")
set(CALENDARUTILS_LIB_VERSION "5.7.80")
set(KCALENDARCORE_LIB_VERSION "5.7.80")
set(CALENDARSUPPORT_LIB_VERSION "5.7.80")
set(LIBKDEPIM_LIB_VERSION "5.7.80")
set(EVENTVIEW_LIB_VERSION "5.7.80")
set(AKONADI_VERSION "5.7.80")

set(KDIAGRAM_LIB_VERSION "1.4.0")
find_package(KGantt ${KDIAGRAM_LIB_VERSION} CONFIG REQUIRED)

find_package(KF5Akonadi ${AKONADI_VERSION} CONFIG REQUIRED)
find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets)
find_package(KF5I18n ${KF5_VERSION} CONFIG REQUIRED)
find_package(KF5IconThemes ${KF5_VERSION} CONFIG REQUIRED)
find_package(KF5KIO ${KF5_VERSION} CONFIG REQUIRED)
find_package(KF5Mime ${KMIME_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5AkonadiMime ${AKONADI_MIMELIB_VERSION} CONFIG REQUIRED)

find_package(KF5Ldap ${KLDAP_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5Codecs ${KF5_VERSION} CONFIG REQUIRED)
find_package(KF5CalendarSupport ${CALENDARSUPPORT_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5EventViews ${EVENTVIEW_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5LibkdepimAkonadi ${LIBKDEPIM_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5KdepimDBusInterfaces ${KDEPIM_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5CalendarUtils ${CALENDARUTILS_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5CalendarCore ${KCALENDARCORE_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5MailTransportAkonadi ${KMAILTRANSPORT_LIB_VERSION} CONFIG REQUIRED)

ecm_setup_version(PROJECT VARIABLE_PREFIX INCIDENCEEDITOR
                        VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/incidenceeditor_version.h"
                        PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5IncidenceEditorConfigVersion.cmake"
                        SOVERSION 5
)

option(KDEPIM_ENTERPRISE_BUILD "Enable features specific to the enterprise branch, which are normally disabled. Also, it disables many components not needed for Kontact such as the Kolab client." FALSE)

# config-enterprise.h is needed for both ENTERPRISE_BUILD and BUILD_EVERYTHING
configure_file(config-enterprise.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/src/config-enterprise.h )

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

add_definitions("-DQT_NO_CAST_FROM_ASCII -DQT_NO_CAST_TO_ASCII")
add_definitions(-DQT_NO_NARROWING_CONVERSIONS_IN_CONNECT)
add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x060000)
add_definitions(-DQT_NO_URL_CAST_FROM_STRING)
########### CMake Config Files ###########
set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5IncidenceEditor")

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

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

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

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

feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

install( FILES incidenceeditor.categories incidenceeditor.renamecategories DESTINATION ${KDE_INSTALL_CONFDIR} )

add_subdirectory(src)
if (BUILD_TESTING)
   find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Test)

add_subdirectory(autotests)
   add_subdirectory(tests)
endif()

070701115400E6000081A40000000200000002000000015AA55A8600004761000000FD0000001000000000000000000000003B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/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.
070701115400E7000081A40000000200000002000000015AA55A860000679F000000FD0000001000000000000000000000003F00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/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!

070701115400E8000081A40000000200000002000000015AA55A86000001E5000000FD0000001000000000000000000000005500000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/KF5IncidenceEditorConfig.cmake.in@PACKAGE_INIT@
include(CMakeFindDependencyMacro)
find_dependency(KF5EventViews "@EVENTVIEW_LIB_VERSION@")
find_dependency(KF5CalendarSupport "@CALENDARSUPPORT_LIB_VERSION@")
find_dependency(KF5CalendarUtils "@CALENDARUTILS_LIB_VERSION@")
find_dependency(KF5CalendarCore "@KCALENDARCORE_LIB_VERSION@")
find_dependency(KF5MailTransport "@KMAILTRANSPORT_LIB_VERSION@")
find_dependency(KF5Mime "@KMIME_LIB_VERSION@")

include("${CMAKE_CURRENT_LIST_DIR}/KF5IncidenceEditorTargets.cmake")
070701119C00CA000041ED0000000200000002000000025AA55A8600000000000000FD0000001000000000000000000000003D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests070701119C00D1000081A40000000200000002000000015AA55A86000006BF000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/CMakeLists.txtset(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})

include_directories(${CMAKE_SOURCE_DIR}/src)

set(grant_lib KGantt)

macro(IE_UNIT_TESTS)
  foreach(_testname ${ARGN})
    add_executable(${_testname} ${_testname}.cpp modeltest.cpp)
    add_test(NAME ${_testname} COMMAND ${_testname})
    ecm_mark_as_test(${_testname})
    target_link_libraries(${_testname}
      Qt5::Test
      KF5::AkonadiCore
      ${grant_lib}
      KF5::CalendarUtils
      KF5::CalendarCore
      KF5::IncidenceEditor
      KF5::KdepimDBusInterfaces
      KF5::Libkdepim
    )
  endforeach()
endmacro()

macro(IE_EXECUTABLE_TESTS)
  foreach(_testname ${ARGN})
    add_executable(${_testname} NOGUI TEST ${_testname}.cpp modeltest.cpp)
    target_link_libraries(${_testname} KF5::CalendarCore Qt5::Test KF5::IncidenceEditor Qt5::Widgets)
  endforeach()
endmacro()

ie_unit_tests(
  conflictresolvertest
  testfreebusyganttproxymodel
)

########### KTimeZoneComboBox unit test #############
set(ktimezonecomboboxtest_SRCS ktimezonecomboboxtest.cpp)

add_executable(ktimezonecomboboxtest ${ktimezonecomboboxtest_SRCS})
add_test(NAME ktimezonecomboboxtest COMMAND ktimezonecomboboxtest)
ecm_mark_as_test(ktimezonecomboboxtest)

target_link_libraries(ktimezonecomboboxtest
  KF5::CalendarCore
  Qt5::Test
  KF5::IncidenceEditor
  KF5::Completion
)

add_executable(testindividualmaildialog testindividualmaildialog.cpp ../src/individualmaildialog.cpp)
ecm_mark_nongui_executable(testindividualmaildialog)
add_test(NAME testindividualmaildialog COMMAND testindividualmaildialog)
ecm_mark_as_test(testindividualmaildialog)
target_link_libraries(testindividualmaildialog
  KF5::CalendarCore
  Qt5::Test
  Qt5::Widgets
  KF5::WidgetsAddons
  KF5::I18n
)
070701119C00D2000081A40000000200000002000000015AA55A8600003488000000FD0000001000000000000000000000005600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/conflictresolvertest.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "conflictresolvertest.h"
#include "conflictresolver.h"

#include <KCalCore/Event>
#include <KCalCore/Period>
#include <KCalCore/Duration>

#include <QWidget>
#include <QTest>

using namespace IncidenceEditorNG;

void ConflictResolverTest::insertAttendees()
{
    foreach (const CalendarSupport::FreeBusyItem::Ptr &item, qAsConst(attendees)) {
        resolver->insertAttendee(item);
    }
}

void ConflictResolverTest::addAttendee(const QString &email, const KCalCore::FreeBusy::Ptr &fb,
                                       KCalCore::Attendee::Role role)
{
    QString name = QStringLiteral("attendee %1").arg(attendees.count());
    CalendarSupport::FreeBusyItem::Ptr item(new CalendarSupport::FreeBusyItem(KCalCore::Attendee::Ptr(
                                     new KCalCore::Attendee(name, email, false,
                                             KCalCore::Attendee::Accepted,
                                             role)), nullptr));
    item->setFreeBusy(KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(*fb.data())));
    attendees << item;
}

void ConflictResolverTest::initTestCase()
{
    parent = new QWidget;
    init();
}

void ConflictResolverTest::init()
{
    base = QDateTime::currentDateTime().addDays(1);
    end = base.addSecs(10 * 60 * 60);
    resolver = new ConflictResolver(parent, parent);
}

void ConflictResolverTest::cleanup()
{
    delete resolver;
    resolver = nullptr;
    attendees.clear();
}

void ConflictResolverTest::simpleTest()
{
    KCalCore::Period meeting(end.addSecs(-3 * 60 * 60), KCalCore::Duration(2 * 60 * 60));
    addAttendee(QStringLiteral("albert@einstein.net"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << meeting)));

insertAttendees();

static const int resolution = 15 * 60;
    resolver->setResolution(resolution);
    resolver->setEarliestDateTime(base);
    resolver->setLatestDateTime(end);
    resolver->findAllFreeSlots();

QVERIFY(resolver->availableSlots().size() == 2);

KCalCore::Period first = resolver->availableSlots().at(0);
    QCOMPARE(first.start(), base);
    QCOMPARE(first.end(), meeting.start());

KCalCore::Period second = resolver->availableSlots().at(1);
    QEXPECT_FAIL("", "Got broken in revision f17b9a8c975588ad7cf4ce8b94ab8e32ac193ed8", Continue);
    QCOMPARE(second.start(), meeting.end().addSecs(resolution));     //add 15 minutes because the
    //free block doesn't start until
    //the next timeslot
    QCOMPARE(second.end(), end);
}

void ConflictResolverTest::stillPrettySimpleTest()
{
    KCalCore::Period meeting1(base, KCalCore::Duration(2 * 60 * 60));
    KCalCore::Period meeting2(base.addSecs(60 * 60), KCalCore::Duration(2 * 60 * 60));
    KCalCore::Period meeting3(end.addSecs(-3 * 60 * 60), KCalCore::Duration(2 * 60 * 60));
    addAttendee(QStringLiteral("john.f@kennedy.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << meeting1 << meeting3)));
    addAttendee(QStringLiteral("elvis@rock.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << meeting2 << meeting3)));
    addAttendee(QStringLiteral("albert@einstein.net"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << meeting3)));

insertAttendees();

static const int resolution = 15 * 60;
    resolver->setResolution(resolution);
    resolver->setEarliestDateTime(base);
    resolver->setLatestDateTime(end);
    resolver->findAllFreeSlots();

QVERIFY(resolver->availableSlots().size() == 2);

KCalCore::Period first = resolver->availableSlots().at(0);
    QEXPECT_FAIL("", "Got broken in revision f17b9a8c975588ad7cf4ce8b94ab8e32ac193ed8", Continue);
    QCOMPARE(first.start(), meeting2.end().addSecs(resolution));
    QCOMPARE(first.end(), meeting3.start());

KCalCore::Period second = resolver->availableSlots().at(1);
    QEXPECT_FAIL("", "Got broken in revision f17b9a8c975588ad7cf4ce8b94ab8e32ac193ed8", Continue);
    QCOMPARE(second.start(), meeting3.end().addSecs(resolution));     //add 15 minutes because the
    //free block doesn't start until
    //the next timeslot
    QCOMPARE(second.end(), end);
}

#define _time( h, m ) QDateTime( base.date(), QTime( h, m ) )

void ConflictResolverTest::akademy2010()
{
    // based off akademy 2010 schedule

// first event was at 9:30, so lets align our start time there
    base.setTime(QTime(9, 30));
    end = base.addSecs(8 * 60 * 60);
    KCalCore::Period opening(_time(9, 30), _time(9, 45));
    KCalCore::Period keynote(_time(9, 45), _time(10, 30));

KCalCore::Period sevenPrinciples(_time(10, 30), _time(11, 15));
    KCalCore::Period commAsService(_time(10, 30), _time(11, 15));

KCalCore::Period kdeForums(_time(11, 15), _time(11, 45));
    KCalCore::Period oviStore(_time(11, 15), _time(11, 45));

// 10 min break

KCalCore::Period highlights(_time(12, 0), _time(12, 45));
    KCalCore::Period styles(_time(12, 0), _time(12, 45));

KCalCore::Period wikimedia(_time(12, 45), _time(13, 15));
    KCalCore::Period avalanche(_time(12, 45), _time(13, 15));

KCalCore::Period pimp(_time(13, 15), _time(13, 45));
    KCalCore::Period direction(_time(13, 15), _time(13, 45));

// lunch 1 hr 25 min lunch

KCalCore::Period blurr(_time(15, 15), _time(16, 00));
    KCalCore::Period plasma(_time(15, 15), _time(16, 00));

//  for ( int i = 1; i < 80; ++i ) {
    // adds 80 people (adds the same 8 peopl 10 times)
    addAttendee(QStringLiteral("akademyattendee1@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << opening << keynote
                                        << oviStore << wikimedia
                                        << direction)));
    addAttendee(QStringLiteral("akademyattendee2@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << opening << keynote
                                        << commAsService << highlights
                                        << pimp)));
    addAttendee(QStringLiteral("akademyattendee3@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << opening << kdeForums
                                        << styles << pimp  << plasma)));
    addAttendee(QStringLiteral("akademyattendee4@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << opening << keynote
                                        << oviStore << pimp << blurr)));
    addAttendee(QStringLiteral("akademyattendee5@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << keynote << oviStore
                                        << highlights << avalanche)));
    addAttendee(QStringLiteral("akademyattendee6@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << opening << keynote
                                        << commAsService
                                        << highlights)));
    addAttendee(QStringLiteral("akademyattendee7@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << opening << kdeForums
                                        << styles << avalanche
                                        << pimp << plasma)));
    addAttendee(QStringLiteral("akademyattendee8@email.com"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << opening << keynote
                                        << oviStore << wikimedia
                                        << blurr)));
//  }

insertAttendees();

const int resolution = 5 * 60;
    resolver->setResolution(resolution);
    resolver->setEarliestDateTime(base);
    resolver->setLatestDateTime(end);
// QBENCHMARK {
    resolver->findAllFreeSlots();
// }

QVERIFY(resolver->availableSlots().size() == 3);
    QEXPECT_FAIL("", "Got broken in revision f17b9a8c975588ad7cf4ce8b94ab8e32ac193ed8", Abort);
    QCOMPARE(resolver->availableSlots().at(0).duration(),
             KCalCore::Duration(10 * 60));
    QCOMPARE(resolver->availableSlots().at(1).duration(),
             KCalCore::Duration(1 * 60 * 60 + 25 * 60));
    QVERIFY(resolver->availableSlots().at(2).start() > plasma.end());
}

void ConflictResolverTest::testPeriodIsLargerThenTimeframe()
{
    base.setDate(QDate(2010, 7, 29));
    base.setTime(QTime(7, 30));

end.setDate(QDate(2010, 7, 29));
    end.setTime(QTime(8, 30));

KCalCore::Period testEvent(_time(5, 45), _time(8, 45));

addAttendee(QStringLiteral("kdabtest1@demo.kolab.org"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List()
                                        << testEvent)));
    addAttendee(QStringLiteral("kdabtest2@demo.kolab.org"),
                KCalCore::FreeBusy::Ptr(new KCalCore::FreeBusy(KCalCore::Period::List())));

insertAttendees();
    resolver->setEarliestDateTime(base);
    resolver->setLatestDateTime(end);
    resolver->findAllFreeSlots();

QCOMPARE(resolver->availableSlots().size(), 0);
}

void ConflictResolverTest::testPeriodBeginsBeforeTimeframeBegins()
{
    base.setDate(QDate(2010, 7, 29));
    base.setTime(QTime(7, 30));

end.setDate(QDate(2010, 7, 29));
    end.setTime(QTime(9, 30));

KCalCore::Period testEvent(_time(5, 45), _time(8, 45));

insertAttendees();
    resolver->setEarliestDateTime(base);
    resolver->setLatestDateTime(end);
    resolver->findAllFreeSlots();

QCOMPARE(resolver->availableSlots().size(), 1);
    KCalCore::Period freeslot = resolver->availableSlots().at(0);
    QCOMPARE(freeslot.start(), _time(8, 45));
    QCOMPARE(freeslot.end(), end);
}

void ConflictResolverTest::testPeriodEndsAfterTimeframeEnds()
{
    base.setDate(QDate(2010, 7, 29));
    base.setTime(QTime(7, 30));

end.setDate(QDate(2010, 7, 29));
    end.setTime(QTime(9, 30));

KCalCore::Period testEvent(_time(8, 00), _time(9, 45));

insertAttendees();
    resolver->setEarliestDateTime(base);
    resolver->setLatestDateTime(end);
    resolver->findAllFreeSlots();

QCOMPARE(resolver->availableSlots().size(), 1);
    KCalCore::Period freeslot = resolver->availableSlots().at(0);
    QCOMPARE(freeslot.duration(), KCalCore::Duration(30 * 60));
    QCOMPARE(freeslot.start(), base);
    QCOMPARE(freeslot.end(), _time(8, 00));
}

void ConflictResolverTest::testPeriodEndsAtSametimeAsTimeframe()
{
    base.setDate(QDate(2010, 7, 29));
    base.setTime(QTime(7, 45));

end.setDate(QDate(2010, 7, 29));
    end.setTime(QTime(8, 45));

KCalCore::Period testEvent(_time(5, 45), _time(8, 45));

insertAttendees();
    resolver->setEarliestDateTime(base);
    resolver->setLatestDateTime(end);
    resolver->findAllFreeSlots();

QCOMPARE(resolver->availableSlots().size(), 0);
}

QTEST_MAIN(ConflictResolverTest)
070701119C00D3000081A40000000200000002000000015AA55A860000078D000000FD0000001000000000000000000000005400000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/conflictresolvertest.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 CONFLICTRESOLVERTEST_H
#define CONFLICTRESOLVERTEST_H

#include "CalendarSupport/FreeBusyItem"

#include <KCalCore/FreeBusy>
#include <KCalCore/Attendee>

#include <QObject>

namespace IncidenceEditorNG
{
class ConflictResolver;
}

class ConflictResolverTest : public QObject
{
    Q_OBJECT
private Q_SLOTS:
    void initTestCase();
    void init();
    void cleanup();
    void simpleTest();
    void stillPrettySimpleTest();
    void akademy2010();
    void testPeriodBeginsBeforeTimeframeBegins();
    void testPeriodEndsAfterTimeframeEnds();
    void testPeriodIsLargerThenTimeframe();
    void testPeriodEndsAtSametimeAsTimeframe();

private:
    void insertAttendees();
    void addAttendee(const QString &email, const KCalCore::FreeBusy::Ptr &fb,
                     KCalCore::Attendee::Role role = KCalCore::Attendee::ReqParticipant);
    QList<CalendarSupport::FreeBusyItem::Ptr> attendees;
    QWidget *parent;
    IncidenceEditorNG::ConflictResolver *resolver;
    QDateTime base, end;
};

#endif
070701119C00D4000081A40000000200000002000000015AA55A8600000604000000FD0000001000000000000000000000005700000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/ktimezonecomboboxtest.cpp/*
  Copyright 2009 Thomas McGuire <mcguire@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 <http://www.gnu.org/licenses/>.
*/
#include "ktimezonecomboboxtest.h"
#include "../src/ktimezonecombobox.h"

#include "qtest.h"

QTEST_MAIN(KTimeZoneComboBoxTest)

void KTimeZoneComboBoxTest::test_timeSpec()
{
    IncidenceEditorNG::KTimeZoneComboBox combo;
    combo.selectLocalTimeZone();
    if (combo.selectedTimeZone().id() != "UTC")
        QCOMPARE(combo.selectedTimeZone(), QTimeZone::systemTimeZone());
    else
        QCOMPARE(combo.selectedTimeZone(), QTimeZone::utc());

combo.selectTimeZone(QTimeZone());
    QCOMPARE(combo.selectedTimeZone(), QTimeZone::systemTimeZone());

combo.setFloating(true);
    QCOMPARE(combo.selectedTimeZone(), QTimeZone::systemTimeZone());
}
070701119C00D5000081A40000000200000002000000015AA55A8600000439000000FD0000001000000000000000000000005500000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/ktimezonecomboboxtest.h/*
  Copyright 2009 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 <http://www.gnu.org/licenses/>.
*/
#ifndef KTIMEZONECOMBOBOXTEST_H
#define KTIMEZONECOMBOBOXTEST_H

#include <QObject>

class KTimeZoneComboBoxTest : public QObject
{
    Q_OBJECT
private Q_SLOTS:
    void test_timeSpec();
};

#endif
070701119C00D6000081A40000000200000002000000015AA55A86000059D5000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/modeltest.cpp/****************************************************************************
**
** Copyright (C) 2007 Trolltech ASA. All rights reserved.
**
** This file is part of the Qt Concurrent project on Trolltech Labs.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
//krazy:excludeall=style

#include "modeltest.h"
#include <QDebug>
#include <QSize>
Q_DECLARE_METATYPE(QModelIndex)

/*!
    Connect to all of the models signals.  Whenever anything happens recheck everything.
*/
ModelTest::ModelTest(QAbstractItemModel *_model, QObject *parent) : QObject(parent), model(_model), fetchingMore(false)
{
    Q_ASSERT(model);

connect(model, &QAbstractItemModel::columnsAboutToBeInserted, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::columnsAboutToBeRemoved, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::columnsInserted, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::columnsRemoved, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::dataChanged, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::headerDataChanged, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::layoutAboutToBeChanged, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::layoutChanged, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::modelReset, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::modelAboutToBeReset, this, &ModelTest::modelAboutToBeReset);
    connect(model, &QAbstractItemModel::modelReset, this, &ModelTest::modelReset);
    connect(model, &QAbstractItemModel::rowsAboutToBeInserted, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::rowsAboutToBeRemoved, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::rowsInserted, this, &ModelTest::runAllTests);
    connect(model, &QAbstractItemModel::rowsRemoved, this, &ModelTest::runAllTests);

// Special checks for inserting/removing
    connect(model, &QAbstractItemModel::layoutAboutToBeChanged, this, &ModelTest::layoutAboutToBeChanged);
    connect(model, &QAbstractItemModel::layoutChanged, this, &ModelTest::layoutChanged);

connect(model, &QAbstractItemModel::rowsAboutToBeInserted, this, &ModelTest::rowsAboutToBeInserted);
    connect(model, &QAbstractItemModel::rowsAboutToBeRemoved, this, &ModelTest::rowsAboutToBeRemoved);
    connect(model, &QAbstractItemModel::rowsInserted, this, &ModelTest::rowsInserted);
    connect(model, &QAbstractItemModel::rowsRemoved, this, &ModelTest::rowsRemoved);

connect(model, &QAbstractItemModel::rowsAboutToBeMoved, this, &ModelTest::rowsAboutToBeMoved);
    connect(model, &QAbstractItemModel::rowsMoved, this, &ModelTest::rowsMoved);

runAllTests();
}

void ModelTest::runAllTests()
{

//     qDebug() << "rats";
    if (fetchingMore) {
        return;
    }
    nonDestructiveBasicTest();
    rowCount();
    columnCount();
    hasIndex();
    index();
    parent();
    data();
}

/*!
    nonDestructiveBasicTest tries to call a number of the basic functions (not all)
    to make sure the model doesn't outright segfault, testing the functions that makes sense.
*/
void ModelTest::nonDestructiveBasicTest()
{
    Q_ASSERT(model->buddy(QModelIndex()) == QModelIndex());
//     model->canFetchMore ( QModelIndex() );
    Q_ASSERT(model->columnCount(QModelIndex()) >= 0);
    Q_ASSERT(model->data(QModelIndex()) == QVariant());
//     fetchingMore = true;
//     model->fetchMore ( QModelIndex() );
//     fetchingMore = false;
    Qt::ItemFlags flags = model->flags(QModelIndex());
    Q_ASSERT(flags == Qt::ItemIsDropEnabled || flags == 0);
    Q_UNUSED(flags);
    model->hasChildren(QModelIndex());
    model->hasIndex(0, 0);
    model->headerData(0, Qt::Horizontal);
    model->index(0, 0);
    model->itemData(QModelIndex());
    QVariant cache;
    model->match(QModelIndex(), -1, cache);
    model->mimeTypes();
    Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
    Q_ASSERT(model->rowCount() >= 0);
    QVariant variant;
    model->setData(QModelIndex(), variant, -1);
    model->setHeaderData(-1, Qt::Horizontal, QVariant());
    model->setHeaderData(999999, Qt::Horizontal, QVariant());
    model->sibling(0, 0, QModelIndex());
    model->span(QModelIndex());
    model->supportedDropActions();
}

/*!
    Tests model's implementation of QAbstractItemModel::rowCount() and hasChildren()

Models that are dynamically populated are not as fully tested here.
 */
void ModelTest::rowCount()
{
//     qDebug() << "rc";
    // check top row
    QModelIndex topIndex = model->index(0, 0, QModelIndex());
    int rows = model->rowCount(topIndex);
    Q_ASSERT(rows >= 0);
    if (rows > 0) {
        Q_ASSERT(model->hasChildren(topIndex) == true);
    }

QModelIndex secondLevelIndex = model->index(0, 0, topIndex);
    if (secondLevelIndex.isValid()) {   // not the top level
        // check a row count where parent is valid
        rows = model->rowCount(secondLevelIndex);
        Q_ASSERT(rows >= 0);
        if (rows > 0) {
            Q_ASSERT(model->hasChildren(secondLevelIndex) == true);
        }
    }

// The models rowCount() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}

/*!
    Tests model's implementation of QAbstractItemModel::columnCount() and hasChildren()
 */
void ModelTest::columnCount()
{
    // check top row
    QModelIndex topIndex = model->index(0, 0, QModelIndex());
    Q_ASSERT(model->columnCount(topIndex) >= 0);

// check a column count where parent is valid
    QModelIndex childIndex = model->index(0, 0, topIndex);
    if (childIndex.isValid()) {
        Q_ASSERT(model->columnCount(childIndex) >= 0);
    }

// columnCount() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}

/*!
    Tests model's implementation of QAbstractItemModel::hasIndex()
 */
void ModelTest::hasIndex()
{
//     qDebug() << "hi";
    // Make sure that invalid values returns an invalid index
    Q_ASSERT(model->hasIndex(-2, -2) == false);
    Q_ASSERT(model->hasIndex(-2, 0) == false);
    Q_ASSERT(model->hasIndex(0, -2) == false);

int rows = model->rowCount();
    int columns = model->columnCount();

// check out of bounds
    Q_ASSERT(model->hasIndex(rows, columns) == false);
    Q_ASSERT(model->hasIndex(rows + 1, columns + 1) == false);

Q_UNUSED(columns);

if (rows > 0) {
        Q_ASSERT(model->hasIndex(0, 0) == true);
    }

// hasIndex() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}

/*!
    Tests model's implementation of QAbstractItemModel::index()
 */
void ModelTest::index()
{
//     qDebug() << "i";
    // Make sure that invalid values returns an invalid index
    Q_ASSERT(model->index(-2, -2) == QModelIndex());
    Q_ASSERT(model->index(-2, 0) == QModelIndex());
    Q_ASSERT(model->index(0, -2) == QModelIndex());

int rows = model->rowCount();
    int columns = model->columnCount();

if (rows == 0) {
        return;
    }

// Catch off by one errors
    Q_ASSERT(model->index(rows, columns) == QModelIndex());
    Q_ASSERT(model->index(0, 0).isValid() == true);

Q_UNUSED(columns);

// Make sure that the same index is *always* returned
    QModelIndex a = model->index(0, 0);
    QModelIndex b = model->index(0, 0);
    Q_ASSERT(a == b);

// index() is tested more extensively in checkChildren(),
    // but this catches the big mistakes
}

/*!
    Tests model's implementation of QAbstractItemModel::parent()
 */
void ModelTest::parent()
{
//     qDebug() << "p";
    // Make sure the model wont crash and will return an invalid QModelIndex
    // when asked for the parent of an invalid index.
    Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());

if (model->rowCount() == 0) {
        return;
    }

// Common error test #1, make sure that a top level index has a parent
    // that is a invalid QModelIndex.
    QModelIndex topIndex = model->index(0, 0, QModelIndex());
    Q_ASSERT(model->parent(topIndex) == QModelIndex());

// Common error test #2, make sure that a second level index has a parent
    // that is the first level index.
    if (model->rowCount(topIndex) > 0) {
        QModelIndex childIndex = model->index(0, 0, topIndex);
        Q_ASSERT(model->parent(childIndex) == topIndex);
    }

// Common error test #3, the second column should NOT have the same children
    // as the first column in a row.
    // Usually the second column shouldn't have children.
    QModelIndex topIndex1 = model->index(0, 1, QModelIndex());
    if (model->rowCount(topIndex1) > 0) {
        QModelIndex childIndex = model->index(0, 0, topIndex);
        QModelIndex childIndex1 = model->index(0, 0, topIndex1);
        Q_ASSERT(childIndex != childIndex1);
    }

// Full test, walk n levels deep through the model making sure that all
    // parent's children correctly specify their parent.
    checkChildren(QModelIndex());
}

/*!
    Called from the parent() test.

A model that returns an index of parent X should also return X when asking
    for the parent of the index.

This recursive function does pretty extensive testing on the whole model in an
    effort to catch edge cases.

This function assumes that rowCount(), columnCount() and index() already work.
    If they have a bug it will point it out, but the above tests should have already
    found the basic bugs because it is easier to figure out the problem in
    those tests then this one.
 */
void ModelTest::checkChildren(const QModelIndex &parent, int currentDepth)
{
    // First just try walking back up the tree.
    QModelIndex p = parent;
    while (p.isValid()) {
        p = p.parent();
    }

// For models that are dynamically populated
//     if ( model->canFetchMore ( parent ) ) {
//         fetchingMore = true;
//         model->fetchMore ( parent );
//         fetchingMore = false;
//     }

int rows = model->rowCount(parent);
    int columns = model->columnCount(parent);

if (rows > 0) {

Q_ASSERT(parent.column() <= 0);
        Q_ASSERT(model->hasChildren(parent));
    }

// Some further testing against rows(), columns(), and hasChildren()
    Q_ASSERT(rows >= 0);
    Q_ASSERT(columns >= 0);
    if (rows > 0) {
        Q_ASSERT(model->hasChildren(parent) == true);
    }

//qDebug() << "parent:" << model->data(parent).toString() << "rows:" << rows
    //         << "columns:" << columns << "parent column:" << parent.column();

Q_ASSERT(model->hasIndex(rows, 0, parent) == false);
    Q_ASSERT(model->index(rows, 0, parent).isValid() == false);
    for (int r = 0; r < rows; ++r) {
//         if ( model->canFetchMore ( parent ) ) {
//             fetchingMore = true;
//             model->fetchMore ( parent );
//             fetchingMore = false;
//         }
        Q_ASSERT(model->hasIndex(r, columns, parent) == false);
        Q_ASSERT(model->index(r, columns, parent).isValid() == false);
        for (int c = 0; c < columns; ++c) {
            Q_ASSERT(model->hasIndex(r, c, parent) == true);
            QModelIndex index = model->index(r, c, parent);
            // rowCount() and columnCount() said that it existed...
            Q_ASSERT(index.isValid() == true);

// index() should always return the same index when called twice in a row
            QModelIndex modifiedIndex = model->index(r, c, parent);
            Q_ASSERT(index == modifiedIndex);

// Make sure we get the same index if we request it twice in a row
            QModelIndex a = model->index(r, c, parent);
            QModelIndex b = model->index(r, c, parent);
            Q_ASSERT(a == b);

// Some basic checking on the index that is returned
            Q_ASSERT(index.model() == model);
            Q_ASSERT(index.row() == r);
            Q_ASSERT(index.column() == c);
            // While you can technically return a QVariant usually this is a sign
            // of an bug in data()  Disable if this really is ok in your model.
//             qDebug() << index << index.data() << index.parent();
            Q_ASSERT(model->data(index, Qt::DisplayRole).isValid() == true);

// If the next test fails here is some somewhat useful debug you play with.
            /*
            if (model->parent(index) != parent) {
                qDebug() << r << c << currentDepth << model->data(index).toString()
                         << model->data(parent).toString();
                qDebug() << index << parent << model->parent(index);
                // And a view that you can even use to show the model.
                //QTreeView view;
                //view.setModel(model);
                //view.show();
            }*/

// Check that we can get back our real parent.
            Q_ASSERT(model->parent(index) == parent);

// recursively go down the children
            if (model->hasChildren(index) && currentDepth < 10) {
                //qDebug() << r << c << "has children" << model->rowCount(index);
                checkChildren(index, ++currentDepth);
            }/* else { if (currentDepth >= 10) qDebug() << "checked 10 deep"; };*/

// make sure that after testing the children that the index doesn't change.
            QModelIndex newerIndex = model->index(r, c, parent);
            Q_ASSERT(index == newerIndex);
        }
    }
}

/*!
    Tests model's implementation of QAbstractItemModel::data()
 */
void ModelTest::data()
{
    // Invalid index should return an invalid qvariant
    Q_ASSERT(!model->data(QModelIndex()).isValid());

if (model->rowCount() == 0) {
        return;
    }

// A valid index should have a valid QVariant data
    Q_ASSERT(model->index(0, 0).isValid());

// shouldn't be able to set data on an invalid index
    Q_ASSERT(model->setData(QModelIndex(), QStringLiteral("foo"), Qt::DisplayRole) == false);

// General Purpose roles that should return a QString
    QVariant variant = model->data(model->index(0, 0), Qt::ToolTipRole);
    if (variant.isValid()) {
        Q_ASSERT(variant.canConvert<QString>());
    }
    variant = model->data(model->index(0, 0), Qt::StatusTipRole);
    if (variant.isValid()) {
        Q_ASSERT(variant.canConvert<QString>());
    }
    variant = model->data(model->index(0, 0), Qt::WhatsThisRole);
    if (variant.isValid()) {
        Q_ASSERT(variant.canConvert<QString>());
    }

// General Purpose roles that should return a QSize
    variant = model->data(model->index(0, 0), Qt::SizeHintRole);
    if (variant.isValid()) {
        Q_ASSERT(variant.canConvert<QSize>());
    }

// General Purpose roles that should return a QFont
    QVariant fontVariant = model->data(model->index(0, 0), Qt::FontRole);
    if (fontVariant.isValid()) {
        Q_ASSERT(fontVariant.canConvert<QFont>());
    }

// Check that the alignment is one we know about
    QVariant textAlignmentVariant = model->data(model->index(0, 0), Qt::TextAlignmentRole);
    if (textAlignmentVariant.isValid()) {
        int alignment = textAlignmentVariant.toInt();
        Q_ASSERT(alignment == (alignment & (Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask)));
        Q_UNUSED(alignment);
    }

// General Purpose roles that should return a QColor
    QVariant colorVariant = model->data(model->index(0, 0), Qt::BackgroundColorRole);
    if (colorVariant.isValid()) {
        Q_ASSERT(colorVariant.canConvert<QColor>());
    }

colorVariant = model->data(model->index(0, 0), Qt::TextColorRole);
    if (colorVariant.isValid()) {
        Q_ASSERT(colorVariant.canConvert<QColor>());
    }

// Check that the "check state" is one we know about.
    QVariant checkStateVariant = model->data(model->index(0, 0), Qt::CheckStateRole);
    if (checkStateVariant.isValid()) {
        int state = checkStateVariant.toInt();
        Q_ASSERT(state == Qt::Unchecked ||
                 state == Qt::PartiallyChecked ||
                 state == Qt::Checked);
        Q_UNUSED(state);
    }
}

/*!
    Store what is about to be inserted to make sure it actually happens

\sa rowsInserted()
 */
void ModelTest::rowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
{
//     Q_UNUSED(end);
    qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data(parent).toString()
             << "current count of parent=" << model->rowCount(parent);    // << "display of last=" << model->data( model->index(start-1, 0, parent) );
//     qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) );
    Changing c;
    c.parent = parent;
    c.oldSize = model->rowCount(parent);
    c.last = model->data(model->index(start - 1, 0, parent));
    c.next = model->data(model->index(start, 0, parent));
    insert.push(c);
}

/*!
    Confirm that what was said was going to happen actually did

\sa rowsAboutToBeInserted()
 */
void ModelTest::rowsInserted(const QModelIndex &parent, int start, int end)
{
    Changing c = insert.pop();
    Q_ASSERT(c.parent == parent);
    qDebug() << "rowsInserted"  << "start=" << start << "end=" << end << "oldsize=" << c.oldSize
             << "parent=" << model->data(parent).toString() << "current rowcount=" << model->rowCount(parent);

for (int ii = start; ii <= end; ii++) {
        qDebug() << "itemWasInserted:" << model->data(model->index(ii, 0, parent));
    }

Q_ASSERT(c.oldSize + (end - start + 1) == model->rowCount(parent));
    Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
    /*
    if (c.next != model->data(model->index(end + 1, 0, c.parent))) {
        qDebug() << start << end;
        for (int i=0; i < model->rowCount(); ++i)
            qDebug() << model->index(i, 0).data().toString();
        qDebug() << c.next << model->data(model->index(end + 1, 0, c.parent));
    }
    */
    Q_ASSERT(c.next == model->data(model->index(end + 1, 0, c.parent)));
}

void ModelTest::modelAboutToBeReset()
{
    qDebug() << "@@@@@@@@@@@" << "modelAboutToBeReset";
}

void ModelTest::modelReset()
{
    qDebug() << "@@@@@@@@@@@" << "modelReset";
}

void ModelTest::layoutAboutToBeChanged()
{
    for (int i = 0; i < qBound(0, model->rowCount(), 100); ++i) {
        changing.append(QPersistentModelIndex(model->index(i, 0)));
    }
}

void ModelTest::layoutChanged()
{
    for (int i = 0; i < changing.count(); ++i) {
        QPersistentModelIndex p = changing[i];
        Q_ASSERT(p == model->index(p.row(), p.column(), p.parent()));
    }
    changing.clear();
}

void ModelTest::rowsAboutToBeMoved(const QModelIndex &srcParent, int start, int end, const QModelIndex &destParent, int destinationRow)
{
    qDebug() << "rowsAboutToBeMoved" << srcParent << start << end << destParent << destinationRow;
    Changing cs;
    cs.parent = srcParent;
    cs.oldSize = model->rowCount(srcParent);
    cs.last = model->data(model->index(start - 1, 0, srcParent));
    cs.next = model->data(model->index(end + 1, 0, srcParent));
    remove.push(cs);
    Changing cd;
    cd.parent = destParent;
    cd.oldSize = model->rowCount(destParent);
    cd.last = model->data(model->index(destinationRow - 1, 0, destParent));
    cd.next = model->data(model->index(destinationRow, 0, destParent));
    insert.push(cd);
}

void ModelTest::rowsMoved(const QModelIndex &srcParent, int start, int end, const QModelIndex &destParent, int destinationRow)
{
    qDebug() << "rowsMoved" << srcParent << start << end << destParent << destinationRow;

Changing cd = insert.pop();
    Q_ASSERT(cd.parent == destParent);
    if (srcParent == destParent) {
        Q_ASSERT(cd.oldSize == model->rowCount(destParent));

// TODO: Find out what I can assert here about last and next.
//     Q_ASSERT ( cd.last == model->data ( model->index ( destinationRow - 1, 0, cd.parent ) ) );
//     Q_ASSERT ( cd.next == model->data ( model->index ( destinationRow + (end - start + 1), 0, cd.parent ) ) );

} else {
        Q_ASSERT(cd.oldSize + (end - start + 1) == model->rowCount(destParent));

Q_ASSERT(cd.last == model->data(model->index(destinationRow - 1, 0, cd.parent)));
        Q_ASSERT(cd.next == model->data(model->index(destinationRow + (end - start + 1), 0, cd.parent)));
    }
    Changing cs = remove.pop();

Q_ASSERT(cs.parent == srcParent);
    if (srcParent == destParent) {
        Q_ASSERT(cs.oldSize == model->rowCount(srcParent));
    } else {
        Q_ASSERT(cs.oldSize - (end - start + 1) == model->rowCount(srcParent));

Q_ASSERT(cs.last == model->data(model->index(start - 1, 0, srcParent)));
        qDebug() << cs.next << model->data(model->index(start, 0, srcParent));
        Q_ASSERT(cs.next == model->data(model->index(start, 0, srcParent)));
    }

}

/*!
    Store what is about to be inserted to make sure it actually happens

\sa rowsRemoved()
 */
void ModelTest::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
{
    qDebug() << "ratbr" << parent << start << end;
    for (int ii = start; ii <= end; ii++) {
        qDebug() << "itemwillbe removed:" << model->data(model->index(ii, 0, parent));
    }

Changing c;
    c.parent = parent;
    c.oldSize = model->rowCount(parent);
    c.last = model->data(model->index(start - 1, 0, parent));
    c.next = model->data(model->index(end + 1, 0, parent));
    remove.push(c);
}

/*!
    Confirm that what was said was going to happen actually did

\sa rowsAboutToBeRemoved()
 */
void ModelTest::rowsRemoved(const QModelIndex &parent, int start, int end)
{
    qDebug() << "rr" << parent << start << end;
    Changing c = remove.pop();
    Q_ASSERT(c.parent == parent);
    Q_ASSERT(c.oldSize - (end - start + 1) == model->rowCount(parent));
    Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
    Q_ASSERT(c.next == model->data(model->index(start, 0, c.parent)));
}

070701119C00D7000081A40000000200000002000000015AA55A86000009D5000000FD0000001000000000000000000000004900000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/modeltest.h/****************************************************************************
**
** Copyright (C) 2007 Trolltech ASA. All rights reserved.
**
** This file is part of the Qt Concurrent project on Trolltech Labs.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
//krazy:excludeall=style

#ifndef MODELTEST_H
#define MODELTEST_H

#include <QObject>
#include <QAbstractItemModel>
#include <QStack>

class ModelTest : public QObject
{
    Q_OBJECT

public:
    explicit ModelTest(QAbstractItemModel *model, QObject *parent = nullptr);

private Q_SLOTS:
    void nonDestructiveBasicTest();
    void rowCount();
    void columnCount();
    void hasIndex();
    void index();
    void parent();
    void data();

protected Q_SLOTS:
    void runAllTests();
    void layoutAboutToBeChanged();
    void layoutChanged();
    void modelAboutToBeReset();
    void modelReset();
    void rowsAboutToBeInserted(const QModelIndex &parent, int start, int end);
    void rowsInserted(const QModelIndex &parent, int start, int end);
    void rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end);
    void rowsRemoved(const QModelIndex &parent, int start, int end);
    void rowsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int);
    void rowsMoved(const QModelIndex &, int, int, const QModelIndex &, int);

private:
    void checkChildren(const QModelIndex &parent, int currentDepth = 0);

QAbstractItemModel *model = nullptr;

struct Changing {
        QModelIndex parent;
        int oldSize;
        QVariant last;
        QVariant next;
    };
    QStack<Changing> insert;
    QStack<Changing> remove;

bool fetchingMore = false;

QList<QPersistentModelIndex> changing;
};

#endif
070701119C00D8000081A40000000200000002000000015AA55A860000121E000000FD0000001000000000000000000000005D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/testfreebusyganttproxymodel.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "testfreebusyganttproxymodel.h"
#include "freebusyganttproxymodel.h"
#include "modeltest.h"

#include <CalendarSupport/FreeBusyItem>
#include <CalendarSupport/FreeBusyItemModel>

#include <KGantt/KGanttGraphicsView>
#include <KCalCore/Attendee>

#include <QTest>
#include <QStandardPaths>
QTEST_MAIN(FreeBusyGanttProxyModelTest)

using namespace IncidenceEditorNG;

void FreeBusyGanttProxyModelTest::initTestCase()
{
    qputenv("TZ", "UTC");
    QStandardPaths::setTestModeEnabled(true);
}

void FreeBusyGanttProxyModelTest::testModelValidity()
{
    CalendarSupport::FreeBusyItemModel *fbModel = new CalendarSupport::FreeBusyItemModel();
    FreeBusyGanttProxyModel *ganttModel = new FreeBusyGanttProxyModel();
    ganttModel->setSourceModel(fbModel);
    ModelTest *modelTest = new ModelTest(ganttModel);

Q_UNUSED(modelTest);

QVERIFY(ganttModel->rowCount() == 0);

const QDateTime dt1(QDate(2010, 8, 24), QTime(7, 0, 0), Qt::UTC);
    const QDateTime dt2(QDate(2010, 8, 24), QTime(16, 0, 0), Qt::UTC);
    KCalCore::Attendee::Ptr a1(new KCalCore::Attendee(QStringLiteral("fred"), QStringLiteral("fred@example.com")));
    KCalCore::FreeBusy::Ptr fb1(new KCalCore::FreeBusy());

fb1->addPeriod(dt1, KCalCore::Duration(60 * 60));
    fb1->addPeriod(dt2, KCalCore::Duration(60 * 60));

CalendarSupport::FreeBusyItem::Ptr item1(new CalendarSupport::FreeBusyItem(a1, nullptr));
    item1->setFreeBusy(fb1);

const QDateTime dt3(QDate(2010, 8, 25), QTime(7, 0, 0), Qt::UTC);
    const QDateTime dt4(QDate(2010, 8, 25), QTime(16, 0, 0), Qt::UTC);
    KCalCore::Attendee::Ptr a2(new KCalCore::Attendee(QStringLiteral("joe"), QStringLiteral("joe@example.com")));
    KCalCore::FreeBusy::Ptr fb2(new KCalCore::FreeBusy());

fb2->addPeriod(dt3, KCalCore::Duration(60 * 60));
    fb2->addPeriod(dt4, KCalCore::Duration(60 * 60));

CalendarSupport::FreeBusyItem::Ptr item2(new CalendarSupport::FreeBusyItem(a2, nullptr));
    item2->setFreeBusy(fb2);

fbModel->addItem(item1);
    fbModel->addItem(item2);

QCOMPARE(ganttModel->rowCount(), 2);

QModelIndex parent0 = ganttModel->index(0, 0);
    QModelIndex parent1 = ganttModel->index(1, 0);
    QModelIndex parent2 = ganttModel->index(2, 0);
    QVERIFY(parent0.isValid());
    QVERIFY(parent1.isValid());
    QVERIFY(parent2.isValid() == false);

QModelIndex source_parent0 = fbModel->index(0, 0);
    QCOMPARE(parent0.data(), source_parent0.data());
    QCOMPARE(parent0.data(KGantt::ItemTypeRole).toInt(), (int) KGantt::TypeMulti);

QModelIndex source_parent1 = fbModel->index(1, 0);
    QCOMPARE(parent1.data(), source_parent1.data());
    QCOMPARE(parent1.data(KGantt::ItemTypeRole).toInt(), (int) KGantt::TypeMulti);

QModelIndex child0_0 = ganttModel->index(0, 0, parent0);
    QModelIndex child0_1 = ganttModel->index(1, 0, parent0);
    QVERIFY(child0_0.isValid());
    QVERIFY(child0_1.isValid());

QCOMPARE(child0_0.data(KGantt::ItemTypeRole).toInt(), (int) KGantt::TypeTask);
    QCOMPARE(child0_0.data(KGantt::StartTimeRole).toDateTime(), dt1);
    QCOMPARE(child0_1.data(KGantt::ItemTypeRole).toInt(), (int) KGantt::TypeTask);
    QCOMPARE(child0_1.data(KGantt::StartTimeRole).toDateTime(), dt2);

QModelIndex child1_0 = ganttModel->index(0, 0, parent1);
    QModelIndex child1_1 = ganttModel->index(1, 0, parent1);
    QVERIFY(child1_0.isValid());
    QVERIFY(child1_1.isValid());

QCOMPARE(child1_0.data(KGantt::ItemTypeRole).toInt(), (int) KGantt::TypeTask);
    QCOMPARE(child1_0.data(KGantt::StartTimeRole).toDateTime(), dt3);
    QCOMPARE(child1_1.data(KGantt::ItemTypeRole).toInt(), (int) KGantt::TypeTask);
    QCOMPARE(child1_1.data(KGantt::StartTimeRole).toDateTime(), dt4);
}
070701119C00D9000081A40000000200000002000000015AA55A8600000488000000FD0000001000000000000000000000005B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/testfreebusyganttproxymodel.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 <QObject>

class FreeBusyGanttProxyModelTest: public QObject
{
    Q_OBJECT
private Q_SLOTS:
    void initTestCase();
    void testModelValidity();
};

#endif
070701119C00DA000081A40000000200000002000000015AA55A8600000CDA000000FD0000001000000000000000000000005A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/autotests/testindividualmaildialog.cpp/*
Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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 "individualmaildialog.h"

#include <KGuiItem>

#include <QObject>
#include <QTest>

using namespace IncidenceEditorNG;

class TestIndividualMailDialog : public QObject
{
    Q_OBJECT
private Q_SLOTS:
    void testDialog()
    {
        KCalCore::Attendee::List attendees;
        KGuiItem buttonYes = KGuiItem(QStringLiteral("Send Email"));
        KGuiItem buttonNo = KGuiItem(QStringLiteral("Do not send"));

KCalCore::Attendee::Ptr attendee1(new KCalCore::Attendee(QStringLiteral("test1"),
                                                                 QStringLiteral("test1@example.com")));
        KCalCore::Attendee::Ptr attendee2(new KCalCore::Attendee(QStringLiteral("test2"),
                                                                 QStringLiteral("test2@example.com")));
        KCalCore::Attendee::Ptr attendee3(new KCalCore::Attendee(QStringLiteral("test3"),
                                                                 QStringLiteral("test3@example.com")));

attendees << attendee1 << attendee2 << attendee3;

IndividualMailDialog dialog(QStringLiteral("title"), attendees, buttonYes, buttonNo, nullptr);

QCOMPARE(dialog.editAttendees().count(), 0);
        QCOMPARE(dialog.updateAttendees().count(), 3);

// Just make sure, that the QCombobox is sorted like we think
        QComboBox *first = dialog.mAttendeeDecision[attendees[0]];
        QCOMPARE((IndividualMailDialog::Decisions)first->itemData(0, Qt::UserRole).toInt(),
                 IndividualMailDialog::Update);
        QCOMPARE((IndividualMailDialog::Decisions)first->itemData(1, Qt::UserRole).toInt(),
                 IndividualMailDialog::NoUpdate);
        QCOMPARE((IndividualMailDialog::Decisions)first->itemData(2, Qt::UserRole).toInt(),
                 IndividualMailDialog::Edit);

// No update for first attendee, other default
        first->setCurrentIndex(1);
        QCOMPARE(dialog.editAttendees().count(), 0);
        QCOMPARE(dialog.updateAttendees().count(), 2);
        QVERIFY(dialog.updateAttendees().contains(attendee2));
        QVERIFY(dialog.updateAttendees().contains(attendee3));

// edit for frist attende, other default
        first->setCurrentIndex(2);
        QCOMPARE(dialog.editAttendees().count(), 1);
        QCOMPARE(dialog.updateAttendees().count(), 2);
        QCOMPARE(dialog.editAttendees()[0], attendee1);
    }
};

QTEST_MAIN(TestIndividualMailDialog)

#include "testindividualmaildialog.moc"
070701115400E9000081A40000000200000002000000015AA55A8600000028000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/config-enterprise.h.cmake#cmakedefine KDEPIM_ENTERPRISE_BUILD 1

070701115400EA000081A40000000200000002000000015AA55A860000003E000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/incidenceeditor.categoriesorg.kde.pim.incidenceeditor incidenceeditor (incidenceeditor)
070701115400EB000081A40000000200000002000000015AA55A8600000030000000FD0000001000000000000000000000005400000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/incidenceeditor.renamecategorieslog_incidenceeditor org.kde.pim.incidenceeditor
070701115400EC000081A40000000200000002000000015AA55A86000000FE000000FD0000001000000000000000000000004100000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/metainfo.yamlmaintainer: 
description: Incidenceeditor library
tier: 3
type: functional
platforms:
    - name: All
portingAid: false
deprecated: false
release: false
libraries:
 - qmake: IncidenceEditor
   cmake: "KF5::IncidenceEditor"
cmakename: KF5IncidenceEditor

07070111A000DA000041ED0000000200000002000000045AA55A8600000000000000FD0000001000000000000000000000003700000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src07070111A000DB000081A40000000200000002000000015AA55A8600001272000000FD0000001000000000000000000000004600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/CMakeLists.txt
add_definitions(-DTRANSLATION_DOMAIN=\"libincidenceeditors\")

set(incidenceeditors_ng_shared_LIB_SRCS
  attachmenteditdialog.cpp
  attachmenticonview.cpp
  attendeedata.cpp
  attendeeline.cpp
  attendeecomboboxdelegate.cpp
  attendeelineeditdelegate.cpp
  attendeetablemodel.cpp
  attendeeeditor.cpp

alarmpresets.cpp
  alarmdialog.cpp
  incidenceeditorsettings.cpp

ktimezonecombobox.cpp

# TODO: Move the next two to akonadi libs when finished
  editoritemmanager.cpp

freebusyurldialog.cpp

# Shared incidence editors code
  combinedincidenceeditor.cpp
  incidenceeditor.cpp

# Specific editors
  incidencealarm.cpp
  incidenceattachment.cpp
  incidenceattendee.cpp
  incidencecategories.cpp
  incidencecompletionpriority.cpp
  incidencedescription.cpp
  incidencewhatwhere.cpp
  incidencedatetime.cpp
  incidencerecurrence.cpp
  incidenceresource.cpp
  incidencesecrecy.cpp

freebusyganttproxymodel.cpp
  conflictresolver.cpp
  schedulingdialog.cpp
  groupwareuidelegate.cpp

incidencedefaults.cpp
  editorconfig.cpp
  korganizereditorconfig.cpp

autochecktreewidget.cpp
  categoryeditdialog.cpp
  categoryselectdialog.cpp
  categorydialog.cpp

# Individual mail
  individualmailcomponentfactory.cpp
  individualmaildialog.cpp
  opencomposerjob.cpp

# Resourcemanagement
  ldaputils.cpp
  resourcemanagement.cpp
  resourceitem.cpp
  resourcemodel.cpp
)
ecm_qt_declare_logging_category(incidenceeditors_ng_shared_LIB_SRCS HEADER incidenceeditor_debug.h IDENTIFIER INCIDENCEEDITOR_LOG CATEGORY_NAME org.kde.pim.incidenceeditor)

kconfig_add_kcfg_files(incidenceeditors_ng_shared_LIB_SRCS globalsettings_incidenceeditor.kcfgc)

### Build the desktop version

set(incidenceeditors_ng_desktop_LIB_SRCS
  ${incidenceeditors_ng_shared_LIB_SRCS}
  templatemanagementdialog.cpp
  incidencedialogfactory.cpp
  incidencedialog.cpp
  visualfreebusywidget.cpp
)

ki18n_wrap_ui(incidenceeditors_ng_desktop_LIB_SRCS
  ui/categoryeditdialog_base.ui
  ui/categoryselectdialog_base.ui
  ui/categorydialog_base.ui
  ui/template_management_dialog_base.ui
  ui/dialogdesktop.ui
  ui/alarmdialog.ui
  ui/attachmenteditdialog.ui
  ui/schedulingdialog.ui
  ui/resourcemanagement.ui
)

add_library(KF5IncidenceEditor ${incidenceeditors_ng_desktop_LIB_SRCS})
generate_export_header(KF5IncidenceEditor BASE_NAME incidenceeditor)

add_library(KF5::IncidenceEditor ALIAS KF5IncidenceEditor)

target_link_libraries(KF5IncidenceEditor
PUBLIC
  KF5::AkonadiCalendar
  KF5::AkonadiMime
  KF5::CalendarCore
  KF5::CalendarUtils
  KF5::MailTransportAkonadi
  KF5::CalendarSupport      # For KCalPrefs
  KF5::EventViews
PRIVATE
  KGantt              # For FreeBusy Editor
  KF5::LibkdepimAkonadi
  KF5::KdepimDBusInterfaces # For UriHandler
  KF5::Codecs
  KF5::Ldap
  KF5::AkonadiWidgets
  KF5::IconThemes
  KF5::Completion
  KF5::KIOWidgets
  KF5::TextWidgets
  KF5::WidgetsAddons
  KF5::XmlGui
)
target_include_directories(KF5IncidenceEditor INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/IncidenceEditor/;${KDE_INSTALL_INCLUDEDIR_KF5}/incidenceeditor>")
target_include_directories(KF5IncidenceEditor PUBLIC "$<BUILD_INTERFACE:${incidenceeditor_SOURCE_DIR}/src;${incidenceeditor_BINARY_DIR}/src;>")

set_target_properties(KF5IncidenceEditor PROPERTIES
    VERSION ${INCIDENCEEDITOR_VERSION_STRING}
    SOVERSION ${INCIDENCEEDITOR_SOVERSION}
    EXPORT_NAME IncidenceEditor
)

install(TARGETS
    KF5IncidenceEditor
    EXPORT KF5IncidenceEditorTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS} ${LIBRARY_NAMELINK}
)

ecm_generate_headers(IncidenceEditor_CamelCase_HEADERS
  HEADER_NAMES
  IncidenceDialog
  IncidenceDialogFactory
  IncidenceEditorSettings
  CategoryEditDialog
  IncidenceAttendee
  IncidenceDefaults
  IndividualMailComponentFactory
  GroupwareUiDelegate
  EditorItemManager
  OpenComposerJob
  IncidenceEditor-Ng
  REQUIRED_HEADERS IncidenceEditor_HEADERS
  PREFIX IncidenceEditor
)

ecm_generate_pri_file(BASE_NAME IncidenceEditor
    LIB_NAME KF5IncidenceEditor
    DEPS "AkonadiCalendar AkonadiMime CalendarCore CalendarUtils MailTransport CalendarSupport EventViews" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/IncidenceEditor
)

install(FILES
    ${IncidenceEditor_CamelCase_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/IncidenceEditor
    COMPONENT Devel
)

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/globalsettings_incidenceeditor.h
    ${CMAKE_CURRENT_BINARY_DIR}/incidenceeditor_export.h
    ${IncidenceEditor_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/incidenceeditor
    COMPONENT Devel
)
install(FILES
    ${PRI_FILENAME}
    DESTINATION ${ECM_MKSPECS_INSTALL_DIR})

######
if (BUILD_TESTING)
   add_subdirectory(tests)
endif()
07070111A000DC000081A40000000200000002000000015AA55A86000000BB000000FD0000001000000000000000000000004300000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/Messages.sh#! /bin/sh
$EXTRACTRC `find . -name \*.ui -o -name \*.kcfg`  >> rc.cpp
$XGETTEXT `find . -name "*.cpp" -o -name "*.h" | grep -v '/tests/'`  -o $podir/libincidenceeditors.pot
rm -f rc.cpp
07070111A000DD000081A40000000200000002000000015AA55A860000269D000000FD0000001000000000000000000000004700000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/alarmdialog.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "alarmdialog.h"
#include "editorconfig.h"
#include "ui_alarmdialog.h"

#include <KEmailAddress>
#include <KLocalizedString>
#include <QVBoxLayout>
#include <QDialogButtonBox>
#include <QPushButton>

using namespace IncidenceEditorNG;

AlarmDialog::AlarmDialog(KCalCore::Incidence::IncidenceType incidenceType, QWidget *parent)
    : QDialog(parent)
    , mUi(new Ui::AlarmDialog)
    , mIncidenceType(incidenceType)
    , mAllowBeginReminders(true)
    , mAllowEndReminders(true)
{
    setWindowTitle(i18n("Create a new reminder"));
    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, &AlarmDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &AlarmDialog::reject);

QWidget *mainWidget = new QWidget(this);
    mUi->setupUi(mainWidget);
    mainLayout->addWidget(mainWidget);
    mainLayout->addWidget(buttonBox);

const int defaultReminderTime = IncidenceEditorNG::EditorConfig::instance()->reminderTime();
    mUi->mAlarmOffset->setValue(defaultReminderTime);

int defaultReminderUnits = IncidenceEditorNG::EditorConfig::instance()->reminderTimeUnits();
    if (defaultReminderUnits < 0 || defaultReminderUnits > 2) {
        defaultReminderUnits = 0; // minutes
    }

mUi->mOffsetUnit->setCurrentIndex(defaultReminderUnits);
    mUi->mSoundFile->setMimeTypeFilters({QStringLiteral("audio/x-wav"), QStringLiteral("audio/x-mp3"), QStringLiteral("application/ogg")});

if (IncidenceEditorNG::EditorConfig::instance()->defaultAudioFileReminders()) {
        mUi->mSoundFile->setUrl(IncidenceEditorNG::EditorConfig::instance()->audioFilePath());
    }

fillCombo();
}

AlarmDialog::~AlarmDialog()
{
    delete mUi;
}

void AlarmDialog::load(const KCalCore::Alarm::Ptr &alarm)
{
    if (!alarm) {
        return;
    }

setWindowTitle(i18n("Edit existing reminder"));

// Offsets
    int offset;
    int beforeafterpos = 0;

if (alarm->hasEndOffset()) {
        beforeafterpos = 2;
        offset = alarm->endOffset().asSeconds();
    } else {
        // TODO: Also allow alarms at fixed times, not relative to start/end
        offset = alarm->startOffset().asSeconds();
    }
    // Negative offset means before the start/end...
    if (offset < 0) {
        offset = -offset;
    } else {
        ++beforeafterpos;
    }
    mUi->mBeforeAfter->setCurrentIndex(beforeafterpos);

offset = offset / 60; // make minutes
    int useoffset = offset;

if (offset % (24 * 60) == 0 && offset > 0) {     // divides evenly into days?
        useoffset = offset / (24 * 60);
        mUi->mOffsetUnit->setCurrentIndex(2);
    } else if (offset % 60 == 0 && offset > 0) {   // divides evenly into hours?
        useoffset = offset / 60;
        mUi->mOffsetUnit->setCurrentIndex(1);
    } else {
        useoffset = offset;
        mUi->mOffsetUnit->setCurrentIndex(0);
    }
    mUi->mAlarmOffset->setValue(useoffset);

// Repeating
    mUi->mRepeats->setChecked(alarm->repeatCount() > 0);
    if (alarm->repeatCount() > 0) {
        mUi->mRepeatCount->setValue(alarm->repeatCount());
        mUi->mRepeatInterval->setValue(alarm->snoozeTime().asSeconds() / 60);   // show as minutes
    }
    int id = 0;

switch (alarm->type()) {
    case KCalCore::Alarm::Audio:
        mUi->mTypeCombo->setCurrentIndex(1);
        mUi->mSoundFile->setUrl(QUrl::fromLocalFile(alarm->audioFile()));
        id = 1;
        break;
    case KCalCore::Alarm::Procedure:
        mUi->mTypeCombo->setCurrentIndex(2);
        mUi->mApplication->setUrl(QUrl::fromLocalFile(alarm->programFile()));
        mUi->mAppArguments->setText(alarm->programArguments());
        id = 2;
        break;
    case KCalCore::Alarm::Email:
    {
        mUi->mTypeCombo->setCurrentIndex(3);
        KCalCore::Person::List addresses = alarm->mailAddresses();
        QStringList add;
        add.reserve(addresses.count());
        const KCalCore::Person::List::ConstIterator end(addresses.constEnd());
        for (KCalCore::Person::List::ConstIterator it = addresses.constBegin();
             it != end; ++it) {
            add << (*it)->fullName();
        }
        mUi->mEmailAddress->setText(add.join(QStringLiteral(", ")));
        mUi->mEmailText->setPlainText(alarm->mailText());
        id = 3;
        break;
    }
    case KCalCore::Alarm::Display:
    case KCalCore::Alarm::Invalid:
    default:
        mUi->mTypeCombo->setCurrentIndex(0);
        mUi->mDisplayText->setPlainText(alarm->text());
        break;
    }

mUi->mTypeStack->setCurrentIndex(id);
    if (alarm->audioFile().isEmpty()
        && IncidenceEditorNG::EditorConfig::instance()->defaultAudioFileReminders()) {
        mUi->mSoundFile->setUrl(IncidenceEditorNG::EditorConfig::instance()->audioFilePath());
    }
}

void AlarmDialog::save(const KCalCore::Alarm::Ptr &alarm) const
{
    // Offsets
    int offset = mUi->mAlarmOffset->value() * 60; // minutes
    int offsetunit = mUi->mOffsetUnit->currentIndex();
    if (offsetunit >= 1) {
        offset *= 60; // hours
    }
    if (offsetunit >= 2) {
        offset *= 24; // days
    }
    if (offsetunit >= 3) {
        offset *= 7; // weeks
    }

const int beforeafterpos = mUi->mBeforeAfter->currentIndex();
    if (beforeafterpos % 2 == 0) {   // before -> negative
        offset = -offset;
    }

// Note: if this triggers, fix the logic at the place causing it. It really makes
    // no sense to have both disabled.
    Q_ASSERT(mAllowBeginReminders || mAllowEndReminders);

// TODO: Add possibility to specify a given time for the reminder

// We assume that if mAllowBeginReminders is not set, that mAllowBeginReminders
    // is set.
    if (!mAllowBeginReminders) {   // before or after DTDUE
        alarm->setEndOffset(KCalCore::Duration(offset));
    } else if (beforeafterpos == 0 || beforeafterpos == 1) {   // before or after DTSTART
        alarm->setStartOffset(KCalCore::Duration(offset));
    } else if (beforeafterpos == 2 || beforeafterpos == 3) {  // before or after DTEND/DTDUE
        alarm->setEndOffset(KCalCore::Duration(offset));
    }

// Repeating
    if (mUi->mRepeats->isChecked()) {
        alarm->setRepeatCount(mUi->mRepeatCount->value());
        alarm->setSnoozeTime(mUi->mRepeatInterval->value() * 60);   // convert back to seconds
    } else {
        alarm->setRepeatCount(0);
    }

if (mUi->mTypeCombo->currentIndex() == 1) {   // Audio
        alarm->setAudioAlarm(mUi->mSoundFile->url().toLocalFile());
    } else if (mUi->mTypeCombo->currentIndex() == 2) {   // Application / script
        alarm->setProcedureAlarm(mUi->mApplication->url().toLocalFile(),
                                 mUi->mAppArguments->text());
    } else if (mUi->mTypeCombo->currentIndex() == 3) {   // Email
        QStringList addresses = KEmailAddress::splitAddressList(mUi->mEmailAddress->text());
        KCalCore::Person::List add;
        add.reserve(addresses.count());
        for (QStringList::Iterator it = addresses.begin(), end = addresses.end(); it != end; ++it) {
            add << KCalCore::Person::fromFullName(*it);
        }
        // TODO: Add a subject line and possibilities for attachments
        alarm->setEmailAlarm(QString(), mUi->mEmailText->toPlainText(), add);
    } else { // Display
        alarm->setDisplayAlarm(mUi->mDisplayText->toPlainText());
    }
}

void AlarmDialog::fillCombo()
{
    QStringList items;

if (mIncidenceType == KCalCore::Incidence::TypeTodo) {
        mUi->mBeforeAfter->clear();

if (mAllowBeginReminders) {
            items << i18n("Before the to-do starts") << i18n("After the to-do starts");
        }

if (mAllowEndReminders) {
            items << i18n("Before the to-do is due") << i18n("After the to-do is due");
        }
    } else {
        if (mAllowEndReminders) {
            items << i18n("Before the event starts") << i18n("After the event starts");
        }
        if (mAllowEndReminders) {
            items << i18n("Before the event ends") << i18n("After the event ends");
        }
    }

mUi->mBeforeAfter->clear();
    mUi->mBeforeAfter->addItems(items);
}

void AlarmDialog::setAllowBeginReminders(bool allow)
{
    mAllowBeginReminders = allow;
    fillCombo();
}

void AlarmDialog::setAllowEndReminders(bool allow)
{
    mAllowEndReminders = allow;
    fillCombo();
}

void AlarmDialog::setOffset(int offset)
{
    Q_ASSERT(offset > 0);
    mUi->mAlarmOffset->setValue(offset);
}

void AlarmDialog::setUnit(Unit unit)
{
    mUi->mOffsetUnit->setCurrentIndex(unit);
}

void AlarmDialog::setWhen(When when)
{
    Q_ASSERT(when <= mUi->mBeforeAfter->count());
    mUi->mBeforeAfter->setCurrentIndex(when);
}
07070111A000DE000081A40000000200000002000000015AA55A860000086D000000FD0000001000000000000000000000004500000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/alarmdialog.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_ALARMDIALOG_H
#define INCIDENCEEDITOR_ALARMDIALOG_H

#include <KCalCore/Incidence>

#include <QDialog>

namespace Ui {
class AlarmDialog;
}

namespace IncidenceEditorNG {
class AlarmDialog : public QDialog
{
    Q_OBJECT
public:
    enum Unit {
        Minutes,
        Hours,
        Days
    };

enum When {
        BeforeStart = 0,
        AfterStart,
        BeforeEnd,
        AfterEnd
    };

public:
    /**
      Constructs a new alarm dialog.
      @p incidenceType will influence i18n strings, that will be different for to-dos.
     */
    explicit AlarmDialog(KCalCore::Incidence::IncidenceType incidenceType,
                         QWidget *parent = nullptr);
    ~AlarmDialog();
    void load(const KCalCore::Alarm::Ptr &alarm);
    void save(const KCalCore::Alarm::Ptr &alarm) const;
    void setAllowBeginReminders(bool allow);
    void setAllowEndReminders(bool allow);
    void setOffset(int offset);
    void setUnit(Unit unit);
    void setWhen(When when);

private:
    void fillCombo();

private:
    Ui::AlarmDialog *mUi = nullptr;
    KCalCore::Incidence::IncidenceType mIncidenceType;
    bool mAllowBeginReminders;
    bool mAllowEndReminders;
};
}

#endif // INCIDENCEEDITOR_ALARMDIALOG_H
07070111A000DF000081A40000000200000002000000015AA55A86000024CD000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/alarmpresets.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "alarmpresets.h"

#include <CalendarSupport/KCalPrefs>

#include <KCalCore/Alarm>

#include <KLocalizedString>

#include "incidenceeditor_debug.h"

using namespace CalendarSupport;
using namespace KCalCore;

namespace IncidenceEditorNG {
namespace AlarmPresets {
// Don't use a map, because order matters
Q_GLOBAL_STATIC(QStringList, sBeforeStartPresetNames)
Q_GLOBAL_STATIC(QStringList, sBeforeEndPresetNames)
Q_GLOBAL_STATIC(QList<KCalCore::Alarm::Ptr>, sBeforeStartPresets)
Q_GLOBAL_STATIC(QList<KCalCore::Alarm::Ptr>, sBeforeEndPresets)

static int sDefaultPresetIndex = 0;
static int sDefaultAlarmOffset = 0; // We must save it, so we can detect that config changed.

int configuredReminderTimeInMinutes()
{
    QList<int> units;
    units << 1 << 60 << (24 * 60);

const int configuredUnits = KCalPrefs::instance()->reminderTimeUnits();
    const int unitsToUse = configuredUnits >= 0 && configuredUnits <= 2 ? configuredUnits : 0;

const int configuredReminderTime = KCalPrefs::instance()->reminderTime();
    const int reminderTimeToUse = configuredReminderTime >= 0
                                  ? configuredReminderTime
                                  : DEFAULT_REMINDER_OFFSET;

return reminderTimeToUse * units[unitsToUse];
}

void initPresets(AlarmPresets::When when)
{
    QList<int> hardcodedPresets;
    hardcodedPresets << 0           // at start/due
                     << 5           // 5 minutes
                     << 10
                     << 15
                     << 30
                     << 45
                     << 60          // 1 hour
                     << 2 * 60      // 2 hours
                     << 24 * 60     // 1 day
                     << 2 * 24 * 60 // 2 days
                     << 5 * 24 * 60;// 5 days

sDefaultAlarmOffset = configuredReminderTimeInMinutes();

if (!hardcodedPresets.contains(sDefaultAlarmOffset)) {
        // Lets insert the user's favorite preset (and keep the list sorted):
        int index;
        for (index = 0; index < hardcodedPresets.count(); ++index) {
            if (hardcodedPresets[index] > sDefaultAlarmOffset) {
                break;
            }
        }
        hardcodedPresets.insert(index, sDefaultAlarmOffset);
        sDefaultPresetIndex = index;
    } else {
        sDefaultPresetIndex = hardcodedPresets.indexOf(sDefaultAlarmOffset);
    }

switch (when) {
    case AlarmPresets::BeforeStart:

for (int i = 0; i < hardcodedPresets.count(); ++i) {
            KCalCore::Alarm::Ptr alarm(new KCalCore::Alarm(nullptr));
            alarm->setType(KCalCore::Alarm::Display);
            const int minutes = hardcodedPresets[i];
            alarm->setStartOffset(-minutes * 60);
            alarm->setEnabled(true);
            if (minutes == 0) {
                sBeforeStartPresetNames->append(i18nc("@item:inlistbox",
                                                      "At start"));
            } else if (minutes < 60) {
                sBeforeStartPresetNames->append(i18ncp("@item:inlistbox",
                                                       "%1 minute before start",
                                                       "%1 minutes before start", minutes));
            } else if (minutes < 24 * 60) {
                sBeforeStartPresetNames->append(i18ncp("@item:inlistbox",
                                                       "%1 hour before start",
                                                       "%1 hours before start", minutes / 60));
            } else {
                sBeforeStartPresetNames->append(i18ncp("@item:inlistbox",
                                                       "%1 day before start",
                                                       "%1 days before start",
                                                       minutes / (24 * 60)));
            }
            sBeforeStartPresets->append(alarm);
        }
        break;

case AlarmPresets::BeforeEnd:
        for (int i = 0; i < hardcodedPresets.count(); ++i) {
            KCalCore::Alarm::Ptr alarm(new KCalCore::Alarm(nullptr));
            alarm->setType(KCalCore::Alarm::Display);
            const int minutes = hardcodedPresets[i];
            alarm->setEndOffset(-minutes * 60);
            alarm->setEnabled(true);
            if (minutes == 0) {
                sBeforeEndPresetNames->append(i18nc("@item:inlistbox", "When due"));
            } else if (minutes < 60) {
                sBeforeEndPresetNames->append(i18ncp("@item:inlistbox",
                                                     "%1 minute before due",
                                                     "%1 minutes before due", minutes));
            } else if (minutes < 24 * 60) {
                sBeforeEndPresetNames->append(i18ncp("@item:inlistbox",
                                                     "%1 hour before due",
                                                     "%1 hours before due", minutes / 60));
            } else {
                sBeforeEndPresetNames->append(i18ncp("@item:inlistbox",
                                                     "%1 day before due",
                                                     "%1 days before due", minutes / (24 * 60)));
            }
            sBeforeEndPresets->append(alarm);
        }
        break;
    }
}

void checkInitNeeded(When when)
{
    const int currentAlarmOffset = configuredReminderTimeInMinutes();
    const bool configChanged = currentAlarmOffset != sDefaultAlarmOffset;

switch (when) {
    case AlarmPresets::BeforeStart:
        if (sBeforeStartPresetNames->isEmpty() || configChanged) {
            sBeforeStartPresetNames->clear();
            sBeforeStartPresets->clear();
            initPresets(when);
        }
        break;
    case AlarmPresets::BeforeEnd:
        if (sBeforeEndPresetNames->isEmpty() || configChanged) {
            sBeforeEndPresetNames->clear();
            sBeforeEndPresets->clear();
            initPresets(when);
        }
        break;
    default:
        Q_ASSERT_X(false, "checkInitNeeded", "Unknown preset type");
    }
}

QStringList availablePresets(AlarmPresets::When when)
{
    checkInitNeeded(when);

switch (when) {
    case AlarmPresets::BeforeStart:
        return *sBeforeStartPresetNames;
    case AlarmPresets::BeforeEnd:
        return *sBeforeEndPresetNames;
    }
    return QStringList();
}

KCalCore::Alarm::Ptr preset(When when, const QString &name)
{
    checkInitNeeded(when);

switch (when) {
    case AlarmPresets::BeforeStart:
        // The name should exists and only once
        if (sBeforeStartPresetNames->count(name) != 1) {
            // print some debug info before crashing
            qCDebug(INCIDENCEEDITOR_LOG) << " name = " << name << "; when = " << when
                                         << "; count for name = " << sBeforeStartPresetNames->count(
                name)
                                         <<  "; global count = "
                                         << sBeforeStartPresetNames->count();
            Q_ASSERT_X(false, "preset", "Number of presets should be one");
        }

return KCalCore::Alarm::Ptr(
            new KCalCore::Alarm(*sBeforeStartPresets->at(sBeforeStartPresetNames->indexOf(name))));
    case AlarmPresets::BeforeEnd:
        Q_ASSERT(sBeforeEndPresetNames->count(name) == 1);     // The name should exists and only once

return KCalCore::Alarm::Ptr(
            new KCalCore::Alarm(*sBeforeEndPresets->at(sBeforeEndPresetNames->indexOf(name))));
    }
    return KCalCore::Alarm::Ptr();
}

KCalCore::Alarm::Ptr defaultAlarm(When when)
{
    checkInitNeeded(when);

switch (when) {
    case AlarmPresets::BeforeStart:
        return Alarm::Ptr(new Alarm(*sBeforeStartPresets->at(sDefaultPresetIndex)));
    case AlarmPresets::BeforeEnd:
        return Alarm::Ptr(new Alarm(*sBeforeEndPresets->at(sDefaultPresetIndex)));
    }
    return Alarm::Ptr();
}

int presetIndex(When when, const KCalCore::Alarm::Ptr &alarm)
{
    checkInitNeeded(when);
    const QStringList presets = availablePresets(when);

for (int i = 0; i < presets.size(); ++i) {
        KCalCore::Alarm::Ptr presetAlarm(preset(when, presets.at(i)));
        if (presetAlarm == alarm) {
            return i;
        }
    }

return -1;
}

int defaultPresetIndex()
{
    // BeforeEnd would do too, index is the same.
    checkInitNeeded(AlarmPresets::BeforeStart);
    return sDefaultPresetIndex;
}
} // AlarmPresets
} // IncidenceEditorNG
07070111A000E0000081A40000000200000002000000015AA55A8600000835000000FD0000001000000000000000000000004600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/alarmpresets.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_ALARMPRESETS_H
#define INCIDENCEEDITOR_ALARMPRESETS_H

#include <KCalCore/Alarm>

class QStringList;

namespace IncidenceEditorNG {
enum {
    // Fallback in case config is invalid
    DEFAULT_REMINDER_OFFSET = 15 // minutes
};

namespace AlarmPresets {
enum When {
    BeforeStart,
    BeforeEnd
};

/**
 * Returns the available presets.
 */
QStringList availablePresets(When when = BeforeStart);

/**
 * Returns a recurrence preset for given name. The name <em>must</em> be one
 * of availablePresets().
 *
 * Note: The caller takes ownership over the pointer.
 */
KCalCore::Alarm::Ptr preset(When when, const QString &name);

/**
 * Returns an Alarm configured accordingly to the default preset.
 *
 * Note: The caller takes ownership over the pointer.
 */
KCalCore::Alarm::Ptr defaultAlarm(When when);

/**
 * Returns the index of the preset in availablePresets for the given recurrence,
 * or -1 if no preset is equal to the given recurrence.
 */
int presetIndex(When when, const KCalCore::Alarm::Ptr &alarm);

/**
   Returns the index of the default preset. ( Comes from KCalPrefs ).
 */
int defaultPresetIndex();
}
}

#endif // INCIDENCEEDITOR_ALARMPRESETS_H
07070111A000E1000081A40000000200000002000000015AA55A8600001BE3000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attachmenteditdialog.cpp/*
  Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2005 Reinhold Kainhofer <reinhold@kainhofer.com>
  Copyright (c) 2005 Rafal Rzepecki <divide@users.sourceforge.net>
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "attachmenteditdialog.h"
#include "attachmenticonview.h"
#include "ui_attachmenteditdialog.h"
#include <KLocalizedString>
#include <KIO/StoredTransferJob>
#include <KJobWidgets>
#include <QLocale>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QMimeDatabase>

using namespace IncidenceEditorNG;

AttachmentEditDialog::AttachmentEditDialog(AttachmentIconItem *item, QWidget *parent, bool modal)
    : QDialog(parent)
    ,
#ifdef KDEPIM_ENTERPRISE_BUILD
    mAttachment(new KCalCore::Attachment('\0'))
    //use the non-uri constructor
    // as we want inline by default
#else
    mAttachment(new KCalCore::Attachment(QString()))
#endif
    , mItem(item)
    , mUi(new Ui::AttachmentEditDialog)
{
    setWindowTitle(i18n("Edit Attachment"));
    QMimeDatabase db;
    mMimeType = db.mimeTypeForName(item->mimeType());
    QWidget *page = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QDialogButtonBox *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, &AttachmentEditDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &AttachmentEditDialog::reject);
    mainLayout->addWidget(page);
    mainLayout->addWidget(buttonBox);

mUi->setupUi(page);
    mUi->mLabelEdit->setText(item->label().isEmpty() ? item->uri() : item->label());
    mUi->mIcon->setPixmap(item->icon());
    mUi->mInlineCheck->setChecked(item->isBinary());

const QString typecomment = item->mimeType().isEmpty()
                                ? i18nc("@label unknown mimetype", "Unknown")
                                : mMimeType.comment();
    mUi->mTypeLabel->setText(typecomment);

setModal(modal);
    mOkButton->setEnabled(false);

mUi->mInlineCheck->setEnabled(false);
    if (item->attachment()->isUri() || item->attachment()->data().isEmpty()) {
        mUi->mStackedWidget->setCurrentIndex(0);
        mUi->mURLRequester->setUrl(QUrl(item->uri()));
        urlChanged(item->uri());
    } else {
        mUi->mInlineCheck->setEnabled(true);
        mUi->mStackedWidget->setCurrentIndex(1);
        mUi->mSizeLabel->setText(QStringLiteral("%1 (%2)").
                                 arg(KIO::convertSize(item->attachment()->size()),
                                     QLocale().toString(item->attachment()->size())));
    }

connect(mUi->mInlineCheck, &QCheckBox::stateChanged, this,
            &AttachmentEditDialog::inlineChanged);
    connect(mUi->mURLRequester, QOverload<const QUrl &>::of(&KUrlRequester::urlSelected), this, static_cast<void (AttachmentEditDialog::*)(const QUrl &)>(&AttachmentEditDialog:: urlChanged));
    connect(mUi->mURLRequester, &KUrlRequester::textChanged, this, static_cast<void (AttachmentEditDialog::*)(const QString &)>(&AttachmentEditDialog::
                                                                         urlChanged));
}

AttachmentEditDialog::~AttachmentEditDialog()
{
    delete mUi;
}

void AttachmentEditDialog::accept()
{
    slotApply();
    QDialog::accept();
}

void AttachmentEditDialog::slotApply()
{
    QUrl url = mUi->mURLRequester->url();

if (mUi->mLabelEdit->text().isEmpty()) {
        if (url.isLocalFile()) {
            mItem->setLabel(url.fileName());
        } else {
            mItem->setLabel(url.url());
        }
    } else {
        mItem->setLabel(mUi->mLabelEdit->text());
    }
    if (mItem->label().isEmpty()) {
        mItem->setLabel(i18nc("@label", "New attachment"));
    }
    mItem->setMimeType(mMimeType.name());

QString correctedUrl = url.url();
    if (!url.isEmpty() && url.isRelative()) {
        // If the user used KURLRequester's KURLCompletion
        // (used the line edit instead of the file dialog)
        // the returned url is not absolute and is always relative
        // to the home directory (not pwd), so we must prepend home

correctedUrl = QDir::home().filePath(url.toLocalFile());
        url = QUrl::fromLocalFile(correctedUrl);
        if (url.isValid()) {
            urlChanged(url);
            mItem->setLabel(url.fileName());
            mItem->setUri(correctedUrl);
            mItem->setMimeType(mMimeType.name());
        }
    }

if (mUi->mStackedWidget->currentIndex() == 0) {
        if (mUi->mInlineCheck->isChecked()) {
            auto job = KIO::storedGet(url);
            KJobWidgets::setWindow(job, nullptr);
            if (job->exec()) {
                QByteArray data = job->data();
                mItem->setData(data);
            }
        } else {
            mItem->setUri(correctedUrl);
        }
    }
}

void AttachmentEditDialog::inlineChanged(int state)
{
    mOkButton->setEnabled(!mUi->mURLRequester->url().toDisplayString().trimmed().isEmpty()
                          || mUi->mStackedWidget->currentIndex() == 1);
    if (state == Qt::Unchecked && mUi->mStackedWidget->currentIndex() == 1) {
        mUi->mStackedWidget->setCurrentIndex(0);
        if (!mItem->savedUri().isEmpty()) {
            mUi->mURLRequester->setUrl(QUrl(mItem->savedUri()));
        } else {
            mUi->mURLRequester->setUrl(QUrl(mItem->uri()));
        }
    }
}

void AttachmentEditDialog::urlChanged(const QString &url)
{
    const bool urlIsNotEmpty = !url.trimmed().isEmpty();
    mOkButton->setEnabled(urlIsNotEmpty);
    mUi->mInlineCheck->setEnabled(urlIsNotEmpty
                                  || mUi->mStackedWidget->currentIndex() == 1);
}

void AttachmentEditDialog::urlChanged(const QUrl &url)
{
    QMimeDatabase db;
    mMimeType = db.mimeTypeForUrl(url);
    mUi->mTypeLabel->setText(mMimeType.comment());
    mUi->mIcon->setPixmap(AttachmentIconItem::icon(mMimeType, url.path()));
}
07070111A000E2000081A40000000200000002000000015AA55A860000089E000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attachmenteditdialog.h/*
  Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2005 Reinhold Kainhofer <reinhold@kainhofer.com>
  Copyright (c) 2005 Rafal Rzepecki <divide@users.sourceforge.net>
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_ATTACHMENTEDITDIALOG_H
#define INCIDENCEEDITOR_ATTACHMENTEDITDIALOG_H

#include <KCalCore/Attachment>
#include <QUrl>
#include <QDialog>
#include <QMimeType>

class QPushButton;

namespace Ui {
class AttachmentEditDialog;
}

namespace IncidenceEditorNG {
class AttachmentIconItem;

class AttachmentEditDialog : public QDialog
{
    Q_OBJECT
public:
    AttachmentEditDialog(AttachmentIconItem *item, QWidget *parent, bool modal = true);
    ~AttachmentEditDialog() override;
    void accept() override;

protected Q_SLOTS:
    void inlineChanged(int state);
    void urlChanged(const QUrl &url);
    void urlChanged(const QString &url);
    virtual void slotApply();

private:
    KCalCore::Attachment::Ptr mAttachment;
    AttachmentIconItem *mItem = nullptr;
    QMimeType mMimeType;
    Ui::AttachmentEditDialog *mUi = nullptr;
    QPushButton *mOkButton = nullptr;
};
}

#endif // INCIDENCEEDITOR_ATTACHMENTEDITDIALOG_H
07070111A000E3000081A40000000200000002000000015AA55A86000021D9000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attachmenticonview.cpp/*
  Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2005 Reinhold Kainhofer <reinhold@kainhofer.com>
  Copyright (c) 2005 Rafal Rzepecki <divide@users.sourceforge.net>
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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.

NOTE: May, 2010. Extracted this code from
        kdepim/incidenceeditors/editorattachments.{h,cpp}
*/

#include <config-enterprise.h>

#include "attachmenticonview.h"

#include <KIconLoader>
#include <KUrlMimeData>
#include <QTemporaryFile>
#include <QDir>

#include <KIconEngine>
#include <QDrag>
#include <QKeyEvent>
#include <QMimeData>
#include <QMimeDatabase>
#include <QMimeType>

using namespace IncidenceEditorNG;

AttachmentIconItem::AttachmentIconItem(const KCalCore::Attachment::Ptr &att, QListWidget *parent)
    : QListWidgetItem(parent)
{
    if (att) {
        mAttachment = KCalCore::Attachment::Ptr(new KCalCore::Attachment(*att.data()));
        mAttachment->setLabel(att->label());
    } else {
        // for the enteprise, inline attachments are the default
#ifdef KDEPIM_ENTERPRISE_BUILD
        mAttachment
            = KCalCore::Attachment::Ptr(
            new KCalCore::Attachment(QByteArray()));        // use the non-uri constructor
        // as we want inline by default
#else
        mAttachment = KCalCore::Attachment::Ptr(new KCalCore::Attachment(QString()));
#endif
    }
    readAttachment();
    setFlags(flags() | Qt::ItemIsDragEnabled);
}

AttachmentIconItem::~AttachmentIconItem()
{
}

KCalCore::Attachment::Ptr AttachmentIconItem::attachment() const
{
    return mAttachment;
}

const QString AttachmentIconItem::uri() const
{
    return mAttachment->uri();
}

const QString AttachmentIconItem::savedUri() const
{
    return mSaveUri;
}

void AttachmentIconItem::setUri(const QString &uri)
{
    mSaveUri = uri;
    mAttachment->setUri(mSaveUri);
    readAttachment();
}

void AttachmentIconItem::setData(const QByteArray &data)
{
    mAttachment->setDecodedData(data);
    readAttachment();
}

const QString AttachmentIconItem::mimeType() const
{
    return mAttachment->mimeType();
}

void AttachmentIconItem::setMimeType(const QString &mime)
{
    mAttachment->setMimeType(mime);
    readAttachment();
}

const QString AttachmentIconItem::label() const
{
    return mAttachment->label();
}

void AttachmentIconItem::setLabel(const QString &description)
{
    if (mAttachment->label() == description) {
        return;
    }
    mAttachment->setLabel(description);
    readAttachment();
}

bool AttachmentIconItem::isBinary() const
{
    return mAttachment->isBinary();
}

QPixmap AttachmentIconItem::icon() const
{
    QMimeDatabase db;
    return icon(db.mimeTypeForName(mAttachment->mimeType()),
                mAttachment->uri(), mAttachment->isBinary());
}

QPixmap AttachmentIconItem::icon(const QMimeType &mimeType, const QString &uri, bool binary)
{
    QString iconStr = mimeType.iconName();
    QStringList overlays;
    if (!uri.isEmpty() && !binary) {
        overlays << QStringLiteral("emblem-link");
    }
    return QIcon(new KIconEngine(iconStr, KIconLoader::global(), overlays)).pixmap(
        KIconLoader::SizeSmallMedium, KIconLoader::SizeSmallMedium);
}

void AttachmentIconItem::readAttachment()
{
    setText(mAttachment->label());
    setFlags(flags() | Qt::ItemIsEditable);

QMimeDatabase db;
    if (mAttachment->mimeType().isEmpty()
        || !(db.mimeTypeForName(mAttachment->mimeType()).isDefault())) {
        QMimeType mimeType;
        if (mAttachment->isUri()) {
            mimeType = db.mimeTypeForUrl(QUrl(mAttachment->uri()));
        } else {
            mimeType = db.mimeTypeForData(mAttachment->decodedData());
        }
        mAttachment->setMimeType(mimeType.name());
    }

setIcon(icon());
}

AttachmentIconView::AttachmentIconView(QWidget *parent)
    : QListWidget(parent)
{
    setMovement(Static);
    setAcceptDrops(true);
    setSelectionMode(ExtendedSelection);
    setSelectionRectVisible(false);
    setIconSize(QSize(KIconLoader::SizeLarge, KIconLoader::SizeLarge));
    setFlow(LeftToRight);
    setWrapping(true);
#ifndef QT_NO_DRAGANDDROP
    setDragDropMode(DragDrop);
    setDragEnabled(true);
#endif
    setEditTriggers(EditKeyPressed);
    setContextMenuPolicy(Qt::CustomContextMenu);
}

QUrl AttachmentIconView::tempFileForAttachment(const KCalCore::Attachment::Ptr &attachment) const
{
    const QUrl url = mTempFiles.value(attachment);
    if (url.isValid()) {
        return url;
    }
    QTemporaryFile *file = nullptr;

QMimeDatabase db;
    QStringList patterns = db.mimeTypeForName(attachment->mimeType()).globPatterns();

if (!patterns.empty()) {
        file = new QTemporaryFile(QDir::tempPath() + QLatin1String(
                                      "/attachementview_XXXXX")
                                  + patterns.first().remove(QLatin1Char('*')));
    } else {
        file = new QTemporaryFile();
    }
    file->setParent(const_cast<AttachmentIconView *>(this));

file->setAutoRemove(true);
    file->open();
    // read-only not to give the idea that it could be written to
    file->setPermissions(QFile::ReadUser);
    file->write(QByteArray::fromBase64(attachment->data()));
    mTempFiles.insert(attachment, QUrl::fromLocalFile(file->fileName()));
    file->close();
    return mTempFiles.value(attachment);
}

QMimeData *AttachmentIconView::mimeData(const QList< QListWidgetItem *> items) const
{
    // create a list of the URL:s that we want to drag
    QList<QUrl> urls;
    QStringList labels;
    for (QListWidgetItem *it : items) {
        if (it->isSelected()) {
            AttachmentIconItem *item = static_cast<AttachmentIconItem *>(it);
            if (item->isBinary()) {
                urls.append(tempFileForAttachment(item->attachment()));
            } else {
                urls.append(QUrl(item->uri()));
            }
            labels.append(QString::fromLatin1(QUrl::toPercentEncoding(item->label())));
        }
    }
    if (selectionMode() == NoSelection) {
        AttachmentIconItem *item = static_cast<AttachmentIconItem *>(currentItem());
        if (item) {
            urls.append(QUrl(item->uri()));
            labels.append(QString::fromLatin1(QUrl::toPercentEncoding(item->label())));
        }
    }

QMap<QString, QString> metadata;
    metadata[QStringLiteral("labels")] = labels.join(QLatin1Char(':'));

QMimeData *mimeData = new QMimeData;
    mimeData->setUrls(urls);
    KUrlMimeData::setMetaData(metadata, mimeData);
    return mimeData;
}

QMimeData *AttachmentIconView::mimeData() const
{
    return mimeData(selectedItems());
}

void AttachmentIconView::startDrag(Qt::DropActions supportedActions)
{
    Q_UNUSED(supportedActions);
#ifndef QT_NO_DRAGANDDROP
    QPixmap pixmap;
    if (selectedItems().size() > 1) {
        pixmap = KIconLoader::global()->loadIcon(QStringLiteral(
                                                     "mail-attachment"), KIconLoader::Desktop);
    }
    if (pixmap.isNull()) {
        pixmap = static_cast<AttachmentIconItem *>(currentItem())->icon();
    }

const QPoint hotspot(pixmap.width() / 2, pixmap.height() / 2);

QDrag *drag = new QDrag(this);
    drag->setMimeData(mimeData());

drag->setPixmap(pixmap);
    drag->setHotSpot(hotspot);
    drag->exec(Qt::CopyAction);
#endif
}

void AttachmentIconView::keyPressEvent(QKeyEvent *event)
{
    if ((event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter)
        && currentItem() && state() != EditingState) {
        Q_EMIT itemDoubleClicked(currentItem());   // ugly, but itemActivated() also includes single click
        return;
    }
    QListWidget::keyPressEvent(event);
}
07070111A000E4000081A40000000200000002000000015AA55A8600000BC1000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attachmenticonview.h/*
  Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2005 Reinhold Kainhofer <reinhold@kainhofer.com>
  Copyright (c) 2005 Rafal Rzepecki <divide@users.sourceforge.net>
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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.

NOTE: May, 2010. Extracted this code from
        kdepim/incidenceeditors/editorattachments.{h,cpp}
*/

#ifndef INCIDENCEEDITOR_ATTACHMENTICONVIEW_H
#define INCIDENCEEDITOR_ATTACHMENTICONVIEW_H

#include <KCalCore/Attachment>

#include <QMimeType>
#include <QUrl>

#include <QListWidget>

namespace IncidenceEditorNG {
class AttachmentIconView : public QListWidget
{
    Q_OBJECT
    friend class EditorAttachments;
public:
    explicit AttachmentIconView(QWidget *parent = nullptr);

QMimeData *mimeData() const;
    QUrl tempFileForAttachment(const KCalCore::Attachment::Ptr &attachment) const;

protected:
    QMimeData *mimeData(const QList<QListWidgetItem *> items) const override;
    void startDrag(Qt::DropActions supportedActions) override;
    void keyPressEvent(QKeyEvent *event) override;

private:
    mutable QHash<KCalCore::Attachment::Ptr, QUrl> mTempFiles;
};

class AttachmentIconItem : public QListWidgetItem
{
public:
    AttachmentIconItem(const KCalCore::Attachment::Ptr &att, QListWidget *parent);
    ~AttachmentIconItem();

KCalCore::Attachment::Ptr attachment() const;
    const QString uri() const;
    const QString savedUri() const;
    void setUri(const QString &uri);

using QListWidgetItem::setData;

void setData(const QByteArray &data);

const QString mimeType() const;
    void setMimeType(const QString &mime);

const QString label() const;
    void setLabel(const QString &description);

bool isBinary() const;

static QPixmap icon(const QMimeType &mimeType, const QString &uri, bool binary = false);
    QPixmap icon() const;

void readAttachment();

private:
    KCalCore::Attachment::Ptr mAttachment;
    QString mSaveUri;
};
}

#endif // INCIDENCEEDITOR_ATTACHMENTICONVIEW_H
07070111A000E5000081A40000000200000002000000015AA55A86000017E1000000FD0000001000000000000000000000005400000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeecomboboxdelegate.cpp/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#include "attendeecomboboxdelegate.h"

#include "attendeeline.h"

#include <QMenu>
#include <QAbstractItemView>
#include <QApplication>
#include <QHelpEvent>
#include <QToolTip>
#include <QWhatsThis>

using namespace IncidenceEditorNG;

AttendeeComboBoxDelegate::AttendeeComboBoxDelegate(QObject *parent)
    : QStyledItemDelegate(parent)
    , mStandardIndex(0)
{
    connect(this, &AttendeeComboBoxDelegate::closeEditor, this,
            &AttendeeComboBoxDelegate::doCloseEditor);
}

void AttendeeComboBoxDelegate::addItem(const QIcon &icon, const QString &text)
{
    QPair<QIcon, QString> pair;
    pair.first = icon;
    pair.second = text;
    mEntries << pair;
}

void AttendeeComboBoxDelegate::clear()
{
    mEntries.clear();
}

void AttendeeComboBoxDelegate::setToolTip(const QString &tT)
{
    mToolTip = tT;
}

void AttendeeComboBoxDelegate::setWhatsThis(const QString &wT)
{
    mWhatsThis = wT;
}

void AttendeeComboBoxDelegate::setStandardIndex(int index)
{
    mStandardIndex = index;
}

QWidget *AttendeeComboBoxDelegate::createEditor(QWidget *parent,
                                                const QStyleOptionViewItem & /* option */,
                                                const QModelIndex & /* index */) const
{
    AttendeeComboBox *editor = new AttendeeComboBox(parent);

for (const QPair<QIcon, QString> &pair : qAsConst(mEntries)) {
        editor->addItem(pair.first, pair.second);
    }

connect(editor, &AttendeeComboBox::leftPressed, this, &AttendeeComboBoxDelegate::leftPressed);
    connect(editor, &AttendeeComboBox::rightPressed, this, &AttendeeComboBoxDelegate::rightPressed);

editor->setPopupMode(QToolButton::MenuButtonPopup);
    editor->setToolTip(mToolTip);
    editor->setWhatsThis(mWhatsThis);
    return editor;
}

void AttendeeComboBoxDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
{
    AttendeeComboBox *comboBox = static_cast<AttendeeComboBox *>(editor);
    int value = index.model()->data(index, Qt::EditRole).toUInt();
    if (value >= mEntries.count()) {
        value = mStandardIndex;
    }
    comboBox->setCurrentIndex(value);
}

void AttendeeComboBoxDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
                                            const QModelIndex &index) const
{
    AttendeeComboBox *comboBox = static_cast<AttendeeComboBox *>(editor);
    model->setData(index, comboBox->currentIndex(), Qt::EditRole);
    comboBox->menu()->close();
}

void AttendeeComboBoxDelegate::updateEditorGeometry(QWidget *editor,
                                                    const QStyleOptionViewItem &option,
                                                    const QModelIndex & /* index */) const
{
    editor->setGeometry(option.rect);
}

void AttendeeComboBoxDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
                                     const QModelIndex &index) const
{
    QStyleOptionButton myOption;

int value = index.model()->data(index).toUInt();
    if (value >= mEntries.count()) {
        value = mStandardIndex;
    }

myOption.rect = option.rect;
    myOption.state = option.state;
    myOption.icon = mEntries[value].first;
    myOption.iconSize = myOption.icon.actualSize(option.rect.size());

QApplication::style()->drawControl(QStyle::CE_PushButton, &myOption, painter);
}

bool AttendeeComboBoxDelegate::eventFilter(QObject *editor, QEvent *event)
{
    if (event->type() == QEvent::Enter) {
        AttendeeComboBox *comboBox = static_cast<AttendeeComboBox *>(editor);
        comboBox->showMenu();
        return editor->eventFilter(editor, event);
    }

return QStyledItemDelegate::eventFilter(editor, event);
}

void AttendeeComboBoxDelegate::doCloseEditor(QWidget *editor)
{
    AttendeeComboBox *comboBox = static_cast<AttendeeComboBox *>(editor);
    comboBox->menu()->close();
}

void AttendeeComboBoxDelegate::leftPressed()
{
    Q_EMIT closeEditor(
        static_cast<QWidget *>(QObject::sender()), QAbstractItemDelegate::EditPreviousItem);
}

void AttendeeComboBoxDelegate::rightPressed()
{
    Q_EMIT closeEditor(
        static_cast<QWidget *>(QObject::sender()), QAbstractItemDelegate::EditNextItem);
}

bool AttendeeComboBoxDelegate::helpEvent(QHelpEvent *event, QAbstractItemView *view,
                                         const QStyleOptionViewItem &option,
                                         const QModelIndex &index)
{
    if (!event || !view) {
        return false;
    }
    switch (event->type()) {
#ifndef QT_NO_TOOLTIP
    case QEvent::ToolTip:
    {
        QHelpEvent *he = static_cast<QHelpEvent *>(event);
        QToolTip::showText(he->globalPos(), mToolTip, view);
        return true;
    }
#endif
#ifndef QT_NO_WHATSTHIS
    case QEvent::QueryWhatsThis:
        return true;
    case QEvent::WhatsThis:
    {
        QHelpEvent *he = static_cast<QHelpEvent *>(event);
        QWhatsThis::showText(he->globalPos(), mWhatsThis, view);
        return true;
    }
#endif
    default:
        break;
    }
    return QStyledItemDelegate::helpEvent(event, view, option, index);
}
07070111A000E6000081A40000000200000002000000015AA55A8600000BC2000000FD0000001000000000000000000000005200000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeecomboboxdelegate.h/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#ifndef INCIDENCEEDITOR_ATTENDEECOMBOBOXDELEGATE_H
#define INCIDENCEEDITOR_ATTENDEECOMBOBOXDELEGATE_H

#include <QStyledItemDelegate>
#include <QModelIndex>
#include <QIcon>
#include <QString>

namespace IncidenceEditorNG {
/**
 * class to show a Icon and Text for an Attendee
 * you have to set the Items via addItem to have a list to choose from.
 * saves the option as int in the model
 */
class AttendeeComboBoxDelegate : public QStyledItemDelegate
{
    Q_OBJECT
public:
    explicit AttendeeComboBoxDelegate(QObject *parent = nullptr);

QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                          const QModelIndex &index) const override;
    void setEditorData(QWidget *editor, const QModelIndex &index) const override;
    void setModelData(QWidget *editor, QAbstractItemModel *model,
                      const QModelIndex &index) const override;
    void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option,
                              const QModelIndex &index) const override;
    void paint(QPainter *painter, const QStyleOptionViewItem &option,
               const QModelIndex &index) const override;

bool eventFilter(QObject *editor, QEvent *event) override;

virtual void addItem(const QIcon &, const QString &);
    virtual void clear();

virtual void setToolTip(const QString &);
    virtual void setWhatsThis(const QString &);

/** choose this index, if the item in the model is unknown
     */
    void setStandardIndex(int);

public Q_SLOTS:
    bool helpEvent(QHelpEvent *event, QAbstractItemView *view, const QStyleOptionViewItem &option,
                   const QModelIndex &index) override;

private Q_SLOTS:
    void doCloseEditor(QWidget *editor);
    void rightPressed();
    void leftPressed();

private:
    /** all entries to choose from */
    QVector<QPair<QIcon, QString> > mEntries;
    QString mToolTip;
    QString mWhatsThis;
    /**fallback index */
    int mStandardIndex;
};
}

#endif
07070111A000E7000081A40000000200000002000000015AA55A860000056D000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeedata.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "attendeedata.h"

using namespace IncidenceEditorNG;

void AttendeeData::clear()
{
    setName(QString());
    setEmail(QString());
    setRole(Attendee::ReqParticipant);
    setStatus(Attendee::None);
    setRSVP(false);
    setUid(QString());
}

bool AttendeeData::isEmpty() const
{
    return name().isEmpty() && email().isEmpty();
}

KCalCore::Attendee::Ptr AttendeeData::attendee() const
{
    return KCalCore::Attendee::Ptr(new KCalCore::Attendee(*this));
}
07070111A000E8000081A40000000200000002000000015AA55A860000077D000000FD0000001000000000000000000000004600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeedata.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_ATTENDEEDATA_H
#define INCIDENCEEDITOR_ATTENDEEDATA_H

#include <Libkdepim/MultiplyingLine>

#include <KCalCore/Attendee>

namespace IncidenceEditorNG {
class AttendeeData : public KPIM::MultiplyingLineData, public KCalCore::Attendee
{
public:
    typedef QSharedPointer<AttendeeData> Ptr;
    typedef QList<AttendeeData::Ptr> List;

AttendeeData(const QString &name, const QString &email, bool rsvp = false,
                 Attendee::PartStat status = Attendee::None,
                 Attendee::Role role = Attendee::ReqParticipant, const QString &uid = QString())
        : KCalCore::Attendee(name, email, rsvp, status, role, uid)
    {
    }

explicit AttendeeData(const KCalCore::Attendee::Ptr &attendee) : KCalCore::Attendee(*attendee)
    {
    }

void clear() override;
    bool isEmpty() const override;

/**
     * Return a copy of the attendee data
     */
    KCalCore::Attendee::Ptr attendee() const;
};
}

#endif // INCIDENCEEDITOR_ATTENDEEDATA_H
07070111A000E9000081A40000000200000002000000015AA55A8600000CF5000000FD0000001000000000000000000000004A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeeeditor.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "attendeeeditor.h"

#include "incidenceeditor_debug.h"

using namespace IncidenceEditorNG;

AttendeeEditor::AttendeeEditor(QWidget *parent)
    : MultiplyingLineEditor(new AttendeeLineFactory(parent), parent)
{
    connect(this, &AttendeeEditor::lineAdded, this, &AttendeeEditor::slotLineAdded);

addData();
}

void AttendeeEditor::slotLineAdded(KPIM::MultiplyingLine *line)
{
    AttendeeLine *att = qobject_cast<AttendeeLine *>(line);
    if (!att) {
        return;
    }

connect(att, QOverload<>::of(&AttendeeLine::changed), this, &AttendeeEditor::slotCalculateTotal);
    connect(att, QOverload<const KCalCore::Attendee::Ptr &, const KCalCore::Attendee::Ptr &>::of(&AttendeeLine:: changed), this, &AttendeeEditor::changed);
    connect(att, &AttendeeLine::editingFinished, this, &AttendeeEditor::editingFinished);
}

void AttendeeEditor::slotCalculateTotal()
{
    int empty = 0;
    int count = 0;

const QList<KPIM::MultiplyingLine *> listLines = lines();
    for (KPIM::MultiplyingLine *line : listLines) {
        AttendeeLine *att = qobject_cast<AttendeeLine *>(line);
        if (att) {
            if (att->isEmpty()) {
                ++empty;
            } else {
                ++count;
            }
        }
    }
    Q_EMIT countChanged(count);
    // We always want at least one empty line
    if (empty == 0) {
        addData();
    }
}

AttendeeData::List AttendeeEditor::attendees() const
{
    const QList<KPIM::MultiplyingLineData::Ptr> dataList = allData();
    AttendeeData::List attList;
    //qCDebug(INCIDENCEEDITOR_LOG) << "num attendees:" << dataList.size();
    for (const KPIM::MultiplyingLineData::Ptr &datum : dataList) {
        AttendeeData::Ptr att = qSharedPointerDynamicCast<AttendeeData>(datum);
        if (!att) {
            continue;
        }
        attList << att;
    }
    return attList;
}

void AttendeeEditor::addAttendee(const KCalCore::Attendee::Ptr &attendee)
{
    addData(AttendeeData::Ptr(new AttendeeData(attendee)));
}

void AttendeeEditor::removeAttendee(const AttendeeData::Ptr &attendee)
{
    removeData(attendee);
}

void AttendeeEditor::setActions(AttendeeLine::AttendeeActions actions)
{
    const QList<KPIM::MultiplyingLine *> listLines = lines();
    for (KPIM::MultiplyingLine *line : listLines) {
        AttendeeLine *att = qobject_cast<AttendeeLine *>(line);
        att->setActions(actions);
    }
}
07070111A000EA000081A40000000200000002000000015AA55A860000084D000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeeeditor.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_ATTENDEEEDITOR_H
#define INCIDENCEEDITOR_ATTENDEEEDITOR_H

#include "attendeeline.h"
#include "attendeedata.h"

#include <Libkdepim/MultiplyingLineEditor>

namespace IncidenceEditorNG {
class AttendeeLineFactory : public KPIM::MultiplyingLineFactory
{
    Q_OBJECT
public:
    explicit AttendeeLineFactory(QObject *parent) : KPIM::MultiplyingLineFactory(parent)
    {
    }

KPIM::MultiplyingLine *newLine(QWidget *parent) override
    {
        return new AttendeeLine(parent);
    }
};

class AttendeeEditor : public KPIM::MultiplyingLineEditor
{
    Q_OBJECT
public:
    explicit AttendeeEditor(QWidget *parent = nullptr);

AttendeeData::List attendees() const;

void addAttendee(const KCalCore::Attendee::Ptr &attendee);
    void removeAttendee(const AttendeeData::Ptr &attendee);

void setActions(AttendeeLine::AttendeeActions actions);

Q_SIGNALS:
    void countChanged(int);
    void changed(const KCalCore::Attendee::Ptr &oldAttendee,
                 const KCalCore::Attendee::Ptr &newAttendee);
    void editingFinished(KPIM::MultiplyingLine *);

protected Q_SLOTS:
    void slotLineAdded(KPIM::MultiplyingLine *);
    void slotCalculateTotal();
};
}

#endif
07070111A000EB000081A40000000200000002000000015AA55A8600003CF8000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeeline.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (c) 2009-2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "attendeeline.h"
#include "attendeedata.h"

#include <KCalUtils/Stringify>

#include <KEmailAddress>

#include <KCompletionBox>
#include "incidenceeditor_debug.h"
#include <KLocalizedString>

#include <QBoxLayout>
#include <QKeyEvent>
#include <QMenu>

using namespace IncidenceEditorNG;

typedef QPair<QString, QIcon> TextIconPair;

AttendeeComboBox::AttendeeComboBox(QWidget *parent)
    : QToolButton(parent)
    , mMenu(new QMenu(this))
    , mCurrentIndex(-1)
{
    setPopupMode(QToolButton::InstantPopup);
    setToolButtonStyle(Qt::ToolButtonIconOnly);
    setMenu(mMenu);
}

void AttendeeComboBox::addItem(const QIcon &icon, const QString &text)
{
    mList.append(TextIconPair(text, icon));
    if (mCurrentIndex == -1) {
        setCurrentIndex(0);
    }
    int index = mList.size() - 1;
    QAction *act = menu()->addAction(icon, text, this, &AttendeeComboBox::slotActionTriggered);
    act->setData(index);
}

void AttendeeComboBox::addItems(const QStringList &texts)
{
    for (const QString &str : texts) {
        addItem(QIcon(), str);
    }
    if (mCurrentIndex == -1) {
        setCurrentIndex(0);
    }
}

int AttendeeComboBox::currentIndex() const
{
    return mCurrentIndex;
}

void AttendeeComboBox::clear()
{
    mCurrentIndex = -1;
    mMenu->clear();
    mList.clear();
}

void AttendeeComboBox::setCurrentIndex(int index)
{
    Q_ASSERT(index < mList.size());
    const int old = mCurrentIndex;
    mCurrentIndex = index;
    setIcon(mList.at(index).second);
    setToolTip(mList.at(index).first);
    if (old != index) {
        Q_EMIT itemChanged();
    }
}

void AttendeeComboBox::slotActionTriggered()
{
    int index = qobject_cast<QAction *>(sender())->data().toInt();
    setCurrentIndex(index);
}

void AttendeeComboBox::keyPressEvent(QKeyEvent *ev)
{
    if (ev->key() == Qt::Key_Left) {
        Q_EMIT leftPressed();
    } else if (ev->key() == Qt::Key_Right) {
        Q_EMIT rightPressed();
    } else if (!mMenu->isVisible() && (
                   ev->key() == Qt::Key_Down
                   || ev->key() == Qt::Key_Space)) {
        showMenu();
    } else {
        QToolButton::keyPressEvent(ev);
    }
}

AttendeeLineEdit::AttendeeLineEdit(QWidget *parent)
    : AddresseeLineEdit(parent, true)
{
}

void AttendeeLineEdit::keyPressEvent(QKeyEvent *ev)
{
    if ((ev->key() == Qt::Key_Enter || ev->key() == Qt::Key_Return)
        && !completionBox()->isVisible()) {
        Q_EMIT downPressed();
        KPIM::AddresseeLineEdit::keyPressEvent(ev);
    } else if (ev->key() == Qt::Key_Backspace && text().isEmpty()) {
        ev->accept();
        Q_EMIT deleteMe();
    } else if (ev->key() == Qt::Key_Left && cursorPosition() == 0
               && !ev->modifiers().testFlag(Qt::ShiftModifier)) {
        // Shift would be pressed during selection
        Q_EMIT leftPressed();
    } else if (ev->key() == Qt::Key_Right && cursorPosition() == text().length()
               && !ev->modifiers().testFlag(Qt::ShiftModifier)) {
        // Shift would be pressed during selection
        Q_EMIT rightPressed();
    } else if (ev->key() == Qt::Key_Down) {
        Q_EMIT downPressed();
    } else if (ev->key() == Qt::Key_Up) {
        Q_EMIT upPressed();
    } else {
        KPIM::AddresseeLineEdit::keyPressEvent(ev);
    }
}

AttendeeLine::AttendeeLine(QWidget *parent)
    : MultiplyingLine(parent)
    , mRoleCombo(new AttendeeComboBox(this))
    , mStateCombo(new AttendeeComboBox(this))
    , mResponseCombo(new AttendeeComboBox(this))
    , mEdit(new AttendeeLineEdit(this))
    , mData(new AttendeeData(QString(), QString()))
    , mModified(false)
{
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);

QBoxLayout *topLayout = new QHBoxLayout(this);
    topLayout->setMargin(0);
    mRoleCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant")),
                        KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::ReqParticipant));
    mRoleCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant-optional")),
                        KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::OptParticipant));
    mRoleCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-observer")),
                        KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::NonParticipant));
    mRoleCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-chair")),
                        KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::Chair));

mResponseCombo->addItem(QIcon::fromTheme(QStringLiteral(
                                                 "meeting-participant-request-response")),
                            i18nc("@item:inlistbox", "Request Response"));
    mResponseCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant-no-response")),
                            i18nc("@item:inlistbox", "Request No Response"));

mEdit->setToolTip(i18nc("@info:tooltip",
                            "Enter the name or email address of the attendee."));
    mEdit->setClearButtonShown(true);

mStateCombo->setWhatsThis(i18nc("@info:whatsthis",
                                    "Edits the current attendance status of the attendee."));

mRoleCombo->setWhatsThis(i18nc("@info:whatsthis",
                                   "Edits the role of the attendee."));

mEdit->setWhatsThis(i18nc("@info:whatsthis",
                              "The email address or name of the attendee. An invitation "
                              "can be sent to the user if an email address is provided."));

setActions(EventActions);

mResponseCombo->setToolTip(i18nc("@info:tooltip", "Request a response from the attendee"));
    mResponseCombo->setWhatsThis(i18nc("@info:whatsthis",
                                       "Edits whether to send an email to the "
                                       "attendee to request a response concerning "
                                       "attendance."));

// add them to the layout in the correct order
    topLayout->addWidget(mRoleCombo);
    topLayout->addWidget(mEdit);
    topLayout->addWidget(mStateCombo);
    topLayout->addWidget(mResponseCombo);

connect(mEdit, &AttendeeLineEdit::returnPressed, this, &AttendeeLine::slotReturnPressed);
    connect(mEdit, &AttendeeLineEdit::deleteMe, this, &AttendeeLine::slotPropagateDeletion,
            Qt::QueuedConnection);
    connect(mEdit, &AttendeeLineEdit::textChanged, this, &AttendeeLine::slotTextChanged,
            Qt::QueuedConnection);
    connect(mEdit, &AttendeeLineEdit::upPressed, this, &AttendeeLine::slotFocusUp);
    connect(mEdit, &AttendeeLineEdit::downPressed, this, &AttendeeLine::slotFocusDown);

connect(mRoleCombo, &AttendeeComboBox::rightPressed, mEdit,
            static_cast<void (AttendeeLineEdit::*)()>(&AttendeeLineEdit::setFocus));
    connect(mEdit, &AttendeeLineEdit::leftPressed, mRoleCombo,
            static_cast<void (AttendeeComboBox::*)()>(&AttendeeComboBox::setFocus));

connect(mEdit, &AttendeeLineEdit::rightPressed, mStateCombo,
            static_cast<void (AttendeeComboBox::*)()>(&AttendeeComboBox::setFocus));
    connect(mStateCombo, &AttendeeComboBox::leftPressed, mEdit,
            static_cast<void (AttendeeLineEdit::*)()>(&AttendeeLineEdit::setFocus));

connect(mStateCombo, &AttendeeComboBox::rightPressed, mResponseCombo,
            static_cast<void (AttendeeComboBox::*)()>(&AttendeeComboBox::setFocus));

connect(mResponseCombo, &AttendeeComboBox::leftPressed, mStateCombo,
            static_cast<void (AttendeeComboBox::*)()>(&AttendeeComboBox::setFocus));
    connect(mResponseCombo, &AttendeeComboBox::rightPressed, this, &AttendeeLine::rightPressed);

connect(mEdit, &AttendeeLineEdit::editingFinished, this, &AttendeeLine::slotHandleChange,
            Qt::QueuedConnection);
    connect(mEdit, &AttendeeLineEdit::textCompleted, this, &AttendeeLine::slotHandleChange,
            Qt::QueuedConnection);
    connect(mEdit, &AttendeeLineEdit::clearButtonClicked, this,
            &AttendeeLine::slotPropagateDeletion, Qt::QueuedConnection);

connect(mRoleCombo, &AttendeeComboBox::itemChanged, this, &AttendeeLine::slotComboChanged);
    connect(mStateCombo, &AttendeeComboBox::itemChanged, this, &AttendeeLine::slotComboChanged);
    connect(mResponseCombo, &AttendeeComboBox::itemChanged, this, &AttendeeLine::slotComboChanged);
}

void AttendeeLine::activate()
{
    mEdit->setFocus();
}

void AttendeeLine::clear()
{
    mEdit->clear();
    mRoleCombo->setCurrentIndex(0);
    mStateCombo->setCurrentIndex(0);
    mResponseCombo->setCurrentIndex(0);
    mUid.clear();
}

void AttendeeLine::clearModified()
{
    mModified = false;
    mEdit->setModified(false);
}

KPIM::MultiplyingLineData::Ptr AttendeeLine::data() const
{
    if (isModified()) {
        const_cast<AttendeeLine *>(this)->dataFromFields();
    }
    return mData;
}

void AttendeeLine::dataFromFields()
{
    if (!mData) {
        return;
    }

KCalCore::Attendee::Ptr oldAttendee(mData->attendee());

QString email, name;
    KEmailAddress::extractEmailAddressAndName(mEdit->text(), email, name);

mData->setName(name);
    mData->setEmail(email);

mData->setRole(AttendeeData::Role(mRoleCombo->currentIndex()));
    mData->setStatus(AttendeeData::PartStat(mStateCombo->currentIndex()));
    mData->setRSVP(mResponseCombo->currentIndex() == 0);
    mData->setUid(mUid);

clearModified();
    if (!(oldAttendee == mData->attendee()) && !email.isEmpty()) {
        // if email is empty, we don't want to update anything
        qCDebug(INCIDENCEEDITOR_LOG) << oldAttendee->email() << mData->email();
        Q_EMIT changed(oldAttendee, mData->attendee());
    }
}

void AttendeeLine::fieldsFromData()
{
    if (!mData) {
        return;
    }

mEdit->setText(mData->fullName());
    mRoleCombo->setCurrentIndex(mData->role());
    AttendeeData::PartStat partStat = mData->status();
    if (partStat != AttendeeData::None) {
        mStateCombo->setCurrentIndex(partStat);
    } else {
        mStateCombo->setCurrentIndex(AttendeeData::NeedsAction);
    }
    mResponseCombo->setCurrentIndex(mData->RSVP() ? 0 : 1);
    mUid = mData->uid();
}

void AttendeeLine::fixTabOrder(QWidget *previous)
{
    setTabOrder(previous, mRoleCombo);
    setTabOrder(mRoleCombo, mEdit);
    setTabOrder(mEdit, mStateCombo);
    setTabOrder(mStateCombo, mResponseCombo);
}

QWidget *AttendeeLine::tabOut() const
{
    return mResponseCombo;
}

bool AttendeeLine::isActive() const
{
    return mEdit->hasFocus();
}

bool AttendeeLine::isEmpty() const
{
    return mEdit->text().isEmpty();
}

bool AttendeeLine::isModified() const
{
    return mModified || mEdit->isModified();
}

int AttendeeLine::setColumnWidth(int w)
{
    w = qMax(w, mRoleCombo->sizeHint().width());
    mRoleCombo->setFixedWidth(w);
    mRoleCombo->updateGeometry();
    parentWidget()->updateGeometry();
    return w;
}

void AttendeeLine::setActions(AttendeeActions actions)
{
    mStateCombo->clear();
    return;
    if (actions == EventActions) {
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-attention")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::NeedsAction));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-accepted")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Accepted));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-reject")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Declined));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-attempt")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Tentative));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-delegate")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Delegated));
    } else {
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-attention")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::NeedsAction));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-accepted")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Accepted));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-reject")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Declined));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-attempt")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Tentative));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-delegate")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Delegated));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-complete")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::Completed));
        mStateCombo->addItem(QIcon::fromTheme(QStringLiteral("task-ongoing")),
                             KCalUtils::Stringify::attendeeStatus(AttendeeData::InProcess));
    }
}

void AttendeeLine::setCompletionMode(KCompletion::CompletionMode mode)
{
    mEdit->setCompletionMode(mode);
}

void AttendeeLine::setData(const KPIM::MultiplyingLineData::Ptr &data)
{
    AttendeeData::Ptr attendee = qSharedPointerDynamicCast<AttendeeData>(data);
    if (!attendee) {
        return;
    }
    mData = attendee;
    fieldsFromData();
}

void AttendeeLine::slotHandleChange()
{
    if (mEdit->text().isEmpty()) {
        Q_EMIT deleteLine(this);
    } else {
        // has bad side-effects, and I have no idea what this was supposed to be doing
//    mEdit->setCursorPosition( 0 );
        Q_EMIT editingFinished(this);
        dataFromFields();
    }
}

void AttendeeLine::slotTextChanged(const QString &str)
{
    Q_UNUSED(str);
    mModified = true;
    Q_EMIT changed(); // TODO: This doesn't seem connected to anywhere in incidenceattendee.cpp.
    // but the important code is run in slotHandleChange() anyway so we don't see any bug
}

void AttendeeLine::slotComboChanged()
{
    mModified = true;
    // If mUid is empty, we're still populating the widget, don't write fields to data yet
    if (!mUid.isEmpty()) {
        dataFromFields();
    }
}

void AttendeeLine::aboutToBeDeleted()
{
    if (!mData) {
        return;
    }

Q_EMIT changed(mData->attendee(),
                   KCalCore::Attendee::Ptr(new KCalCore::Attendee(QLatin1String(""),
                                                                  QLatin1String(""))));
}

bool AttendeeLine::canDeleteLineEdit() const
{
    return mEdit->canDeleteLineEdit();
}
07070111A000EC000081A40000000200000002000000015AA55A8600000E98000000FD0000001000000000000000000000004600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeeline.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_ATTENDEELINE_H
#define INCIDENCEEDITOR_ATTENDEELINE_H

#include <LibkdepimAkonadi/AddresseeLineEdit>
#include <Libkdepim/MultiplyingLine>

#include <KCalCore/Attendee>

#include <QCheckBox>
#include <QToolButton>

class QKeyEvent;

namespace IncidenceEditorNG {
class AttendeeData;

class AttendeeComboBox : public QToolButton
{
    Q_OBJECT
public:
    explicit AttendeeComboBox(QWidget *parent);

void addItem(const QIcon &icon, const QString &text);
    void addItems(const QStringList &texts);

int currentIndex() const;

Q_SIGNALS:
    void rightPressed();
    void leftPressed();
    void itemChanged();

public Q_SLOTS:
    /** Clears the combobox, removing all items. */
    void clear();
    void setCurrentIndex(int index);

protected:
    void keyPressEvent(QKeyEvent *ev) override;

private:
    void slotActionTriggered();
    QMenu *mMenu = nullptr;
    QVector<QPair<QString, QIcon> > mList;
    int mCurrentIndex;
};

class AttendeeLineEdit : public KPIM::AddresseeLineEdit
{
    Q_OBJECT
public:
    explicit AttendeeLineEdit(QWidget *parent);

Q_SIGNALS:
    void deleteMe();
    void leftPressed();
    void rightPressed();
    void upPressed();
    void downPressed();

protected:
    void keyPressEvent(QKeyEvent *ev) override;
};

class AttendeeLine : public KPIM::MultiplyingLine
{
    Q_OBJECT
public:
    enum AttendeeActions {
        EventActions,
        TodoActions
    };

explicit AttendeeLine(QWidget *parent);
    virtual ~AttendeeLine()
    {
    }

void activate() override;
    bool isActive() const override;

bool isEmpty() const override;
    void clear() override;

bool isModified() const override;
    void clearModified() override;

KPIM::MultiplyingLineData::Ptr data() const override;
    void setData(const KPIM::MultiplyingLineData::Ptr &data) override;

void fixTabOrder(QWidget *previous) override;
    QWidget *tabOut() const override;

void setCompletionMode(KCompletion::CompletionMode) override;

int setColumnWidth(int w) override;

void aboutToBeDeleted() override;
    bool canDeleteLineEdit() const override;

void setActions(AttendeeActions actions);

Q_SIGNALS:
    void changed();
    void changed(const KCalCore::Attendee::Ptr &oldAttendee,
                 const KCalCore::Attendee::Ptr &newAttendee);
    void editingFinished(KPIM::MultiplyingLine *);

private:
    void slotTextChanged(const QString &);
    void slotHandleChange();
    void slotComboChanged();
    void dataFromFields();
    void fieldsFromData();

AttendeeComboBox *mRoleCombo = nullptr;
    AttendeeComboBox *mStateCombo = nullptr;
    AttendeeComboBox *mResponseCombo = nullptr;
    AttendeeLineEdit *mEdit = nullptr;
    QSharedPointer<AttendeeData> mData;
    QString mUid;
    bool mModified;
};
}

#endif
07070111A000ED000081A40000000200000002000000015AA55A86000011AA000000FD0000001000000000000000000000005400000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeelineeditdelegate.cpp/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#include "attendeelineeditdelegate.h"

#include "attendeeline.h"

#include <KLocalizedString>

#include <QAbstractItemView>
#include <QHelpEvent>
#include <QToolTip>
#include <QWhatsThis>

using namespace IncidenceEditorNG;

AttendeeLineEditDelegate::AttendeeLineEditDelegate(QObject *parent)
    : QStyledItemDelegate(parent)
{
    mToolTip = i18nc("@info:tooltip",
                     "Enter the name or email address of the attendee.");
    mWhatsThis = i18nc("@info:whatsthis",
                       "The email address or name of the attendee. An invitation "
                       "can be sent to the user if an email address is provided.");
}

QWidget *AttendeeLineEditDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                                                const QModelIndex &index) const
{
    Q_UNUSED(option);
    Q_UNUSED(index);
    AttendeeLineEdit *editor = new AttendeeLineEdit(parent);
    connect(editor, &AttendeeLineEdit::leftPressed, this, &AttendeeLineEditDelegate::leftPressed);
    connect(editor, &AttendeeLineEdit::rightPressed, this, &AttendeeLineEditDelegate::rightPressed);
    editor->setToolTip(mToolTip);
    editor->setWhatsThis(mWhatsThis);
    editor->setCompletionMode(mCompletionMode);
    editor->setClearButtonShown(true);

return editor;
}

void AttendeeLineEditDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
{
    AttendeeLineEdit *lineedit = static_cast<AttendeeLineEdit *>(editor);
    lineedit->setText(index.model()->data(index, Qt::EditRole).toString());
}

void AttendeeLineEditDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
                                            const QModelIndex &index) const
{
    AttendeeLineEdit *lineedit = static_cast<AttendeeLineEdit *>(editor);
    model->setData(index, lineedit->text(), Qt::EditRole);
}

void AttendeeLineEditDelegate::updateEditorGeometry(QWidget *editor,
                                                    const QStyleOptionViewItem &option,
                                                    const QModelIndex &index) const
{
    Q_UNUSED(index);
    editor->setGeometry(option.rect);
}

void AttendeeLineEditDelegate::leftPressed()
{
    Q_EMIT closeEditor(
        static_cast<QWidget *>(QObject::sender()), QAbstractItemDelegate::EditPreviousItem);
}

void AttendeeLineEditDelegate::rightPressed()
{
    Q_EMIT closeEditor(
        static_cast<QWidget *>(QObject::sender()), QAbstractItemDelegate::EditNextItem);
}

void AttendeeLineEditDelegate::setCompletionMode(KCompletion::CompletionMode mode)
{
    mCompletionMode = mode;
}

bool AttendeeLineEditDelegate::helpEvent(QHelpEvent *event, QAbstractItemView *view,
                                         const QStyleOptionViewItem &option,
                                         const QModelIndex &index)
{
    if (!event || !view) {
        return false;
    }
    switch (event->type()) {
#ifndef QT_NO_TOOLTIP
    case QEvent::ToolTip:
    {
        QHelpEvent *he = static_cast<QHelpEvent *>(event);
        QToolTip::showText(he->globalPos(), mToolTip, view);
        return true;
    }
#endif
#ifndef QT_NO_WHATSTHIS
    case QEvent::QueryWhatsThis:
        return true;
    case QEvent::WhatsThis:
    {
        QHelpEvent *he = static_cast<QHelpEvent *>(event);
        QWhatsThis::showText(he->globalPos(), mWhatsThis, view);
        return true;
    }
#endif
    default:
        break;
    }
    return QStyledItemDelegate::helpEvent(event, view, option, index);
}
07070111A000EE000081A40000000200000002000000015AA55A8600000945000000FD0000001000000000000000000000005200000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeelineeditdelegate.h/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#ifndef INCIDENCEEDITOR_ATTENDEELINEEDITDELEGATE_H
#define INCIDENCEEDITOR_ATTENDEELINEEDITDELEGATE_H

#include <QStyledItemDelegate>
#include <QModelIndex>
#include <QString>

#include <KCompletion>

namespace IncidenceEditorNG {
/** show a AttendeeLineEdit as editor */
class AttendeeLineEditDelegate : public QStyledItemDelegate
{
    Q_OBJECT
public:
    explicit AttendeeLineEditDelegate(QObject *parent = nullptr);

virtual void setCompletionMode(KCompletion::CompletionMode mode);

public Q_SLOTS:
    bool helpEvent(QHelpEvent *event, QAbstractItemView *view, const QStyleOptionViewItem &option,
                   const QModelIndex &index) override;

private:
    void rightPressed();
    void leftPressed();
    QString mToolTip;
    QString mWhatsThis;
    KCompletion::CompletionMode mCompletionMode = KCompletion::CompletionPopup;
};
}

#endif
07070111A000EF000081A40000000200000002000000015AA55A860000259D000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeetablemodel.cpp/*
 *  Copyright (C) 2014 Sandro Knauß <knauss@kolabsys.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 "attendeetablemodel.h"

#include <KCalCore/Attendee>
#include <KEmailAddress>

#include <KLocalizedString>

using namespace IncidenceEditorNG;

AttendeeTableModel::AttendeeTableModel(const KCalCore::Attendee::List &attendees, QObject *parent)
    : QAbstractTableModel(parent)
    , mAttendeeList(attendees)
    , mKeepEmpty(false)
    , mRemoveEmptyLines(false)
{
}

int AttendeeTableModel::rowCount(const QModelIndex & /*parent*/) const
{
    return mAttendeeList.count();
}

int AttendeeTableModel::columnCount(const QModelIndex & /*parent*/) const
{
    return 8;
}

Qt::ItemFlags AttendeeTableModel::flags(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return Qt::ItemIsEnabled;
    }
    if (index.column() == Available || index.column() == Name || index.column() == Email) { //Available is read only
        return QAbstractTableModel::flags(index);
    } else {
        return QAbstractTableModel::flags(index) | Qt::ItemIsEditable;
    }
}

QVariant AttendeeTableModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        return QVariant();
    }

if (index.row() >= mAttendeeList.size()) {
        return QVariant();
    }

KCalCore::Attendee::Ptr attendee = mAttendeeList[index.row()];
    if (role == Qt::DisplayRole || role == Qt::EditRole) {
        switch (index.column()) {
        case Role:
            return attendee->role();
        case FullName:
            return attendee->fullName();
        case Available:
        {
            AvailableStatus available = mAttendeeAvailable[attendee];
            if (role == Qt::DisplayRole) {
                switch (available) {
                case Free:
                    return i18n("Free");
                case Busy:
                    return i18n("Busy");
                case Accepted:
                    return i18n("Accepted");
                case Unknown:
                    return i18n("Unknown");
                default:
                    return i18n("Unknown");
                }
            } else {
                return available;
            }
        }
        case Status:
            return attendee->status();
        case CuType:
            return attendee->cuType();
        case Response:
            return attendee->RSVP();
        case Name:
            return attendee->name();
        case Email:
            return attendee->email();
        }
    }
    if (role == AttendeeRole) {
        return QVariant::fromValue(attendee);
    }
    return QVariant();
}

bool AttendeeTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    QString email, name;
    if (index.isValid() && role == Qt::EditRole) {
        KCalCore::Attendee::Ptr attendee = mAttendeeList[index.row()];
        switch (index.column()) {
        case Role:
            attendee->setRole(static_cast<KCalCore::Attendee::Role>(value.toInt()));
            break;
        case FullName:
            if (mRemoveEmptyLines && value.toString().trimmed().isEmpty()) {
                // Do not remove last empty line if mKeepEmpty==true
                // (only works if initaly there is only one empty line)
                if (!mKeepEmpty || !(attendee->name().isEmpty() && attendee->email().isEmpty())) {
                    removeRows(index.row(), 1);
                    return true;
                }
            }
            KEmailAddress::extractEmailAddressAndName(value.toString(), email, name);
            attendee->setName(name);
            attendee->setEmail(email);

addEmptyAttendee();
            break;
        case Available:
            mAttendeeAvailable[attendee] = static_cast<AvailableStatus>(value.toInt());
            break;
        case Status:
            attendee->setStatus(static_cast<KCalCore::Attendee::PartStat>(value.toInt()));
            break;
        case CuType:
            attendee->setCuType(static_cast<KCalCore::Attendee::CuType>(value.toInt()));
            break;
        case Response:
            attendee->setRSVP(value.toBool());
            break;
        default:
            return false;
        }
        Q_EMIT dataChanged(index, index);
        return true;
    }
    return false;
}

QVariant AttendeeTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role != Qt::DisplayRole) {
        return QVariant();
    }

if (orientation == Qt::Horizontal) {
        switch (section) {
        case Role:
            return i18nc("vCard attendee role", "Role");
        case FullName:
            return i18nc("Attendees  (name+emailaddress)", "Name");
        case Available:
            return i18nc("Is attendee available for incidence", "Available");
        case Status:
            return i18nc("Status of attendee in an incidence (accepted, declined, delegated, ...)",
                         "Status");
        case CuType:
            return i18nc("Type of calendar user (vCard attribute)", "User Type");
        case Response:
            return i18nc("Has attendee to respond to the invitation", "Response");
        case Name:
            return i18nc("Attendee name", "Name");
        case Email:
            return i18nc("Attendee email", "Email");
        }
    }

return QVariant();
}

bool AttendeeTableModel::insertRows(int position, int rows, const QModelIndex &parent)
{
    beginInsertRows(parent, position, position + rows - 1);

for (int row = 0; row < rows; ++row) {
        KCalCore::Attendee::Ptr attendee(new KCalCore::Attendee(QLatin1String(""), QLatin1String("")));
        mAttendeeList.insert(position, attendee);
    }

endInsertRows();
    return true;
}

bool AttendeeTableModel::removeRows(int position, int rows, const QModelIndex &parent)
{
    beginRemoveRows(parent, position, position + rows - 1);

for (int row = 0; row < rows; ++row) {
        mAttendeeAvailable.remove(mAttendeeList.at(position));
        mAttendeeList.remove(position);
    }

endRemoveRows();
    return true;
}

bool AttendeeTableModel::insertAttendee(int position, const KCalCore::Attendee::Ptr &attendee)
{
    beginInsertRows(QModelIndex(), position, position);

mAttendeeList.insert(position, attendee);

endInsertRows();

addEmptyAttendee();

return true;
}

void AttendeeTableModel::setAttendees(const KCalCore::Attendee::List &attendees)
{
    Q_EMIT layoutAboutToBeChanged();

mAttendeeList = attendees;
    mAttendeeAvailable = QMap<KCalCore::Attendee::Ptr, AvailableStatus>();

addEmptyAttendee();

Q_EMIT layoutChanged();
}

KCalCore::Attendee::List AttendeeTableModel::attendees() const
{
    return mAttendeeList;
}

void AttendeeTableModel::addEmptyAttendee()
{
    if (mKeepEmpty) {
        bool create = true;
        for (const KCalCore::Attendee::Ptr &attendee : qAsConst(mAttendeeList)) {
            if (attendee->fullName().isEmpty()) {
                create = false;
                break;
            }
        }

if (create) {
            insertRows(rowCount(), 1);
        }
    }
}

bool AttendeeTableModel::keepEmpty() const
{
    return mKeepEmpty;
}

void AttendeeTableModel::setKeepEmpty(bool keepEmpty)
{
    if (keepEmpty != mKeepEmpty) {
        mKeepEmpty = keepEmpty;
        addEmptyAttendee();
    }
}

bool AttendeeTableModel::removeEmptyLines() const
{
    return mRemoveEmptyLines;
}

void AttendeeTableModel::setRemoveEmptyLines(bool removeEmptyLines)
{
    mRemoveEmptyLines = removeEmptyLines;
}

ResourceFilterProxyModel::ResourceFilterProxyModel(QObject *parent)
    : QSortFilterProxyModel(parent)
{
}

bool ResourceFilterProxyModel::filterAcceptsRow(int sourceRow,
                                                const QModelIndex &sourceParent) const
{
    QModelIndex cuTypeIndex = sourceModel()->index(sourceRow, AttendeeTableModel::CuType,
                                                   sourceParent);
    KCalCore::Attendee::CuType cuType
        = static_cast<KCalCore::Attendee::CuType>(sourceModel()->data(cuTypeIndex).toUInt());

return cuType == KCalCore::Attendee::Resource || cuType == KCalCore::Attendee::Room;
}

AttendeeFilterProxyModel::AttendeeFilterProxyModel(QObject *parent)
    : QSortFilterProxyModel(parent)
{
}

bool AttendeeFilterProxyModel::filterAcceptsRow(int sourceRow,
                                                const QModelIndex &sourceParent) const
{
    QModelIndex cuTypeIndex = sourceModel()->index(sourceRow, AttendeeTableModel::CuType,
                                                   sourceParent);
    KCalCore::Attendee::CuType cuType
        = static_cast<KCalCore::Attendee::CuType>(sourceModel()->data(cuTypeIndex).toUInt());

return !(cuType == KCalCore::Attendee::Resource || cuType == KCalCore::Attendee::Room);
}
07070111A000F0000081A40000000200000002000000015AA55A8600000D6D000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/attendeetablemodel.h/*
 *  Copyright (C) 2014 Sandro Knauß <knauss@kolabsys.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.
 */

#ifndef INCIDENCEEDITOR_ATTENDEETABLEMODEL_H
#define INCIDENCEEDITOR_ATTENDEETABLEMODEL_H

#include <KCalCore/Attendee>

#include <QAbstractTableModel>
#include <QSortFilterProxyModel>
#include <QModelIndex>

namespace IncidenceEditorNG {
class AttendeeTableModel : public QAbstractTableModel
{
    Q_OBJECT

public:
    enum Roles {
        AttendeeRole = Qt::UserRole
    };

enum Columns {
        CuType,
        Role,
        FullName,
        Name,
        Email,
        Available,
        Status,
        Response
    };

enum AvailableStatus {
        Unknown,
        Free,
        Accepted,
        Busy,
        Tentative
    };

explicit AttendeeTableModel(const KCalCore::Attendee::List &resources,
                                QObject *parent = nullptr);

int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    QVariant headerData(int section, Qt::Orientation orientation,
                        int role = Qt::DisplayRole) const override;

Qt::ItemFlags flags(const QModelIndex &index) const override;
    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;

bool insertRows(int position, int rows, const QModelIndex &index = QModelIndex()) override;
    bool removeRows(int position, int rows, const QModelIndex &index = QModelIndex()) override;

bool insertAttendee(int position, const KCalCore::Attendee::Ptr &attendee);

void setAttendees(const KCalCore::Attendee::List &resources);
    KCalCore::Attendee::List attendees() const;

void setKeepEmpty(bool keepEmpty);
    bool keepEmpty() const;

void setRemoveEmptyLines(bool removeEmptyLines);
    bool removeEmptyLines() const;
private:
    void addEmptyAttendee();

KCalCore::Attendee::List mAttendeeList;
    QMap<KCalCore::Attendee::Ptr, AvailableStatus> mAttendeeAvailable;
    bool mKeepEmpty;
    bool mRemoveEmptyLines;
};

class ResourceFilterProxyModel : public QSortFilterProxyModel
{
    Q_OBJECT
public:
    explicit ResourceFilterProxyModel(QObject *parent = nullptr);
    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
};

class AttendeeFilterProxyModel : public QSortFilterProxyModel
{
    Q_OBJECT
public:
    explicit AttendeeFilterProxyModel(QObject *parent = nullptr);
    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
};
}

#endif
07070111A000F1000081A40000000200000002000000015AA55A8600001168000000FD0000001000000000000000000000004F00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/autochecktreewidget.cpp/*
  Copyright (c) 2007 Mathias Soeken <msoeken@tzi.de>

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 "autochecktreewidget.h"

using namespace IncidenceEditorNG;

//@cond PRIVATE
class Q_DECL_HIDDEN AutoCheckTreeWidget::Private
{
public:
    Private()
        : mAutoCheckChildren(false)
        , mAutoCheck(true)
    {
    }

bool mAutoCheckChildren;
    bool mAutoCheck;
};
//@endcond

AutoCheckTreeWidget::AutoCheckTreeWidget(QWidget *parent)
    : QTreeWidget(parent)
    , d(new Private())
{
    connect(model(), &QAbstractItemModel::rowsInserted,
            this, &AutoCheckTreeWidget::slotRowsInserted);
    connect(model(), &QAbstractItemModel::dataChanged, this,
            &AutoCheckTreeWidget::slotDataChanged);

setColumnCount(2);
}

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

QTreeWidgetItem *AutoCheckTreeWidget::itemByPath(const QStringList &path) const
{
    QStringList newPath = path;
    QTreeWidgetItem *item = nullptr;

while (newPath.count()) {
        item = findItem(item, newPath.takeFirst());
        if (!item) {
            return nullptr;
        }
    }

return item;
}

QStringList AutoCheckTreeWidget::pathByItem(QTreeWidgetItem *item) const
{
    QStringList path;
    QTreeWidgetItem *current = item;

while (current) {
        path.prepend(current->text(0));
        current = current->parent();
    }

return path;
}

bool AutoCheckTreeWidget::autoCheckChildren() const
{
    return d->mAutoCheckChildren;
}

void AutoCheckTreeWidget::setAutoCheckChildren(bool autoCheckChildren)
{
    d->mAutoCheckChildren = autoCheckChildren;
}

bool AutoCheckTreeWidget::autoCheck() const
{
    return d->mAutoCheck;
}

void AutoCheckTreeWidget::setAutoCheck(bool autoCheck)
{
    d->mAutoCheck = autoCheck;
}

QTreeWidgetItem *AutoCheckTreeWidget::findItem(QTreeWidgetItem *parent, const QString &text) const
{
    if (parent) {
        const int nbChild{
            parent->childCount()
        };
        for (int i = 0; i < nbChild; ++i) {
            if (parent->child(i)->text(0) == text) {
                return parent->child(i);
            }
        }
    } else {
        for (int i = 0; i < topLevelItemCount(); ++i) {
            if (topLevelItem(i)->text(0) == text) {
                return topLevelItem(i);
            }
        }
    }

return nullptr;
}

void AutoCheckTreeWidget::slotRowsInserted(const QModelIndex &parent, int start, int end)
{
    if (d->mAutoCheck) {
        QTreeWidgetItem *item = itemFromIndex(parent);
        QTreeWidgetItem *child = nullptr;
        if (item) {
            QBrush b(Qt::yellow);
            item->setBackground(0, b);
            for (int i = start; i < qMax(end, item->childCount()); ++i) {
                child = item->child(i);
                child->setFlags(child->flags() | Qt::ItemIsUserCheckable);
                child->setCheckState(0, Qt::Unchecked);
            }
        } else { /* top level item has been inserted */
            for (int i = start; i < qMax(end, topLevelItemCount()); ++i) {
                child = topLevelItem(i);
                child->setFlags(child->flags() | Qt::ItemIsUserCheckable);
                child->setCheckState(0, Qt::Unchecked);
            }
        }
    }
}

void AutoCheckTreeWidget::slotDataChanged(const QModelIndex &topLeft,
                                          const QModelIndex &bottomRight)
{
    if (!d->mAutoCheckChildren) {
        return;
    }

QTreeWidgetItem *item1 = itemFromIndex(topLeft);
    QTreeWidgetItem *item2 = itemFromIndex(bottomRight);

if (item1 == item2) {
        for (int i = 0; i < item1->childCount(); ++i) {
            item1->child(i)->setCheckState(0, item1->checkState(0));
        }
    }
}
07070111A000F2000081A40000000200000002000000015AA55A8600000D2D000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/autochecktreewidget.h/*
  Copyright (c) 2007 Mathias Soeken <msoeken@tzi.de>

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 INCIDENCEEDITOR_AUTOCHECKTREEWIDGET_H
#define INCIDENCEEDITOR_AUTOCHECKTREEWIDGET_H

#include <QTreeWidget>

namespace IncidenceEditorNG {
/**
  A tree widget which supports auto selecting child items, when clicking
  an item of the tree.

Further you can find an item by passing a path as QStringList with
  the method itemByPath().

@author Mathias Soeken <msoeken@tzi.de>
*/
class AutoCheckTreeWidget : public QTreeWidget
{
    Q_OBJECT

Q_PROPERTY(bool autoCheckChildren READ autoCheckChildren WRITE setAutoCheckChildren)

Q_PROPERTY(bool autoCheck READ autoCheck WRITE setAutoCheck)

public:
    /**
      Default constructor. The default behavior is like a QTreeWidget, so you
      have to activate the autoCheckChildren property manually.
    */
    explicit AutoCheckTreeWidget(QWidget *parent = nullptr);

~AutoCheckTreeWidget();

/**
      Returns QTreeWidgetItem which matches the path, if available.

@param path The path
      @returns a item which is represented by the path, if available.
    */
    QTreeWidgetItem *itemByPath(const QStringList &path) const;

/**
      Returns a path by a given item as QStringList.

@param item The item
      @returns a string list which is the represented path of the item.
    */
    QStringList pathByItem(QTreeWidgetItem *item) const;

/**
      @returns whether autoCheckChildren is enabled or not.
               Default value is false.
    */
    bool autoCheckChildren() const;

/**
      enables or disables autoCheckChildren behavior.

@param autoCheckChildren if true, children of items are auto checked or
                               not, otherwise. Default value is false.
    */
    void setAutoCheckChildren(bool autoCheckChildren);

/**
      @returns whether newly added items have checkboxes by default.
               Default value is true.
    */
    bool autoCheck() const;

/**
      Sets whether newly added items have checkboxes by default.

@param autoCheck if true, newly added items have unchecked checkboxes
                       by default, otherwise not. Default value is true.
    */
    void setAutoCheck(bool autoCheck);

protected:
    QTreeWidgetItem *findItem(QTreeWidgetItem *parent, const QString &text) const;

protected Q_SLOTS:
    void slotRowsInserted(const QModelIndex &parent, int start, int end);
    void slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
}

#endif
07070111A000F3000081A40000000200000002000000015AA55A8600002748000000FD0000001000000000000000000000004A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/categorydialog.cpp/*
  Copyright (c) 2000, 2001, 2002 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.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 "categorydialog.h"
#include "categoryhierarchyreader.h"
#include "ui_categorydialog_base.h"

#include <CalendarSupport/KCalPrefs>
#include <CalendarSupport/CategoryConfig>

#include <QIcon>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>

using namespace IncidenceEditorNG;
using namespace CalendarSupport;

class CategoryWidgetBase : public QWidget, public Ui::CategoryDialog_base
{
public:
    CategoryWidgetBase(QWidget *parent) : QWidget(parent)
    {
        setupUi(this);
    }
};

CategoryWidget::CategoryWidget(CategoryConfig *cc, QWidget *parent)
    : QWidget(parent)
    , mCategoryConfig(cc)
{
    QHBoxLayout *topL = new QHBoxLayout(this);
    topL->setMargin(0);
    mWidgets = new CategoryWidgetBase(this);
    topL->addWidget(mWidgets);

mWidgets->mButtonAdd->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
    mWidgets->mButtonRemove->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
    mWidgets->mLineEdit->setPlaceholderText(i18n("Click to add a new category"));

connect(mWidgets->mLineEdit, &QLineEdit::textChanged,
            this, &CategoryWidget::handleTextChanged);

mWidgets->mButtonAdd->setEnabled(false);
    mWidgets->mButtonRemove->setEnabled(false);
    mWidgets->mColorCombo->setEnabled(false);

connect(mWidgets->mCategories, &QTreeWidget::itemSelectionChanged,
            this, &CategoryWidget::handleSelectionChanged);

connect(mWidgets->mButtonAdd, &QAbstractButton::clicked,
            this, &CategoryWidget::addCategory);

connect(mWidgets->mButtonRemove, &QAbstractButton::clicked,
            this, &CategoryWidget::removeCategory);

connect(mWidgets->mColorCombo, &KColorCombo::activated,
            this, &CategoryWidget::handleColorChanged);
}

CategoryWidget::~CategoryWidget()
{
}

AutoCheckTreeWidget *CategoryWidget::listView() const
{
    return mWidgets->mCategories;
}

void CategoryWidget::hideButton()
{
}

void CategoryWidget::setCategories(const QStringList &categoryList)
{
    mWidgets->mCategories->clear();
    mCategoryList.clear();

QStringList cats = mCategoryConfig->customCategories();
    for (QStringList::ConstIterator it = categoryList.begin(), end = categoryList.end(); it != end;
         ++it) {
        if (!cats.contains(*it)) {
            cats.append(*it);
        }
    }
    mCategoryConfig->setCustomCategories(cats);
    CategoryHierarchyReaderQTreeWidget(mWidgets->mCategories).read(cats);
}

void CategoryWidget::setSelected(const QStringList &selList)
{
    clear();
    const bool remAutoCheckChildren = mWidgets->mCategories->autoCheckChildren();
    mWidgets->mCategories->setAutoCheckChildren(false);
    for (QStringList::ConstIterator it = selList.begin(), end = selList.end(); it != end; ++it) {
        QStringList path = CategoryHierarchyReader::path(*it);
        QTreeWidgetItem *item = mWidgets->mCategories->itemByPath(path);
        if (item) {
            item->setCheckState(0, Qt::Checked);
        }
    }
    mWidgets->mCategories->setAutoCheckChildren(remAutoCheckChildren);
}

static QStringList getSelectedCategories(AutoCheckTreeWidget *categoriesView)
{
    QStringList categories;

QTreeWidgetItemIterator it(categoriesView, QTreeWidgetItemIterator::Checked);
    while (*it) {
        QStringList path = categoriesView->pathByItem(*it++);
        if (path.count()) {
            path.replaceInStrings(CategoryConfig::categorySeparator, QLatin1Char('\\')
                                  +CategoryConfig::categorySeparator);
            categories.append(path.join(CategoryConfig::categorySeparator));
        }
    }

return categories;
}

void CategoryWidget::clear()
{
    const bool remAutoCheckChildren = mWidgets->mCategories->autoCheckChildren();
    mWidgets->mCategories->setAutoCheckChildren(false);

QTreeWidgetItemIterator it(mWidgets->mCategories);
    while (*it) {
        (*it++)->setCheckState(0, Qt::Unchecked);
    }

mWidgets->mCategories->setAutoCheckChildren(remAutoCheckChildren);
}

void CategoryWidget::setAutoselectChildren(bool autoselectChildren)
{
    mWidgets->mCategories->setAutoCheckChildren(autoselectChildren);
}

void CategoryWidget::hideHeader()
{
    mWidgets->mCategories->header()->hide();
}

QStringList CategoryWidget::selectedCategories(QString &categoriesStr)
{
    mCategoryList = getSelectedCategories(listView());
    categoriesStr = mCategoryList.join(QStringLiteral(", "));
    return mCategoryList;
}

QStringList CategoryWidget::selectedCategories() const
{
    return mCategoryList;
}

void CategoryWidget::setCategoryList(const QStringList &categories)
{
    mCategoryList = categories;
}

void CategoryWidget::addCategory()
{
    QTreeWidgetItem *newItem = new QTreeWidgetItem(listView(),
                                                   QStringList(mWidgets->mLineEdit->text()));
    listView()->scrollToItem(newItem);
    listView()->clearSelection();
    newItem->setSelected(true);
}

void CategoryWidget::removeCategory()
{
    // Multi-select not supported, only one selected
    QTreeWidgetItem *itemToDelete = listView()->selectedItems().first();
    delete itemToDelete;
}

void CategoryWidget::handleTextChanged(const QString &newText)
{
    mWidgets->mButtonAdd->setEnabled(!newText.isEmpty());
}

void CategoryWidget::handleSelectionChanged()
{
    const bool hasSelection = !listView()->selectedItems().isEmpty();
    mWidgets->mButtonRemove->setEnabled(hasSelection);
    mWidgets->mColorCombo->setEnabled(hasSelection);

if (hasSelection) {
        const QTreeWidgetItem *item = listView()->selectedItems().first();
        const QColor &color = KCalPrefs::instance()->categoryColor(item->text(0));
        if (color.isValid()) {
            mWidgets->mColorCombo->setColor(color);
            // update is needed. bug in KColorCombo?
            mWidgets->mColorCombo->update();
        }
    }
}

void CategoryWidget::handleColorChanged(const QColor &newColor)
{
    if (!listView()->selectedItems().isEmpty()) {
        const QTreeWidgetItem *item = listView()->selectedItems().first();
        const QString category = item->text(0);
        if (newColor.isValid()) {
            KCalPrefs::instance()->setCategoryColor(category, newColor);
        }
    }
}

CategoryDialog::CategoryDialog(CategoryConfig *cc, QWidget *parent)
    : QDialog(parent)
    , d(nullptr)
{
    setWindowTitle(i18n("Select Categories"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QDialogButtonBox *buttonBox = new QDialogButtonBox(
        QDialogButtonBox::Ok | QDialogButtonBox::Cancel /*| QDialogButtonBox::Help*/ | QDialogButtonBox::Apply,
        this);

QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setDefault(true);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &CategoryDialog::reject);

QWidget *page = new QWidget;
    mainLayout->addWidget(page);
    mainLayout->addWidget(buttonBox);
    QVBoxLayout *lay = new QVBoxLayout(page);
    lay->setMargin(0);

mWidgets = new CategoryWidget(cc, this);
    mCategoryConfig = cc;
    mWidgets->setObjectName(QStringLiteral("CategorySelection"));
    mWidgets->hideHeader();
    lay->addWidget(mWidgets);

mWidgets->setCategories();
    mWidgets->listView()->setFocus();

connect(okButton, &QPushButton::clicked, this, &CategoryDialog::slotOk);
    connect(buttonBox->button(
                QDialogButtonBox::Apply), &QPushButton::clicked, this, &CategoryDialog::slotApply);
}

CategoryDialog::~CategoryDialog()
{
    delete mWidgets;
}

QStringList CategoryDialog::selectedCategories() const
{
    return mWidgets->selectedCategories();
}

void CategoryDialog::slotApply()
{
    QStringList l;

QStringList path;
    QTreeWidgetItemIterator it(mWidgets->listView());
    while (*it) {
        path = mWidgets->listView()->pathByItem(*it++);
        path.replaceInStrings(
            CategoryConfig::categorySeparator,
            QLatin1Char('\\') + CategoryConfig::categorySeparator);
        l.append(path.join(CategoryConfig::categorySeparator));
    }
    mCategoryConfig->setCustomCategories(l);
    mCategoryConfig->writeConfig();

QString categoriesStr;
    QStringList categories = mWidgets->selectedCategories(categoriesStr);
    Q_EMIT categoriesSelected(categories);
    Q_EMIT categoriesSelected(categoriesStr);
}

void CategoryDialog::slotOk()
{
    slotApply();
    accept();
}

void CategoryDialog::updateCategoryConfig()
{
    QString tmp;
    QStringList selected = mWidgets->selectedCategories(tmp);
    mWidgets->setCategories();
    mWidgets->setSelected(selected);
}

void CategoryDialog::setAutoselectChildren(bool autoselectChildren)
{
    mWidgets->setAutoselectChildren(autoselectChildren);
}

void CategoryDialog::setCategoryList(const QStringList &categories)
{
    mWidgets->setCategoryList(categories);
}

void CategoryDialog::setSelected(const QStringList &selList)
{
    mWidgets->setSelected(selList);
}
07070111A000F4000081A40000000200000002000000015AA55A8600000BFE000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/categorydialog.h/*
  Copyright (c) 2000, 2001, 2002 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.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.
*/

#ifndef INCIDENCEEDITOR_CATEGORYDIALOG_H
#define INCIDENCEEDITOR_CATEGORYDIALOG_H

#include <QDialog>

class CategoryWidgetBase;

namespace CalendarSupport {
class CategoryConfig;
}

namespace IncidenceEditorNG {
class AutoCheckTreeWidget;

class CategoryWidget : public QWidget
{
    Q_OBJECT
public:
    explicit CategoryWidget(CalendarSupport::CategoryConfig *config, QWidget *parent = nullptr);
    ~CategoryWidget();

void setCategories(const QStringList &categoryList = QStringList());
    void setCategoryList(const QStringList &categories);

void setSelected(const QStringList &selList);
    QStringList selectedCategories() const;
    QStringList selectedCategories(QString &categoriesStr);

void setAutoselectChildren(bool autoselectChildren);

void hideButton();
    void hideHeader();

AutoCheckTreeWidget *listView() const;

public Q_SLOTS:
    void clear();

private:
    void handleTextChanged(const QString &newText);
    void handleSelectionChanged();
    void handleColorChanged(const QColor &);
    void addCategory();
    void removeCategory();
    QStringList mCategoryList;
    CategoryWidgetBase *mWidgets = nullptr;
    CalendarSupport::CategoryConfig *mCategoryConfig = nullptr;
};

class CategoryDialog : public QDialog
{
    Q_OBJECT
public:
    explicit CategoryDialog(CalendarSupport::CategoryConfig *cfg, QWidget *parent = nullptr);
    ~CategoryDialog();

QStringList selectedCategories() const;
    void setCategoryList(const QStringList &categories);

void setAutoselectChildren(bool autoselectChildren);
    void setSelected(const QStringList &selList);

public Q_SLOTS:
    void slotOk();
    void slotApply();
    void updateCategoryConfig();

Q_SIGNALS:
    void categoriesSelected(const QString &);
    void categoriesSelected(const QStringList &);

private:
    CategoryWidget *mWidgets = nullptr;
    CalendarSupport::CategoryConfig *mCategoryConfig = nullptr;
    class CategorySelectDialogPrivate;
    CategorySelectDialogPrivate *d;
};
}

#endif
07070111A000F5000081A40000000200000002000000015AA55A86000023D3000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/categoryeditdialog.cpp/*
  Copyright (c) 2000, 2001, 2002 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
  Copyright (c) 2005 Rafal Rzepecki <divide@users.sourceforge.net>
  Copyright (c) 2012 Allen Winter <winter@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 "categoryeditdialog.h"

#include "ui_categoryeditdialog_base.h"

#include <CalendarSupport/CategoryHierarchyReader>
#include <CalendarSupport/CategoryConfig>

#include <KLocalizedString>
#include <QIcon>

#include <QHeaderView>
#include <QList>
#include <QStringList>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>

using namespace IncidenceEditorNG;
using namespace CalendarSupport;

CategoryEditDialog::CategoryEditDialog(CategoryConfig *categoryConfig, QWidget *parent)
    : QDialog(parent)
    , mCategoryConfig(categoryConfig)
{
    setWindowTitle(i18n("Edit Categories"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QDialogButtonBox *buttonBox = new QDialogButtonBox(
        QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Help, this);
    QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setDefault(true);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &CategoryEditDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &CategoryEditDialog::reject);
    mWidgets = new Ui::CategoryEditDialog_base();
    QWidget *widget = new QWidget(this);
    widget->setObjectName(QStringLiteral("CategoryEdit"));
    mWidgets->setupUi(widget);

mWidgets->mCategories->header()->hide();
    mWidgets->mButtonAdd->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));

mWidgets->mButtonAddSubcategory->setEnabled(false);
    mWidgets->mButtonAddSubcategory->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));

mWidgets->mButtonRemove->setEnabled(false);
    mWidgets->mButtonRemove->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));

mWidgets->mCategories->setDragDropMode(QAbstractItemView::InternalMove);

// unfortunately, kde-core-devel will not allow this code in QDialog
    // because these button's functionality cannot be easily generalized.
    okButton->setToolTip(i18n("Apply changes and close"));
    okButton->setWhatsThis(i18n("When clicking <b>Ok</b>, "
                                "the settings will be handed over to the "
                                "program and the dialog will be closed."));
    buttonBox->button(QDialogButtonBox::Cancel)->setToolTip(i18n("Cancel changes and close"));
    buttonBox->button(QDialogButtonBox::Cancel)->setWhatsThis(i18n("When clicking <b>Cancel</b>, "
                                                                   "the settings will be discarded and the "
                                                                   "dialog will be closed."));

buttonBox->button(QDialogButtonBox::Help)->setWhatsThis(i18n("When clicking <b>Help</b>, "
                                                                 "a separate KHelpCenter window will open "
                                                                 "providing more information about the settings."));

mainLayout->addWidget(widget);
    mainLayout->addWidget(buttonBox);

fillList();

mWidgets->mCategories->setFocus();

connect(mWidgets->mCategories, &IncidenceEditorNG::AutoCheckTreeWidget::itemSelectionChanged,
            this, &CategoryEditDialog::editItem);
    connect(mWidgets->mCategories, &IncidenceEditorNG::AutoCheckTreeWidget::itemSelectionChanged,
            this, &CategoryEditDialog::slotSelectionChanged);
    connect(mWidgets->mCategories, &IncidenceEditorNG::AutoCheckTreeWidget::itemCollapsed, this,
            &CategoryEditDialog::expandIfToplevel);
    connect(mWidgets->mEdit, &QLineEdit::textChanged, this, &CategoryEditDialog::slotTextChanged);
    connect(mWidgets->mButtonAdd, &QPushButton::clicked, this, &CategoryEditDialog::add);
    connect(mWidgets->mButtonAddSubcategory, &QPushButton::clicked, this,
            &CategoryEditDialog::addSubcategory);
    connect(mWidgets->mButtonRemove, &QPushButton::clicked, this, &CategoryEditDialog::remove);
    connect(okButton, &QPushButton::clicked, this, &CategoryEditDialog::slotOk);
    connect(buttonBox->button(
                QDialogButtonBox::Cancel), &QPushButton::clicked, this,
            &CategoryEditDialog::slotCancel);
}

CategoryEditDialog::~CategoryEditDialog()
{
    delete mWidgets;
}

void CategoryEditDialog::fillList()
{
    CalendarSupport::CategoryHierarchyReaderQTreeWidget(
        mWidgets->mCategories).read(mCategoryConfig->customCategories());
}

void CategoryEditDialog::slotTextChanged(const QString &text)
{
    QTreeWidgetItem *item = mWidgets->mCategories->currentItem();
    if (item) {
        item->setText(0, text);
    }
}

void CategoryEditDialog::slotSelectionChanged()
{
    bool enable = (!mWidgets->mCategories->selectedItems().isEmpty());
    mWidgets->mButtonAddSubcategory->setEnabled(enable);
    mWidgets->mButtonRemove->setEnabled(enable);
}

void CategoryEditDialog::add()
{
    QTreeWidgetItem *newItem
        = new QTreeWidgetItem(mWidgets->mCategories,
                              QStringList(i18n("New category")));
    newItem->setExpanded(true);

mWidgets->mCategories->setCurrentItem(newItem);
    mWidgets->mCategories->clearSelection();
    newItem->setSelected(true);
    mWidgets->mCategories->scrollToItem(newItem);
    mWidgets->mEdit->setFocus();
    mWidgets->mEdit->selectAll();
}

void CategoryEditDialog::addSubcategory()
{
    if (!mWidgets->mEdit->text().isEmpty()) {
        QTreeWidgetItem *newItem
            = new QTreeWidgetItem(mWidgets->mCategories->currentItem(),
                                  QStringList(i18n("New subcategory")));
        newItem->setExpanded(true);

mWidgets->mCategories->setCurrentItem(newItem);
        mWidgets->mCategories->clearSelection();
        newItem->setSelected(true);
        mWidgets->mCategories->scrollToItem(newItem);
        mWidgets->mEdit->setFocus();
        mWidgets->mEdit->selectAll();
    }
}

void CategoryEditDialog::remove()
{
    QList<QTreeWidgetItem *> to_remove = mWidgets->mCategories->selectedItems();
    while (!to_remove.isEmpty()) {
        deleteItem(to_remove.takeFirst(), to_remove);
    }

if (mWidgets->mCategories->currentItem()) {
        mWidgets->mCategories->currentItem()->setSelected(true);
    }
}

void CategoryEditDialog::deleteItem(QTreeWidgetItem *item, QList<QTreeWidgetItem *> &to_remove)
{
    if (!item) {
        return;
    }

for (int i = item->childCount() - 1; i >= 0; i--) {
        QTreeWidgetItem *child = item->child(i);
        to_remove.removeAll(child);
        deleteItem(child, to_remove);
    }
    delete item;
}

void CategoryEditDialog::slotOk()
{
    slotApply();
    accept();
}

void CategoryEditDialog::slotApply()
{
    QStringList l;

QStringList path;
    QTreeWidgetItemIterator it(mWidgets->mCategories);
    while (*it) {
        path = mWidgets->mCategories->pathByItem(*it++);
        path.replaceInStrings(
            CategoryConfig::categorySeparator,
            QLatin1Char('\\') + CategoryConfig::categorySeparator);
        l.append(path.join(CategoryConfig::categorySeparator));
    }
    mCategoryConfig->setCustomCategories(l);
    mCategoryConfig->writeConfig();

Q_EMIT categoryConfigChanged();
}

void CategoryEditDialog::slotCancel()
{
    reload();
}

void CategoryEditDialog::editItem()
{
    QList<QTreeWidgetItem *> to_edit = mWidgets->mCategories->selectedItems();
    if (!to_edit.isEmpty()) {
        QTreeWidgetItem *item = to_edit.first();
        if (item) {
            mWidgets->mEdit->setText(item->text(0));
        }
    }
}

void CategoryEditDialog::reload()
{
    fillList();
}

void CategoryEditDialog::show()
{
    /*
      QTreeWidgetItem *first = 0;
      if ( mWidgets->mCategories->topLevelItemCount() ) {
        first = mWidgets->mCategories->topLevelItem( 0 );
        mWidgets->mCategories->setCurrentItem( first );
      }
      mWidgets->mCategories->clearSelection();
      if ( first ) {
        first->setSelected( true );
        editItem( first );
      }
    */
    QDialog::show();
}

void CategoryEditDialog::expandIfToplevel(QTreeWidgetItem *item)
{
    if (!item->parent()) {
        item->setExpanded(true);
    }
}
07070111A000F6000081A40000000200000002000000015AA55A8600000856000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/categoryeditdialog.h/*
  Copyright (c) 2000, 2001, 2002 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
  Copyright (c) 2005 Rafal Rzepecki <divide@users.sourceforge.net>

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 INCIDENCEEDITOR_CATEGORYEDITDIALOG_H
#define INCIDENCEEDITOR_CATEGORYEDITDIALOG_H

#include <QDialog>

class QTreeWidgetItem;

namespace Ui {
class CategoryEditDialog_base;
}

namespace CalendarSupport {
class CategoryConfig;
}

namespace IncidenceEditorNG {
class CategoryEditDialog : public QDialog
{
    Q_OBJECT
public:
    explicit CategoryEditDialog(CalendarSupport::CategoryConfig *categoryConfig,
                                QWidget *parent = nullptr);

~CategoryEditDialog();

public Q_SLOTS:
    void reload();
    virtual void show();

protected Q_SLOTS:
    void slotOk();
    void slotApply();
    void slotCancel();
    void slotTextChanged(const QString &text);
    void slotSelectionChanged();
    void add();
    void addSubcategory();
    void remove();
    void editItem();
    void expandIfToplevel(QTreeWidgetItem *item);

Q_SIGNALS:
    void categoryConfigChanged();

protected:
    void fillList();

private:
    void deleteItem(QTreeWidgetItem *item, QList<QTreeWidgetItem *> &to_remove);
    CalendarSupport::CategoryConfig *mCategoryConfig = nullptr;
    Ui::CategoryEditDialog_base *mWidgets = nullptr;
};
}

#endif
07070111A000F7000081A40000000200000002000000015AA55A8600001E03000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/categoryselectdialog.cpp/*
  Copyright (c) 2000, 2001, 2002 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.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 "categoryselectdialog.h"
#include "categoryhierarchyreader.h"
#include "ui_categoryselectdialog_base.h"

#include <CalendarSupport/CategoryConfig>

#include <QIcon>
#include <KLocalizedString>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>

using namespace IncidenceEditorNG;
using namespace CalendarSupport;

class CategorySelectWidgetBase : public QWidget, public Ui::CategorySelectDialog_base
{
public:
    CategorySelectWidgetBase(QWidget *parent) : QWidget(parent)
    {
        setupUi(this);

mButtonClear->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-locationbar-rtl")));
        mButtonEdit->setIcon(QIcon::fromTheme(QStringLiteral("document-properties")));
    }
};

CategorySelectWidget::CategorySelectWidget(CategoryConfig *cc, QWidget *parent)
    : QWidget(parent)
    , mCategoryConfig(cc)
{
    QHBoxLayout *topL = new QHBoxLayout(this);
    topL->setMargin(0);
    mWidgets = new CategorySelectWidgetBase(this);
    topL->addWidget(mWidgets);
    connect(mWidgets->mButtonEdit, &QAbstractButton::clicked,
            this, &CategorySelectWidget::editCategories);
    connect(mWidgets->mButtonClear, &QAbstractButton::clicked,
            this, &CategorySelectWidget::clear);
}

CategorySelectWidget::~CategorySelectWidget()
{
}

AutoCheckTreeWidget *CategorySelectWidget::listView() const
{
    return mWidgets->mCategories;
}

void CategorySelectWidget::hideButton()
{
    mWidgets->mButtonEdit->hide();
    mWidgets->mButtonClear->hide();
}

void CategorySelectWidget::setCategories(const QStringList &categoryList)
{
    mWidgets->mCategories->clear();
    mCategoryList.clear();

void CategorySelectWidget::setSelected(const QStringList &selList)
{
    clear();
    bool remAutoCheckChildren = mWidgets->mCategories->autoCheckChildren();
    mWidgets->mCategories->setAutoCheckChildren(false);
    for (QStringList::ConstIterator it = selList.begin(), end = selList.end(); it != end; ++it) {
        QStringList path = CategoryHierarchyReader::path(*it);
        QTreeWidgetItem *item = mWidgets->mCategories->itemByPath(path);
        if (item) {
            item->setCheckState(0, Qt::Checked);
        }
    }
    mWidgets->mCategories->setAutoCheckChildren(remAutoCheckChildren);
}

static QStringList getSelectedCategoriesFromCategoriesView(AutoCheckTreeWidget *categoriesView)
{
    QStringList categories;

return categories;
}

void CategorySelectWidget::clear()
{
    bool remAutoCheckChildren = mWidgets->mCategories->autoCheckChildren();
    mWidgets->mCategories->setAutoCheckChildren(false);

QTreeWidgetItemIterator it(mWidgets->mCategories);
    while (*it) {
        (*it++)->setCheckState(0, Qt::Unchecked);
    }

mWidgets->mCategories->setAutoCheckChildren(remAutoCheckChildren);
}

void CategorySelectWidget::setAutoselectChildren(bool autoselectChildren)
{
    mWidgets->mCategories->setAutoCheckChildren(autoselectChildren);
}

void CategorySelectWidget::hideHeader()
{
    mWidgets->mCategories->header()->hide();
}

QStringList CategorySelectWidget::selectedCategories(QString &categoriesStr)
{
    mCategoryList = getSelectedCategoriesFromCategoriesView(listView());
    categoriesStr = mCategoryList.join(QStringLiteral(", "));
    return mCategoryList;
}

QStringList CategorySelectWidget::selectedCategories() const
{
    return mCategoryList;
}

void CategorySelectWidget::setCategoryList(const QStringList &categories)
{
    mCategoryList = categories;
}

CategorySelectDialog::CategorySelectDialog(CategoryConfig *cc, QWidget *parent)
    : QDialog(parent)
    , d(nullptr)
{
    setWindowTitle(i18n("Select Categories"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QDialogButtonBox *buttonBox = new QDialogButtonBox(
        QDialogButtonBox::Ok | QDialogButtonBox::Cancel /*| QDialogButtonBox::Help*/ | QDialogButtonBox::Apply,
        this);
    QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setDefault(true);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &CategorySelectDialog::reject);

QWidget *page = new QWidget;
    QVBoxLayout *lay = new QVBoxLayout(page);
    lay->setMargin(0);

mWidgets = new CategorySelectWidget(cc, this);
    mainLayout->addWidget(page);
    mainLayout->addWidget(buttonBox);
    mWidgets->setObjectName(QStringLiteral("CategorySelection"));
    mWidgets->hideHeader();
    lay->addWidget(mWidgets);

mWidgets->setCategories();
    mWidgets->listView()->setFocus();

connect(mWidgets, &CategorySelectWidget::editCategories, this,
            &CategorySelectDialog::editCategories);

connect(okButton, &QPushButton::clicked, this, &CategorySelectDialog::slotOk);
    connect(buttonBox->button(
                QDialogButtonBox::Apply), &QPushButton::clicked, this,
            &CategorySelectDialog::slotApply);
}

CategorySelectDialog::~CategorySelectDialog()
{
    delete mWidgets;
}

QStringList CategorySelectDialog::selectedCategories() const
{
    return mWidgets->selectedCategories();
}

void CategorySelectDialog::slotApply()
{
    QString categoriesStr;
    QStringList categories = mWidgets->selectedCategories(categoriesStr);
    Q_EMIT categoriesSelected(categories);
    Q_EMIT categoriesSelected(categoriesStr);
}

void CategorySelectDialog::slotOk()
{
    slotApply();
    accept();
}

void CategorySelectDialog::updateCategoryConfig()
{
    QString tmp;
    QStringList selected = mWidgets->selectedCategories(tmp);
    mWidgets->setCategories();
    mWidgets->setSelected(selected);
}

void CategorySelectDialog::setAutoselectChildren(bool autoselectChildren)
{
    mWidgets->setAutoselectChildren(autoselectChildren);
}

void CategorySelectDialog::setCategoryList(const QStringList &categories)
{
    mWidgets->setCategoryList(categories);
}

void CategorySelectDialog::setSelected(const QStringList &selList)
{
    mWidgets->setSelected(selList);
}
07070111A000F8000081A40000000200000002000000015AA55A8600000B1E000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/categoryselectdialog.h/*
  Copyright (c) 2000, 2001, 2002 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.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.
*/

#ifndef INCIDENCEEDITOR_CATEGORYSELECTDIALOG_H
#define INCIDENCEEDITOR_CATEGORYSELECTDIALOG_H

#include <QDialog>

class CategorySelectWidgetBase;

namespace CalendarSupport {
class CategoryConfig;
}

namespace IncidenceEditorNG {
class AutoCheckTreeWidget;

class CategorySelectWidget : public QWidget
{
    Q_OBJECT
public:
    explicit CategorySelectWidget(CalendarSupport::CategoryConfig *config,
                                  QWidget *parent = nullptr);
    ~CategorySelectWidget();

void setCategories(const QStringList &categoryList = QStringList());
    void setCategoryList(const QStringList &categories);

void setSelected(const QStringList &selList);
    QStringList selectedCategories() const;
    QStringList selectedCategories(QString &categoriesStr);

void setAutoselectChildren(bool autoselectChildren);

void hideButton();
    void hideHeader();

AutoCheckTreeWidget *listView() const;

public Q_SLOTS:
    void clear();

Q_SIGNALS:
    void editCategories();

private:
    QStringList mCategoryList;
    CategorySelectWidgetBase *mWidgets = nullptr;
    CalendarSupport::CategoryConfig *mCategoryConfig = nullptr;
};

class CategorySelectDialog : public QDialog
{
    Q_OBJECT
public:
    explicit CategorySelectDialog(CalendarSupport::CategoryConfig *cfg, QWidget *parent = nullptr);
    ~CategorySelectDialog();

QStringList selectedCategories() const;
    void setCategoryList(const QStringList &categories);

void setAutoselectChildren(bool autoselectChildren);
    void setSelected(const QStringList &selList);

public Q_SLOTS:
    void slotOk();
    void slotApply();
    void updateCategoryConfig();

Q_SIGNALS:
    void categoriesSelected(const QString &);
    void categoriesSelected(const QStringList &);
    void editCategories();

private:
    CategorySelectWidget *mWidgets = nullptr;

class CategorySelectDialogPrivate;
    CategorySelectDialogPrivate *d;
};
}

#endif
07070111A000F9000081A40000000200000002000000015AA55A8600001280000000FD0000001000000000000000000000005300000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/combinedincidenceeditor.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "combinedincidenceeditor.h"

#include "incidenceeditor_debug.h"

using namespace IncidenceEditorNG;

/// public methods

CombinedIncidenceEditor::CombinedIncidenceEditor(QWidget *parent)
    : IncidenceEditor(parent)
    , mDirtyEditorCount(0)
{
}

CombinedIncidenceEditor::~CombinedIncidenceEditor()
{
    qDeleteAll(mCombinedEditors);
}

void CombinedIncidenceEditor::combine(IncidenceEditor *other)
{
    Q_ASSERT(other);
    mCombinedEditors.append(other);
    connect(other, &IncidenceEditor::dirtyStatusChanged,
            this, &CombinedIncidenceEditor::handleDirtyStatusChange);
}

bool CombinedIncidenceEditor::isDirty() const
{
    return mDirtyEditorCount > 0;
}

bool CombinedIncidenceEditor::isValid() const
{
    foreach (IncidenceEditor *editor, mCombinedEditors) {
        if (!editor->isValid()) {
            const QString reason = editor->lastErrorString();
            editor->focusInvalidField();
            if (!reason.isEmpty()) {
                Q_EMIT showMessage(reason, KMessageWidget::Warning);
            }
            return false;
        }
    }

return true;
}

void CombinedIncidenceEditor::handleDirtyStatusChange(bool isDirty)
{
    const int prevDirtyCount = mDirtyEditorCount;

Q_ASSERT(mDirtyEditorCount >= 0);

if (isDirty) {
        ++mDirtyEditorCount;
    } else {
        --mDirtyEditorCount;
    }

Q_ASSERT(mDirtyEditorCount >= 0);

if (prevDirtyCount == 0) {
        Q_EMIT dirtyStatusChanged(true);
    }
    if (mDirtyEditorCount == 0) {
        Q_EMIT dirtyStatusChanged(false);
    }
}

void CombinedIncidenceEditor::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;
    foreach (IncidenceEditor *editor, mCombinedEditors) {
        // load() may fire dirtyStatusChanged(), reset mDirtyEditorCount to make sure
        // we don't end up with an invalid dirty count.
        editor->blockSignals(true);
        editor->load(incidence);
        editor->blockSignals(false);

if (editor->isDirty()) {
            // We are going to crash due to assert. Print some useful info before crashing.
            qCWarning(INCIDENCEEDITOR_LOG) << "Faulty editor was " << editor->objectName();
            qCWarning(INCIDENCEEDITOR_LOG) << "Incidence "
                                           << (incidence ? incidence->uid() : QStringLiteral("null"));

editor->printDebugInfo();

Q_ASSERT_X(false, "load", "editor shouldn't be dirty");
        }
    }

mWasDirty = false;
    mDirtyEditorCount = 0;
    Q_EMIT dirtyStatusChanged(false);
}

void CombinedIncidenceEditor::load(const Akonadi::Item &item)
{
    foreach (IncidenceEditor *editor, mCombinedEditors) {
        // load() may fire dirtyStatusChanged(), reset mDirtyEditorCount to make sure
        // we don't end up with an invalid dirty count.
        editor->blockSignals(true);
        editor->load(item);
        editor->blockSignals(false);

if (editor->isDirty()) {
            // We are going to crash due to assert. Print some useful info before crashing.
            qCWarning(INCIDENCEEDITOR_LOG) << "Faulty editor was " << editor->objectName();
            // qCWarning(INCIDENCEEDITOR_LOG) << "Incidence " << ( incidence ? incidence->uid() : "null" );

editor->printDebugInfo();

Q_ASSERT_X(false, "load", "editor shouldn't be dirty");
        }
    }

mWasDirty = false;
    mDirtyEditorCount = 0;
    Q_EMIT dirtyStatusChanged(false);
}

void CombinedIncidenceEditor::save(const KCalCore::Incidence::Ptr &incidence)
{
    foreach (IncidenceEditor *editor, mCombinedEditors) {
        editor->save(incidence);
    }
}

void CombinedIncidenceEditor::save(Akonadi::Item &item)
{
    foreach (IncidenceEditor *editor, mCombinedEditors) {
        editor->save(item);
    }
}
07070111A000FA000081A40000000200000002000000015AA55A8600000A06000000FD0000001000000000000000000000005100000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/combinedincidenceeditor.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 COMBINEDINCIDENCEEDITOR_H
#define COMBINEDINCIDENCEEDITOR_H

#include "incidenceeditor-ng.h"

#include <KMessageWidget>
#include <AkonadiCore/Item>

namespace IncidenceEditorNG {
/**
 * The CombinedIncidenceEditor combines optional widgets with zero or more
 * IncidenceEditors. The CombinedIncidenceEditor keeps track of the dirty state
 * of the IncidenceEditors that where combined.
 */
class CombinedIncidenceEditor : public IncidenceEditor
{
    Q_OBJECT
public:
    explicit CombinedIncidenceEditor(QWidget *parent = nullptr);
    /**
     * Deletes this editor as well as all editors which are combined into this
     * one.
     */
    ~CombinedIncidenceEditor();

void combine(IncidenceEditor *other);

/**
     * Returns whether or not the current values in the editor differ from the
     * initial values or if one of the combined editors is dirty.
     */
    bool isDirty() const override;
    bool isValid() const override;

/**
     * Loads all data from @param inicidence into the combined editors. Note, if
     * you reimplement the load method in a subclass, make sure to call this
     * implementation too.
     */
    void load(const KCalCore::Incidence::Ptr &incidence) override;
    void load(const Akonadi::Item &item) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    void save(Akonadi::Item &item) override;

Q_SIGNALS:
    void showMessage(const QString &reason, KMessageWidget::MessageType) const;

private:
    void handleDirtyStatusChange(bool isDirty);
    QVector<IncidenceEditor *> mCombinedEditors;
    int mDirtyEditorCount;
};
}

#endif // COMBINEDINCIDENCEEDITOR_H
07070111A000FB000081A40000000200000002000000015AA55A8600004C97000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/conflictresolver.cpp/*
  Copyright (c) 2000,2001,2004 Cornelius Schumacher <schumacher@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
  Copyright (c) 2010 Andras Mantia <andras@kdab.com>
  Copyright (C) 2010 Casey Link <casey@kdab.com>

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 "conflictresolver.h"
#include "CalendarSupport/FreeBusyItemModel"
#include "incidenceeditor_debug.h"

#include <QDate>

static const int DEFAULT_RESOLUTION_SECONDS = 15 * 60; // 15 minutes, 1 slot = 15 minutes

using namespace IncidenceEditorNG;

ConflictResolver::ConflictResolver(QWidget *parentWidget, QObject *parent)
    : QObject(parent)
    , mFBModel(new CalendarSupport::FreeBusyItemModel(this))
    , mParentWidget(parentWidget)
    , mWeekdays(7)
    , mSlotResolutionSeconds(DEFAULT_RESOLUTION_SECONDS)
{
    const QDateTime currentLocalDateTime = QDateTime::currentDateTime();
    mTimeframeConstraint = KCalCore::Period(currentLocalDateTime, currentLocalDateTime);

// trigger a reload in case any attendees were inserted before
    // the connection was made
    // triggerReload();

// set default values, all the days
    mWeekdays.setBit(0);   // Monday
    mWeekdays.setBit(1);
    mWeekdays.setBit(2);
    mWeekdays.setBit(3);
    mWeekdays.setBit(4);
    mWeekdays.setBit(5);
    mWeekdays.setBit(6);   // Sunday

mMandatoryRoles.reserve(4);
    mMandatoryRoles << KCalCore::Attendee::ReqParticipant
                    << KCalCore::Attendee::OptParticipant
                    << KCalCore::Attendee::NonParticipant
                    << KCalCore::Attendee::Chair;

connect(mFBModel, &CalendarSupport::FreeBusyItemModel::dataChanged, this,
            &ConflictResolver::freebusyDataChanged);

connect(&mCalculateTimer, &QTimer::timeout, this, &ConflictResolver::findAllFreeSlots);
    mCalculateTimer.setSingleShot(true);
}

void ConflictResolver::insertAttendee(const KCalCore::Attendee::Ptr &attendee)
{
    if (!mFBModel->containsAttendee(attendee)) {
        mFBModel->addItem(CalendarSupport::FreeBusyItem::Ptr(new CalendarSupport::FreeBusyItem(
                                                                 attendee, mParentWidget)));
    }
}

void ConflictResolver::insertAttendee(const CalendarSupport::FreeBusyItem::Ptr &freebusy)
{
    if (!mFBModel->containsAttendee(freebusy->attendee())) {
        mFBModel->addItem(freebusy);
    }
}

void ConflictResolver::removeAttendee(const KCalCore::Attendee::Ptr &attendee)
{
    mFBModel->removeAttendee(attendee);
    calculateConflicts();
}

void ConflictResolver::clearAttendees()
{
    mFBModel->clear();
}

bool ConflictResolver::containsAttendee(const KCalCore::Attendee::Ptr &attendee)
{
    return mFBModel->containsAttendee(attendee);
}

void ConflictResolver::setEarliestDate(const QDate &newDate)
{
    QDateTime newStart = mTimeframeConstraint.start();
    newStart.setDate(newDate);
    mTimeframeConstraint = KCalCore::Period(newStart, mTimeframeConstraint.end());
    calculateConflicts();
}

void ConflictResolver::setEarliestTime(const QTime &newTime)
{
    QDateTime newStart = mTimeframeConstraint.start();
    newStart.setTime(newTime);
    mTimeframeConstraint = KCalCore::Period(newStart, mTimeframeConstraint.end());
    calculateConflicts();
}

void ConflictResolver::setLatestDate(const QDate &newDate)
{
    QDateTime newEnd = mTimeframeConstraint.end();
    newEnd.setDate(newDate);
    mTimeframeConstraint = KCalCore::Period(mTimeframeConstraint.start(), newEnd);
    calculateConflicts();
}

void ConflictResolver::setLatestTime(const QTime &newTime)
{
    QDateTime newEnd = mTimeframeConstraint.end();
    newEnd.setTime(newTime);
    mTimeframeConstraint = KCalCore::Period(mTimeframeConstraint.start(), newEnd);
    calculateConflicts();
}

void ConflictResolver::setEarliestDateTime(const QDateTime &newDateTime)
{
    mTimeframeConstraint = KCalCore::Period(newDateTime, mTimeframeConstraint.end());
    calculateConflicts();
}

void ConflictResolver::setLatestDateTime(const QDateTime &newDateTime)
{
    mTimeframeConstraint = KCalCore::Period(mTimeframeConstraint.start(), newDateTime);
    calculateConflicts();
}

void ConflictResolver::freebusyDataChanged()
{
    calculateConflicts();
}

int ConflictResolver::tryDate(QDateTime &tryFrom, QDateTime &tryTo)
{
    int conflicts_count = 0;
    for (int i = 0; i < mFBModel->rowCount(); ++i) {
        QModelIndex index = mFBModel->index(i);
        KCalCore::Attendee::Ptr attendee
            = mFBModel->data(index,
                             CalendarSupport::FreeBusyItemModel::AttendeeRole).value<KCalCore::
                                                                                     Attendee::Ptr>();
        if (!matchesRoleConstraint(attendee)) {
            continue;
        }
        KCalCore::FreeBusy::Ptr freebusy
            = mFBModel->data(index,
                             CalendarSupport::FreeBusyItemModel::FreeBusyRole).value<KCalCore::
                                                                                     FreeBusy::Ptr>();
        if (!tryDate(freebusy, tryFrom, tryTo)) {
            ++conflicts_count;
        }
    }
    return conflicts_count;
}

bool ConflictResolver::tryDate(const KCalCore::FreeBusy::Ptr &fb, QDateTime &tryFrom,
                               QDateTime &tryTo)
{
    // If we don't have any free/busy information, assume the
    // participant is free. Otherwise a participant without available
    // information would block the whole allocation.
    if (!fb) {
        return true;
    }

KCalCore::Period::List busyPeriods = fb->busyPeriods();
    for (auto it = busyPeriods.begin(); it != busyPeriods.end(); ++it) {
        if ((*it).end() <= tryFrom     // busy period ends before try period
            || (*it).start() >= tryTo) {   // busy period starts after try period
            continue;
        } else {
            // the current busy period blocks the try period, try
            // after the end of the current busy period
            const qint64 secsDuration = tryFrom.secsTo(tryTo);
            tryFrom = (*it).end();
            tryTo = tryFrom.addSecs(secsDuration);
            // try again with the new try period
            tryDate(fb, tryFrom, tryTo);
            // we had to change the date at least once
            return false;
        }
    }
    return true;
}

bool ConflictResolver::findFreeSlot(const KCalCore::Period &dateTimeRange)
{
    QDateTime dtFrom = dateTimeRange.start();
    QDateTime dtTo = dateTimeRange.end();
    if (tryDate(dtFrom, dtTo)) {
        // Current time is acceptable
        return true;
    }

QDateTime tryFrom = dtFrom;
    QDateTime tryTo = dtTo;

// Make sure that we never suggest a date in the past, even if the
    // user originally scheduled the meeting to be in the past.
    QDateTime now = QDateTime::currentDateTimeUtc();
    if (tryFrom < now) {
        // The slot to look for is at least partially in the past.
        const qint64 secs = tryFrom.secsTo(tryTo);
        tryFrom = now;
        tryTo = tryFrom.addSecs(secs);
    }

bool found = false;
    while (!found) {
        found = tryDate(tryFrom, tryTo);
        // PENDING(kalle) Make the interval configurable
        if (!found && dtFrom.daysTo(tryFrom) > 365) {
            break; // don't look more than one year in the future
        }
    }

dtFrom = tryFrom;
    dtTo = tryTo;

return found;
}

void ConflictResolver::findAllFreeSlots()
{
    // Uses an O(p*n) (n number of attendees, p timeframe range / timeslot resolution ) algorithm to
    // locate all free blocks in a given timeframe that match the search constraints.
    // Does so by:
    // 1. convert each attendees schedule for the timeframe into a bitarray according to
    //    the time resolution, where each time slot has a value of 1 = busy, 0 = free.
    // 2. align the arrays vertically, and sum the columns
    // 3. the resulting summation indcates # of conflicts at each timeslot
    // 4. locate contiguous timeslots with a values of 0. these are the free time blocks.

// define these locally for readability
    const QDateTime begin = mTimeframeConstraint.start();
    const QDateTime end = mTimeframeConstraint.end();

// calculate the time resolution
    // each timeslot in the arrays represents a unit of time
    // specified here.
    if (mSlotResolutionSeconds < 1) {
        // fallback to default, if the user's value is invalid
        mSlotResolutionSeconds = DEFAULT_RESOLUTION_SECONDS;
    }

// calculate the length of the timeframe in terms of the amount of timeslots.
    // Example: 1 week timeframe, with resolution of 15 minutes
    //          1 week = 10080 minutes / 15 = 672 15 min timeslots
    //          So, the array would have a length of 672
    const int range = begin.secsTo(end) / mSlotResolutionSeconds;
    if (range <= 0) {
        qCWarning(INCIDENCEEDITOR_LOG) << "free slot calculation: invalid range. range( "
                                       << begin.secsTo(end)
                                       << ") / mSlotResolutionSeconds(" << mSlotResolutionSeconds
                                       << ") = " << range;
        return;
    }

qCDebug(INCIDENCEEDITOR_LOG) << "from " << begin << " to " << end
                                 << "; mSlotResolutionSeconds = " << mSlotResolutionSeconds
                                 << "; range = " << range;
    // filter out attendees for which we don't have FB data
    // and which don't match the mandatory role contrstaint
    QList<KCalCore::FreeBusy::Ptr> filteredFBItems;
    for (int i = 0; i < mFBModel->rowCount(); ++i) {
        QModelIndex index = mFBModel->index(i);
        KCalCore::Attendee::Ptr attendee
            = mFBModel->data(index,
                             CalendarSupport::FreeBusyItemModel::AttendeeRole).value<KCalCore::
                                                                                     Attendee::Ptr>();
        if (!matchesRoleConstraint(attendee)) {
            continue;
        }
        KCalCore::FreeBusy::Ptr freebusy
            = mFBModel->data(index,
                             CalendarSupport::FreeBusyItemModel::FreeBusyRole).value<KCalCore::
                                                                                     FreeBusy::Ptr>();
        if (freebusy) {
            filteredFBItems << freebusy;
        }
    }

// now we know the number of attendees we are calculating for
    const int number_attendees = filteredFBItems.size();
    if (number_attendees <= 0) {
        qCDebug(INCIDENCEEDITOR_LOG) << "no attendees match search criteria";
        return;
    }
    qCDebug(INCIDENCEEDITOR_LOG) << "num attendees: " << number_attendees;
    // this is a 2 dimensional array where the rows are attendees
    // and the columns are 0 or 1 denoting freee or busy respectively.
    QVector< QVector<int> > fbTable;

// Explanation of the following loop:
    // iterate: through each attendee
    //   allocate: an array of length <range> and fill it with 0s
    //   iterate: through each attendee's busy period
    //     if: the period lies inside our timeframe
    //     then:
    //       calculate the array index within the timeframe range of the beginning of the busy period
    //       fill from that index until the period ends with a 1, representing busy
    //     fi
    //   etareti
    // append the allocated array to <fbTable>
    // etareti
    foreach (const KCalCore::FreeBusy::Ptr &currentFB, filteredFBItems) {
        Q_ASSERT(currentFB);   // sanity check
        const KCalCore::Period::List busyPeriods = currentFB->busyPeriods();
        QVector<int> fbArray(range);
        fbArray.fill(0);   // initialize to zero
        for (const auto &period : busyPeriods) {
            if (period.end() >= begin && period.start() <= end) {
                int start_index = -1; // Initialize it to an invalid value.
                int duration = -1;    // Initialize it to an invalid value.
                // case1: the period is completely in our timeframe
                if (period.end() <= end && period.start() >= begin) {
                    start_index = begin.secsTo(period.start()) / mSlotResolutionSeconds;
                    duration = period.start().secsTo(period.end()) / mSlotResolutionSeconds;
                    duration -= 1; // vector starts at 0
                    // case2: the period begins before our timeframe begins
                } else if (period.start() <= begin && period.end() <= end) {
                    start_index = 0;
                    duration = (begin.secsTo(period.end()) / mSlotResolutionSeconds) - 1;
                    // case3: the period ends after our timeframe ends
                } else if (period.end() >= end && period.start() >= begin) {
                    start_index = begin.secsTo(period.start()) / mSlotResolutionSeconds;
                    duration = range - start_index - 1;
                    // case4: case2+case3: our timeframe is inside the period
                } else if (period.start() <= begin && period.end() >= end) {
                    start_index = 0;
                    duration = range - 1;
                } else {
                    //QT5
                    //qCCritical(INCIDENCEEDITOR_LOG) << "impossible condition reached" << period.start() << period.end();
                }
                //      qCDebug(INCIDENCEEDITOR_LOG) << start_index << "+" << duration << "="
                //               << start_index + duration << "<=" << range;
                Q_ASSERT((start_index + duration) < range);     // sanity check
                for (int i = start_index; i <= start_index + duration; ++i) {
                    fbArray[i] = 1;
                }
            }
        }
        Q_ASSERT(fbArray.size() == range);   // sanity check
        fbTable.append(fbArray);
    }

Q_ASSERT(fbTable.size() == number_attendees);

// Now, create another array to represent the allowed weekdays constraints
    // All days which are not allowed, will be marked as busy
    QVector<int> fbArray(range);
    fbArray.fill(0);   // initialize to zero
    for (int slot = 0; slot < fbArray.size(); ++slot) {
        const QDateTime dateTime = begin.addSecs(slot * mSlotResolutionSeconds);
        const int dayOfWeek = dateTime.date().dayOfWeek() - 1;   // bitarray is 0 indexed
        if (!mWeekdays[dayOfWeek]) {
            fbArray[slot] = 1;
        }
    }
    fbTable.append(fbArray);

// Create the composite array that will hold the sums for
    // each 15 minute timeslot
    QVector<int> summed(range);
    summed.fill(0);   // initialize to zero

// Sum the columns of the table
    for (int i = 0; i < fbTable.size(); ++i) {
        for (int j = 0; j < range; ++j) {
            summed[j] += fbTable[i][j];
        }
    }

// Finally, iterate through the composite array locating contiguous free timeslots
    int free_count = 0;
    bool free_found = false;
    mAvailableSlots.clear();
    for (int i = 0; i < range; ++i) {
        // free timeslot encountered, increment counter
        if (summed[i] == 0) {
            ++free_count;
        }
        if (summed[i] != 0 || (i == (range - 1) && summed[i] == 0)) {
            // current slot is not free, so push the previous free blocks
            // OR we are in the last slot and it is free
            if (free_count > 0) {
                int free_start_i;// start index of the free block
                int free_end_i; // end index of the free block
                if (summed[i] == 0) {
                    // special case: we are on the last slot and it is free
                    //               so we want to include this slot in the free block
                    free_start_i = i - free_count + 1; // add one, to set us back inside the array because
                    // free_count was incremented already this iteration
                    free_end_i = i + 1; // add one to compensate for the fact that the array is 0 indexed
                } else {
                    free_start_i = i - free_count;
                    free_end_i = i - 1 + 1; // add one to compensate for the fact that the array is 0 indexed
                    // compiler will optmize out the -1+1, but I leave it here to make the reasoning apparent.
                }
                // convert from our timeslot interval back into to normal seconds
                // then calculate the date times of the free block based on
                // our initial timeframe
                const QDateTime freeBegin = begin.addSecs(free_start_i * mSlotResolutionSeconds);
                const QDateTime freeEnd
                    = freeBegin.addSecs((free_end_i - free_start_i) * mSlotResolutionSeconds);
                // push the free block onto the list
                mAvailableSlots << KCalCore::Period(freeBegin, freeEnd);
                free_count = 0;
                if (!free_found) {
                    free_found = true;
                }
            }
        }
    }
    if (free_found) {
        Q_EMIT freeSlotsAvailable(mAvailableSlots);
    }
#if 0
    //DEBUG, dump the arrays. very helpful for debugging
    QTextStream dump(stdout);
    dump << "    ";
    dump.setFieldWidth(3);
    for (int i = 0; i < range; ++i) {   // header
        dump << i;
    }
    dump.setFieldWidth(1);
    dump << "\n\n";
    for (int i = 0; i < number_attendees; ++i) {
        dump.setFieldWidth(1);
        dump << i << ":  ";
        dump.setFieldWidth(3);
        for (int j = 0; j < range; ++j) {
            dump << fbTable[i][j];
        }
        dump << "\n\n";
    }
    dump.setFieldWidth(1);
    dump << "    ";
    dump.setFieldWidth(3);
    for (int i = 0; i < range; ++i) {
        dump << summed[i];
    }
    dump << "\n";
#endif
}

void ConflictResolver::calculateConflicts()
{
    QDateTime start = mTimeframeConstraint.start();
    QDateTime end = mTimeframeConstraint.end();
    const int count = tryDate(start, end);
    Q_EMIT conflictsDetected(count);

if (!mCalculateTimer.isActive()) {
        mCalculateTimer.start(0);
    }
}

void ConflictResolver::setAllowedWeekdays(const QBitArray &weekdays)
{
    mWeekdays = weekdays;
    calculateConflicts();
}

void ConflictResolver::setMandatoryRoles(const QSet< KCalCore::Attendee::Role > &roles)
{
    mMandatoryRoles = roles;
    calculateConflicts();
}

bool ConflictResolver::matchesRoleConstraint(const KCalCore::Attendee::Ptr &attendee)
{
    return mMandatoryRoles.contains(attendee->role());
}

KCalCore::Period::List ConflictResolver::availableSlots() const
{
    return mAvailableSlots;
}

void ConflictResolver::setResolution(int seconds)
{
    mSlotResolutionSeconds = seconds;
}

CalendarSupport::FreeBusyItemModel *ConflictResolver::model() const
{
    return mFBModel;
}
07070111A000FC000081A40000000200000002000000015AA55A8600001A96000000FD0000001000000000000000000000004A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/conflictresolver.h/*
  Copyright (c) 2000,2001,2004 Cornelius Schumacher <schumacher@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
  Copyright (c) 2010 Andras Mantia <andras@kdab.com>
  Copyright (C) 2010 Casey Link <casey@kdab.com>

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 INCIDENCEEDITOR_CONFLICTRESOLVER_H
#define INCIDENCEEDITOR_CONFLICTRESOLVER_H

#include "incidenceeditor_export.h"
#include "CalendarSupport/FreeBusyItem"

#include <QBitArray>
#include <QSet>
#include <QTimer>

namespace CalendarSupport {
class FreeBusyItemModel;
}

namespace IncidenceEditorNG {
/**
 * Takes a list of attendees and event info (e.g., min time start, max time end)
 * fetches their freebusy information, then identifies conflicts and periods of non-conflict.
 *
 * It exposes these periods so another class can display them to the user and allow
 * them to choose a correct time.
 * @author Casey Link
 */
class INCIDENCEEDITOR_EXPORT ConflictResolver : public QObject
{
    Q_OBJECT
public:
    /**
     * @param parentWidget is passed to Akonadi when fetching free/busy data.
     */
    explicit ConflictResolver(QWidget *parentWidget, QObject *parent = nullptr);

/**
     *  Add an attendee
     * The attendees free busy info will be fetched
     * and integrated into the resolver.
     */
    void insertAttendee(const KCalCore::Attendee::Ptr &attendee);

void insertAttendee(const CalendarSupport::FreeBusyItem::Ptr &freebusy);
    /**
     * Removes an attendee
     * The attendee will no longer be considered when
     * resolving conflicts
     */

void removeAttendee(const KCalCore::Attendee::Ptr &attendee);

/**
     * Clear all attendees
     */
    void clearAttendees();

/**
     * Returns whether the resolver contains the attendee
     */
    bool containsAttendee(const KCalCore::Attendee::Ptr &attendee);

/**
     * Constrain the free time slot search to the weekdays
     * identified by their KCalendarSystem integer representation
     * Default is Monday - Friday
     * @param weekdays a 7 bit array indicating the allowed days (bit 0=Monday, value 1=allowed).
     * @see KCalendarSystem
     */
    void setAllowedWeekdays(const QBitArray &weekdays);

/**
     * Constrain the free time slot search to the set participant roles.
     * Mandatory roles are considered the minimum required to attend
     * the meeting, so only those attendees with the mandatory roles will
     * be considered  in the search.
     * Default is all roles are mandatory.
     * @param roles the set of mandatory participant roles
     */
    void setMandatoryRoles(const QSet<KCalCore::Attendee::Role> &roles);

/**
     * Returns a list of date time ranges that conform to the
     * search constraints.
     * @see setMandatoryRoles
     * @see setAllowedWeekdays
     */
    KCalCore::Period::List availableSlots() const;

/**
      Finds a free slot in the future which has at least the same size as
      the initial slot.
    */
    bool findFreeSlot(const KCalCore::Period &dateTimeRange);

QList<CalendarSupport::FreeBusyItem::Ptr> freeBusyItems() const;

CalendarSupport::FreeBusyItemModel *model() const;

Q_SIGNALS:
    /**
     * Emitted when the user changes the start and end dateTimes
     * for the incidence.
     */
    void dateTimesChanged(const QDateTime &newStart, const QDateTime &newEnd);

/**
     * Emitted when there are conflicts
     * @param number the number of conflicts
     */
    void conflictsDetected(int number);

/**
     * Emitted when the resolver locates new free slots.
     */
    void freeSlotsAvailable(const KCalCore::Period::List &);

public Q_SLOTS:
    /**
     * Set the timeframe constraints
     *
     * These control the timeframe for which conflicts are to be resolved.
     */
    void setEarliestDate(const QDate &newDate);
    void setEarliestTime(const QTime &newTime);
    void setLatestDate(const QDate &newDate);
    void setLatestTime(const QTime &newTime);

void setEarliestDateTime(const QDateTime &newDateTime);
    void setLatestDateTime(const QDateTime &newDateTime);

void freebusyDataChanged();

void findAllFreeSlots();

void setResolution(int seconds);

private:
    /**
      Checks whether the slot specified by (tryFrom, tryTo) matches the
      search constraints. If yes, return true. The return value is the
      number of conflicts that were detected, and (tryFrom, tryTo) contain the next free slot for
      that participant. In other words, the returned slot does not have to
      be free for everybody else.
    */
    int tryDate(QDateTime &tryFrom, QDateTime &tryTo);

/**
      Checks whether the slot specified by (tryFrom, tryTo) is available
      for the participant with specified fb. If yes, return true. If
      not, return false and change (tryFrom, tryTo) to contain the next
      possible slot for this participant (not necessarily a slot that is
      available for all participants).
    */
    bool tryDate(const KCalCore::FreeBusy::Ptr &fb, QDateTime &tryFrom, QDateTime &tryTo);

/**
     * Checks whether the supplied attendee passes the
     * current mandatory role constraint.
     * @return true if the attendee is of one of the mandatory roles, false if not
     */
    bool matchesRoleConstraint(const KCalCore::Attendee::Ptr &attendee);

void calculateConflicts();

KCalCore::Period mTimeframeConstraint; //!< the datetime range for outside of which
    //free slots won't be searched.
    KCalCore::Period::List mAvailableSlots;

QTimer mCalculateTimer; //!< A timer is used control the calculation of conflicts
    // to prevent the process from being repeated many times
    // after a series of quick parameter changes.

CalendarSupport::FreeBusyItemModel *mFBModel = nullptr;
    QWidget *mParentWidget = nullptr;

QSet<KCalCore::Attendee::Role> mMandatoryRoles;
    QBitArray mWeekdays; //!< a 7 bit array indicating the allowed days
    //(bit 0 = Monday, value 1 = allowed).

int mSlotResolutionSeconds;
};
}

#endif
07070111A000FD000081A40000000200000002000000015AA55A8600000C53000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/editorconfig.cpp/*
  Copyright (c) 2009 Sebastian Sauer <sebsauer@kdab.net>

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 "editorconfig.h"
#include "korganizereditorconfig.h"

#include <QCoreApplication>

using namespace IncidenceEditorNG;

class EditorConfig::Private
{
public:
    static EditorConfig *config;
    static void cleanup_config()
    {
        delete config;
        config = nullptr;
    }

QHash<KCalCore::IncidenceBase::IncidenceType, QStringList> mTemplates;
};

EditorConfig *EditorConfig::Private::config = nullptr;

EditorConfig::EditorConfig()
    : d(new Private)
{
}

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

EditorConfig *EditorConfig::instance()
{
    if (!Private::config) {
        // No one called setEditorConfig(), so we default to a KorganizerEditorConfig.
        EditorConfig::setEditorConfig(new IncidenceEditorNG::KOrganizerEditorConfig);
    }

return Private::config;
}

void EditorConfig::setEditorConfig(EditorConfig *config)
{
    delete Private::config;
    Private::config = config;
    qAddPostRoutine(Private::cleanup_config);
}

QString EditorConfig::fullName() const
{
    if (Private::config != this) {
        return Private::config->fullName();
    }
    return QString();
}

QString EditorConfig::email() const
{
    if (Private::config != this) {
        return Private::config->email();
    }
    return QString();
}

bool EditorConfig::thatIsMe(const QString &mail) const
{
    if (Private::config != this) {
        return Private::config->thatIsMe(mail);
    }
    return false;
}

QStringList EditorConfig::allEmails() const
{
    if (Private::config != this) {
        return Private::config->allEmails();
    }

QStringList mails;
    const QString m = email();
    if (!m.isEmpty()) {
        mails << m;
    }
    return mails;
}

QStringList EditorConfig::fullEmails() const
{
    if (Private::config != this) {
        return Private::config->fullEmails();
    }
    return QStringList();
}

bool EditorConfig::showTimeZoneSelectorInIncidenceEditor() const
{
    if (Private::config != this) {
        return Private::config->showTimeZoneSelectorInIncidenceEditor();
    }
    return true;
}

QStringList &EditorConfig::templates(KCalCore::IncidenceBase::IncidenceType type)
{
    return d->mTemplates[type];
}
07070111A000FE000081A40000000200000002000000015AA55A8600000C69000000FD0000001000000000000000000000004600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/editorconfig.h/*
  Copyright (c) 2009 Sebastian Sauer <sebsauer@kdab.net>

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 INCIDENCEEDITOR_EDITORCONFIG_H
#define INCIDENCEEDITOR_EDITORCONFIG_H

#include "incidenceeditor_export.h"

#include <KCalCore/IncidenceBase>

#include <QUrl>

#include <QStringList>
#include <QDateTime>

class KConfigSkeleton;

namespace IncidenceEditorNG {
/**
 * Configuration details. An application can inherit from this class
 * to provide application specific configurations to the editor.
 *
 */
class INCIDENCEEDITOR_EXPORT EditorConfig
{
public:
    EditorConfig();
    virtual ~EditorConfig();

static EditorConfig *instance();
    static void setEditorConfig(EditorConfig *);

virtual KConfigSkeleton *config() const = 0;

/// Return the own full name.
    virtual QString fullName() const;

/// Return the own mail address.
    virtual QString email() const;

/// Return true if the given email belongs to the user.
    virtual bool thatIsMe(const QString &email) const;

/// Returns all email addresses for the user.
    virtual QStringList allEmails() const;

/// Returns all email addresses together with the full username for the user.
    virtual QStringList fullEmails() const;

/// Show timezone selectors in the event and todo editor dialog.
    virtual bool showTimeZoneSelectorInIncidenceEditor() const;

virtual QDateTime defaultDuration() const
    {
        return QDateTime(QDate(1752, 1, 1), QTime(2, 0));
    }

virtual QDateTime startTime() const
    {
        return QDateTime(QDate(1752, 1, 1), QTime(10, 0));
    }

virtual bool defaultAudioFileReminders() const
    {
        return false;
    }

virtual QUrl audioFilePath() const
    {
        return QUrl();
    }

virtual int reminderTime() const
    {
        return 15;
    }

virtual int reminderTimeUnits() const
    {
        return 0;
    }

virtual bool defaultTodoReminders() const
    {
        return false;
    }

virtual bool defaultEventReminders() const
    {
        return false;
    }

virtual QStringList activeDesignerFields() const
    {
        return QStringList();
    }

virtual QStringList &templates(KCalCore::IncidenceBase::IncidenceType type);

private:
    class Private;
    Private *const d;
};
}

#endif
07070111A000FF000081A40000000200000002000000015AA55A8600003A02000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/editoritemmanager.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "editoritemmanager.h"
#include "individualmailcomponentfactory.h"

#include <CalendarSupport/Utils>
#include <CalendarSupport/KCalPrefs>

#include <Item>
#include <ItemDeleteJob>
#include <ItemFetchJob>
#include <ItemFetchScope>
#include <ItemMoveJob>
#include <Monitor>
#include <Session>
#include <AkonadiCore/TagFetchScope>

#include <KJob>
#include <KLocalizedString>
#include "incidenceeditor_debug.h"

#include <QMessageBox>
#include <QPointer>

/// ItemEditorPrivate

namespace IncidenceEditorNG {
class ItemEditorPrivate
{
    EditorItemManager *q_ptr;
    Q_DECLARE_PUBLIC(EditorItemManager)

public:
    Akonadi::Item mItem;
    Akonadi::Item mPrevItem;
    Akonadi::ItemFetchScope mFetchScope;
    Akonadi::Monitor *mItemMonitor = nullptr;
    ItemEditorUi *mItemUi = nullptr;
    bool mIsCounterProposal = false;
    EditorItemManager::SaveAction currentAction;
    Akonadi::IncidenceChanger *mChanger = nullptr;

public:
    ItemEditorPrivate(Akonadi::IncidenceChanger *changer, EditorItemManager *qq);
    void itemChanged(const Akonadi::Item &, const QSet<QByteArray> &);
    void itemFetchResult(KJob *job);
    void itemMoveResult(KJob *job);
    void onModifyFinished(int changeId, const Akonadi::Item &item,
                          Akonadi::IncidenceChanger::ResultCode resultCode,
                          const QString &errorString);

void onCreateFinished(int changeId, const Akonadi::Item &item,
                          Akonadi::IncidenceChanger::ResultCode resultCode,
                          const QString &errorString);

void setupMonitor();
    void moveJobFinished(KJob *job);
    void setItem(const Akonadi::Item &item);
};

ItemEditorPrivate::ItemEditorPrivate(Akonadi::IncidenceChanger *changer, EditorItemManager *qq)
    : q_ptr(qq)
    , mItemMonitor(nullptr)
    , mIsCounterProposal(false)
    , currentAction(EditorItemManager::None)
{
    mFetchScope.fetchFullPayload();
    mFetchScope.setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
    mFetchScope.setFetchTags(true);
    mFetchScope.tagFetchScope().setFetchIdOnly(false);

mChanger
        = changer ? changer : new Akonadi::IncidenceChanger(new IndividualMailComponentFactory(
                                                                qq), qq);

qq->connect(mChanger,
                SIGNAL(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,
                                      QString)),
                qq,
                SLOT(onModifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,
                                      QString)));

qq->connect(mChanger,
                SIGNAL(createFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,
                                      QString)),
                qq,
                SLOT(onCreateFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,
                                      QString)));
}

void ItemEditorPrivate::moveJobFinished(KJob *job)
{
    Q_Q(EditorItemManager);
    if (job->error()) {
        qCCritical(INCIDENCEEDITOR_LOG) << "Error while moving and modifying "
                                        << job->errorString();
        mItemUi->reject(ItemEditorUi::ItemMoveFailed, job->errorString());
    } else {
        Akonadi::Item item(mItem.id());
        currentAction = EditorItemManager::MoveAndModify;
        q->load(item);
    }
}

void ItemEditorPrivate::itemFetchResult(KJob *job)
{
    Q_ASSERT(job);
    Q_Q(EditorItemManager);

EditorItemManager::SaveAction action = currentAction;
    currentAction = EditorItemManager::None;

if (job->error()) {
        mItemUi->reject(ItemEditorUi::ItemFetchFailed, job->errorString());
        return;
    }

Akonadi::ItemFetchJob *fetchJob = qobject_cast<Akonadi::ItemFetchJob *>(job);
    if (fetchJob->items().isEmpty()) {
        mItemUi->reject(ItemEditorUi::ItemFetchFailed);
        return;
    }

Akonadi::Item item = fetchJob->items().at(0);
    if (mItemUi->hasSupportedPayload(item)) {
        setItem(item);
        if (action != EditorItemManager::None) {
            // Finally enable ok/apply buttons, we've finished loading
            Q_EMIT q->itemSaveFinished(action);
        }
    } else {
        mItemUi->reject(ItemEditorUi::ItemHasInvalidPayload);
    }
}

void ItemEditorPrivate::setItem(const Akonadi::Item &item)
{
    Q_ASSERT(item.hasPayload());
    mPrevItem = item;
    mItem = item;
    mItemUi->load(item);
    setupMonitor();
}

void ItemEditorPrivate::itemMoveResult(KJob *job)
{
    Q_ASSERT(job);
    Q_Q(EditorItemManager);

if (job->error()) {
        Akonadi::ItemMoveJob *moveJob = qobject_cast<Akonadi::ItemMoveJob *>(job);
        Q_ASSERT(moveJob);
        Q_UNUSED(moveJob);
        //Q_ASSERT(!moveJob->items().isEmpty());
        // TODO: What is reasonable behavior at this point?
        qCCritical(INCIDENCEEDITOR_LOG) << "Error while moving item ";// << moveJob->items().first().id() << " to collection "
        //<< moveJob->destinationCollection() << job->errorString();
        Q_EMIT q->itemSaveFailed(EditorItemManager::Move, job->errorString());
    } else {
        // Fetch the item again, we want a new mItem, which has an updated parentCollection
        Akonadi::Item item(mItem.id());
        // set currentAction, so the fetchResult slot emits itemSavedFinished(Move);
        // We could emit it here, but we should only enable ok/apply buttons after the loading
        // is complete
        currentAction = EditorItemManager::Move;
        q->load(item);
    }
}

void ItemEditorPrivate::onModifyFinished(int, const Akonadi::Item &item,
                                         Akonadi::IncidenceChanger::ResultCode resultCode,
                                         const QString &errorString)
{
    Q_Q(EditorItemManager);
    if (resultCode == Akonadi::IncidenceChanger::ResultCodeSuccess) {
        if (mItem.parentCollection() == mItemUi->selectedCollection()
            || mItem.storageCollectionId() == mItemUi->selectedCollection().id()) {
            mItem = item;
            Q_EMIT q->itemSaveFinished(EditorItemManager::Modify);
            setupMonitor();
        } else { // There's a collection move too.
            Akonadi::ItemMoveJob *moveJob = new Akonadi::ItemMoveJob(mItem,
                                                                     mItemUi->selectedCollection());
            q->connect(moveJob, SIGNAL(result(KJob*)), SLOT(moveJobFinished(KJob*)));
        }
    } else if (resultCode == Akonadi::IncidenceChanger::ResultCodeUserCanceled) {
        Q_EMIT q->itemSaveFailed(EditorItemManager::Modify, QString());
        q->load(Akonadi::Item(mItem.id()));
    } else {
        qCCritical(INCIDENCEEDITOR_LOG) << "Modify failed " << errorString;
        Q_EMIT q->itemSaveFailed(EditorItemManager::Modify, errorString);
    }
}

void ItemEditorPrivate::onCreateFinished(int, const Akonadi::Item &item,
                                         Akonadi::IncidenceChanger::ResultCode resultCode,
                                         const QString &errorString)
{
    Q_Q(EditorItemManager);
    if (resultCode == Akonadi::IncidenceChanger::ResultCodeSuccess) {
        currentAction = EditorItemManager::Create;
        q->load(item);
        setupMonitor();
    } else {
        qCCritical(INCIDENCEEDITOR_LOG) << "Creation failed " << errorString;
        Q_EMIT q->itemSaveFailed(EditorItemManager::Create, errorString);
    }
}

void ItemEditorPrivate::setupMonitor()
{
    // Q_Q(EditorItemManager);
    delete mItemMonitor;
    mItemMonitor = new Akonadi::Monitor;
    mItemMonitor->setObjectName(QStringLiteral("EditorItemManagerMonitor"));
    mItemMonitor->ignoreSession(Akonadi::Session::defaultSession());
    mItemMonitor->itemFetchScope().fetchFullPayload();
    if (mItem.isValid()) {
        mItemMonitor->setItemMonitored(mItem);
    }

//   q->connect(mItemMonitor, SIGNAL(itemChanged(Akonadi::Item,QSet<QByteArray>)),
//               SLOT(itemChanged(Akonadi::Item,QSet<QByteArray>)));
}

void ItemEditorPrivate::itemChanged(const Akonadi::Item &item,
                                    const QSet<QByteArray> &partIdentifiers)
{
    Q_Q(EditorItemManager);
    if (mItemUi->containsPayloadIdentifiers(partIdentifiers)) {
        QPointer<QMessageBox> dlg = new QMessageBox; //krazy:exclude=qclasses
        dlg->setIcon(QMessageBox::Question);
        dlg->setInformativeText(i18n("The item has been changed by another application.\n"
                                     "What should be done?"));
        dlg->addButton(i18n("Take over changes"), QMessageBox::AcceptRole);
        dlg->addButton(i18n("Ignore and Overwrite changes"), QMessageBox::RejectRole);

if (dlg->exec() == QMessageBox::AcceptRole) {
            Akonadi::ItemFetchJob *job = new Akonadi::ItemFetchJob(mItem);
            job->setFetchScope(mFetchScope);

mItem = item;

q->load(mItem);
        } else {
            mItem.setRevision(item.revision());
            q->save();
        }

delete dlg;
    }

// Overwrite or not, we need to update the revision and the remote id to be able
    // to store item later on.
    mItem.setRevision(item.revision());
}

/// ItemEditor

EditorItemManager::EditorItemManager(ItemEditorUi *ui, Akonadi::IncidenceChanger *changer)
    : d_ptr(new ItemEditorPrivate(changer, this))
{
    Q_D(ItemEditor);
    d->mItemUi = ui;
}

EditorItemManager::~EditorItemManager()
{
    delete d_ptr;
}

Akonadi::Item EditorItemManager::item(ItemState state) const
{
    Q_D(const ItemEditor);

switch (state) {
    case EditorItemManager::AfterSave:
        if (d->mItem.hasPayload()) {
            return d->mItem;
        } else {
            qCDebug(INCIDENCEEDITOR_LOG) << "Won't return mItem because isValid = "
                                         << d->mItem.isValid()
                                         << "; and haPayload is " << d->mItem.hasPayload();
        }
        break;
    case EditorItemManager::BeforeSave:
        if (d->mPrevItem.hasPayload()) {
            return d->mPrevItem;
        } else {
            qCDebug(INCIDENCEEDITOR_LOG) << "Won't return mPrevItem because isValid = "
                                         << d->mPrevItem.isValid()
                                         << "; and haPayload is " << d->mPrevItem.hasPayload();
        }
        break;
    }
    qCDebug(INCIDENCEEDITOR_LOG) << "state = " << state;
    Q_ASSERT_X(false, "EditorItemManager::item", "Unknown enum value");
    return Akonadi::Item();
}

void EditorItemManager::load(const Akonadi::Item &item)
{
    Q_D(ItemEditor);

//We fetch anyways to make sure we have everything required including tags
    Akonadi::ItemFetchJob *job = new Akonadi::ItemFetchJob(item, this);
    job->setFetchScope(d->mFetchScope);
    connect(job, SIGNAL(result(KJob*)), SLOT(itemFetchResult(KJob*)));
}

void EditorItemManager::save()
{
    Q_D(ItemEditor);

if (!d->mItemUi->isValid()) {
        Q_EMIT itemSaveFailed(d->mItem.isValid() ? Modify : Create, QString());
        return;
    }

if (!d->mItemUi->isDirty()
        && d->mItemUi->selectedCollection() == d->mItem.parentCollection()) {
        // Item did not change and was not moved
        Q_EMIT itemSaveFinished(None);
        return;
    }

d->mChanger->setGroupwareCommunication(
        CalendarSupport::KCalPrefs::instance()->useGroupwareCommunication());

Akonadi::Item updateItem = d->mItemUi->save(d->mItem);
    Q_ASSERT(updateItem.id() == d->mItem.id());
    d->mItem = updateItem;

if (d->mItem.isValid()) {   // A valid item. Means we're modifying.
        Q_ASSERT(d->mItem.parentCollection().isValid());
        KCalCore::Incidence::Ptr oldPayload = CalendarSupport::incidence(d->mPrevItem);
        if (d->mItem.parentCollection() == d->mItemUi->selectedCollection()
            || d->mItem.storageCollectionId() == d->mItemUi->selectedCollection().id()) {
            d->mChanger->modifyIncidence(d->mItem, oldPayload);
        } else {
            Q_ASSERT(d->mItemUi->selectedCollection().isValid());
            Q_ASSERT(d->mItem.parentCollection().isValid());

// ETM and the KSelectionProxyModel has a bug wrt collections moves, so this is disabled.
            // To test this, enable the collection combo-box and remove the following assert.
            qCCritical(INCIDENCEEDITOR_LOG) << "Moving between collections is disabled for now: "
                                            << d->mItemUi->selectedCollection().id()
                                            << d->mItem.parentCollection().id();
            Q_ASSERT_X(false, "save()", "Moving between collections is disabled for now");

if (d->mItemUi->isDirty()) {
                d->mChanger->modifyIncidence(d->mItem, oldPayload);
            } else {
                Akonadi::ItemMoveJob *itemMoveJob
                    = new Akonadi::ItemMoveJob(d->mItem, d->mItemUi->selectedCollection());
                connect(itemMoveJob, SIGNAL(result(KJob*)), SLOT(itemMoveResult(KJob*)));
            }
        }
    } else { // An invalid item. Means we're creating.
        if (d->mIsCounterProposal) {
            // We don't write back to akonadi, that will be done in ITipHandler.
            Q_EMIT itemSaveFinished(EditorItemManager::Modify);
        } else {
            Q_ASSERT(d->mItemUi->selectedCollection().isValid());
            KCalCore::Incidence::Ptr incidence = CalendarSupport::incidence(d->mItem);
            d->mChanger->createIncidence(incidence, d->mItemUi->selectedCollection());
        }
    }
}

void EditorItemManager::setIsCounterProposal(bool isCounterProposal)
{
    Q_D(ItemEditor);
    d->mIsCounterProposal = isCounterProposal;
}

ItemEditorUi::~ItemEditorUi()
{
}

bool ItemEditorUi::isValid() const
{
    return true;
}
} // namespace

#include "moc_editoritemmanager.cpp"
07070111A01940000081A40000000200000002000000015AA55A86000019EF000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/editoritemmanager.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_EDITORITEMMANAGER_H
#define INCIDENCEEDITOR_EDITORITEMMANAGER_H

#include <Akonadi/Calendar/IncidenceChanger>
#include <Collection>
#include <QObject>

namespace Akonadi {
class Collection;
class Item;
}

class KJob;

namespace IncidenceEditorNG {
class ItemEditorUi;
class ItemEditorPrivate;

/**
 * Helper class for creating dialogs that let the user create and edit the payload
 * of Akonadi items (e.g. events, contacts, etc). This class supports editting of
 * one item at a time and hanldes all Akonadi specific logic like Item creation,
 * Item modifying and monitoring of changes to the item during editing.
 */
// template <typename PayloadT>
class EditorItemManager : public QObject
{
    Q_OBJECT
public:
    /**
     * Creates an ItemEditor for a new Item.
     * Receives an option IncidenceChanger, so you can share the undo/redo stack with your
     * application.
     */
    EditorItemManager(ItemEditorUi *ui, Akonadi::IncidenceChanger *changer = nullptr);

/**
     * Destructs the ItemEditor. Unsaved changes will get lost at this point.
     */
    ~EditorItemManager();

enum ItemState {
        AfterSave,  /**< Returns the last saved item */
        BeforeSave  /**< Returns an item with the original payload before the last save call */
    };

/**
     * Returns the last saved item with payload or an invalid item when save is
     * not called yet.
     */
    Akonadi::Item item(ItemState state = AfterSave) const;

/**
     * Loads the @param item into the editor. The item passed must be
     * a valid item.
     */
    void load(const Akonadi::Item &item);

/**
     * Saves the new or modified item. This method does nothing when the
     * ui is not dirty.
     */
    void save();

enum SaveAction {
        Create, /**< A new item was created */
        Modify, /**< An existing item was modified */
        None,   /**< Nothing happened. */
        Move,    /**< An existing item was moved to another collection */
        MoveAndModify /**< An existing item was moved to another collection and modified */
    };

void setIsCounterProposal(bool isCounterProposal);

Q_SIGNALS:
    void itemSaveFinished(IncidenceEditorNG::EditorItemManager::SaveAction action);

void itemSaveFailed(IncidenceEditorNG::EditorItemManager::SaveAction action,
                        const QString &message);

void revertFinished();
    void revertFailed(const QString &message);

private:
    ItemEditorPrivate *const d_ptr;
    Q_DECLARE_PRIVATE(ItemEditor)
    Q_DISABLE_COPY(EditorItemManager)

Q_PRIVATE_SLOT(d_ptr, void itemChanged(const Akonadi::Item &, const QSet<QByteArray> &))
    Q_PRIVATE_SLOT(d_ptr, void itemFetchResult(KJob *))
    Q_PRIVATE_SLOT(d_ptr, void itemMoveResult(KJob *))
    Q_PRIVATE_SLOT(d_ptr, void onModifyFinished(int changeId, const Akonadi::Item &item,
                                                Akonadi::IncidenceChanger::ResultCode resultCode,
                                                const QString &errorString))
    Q_PRIVATE_SLOT(d_ptr, void onCreateFinished(int changeId,
                                                const Akonadi::Item &item,
                                                Akonadi::IncidenceChanger::ResultCode resultCode,
                                                const QString &errorString))
    Q_PRIVATE_SLOT(d_ptr, void moveJobFinished(KJob *job))
};

class ItemEditorUi
{
public:
    enum RejectReason {
        ItemFetchFailed,      ///> Either the fetchjob failed or no items where returned
        ItemHasInvalidPayload, ///> The fetched item has an invalid payload
        ItemMoveFailed ///> Item move failed
    };

virtual ~ItemEditorUi();

/**
     * Returns whether or not the identifier set contains payload identifiers that
     * are displayed/editable in the Gui.
     */
    virtual bool containsPayloadIdentifiers(const QSet<QByteArray> &partIdentifiers) const = 0;

/**
     * Returns whether or not @param item has a payload type that is supported by
     * the gui.
     */
    virtual bool hasSupportedPayload(const Akonadi::Item &item) const = 0;

/**
     * Returns whether or not the values in the ui differ from the original (i.e.
     * either an empty or a loaded item). This method <em>only</em> involves
     * payload fields. I.e. if only the collection in which the item should be
     * stored has changed, this method should return false.
     */
    virtual bool isDirty() const = 0;

/**
     * Returns whether or not the values in the ui are valid. This method can also
     * be used to update the ui if necessary. The default implementation returns
     * true, so if the ui doesn't need validation there is no need to reimplement
     * this method.
     */
    virtual bool isValid() const;

/**
     * Fills the ui with the values of the payload of @param item. The item is
     * guaranteed to have a payload.
     */
    virtual void load(const Akonadi::Item &item) = 0;

/**
     * Stores the values of the ui into the payload of @param item and returns the
     * item with an updated payload. The returned item must have a valid mimetype
     * too.
     */
    virtual Akonadi::Item save(const Akonadi::Item &item) = 0;

/**
     * Returns the currently sellected collection in which the item will be stored.
     */
    virtual Akonadi::Collection selectedCollection() const = 0;

/**
     * This function is called if for some reason the creation or editting of the
     * item cannot be continued. The implementing class must abort editting at
     * this point.
     */
    virtual void reject(RejectReason reason, const QString &errorMessage = QString()) = 0;
};
}

#endif
07070111A01941000081A40000000200000002000000015AA55A8600001014000000FD0000001000000000000000000000005300000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/freebusyganttproxymodel.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "freebusyganttproxymodel.h"
#include "CalendarSupport/FreeBusyItemModel"

#include <KGantt/KGanttGraphicsView>
#include <KCalCore/FreeBusyPeriod>

#include <KLocalizedString>

#include <QLocale>

using namespace IncidenceEditorNG;

FreeBusyGanttProxyModel::FreeBusyGanttProxyModel(QObject *parent)
    : QSortFilterProxyModel(parent)
{
}

QVariant FreeBusyGanttProxyModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        return QVariant();
    }
    QModelIndex source_index = mapToSource(index);

// if the index is not valid, then its a toplevel item, which is an attendee
    if (!source_index.parent().isValid()) {
        switch (role) {
        case KGantt::ItemTypeRole:
            return KGantt::TypeMulti;
        case Qt::DisplayRole:
            return source_index.data(Qt::DisplayRole);
        default:
            return QVariant();
        }
    }

// if the index is valid, then it corrsponds to a free busy period
    KCalCore::FreeBusyPeriod period
        = sourceModel()->data(source_index, CalendarSupport::FreeBusyItemModel::FreeBusyPeriodRole).
          value<KCalCore::FreeBusyPeriod>();

switch (role) {
    case KGantt::ItemTypeRole:
        return KGantt::TypeTask;
    case KGantt::StartTimeRole:
        return period.start().toLocalTime();
    case KGantt::EndTimeRole:
        return period.end().toLocalTime();
    case Qt::BackgroundRole:
        return QColor(Qt::red);
    case Qt::ToolTipRole:
        return tooltipify(period);
    case Qt::DisplayRole:
        return sourceModel()->data(source_index.parent(), Qt::DisplayRole);
    default:
        return QVariant();
    }
}

QString FreeBusyGanttProxyModel::tooltipify(const KCalCore::FreeBusyPeriod &period) const
{
    QString toolTip = QStringLiteral("<qt>");
    toolTip += QStringLiteral("<b>") + i18nc("@info:tooltip", "Free/Busy Period") + QStringLiteral(
        "</b>");
    toolTip += QStringLiteral("<hr>");
    if (!period.summary().isEmpty()) {
        toolTip += QStringLiteral("<i>") + i18nc("@info:tooltip", "Summary:") + QStringLiteral(
            "</i>") + QStringLiteral("&nbsp;");
        toolTip += period.summary();
        toolTip += QStringLiteral("<br>");
    }
    if (!period.location().isEmpty()) {
        toolTip += QStringLiteral("<i>") + i18nc("@info:tooltip", "Location:") + QStringLiteral(
            "</i>") + QStringLiteral("&nbsp;");
        toolTip += period.location();
        toolTip += QStringLiteral("<br>");
    }
    toolTip += QStringLiteral("<i>")
               + i18nc("@info:tooltip period start time",
                       "Start:") + QStringLiteral("</i>") + QStringLiteral(
        "&nbsp;");
    toolTip += QLocale().toString(period.start().toLocalTime(), QLocale::ShortFormat);
    toolTip += QStringLiteral("<br>");
    toolTip += QStringLiteral("<i>")
               + i18nc("@info:tooltip period end time",
                       "End:") + QStringLiteral("</i>") + QStringLiteral(
        "&nbsp;");
    toolTip += QLocale().toString(period.end().toLocalTime(), QLocale::ShortFormat);
    toolTip += QStringLiteral("<br>");
    toolTip += QStringLiteral("</qt>");
    return toolTip;
}
07070111A01942000081A40000000200000002000000015AA55A8600000707000000FD0000001000000000000000000000005100000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/freebusyganttproxymodel.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_FREEBUSYGANTTPROXYMODEL_H
#define INCIDENCEEDITOR_FREEBUSYGANTTPROXYMODEL_H

#include "incidenceeditor_export.h"

#include <QSortFilterProxyModel>

namespace KCalCore {
class FreeBusyPeriod;
}

namespace IncidenceEditorNG {
/**
 * This is a private proxy model, that wraps the free busy data exposed
 * by the FreeBusyItemModel for use by KDGantt2.
 *
 * This model exposes the FreeBusyPeriods, which are the child level nodes
 * in FreeBusyItemModel, as a list.
 *
 * @see FreeBusyItemMode
 * @see FreeBusyItem
 */
class INCIDENCEEDITOR_EXPORT FreeBusyGanttProxyModel : public QSortFilterProxyModel
{
    Q_OBJECT
public:
    explicit FreeBusyGanttProxyModel(QObject *parent = nullptr);
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    QString tooltipify(const KCalCore::FreeBusyPeriod &period) const;
};
}

#endif
07070111A01943000081A40000000200000002000000015AA55A8600000DAE000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/freebusyurldialog.cpp/*
  Copyright (c) 2004 Cornelius Schumacher <schumacher@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 "freebusyurldialog.h"

#include <KLineEdit>
#include <KLocalizedString>

#include <QBoxLayout>
#include "incidenceeditor_debug.h"
#include <QFrame>
#include <QLabel>
#include <KConfig>
#include <KConfigGroup>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>
#include <QStandardPaths>

using namespace IncidenceEditorNG;

FreeBusyUrlDialog::FreeBusyUrlDialog(const AttendeeData::Ptr &attendee, QWidget *parent)
    : QDialog(parent)
{
    setModal(true);
    setWindowTitle(i18n("Edit Free/Busy Location"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);

QFrame *topFrame = new QFrame(this);
    QDialogButtonBox *buttonBox = new QDialogButtonBox(
        QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
    mainLayout->addWidget(topFrame);
    QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &FreeBusyUrlDialog::reject);
    mainLayout->addWidget(buttonBox);
    okButton->setDefault(true);

QBoxLayout *topLayout = new QVBoxLayout(topFrame);
    topLayout->setMargin(0);

mWidget = new FreeBusyUrlWidget(attendee, topFrame);
    topLayout->addWidget(mWidget);

mWidget->loadConfig();
    connect(okButton, &QPushButton::clicked, this, &FreeBusyUrlDialog::slotOk);
}

void FreeBusyUrlDialog::slotOk()
{
    mWidget->saveConfig();
    accept();
}

FreeBusyUrlWidget::FreeBusyUrlWidget(const AttendeeData::Ptr &attendee, QWidget *parent)
    : QWidget(parent)
    , mAttendee(attendee)
{
    QBoxLayout *topLayout = new QVBoxLayout(this);

QLabel *label
        = new QLabel(xi18n("Location of Free/Busy information for %1 <placeholder>%2</placeholder>:",
                           mAttendee->name(), mAttendee->email()), this);
    topLayout->addWidget(label);

mUrlEdit = new KLineEdit(this);
    mUrlEdit->setFocus();
    topLayout->addWidget(mUrlEdit);
}

FreeBusyUrlWidget::~FreeBusyUrlWidget()
{
}

static QString freeBusyUrlStore()
{
    return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)
           + QStringLiteral("/korganizer/freebusyurls");
}

void FreeBusyUrlWidget::loadConfig()
{
    KConfig config(freeBusyUrlStore());
    mUrlEdit->setText(config.group(mAttendee->email()).readEntry("url"));
}

void FreeBusyUrlWidget::saveConfig()
{
    const QString url = mUrlEdit->text();
    KConfig config(freeBusyUrlStore());
    config.group(mAttendee->email()).writeEntry("url", url);
}
07070111A01944000081A40000000200000002000000015AA55A86000006D0000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/freebusyurldialog.h/*
  Copyright (c) 2004 Cornelius Schumacher <schumacher@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.

As a special exception, permission is given to link this program
  with any edition of Qt, and distribute the resulting executable,
  without including the source code for Qt in the source distribution.
*/
#ifndef INCIDENCEEDITOR_FREEBUSYURLDIALOG_H
#define INCIDENCEEDITOR_FREEBUSYURLDIALOG_H

#include "attendeedata.h"

#include <QDialog>

class KLineEdit;

namespace IncidenceEditorNG {
class FreeBusyUrlWidget;

class FreeBusyUrlDialog : public QDialog
{
    Q_OBJECT
public:
    explicit FreeBusyUrlDialog(const AttendeeData::Ptr &, QWidget *parent = nullptr);

public Q_SLOTS:
    void slotOk();

private:
    FreeBusyUrlWidget *mWidget = nullptr;
};

class FreeBusyUrlWidget : public QWidget
{
    Q_OBJECT
public:
    explicit FreeBusyUrlWidget(const AttendeeData::Ptr &, QWidget *parent = nullptr);
    ~FreeBusyUrlWidget();

void loadConfig();
    void saveConfig();

private:
    KLineEdit *mUrlEdit = nullptr;
    AttendeeData::Ptr mAttendee;
};
}

#endif
07070111A01945000081A40000000200000002000000015AA55A860000013E000000FD0000001000000000000000000000005C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/globalsettings_incidenceeditor.kcfgc# Code generation options for kconfig_compiler
File=incidenceeditor.kcfg
ClassName=IncidenceEditorSettingsBase
NameSpace=IncidenceEditorNG
Singleton=false
Mutators=true
MemberVariables=public
GlobalEnums=true
ItemAccessors=true
SetUserTexts=true
Visibility=
TranslationDomain=libincidenceeditors
TranslationSystem=kde
07070111A01946000081A40000000200000002000000015AA55A8600000979000000FD0000001000000000000000000000004F00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/groupwareuidelegate.cpp/*
  Copyright (c) 2010 Kevin Ottens <ervin@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 "groupwareuidelegate.h"
#include "incidencedialog.h"
#include "incidencedialogfactory.h"

#include <CalendarSupport/Utils>

#include <Item>
#include "incidenceeditor_debug.h"
using namespace IncidenceEditorNG;

void GroupwareUiDelegate::requestIncidenceEditor(const Akonadi::Item &item)
{
// TODO_KDE5:
// The GroupwareUiDelegate interface should be a QObject. Right now we have no way of emitting a
// finished signal, so we have to use dialog->exec();

const KCalCore::Incidence::Ptr incidence = CalendarSupport::incidence(item);
    if (!incidence) {
        qCWarning(INCIDENCEEDITOR_LOG) << "Incidence is null, won't open the editor";
        return;
    }

IncidenceDialog *dialog = IncidenceDialogFactory::create(/*needs initial saving=*/ false,
                                                                                       incidence->type(),
                                                                                       nullptr);
    dialog->setAttribute(Qt::WA_DeleteOnClose, false);
    dialog->setIsCounterProposal(true);
    dialog->load(item, QDate::currentDate());
    dialog->exec();
    dialog->deleteLater();
    Akonadi::Item newItem = dialog->item();
    if (newItem.hasPayload<KCalCore::Incidence::Ptr>()) {
        KCalCore::IncidenceBase::Ptr newIncidence = newItem.payload<KCalCore::Incidence::Ptr>();
        *incidence.staticCast<KCalCore::IncidenceBase>() = *newIncidence;
    }
}

void GroupwareUiDelegate::setCalendar(const Akonadi::ETMCalendar::Ptr &calendar)
{
    // We don't need a calendar.
    Q_UNUSED(calendar);
}

void GroupwareUiDelegate::createCalendar()
{
    // We don't need a calendar
}
07070111A01947000081A40000000200000002000000015AA55A8600000520000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/groupwareuidelegate.h/*
  Copyright (c) 2010 Kevin Ottens <ervin@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 INCIDENCEEDITOR_GROUPWAREUIDELEGATE_H
#define INCIDENCEEDITOR_GROUPWAREUIDELEGATE_H

#include "incidenceeditor_export.h"

#include <Akonadi/Calendar/ITIPHandler>

// Class to edit counter proposals through incidence editors
namespace IncidenceEditorNG {
class INCIDENCEEDITOR_EXPORT GroupwareUiDelegate : public Akonadi::GroupwareUiDelegate
{
public:

void requestIncidenceEditor(const Akonadi::Item &item) override;
    void setCalendar(const Akonadi::ETMCalendar::Ptr &calendar) override;
    void createCalendar() override;
};
}

#endif
07070111A01948000081A40000000200000002000000015AA55A8600004059000000FD0000001000000000000000000000004A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencealarm.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidencealarm.h"
#include "alarmdialog.h"
#include "alarmpresets.h"
#include "incidencedatetime.h"
#include "ui_dialogdesktop.h"

#include <CalendarSupport/KCalPrefs>

using namespace IncidenceEditorNG;
using namespace CalendarSupport;

IncidenceAlarm::IncidenceAlarm(IncidenceDateTime *dateTime, Ui::EventOrTodoDesktop *ui)
    : mUi(ui)
    , mDateTime(dateTime)
    , mEnabledAlarmCount(0)
    , mIsTodo(false)
{
    setObjectName(QStringLiteral("IncidenceAlarm"));

mUi->mAlarmPresetCombo->insertItems(0, AlarmPresets::availablePresets());
    mUi->mAlarmPresetCombo->setCurrentIndex(AlarmPresets::defaultPresetIndex());
    updateButtons();

connect(mDateTime, &IncidenceDateTime::startDateTimeToggled, this,
            &IncidenceAlarm::handleDateTimeToggle);
    connect(mDateTime, &IncidenceDateTime::endDateTimeToggled, this,
            &IncidenceAlarm::handleDateTimeToggle);
    connect(mUi->mAlarmAddPresetButton, &QPushButton::clicked, this,
            &IncidenceAlarm::newAlarmFromPreset);
    connect(mUi->mAlarmList, &QListWidget::itemSelectionChanged, this,
            &IncidenceAlarm::updateButtons);
    connect(mUi->mAlarmNewButton, &QPushButton::clicked, this, &IncidenceAlarm::newAlarm);
    connect(mUi->mAlarmConfigureButton, &QPushButton::clicked, this,
            &IncidenceAlarm::editCurrentAlarm);
    connect(mUi->mAlarmToggleButton, &QPushButton::clicked, this,
            &IncidenceAlarm::toggleCurrentAlarm);
    connect(mUi->mAlarmRemoveButton, &QPushButton::clicked, this,
            &IncidenceAlarm::removeCurrentAlarm);
}

void IncidenceAlarm::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;
    // We must be sure that the date/time in mDateTime is the correct date time.
    // So don't depend on CombinedIncidenceEditor or whatever external factor to
    // load the date/time before loading the recurrence
    mDateTime->load(incidence);

mAlarms.clear();
    foreach (const KCalCore::Alarm::Ptr &alarm, incidence->alarms()) {
        mAlarms.append(KCalCore::Alarm::Ptr(new KCalCore::Alarm(*alarm.data())));
    }

mIsTodo = incidence->type() == KCalCore::Incidence::TypeTodo;
    if (mIsTodo) {
        mUi->mAlarmPresetCombo->clear();
        mUi->mAlarmPresetCombo->addItems(AlarmPresets::availablePresets(AlarmPresets::BeforeEnd));
    } else {
        mUi->mAlarmPresetCombo->clear();
        mUi->mAlarmPresetCombo->addItems(AlarmPresets::availablePresets(AlarmPresets::BeforeStart));
    }
    mUi->mAlarmPresetCombo->setCurrentIndex(AlarmPresets::defaultPresetIndex());

handleDateTimeToggle();
    mWasDirty = false;

updateAlarmList();
}

void IncidenceAlarm::save(const KCalCore::Incidence::Ptr &incidence)
{
    incidence->clearAlarms();
    const KCalCore::Alarm::List::ConstIterator end(mAlarms.constEnd());
    for (KCalCore::Alarm::List::ConstIterator it = mAlarms.constBegin(); it != end; ++it) {
        KCalCore::Alarm::Ptr al(new KCalCore::Alarm(*(*it)));
        al->setParent(incidence.data());
        // We need to make sure that both lists are the same in the end for isDirty.
        Q_ASSERT(*al == *(*it));
        incidence->addAlarm(al);
    }
}

bool IncidenceAlarm::isDirty() const
{
    if (mLoadedIncidence->alarms().count() != mAlarms.count()) {
        return true;
    }

if (!mLoadedIncidence->alarms().isEmpty()) {
        const KCalCore::Alarm::List initialAlarms = mLoadedIncidence->alarms();

if (initialAlarms.count() != mAlarms.count()) {
            return true; // The number of alarms has changed
        }

// Note: Not the most efficient algorithm but I'm assuming that we're only
        //       dealing with a couple, at most tens of alarms. The idea is we check
        //       if all currently enabled alarms are also in the incidence. The
        //       disabled alarms are not changed by our code at all, so we assume that
        //       they're still there.
        foreach (const KCalCore::Alarm::Ptr &alarm, mAlarms) {
            bool found = false;
            foreach (const KCalCore::Alarm::Ptr &initialAlarm, initialAlarms) {
                if (*alarm == *initialAlarm) {
                    found = true;
                    break;
                }
            }

if (!found) {
                // There was an alarm in the mLoadedIncidence->alarms() that wasn't found
                // in mLastAlarms. This means that one of the alarms was modified.
                return true;
            }
        }
    }

return false;
}

void IncidenceAlarm::editCurrentAlarm()
{
    KCalCore::Alarm::Ptr currentAlarm = mAlarms.at(mUi->mAlarmList->currentRow());

QPointer<AlarmDialog> dialog(new AlarmDialog(mLoadedIncidence->type(), mUi->mTabWidget));
    dialog->load(currentAlarm);

dialog->setAllowBeginReminders(mDateTime->startDateTimeEnabled());
    dialog->setAllowEndReminders(mDateTime->endDateTimeEnabled());

if (dialog->exec() == QDialog::Accepted) {
        dialog->save(currentAlarm);
        updateAlarmList();
        checkDirtyStatus();
    }
    delete dialog;
}

void IncidenceAlarm::handleDateTimeToggle()
{
    QWidget *parent = mUi->mAlarmPresetCombo->parentWidget();  // the parent of a toplevel widget
    if (parent) {
        parent->setEnabled(mDateTime->startDateTimeEnabled() || mDateTime->endDateTimeEnabled());
    }

mUi->mAlarmPresetCombo->setEnabled(mDateTime->endDateTimeEnabled());
    mUi->mAlarmAddPresetButton->setEnabled(mDateTime->endDateTimeEnabled());

mUi->mQuickAddReminderLabel->setEnabled(mDateTime->endDateTimeEnabled());
}

void IncidenceAlarm::newAlarm()
{
    QPointer<AlarmDialog> dialog(new AlarmDialog(mLoadedIncidence->type(), mUi->mTabWidget));
    const int reminderOffset = KCalPrefs::instance()->reminderTime();

if (reminderOffset >= 0) {
        dialog->setOffset(reminderOffset);
    } else {
        dialog->setOffset(DEFAULT_REMINDER_OFFSET);
    }
    dialog->setUnit(AlarmDialog::Minutes);
    if (mIsTodo && mDateTime->endDateTimeEnabled()) {
        dialog->setWhen(AlarmDialog::BeforeEnd);
    } else {
        dialog->setWhen(AlarmDialog::BeforeStart);
    }

dialog->setAllowBeginReminders(mDateTime->startDateTimeEnabled());
    dialog->setAllowEndReminders(mDateTime->endDateTimeEnabled());

if (dialog->exec() == QDialog::Accepted) {
        KCalCore::Alarm::Ptr newAlarm(new KCalCore::Alarm(nullptr));
        dialog->save(newAlarm);
        newAlarm->setEnabled(true);
        mAlarms.append(newAlarm);
        updateAlarmList();
        checkDirtyStatus();
    }
    delete dialog;
}

void IncidenceAlarm::newAlarmFromPreset()
{
    if (mIsTodo) {
        mAlarms.append(
            AlarmPresets::preset(AlarmPresets::BeforeEnd, mUi->mAlarmPresetCombo->currentText()));
    } else {
        mAlarms.append(
            AlarmPresets::preset(AlarmPresets::BeforeStart, mUi->mAlarmPresetCombo->currentText()));
    }

updateAlarmList();
    checkDirtyStatus();
}

void IncidenceAlarm::removeCurrentAlarm()
{
    Q_ASSERT(mUi->mAlarmList->selectedItems().size() == 1);
    const int curAlarmIndex = mUi->mAlarmList->currentRow();
    delete mUi->mAlarmList->takeItem(curAlarmIndex);
    mAlarms.remove(curAlarmIndex);

updateAlarmList();
    updateButtons();
    checkDirtyStatus();
}

void IncidenceAlarm::toggleCurrentAlarm()
{
    Q_ASSERT(mUi->mAlarmList->selectedItems().size() == 1);
    const int curAlarmIndex = mUi->mAlarmList->currentRow();
    KCalCore::Alarm::Ptr alarm = mAlarms.at(curAlarmIndex);
    alarm->setEnabled(!alarm->enabled());

updateButtons();
    updateAlarmList();
    checkDirtyStatus();
}

void IncidenceAlarm::updateAlarmList()
{
    const int prevEnabledAlarmCount = mEnabledAlarmCount;
    mEnabledAlarmCount = 0;

const QModelIndex currentIndex = mUi->mAlarmList->currentIndex();
    mUi->mAlarmList->clear();
    for (const KCalCore::Alarm::Ptr &alarm : qAsConst(mAlarms)) {
        mUi->mAlarmList->addItem(stringForAlarm(alarm));
        if (alarm->enabled()) {
            ++mEnabledAlarmCount;
        }
    }

mUi->mAlarmList->setCurrentIndex(currentIndex);
    if (prevEnabledAlarmCount != mEnabledAlarmCount) {
        Q_EMIT alarmCountChanged(mEnabledAlarmCount);
    }
}

void IncidenceAlarm::updateButtons()
{
    if (mUi->mAlarmList->count() > 0 && !mUi->mAlarmList->selectedItems().isEmpty()) {
        mUi->mAlarmConfigureButton->setEnabled(true);
        mUi->mAlarmRemoveButton->setEnabled(true);
        mUi->mAlarmToggleButton->setEnabled(true);
        KCalCore::Alarm::Ptr selAlarm;
        if (mUi->mAlarmList->currentIndex().isValid()) {
            selAlarm = mAlarms.at(mUi->mAlarmList->currentIndex().row());
        }
        if (selAlarm && selAlarm->enabled()) {
            mUi->mAlarmToggleButton->setText(i18nc("Disable currently selected reminder",
                                                   "Disable"));
        } else {
            mUi->mAlarmToggleButton->setText(i18nc("Enable currently selected reminder", "Enable"));
        }
    } else {
        mUi->mAlarmConfigureButton->setEnabled(false);
        mUi->mAlarmRemoveButton->setEnabled(false);
        mUi->mAlarmToggleButton->setEnabled(false);
    }
}

QString IncidenceAlarm::stringForAlarm(const KCalCore::Alarm::Ptr &alarm)
{
    Q_ASSERT(alarm);

QString action;
    switch (alarm->type()) {
    case KCalCore::Alarm::Display:
        action = i18nc("Alarm action", "Display a dialog");
        break;
    case KCalCore::Alarm::Procedure:
        action = i18nc("Alarm action", "Execute a script");
        break;
    case KCalCore::Alarm::Email:
        action = i18nc("Alarm action", "Send an email");
        break;
    case KCalCore::Alarm::Audio:
        action = i18nc("Alarm action", "Play an audio file");
        break;
    default:
        action = i18nc("Alarm action", "Invalid Reminder.");
        return action;
    }

const int offset = alarm->hasStartOffset() ? alarm->startOffset().asSeconds() / 60
                       : alarm->endOffset().asSeconds() / 60; // make minutes

QString offsetUnitTranslated
        = i18ncp("The reminder is set to X minutes before/after the event",
                 "1 minute", "%1 minutes", qAbs(offset));

int useoffset = offset;
    if (offset % (24 * 60) == 0 && offset != 0) {     // divides evenly into days?
        useoffset = offset / 60 / 24;
        offsetUnitTranslated = i18ncp("The reminder is set to X days before/after the event",
                             "1 day", "%1 days", qAbs(useoffset));
    } else if (offset % 60 == 0 && offset != 0) {   // divides evenly into hours?
        useoffset = offset / 60;
        offsetUnitTranslated = i18ncp("The reminder is set to X hours before/after the event",
                             "1 hour", "%1 hours", qAbs(useoffset));
    }

QString repeatStr;
    if (alarm->repeatCount() > 0) {
        repeatStr = i18nc("The reminder is configured to repeat after snooze", "(Repeats)");
    }

if (alarm->enabled()) {
        if (useoffset > 0 && alarm->hasStartOffset()) {
            if (mIsTodo) {
                // i18n: These series of strings are used to show the user a describtion of
                // the alarm. %1 is replaced by one of the actions above, %2 is replaced by
                // one of the time units above, %3 is the (Repeats) part that will be used
                // in case of repetition of the alarm.
                return i18n("%1 %2 after the to-do started %3",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 after the event started %3",
                            action, offsetUnitTranslated, repeatStr);
            }
        } else if (useoffset < 0 && alarm->hasStartOffset()) {
            if (mIsTodo) {
                return i18n("%1 %2 before the to-do starts %3",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 before the event starts %3",
                            action, offsetUnitTranslated, repeatStr);
            }
        } else if (useoffset > 0 && alarm->hasEndOffset()) {
            if (mIsTodo) {
                return i18n("%1 %2 after the to-do is due %3",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 after the event ends %3",
                            action, offsetUnitTranslated, repeatStr);
            }
        } else if (useoffset < 0 && alarm->hasEndOffset()) {
            if (mIsTodo) {
                return i18n("%1 %2 before the to-do is due %3",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 before the event ends %3",
                            action, offsetUnitTranslated, repeatStr);
            }
        }
    } else {
        if (useoffset > 0 && alarm->hasStartOffset()) {
            if (mIsTodo) {
                return i18n("%1 %2 after the to-do started %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 after the event started %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            }
        } else if (useoffset < 0 && alarm->hasStartOffset()) {
            if (mIsTodo) {
                return i18n("%1 %2 before the to-do starts %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 before the event starts %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            }
        } else if (useoffset > 0 && alarm->hasEndOffset()) {
            if (mIsTodo) {
                return i18n("%1 %2 after the to-do is due %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 after the event ends %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            }
        } else if (useoffset < 0 && alarm->hasEndOffset()) {
            if (mIsTodo) {
                return i18n("%1 %2 before the to-do is due %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            } else {
                return i18n("%1 %2 before the event ends %3 (Disabled)",
                            action, offsetUnitTranslated, repeatStr);
            }
        }
    }

// useoffset == 0
    if (alarm->enabled()) {
        if (mIsTodo && alarm->hasStartOffset()) {
            return i18n("%1 when the to-do starts", action);
        } else if (alarm->hasStartOffset()) {
            return i18n("%1 when the event starts", action);
        } else if (mIsTodo && alarm->hasEndOffset()) {
            return i18n("%1 when the to-do is due", action);
        } else {
            return i18n("%1 when the event ends", action);
        }
    } else {
        if (mIsTodo && alarm->hasStartOffset()) {
            return i18n("%1 when the to-do starts (Disabled)", action);
        } else if (alarm->hasStartOffset()) {
            return i18n("%1 when the event starts (Disabled)", action);
        } else if (mIsTodo && alarm->hasEndOffset()) {
            return i18n("%1 when the to-do is due (Disabled)", action);
        } else {
            return i18n("%1 when the event ends (Disabled)", action);
        }
    }
}
07070111A0194B000081A40000000200000002000000015AA55A8600000896000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencealarm.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_INCIDENCEALARM_H
#define INCIDENCEEDITOR_INCIDENCEALARM_H

#include "incidenceeditor-ng.h"

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class IncidenceDateTime;

class IncidenceAlarm : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::load;  // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::save;  // So we don't trigger -Woverloaded-virtual
    IncidenceAlarm(IncidenceDateTime *dateTime, Ui::EventOrTodoDesktop *ui);

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;

Q_SIGNALS:
    void alarmCountChanged(int newCount);

private:
    void editCurrentAlarm();
    void handleDateTimeToggle();
    void newAlarm();
    void newAlarmFromPreset();
    void removeCurrentAlarm();
    void toggleCurrentAlarm();
    void updateAlarmList();
    void updateButtons();
    QString stringForAlarm(const KCalCore::Alarm::Ptr &alarm);

private:
    Ui::EventOrTodoDesktop *mUi = nullptr;

KCalCore::Alarm::List mAlarms;
    IncidenceDateTime *mDateTime = nullptr;
    int mEnabledAlarmCount = 0;
    bool mIsTodo = false;
};
}

#endif
07070111A0194C000081A40000000200000002000000015AA55A86000054F8000000FD0000001000000000000000000000004F00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceattachment.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidenceattachment.h"
#include "attachmenteditdialog.h"
#include "attachmenticonview.h"
#include "ui_dialogdesktop.h"

#include <KdepimDBusInterfaces/UriHandler>

#include <KContacts/VCardDrag>

#include <KMime/Message>

#include <QAction>
#include <KActionCollection>
#include <QFileDialog>
#include <QMenu>
#include <KMessageBox>
#include <KProtocolManager>
#include <KRun>
#include <KIO/Job>
#include <KIO/StoredTransferJob>
#include <KJobWidgets>
#include <KLocalizedString>
#include <QIcon>
#include <QUrl>

#include <QClipboard>
#include <QMimeData>
#include <QMimeDatabase>
#include <QMimeType>

using namespace IncidenceEditorNG;

IncidenceAttachment::IncidenceAttachment(Ui::EventOrTodoDesktop *ui)
    : IncidenceEditor(nullptr)
    , mUi(ui)
    , mPopupMenu(new QMenu)
{
    setupActions();
    setupAttachmentIconView();
    setObjectName(QStringLiteral("IncidenceAttachment"));

connect(mUi->mAddButton, &QPushButton::clicked, this, &IncidenceAttachment::addAttachment);
    connect(mUi->mRemoveButton, &QPushButton::clicked, this,
            &IncidenceAttachment::removeSelectedAttachments);
}

IncidenceAttachment::~IncidenceAttachment()
{
    delete mPopupMenu;
}

void IncidenceAttachment::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;
    mAttachmentView->clear();

KCalCore::Attachment::List attachments = incidence->attachments();
    for (KCalCore::Attachment::List::ConstIterator it = attachments.constBegin(),
         end = attachments.constEnd();
         it != end; ++it) {
        new AttachmentIconItem((*it), mAttachmentView);
    }

mWasDirty = false;
}

void IncidenceAttachment::save(const KCalCore::Incidence::Ptr &incidence)
{
    incidence->clearAttachments();

for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
        QListWidgetItem *item = mAttachmentView->item(itemIndex);
        AttachmentIconItem *attitem = dynamic_cast<AttachmentIconItem *>(item);
        Q_ASSERT(item);
        incidence->addAttachment(
            KCalCore::Attachment::Ptr(new KCalCore::Attachment(*(attitem->attachment()))));
    }
}

bool IncidenceAttachment::isDirty() const
{
    if (mLoadedIncidence) {
        if (mAttachmentView->count() != mLoadedIncidence->attachments().count()) {
            return true;
        }

KCalCore::Attachment::List origAttachments = mLoadedIncidence->attachments();
        for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
            QListWidgetItem *item = mAttachmentView->item(itemIndex);
            Q_ASSERT(dynamic_cast<AttachmentIconItem *>(item));

const KCalCore::Attachment::Ptr listAttachment
                = static_cast<AttachmentIconItem *>(item)->attachment();

for (int i = 0; i < origAttachments.count(); ++i) {
                const KCalCore::Attachment::Ptr attachment = origAttachments.at(i);

if (*attachment == *listAttachment) {
                    origAttachments.remove(i);
                    break;
                }
            }
        }
        // All attachments are removed from the list, meaning, the items in mAttachmentView
        // are equal to the attachments set on mLoadedIncidence.
        return !origAttachments.isEmpty();
    } else {
        // No incidence loaded, so if the user added attachments we're dirty.
        return mAttachmentView->count() != 0;
    }
}

int IncidenceAttachment::attachmentCount() const
{
    return mAttachmentView->count();
}

/// Private slots

void IncidenceAttachment::addAttachment()
{
    QPointer<QObject> that(this);
    AttachmentIconItem *item = new AttachmentIconItem(KCalCore::Attachment::Ptr(), mAttachmentView);

QPointer<AttachmentEditDialog> dialog(new AttachmentEditDialog(item, mAttachmentView));
    dialog->setWindowTitle(i18nc("@title", "Add Attachment"));
    auto dialogResult = dialog->exec();
    if (!that) {
        return;
    }

if (dialogResult == QDialog::Rejected) {
        delete item;
    } else {
        Q_EMIT attachmentCountChanged(mAttachmentView->count());
    }
    delete dialog;

checkDirtyStatus();
}

void IncidenceAttachment::copyToClipboard()
{
#ifndef QT_NO_CLIPBOARD
    QApplication::clipboard()->setMimeData(mAttachmentView->mimeData(), QClipboard::Clipboard);
#endif
}

void IncidenceAttachment::openURL(const QUrl &url)
{
    QString uri = url.url();
    UriHandler::process(uri);
}

void IncidenceAttachment::pasteFromClipboard()
{
#ifndef QT_NO_CLIPBOARD
    handlePasteOrDrop(QApplication::clipboard()->mimeData());
#endif
}

void IncidenceAttachment::removeSelectedAttachments()
{
    QList<QListWidgetItem *> selected;
    QStringList labels;

for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
        QListWidgetItem *it = mAttachmentView->item(itemIndex);
        if (it->isSelected()) {
            AttachmentIconItem *attitem = static_cast<AttachmentIconItem *>(it);
            if (attitem) {
                KCalCore::Attachment::Ptr att = attitem->attachment();
                labels << att->label();
                selected << it;
            }
        }
    }

if (selected.isEmpty()) {
        return;
    }

QString labelsStr = labels.join(QStringLiteral("<nl/>"));

if (KMessageBox::questionYesNo(
            nullptr,
            xi18nc("@info",
                   "Do you really want to remove these attachments?<nl/>%1", labelsStr),
            i18nc("@title:window", "Remove Attachments?"),
            KStandardGuiItem::yes(), KStandardGuiItem::no(),
            QStringLiteral("calendarRemoveAttachments")) != KMessageBox::Yes) {
        return;
    }

for (QList<QListWidgetItem *>::iterator it(selected.begin()), end(selected.end());
         it != end; ++it) {
        int row = mAttachmentView->row(*it);
        QListWidgetItem *next = mAttachmentView->item(++row);
        QListWidgetItem *prev = mAttachmentView->item(--row);
        if (next) {
            next->setSelected(true);
        } else if (prev) {
            prev->setSelected(true);
        }
        delete *it;
    }

mAttachmentView->update();
    Q_EMIT attachmentCountChanged(mAttachmentView->count());
    checkDirtyStatus();
}

void IncidenceAttachment::saveAttachment(QListWidgetItem *item)
{
    Q_ASSERT(item);
    Q_ASSERT(dynamic_cast<AttachmentIconItem *>(item));

AttachmentIconItem *attitem = static_cast<AttachmentIconItem *>(item);
    if (!attitem->attachment()) {
        return;
    }

KCalCore::Attachment::Ptr att = attitem->attachment();

// get the saveas file name
    const QString saveAsFile = QFileDialog::getSaveFileName(nullptr, i18nc("@title", "Save Attachment"),
                                                      att->label());

if (saveAsFile.isEmpty()) {
        return;
    }

QUrl sourceUrl;
    if (att->isUri()) {
        sourceUrl = QUrl(att->uri());
    } else {
        sourceUrl = mAttachmentView->tempFileForAttachment(att);
    }
    // save the attachment url
    auto job = KIO::file_copy(sourceUrl, QUrl::fromLocalFile(saveAsFile));
    if (!job->exec() && job->error()) {
        KMessageBox::error(nullptr, job->errorString());
    }
}

void IncidenceAttachment::saveSelectedAttachments()
{
    for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
        QListWidgetItem *item = mAttachmentView->item(itemIndex);
        if (item->isSelected()) {
            saveAttachment(item);
        }
    }
}

void IncidenceAttachment::showAttachment(QListWidgetItem *item)
{
    Q_ASSERT(item);
    Q_ASSERT(dynamic_cast<AttachmentIconItem *>(item));
    AttachmentIconItem *attitem = static_cast<AttachmentIconItem *>(item);
    if (!attitem->attachment()) {
        return;
    }

KCalCore::Attachment::Ptr att = attitem->attachment();
    if (att->isUri()) {
        openURL(QUrl(att->uri()));
    } else {
        KRun::RunFlags flags;
        flags |= KRun::DeleteTemporaryFiles;
        flags |= KRun::RunExecutables;
        KRun::runUrl(mAttachmentView->tempFileForAttachment(att), att->mimeType(), nullptr, flags);
    }
}

void IncidenceAttachment::showContextMenu(const QPoint &pos)
{
    QListWidgetItem *item = mAttachmentView->itemAt(pos);
    const bool enable = item != nullptr;

int numSelected = 0;
    for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
        QListWidgetItem *item = mAttachmentView->item(itemIndex);
        if (item->isSelected()) {
            numSelected++;
        }
    }

mOpenAction->setEnabled(enable);
    //TODO: support saving multiple attachments into a directory
    mSaveAsAction->setEnabled(enable && numSelected == 1);
#ifndef QT_NO_CLIPBOARD
    mCopyAction->setEnabled(enable && numSelected == 1);
    mCutAction->setEnabled(enable && numSelected == 1);
#endif
    mDeleteAction->setEnabled(enable);
    mEditAction->setEnabled(enable);
    mPopupMenu->exec(mAttachmentView->mapToGlobal(pos));
}

void IncidenceAttachment::showSelectedAttachments()
{
    for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
        QListWidgetItem *item = mAttachmentView->item(itemIndex);
        if (item->isSelected()) {
            showAttachment(item);
        }
    }
}

void IncidenceAttachment::cutToClipboard()
{
#ifndef QT_NO_CLIPBOARD
    copyToClipboard();
    removeSelectedAttachments();
#endif
}

void IncidenceAttachment::editSelectedAttachments()
{
    for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
        QListWidgetItem *item = mAttachmentView->item(itemIndex);
        if (item->isSelected()) {
            Q_ASSERT(dynamic_cast<AttachmentIconItem *>(item));

AttachmentIconItem *attitem = static_cast<AttachmentIconItem *>(item);
            if (!attitem->attachment()) {
                return;
            }

QPointer<AttachmentEditDialog> dialog(
                new AttachmentEditDialog(attitem, mAttachmentView, false));
            dialog->setModal(false);
            dialog->setAttribute(Qt::WA_DeleteOnClose, true);
            dialog->show();
        }
    }
}

void IncidenceAttachment::slotItemRenamed(QListWidgetItem *item)
{
    Q_ASSERT(item);
    Q_ASSERT(dynamic_cast<AttachmentIconItem *>(item));
    static_cast<AttachmentIconItem *>(item)->setLabel(item->text());
    checkDirtyStatus();
}

void IncidenceAttachment::slotSelectionChanged()
{
    bool selected = false;
    for (int itemIndex = 0; itemIndex < mAttachmentView->count(); ++itemIndex) {
        QListWidgetItem *item = mAttachmentView->item(itemIndex);
        if (item->isSelected()) {
            selected = true;
            break;
        }
    }
    mUi->mRemoveButton->setEnabled(selected);
}

/// Private functions

void IncidenceAttachment::handlePasteOrDrop(const QMimeData *mimeData)
{
    QList<QUrl> urls;
    bool probablyWeHaveUris = false;
    QStringList labels;

if (KContacts::VCardDrag::canDecode(mimeData)) {
        KContacts::Addressee::List addressees;
        KContacts::VCardDrag::fromMimeData(mimeData, addressees);
        urls.reserve(addressees.count());
        labels.reserve(addressees.count());
        const KContacts::Addressee::List::ConstIterator end(addressees.constEnd());
        for (KContacts::Addressee::List::ConstIterator it = addressees.constBegin();
             it != end; ++it) {
            urls.append(QUrl(QStringLiteral("uid:") + (*it).uid()));
            // there is some weirdness about realName(), hence fromUtf8
            labels.append(QString::fromUtf8((*it).realName().toLatin1()));
        }
        probablyWeHaveUris = true;
    } else if (mimeData->hasUrls()) {
        QMap<QString, QString> metadata;

//QT5
        //urls = QList<QUrl>::fromMimeData( mimeData, &metadata );
        probablyWeHaveUris = true;
        labels
            = metadata[QStringLiteral("labels")].split(QLatin1Char(':'), QString::SkipEmptyParts);
        const QStringList::Iterator end(labels.end());
        for (QStringList::Iterator it = labels.begin(); it != end; ++it) {
            *it = QUrl::fromPercentEncoding((*it).toLatin1());
        }
    } else if (mimeData->hasText()) {
        const QString text = mimeData->text();
        QStringList lst = text.split(QLatin1Char('\n'), QString::SkipEmptyParts);
        urls.reserve(lst.count());
        QStringList::ConstIterator end(lst.constEnd());
        for (QStringList::ConstIterator it = lst.constBegin(); it != end; ++it) {
            urls.append(QUrl(*it));
        }
        probablyWeHaveUris = true;
    }
    QMenu menu;
    QAction *linkAction = nullptr, *cancelAction = nullptr;
    if (probablyWeHaveUris) {
        linkAction
            = menu.addAction(QIcon::fromTheme(QStringLiteral("insert-link")),
                             i18nc("@action:inmenu", "&Link here"));
        // we need to check if we can reasonably expect to copy the objects
        bool weCanCopy = true;
        QList<QUrl>::ConstIterator end(urls.constEnd());
        for (QList<QUrl>::ConstIterator it = urls.constBegin(); it != end; ++it) {
            if (!(weCanCopy = KProtocolManager::supportsReading(*it))) {
                break; // either we can copy them all, or no copying at all
            }
        }
        if (weCanCopy) {
            menu.addAction(QIcon::fromTheme(QStringLiteral("edit-copy")),
                           i18nc("@action:inmenu", "&Copy here"));
        }
    } else {
        menu.addAction(QIcon::fromTheme(QStringLiteral("edit-copy")),
                       i18nc("@action:inmenu", "&Copy here"));
    }

menu.addSeparator();
    cancelAction
        = menu.addAction(QIcon::fromTheme(QStringLiteral("process-stop")),
                         i18nc("@action:inmenu", "C&ancel"));

QByteArray data;
    QString mimeType;
    QString label;

if (!mimeData->formats().isEmpty() && !probablyWeHaveUris) {
        mimeType = mimeData->formats().first();
        data = mimeData->data(mimeType);
        QMimeDatabase db;
        QMimeType mime = db.mimeTypeForName(mimeType);
        if (mime.isValid()) {
            label = mime.comment();
        }
    }

QAction *ret = menu.exec(QCursor::pos());
    if (linkAction == ret) {
        QStringList::ConstIterator jt = labels.constBegin();
        const QList<QUrl>::ConstIterator jtEnd = urls.constEnd();
        for (QList<QUrl>::ConstIterator it = urls.constBegin();
             it != jtEnd; ++it) {
            addUriAttachment((*it).url(), QString(), (jt == labels.constEnd()
                                                      ? QString() : *(jt++)), true);
        }
    } else if (cancelAction != ret) {
        if (probablyWeHaveUris) {
            QList<QUrl>::ConstIterator end = urls.constEnd();
            for (QList<QUrl>::ConstIterator it = urls.constBegin();
                 it != end; ++it) {
                KIO::Job *job = KIO::storedGet(*it);
                //TODO verify if slot exist !
                connect(job, &KIO::Job::result, this, &IncidenceAttachment::downloadComplete);
            }
        } else { // we take anything
            addDataAttachment(data, mimeType, label);
        }
    }
}

void IncidenceAttachment::downloadComplete(KJob *)
{
    //TODO
}

void IncidenceAttachment::setupActions()
{
    KActionCollection *ac = new KActionCollection(this);
//  ac->addAssociatedWidget( this );

mOpenAction = new QAction(QIcon::fromTheme(QStringLiteral("document-open")),i18nc("@action:inmenu open the attachment in a viewer",
                                    "&Open"), this);
    connect(mOpenAction, &QAction::triggered, this, &IncidenceAttachment::showSelectedAttachments);
    ac->addAction(QStringLiteral("view"), mOpenAction);
    mPopupMenu->addAction(mOpenAction);

mSaveAsAction = new QAction(QIcon::fromTheme(QStringLiteral("document-save-as")), i18nc("@action:inmenu save the attachment to a file",
                                      "Save As..."), this);
    connect(mSaveAsAction, &QAction::triggered, this,
            &IncidenceAttachment::saveSelectedAttachments);
    mPopupMenu->addAction(mSaveAsAction);
    mPopupMenu->addSeparator();

#ifndef QT_NO_CLIPBOARD
    mCopyAction = KStandardAction::copy(this, &IncidenceAttachment::copyToClipboard, ac);
    mPopupMenu->addAction(mCopyAction);

mCutAction = KStandardAction::cut(this, &IncidenceAttachment::cutToClipboard, ac);
    mPopupMenu->addAction(mCutAction);

QAction *action = KStandardAction::paste(this, &IncidenceAttachment::pasteFromClipboard, ac);
    mPopupMenu->addAction(action);
    mPopupMenu->addSeparator();
#endif

mDeleteAction = new QAction(QIcon::fromTheme(QStringLiteral("list-remove")), i18nc("@action:inmenu remove the attachment",
                                      "&Remove"), this);
    connect(mDeleteAction, &QAction::triggered, this,
            &IncidenceAttachment::removeSelectedAttachments);
    ac->addAction(QStringLiteral("remove"), mDeleteAction);
    mDeleteAction->setShortcut(Qt::Key_Delete);
    mPopupMenu->addAction(mDeleteAction);
    mPopupMenu->addSeparator();

mEditAction = new QAction(QIcon::fromTheme(QStringLiteral("document-properties")), i18nc("@action:inmenu show a dialog used to edit the attachment",
                                    "&Properties..."), this);
    connect(mEditAction, &QAction::triggered, this, &IncidenceAttachment::editSelectedAttachments);
    ac->addAction(QStringLiteral("edit"), mEditAction);
    mPopupMenu->addAction(mEditAction);
}

void IncidenceAttachment::setupAttachmentIconView()
{
    mAttachmentView = new AttachmentIconView;
    mAttachmentView->setWhatsThis(i18nc("@info:whatsthis",
                                        "Displays items (files, mail, etc.) that "
                                        "have been associated with this event or to-do."));

connect(mAttachmentView, &AttachmentIconView::itemDoubleClicked, this,
            &IncidenceAttachment::showAttachment);
    connect(mAttachmentView, &AttachmentIconView::itemChanged, this,
            &IncidenceAttachment::slotItemRenamed);
    connect(mAttachmentView, &AttachmentIconView::itemSelectionChanged, this,
            &IncidenceAttachment::slotSelectionChanged);
    connect(mAttachmentView, &AttachmentIconView::customContextMenuRequested, this,
            &IncidenceAttachment::showContextMenu);

QGridLayout *layout = new QGridLayout(mUi->mAttachmentViewPlaceHolder);
    layout->setMargin(0);
    layout->addWidget(mAttachmentView);
}

// void IncidenceAttachmentEditor::addAttachment( KCalCore::Attachment *attachment )
// {
//   new AttachmentIconItem( attachment, mAttachmentView );
// }

void IncidenceAttachment::addDataAttachment(const QByteArray &data, const QString &mimeType,
                                            const QString &label)
{
    AttachmentIconItem *item = new AttachmentIconItem(KCalCore::Attachment::Ptr(), mAttachmentView);

QString nlabel = label;
    if (mimeType == QLatin1String("message/rfc822")) {
        // mail message. try to set the label from the mail Subject:
        KMime::Message msg;
        msg.setContent(data);
        msg.parse();
        nlabel = msg.subject()->asUnicodeString();
    }

item->setData(data);
    item->setLabel(nlabel);
    if (mimeType.isEmpty()) {
        QMimeDatabase db;
        item->setMimeType(db.mimeTypeForData(data).name());
    } else {
        item->setMimeType(mimeType);
    }

checkDirtyStatus();
}

void IncidenceAttachment::addUriAttachment(const QString &uri, const QString &mimeType,
                                           const QString &label, bool inLine)
{
    if (!inLine) {
        AttachmentIconItem *item
            = new AttachmentIconItem(KCalCore::Attachment::Ptr(), mAttachmentView);
        item->setUri(uri);
        item->setLabel(label);
        if (mimeType.isEmpty()) {
            if (uri.startsWith(QStringLiteral("uid:"))) {
                item->setMimeType(QStringLiteral("text/directory"));
            } else if (uri.startsWith(QStringLiteral("kmail:"))) {
                item->setMimeType(QStringLiteral("message/rfc822"));
            } else if (uri.startsWith(QStringLiteral("urn:x-ical"))) {
                item->setMimeType(QStringLiteral("text/calendar"));
            } else if (uri.startsWith(QStringLiteral("news:"))) {
                item->setMimeType(QStringLiteral("message/news"));
            } else {
                QMimeDatabase db;
                item->setMimeType(db.mimeTypeForUrl(QUrl(uri)).name());
            }
        }
    } else {
        auto job = KIO::storedGet(QUrl(uri));
        KJobWidgets::setWindow(job, nullptr);
        if (job->exec()) {
            const QByteArray data = job->data();
            addDataAttachment(data, mimeType, label);
        }
    }
}
07070111A0194D000081A40000000200000002000000015AA55A8600000D82000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceattachment.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_INCIDENCEATTACHMENT_H
#define INCIDENCEEDITOR_INCIDENCEATTACHMENT_H

#include "incidenceeditor-ng.h"
class QUrl;
class KJob;
namespace Ui {
class EventOrTodoDesktop;
}

class QMenu;

class QListWidgetItem;
class QMimeData;
class QAction;
namespace IncidenceEditorNG {
class AttachmentIconView;

class IncidenceAttachment : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual

explicit IncidenceAttachment(Ui::EventOrTodoDesktop *ui);

~IncidenceAttachment();

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;

int attachmentCount() const;

Q_SIGNALS:
    void attachmentCountChanged(int newCount);

private:
    void addAttachment();
    void copyToClipboard(); /// Copies selected items to clip board
    void cutToClipboard();  /// Copies selected items to clipboard and removes them from the list
    void editSelectedAttachments();
    void openURL(const QUrl &url);
    void pasteFromClipboard();
    void removeSelectedAttachments();
    void saveAttachment(QListWidgetItem *item);
    void saveSelectedAttachments();
    void showAttachment(QListWidgetItem *item);
    void showContextMenu(const QPoint &pos);
    void showSelectedAttachments();
    void slotItemRenamed(QListWidgetItem *item);
    void slotSelectionChanged();
    void downloadComplete(KJob *);

private:
    //     void addAttachment( KCalCore::Attachment *attachment );
    void addDataAttachment(const QByteArray &data,
                           const QString &mimeType = QString(), const QString &label = QString());
    void addUriAttachment(const QString &uri,
                          const QString &mimeType = QString(),
                          const QString &label = QString(), bool inLine = false);
    void handlePasteOrDrop(const QMimeData *mimeData);
    void setupActions();
    void setupAttachmentIconView();

private:
    AttachmentIconView *mAttachmentView = nullptr;
    Ui::EventOrTodoDesktop *mUi = nullptr;

QMenu *mPopupMenu = nullptr;
    QAction *mOpenAction = nullptr;
    QAction *mSaveAsAction = nullptr;
#ifndef QT_NO_CLIPBOARD
    QAction *mCopyAction = nullptr;
    QAction *mCutAction = nullptr;
#endif
    QAction *mDeleteAction = nullptr;
    QAction *mEditAction = nullptr;
};
}

#endif
07070111A0194E000081A40000000200000002000000015AA55A860000AE94000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceattendee.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (c) 2009-2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

Based on old attendeeeditor.cpp:
  Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org>
  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
  Copyright (c) 2007 Volker Krause <vkrause@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 "incidenceattendee.h"
#include "attendeetablemodel.h"
#include "attendeeeditor.h"
#include "attendeecomboboxdelegate.h"
#include "attendeelineeditdelegate.h"
#include "conflictresolver.h"
#include "editorconfig.h"
#include "incidencedatetime.h"
#include "schedulingdialog.h"
#include "CalendarSupport/FreeBusyItemModel"
#include "ui_dialogdesktop.h"

#include <Akonadi/Contact/ContactGroupExpandJob>
#include <Akonadi/Contact/ContactGroupSearchJob>
#include <Akonadi/Contact/EmailAddressSelectionDialog>

#include <KEmailAddress>
#include <KCalUtils/Stringify>

#include "incidenceeditor_debug.h"
#include <QTreeView>
#include <KMessageBox>
#include <KLocalizedString>

using namespace IncidenceEditorNG;

IncidenceAttendee::IncidenceAttendee(QWidget *parent, IncidenceDateTime *dateTime,
                                     Ui::EventOrTodoDesktop *ui)
    : mUi(ui)
    , mParentWidget(parent)
    , mConflictResolver(nullptr)
    , mDateTime(dateTime)
    , mStateDelegate(new AttendeeComboBoxDelegate(this))
    , mRoleDelegate(new AttendeeComboBoxDelegate(this))
    , mResponseDelegate(new AttendeeComboBoxDelegate(this))
{
    KCalCore::Attendee::List attendees;
    KCalCore::Attendee::Ptr attendee(new KCalCore::Attendee(QLatin1String(""), QLatin1String("")));
    attendees.append(attendee);
    mDataModel = new AttendeeTableModel(attendees, this);
    mDataModel->setKeepEmpty(true);
    mDataModel->setRemoveEmptyLines(true);
    mOldIconName = QIcon::themeName();
    QIcon::setThemeName(QStringLiteral("oxygen"));
    mRoleDelegate->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant")),
                           KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::ReqParticipant));
    mRoleDelegate->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant-optional")),
                           KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::OptParticipant));
    mRoleDelegate->addItem(QIcon::fromTheme(QStringLiteral("meeting-observer")),
                           KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::NonParticipant));
    mRoleDelegate->addItem(QIcon::fromTheme(QStringLiteral("meeting-chair")),
                           KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::Chair));

mResponseDelegate->addItem(QIcon::fromTheme(QStringLiteral(
                                                    "meeting-participant-request-response")),
                               i18nc("@item:inlistbox", "Request Response"));
    mResponseDelegate->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant-no-response")),
                               i18nc("@item:inlistbox", "Request No Response"));

mStateDelegate->setWhatsThis(i18nc("@info:whatsthis",
                                       "Edits the current attendance status of the attendee."));

mRoleDelegate->setWhatsThis(i18nc("@info:whatsthis",
                                      "Edits the role of the attendee."));

mResponseDelegate->setToolTip(i18nc("@info:tooltip", "Request a response from the attendee"));
    mResponseDelegate->setWhatsThis(i18nc("@info:whatsthis",
                                          "Edits whether to send an email to the "
                                          "attendee to request a response concerning "
                                          "attendance."));

setObjectName(QStringLiteral("IncidenceAttendee"));

AttendeeFilterProxyModel *filterProxyModel = new AttendeeFilterProxyModel(this);
    filterProxyModel->setDynamicSortFilter(true);
    filterProxyModel->setSourceModel(mDataModel);

connect(mUi->mGroupSubstitution, &QPushButton::clicked, this,
            &IncidenceAttendee::slotGroupSubstitutionPressed);

mUi->mAttendeeTable->setModel(filterProxyModel);

mAttendeeDelegate = new AttendeeLineEditDelegate(this);

mUi->mAttendeeTable->setItemDelegateForColumn(AttendeeTableModel::Role, roleDelegate());
    mUi->mAttendeeTable->setItemDelegateForColumn(AttendeeTableModel::FullName, attendeeDelegate());
    mUi->mAttendeeTable->setItemDelegateForColumn(AttendeeTableModel::Status, stateDelegate());
    mUi->mAttendeeTable->setItemDelegateForColumn(AttendeeTableModel::Response, responseDelegate());

mUi->mOrganizerStack->setCurrentIndex(0);

fillOrganizerCombo();
    mUi->mSolveButton->setEnabled(false);
    mUi->mOrganizerLabel->setVisible(false);

mConflictResolver = new ConflictResolver(parent, parent);
    mConflictResolver->setEarliestDate(mDateTime->startDate());
    mConflictResolver->setEarliestTime(mDateTime->startTime());
    mConflictResolver->setLatestDate(mDateTime->endDate());
    mConflictResolver->setLatestTime(mDateTime->endTime());

connect(mUi->mSelectButton, &QPushButton::clicked, this,
            &IncidenceAttendee::slotSelectAddresses);
    connect(mUi->mSolveButton, &QPushButton::clicked, this,
            &IncidenceAttendee::slotSolveConflictPressed);
    /* Added as part of kolab/issue2297, which is currently under review
    connect(mUi->mOrganizerCombo, QOverload<const QString &>::of(&KComboBox::activated),
            this, &IncidenceAttendee::slotOrganizerChanged);
    */
    connect(mUi->mOrganizerCombo, QOverload<int>::of(&KComboBox::currentIndexChanged),
            this, &IncidenceAttendee::checkDirtyStatus);

connect(mDateTime, &IncidenceDateTime::startDateChanged, this,
            &IncidenceAttendee::slotEventDurationChanged);
    connect(mDateTime, &IncidenceDateTime::endDateChanged, this,
            &IncidenceAttendee::slotEventDurationChanged);
    connect(mDateTime, &IncidenceDateTime::startTimeChanged, this,
            &IncidenceAttendee::slotEventDurationChanged);
    connect(mDateTime, &IncidenceDateTime::endTimeChanged, this,
            &IncidenceAttendee::slotEventDurationChanged);

connect(mConflictResolver, &ConflictResolver::conflictsDetected, this,
            &IncidenceAttendee::slotUpdateConflictLabel);

connect(mConflictResolver->model(), SIGNAL(rowsInserted(QModelIndex,int,int)),
            SLOT(slotFreeBusyAdded(QModelIndex,int,int)));
    connect(mConflictResolver->model(), SIGNAL(layoutChanged()), SLOT(updateFBStatus()));
    connect(mConflictResolver->model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
            SLOT(slotFreeBusyChanged(QModelIndex,QModelIndex)));

slotUpdateConflictLabel(0);   //initialize label

// confict resolver (should show also resources)
    connect(mDataModel, &AttendeeTableModel::layoutChanged, this,
            &IncidenceAttendee::slotConflictResolverLayoutChanged);
    connect(mDataModel, &AttendeeTableModel::rowsAboutToBeRemoved, this,
            &IncidenceAttendee::slotConflictResolverAttendeeRemoved);
    connect(mDataModel, &AttendeeTableModel::rowsInserted, this,
            &IncidenceAttendee::slotConflictResolverAttendeeAdded);
    connect(mDataModel, &AttendeeTableModel::dataChanged, this,
            &IncidenceAttendee::slotConflictResolverAttendeeChanged);

//Group substitution
    connect(filterProxyModel, &AttendeeFilterProxyModel::layoutChanged, this,
            &IncidenceAttendee::slotGroupSubstitutionLayoutChanged);
    connect(filterProxyModel, &AttendeeFilterProxyModel::rowsAboutToBeRemoved, this,
            &IncidenceAttendee::slotGroupSubstitutionAttendeeRemoved);
    connect(filterProxyModel, &AttendeeFilterProxyModel::rowsInserted, this,
            &IncidenceAttendee::slotGroupSubstitutionAttendeeAdded);
    connect(filterProxyModel, &AttendeeFilterProxyModel::dataChanged, this,
            &IncidenceAttendee::slotGroupSubstitutionAttendeeChanged);

connect(filterProxyModel, &AttendeeFilterProxyModel::rowsInserted, this,
            &IncidenceAttendee::updateCount);
    connect(filterProxyModel, &AttendeeFilterProxyModel::rowsRemoved, this,
            &IncidenceAttendee::updateCount);
    // only update when FullName is changed
    connect(filterProxyModel, &AttendeeFilterProxyModel::dataChanged, this,
            &IncidenceAttendee::updateCount);
    connect(filterProxyModel, &AttendeeFilterProxyModel::layoutChanged, this,
            &IncidenceAttendee::updateCount);
    connect(filterProxyModel, &AttendeeFilterProxyModel::layoutChanged, this,
            &IncidenceAttendee::filterLayoutChanged);
}

IncidenceAttendee::~IncidenceAttendee()
{
    QIcon::setThemeName(mOldIconName);
}

void IncidenceAttendee::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;

if (iAmOrganizer() || incidence->organizer()->isEmpty()) {
        mUi->mOrganizerStack->setCurrentIndex(0);

int found = -1;
        const QString fullOrganizer = incidence->organizer()->fullName();
        const QString organizerEmail = incidence->organizer()->email();
        for (int i = 0; i < mUi->mOrganizerCombo->count(); ++i) {
            KCalCore::Person::Ptr organizerCandidate
                = KCalCore::Person::fromFullName(mUi->mOrganizerCombo->itemText(i));
            if (organizerCandidate->email() == organizerEmail) {
                found = i;
                mUi->mOrganizerCombo->setCurrentIndex(i);
                break;
            }
        }
        if (found < 0 && !fullOrganizer.isEmpty()) {
            mUi->mOrganizerCombo->insertItem(0, fullOrganizer);
            mUi->mOrganizerCombo->setCurrentIndex(0);
        }

mUi->mOrganizerLabel->setVisible(false);
    } else { // someone else is the organizer
        mUi->mOrganizerStack->setCurrentIndex(1);
        mUi->mOrganizerLabel->setText(incidence->organizer()->fullName());
        mUi->mOrganizerLabel->setVisible(true);
    }

KCalCore::Attendee::List attendees;
    const KCalCore::Attendee::List incidenceAttendees = incidence->attendees();
    attendees.reserve(incidenceAttendees.count());
    for (const KCalCore::Attendee::Ptr &a : incidenceAttendees) {
        attendees << KCalCore::Attendee::Ptr(new KCalCore::Attendee(*a));
    }

mDataModel->setAttendees(attendees);
    slotUpdateConflictLabel(0);

setActions(incidence->type());

mWasDirty = false;
}

void IncidenceAttendee::save(const KCalCore::Incidence::Ptr &incidence)
{
    incidence->clearAttendees();
    const KCalCore::Attendee::List attendees = mDataModel->attendees();

for (const KCalCore::Attendee::Ptr &attendee : attendees) {
        Q_ASSERT(attendee);

bool skip = false;
        if (attendee->fullName().isEmpty()) {
            continue;
        }
        if (KEmailAddress::isValidAddress(attendee->email())) {
            if (KMessageBox::warningYesNo(
                    nullptr,
                    i18nc("@info",
                          "%1 does not look like a valid email address. "
                          "Are you sure you want to invite this participant?",
                          attendee->email()),
                    i18nc("@title:window", "Invalid Email Address")) != KMessageBox::Yes) {
                skip = true;
            }
        }
        if (!skip) {
            incidence->addAttendee(attendee);
        }
    }

// Must not have an organizer for items without attendees
    if (!incidence->attendeeCount()) {
        return;
    }

if (mUi->mOrganizerStack->currentIndex() == 0) {
        incidence->setOrganizer(mUi->mOrganizerCombo->currentText());
    } else {
        incidence->setOrganizer(mUi->mOrganizerLabel->text());
    }
}

bool IncidenceAttendee::isDirty() const
{
    if (iAmOrganizer()) {
        KCalCore::Event tmp;
        tmp.setOrganizer(mUi->mOrganizerCombo->currentText());

if (mLoadedIncidence->organizer()->email() != tmp.organizer()->email()) {
            qCDebug(INCIDENCEEDITOR_LOG) << "Organizer changed. Old was "
                                         << mLoadedIncidence->organizer()->name()
                                         << mLoadedIncidence->organizer()->email() << "; new is "
                                         << tmp.organizer()->name()
                                         << tmp.organizer()->email();
            return true;
        }
    }

const KCalCore::Attendee::List originalList = mLoadedIncidence->attendees();
    KCalCore::Attendee::List newList;

foreach (KCalCore::Attendee::Ptr attendee, mDataModel->attendees()) {
        if (!attendee->fullName().isEmpty()) {
            newList.append(attendee);
        }
    }

// The lists sizes *must* be the same. When the organizer is attending the
    // event as well, he should be in the attendees list as well.
    if (originalList.size() != newList.size()) {
        return true;
    }

// Okay, again not the most efficient algorithm, but I'm assuming that in the
    // bulk of the use cases, the number of attendees is not much higher than 10 or so.
    foreach (const KCalCore::Attendee::Ptr &attendee, originalList) {
        bool found = false;
        for (int i = 0; i < newList.count(); ++i) {
            if (*(newList[i]) == *attendee) {
                newList.remove(i);
                found = true;
                break;
            }
        }

if (!found) {
            // One of the attendees in the original list was not found in the new list.
            return true;
        }
    }

return false;
}

void IncidenceAttendee::changeStatusForMe(KCalCore::Attendee::PartStat stat)
{
    const IncidenceEditorNG::EditorConfig *config = IncidenceEditorNG::EditorConfig::instance();
    Q_ASSERT(config);

for (int i = 0; i < mDataModel->rowCount(); ++i) {
        QModelIndex index = mDataModel->index(i, AttendeeTableModel::Email);
        if (config->thatIsMe(mDataModel->data(index, Qt::DisplayRole).toString())) {
            index = mDataModel->index(i, AttendeeTableModel::Status);
            mDataModel->setData(index, stat);
            break;
        }
    }

checkDirtyStatus();
}

void IncidenceAttendee::acceptForMe()
{
    changeStatusForMe(KCalCore::Attendee::Accepted);
}

void IncidenceAttendee::declineForMe()
{
    changeStatusForMe(KCalCore::Attendee::Declined);
}

void IncidenceAttendee::fillOrganizerCombo()
{
    mUi->mOrganizerCombo->clear();
    const QStringList lst = IncidenceEditorNG::EditorConfig::instance()->fullEmails();
    QStringList uniqueList;
    for (QStringList::ConstIterator it = lst.begin(), end = lst.end(); it != end; ++it) {
        if (!uniqueList.contains(*it)) {
            uniqueList << *it;
        }
    }
    mUi->mOrganizerCombo->addItems(uniqueList);
}

void IncidenceAttendee::checkIfExpansionIsNeeded(const KCalCore::Attendee::Ptr &attendee)
{
    QString fullname = attendee->fullName();

// stop old job
    KJob *oldJob = mMightBeGroupJobs.key(attendee);
    if (oldJob != nullptr) {
        disconnect(oldJob);
        oldJob->deleteLater();
        mMightBeGroupJobs.remove(oldJob);
    }

mGroupList.remove(attendee);

if (!fullname.isEmpty()) {
        Akonadi::ContactGroupSearchJob *job = new Akonadi::ContactGroupSearchJob();
        job->setQuery(Akonadi::ContactGroupSearchJob::Name, fullname);
        connect(job, &Akonadi::ContactGroupSearchJob::result, this,
                &IncidenceAttendee::groupSearchResult);

mMightBeGroupJobs.insert(job, attendee);
    }
}

void IncidenceAttendee::groupSearchResult(KJob *job)
{
    Akonadi::ContactGroupSearchJob *searchJob = qobject_cast<Akonadi::ContactGroupSearchJob *>(job);
    Q_ASSERT(searchJob);

Q_ASSERT(mMightBeGroupJobs.contains(job));
    KCalCore::Attendee::Ptr attendee = mMightBeGroupJobs.take(job);

const KContacts::ContactGroup::List contactGroups = searchJob->contactGroups();
    if (contactGroups.isEmpty()) {
        updateGroupExpand();
        return; // Nothing todo, probably a normal email address was entered
    }

// TODO: Give the user the possibility to choose a group when there is more than one?!
    KContacts::ContactGroup group = contactGroups.first();

int row = dataModel()->attendees().indexOf(attendee);
    QModelIndex index = dataModel()->index(row, AttendeeTableModel::CuType);
    dataModel()->setData(index, KCalCore::Attendee::Group);

mGroupList.insert(attendee, group);
    updateGroupExpand();
}

void IncidenceAttendee::updateGroupExpand()
{
    mUi->mGroupSubstitution->setEnabled(!mGroupList.isEmpty());
}

void IncidenceAttendee::slotGroupSubstitutionPressed()
{
    for (auto it = mGroupList.cbegin(), end = mGroupList.cend(); it != end; ++it) {
        const KCalCore::Attendee::Ptr attendee = it.key();
        Akonadi::ContactGroupExpandJob *expandJob = new Akonadi::ContactGroupExpandJob(mGroupList.value(
                                                                                           attendee),
                                                                                       this);
        connect(expandJob, &Akonadi::ContactGroupExpandJob::result, this,
                &IncidenceAttendee::expandResult);
        mExpandGroupJobs.insert(expandJob, attendee);
        expandJob->start();
    }
}

void IncidenceAttendee::expandResult(KJob *job)
{
    Akonadi::ContactGroupExpandJob *expandJob = qobject_cast<Akonadi::ContactGroupExpandJob *>(job);
    Q_ASSERT(expandJob);
    Q_ASSERT(mExpandGroupJobs.contains(job));
    KCalCore::Attendee::Ptr attendee = mExpandGroupJobs.take(job);
    int row = dataModel()->attendees().indexOf(attendee);
    const QString currentEmail = attendee->email();
    const KContacts::Addressee::List groupMembers = expandJob->contacts();
    bool wasACorrectEmail = false;
    for (const KContacts::Addressee &member : groupMembers) {
        if (member.preferredEmail() == currentEmail) {
            wasACorrectEmail = true;
            break;
        }
    }

if (!wasACorrectEmail) {
        dataModel()->removeRow(row);
        for (const KContacts::Addressee &member : groupMembers) {
            KCalCore::Attendee::Ptr newAt(new KCalCore::Attendee(
                                              member.realName(), member.preferredEmail(),
                                              attendee->RSVP(),
                                              attendee->status(),
                                              attendee->role(),
                                              member.uid()));
            dataModel()->insertAttendee(row, newAt);
        }
    }
}

void IncidenceAttendee::slotSelectAddresses()
{
    QSharedPointer<Akonadi::EmailAddressSelectionDialog> d(new Akonadi::EmailAddressSelectionDialog(
                                                               mParentWidget));

QWeakPointer<Akonadi::EmailAddressSelectionDialog> dialog(d);
    dialog.data()->view()->view()->setSelectionMode(QAbstractItemView::ExtendedSelection);
    dialog.data()->setWindowTitle(i18n("Select Attendees"));
    if (dialog.data()->exec() == QDialog::Accepted) {
        Akonadi::EmailAddressSelectionDialog *dialogPtr = dialog.data();
        if (dialogPtr) {
            const Akonadi::EmailAddressSelection::List list = dialogPtr->selectedAddresses();
            for (const Akonadi::EmailAddressSelection &selection : list) {
                if (selection.item().hasPayload<KContacts::ContactGroup>()) {
                    Akonadi::ContactGroupExpandJob *job
                        = new Akonadi::ContactGroupExpandJob(
                        selection.item().payload<KContacts::ContactGroup>(), this);
                    connect(job, &Akonadi::ContactGroupExpandJob::result, this,
                            &IncidenceAttendee::expandResult);
                    KCalCore::Attendee::PartStat partStat = KCalCore::Attendee::NeedsAction;
                    bool rsvp = true;

int pos = 0;
                    KCalCore::Attendee::Ptr newAt(new KCalCore::Attendee(
                                                      selection.name(),
                                                      selection.email(),
                                                      rsvp,
                                                      partStat,
                                                      KCalCore::Attendee::ReqParticipant
                                                      ));
                    dataModel()->insertAttendee(pos, newAt);

mExpandGroupJobs.insert(job, newAt);
                    job->start();
                } else {
                    KContacts::Addressee contact;
                    contact.setName(selection.name());
                    contact.insertEmail(selection.email());

if (selection.item().hasPayload<KContacts::Addressee>()) {
                        contact.setUid(selection.item().payload<KContacts::Addressee>().uid());
                    }
                    insertAttendeeFromAddressee(contact);
                }
            }
        } else {
            qCDebug(INCIDENCEEDITOR_LOG) << "dialog was already deleted";
        }
    }

if (dialog.data()) {
        dialog.data()->deleteLater();
    }
}

void IncidenceEditorNG::IncidenceAttendee::slotSolveConflictPressed()
{
    const int duration = mDateTime->startTime().secsTo(mDateTime->endTime());
    QScopedPointer<SchedulingDialog> dialog(new SchedulingDialog(mDateTime->startDate(),
                                                                 mDateTime->startTime(),
                                                                 duration, mConflictResolver,
                                                                 mParentWidget));
    dialog->slotUpdateIncidenceStartEnd(mDateTime->currentStartDateTime(), mDateTime->currentEndDateTime());
    if (dialog->exec() == QDialog::Accepted) {
        qCDebug(INCIDENCEEDITOR_LOG) << dialog->selectedStartDate() << dialog->selectedStartTime();
        if (dialog->selectedStartDate().isValid() && dialog->selectedStartTime().isValid()) {
            mDateTime->setStartDate(dialog->selectedStartDate());
            mDateTime->setStartTime(dialog->selectedStartTime());
        }
    }
}

void IncidenceAttendee::slotConflictResolverAttendeeChanged(const QModelIndex &topLeft,
                                                            const QModelIndex &bottomRight)
{
    if (AttendeeTableModel::FullName <= bottomRight.column() &&
        AttendeeTableModel::FullName >= topLeft.column()) {
        for (int i = topLeft.row(); i <= bottomRight.row(); ++i) {
            QModelIndex email = dataModel()->index(i, AttendeeTableModel::Email);
            KCalCore::Attendee::Ptr attendee = dataModel()->data(email,
                                                                 AttendeeTableModel::AttendeeRole).
                                               value<KCalCore::Attendee::Ptr>();
            if (mConflictResolver->containsAttendee(attendee)) {
                mConflictResolver->removeAttendee(attendee);
            }
            if (!dataModel()->data(email).toString().isEmpty()) {
                mConflictResolver->insertAttendee(attendee);
            }
        }
    }
    checkDirtyStatus();
}

void IncidenceAttendee::slotConflictResolverAttendeeAdded(const QModelIndex &index, int first,
                                                          int last)
{
    for (int i = first; i <= last; ++i) {
        QModelIndex email = dataModel()->index(i, AttendeeTableModel::Email, index);
        if (!dataModel()->data(email).toString().isEmpty()) {
            mConflictResolver->insertAttendee(dataModel()->data(email,
                                                                AttendeeTableModel::AttendeeRole).value<
                                                  KCalCore::Attendee::Ptr>());
        }
    }
    checkDirtyStatus();
}

void IncidenceAttendee::slotConflictResolverAttendeeRemoved(const QModelIndex &index, int first,
                                                            int last)
{
    for (int i = first; i <= last; ++i) {
        QModelIndex email = dataModel()->index(i, AttendeeTableModel::Email, index);
        if (!dataModel()->data(email).toString().isEmpty()) {
            mConflictResolver->removeAttendee(dataModel()->data(email,
                                                                AttendeeTableModel::AttendeeRole).value<
                                                  KCalCore::Attendee::Ptr>());
        }
    }
    checkDirtyStatus();
}

void IncidenceAttendee::slotConflictResolverLayoutChanged()
{
    const KCalCore::Attendee::List attendees = mDataModel->attendees();
    mConflictResolver->clearAttendees();
    for (const KCalCore::Attendee::Ptr &attendee : attendees) {
        if (!attendee->email().isEmpty()) {
            mConflictResolver->insertAttendee(attendee);
        }
    }
    checkDirtyStatus();
}

void IncidenceAttendee::slotFreeBusyAdded(const QModelIndex &parent, int first, int last)
{
    // We are only interested in toplevel changes
    if (parent.isValid()) {
        return;
    }
    QAbstractItemModel *model = mConflictResolver->model();
    for (int i = first; i <= last; ++i) {
        QModelIndex index = model->index(i, 0, parent);
        const KCalCore::Attendee::Ptr &attendee =
            model->data(index, CalendarSupport::FreeBusyItemModel::AttendeeRole).value<KCalCore::Attendee::Ptr>();
        const KCalCore::FreeBusy::Ptr &fb =
            model->data(index, CalendarSupport::FreeBusyItemModel::FreeBusyRole).value<KCalCore::FreeBusy::Ptr>();
        if (attendee) {
            updateFBStatus(attendee, fb);
        }
    }
}

void IncidenceAttendee::slotFreeBusyChanged(const QModelIndex &topLeft,
                                            const QModelIndex &bottomRight)
{
    // We are only interested in toplevel changes
    if (topLeft.parent().isValid()) {
        return;
    }
    QAbstractItemModel *model = mConflictResolver->model();
    for (int i = topLeft.row(); i <= bottomRight.row(); ++i) {
        QModelIndex index = model->index(i, 0);
        const KCalCore::Attendee::Ptr &attendee =
            model->data(index, CalendarSupport::FreeBusyItemModel::AttendeeRole).value<KCalCore::Attendee::Ptr>();
        const KCalCore::FreeBusy::Ptr &fb =
            model->data(index, CalendarSupport::FreeBusyItemModel::FreeBusyRole).value<KCalCore::FreeBusy::Ptr>();
        if (attendee) {
            updateFBStatus(attendee, fb);
        }
    }
}

void IncidenceAttendee::updateFBStatus()
{
    QAbstractItemModel *model = mConflictResolver->model();
    for (int i = 0; i < model->rowCount(); ++i) {
        QModelIndex index = model->index(i, 0);
        const KCalCore::Attendee::Ptr &attendee =
            model->data(index, CalendarSupport::FreeBusyItemModel::AttendeeRole).value<KCalCore::Attendee::Ptr>();
        const KCalCore::FreeBusy::Ptr &fb =
            model->data(index, CalendarSupport::FreeBusyItemModel::FreeBusyRole).value<KCalCore::FreeBusy::Ptr>();
        if (attendee) {
            updateFBStatus(attendee, fb);
        }
    }
}

void IncidenceAttendee::updateFBStatus(const KCalCore::Attendee::Ptr &attendee,
                                       const KCalCore::FreeBusy::Ptr &fb)
{
    KCalCore::Attendee::List attendees = mDataModel->attendees();
    QDateTime startTime = mDateTime->currentStartDateTime();
    QDateTime endTime = mDateTime->currentEndDateTime();
    if (attendees.contains(attendee)) {
        int row = dataModel()->attendees().indexOf(attendee);
        QModelIndex attendeeIndex = dataModel()->index(row, AttendeeTableModel::Available);
        if (fb) {
            KCalCore::Period::List busyPeriods = fb->busyPeriods();
            for (auto it = busyPeriods.begin(); it != busyPeriods.end(); ++it) {
                // periods started before and laping into the incidence (s < startTime && e >= startTime)
                // periods starting in the time of incidende (s >= startTime && s <= endTime)
                if (((*it).start() < startTime && (*it).end() > startTime) ||
                    ((*it).start() >= startTime && (*it).start() <= endTime)) {
                    switch (attendee->status()) {
                    case KCalCore::Attendee::Accepted:
                        dataModel()->setData(attendeeIndex, AttendeeTableModel::Accepted);
                        return;
                    default:
                        dataModel()->setData(attendeeIndex, AttendeeTableModel::Busy);
                        return;
                    }
                }
            }
            dataModel()->setData(attendeeIndex, AttendeeTableModel::Free);
        } else {
            dataModel()->setData(attendeeIndex, AttendeeTableModel::Unknown);
        }
    }
}

void IncidenceAttendee::slotUpdateConflictLabel(int count)
{
    if (attendeeCount() > 0) {
        mUi->mSolveButton->setEnabled(true);
        if (count > 0) {
            QString label = i18ncp("@label Shows the number of scheduling conflicts",
                                   "%1 conflict",
                                   "%1 conflicts", count);
            mUi->mConflictsLabel->setText(label);
            mUi->mConflictsLabel->setVisible(true);
        } else {
            mUi->mConflictsLabel->setVisible(false);
        }
    } else {
        mUi->mSolveButton->setEnabled(false);
        mUi->mConflictsLabel->setVisible(false);
    }
}

void IncidenceAttendee::slotGroupSubstitutionAttendeeChanged(const QModelIndex &topLeft,
                                                             const QModelIndex &bottomRight)
{
    if (AttendeeTableModel::FullName <= bottomRight.column() &&
        AttendeeTableModel::FullName >= topLeft.column()) {
        for (int i = topLeft.row(); i <= bottomRight.row(); ++i) {
            QModelIndex email = dataModel()->index(i, AttendeeTableModel::Email);
            KCalCore::Attendee::Ptr attendee = dataModel()->data(email,
                                                                 AttendeeTableModel::AttendeeRole).
                                               value<KCalCore::Attendee::Ptr>();
            checkIfExpansionIsNeeded(attendee);
        }
    }
    updateGroupExpand();
}

void IncidenceAttendee::slotGroupSubstitutionAttendeeAdded(const QModelIndex &index, int first,
                                                           int last)
{
    Q_UNUSED(index);
    for (int i = first; i <= last; ++i) {
        QModelIndex email = dataModel()->index(i, AttendeeTableModel::Email);
        KCalCore::Attendee::Ptr attendee
            = dataModel()->data(email,
                                AttendeeTableModel::AttendeeRole).value<KCalCore::Attendee::Ptr>();
        checkIfExpansionIsNeeded(attendee);
    }
    updateGroupExpand();
}

void IncidenceAttendee::slotGroupSubstitutionAttendeeRemoved(const QModelIndex &index, int first,
                                                             int last)
{
    Q_UNUSED(index);
    for (int i = first; i <= last; ++i) {
        QModelIndex email = dataModel()->index(i, AttendeeTableModel::Email);
        KCalCore::Attendee::Ptr attendee
            = dataModel()->data(email,
                                AttendeeTableModel::AttendeeRole).value<KCalCore::Attendee::Ptr>();
        KJob *job = mMightBeGroupJobs.key(attendee);
        if (job) {
            disconnect(job);
            job->deleteLater();
            mMightBeGroupJobs.remove(job);
        }
        job = mExpandGroupJobs.key(attendee);
        if (job) {
            disconnect(job);
            job->deleteLater();
            mExpandGroupJobs.remove(job);
        }
        mGroupList.remove(attendee);
    }
    updateGroupExpand();
}

void IncidenceAttendee::slotGroupSubstitutionLayoutChanged()
{
    for (auto it = mMightBeGroupJobs.cbegin(), end = mMightBeGroupJobs.cend(); it != end; ++it) {
        KJob *job = it.key();
        disconnect(job);
        job->deleteLater();
    }

for (auto it = mExpandGroupJobs.cbegin(), end = mExpandGroupJobs.cend(); it != end; ++it) {
        KJob *job = it.key();
        disconnect(job);
        job->deleteLater();
    }
    mMightBeGroupJobs.clear();
    mExpandGroupJobs.clear();
    mGroupList.clear();

QAbstractItemModel *model = mUi->mAttendeeTable->model();
    if (!model) {
        return;
    }
    for (int i = 0; i < model->rowCount(QModelIndex()); ++i) {
        QModelIndex index = model->index(i, AttendeeTableModel::FullName);
        if (!model->data(index).toString().isEmpty()) {
            QModelIndex email = dataModel()->index(i, AttendeeTableModel::Email);
            KCalCore::Attendee::Ptr attendee = dataModel()->data(email,
                                                                 AttendeeTableModel::AttendeeRole).
                                               value<KCalCore::Attendee::Ptr>();
            checkIfExpansionIsNeeded(attendee);
        }
    }

updateGroupExpand();
}

bool IncidenceAttendee::iAmOrganizer() const
{
    if (mLoadedIncidence) {
        const IncidenceEditorNG::EditorConfig *config = IncidenceEditorNG::EditorConfig::instance();
        return config->thatIsMe(mLoadedIncidence->organizer()->email());
    }

return true;
}

void IncidenceAttendee::insertAttendeeFromAddressee(const KContacts::Addressee &a, int pos /*=-1*/)
{
    const bool sameAsOrganizer =
        mUi->mOrganizerCombo && KEmailAddress::compareEmail(a.preferredEmail(),
                                                            mUi->mOrganizerCombo->currentText(),
                                                            false);
    KCalCore::Attendee::PartStat partStat = KCalCore::Attendee::NeedsAction;
    bool rsvp = true;

if (iAmOrganizer() && sameAsOrganizer) {
        partStat = KCalCore::Attendee::Accepted;
        rsvp = false;
    }
    KCalCore::Attendee::Ptr newAt(new KCalCore::Attendee(a.realName(), a.preferredEmail(),
                                                         rsvp,
                                                         partStat,
                                                         KCalCore::Attendee::ReqParticipant,
                                                         a.uid()));
    if (pos < 0) {
        pos = dataModel()->rowCount() - 1;
    }

dataModel()->insertAttendee(pos, newAt);
}

void IncidenceAttendee::slotEventDurationChanged()
{
    const QDateTime start = mDateTime->currentStartDateTime();
    const QDateTime end = mDateTime->currentEndDateTime();

if (start >= end) {   // This can happen, especially for todos.
        return;
    }

mConflictResolver->setEarliestDateTime(start);
    mConflictResolver->setLatestDateTime(end);
    updateFBStatus();
}

void IncidenceAttendee::slotOrganizerChanged(const QString &newOrganizer)
{
    if (KEmailAddress::compareEmail(newOrganizer, mOrganizer, false)) {
        return;
    }

QString name;
    QString email;
    bool success = KEmailAddress::extractEmailAddressAndName(newOrganizer, email, name);

if (!success) {
        qCWarning(INCIDENCEEDITOR_LOG) << "Could not extract email address and name";
        return;
    }

int currentOrganizerAttendee = -1;
    int newOrganizerAttendee = -1;

for (int i = 0; i < mDataModel->rowCount(); ++i) {
        QModelIndex index = mDataModel->index(i, AttendeeTableModel::FullName);
        QString fullName = mDataModel->data(index, Qt::DisplayRole).toString();
        if (fullName == mOrganizer) {
            currentOrganizerAttendee = i;
        }

if (fullName == newOrganizer) {
            newOrganizerAttendee = i;
        }
    }

int answer = KMessageBox::No;
    if (currentOrganizerAttendee > -1) {
        answer = KMessageBox::questionYesNo(
            mParentWidget,
            i18nc("@option",
                  "You are changing the organizer of this event. "
                  "Since the organizer is also attending this event, would you "
                  "like to change the corresponding attendee as well?"));
    } else {
        answer = KMessageBox::Yes;
    }

if (answer == KMessageBox::Yes) {
        if (currentOrganizerAttendee > -1) {
            mDataModel->removeRows(currentOrganizerAttendee, 1);
        }

if (newOrganizerAttendee == -1) {
            bool rsvp = !iAmOrganizer(); // if it is the user, don't make him rsvp.
            KCalCore::Attendee::PartStat status = iAmOrganizer() ? KCalCore::Attendee::Accepted
                                                  : KCalCore::Attendee::NeedsAction;

KCalCore::Attendee::Ptr newAt(
                new KCalCore::Attendee(name, email, rsvp, status,
                                       KCalCore::Attendee::ReqParticipant));

mDataModel->insertAttendee(mDataModel->rowCount(), newAt);
        }
    }
    mOrganizer = newOrganizer;
}

AttendeeTableModel *IncidenceAttendee::dataModel() const
{
    return mDataModel;
}

AttendeeComboBoxDelegate *IncidenceAttendee::responseDelegate() const
{
    return mResponseDelegate;
}

AttendeeComboBoxDelegate *IncidenceAttendee::roleDelegate() const
{
    return mRoleDelegate;
}

AttendeeComboBoxDelegate *IncidenceAttendee::stateDelegate() const
{
    return mStateDelegate;
}

AttendeeLineEditDelegate *IncidenceAttendee::attendeeDelegate() const
{
    return mAttendeeDelegate;
}

void IncidenceAttendee::filterLayoutChanged()
{
    QHeaderView *headerView = mUi->mAttendeeTable->horizontalHeader();
    headerView->setSectionResizeMode(AttendeeTableModel::Role, QHeaderView::ResizeToContents);
    headerView->setSectionResizeMode(AttendeeTableModel::FullName, QHeaderView::Stretch);
    headerView->setSectionResizeMode(AttendeeTableModel::Status, QHeaderView::ResizeToContents);
    headerView->setSectionResizeMode(AttendeeTableModel::Response, QHeaderView::ResizeToContents);
    headerView->setSectionHidden(AttendeeTableModel::CuType, true);
    headerView->setSectionHidden(AttendeeTableModel::Name, true);
    headerView->setSectionHidden(AttendeeTableModel::Email, true);
    headerView->setSectionHidden(AttendeeTableModel::Available, true);
}

void IncidenceAttendee::updateCount()
{
    Q_EMIT attendeeCountChanged(attendeeCount());

checkDirtyStatus();
}

int IncidenceAttendee::attendeeCount() const
{
    int c = 0;
    QModelIndex index;
    QAbstractItemModel *model = mUi->mAttendeeTable->model();
    if (!model) {
        return 0;
    }
    for (int i = 0; i < model->rowCount(QModelIndex()); ++i) {
        index = model->index(i, AttendeeTableModel::FullName);
        if (!model->data(index).toString().isEmpty()) {
            ++c;
        }
    }
    return c;
}

void IncidenceAttendee::setActions(KCalCore::Incidence::IncidenceType actions)
{
    mStateDelegate->clear();
    if (actions == KCalCore::Incidence::TypeEvent) {
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-attention")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::NeedsAction));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-accepted")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Accepted));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-reject")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Declined));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-attempt")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Tentative));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-delegate")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Delegated));
    } else {
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-attention")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::NeedsAction));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-accepted")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Accepted));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-reject")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Declined));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-attempt")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Tentative));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-delegate")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Delegated));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-complete")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::Completed));
        mStateDelegate->addItem(QIcon::fromTheme(QStringLiteral("task-ongoing")),
                                KCalUtils::Stringify::attendeeStatus(AttendeeData::InProcess));
    }
}

void IncidenceAttendee::printDebugInfo() const
{
    qCDebug(INCIDENCEEDITOR_LOG) << "I'm organizer   : " << iAmOrganizer();
    qCDebug(INCIDENCEEDITOR_LOG) << "Loaded organizer: " << mLoadedIncidence->organizer()->email();

if (iAmOrganizer()) {
        KCalCore::Event tmp;
        tmp.setOrganizer(mUi->mOrganizerCombo->currentText());
        qCDebug(INCIDENCEEDITOR_LOG) << "Organizer combo: " << tmp.organizer()->email();
    }

const KCalCore::Attendee::List originalList = mLoadedIncidence->attendees();
    KCalCore::Attendee::List newList;
    qCDebug(INCIDENCEEDITOR_LOG) << "List sizes: " << originalList.count() << newList.count();

foreach (KCalCore::Attendee::Ptr attendee, mDataModel->attendees()) {
        if (!attendee->fullName().isEmpty()) {
            newList.append(attendee);
        }
    }

// Okay, again not the most efficient algorithm, but I'm assuming that in the
    // bulk of the use cases, the number of attendees is not much higher than 10 or so.
    foreach (const KCalCore::Attendee::Ptr &attendee, originalList) {
        bool found = false;
        for (int i = 0; i < newList.count(); ++i) {
            if (newList[i] == attendee) {
                newList.remove(i);
                found = true;
                break;
            }
        }

if (!found) {
            qCDebug(INCIDENCEEDITOR_LOG) << "Attendee not found: " << attendee->email()
                                         << attendee->name()
                                         << attendee->status()
                                         << attendee->RSVP()
                                         << attendee->role()
                                         << attendee->uid()
                                         << attendee->cuType()
                                         << attendee->delegate()
                                         << attendee->delegator()
                                         << "; we have:";
            for (int i = 0; i < newList.count(); ++i) {
                KCalCore::Attendee::Ptr attendee = newList[i];
                qCDebug(INCIDENCEEDITOR_LOG) << "Attendee: " << attendee->email()
                                             << attendee->name()
                                             << attendee->status()
                                             << attendee->RSVP()
                                             << attendee->role()
                                             << attendee->uid()
                                             << attendee->cuType()
                                             << attendee->delegate()
                                             << attendee->delegator();
            }

return;
        }
    }
}
07070111A0194F000081A40000000200000002000000015AA55A8600001624000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceattendee.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_INCIDENCEATTENDEE_H
#define INCIDENCEEDITOR_INCIDENCEATTENDEE_H

#include "incidenceeditor-ng.h"

#include <KCalCore/FreeBusy>

namespace Ui {
class EventOrTodoDesktop;
}

namespace KContacts {
class Addressee;
class ContactGroup;
}

class KJob;

namespace IncidenceEditorNG {
class AttendeeComboBoxDelegate;
class AttendeeLineEditDelegate;
class AttendeeTableModel;
class ConflictResolver;
class IncidenceDateTime;

class IncidenceAttendee : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual
    IncidenceAttendee(QWidget *parent, IncidenceDateTime *dateTime, Ui::EventOrTodoDesktop *ui);
    ~IncidenceAttendee();

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;
    void printDebugInfo() const override;

AttendeeTableModel *dataModel() const;
    AttendeeComboBoxDelegate *stateDelegate() const;
    AttendeeComboBoxDelegate *roleDelegate() const;
    AttendeeComboBoxDelegate *responseDelegate() const;
    AttendeeLineEditDelegate *attendeeDelegate() const;

int attendeeCount() const;

Q_SIGNALS:
    void attendeeCountChanged(int);

public Q_SLOTS:
    /// If the user is attendee of the loaded event, one of the following slots
    /// can be used to change the status.
    void acceptForMe();
    void declineForMe();

private Q_SLOTS:
    // cheks if row is a group,  that can/should be expanded
    void checkIfExpansionIsNeeded(const KCalCore::Attendee::Ptr &attendee);

// results of the group search job
    void groupSearchResult(KJob *job);
    void expandResult(KJob *job);
    void slotSelectAddresses();
    void slotSolveConflictPressed();
    void slotUpdateConflictLabel(int);
    void slotOrganizerChanged(const QString &organizer);
    void slotGroupSubstitutionPressed();

// wrapper for the conflict resolver
    void slotEventDurationChanged();

void filterLayoutChanged();
    void updateCount();

void slotConflictResolverAttendeeAdded(const QModelIndex &index, int first, int last);
    void slotConflictResolverAttendeeRemoved(const QModelIndex &index, int first, int last);
    void slotConflictResolverAttendeeChanged(const QModelIndex &topLeft,
                                             const QModelIndex &bottomRight);
    void slotConflictResolverLayoutChanged();
    void slotFreeBusyAdded(const QModelIndex &index, int first, int last);
    void slotFreeBusyChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
    void updateFBStatus();
    void updateFBStatus(const KCalCore::Attendee::Ptr &attendee, const KCalCore::FreeBusy::Ptr &fb);

void slotGroupSubstitutionAttendeeAdded(const QModelIndex &index, int first, int last);
    void slotGroupSubstitutionAttendeeRemoved(const QModelIndex &index, int first, int last);
    void slotGroupSubstitutionAttendeeChanged(const QModelIndex &topLeft,
                                              const QModelIndex &bottomRight);
    void slotGroupSubstitutionLayoutChanged();

private:
    void updateGroupExpand();

void changeStatusForMe(KCalCore::Attendee::PartStat);

/** Returns if I was the organizer of the loaded event */
    bool iAmOrganizer() const;

/** Reads values from a KContacts::Addressee and inserts a new Attendee
     * item into the listview with those items. Used when adding attendees
     * from the addressbook and expanding distribution lists.
     * The optional Attendee parameter can be used to pass in default values
     * to be used by the new Attendee.
     * pos =-1 means insert attendee before empty line
     */
    void insertAttendeeFromAddressee(const KContacts::Addressee &a, int pos = -1);
    void fillOrganizerCombo();
    void setActions(KCalCore::Incidence::IncidenceType actions);

Ui::EventOrTodoDesktop *mUi = nullptr;
    QWidget *mParentWidget = nullptr;
    ConflictResolver *mConflictResolver = nullptr;

IncidenceDateTime *mDateTime = nullptr;
    QString mOrganizer;
    QString mOldIconName;

/** used dataModel to rely on*/
    AttendeeTableModel *mDataModel = nullptr;
    AttendeeLineEditDelegate *mAttendeeDelegate = nullptr;
    AttendeeComboBoxDelegate *mStateDelegate = nullptr;
    AttendeeComboBoxDelegate *mRoleDelegate = nullptr;
    AttendeeComboBoxDelegate *mResponseDelegate = nullptr;

QMap<KCalCore::Attendee::Ptr, KContacts::ContactGroup> mGroupList;
    QMap<KJob *, KCalCore::Attendee::Ptr> mMightBeGroupJobs;
    QMap<KJob *, KCalCore::Attendee::Ptr> mExpandGroupJobs;
};
}

#endif
07070111A01950000081A40000000200000002000000015AA55A860000137E000000FD0000001000000000000000000000004F00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencecategories.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidencecategories.h"

#include "editorconfig.h"

#include "ui_dialogdesktop.h"
#include <LibkdepimAkonadi/TagWidgets>
#include "incidenceeditor_debug.h"

#include <TagAttribute>
#include <TagCreateJob>
#include <TagFetchJob>
#include <TagFetchScope>

using namespace IncidenceEditorNG;

IncidenceCategories::IncidenceCategories(Ui::EventOrTodoDesktop *ui)
    : mUi(ui)
    , mDirty(false)
{
    setObjectName(QStringLiteral("IncidenceCategories"));

connect(mUi->mTagWidget, &Akonadi::TagWidget::selectionChanged, this,
            &IncidenceCategories::onSelectionChanged);
}

void IncidenceCategories::onSelectionChanged(const Akonadi::Tag::List &list)
{
    Q_UNUSED(list);
    mDirty = true;
    checkDirtyStatus();
}

void IncidenceCategories::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;
    mDirty = false;
    mWasDirty = false;
    mMissingCategories.clear();

if (mLoadedIncidence) {
        Akonadi::TagFetchJob *fetchJob = new Akonadi::TagFetchJob(this);
        fetchJob->fetchScope().fetchAttribute<Akonadi::TagAttribute>();
        connect(fetchJob, &Akonadi::TagFetchJob::result, this, &IncidenceCategories::onTagsFetched);
    }
}

void IncidenceCategories::save(const KCalCore::Incidence::Ptr &incidence)
{
    Q_ASSERT(incidence);
    if (mDirty) {
        incidence->setCategories(categories());
    }
}

void IncidenceCategories::save(Akonadi::Item &item)
{
    const auto &selectedTags = mUi->mTagWidget->selection();
    if (mDirty) {
        item.setTags(selectedTags);
    }
}

QStringList IncidenceCategories::categories() const
{
    QStringList list;
    const auto &selectedTags = mUi->mTagWidget->selection();
    list.reserve(selectedTags.count() + mMissingCategories.count());
    for (const Akonadi::Tag &tag : selectedTags) {
        list << tag.name();
    }
    list << mMissingCategories;
    return list;
}

void IncidenceCategories::createMissingCategories()
{
    for (const QString &category : qAsConst(mMissingCategories)) {
        Akonadi::Tag missingTag = Akonadi::Tag::genericTag(category);
        Akonadi::TagCreateJob *createJob = new Akonadi::TagCreateJob(missingTag, this);
        connect(createJob, &Akonadi::TagCreateJob::result, this,
                &IncidenceCategories::onMissingTagCreated);
    }
}

bool IncidenceCategories::isDirty() const
{
    return mDirty;
}

void IncidenceCategories::printDebugInfo() const
{
    qCDebug(INCIDENCEEDITOR_LOG) << "selected categories = " << categories();
    qCDebug(INCIDENCEEDITOR_LOG) << "mMissingCategories = " << mMissingCategories;
    qCDebug(INCIDENCEEDITOR_LOG) << "mLoadedIncidence->categories() = "
                                 << mLoadedIncidence->categories();
}

void IncidenceCategories::onTagsFetched(KJob *job)
{
    if (job->error()) {
        qCWarning(INCIDENCEEDITOR_LOG) << "Failed to load tags " << job->errorString();
        return;
    }
    Akonadi::TagFetchJob *fetchJob = static_cast<Akonadi::TagFetchJob *>(job);
    const Akonadi::Tag::List jobTags = fetchJob->tags();

Q_ASSERT(mLoadedIncidence);
    mMissingCategories = mLoadedIncidence->categories();

Akonadi::Tag::List selectedTags;
    selectedTags.reserve(mMissingCategories.count());
    for (const auto &tag : jobTags) {
        if (mMissingCategories.removeAll(tag.name()) > 0) {
            selectedTags << tag;
        }
    }

createMissingCategories();
    mUi->mTagWidget->setSelection(selectedTags);
}

void IncidenceCategories::onMissingTagCreated(KJob *job)
{
    if (job->error()) {
        qCWarning(INCIDENCEEDITOR_LOG) << "Failed to create tag " << job->errorString();
        return;
    }
    Akonadi::TagCreateJob *createJob = static_cast<Akonadi::TagCreateJob *>(job);
    int count = mMissingCategories.removeAll(createJob->tag().name());
    Q_ASSERT(count > 0);

QVector<Akonadi::Tag> selectedTags;
    selectedTags.reserve(mUi->mTagWidget->selection().count() + 1);
    selectedTags << mUi->mTagWidget->selection() << createJob->tag();
    mUi->mTagWidget->setSelection(selectedTags);
}
07070111A01951000081A40000000200000002000000015AA55A8600000930000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencecategories.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 INCIDENCEEDITOR_INCIDENCECATEGORIES_H
#define INCIDENCEEDITOR_INCIDENCECATEGORIES_H

#include "incidenceeditor-ng.h"

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class IncidenceCategories : public IncidenceEditor
{
    Q_OBJECT
public:
    explicit IncidenceCategories(Ui::EventOrTodoDesktop *ui);

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    void save(Akonadi::Item &item) override;

/**
     * Returns the list of currently selected categories.
     */
    QStringList categories() const;

bool isDirty() const override;
    void printDebugInfo() const override;

private:
    void createMissingCategories();

void onSelectionChanged(const Akonadi::Tag::List &);
    void onTagsFetched(KJob *);
    void onMissingTagCreated(KJob *);

Ui::EventOrTodoDesktop *mUi = nullptr;

/**
     * List of categories for which no tag might exist.
     *
     * For each category of the editted incidence, we want to  make sure that there exists a
     * corresponding tag in Akonadi. For missing categories, a \a TagCreateJob is issued.
     * Eventually, there should be no missing categories left. In case tag creation fails for some
     * categories, this list still holds these categories so they don't get lost
     */
    QStringList mMissingCategories;
    bool mDirty = false;
};
}

#endif
07070111A01952000081A40000000200000002000000015AA55A86000012A8000000FD0000001000000000000000000000005700000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencecompletionpriority.cpp/*
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
    Author: Kevin Krammer <krake@kdab.com>

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 "incidencecompletionpriority.h"
#include "ui_dialogdesktop.h"

#include <KCalCore/Todo>

using namespace IncidenceEditorNG;

class IncidenceCompletionPriority::Private
{
    IncidenceCompletionPriority *const q;
public:
    explicit Private(IncidenceCompletionPriority *parent)
        : q(parent)
        , mUi(nullptr)
        , mOrigPercentCompleted(-1)
    {
    }

public:
    Ui::EventOrTodoDesktop *mUi = nullptr;
    int mOrigPercentCompleted = -1;

public: // slots
    void sliderValueChanged(int);
};

void IncidenceCompletionPriority::Private::sliderValueChanged(int value)
{
    if (q->sender() == mUi->mCompletionSlider) {
        mOrigPercentCompleted = -1;
    }

mUi->mCompletedLabel->setText(QStringLiteral("%1%").arg(value));
    q->checkDirtyStatus();
}

IncidenceCompletionPriority::IncidenceCompletionPriority(Ui::EventOrTodoDesktop *ui)
    : IncidenceEditor()
    , d(new Private(this))
{
    Q_ASSERT(ui != nullptr);
    setObjectName(QStringLiteral("IncidenceCompletionPriority"));

d->mUi = ui;

d->sliderValueChanged(d->mUi->mCompletionSlider->value());
    d->mUi->mCompletionPriorityWidget->hide();
    d->mUi->mTaskLabel->hide();
    const QFontMetrics metrics(d->mUi->mCompletedLabel->font());
    d->mUi->mCompletedLabel->setMinimumWidth(metrics.width(QStringLiteral("100%")));
    d->mUi->mTaskSeparator->hide();

connect(d->mUi->mCompletionSlider, QOverload<int>::of(&QSlider::valueChanged), this, [this](int val) { d->sliderValueChanged(val);});
    connect(d->mUi->mPriorityCombo, QOverload< int>::of(&KComboBox::currentIndexChanged), this, &IncidenceCompletionPriority::checkDirtyStatus);
}

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

void IncidenceCompletionPriority::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;

// TODO priority might be valid for other incidence types as well
    // only for Todos
    KCalCore::Todo::Ptr todo = IncidenceCompletionPriority::incidence<KCalCore::Todo>();
    if (todo == nullptr) {
        mWasDirty = false;
        return;
    }

d->mUi->mCompletionPriorityWidget->show();
    d->mUi->mTaskLabel->show();
    d->mUi->mTaskSeparator->show();

d->mOrigPercentCompleted = todo->percentComplete();
    d->mUi->mCompletionSlider->blockSignals(true);
    d->mUi->mCompletionSlider->setValue(todo->percentComplete());
    d->sliderValueChanged(d->mUi->mCompletionSlider->value());
    d->mUi->mCompletionSlider->blockSignals(false);

d->mUi->mPriorityCombo->blockSignals(true);
    d->mUi->mPriorityCombo->setCurrentIndex(todo->priority());
    d->mUi->mPriorityCombo->blockSignals(false);

mWasDirty = false;
}

void IncidenceCompletionPriority::save(const KCalCore::Incidence::Ptr &incidence)
{
    // TODO priority might be valid for other incidence types as well
    // only for Todos
    KCalCore::Todo::Ptr todo = IncidenceCompletionPriority::incidence<KCalCore::Todo>(incidence);
    if (todo == nullptr) {
        return;
    }

// we only have multiples of ten on our combo. If the combo did not change its value,
    // see if we have an original value to restore
    if (d->mOrigPercentCompleted != -1) {
        todo->setPercentComplete(d->mOrigPercentCompleted);
    } else {
        todo->setPercentComplete(d->mUi->mCompletionSlider->value());
    }
    todo->setPriority(d->mUi->mPriorityCombo->currentIndex());
}

bool IncidenceCompletionPriority::isDirty() const
{
    KCalCore::Todo::Ptr todo = IncidenceCompletionPriority::incidence<KCalCore::Todo>();

if (!todo) {
        return false;
    }

if (d->mUi->mCompletionSlider->value() != todo->percentComplete()) {
        return true;
    }

if (d->mUi->mPriorityCombo->currentIndex() != todo->priority()) {
        return true;
    }

return false;
}

#include "moc_incidencecompletionpriority.cpp"
07070111A01953000081A40000000200000002000000015AA55A86000006BC000000FD0000001000000000000000000000005500000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencecompletionpriority.h/*
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>
  Author: Kevin Krammer <krake@kdab.com>

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 INCIDENCEEDITOR_INCIDENCECOMPLETIONPRIORITY_H
#define INCIDENCEEDITOR_INCIDENCECOMPLETIONPRIORITY_H

#include "incidenceeditor-ng.h"

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class IncidenceCompletionPriority : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual

explicit IncidenceCompletionPriority(Ui::EventOrTodoDesktop *ui);
    ~IncidenceCompletionPriority();

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;

private:
    class Private;
    Private *const d;
};
}

#endif
07070111A01954000081A40000000200000002000000015AA55A8600009673000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedatetime.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidencedatetime.h"
#include "ui_dialogdesktop.h"
#include "incidenceeditor_debug.h"

#include <CalendarSupport/KCalPrefs>

#include <KCalUtils/IncidenceFormatter>

#include <QTimeZone>

using namespace IncidenceEditorNG;

/**
 * Returns true if the incidence's dates are equal to the default ones specified in config.
 */
static bool incidenceHasDefaultTimes(const KCalCore::Incidence::Ptr &incidence)
{
    if (!incidence || incidence->allDay()) {
        return false;
    }

QTime defaultDuration = CalendarSupport::KCalPrefs::instance()->defaultDuration().time();
    if (!defaultDuration.isValid()) {
        return false;
    }

QTime defaultStart = CalendarSupport::KCalPrefs::instance()->mStartTime.time();
    if (!defaultStart.isValid()) {
        return false;
    }

if (incidence->dtStart().time() == defaultStart) {
        if (incidence->type() == KCalCore::Incidence::TypeJournal) {
            return true; // no duration to compare with
        }

const QDateTime start = incidence->dtStart();
        const QDateTime end = incidence->dateTime(KCalCore::Incidence::RoleEnd);
        if (!end.isValid() || !start.isValid()) {
            return false;
        }

const int durationInSeconds = defaultDuration.hour() * 3600 + defaultDuration.minute() * 60;
        return start.secsTo(end) == durationInSeconds;
    }

return false;
}

IncidenceDateTime::IncidenceDateTime(Ui::EventOrTodoDesktop *ui)
    : IncidenceEditor(nullptr)
    , mUi(ui)
    , mTimezoneCombosWereVisibile(false)
{
    setTimeZonesVisibility(false);
    setObjectName(QStringLiteral("IncidenceDateTime"));

mUi->mTimeZoneLabel->setVisible(!mUi->mWholeDayCheck->isChecked());
    connect(mUi->mTimeZoneLabel, &QLabel::linkActivated, this,
            &IncidenceDateTime::toggleTimeZoneVisibility);
    mUi->mTimeZoneLabel->setContextMenuPolicy(Qt::NoContextMenu);

const QList<QLineEdit *> lineEdits {
        mUi->mStartDateEdit->lineEdit(), mUi->mEndDateEdit->lineEdit()
                ,mUi->mStartTimeEdit->lineEdit(), mUi->mEndTimeEdit->lineEdit()};
    for (QLineEdit *lineEdit : lineEdits) {
        if (lineEdit) {
            lineEdit->setClearButtonEnabled(false);
        }
    }

connect(mUi->mFreeBusyCheck, &QCheckBox::toggled, this, &IncidenceDateTime::checkDirtyStatus);
    connect(mUi->mWholeDayCheck, &QCheckBox::toggled, this, &IncidenceDateTime::enableTimeEdits);
    connect(mUi->mWholeDayCheck, &QCheckBox::toggled, this, &IncidenceDateTime::checkDirtyStatus);

connect(this, &IncidenceDateTime::startDateChanged, this,
            &IncidenceDateTime::updateStartToolTips);
    connect(this, &IncidenceDateTime::startTimeChanged, this,
            &IncidenceDateTime::updateStartToolTips);
    connect(this, &IncidenceDateTime::endDateChanged, this, &IncidenceDateTime::updateEndToolTips);
    connect(this, &IncidenceDateTime::endTimeChanged, this, &IncidenceDateTime::updateEndToolTips);
    connect(mUi->mWholeDayCheck, &QCheckBox::toggled, this,
            &IncidenceDateTime::updateStartToolTips);
    connect(mUi->mWholeDayCheck, &QCheckBox::toggled, this, &IncidenceDateTime::updateEndToolTips);
    connect(mUi->mStartCheck, &QCheckBox::toggled, this, &IncidenceDateTime::updateStartToolTips);
    connect(mUi->mEndCheck, &QCheckBox::toggled, this, &IncidenceDateTime::updateEndToolTips);
}

IncidenceDateTime::~IncidenceDateTime()
{
}

bool IncidenceDateTime::eventFilter(QObject *obj, QEvent *event)
{
    if (event->type() == QEvent::FocusIn) {
        if (obj == mUi->mStartDateEdit) {
            qCDebug(INCIDENCEEDITOR_LOG) << "emiting startDateTime: " << mUi->mStartDateEdit;
            Q_EMIT startDateFocus(obj);
        } else if (obj == mUi->mEndDateEdit) {
            qCDebug(INCIDENCEEDITOR_LOG) << "emiting endDateTime: " << mUi->mEndDateEdit;
            Q_EMIT endDateFocus(obj);
        } else if (obj == mUi->mStartTimeEdit) {
            qCDebug(INCIDENCEEDITOR_LOG) << "emiting startTimeTime: " << mUi->mStartTimeEdit;
            Q_EMIT startTimeFocus(obj);
        } else if (obj == mUi->mEndTimeEdit) {
            qCDebug(INCIDENCEEDITOR_LOG) << "emiting endTimeTime: " << mUi->mEndTimeEdit;
            Q_EMIT endTimeFocus(obj);
        }

return true;
    } else {
        // standard event processing
        return QObject::eventFilter(obj, event);
    }
}

void IncidenceDateTime::load(const KCalCore::Incidence::Ptr &incidence)
{
    if (mLoadedIncidence && *mLoadedIncidence == *incidence) {
        return;
    }

const bool isTemplate = incidence->customProperty("kdepim", "isTemplate") == QLatin1String(
        "true");
    const bool templateOverridesTimes = incidenceHasDefaultTimes(mLoadedIncidence);

mLoadedIncidence = incidence;
    mLoadingIncidence = true;

// We can only handle events or todos.
    if (KCalCore::Todo::Ptr todo = IncidenceDateTime::incidence<KCalCore::Todo>()) {
        load(todo, isTemplate, templateOverridesTimes);
    } else if (KCalCore::Event::Ptr event = IncidenceDateTime::incidence<KCalCore::Event>()) {
        load(event, isTemplate, templateOverridesTimes);
    } else if (KCalCore::Journal::Ptr journal = IncidenceDateTime::incidence<KCalCore::Journal>()) {
        load(journal, isTemplate, templateOverridesTimes);
    } else {
        qCDebug(INCIDENCEEDITOR_LOG) << "Not an Incidence.";
    }

// Set the initial times before calling enableTimeEdits, as enableTimeEdits
    // assumes that the initial times are initialized.
    mInitialStartDT = currentStartDateTime();
    mInitialEndDT = currentEndDateTime();

enableTimeEdits();

if (mUi->mTimeZoneComboStart->currentIndex() == 0) {   // Floating
        mInitialStartDT.setTimeZone(QTimeZone::systemTimeZone());
    }

if (mUi->mTimeZoneComboEnd->currentIndex() == 0) {   // Floating
        mInitialEndDT.setTimeZone(QTimeZone::systemTimeZone());
    }

mWasDirty = false;
    mLoadingIncidence = false;
}

void IncidenceDateTime::save(const KCalCore::Incidence::Ptr &incidence)
{
    if (KCalCore::Todo::Ptr todo
            = IncidenceDateTime::incidence<KCalCore::Todo>(incidence)) {
        save(todo);
    } else if (KCalCore::Event::Ptr event
                   = IncidenceDateTime::incidence<KCalCore::Event>(incidence)) {
        save(event);
    } else if (KCalCore::Journal::Ptr journal
                   = IncidenceDateTime::incidence<KCalCore::Journal>(incidence)) {
        save(journal);
    } else {
        Q_ASSERT_X(false, "IncidenceDateTimeEditor::save",
                   "Only implemented for todos, events and journals");
    }
}

bool IncidenceDateTime::isDirty() const
{
    if (KCalCore::Todo::Ptr todo = IncidenceDateTime::incidence<KCalCore::Todo>()) {
        return isDirty(todo);
    } else if (KCalCore::Event::Ptr event = IncidenceDateTime::incidence<KCalCore::Event>()) {
        return isDirty(event);
    } else if (KCalCore::Journal::Ptr journal = IncidenceDateTime::incidence<KCalCore::Journal>()) {
        return isDirty(journal);
    } else {
        Q_ASSERT_X(false, "IncidenceDateTimeEditor::isDirty",
                   "Only implemented for todos and events");
        return false;
    }
}

void IncidenceDateTime::setActiveDate(const QDate &activeDate)
{
    mActiveDate = activeDate;
}

QDate IncidenceDateTime::startDate() const
{
    return currentStartDateTime().date();
}

QDate IncidenceDateTime::endDate() const
{
    return currentEndDateTime().date();
}

QTime IncidenceDateTime::startTime() const
{
    return currentStartDateTime().time();
}

QTime IncidenceDateTime::endTime() const
{
    return currentEndDateTime().time();
}

/// private slots for General

void IncidenceDateTime::setTimeZonesVisibility(bool visible)
{
    static const QString tz(i18nc("@action show or hide the time zone widgets", "Time zones"));
    QString placeholder(QStringLiteral("<a href=\"hide\"><font color='blue'>&lt;&lt; %1</font></a>"));
    if (visible) {
        placeholder = placeholder.arg(tz);
    } else {
        placeholder = QStringLiteral("<a href=\"show\"><font color='blue'>%1 &gt;&gt;</font></a>");
        placeholder = placeholder.arg(tz);
    }
    mUi->mTimeZoneLabel->setText(placeholder);

mUi->mTimeZoneComboStart->setVisible(visible);
    mUi->mTimeZoneComboEnd->setVisible(visible && type() != KCalCore::Incidence::TypeJournal);
}

void IncidenceDateTime::toggleTimeZoneVisibility()
{
    setTimeZonesVisibility(!mUi->mTimeZoneComboStart->isVisible());
}

void IncidenceDateTime::updateStartTime(const QTime &newTime)
{
    if (!newTime.isValid()) {
        return;
    }

QDateTime endDateTime = currentEndDateTime();
    const int secsep = mCurrentStartDateTime.secsTo(endDateTime);
    mCurrentStartDateTime.setTime(newTime);
    if (mUi->mEndCheck->isChecked()) {
        // Only update the end time when it is actually enabled, adjust end time so
        // that the event/todo has the same duration as before.
        endDateTime = mCurrentStartDateTime.addSecs(secsep);
        mUi->mEndTimeEdit->setTime(endDateTime.time());
        mUi->mEndDateEdit->setDate(endDateTime.date());
    }

Q_EMIT startTimeChanged(mCurrentStartDateTime.time());
    checkDirtyStatus();
}

void IncidenceDateTime::updateStartDate(const QDate &newDate)
{
    if (!newDate.isValid()) {
        return;
    }

const bool dateChanged = mCurrentStartDateTime.date().day() != newDate.day()
                             || mCurrentStartDateTime.date().month() != newDate.month();

QDateTime endDateTime = currentEndDateTime();
    int daysep = mCurrentStartDateTime.daysTo(endDateTime);
    mCurrentStartDateTime.setDate(newDate);
    if (mUi->mEndCheck->isChecked()) {
        // Only update the end time when it is actually enabled, adjust end time so
        // that the event/todo has the same duration as before.
        endDateTime.setDate(mCurrentStartDateTime.date().addDays(daysep));
        mUi->mEndDateEdit->setDate(endDateTime.date());
    }

checkDirtyStatus();

if (dateChanged) {
        Q_EMIT startDateChanged(mCurrentStartDateTime.date());
    }
}

void IncidenceDateTime::updateStartSpec()
{
    const QDate prevDate = mCurrentStartDateTime.date();

if (mUi->mEndCheck->isChecked()
        && currentEndDateTime().timeZone() == mCurrentStartDateTime.timeZone()) {
        mUi->mTimeZoneComboEnd->selectTimeZone(mUi->mTimeZoneComboStart->selectedTimeZone());
    }

mCurrentStartDateTime.setTimeZone(mUi->mTimeZoneComboStart->selectedTimeZone());

const bool dateChanged = mCurrentStartDateTime.date().day() != prevDate.day()
                             || mCurrentStartDateTime.date().month() != prevDate.month();

if (dateChanged) {
        Q_EMIT startDateChanged(mCurrentStartDateTime.date());
    }

if (type() == KCalCore::Incidence::TypeJournal) {
        checkDirtyStatus();
    }
}

/// private slots for Todo

void IncidenceDateTime::enableStartEdit(bool enable)
{
    mUi->mStartDateEdit->setEnabled(enable);

if (mUi->mEndCheck->isChecked() || mUi->mStartCheck->isChecked()) {
        mUi->mWholeDayCheck->setEnabled(true);
        setTimeZoneLabelEnabled(!mUi->mWholeDayCheck->isChecked());
    } else {
        mUi->mWholeDayCheck->setEnabled(false);
        mUi->mWholeDayCheck->setChecked(false);
        setTimeZoneLabelEnabled(false);
    }

if (enable) {
        mUi->mStartTimeEdit->setEnabled(!mUi->mWholeDayCheck->isChecked());
        mUi->mTimeZoneComboStart->setEnabled(!mUi->mWholeDayCheck->isChecked());
    } else {
        mUi->mStartTimeEdit->setEnabled(false);
        mUi->mTimeZoneComboStart->setEnabled(false);
    }

mUi->mTimeZoneComboStart->setFloating(!mUi->mTimeZoneComboStart->isEnabled());
    checkDirtyStatus();
}

void IncidenceDateTime::enableEndEdit(bool enable)
{
    mUi->mEndDateEdit->setEnabled(enable);

if (enable) {
        mUi->mEndTimeEdit->setEnabled(!mUi->mWholeDayCheck->isChecked());
        mUi->mTimeZoneComboEnd->setEnabled(!mUi->mWholeDayCheck->isChecked());
    } else {
        mUi->mEndTimeEdit->setEnabled(false);
        mUi->mTimeZoneComboEnd->setEnabled(false);
    }

mUi->mTimeZoneComboEnd->setFloating(!mUi->mTimeZoneComboEnd->isEnabled());
    checkDirtyStatus();
}

bool IncidenceDateTime::timeZonesAreLocal(const QDateTime &start, const QDateTime &end)
{
    // Returns false if the incidence start or end timezone is not the local zone.

if ((start.isValid() && start.timeZone() != QTimeZone::systemTimeZone())
        || (end.isValid() && end.timeZone() != QTimeZone::systemTimeZone())) {
        return false;
    } else {
        return true;
    }
}

void IncidenceDateTime::enableTimeEdits()
{
    // NOTE: assumes that the initial times are initialized.
    const bool wholeDayChecked = mUi->mWholeDayCheck->isChecked();

setTimeZoneLabelEnabled(!wholeDayChecked);

if (mUi->mStartCheck->isChecked()) {
        mUi->mStartTimeEdit->setEnabled(!wholeDayChecked);
        mUi->mTimeZoneComboStart->setEnabled(!wholeDayChecked);
        mUi->mTimeZoneComboStart->setFloating(wholeDayChecked, mInitialStartDT.timeZone());
    }
    if (mUi->mEndCheck->isChecked()) {
        mUi->mEndTimeEdit->setEnabled(!wholeDayChecked);
        mUi->mTimeZoneComboEnd->setEnabled(!wholeDayChecked);
        mUi->mTimeZoneComboEnd->setFloating(wholeDayChecked, mInitialEndDT.timeZone());
    }

/**
       When editing a whole-day event, unchecking mWholeDayCheck shouldn't set both
       times to 00:00. DTSTART must always be smaller than DTEND
     */
    if (sender() == mUi->mWholeDayCheck && !wholeDayChecked     // Somebody unchecked it, the incidence will now have time.
        && mUi->mStartCheck->isChecked() && mUi->mEndCheck->isChecked()     // The incidence has both start and end/due dates
        && currentStartDateTime() == currentEndDateTime()) {   // DTSTART == DTEND. This is illegal, lets correct it.
        // Not sure about the best time here... doesn't really matter, when someone unchecks mWholeDayCheck, she will
        // always want to set a time.
        mUi->mStartTimeEdit->setTime(QTime(0, 0));
        mUi->mEndTimeEdit->setTime(QTime(1, 0));
    }

const bool currentlyVisible = mUi->mTimeZoneLabel->text().contains(QStringLiteral("&lt;&lt;"));
    setTimeZonesVisibility(!wholeDayChecked && mTimezoneCombosWereVisibile);
    mTimezoneCombosWereVisibile = currentlyVisible;
    if (!wholeDayChecked && !timeZonesAreLocal(currentStartDateTime(), currentEndDateTime())) {
        setTimeZonesVisibility(true);
        mTimezoneCombosWereVisibile = true;
    }
}

bool IncidenceDateTime::isDirty(const KCalCore::Todo::Ptr &todo) const
{
    Q_ASSERT(todo);

const bool hasDateTimes = mUi->mStartCheck->isChecked()
                              || mUi->mEndCheck->isChecked();

// First check the start time/date of the todo
    if (todo->hasStartDate() != mUi->mStartCheck->isChecked()) {
        return true;
    }

if ((hasDateTimes && todo->allDay()) != mUi->mWholeDayCheck->isChecked()) {
        return true;
    }

if (todo->hasDueDate() != mUi->mEndCheck->isChecked()) {
        return true;
    }

if (mUi->mStartCheck->isChecked()) {
        // Use mActiveStartTime. This is the QTimeZone selected on load coming from
        // the combobox. We use this one as it can slightly differ (e.g. missing
        // country code in the incidence time spec) from the incidence.
        if (currentStartDateTime() != mInitialStartDT) {
            return true;
        }
    }

if (mUi->mEndCheck->isChecked() && currentEndDateTime() != mInitialEndDT) {
        return true;
    }

return false;
}

/// Event specific methods

bool IncidenceDateTime::isDirty(const KCalCore::Event::Ptr &event) const
{
    if (event->allDay() != mUi->mWholeDayCheck->isChecked()) {
        return true;
    }

if (mUi->mFreeBusyCheck->isChecked()
        && event->transparency() != KCalCore::Event::Opaque) {
        return true;
    }

if (!mUi->mFreeBusyCheck->isChecked()
        && event->transparency() != KCalCore::Event::Transparent) {
        return true;
    }

if (event->allDay()) {
        if (mUi->mStartDateEdit->date() != mInitialStartDT.date()
            || mUi->mEndDateEdit->date() != mInitialEndDT.date()) {
            return true;
        }
    } else {
        if (currentStartDateTime() != mInitialStartDT
            || currentEndDateTime() != mInitialEndDT
            || currentStartDateTime().timeZone() != mInitialStartDT.timeZone()
            || currentEndDateTime().timeZone() != mInitialEndDT.timeZone()) {
            return true;
        }
    }

return false;
}

bool IncidenceDateTime::isDirty(const KCalCore::Journal::Ptr &journal) const
{
    if (journal->allDay() != mUi->mWholeDayCheck->isChecked()) {
        return true;
    }

if (journal->allDay()) {
        if (mUi->mStartDateEdit->date() != mInitialStartDT.date()) {
            return true;
        }
    } else {
        if (currentStartDateTime() != mInitialStartDT) {
            return true;
        }
    }

return false;
}

/// Private methods

QDateTime IncidenceDateTime::currentStartDateTime() const
{
    return QDateTime(
        mUi->mStartDateEdit->date(),
        mUi->mStartTimeEdit->time(),
        mUi->mTimeZoneComboStart->selectedTimeZone());
}

QDateTime IncidenceDateTime::currentEndDateTime() const
{
    return QDateTime(
        mUi->mEndDateEdit->date(),
        mUi->mEndTimeEdit->time(),
        mUi->mTimeZoneComboEnd->selectedTimeZone());
}

void IncidenceDateTime::load(const KCalCore::Event::Ptr &event, bool isTemplate,
                             bool templateOverridesTimes)
{
    // First en/disable the necessary ui bits and pieces
    mUi->mStartCheck->setVisible(false);
    mUi->mStartCheck->setChecked(true);   // Set to checked so we can reuse enableTimeEdits.
    mUi->mEndCheck->setVisible(false);
    mUi->mEndCheck->setChecked(true);   // Set to checked so we can reuse enableTimeEdits.

// Start time
    connect(mUi->mStartTimeEdit, &KTimeComboBox::timeChanged, this,
            &IncidenceDateTime::updateStartTime);                                                          // when editing with mouse, or up/down arrows
    connect(mUi->mStartTimeEdit, &KTimeComboBox::timeEdited, this,
            &IncidenceDateTime::updateStartTime);                                                         // When editing with any key except up/down
    connect(mUi->mStartDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceDateTime::updateStartDate);
    connect(mUi->mTimeZoneComboStart,
            static_cast<void (IncidenceEditorNG::KTimeZoneComboBox::*)(int)>(&IncidenceEditorNG::
                                                                             KTimeZoneComboBox::
                                                                             currentIndexChanged),
            this,
            &IncidenceDateTime::updateStartSpec);
    // End time
    connect(mUi->mEndTimeEdit, &KTimeComboBox::timeChanged, this,
            &IncidenceDateTime::checkDirtyStatus);
    connect(mUi->mEndTimeEdit, &KTimeComboBox::timeEdited, this,
            &IncidenceDateTime::checkDirtyStatus);
    connect(mUi->mEndDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceDateTime::checkDirtyStatus);
    connect(mUi->mEndTimeEdit, &KTimeComboBox::timeChanged, this,
            &IncidenceDateTime::endTimeChanged);
    connect(mUi->mEndTimeEdit, &KTimeComboBox::timeEdited, this,
            &IncidenceDateTime::endTimeChanged);
    connect(mUi->mEndDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceDateTime::endDateChanged);
    connect(mUi->mTimeZoneComboEnd,
            static_cast<void (IncidenceEditorNG::KTimeZoneComboBox::*)(int)>(&IncidenceEditorNG::
                                                                             KTimeZoneComboBox::
                                                                             currentIndexChanged),
            this,
            &IncidenceDateTime::checkDirtyStatus);

mUi->mWholeDayCheck->setChecked(event->allDay());
    enableTimeEdits();

if (isTemplate) {
        if (templateOverridesTimes) {
            // We only use the template times if the user didn't override them.
            setTimes(event->dtStart(), event->dtEnd());
        }
    } else {
        QDateTime startDT = event->dtStart();
        QDateTime endDT = event->dtEnd();
        setDateTimes(startDT, endDT);
    }

switch (event->transparency()) {
    case KCalCore::Event::Transparent:
        mUi->mFreeBusyCheck->setChecked(false);
        break;
    case KCalCore::Event::Opaque:
        mUi->mFreeBusyCheck->setChecked(true);
        break;
    }
}

void IncidenceDateTime::load(const KCalCore::Journal::Ptr &journal, bool isTemplate,
                             bool templateOverridesTimes)
{
    // First en/disable the necessary ui bits and pieces
    mUi->mStartCheck->setVisible(false);
    mUi->mStartCheck->setChecked(true);   // Set to checked so we can reuse enableTimeEdits.
    mUi->mEndCheck->setVisible(false);
    mUi->mEndCheck->setChecked(true);   // Set to checked so we can reuse enableTimeEdits.
    mUi->mEndDateEdit->setVisible(false);
    mUi->mEndTimeEdit->setVisible(false);
    mUi->mTimeZoneComboEnd->setVisible(false);
    mUi->mEndLabel->setVisible(false);
    mUi->mFreeBusyCheck->setVisible(false);

// Start time
    connect(mUi->mStartTimeEdit, &KTimeComboBox::timeChanged, this,
            &IncidenceDateTime::updateStartTime);
    connect(mUi->mStartDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceDateTime::updateStartDate);
    connect(mUi->mTimeZoneComboStart,
            static_cast<void (IncidenceEditorNG::KTimeZoneComboBox::*)(int)>(&IncidenceEditorNG::
                                                                             KTimeZoneComboBox::
                                                                             currentIndexChanged),
            this,
            &IncidenceDateTime::updateStartSpec);

mUi->mWholeDayCheck->setChecked(journal->allDay());
    enableTimeEdits();

if (isTemplate) {
        if (templateOverridesTimes) {
            // We only use the template times if the user didn't override them.
            setTimes(journal->dtStart(), QDateTime());
        }
    } else {
        QDateTime startDT = journal->dtStart();

// Convert UTC to local timezone, if needed (i.e. for kolab #204059)
        if (startDT.timeZone() == QTimeZone::utc()) {
            startDT = startDT.toLocalTime();
        }
        setDateTimes(startDT, QDateTime());
    }
}

void IncidenceDateTime::load(const KCalCore::Todo::Ptr &todo, bool isTemplate,
                             bool templateOverridesTimes)
{
    // First en/disable the necessary ui bits and pieces
    mUi->mStartCheck->setVisible(true);
    mUi->mStartCheck->setChecked(todo->hasStartDate());
    mUi->mStartDateEdit->setEnabled(todo->hasStartDate());
    mUi->mStartTimeEdit->setEnabled(todo->hasStartDate());
    mUi->mTimeZoneComboStart->setEnabled(todo->hasStartDate());

mUi->mEndLabel->setText(i18nc("@label The due date/time of a to-do", "Due:"));
    mUi->mEndCheck->setVisible(true);
    mUi->mEndCheck->setChecked(todo->hasDueDate());
    mUi->mEndDateEdit->setEnabled(todo->hasDueDate());
    mUi->mEndTimeEdit->setEnabled(todo->hasDueDate());
    mUi->mTimeZoneComboEnd->setEnabled(todo->hasDueDate());

// These fields where not enabled in the old code either:
    mUi->mFreeBusyCheck->setVisible(false);

const bool hasDateTimes = mUi->mEndCheck->isChecked() || mUi->mStartCheck->isChecked();
    mUi->mWholeDayCheck->setChecked(hasDateTimes && todo->allDay());
    mUi->mWholeDayCheck->setEnabled(hasDateTimes);

// Connect to the right logic
    connect(mUi->mStartCheck, &QCheckBox::toggled, this, &IncidenceDateTime::enableStartEdit);
    connect(mUi->mStartCheck, &QCheckBox::toggled, this, &IncidenceDateTime::startDateTimeToggled);
    connect(mUi->mStartDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceDateTime::checkDirtyStatus);
    connect(mUi->mStartTimeEdit, &KTimeComboBox::timeChanged, this,
            &IncidenceDateTime::updateStartTime);
    connect(mUi->mTimeZoneComboStart,
            static_cast<void (IncidenceEditorNG::KTimeZoneComboBox::*)(int)>(&IncidenceEditorNG::
                                                                             KTimeZoneComboBox::
                                                                             currentIndexChanged),
            this,
            &IncidenceDateTime::checkDirtyStatus);

connect(mUi->mEndCheck, &QCheckBox::toggled, this, &IncidenceDateTime::enableEndEdit);
    connect(mUi->mEndCheck, &QCheckBox::toggled, this, &IncidenceDateTime::endDateTimeToggled);
    connect(mUi->mEndDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceDateTime::checkDirtyStatus);
    connect(mUi->mEndTimeEdit, &KTimeComboBox::timeChanged, this,
            &IncidenceDateTime::checkDirtyStatus);
    connect(mUi->mEndDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceDateTime::endDateChanged);
    connect(mUi->mEndTimeEdit, &KTimeComboBox::timeChanged, this,
            &IncidenceDateTime::endTimeChanged);
    connect(mUi->mTimeZoneComboEnd,
            static_cast<void (IncidenceEditorNG::KTimeZoneComboBox::*)(int)>(&IncidenceEditorNG::
                                                                             KTimeZoneComboBox::
                                                                             currentIndexChanged),
            this,
            &IncidenceDateTime::checkDirtyStatus);

const QDateTime rightNow = QDateTime::currentDateTime();

if (isTemplate) {
        if (templateOverridesTimes) {
            // We only use the template times if the user didn't override them.
            setTimes(todo->dtStart(), todo->dateTime(KCalCore::Incidence::RoleEnd));
        }
    } else {
        const QDateTime endDT = todo->hasDueDate() ? todo->dtDue(true /** first */) : rightNow;
        const QDateTime startDT
            = todo->hasStartDate() ? todo->dtStart(true /** first */) : rightNow;
        setDateTimes(startDT, endDT);
    }
}

void IncidenceDateTime::save(const KCalCore::Event::Ptr &event)
{
    if (mUi->mWholeDayCheck->isChecked()) {   // All day event
        event->setAllDay(true);

// TODO: need to change this.
        QDateTime eventDTStart = currentStartDateTime();
        event->setAllDay(true);
        event->setDtStart(eventDTStart);

QDateTime eventDTEnd = currentEndDateTime();

event->setDtEnd(eventDTEnd);
    } else { // Timed Event
        event->setAllDay(false);

// set date/time end
        event->setDtStart(currentStartDateTime());
        event->setDtEnd(currentEndDateTime());
    }

// Free == Event::Transparent
    // Busy == Event::Opaque
    event->setTransparency(mUi->mFreeBusyCheck->isChecked()
                           ? KCalCore::Event::Opaque
                           : KCalCore::Event::Transparent);
}

void IncidenceDateTime::save(const KCalCore::Todo::Ptr &todo)
{
    if (mUi->mStartCheck->isChecked()) {
        todo->setDtStart(currentStartDateTime());
        // Set allday must be executed after setDtStart
        todo->setAllDay(mUi->mWholeDayCheck->isChecked());
        if (currentStartDateTime() != mInitialStartDT) {
            // We don't offer any way to edit the current completed occurrence.
            // So, if the start date changes, reset the dtRecurrence
            todo->setDtRecurrence(currentStartDateTime());
        }
    } else {
        todo->setDtStart(QDateTime());
    }

if (mUi->mEndCheck->isChecked()) {
        todo->setDtDue(currentEndDateTime(), true /** first */);
        // Set allday must be executed after setDtDue
        todo->setAllDay(mUi->mWholeDayCheck->isChecked());
    } else {
        todo->setDtDue(QDateTime());
    }
}

void IncidenceDateTime::save(const KCalCore::Journal::Ptr &journal)
{
    journal->setAllDay(mUi->mWholeDayCheck->isChecked());

if (mUi->mWholeDayCheck->isChecked()) {   // All day journal
        QDateTime journalDTStart = currentStartDateTime();
        journal->setAllDay(true);
        journal->setDtStart(journalDTStart);
    } else { // Timed Journal
        // set date/time end
        journal->setDtStart(currentStartDateTime());
    }
}

void IncidenceDateTime::setDateTimes(const QDateTime &start, const QDateTime &end)
{
    if (start.isValid()) {
        mUi->mStartDateEdit->setDate(start.date());
        mUi->mStartTimeEdit->setTime(start.time());
        mUi->mTimeZoneComboStart->selectTimeZone(start.timeZone());
    } else {
        QDateTime dt = QDateTime::currentDateTime();
        mUi->mStartDateEdit->setDate(dt.date());
        mUi->mStartTimeEdit->setTime(dt.time());
        mUi->mTimeZoneComboStart->selectTimeZone(dt.timeZone());
    }

if (end.isValid()) {
        mUi->mEndDateEdit->setDate(end.date());
        mUi->mEndTimeEdit->setTime(end.time());
        mUi->mTimeZoneComboEnd->selectTimeZone(end.timeZone());
    } else {
        QDateTime dt(QDate::currentDate(), QTime::currentTime().addSecs(60 * 60));
        mUi->mEndDateEdit->setDate(dt.date());
        mUi->mEndTimeEdit->setTime(dt.time());
        mUi->mTimeZoneComboEnd->selectTimeZone(dt.timeZone());
    }

mCurrentStartDateTime = currentStartDateTime();
    Q_EMIT startDateChanged(start.date());
    Q_EMIT startTimeChanged(start.time());
    Q_EMIT endDateChanged(end.date());
    Q_EMIT endTimeChanged(end.time());

updateStartToolTips();
    updateEndToolTips();
}

void IncidenceDateTime::updateStartToolTips()
{
    if (mUi->mStartCheck->isChecked()) {
        QString datetimeStr
            = KCalUtils::IncidenceFormatter::dateTimeToString(
            currentStartDateTime(),
            mUi->mWholeDayCheck->isChecked(),
            false);
        mUi->mStartDateEdit->setToolTip(i18n("Starts: %1", datetimeStr));
        mUi->mStartTimeEdit->setToolTip(i18n("Starts: %1", datetimeStr));
    } else {
        mUi->mStartDateEdit->setToolTip(i18n("Starting Date"));
        mUi->mStartTimeEdit->setToolTip(i18n("Starting Time"));
    }
}

void IncidenceDateTime::updateEndToolTips()
{
    if (mUi->mStartCheck->isChecked()) {
        QString datetimeStr
            = KCalUtils::IncidenceFormatter::dateTimeToString(
            currentEndDateTime(),
            mUi->mWholeDayCheck->isChecked(),
            false);
        if (mLoadedIncidence->type() == KCalCore::Incidence::TypeTodo) {
            mUi->mEndDateEdit->setToolTip(i18n("Due on: %1", datetimeStr));
            mUi->mEndTimeEdit->setToolTip(i18n("Due on: %1", datetimeStr));
        } else {
            mUi->mEndDateEdit->setToolTip(i18n("Ends: %1", datetimeStr));
            mUi->mEndTimeEdit->setToolTip(i18n("Ends: %1", datetimeStr));
        }
    } else {
        if (mLoadedIncidence->type() == KCalCore::Incidence::TypeTodo) {
            mUi->mEndDateEdit->setToolTip(i18n("Due Date"));
            mUi->mEndTimeEdit->setToolTip(i18n("Due Time"));
        } else {
            mUi->mEndDateEdit->setToolTip(i18n("Ending Date"));
            mUi->mEndTimeEdit->setToolTip(i18n("Ending Time"));
        }
    }
}

void IncidenceDateTime::setTimes(const QDateTime &start, const QDateTime &end)
{
    // like setDateTimes(), but it set only the start/end time, not the date
    // it is used while applying a template to an event.
    mUi->mStartTimeEdit->blockSignals(true);
    mUi->mStartTimeEdit->setTime(start.time());
    mUi->mStartTimeEdit->blockSignals(false);

mUi->mEndTimeEdit->setTime(end.time());

mUi->mTimeZoneComboStart->selectTimeZone(start.timeZone());
    mUi->mTimeZoneComboEnd->selectTimeZone(end.timeZone());

//   emitDateTimeStr();
}

void IncidenceDateTime::setStartDate(const QDate &newDate)
{
    mUi->mStartDateEdit->setDate(newDate);
    updateStartDate(newDate);
}

void IncidenceDateTime::setStartTime(const QTime &newTime)
{
    mUi->mStartTimeEdit->setTime(newTime);
    updateStartTime(newTime);
}

bool IncidenceDateTime::startDateTimeEnabled() const
{
    return mUi->mStartCheck->isChecked();
}

bool IncidenceDateTime::endDateTimeEnabled() const
{
    return mUi->mEndCheck->isChecked();
}

bool IncidenceDateTime::isValid() const
{
    if (startDateTimeEnabled() && !currentStartDateTime().isValid()) {
        //TODO: Add strings
        qCWarning(INCIDENCEEDITOR_LOG) << "Start date is invalid";
        return false;
    }

if (endDateTimeEnabled() && !currentEndDateTime().isValid()) {
        //TODO: Add strings
        qCWarning(INCIDENCEEDITOR_LOG) << "End date is invalid";
        return false;
    }

if (startDateTimeEnabled() && endDateTimeEnabled()
        && currentStartDateTime() > currentEndDateTime()) {
        if (mLoadedIncidence->type() == KCalCore::Incidence::TypeEvent) {
            mLastErrorString = i18nc("@info",
                                     "The event ends before it starts.\n"
                                     "Please correct dates and times.");
        } else if (mLoadedIncidence->type() == KCalCore::Incidence::TypeTodo) {
            mLastErrorString = i18nc("@info",
                                     "The to-do is due before it starts.\n"
                                     "Please correct dates and times.");
        } else if (mLoadedIncidence->type() == KCalCore::Incidence::TypeJournal) {
            return true;
        }

qCDebug(INCIDENCEEDITOR_LOG) << mLastErrorString;
        return false;
    } else {
        mLastErrorString.clear();
        return true;
    }
}

void IncidenceDateTime::printDebugInfo() const
{
    qCDebug(INCIDENCEEDITOR_LOG) << "startDateTimeEnabled()          : " << startDateTimeEnabled();
    qCDebug(INCIDENCEEDITOR_LOG) << "endDateTimeEnabled()            : " << endDateTimeEnabled();
    qCDebug(INCIDENCEEDITOR_LOG) << "currentStartDateTime().isValid(): "
                                 << currentStartDateTime().isValid();
    qCDebug(INCIDENCEEDITOR_LOG) << "currentEndDateTime().isValid()  : "
                                 << currentEndDateTime().isValid();
    qCDebug(INCIDENCEEDITOR_LOG) << "currentStartDateTime()          : "
                                 << currentStartDateTime().toString();
    qCDebug(INCIDENCEEDITOR_LOG) << "currentEndDateTime()            : "
                                 << currentEndDateTime().toString();
    qCDebug(INCIDENCEEDITOR_LOG) << "Incidence type                  : "
                                 << mLoadedIncidence->type();
    qCDebug(INCIDENCEEDITOR_LOG) << "allday                          : "
                                 << mLoadedIncidence->allDay();
    qCDebug(INCIDENCEEDITOR_LOG) << "mInitialStartDT                 : "
                                 << mInitialStartDT.toString();
    qCDebug(INCIDENCEEDITOR_LOG) << "mInitialEndDT                   : "
                                 << mInitialEndDT.toString();

qCDebug(INCIDENCEEDITOR_LOG) << "currentStartDateTime().timeZone(): " << currentStartDateTime().timeZone().id();
    qCDebug(INCIDENCEEDITOR_LOG) << "currentEndDateTime().timeZone()  : " << currentEndDateTime().timeZone().id();
    qCDebug(INCIDENCEEDITOR_LOG) << "mInitialStartDT.timeZone()       : " << mInitialStartDT.timeZone().id();
    qCDebug(INCIDENCEEDITOR_LOG) << "mInitialEndDT.timeZone()         : " << mInitialEndDT.timeZone().id();

qCDebug(INCIDENCEEDITOR_LOG) << "dirty test1: "
                                 << (mLoadedIncidence->allDay()
        != mUi->mWholeDayCheck->isChecked());
    if (mLoadedIncidence->type() == KCalCore::Incidence::TypeEvent) {
        KCalCore::Event::Ptr event = mLoadedIncidence.staticCast<KCalCore::Event>();
        qCDebug(INCIDENCEEDITOR_LOG) << "dirty test2: "
                                     << (mUi->mFreeBusyCheck->isChecked()
            && event->transparency() != KCalCore::Event::Opaque);
        qCDebug(INCIDENCEEDITOR_LOG) << "dirty test3: "
                                     << (!mUi->mFreeBusyCheck->isChecked()
            && event->transparency() != KCalCore::Event::Transparent);
    }

if (mLoadedIncidence->allDay()) {
        qCDebug(INCIDENCEEDITOR_LOG) << "dirty test4: "
                                     << (mUi->mStartDateEdit->date() != mInitialStartDT.date()
            || mUi->mEndDateEdit->date() != mInitialEndDT.date());
    } else {
        qCDebug(INCIDENCEEDITOR_LOG) << "dirty test4.1: "
                                     << (currentStartDateTime() != mInitialStartDT);
        qCDebug(INCIDENCEEDITOR_LOG) << "dirty test4.2: "
                                     << (currentEndDateTime() != mInitialEndDT);
        qCDebug(INCIDENCEEDITOR_LOG) << "dirty test4.3: "
                                     << (currentStartDateTime().timeZone() != mInitialStartDT.timeZone());
        qCDebug(INCIDENCEEDITOR_LOG) << "dirty test4.4: "
                                     << (currentEndDateTime().timeZone() != mInitialEndDT.timeZone());
    }
}

void IncidenceDateTime::setTimeZoneLabelEnabled(bool enable)
{
    mUi->mTimeZoneLabel->setVisible(enable);
}
07070111A01955000081A40000000200000002000000015AA55A86000014B0000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedatetime.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 INCIDENCEEDITOR_INCIDENCEDATETIME_H
#define INCIDENCEEDITOR_INCIDENCEDATETIME_H

#include "incidenceeditor-ng.h"

#include <KCalCore/Event>
#include <KCalCore/Journal>
#include <KCalCore/Todo>

#include <QDate>

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class IncidenceDateTime : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual
    explicit IncidenceDateTime(Ui::EventOrTodoDesktop *ui);
    ~IncidenceDateTime();

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;

/**
     * Sets the active date for the editing session. This defaults to the current
     * date. It should be set <em>before</em> loading a non-empty (i.e. existing
     * incidence).
     */
    void setActiveDate(const QDate &activeDate);

QDate startDate() const; /// Returns the current start date.
    QTime startTime() const; /// Returns the current start time.
    QDate endDate() const; /// Returns the current end date.
    QTime endTime() const; /// Returns the current endtime.

/// Created from the values in the widgets
    QDateTime currentStartDateTime() const;
    QDateTime currentEndDateTime() const;

void setStartTime(const QTime &newTime);
    void setStartDate(const QDate &newDate);

bool startDateTimeEnabled() const;
    bool endDateTimeEnabled() const;

bool isValid() const override;
    void printDebugInfo() const override;

Q_SIGNALS:
    // used to indicate that the widgets were activated
    void startDateFocus(QObject *obj);
    void endDateFocus(QObject *obj);
    void startTimeFocus(QObject *obj);
    void endTimeFocus(QObject *obj);

// general
    void startDateTimeToggled(bool enabled);
    void startDateChanged(const QDate &newDate);
    void startTimeChanged(const QTime &newTime);
    void endDateTimeToggled(bool enabled);
    void endDateChanged(const QDate &newDate);
    void endTimeChanged(const QTime &newTime);

private Q_SLOTS: /// General
    void setTimeZonesVisibility(bool visible);
    void toggleTimeZoneVisibility();
    void updateStartTime(const QTime &newTime);
    void updateStartDate(const QDate &newDate);
    void updateStartSpec();
    void updateStartToolTips();
    void updateEndToolTips();

private Q_SLOTS: /// Todo specific
    void enableStartEdit(bool enable);
    void enableEndEdit(bool enable);
    void enableTimeEdits();

private:
    bool isDirty(const KCalCore::Todo::Ptr &todo) const;
    bool isDirty(const KCalCore::Event::Ptr &event) const;
    bool isDirty(const KCalCore::Journal::Ptr &journal) const;

protected:
    bool eventFilter(QObject *obj, QEvent *event) override;

private:
    void load(const KCalCore::Event::Ptr &event, bool isTemplate = false,
              bool templateOverridesTimes = false);
    void load(const KCalCore::Todo::Ptr &todo, bool isTemplate = false,
              bool templateOverridesTimes = false);
    void load(const KCalCore::Journal::Ptr &journal, bool isTemplate = false,
              bool templateOverridesTimes = false);
    void save(const KCalCore::Event::Ptr &event);
    void save(const KCalCore::Todo::Ptr &todo);
    void save(const KCalCore::Journal::Ptr &journal);
    void setDateTimes(const QDateTime &start, const QDateTime &end);
    void setTimes(const QDateTime &start, const QDateTime &end);
    void setTimeZoneLabelEnabled(bool enable);
    bool timeZonesAreLocal(const QDateTime &start, const QDateTime &end);

private:
    Ui::EventOrTodoDesktop *mUi = nullptr;

QDate mActiveDate;
    /**
     * These might differ from mLoadedIncidence->(dtStart|dtDue) as these take
     * in account recurrence if needed. The values are calculated once on load().
     * and don't change afterwards.
     */
    QDateTime mInitialStartDT;
    QDateTime mInitialEndDT;

/**
     * We need to store the current start date/time to be able to update the end
     * time appropriate when the start time changes.
     */
    QDateTime mCurrentStartDateTime;

/// Remembers state when switching between takes whole day and timed event/to-do.
    bool mTimezoneCombosWereVisibile;
};
}

#endif
07070111A01956000081A40000000200000002000000015AA55A8600003C2E000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedefaults.cpp/*
  Copyright (C) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 <config-enterprise.h>

#include "incidencedefaults.h"
#include "alarmpresets.h"
#include "incidenceeditor_debug.h"

#include <CalendarSupport/KCalPrefs>
#include <akonadi/calendar/calendarsettings.h> //krazy:exclude=camelcase this is a generated file

#include <KContacts/Addressee>

#include <KCalCore/Event>
#include <KCalCore/Todo>
#include <KCalCore/Journal>
#include <KCalCore/Alarm>

#include <KEmailAddress>

#include <KIO/Job>
#include <KIO/StoredTransferJob>
#include <KLocalizedString>

#include <QUrl>
#include <QFile>

using namespace CalendarSupport;
using namespace IncidenceEditorNG;
using namespace KCalCore;

namespace IncidenceEditorNG {
enum {
    UNSPECIFED_PRIORITY = 0
};

class IncidenceDefaultsPrivate
{
public:
    /// Members
    KCalCore::Attachment::List mAttachments;
    QVector<KCalCore::Attendee::Ptr> mAttendees;
    QStringList mEmails;
    QString mGroupWareDomain;
    KCalCore::Incidence::Ptr mRelatedIncidence;
    QDateTime mStartDt;
    QDateTime mEndDt;
    bool mCleanupTemporaryFiles;

/// Methods
    KCalCore::Person::Ptr organizerAsPerson() const;
    KCalCore::Attendee::Ptr organizerAsAttendee(const KCalCore::Person::Ptr &organizer) const;

void todoDefaults(const KCalCore::Todo::Ptr &todo) const;
    void eventDefaults(const KCalCore::Event::Ptr &event) const;
    void journalDefaults(const KCalCore::Journal::Ptr &journal) const;
};
}

KCalCore::Person::Ptr IncidenceDefaultsPrivate::organizerAsPerson() const
{
    const QString invalidEmail = IncidenceDefaults::invalidEmailAddress();

KCalCore::Person::Ptr organizer(new KCalCore::Person);
    organizer->setName(i18nc("@label", "no (valid) identities found"));
    organizer->setEmail(invalidEmail);

if (mEmails.isEmpty()) {
        // Don't bother any longer, either someone forget to call setFullEmails, or
        // the user has no identities configured.
        return organizer;
    }

if (!mGroupWareDomain.isEmpty()) {
        // Check if we have an identity with an email that ends with the groupware
        // domain.
        for (const QString &fullEmail : qAsConst(mEmails)) {
            QString name;
            QString email;
            const bool success = KEmailAddress::extractEmailAddressAndName(fullEmail, email, name);
            if (success && email.endsWith(mGroupWareDomain)) {
                organizer->setName(name);
                organizer->setEmail(email);
                break;
            }
        }
    }

if (organizer->email() == invalidEmail) {
        // Either, no groupware was used, or we didn't find a groupware email address.
        // Now try to
        for (const QString &fullEmail : qAsConst(mEmails)) {
            QString name;
            QString email;
            const bool success = KEmailAddress::extractEmailAddressAndName(fullEmail, email, name);
            if (success) {
                organizer->setName(name);
                organizer->setEmail(email);
                break;
            }
        }
    }

return organizer;
}

KCalCore::Attendee::Ptr IncidenceDefaultsPrivate::organizerAsAttendee(
    const KCalCore::Person::Ptr &organizer) const
{
    KCalCore::Attendee::Ptr organizerAsAttendee(new KCalCore::Attendee(QLatin1String(
                                                                           ""), QLatin1String("")));
    // Really, the appropriate values (even the fall back values) should come from
    // organizer. (See organizerAsPerson for more details).
    organizerAsAttendee->setName(organizer->name());
    organizerAsAttendee->setEmail(organizer->email());
    // NOTE: Don't set the status to None, this value is not supported by the attendee
    //       editor atm.
    organizerAsAttendee->setStatus(KCalCore::Attendee::Accepted);
    organizerAsAttendee->setRole(KCalCore::Attendee::ReqParticipant);
    return organizerAsAttendee;
}

void IncidenceDefaultsPrivate::eventDefaults(const KCalCore::Event::Ptr &event) const
{
    QDateTime startDT;
    if (mStartDt.isValid()) {
        startDT = mStartDt;
    } else {
        startDT = QDateTime::currentDateTime();

if (KCalPrefs::instance()->startTime().isValid()) {
            startDT.setTime(KCalPrefs::instance()->startTime().time());
        }
    }

const QTime defaultDurationTime = KCalPrefs::instance()->defaultDuration().time();
    const int defaultDuration = (defaultDurationTime.hour() * 3600) +
                                (defaultDurationTime.minute() * 60);

const QDateTime endDT = mEndDt.isValid() ? mEndDt : startDT.addSecs(defaultDuration);

event->setDtStart(startDT);
    event->setDtEnd(endDT);
    event->setTransparency(KCalCore::Event::Opaque);

if (KCalPrefs::instance()->defaultEventReminders()) {
        event->addAlarm(AlarmPresets::defaultAlarm(AlarmPresets::BeforeStart));
    }
}

void IncidenceDefaultsPrivate::journalDefaults(const KCalCore::Journal::Ptr &journal) const
{
    const QDateTime startDT = mStartDt.isValid() ? mStartDt : QDateTime::currentDateTime();
    journal->setDtStart(startDT);
    journal->setAllDay(true);
}

void IncidenceDefaultsPrivate::todoDefaults(const KCalCore::Todo::Ptr &todo) const
{
    KCalCore::Todo::Ptr relatedTodo = mRelatedIncidence.dynamicCast<KCalCore::Todo>();
    if (relatedTodo) {
        todo->setCategories(relatedTodo->categories());
    }

if (mEndDt.isValid()) {
        todo->setDtDue(mEndDt, true /** first */);
    } else if (relatedTodo && relatedTodo->hasDueDate()) {
        todo->setDtDue(relatedTodo->dtDue(true), true /** first */);
        todo->setAllDay(relatedTodo->allDay());
    } else if (relatedTodo) {
        todo->setDtDue(QDateTime());
    } else {
        todo->setDtDue(QDateTime::currentDateTime().addDays(1), true /** first */);
    }

if (mStartDt.isValid()) {
        todo->setDtStart(mStartDt);
    } else if (relatedTodo && !relatedTodo->hasStartDate()) {
        todo->setDtStart(QDateTime());
    } else if (relatedTodo && relatedTodo->hasStartDate() &&
               relatedTodo->dtStart() <= todo->dtDue()) {
        todo->setDtStart(relatedTodo->dtStart());
        todo->setAllDay(relatedTodo->allDay());
    } else if (!mEndDt.isValid() || (QDateTime::currentDateTime() < mEndDt)) {
        todo->setDtStart(QDateTime::currentDateTime());
    } else {
        todo->setDtStart(mEndDt.addDays(-1));
    }

todo->setCompleted(false);
    todo->setPercentComplete(0);

// I had a bunch of to-dos and couldn't distinguish between those that had priority '5'
    // because I wanted, and those that had priority '5' because it was set by default
    // and I forgot to unset it.
    // So don't be smart and try to guess a good default priority for the user, just use unspecified.
    todo->setPriority(UNSPECIFED_PRIORITY);

if (KCalPrefs::instance()->defaultTodoReminders()) {
        todo->addAlarm(AlarmPresets::defaultAlarm(AlarmPresets::BeforeEnd));
    }
}

/// IncidenceDefaults

IncidenceDefaults::IncidenceDefaults(bool cleanupAttachmentTemporaryFiles)
    : d_ptr(new IncidenceDefaultsPrivate)
{
    d_ptr->mCleanupTemporaryFiles = cleanupAttachmentTemporaryFiles;
}

IncidenceDefaults::IncidenceDefaults(const IncidenceDefaults &other)
    : d_ptr(new IncidenceDefaultsPrivate)
{
    *d_ptr = *other.d_ptr;
}

IncidenceDefaults::~IncidenceDefaults()
{
    delete d_ptr;
}

IncidenceDefaults &IncidenceDefaults::operator=(const IncidenceDefaults &other)
{
    if (&other != this) {
        *d_ptr = *other.d_ptr;
    }
    return *this;
}

void IncidenceDefaults::setAttachments(const QStringList &attachments,
                                       const QStringList &attachmentMimetypes,
                                       const QStringList &attachmentLabels, bool inlineAttachment)
{
    Q_D(IncidenceDefaults);
    d->mAttachments.clear();

QStringList::ConstIterator it;
    int i = 0;
    for (it = attachments.constBegin(); it != attachments.constEnd(); ++it, ++i) {
        if (!(*it).isEmpty()) {
            QString mimeType;
            if (attachmentMimetypes.count() > i) {
                mimeType = attachmentMimetypes[ i ];
            }

KCalCore::Attachment::Ptr attachment;
            if (inlineAttachment) {
                auto job = KIO::storedGet(QUrl::fromUserInput(*it));
                if (job->exec()) {
                    const QByteArray data = job->data();
                    attachment
                        = KCalCore::Attachment::Ptr(new KCalCore::Attachment(data.toBase64(),
                                                                             mimeType));

if (i < attachmentLabels.count()) {
                        attachment->setLabel(attachmentLabels[ i ]);
                    }
                } else {
                    qCCritical(INCIDENCEEDITOR_LOG) << "Error downloading uri " << *it
                                                    << job->errorString();
                }

if (d_ptr->mCleanupTemporaryFiles) {
                    QFile file(*it);
                    if (!file.remove()) {
                        qCCritical(INCIDENCEEDITOR_LOG) << "Uname to remove file " << *it;
                    }
                }
            } else {
                attachment = KCalCore::Attachment::Ptr(new KCalCore::Attachment(*it, mimeType));
                if (i < attachmentLabels.count()) {
                    attachment->setLabel(attachmentLabels[ i ]);
                }
            }

if (attachment) {
                if (attachment->label().isEmpty()) {
                    if (attachment->isUri()) {
                        attachment->setLabel(attachment->uri());
                    } else {
                        attachment->setLabel(
                            i18nc("@label attachment contains binary data", "[Binary data]"));
                    }
                }
                d->mAttachments << attachment;
                attachment->setShowInline(inlineAttachment);
            }
        }
    }
}

void IncidenceDefaults::setAttendees(const QStringList &attendees)
{
    Q_D(IncidenceDefaults);
    d->mAttendees.clear();
    QStringList::ConstIterator it;
    for (it = attendees.begin(); it != attendees.end(); ++it) {
        QString name, email;
        KContacts::Addressee::parseEmailAddress(*it, name, email);
        d->mAttendees << KCalCore::Attendee::Ptr(
            new KCalCore::Attendee(name, email, true, KCalCore::Attendee::NeedsAction));
    }
}

void IncidenceDefaults::setFullEmails(const QStringList &fullEmails)
{
    Q_D(IncidenceDefaults);
    d->mEmails = fullEmails;
}

void IncidenceDefaults::setGroupWareDomain(const QString &domain)
{
    Q_D(IncidenceDefaults);
    d->mGroupWareDomain = domain;
}

void IncidenceDefaults::setRelatedIncidence(const KCalCore::Incidence::Ptr &incidence)
{
    Q_D(IncidenceDefaults);
    d->mRelatedIncidence = incidence;
}

void IncidenceDefaults::setStartDateTime(const QDateTime &startDT)
{
    Q_D(IncidenceDefaults);
    d->mStartDt = startDT;
}

void IncidenceDefaults::setEndDateTime(const QDateTime &endDT)
{
    Q_D(IncidenceDefaults);
    d->mEndDt = endDT;
}

void IncidenceDefaults::setDefaults(const KCalCore::Incidence::Ptr &incidence) const
{
    Q_D(const IncidenceDefaults);

// First some general defaults
    incidence->setSummary(QString(), false);
    incidence->setLocation(QString(), false);
    incidence->setCategories(QStringList());
    incidence->setSecrecy(KCalCore::Incidence::SecrecyPublic);
    incidence->setStatus(KCalCore::Incidence::StatusNone);
    incidence->setAllDay(false);
    incidence->setCustomStatus(QString());
    incidence->setResources(QStringList());
    incidence->setPriority(0);

if (d->mRelatedIncidence) {
        incidence->setRelatedTo(d->mRelatedIncidence->uid());
    }

incidence->clearAlarms();
    incidence->clearAttachments();
    incidence->clearAttendees();
    incidence->clearComments();
    incidence->clearContacts();
    incidence->clearRecurrence();
    incidence->clearTempFiles();

const KCalCore::Person::Ptr organizerAsPerson = d->organizerAsPerson();
#ifdef KDEPIM_ENTERPRISE_BUILD
    incidence->addAttendee(d->organizerAsAttendee(organizerAsPerson));
#endif
    for (const KCalCore::Attendee::Ptr &attendee : qAsConst(d->mAttendees)) {
        incidence->addAttendee(attendee);
    }
    // Ical standard: No attendees -> must not have an organizer!
    if (incidence->attendeeCount()) {
        incidence->setOrganizer(organizerAsPerson);
    }

for (const KCalCore::Attachment::Ptr &attachment : qAsConst(d->mAttachments)) {
        incidence->addAttachment(attachment);
    }

switch (incidence->type()) {
    case KCalCore::Incidence::TypeEvent:
        d->eventDefaults(incidence.dynamicCast<KCalCore::Event>());
        break;
    case KCalCore::Incidence::TypeTodo:
        d->todoDefaults(incidence.dynamicCast<KCalCore::Todo>());
        break;
    case KCalCore::Incidence::TypeJournal:
        d->journalDefaults(incidence.dynamicCast<KCalCore::Journal>());
        break;
    default:
        qCDebug(INCIDENCEEDITOR_LOG) << "Unsupported incidence type, keeping current values. Type: "
                                     << static_cast<int>(incidence->type());
    }
}

/** static */
IncidenceDefaults IncidenceDefaults::minimalIncidenceDefaults(bool cleanupAttachmentTempFiles)
{
    IncidenceDefaults defaults(cleanupAttachmentTempFiles);

// Set the full emails manually here, to avoid that we get dependencies on
    // KCalPrefs all over the place.
    defaults.setFullEmails(CalendarSupport::KCalPrefs::instance()->fullEmails());

// NOTE: At some point this should be generalized. That is, we now use the
    //       freebusy url as a hack, but this assumes that the user has only one
    //       groupware account. Which doesn't have to be the case necessarily.
    //       This method should somehow depend on the calendar selected to which
    //       the incidence is added.
    if (CalendarSupport::KCalPrefs::instance()->useGroupwareCommunication()) {
        defaults.setGroupWareDomain(
            QUrl(Akonadi::CalendarSettings::self()->freeBusyRetrieveUrl()).host());
    }
    return defaults;
}

/** static */
QString IncidenceDefaults::invalidEmailAddress()
{
    static const QString invalidEmail(i18nc("@label invalid email address marker",
                                            "invalid@email.address"));
    return invalidEmail;
}
07070111A01957000081A40000000200000002000000015AA55A8600001224000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedefaults.h/*
  Copyright (C) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 INCIDENCEEDITOR_INCIDENCEDEFAULTS_H
#define INCIDENCEEDITOR_INCIDENCEDEFAULTS_H

#include "incidenceeditor_export.h"

#include <KCalCore/Incidence>

namespace IncidenceEditorNG {
class IncidenceDefaultsPrivate;

class INCIDENCEEDITOR_EXPORT IncidenceDefaults
{
public:
    explicit IncidenceDefaults(bool cleanupAttachmentTEmporaryFiles = false);
    IncidenceDefaults(const IncidenceDefaults &other);
    ~IncidenceDefaults();

IncidenceDefaults &operator=(const IncidenceDefaults &other);

/**
      Sets the attachments that are added by default to incidences.
    */
    void setAttachments(const QStringList &attachments,
                        const QStringList &attachmentMimetypes = QStringList(),
                        const QStringList &attachmentLabels = QStringList(),
                        bool inlineAttachment = false);

/**
      Sets the attendees that are added by default to incidences.
      @param attendees Expected to be of the form "name name <email>"
    */
    void setAttendees(const QStringList &attendees);

/**
      Sets the list of identities to be used for the user. The items in the list
      are expected to be of the form: "name [name] <email>".

If the list is empty, it is assumed that no valid identities are configured.

@param fullEmails The list of name email pairs that the user has configured as identities.
    */
    void setFullEmails(const QStringList &fullEmails);

/**
      This is used to do a smarter guess about which identity to use for the organizer.
      If the groupware server is not set, the first avaialble identity will be used.
      @param domain The gropuware server domain name without any protocol prefixes
      (e.g. demo.kolab.org).
    */
    void setGroupWareDomain(const QString &domain);

/**
      Sets the incidence related to the incidence for which to set the defaults. For
      example the parent todo of a new sub todo.
    */
    void setRelatedIncidence(const KCalCore::Incidence::Ptr &incidence);

/**
      Set the start date/time to use for passed incidences. This defaults to the
      current start date/time. The main purpose of this method is supporting
      defaults for new incidences that where created with a given time slot.
      @param startDT The start date time to set on the incidence.
    */
    void setStartDateTime(const QDateTime &startDT);

/**
      Set the end date/time to use for passed incidences. This defaults to the
      current start date/time. The main purpose of this method is supporting
      defaults for new incidences that where created with a given time slot.
      @param endDT The start date time to set on the incidence.
    */
    void setEndDateTime(const QDateTime &endDT);

/**
      Sets the default values for @param incidence. This method is merely meant for
      <em>new</em> icidences. However, it will clear out all fields and set them
      to default values.
      @param incidence The incidence that will get default values for all of its field.
    */
    void setDefaults(const KCalCore::Incidence::Ptr &incidence) const;

/**
     * Returns minimal incidence defaults: e-mails and groupware domain.
     *
     * TODO: See if this is always called when using IncidenceDefaults.
     * If yes, this should be done inside ctor.
     */
    static IncidenceDefaults minimalIncidenceDefaults(bool cleanupAttachmentTempFiles = false);

// Returns the e-mail address used for the organizer when we can't find anything useful
    // This is something like "invalid@invalid"
    static QString invalidEmailAddress();

private:
    IncidenceDefaultsPrivate *const d_ptr;
    Q_DECLARE_PRIVATE(IncidenceDefaults)
};
}

#endif
07070111A01958000081A40000000200000002000000015AA55A8600002533000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedescription.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidencedescription.h"
#include "ui_dialogdesktop.h"
#include <KPIMTextEdit/RichTextComposer>

#include "incidenceeditor_debug.h"
#include <KActionCollection>
#include <KToolBar>
#include <KLocalizedString>

using namespace IncidenceEditorNG;

namespace IncidenceEditorNG {
class IncidenceDescriptionPrivate
{
public:
    IncidenceDescriptionPrivate() : mRichTextEnabled(false)
    {
    }

QString mRealOriginalDescriptionEditContents;
    bool mRichTextEnabled;
};
}

IncidenceDescription::IncidenceDescription(Ui::EventOrTodoDesktop *ui)
    : IncidenceEditor(nullptr)
    , mUi(ui)
    , d(new IncidenceDescriptionPrivate())
{
    setObjectName(QStringLiteral("IncidenceDescription"));
    mUi->mRichTextLabel->setContextMenuPolicy(Qt::NoContextMenu);
    setupToolBar();
    connect(mUi->mRichTextLabel, &QLabel::linkActivated, this,
            &IncidenceDescription::toggleRichTextDescription);
    connect(
        mUi->mDescriptionEdit->richTextComposer(), &KPIMTextEdit::RichTextComposer::textChanged, this,
        &IncidenceDescription::checkDirtyStatus);
}

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

void IncidenceDescription::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;

d->mRealOriginalDescriptionEditContents.clear();

if (incidence) {
        enableRichTextDescription(incidence->descriptionIsRich());
        if (incidence->descriptionIsRich()) {
            mUi->mDescriptionEdit->richTextComposer()->setHtml(incidence->richDescription());
            d->mRealOriginalDescriptionEditContents
                = mUi->mDescriptionEdit->richTextComposer()->toHtml();
        } else {
            mUi->mDescriptionEdit->richTextComposer()->setPlainText(incidence->description());
            d->mRealOriginalDescriptionEditContents
                = mUi->mDescriptionEdit->richTextComposer()->toPlainText();
        }
    } else {
        enableRichTextDescription(false);
        mUi->mDescriptionEdit->richTextComposer()->clear();
    }

mWasDirty = false;
}

void IncidenceDescription::save(const KCalCore::Incidence::Ptr &incidence)
{
    if (d->mRichTextEnabled) {
        incidence->setDescription(mUi->mDescriptionEdit->richTextComposer()->toHtml(), true);
    } else {
        incidence->setDescription(mUi->mDescriptionEdit->richTextComposer()->toPlainText(), false);
    }
}

bool IncidenceDescription::isDirty() const
{
    /* Sometimes, what you put in a KRichTextWidget isn't the same as what you get out.
       Line terminators (cr,lf) for example can be converted.

So, to see if the user changed something, we can't compare the original incidence
       with the new editor content.

Instead we compare the new editor content, with the original editor content, this way
       any tranformation regarding non-printable chars will be irrelevant.
    */
    if (d->mRichTextEnabled) {
        return !mLoadedIncidence->descriptionIsRich()
               || d->mRealOriginalDescriptionEditContents
               != mUi->mDescriptionEdit->richTextComposer()->toHtml();
    } else {
        return mLoadedIncidence->descriptionIsRich()
               || d->mRealOriginalDescriptionEditContents
               != mUi->mDescriptionEdit->richTextComposer()->toPlainText();
    }
}

void IncidenceDescription::enableRichTextDescription(bool enable)
{
    d->mRichTextEnabled = enable;

QString rt(i18nc("@action Enable or disable rich text editting", "Enable rich text"));
    QString placeholder(QStringLiteral("<a href=\"show\"><font color='blue'>%1 &gt;&gt;</font></a>"));

if (enable) {
        rt = i18nc("@action Enable or disable rich text editting", "Disable rich text");
        placeholder = QStringLiteral("<a href=\"show\"><font color='blue'>&lt;&lt; %1</font></a>");
        mUi->mDescriptionEdit->richTextComposer()->activateRichText();
        d->mRealOriginalDescriptionEditContents
            = mUi->mDescriptionEdit->richTextComposer()->toHtml();
    } else {
        mUi->mDescriptionEdit->richTextComposer()->switchToPlainText();
        d->mRealOriginalDescriptionEditContents
            = mUi->mDescriptionEdit->richTextComposer()->toPlainText();
    }

placeholder = placeholder.arg(rt);
    mUi->mRichTextLabel->setText(placeholder);
    mUi->mDescriptionEdit->richTextComposer()->setEnableActions(enable);
    mUi->mEditToolBarPlaceHolder->setVisible(enable);
    checkDirtyStatus();
}

void IncidenceDescription::toggleRichTextDescription()
{
    enableRichTextDescription(!d->mRichTextEnabled);
}

void IncidenceDescription::setupToolBar()
{
#ifndef QT_NO_TOOLBAR
    KActionCollection *collection = new KActionCollection(this);
    mUi->mDescriptionEdit->richTextComposer()->createActions(collection);

KToolBar *mEditToolBar = new KToolBar(mUi->mEditToolBarPlaceHolder);
    mEditToolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
    mEditToolBar->addAction(collection->action(QStringLiteral("format_text_bold")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_text_italic")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_text_underline")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_text_strikeout")));
    mEditToolBar->addSeparator();

mEditToolBar->addAction(collection->action(QStringLiteral("format_font_family")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_font_size")));
    mEditToolBar->addSeparator();

mEditToolBar->addAction(collection->action(QStringLiteral("format_text_foreground_color")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_text_background_color")));
    mEditToolBar->addSeparator();

mEditToolBar->addAction(collection->action(QStringLiteral("format_list_style")));
    mEditToolBar->addSeparator();

mEditToolBar->addAction(collection->action(QStringLiteral("format_align_left")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_align_center")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_align_right")));
    mEditToolBar->addAction(collection->action(QStringLiteral("format_align_justify")));
    mEditToolBar->addSeparator();

mEditToolBar->addAction(collection->action(QStringLiteral("format_painter")));
    mUi->mDescriptionEdit->richTextComposer()->setEnableActions(false);

QGridLayout *layout = new QGridLayout(mUi->mEditToolBarPlaceHolder);
    layout->addWidget(mEditToolBar);
#endif

// By default we don't show the rich text toolbar.
    mUi->mEditToolBarPlaceHolder->setVisible(false);
    d->mRichTextEnabled = false;
}

void IncidenceDescription::printDebugInfo() const
{
    // We're going to crash
    qCDebug(INCIDENCEEDITOR_LOG) << "RichText enabled " << d->mRichTextEnabled;

if (mLoadedIncidence) {
        qCDebug(INCIDENCEEDITOR_LOG) << "Incidence description is rich "
                                     << mLoadedIncidence->descriptionIsRich();

if (mLoadedIncidence->descriptionIsRich()) {
            qCDebug(INCIDENCEEDITOR_LOG) << "desc is rich, and it is <desc>"
                                         <<  mLoadedIncidence->richDescription()
                                         << "</desc>; "
                                         << "widget has <desc>"
                                         << mUi->mDescriptionEdit->richTextComposer()->toHtml()
                                         << "</desc>; "
                                         <<
            "expr mLoadedIncidence->richDescription() != mUi->mDescriptionEdit->toHtml() is "
                                         << (mLoadedIncidence->richDescription()
                != mUi->mDescriptionEdit->richTextComposer()->toHtml());
        } else {
            qCDebug(INCIDENCEEDITOR_LOG) << "desc is not rich, and it is <desc>"
                                         << mLoadedIncidence->description()
                                         << "</desc>; "
                                         << "widget has <desc>"
                                         << mUi->mDescriptionEdit->richTextComposer()->toPlainText()
                                         << "</desc>; "
                                         <<
            "expr mLoadedIncidence->description() != mUi->mDescriptionEdit->toPlainText() is "
                                         << (mLoadedIncidence->description()
                != mUi->mDescriptionEdit->richTextComposer()->toPlainText());
        }
    } else {
        qCDebug(INCIDENCEEDITOR_LOG) << "Incidence is invalid";
    }
}
07070111A01959000081A40000000200000002000000015AA55A860000089B000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedescription.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_INCIDENCEDESCRIPTION_H
#define INCIDENCEEDITOR_INCIDENCEDESCRIPTION_H

#include "incidenceeditor-ng.h"

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class IncidenceDescriptionPrivate;

/**
 * The IncidenceDescriptionEditor keeps track of the following Incidence parts:
 * - description
 */
class IncidenceDescription : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual

explicit IncidenceDescription(Ui::EventOrTodoDesktop *ui);

~IncidenceDescription();

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;

// For debugging pursposes
    bool richTextEnabled() const;

void printDebugInfo() const override;

private:
    void toggleRichTextDescription();
    void enableRichTextDescription(bool enable);
    void setupToolBar();

private:
    Ui::EventOrTodoDesktop *mUi = nullptr;
    //@cond PRIVATE
    Q_DECLARE_PRIVATE(IncidenceDescription)
    IncidenceDescriptionPrivate *const d;
    //@endcond
};
}

#endif
07070111A0195A000081A40000000200000002000000015AA55A8600007BA4000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedialog.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
  Copyright (C) 2012  Allen Winter <winter@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 "incidencedialog.h"
#include "incidenceeditor_debug.h"
#include "combinedincidenceeditor.h"
#include "editorconfig.h"
#include "incidencealarm.h"
#include "incidenceattachment.h"
#include "incidenceattendee.h"
#include "incidencecategories.h"
#include "incidencecompletionpriority.h"
#include "incidencedatetime.h"
#include "incidencedescription.h"
#include "incidencerecurrence.h"
#include "incidenceresource.h"
#include "incidencesecrecy.h"
#include "incidencewhatwhere.h"
#include "templatemanagementdialog.h"
#include "ui_dialogdesktop.h"

#include <incidenceeditorsettings.h>

#include <CalendarSupport/KCalPrefs>
#include <CalendarSupport/Utils>

#include <CollectionComboBox>
#include <Item>
#include <Akonadi/Calendar/ETMCalendar>

#include <KCalCore/ICalFormat>
#include <KCalCore/MemoryCalendar>
#include <KCalUtils/Stringify>

#include <KMessageBox>
#include <KSharedConfig>

#include <QCloseEvent>
#include <QDir>
#include <QIcon>
#include <QStandardPaths>
#include <QTimeZone>

using namespace IncidenceEditorNG;

namespace IncidenceEditorNG {
enum Tabs {
    GeneralTab = 0,
    AttendeesTab,
    ResourcesTab,
    AlarmsTab,
    RecurrenceTab,
    AttachmentsTab
};

class IncidenceDialogPrivate : public ItemEditorUi
{
    IncidenceDialog *q_ptr;
    Q_DECLARE_PUBLIC(IncidenceDialog)

public:
    Ui::EventOrTodoDesktop *mUi = nullptr;
    Akonadi::CollectionComboBox *mCalSelector = nullptr;
    bool mCloseOnSave = false;

EditorItemManager *mItemManager = nullptr;
    CombinedIncidenceEditor *mEditor = nullptr;
    IncidenceDateTime *mIeDateTime = nullptr;
    IncidenceAttendee *mIeAttendee = nullptr;
    IncidenceRecurrence *mIeRecurrence = nullptr;
    IncidenceResource *mIeResource = nullptr;
    bool mInitiallyDirty = false;
    Akonadi::Item mItem;
    QString typeToString(const int type) const;

public:
    IncidenceDialogPrivate(Akonadi::IncidenceChanger *changer, IncidenceDialog *qq);
    ~IncidenceDialogPrivate();

/// General methods
    void handleAlarmCountChange(int newCount);
    void handleRecurrenceChange(IncidenceEditorNG::RecurrenceType type);
    void loadTemplate(const QString &templateName);
    void manageTemplates();
    void saveTemplate(const QString &templateName);
    void storeTemplatesInConfig(const QStringList &newTemplates);
    void updateAttachmentCount(int newCount);
    void updateAttendeeCount(int newCount);
    void updateResourceCount(int newCount);
    void updateButtonStatus(bool isDirty);
    void showMessage(const QString &text, KMessageWidget::MessageType type);
    void slotInvalidCollection();

/// ItemEditorUi methods
    bool containsPayloadIdentifiers(const QSet<QByteArray> &partIdentifiers) const override;
    void handleItemSaveFinish(EditorItemManager::SaveAction);
    void handleItemSaveFail(EditorItemManager::SaveAction, const QString &errorMessage);
    bool hasSupportedPayload(const Akonadi::Item &item) const override;
    bool isDirty() const override;
    bool isValid() const override;
    void load(const Akonadi::Item &item) override;
    Akonadi::Item save(const Akonadi::Item &item) override;
    Akonadi::Collection selectedCollection() const override;

void reject(RejectReason reason, const QString &errorMessage = QString()) override;
};
}

IncidenceDialogPrivate::IncidenceDialogPrivate(Akonadi::IncidenceChanger *changer,
                                               IncidenceDialog *qq)
    : q_ptr(qq)
    , mUi(new Ui::EventOrTodoDesktop)
    , mCalSelector(new Akonadi::CollectionComboBox)
    , mCloseOnSave(false)
    , mItemManager(new EditorItemManager(this, changer))
    , mEditor(new CombinedIncidenceEditor(qq))
    , mInitiallyDirty(false)
{
    Q_Q(IncidenceDialog);
    mUi->setupUi(q);
    QGridLayout *layout = new QGridLayout(mUi->mCalSelectorPlaceHolder);
    layout->setSpacing(0);
    layout->setMargin(0);
    layout->addWidget(mCalSelector);
    mCalSelector->setAccessRightsFilter(Akonadi::Collection::CanCreateItem);
    mUi->label->setBuddy(mCalSelector);
    q->connect(mCalSelector, &Akonadi::CollectionComboBox::currentChanged, q,
               &IncidenceDialog::handleSelectedCollectionChange);

// Now instantiate the logic of the dialog. These editors update the ui, validate
    // fields and load/store incidences in the ui.
    IncidenceWhatWhere *ieGeneral = new IncidenceWhatWhere(mUi);
    mEditor->combine(ieGeneral);

IncidenceCategories *ieCategories = new IncidenceCategories(mUi);
    mEditor->combine(ieCategories);

mIeDateTime = new IncidenceDateTime(mUi);
    mEditor->combine(mIeDateTime);

IncidenceCompletionPriority *ieCompletionPriority = new IncidenceCompletionPriority(mUi);
    mEditor->combine(ieCompletionPriority);

IncidenceDescription *ieDescription = new IncidenceDescription(mUi);
    mEditor->combine(ieDescription);

IncidenceAlarm *ieAlarm = new IncidenceAlarm(mIeDateTime, mUi);
    mEditor->combine(ieAlarm);

IncidenceAttachment *ieAttachments = new IncidenceAttachment(mUi);
    mEditor->combine(ieAttachments);

mIeRecurrence = new IncidenceRecurrence(mIeDateTime, mUi);
    mEditor->combine(mIeRecurrence);

IncidenceSecrecy *ieSecrecy = new IncidenceSecrecy(mUi);
    mEditor->combine(ieSecrecy);

mIeAttendee = new IncidenceAttendee(qq, mIeDateTime, mUi);
    mIeAttendee->setParent(qq);
    mEditor->combine(mIeAttendee);

mIeResource = new IncidenceResource(mIeAttendee, mIeDateTime, mUi);
    mEditor->combine(mIeResource);

q->connect(mEditor, SIGNAL(showMessage(QString,KMessageWidget::MessageType)),
               SLOT(showMessage(QString,KMessageWidget::MessageType)));
    q->connect(mEditor, SIGNAL(dirtyStatusChanged(bool)),
               SLOT(updateButtonStatus(bool)));
    q->connect(mItemManager,
               SIGNAL(itemSaveFinished(IncidenceEditorNG::EditorItemManager::SaveAction)),
               SLOT(handleItemSaveFinish(IncidenceEditorNG::EditorItemManager::SaveAction)));
    q->connect(mItemManager,
               SIGNAL(itemSaveFailed(IncidenceEditorNG::EditorItemManager::SaveAction,QString)),
               SLOT(handleItemSaveFail(IncidenceEditorNG::EditorItemManager::SaveAction,QString)));
    q->connect(ieAlarm, SIGNAL(alarmCountChanged(int)),
               SLOT(handleAlarmCountChange(int)));
    q->connect(mIeRecurrence, SIGNAL(recurrenceChanged(IncidenceEditorNG::RecurrenceType)),
               SLOT(handleRecurrenceChange(IncidenceEditorNG::RecurrenceType)));
    q->connect(ieAttachments, SIGNAL(attachmentCountChanged(int)),
               SLOT(updateAttachmentCount(int)));
    q->connect(mIeAttendee, SIGNAL(attendeeCountChanged(int)),
               SLOT(updateAttendeeCount(int)));
    q->connect(mIeResource, SIGNAL(resourceCountChanged(int)),
               SLOT(updateResourceCount(int)));
}

IncidenceDialogPrivate::~IncidenceDialogPrivate()
{
    delete mItemManager;
    delete mEditor;
    delete mUi;
}

void IncidenceDialogPrivate::slotInvalidCollection()
{
    showMessage(i18n("Select a valid collection first."), KMessageWidget::Warning);
}

void IncidenceDialogPrivate::showMessage(const QString &text, KMessageWidget::MessageType type)
{
    mUi->mMessageWidget->setText(text);
    mUi->mMessageWidget->setMessageType(type);
    mUi->mMessageWidget->show();
}

void IncidenceDialogPrivate::handleAlarmCountChange(int newCount)
{
    QString tabText;
    if (newCount > 0) {
        tabText
            = i18nc("@title:tab Tab to configure the reminders of an event or todo",
                    "Reminder (%1)", newCount);
    } else {
        tabText
            = i18nc("@title:tab Tab to configure the reminders of an event or todo",
                    "Reminder");
    }

mUi->mTabWidget->setTabText(AlarmsTab, tabText);
}

void IncidenceDialogPrivate::handleRecurrenceChange(IncidenceEditorNG::RecurrenceType type)
{
    QString tabText
        = i18nc("@title:tab Tab to configure the recurrence of an event or todo",
                "Rec&urrence");

// Keep this numbers in sync with the items in mUi->mRecurrenceTypeCombo. I
    // tried adding an enum to IncidenceRecurrence but for whatever reason I could
    // Qt not play nice with namespaced enums in signal/slot connections.
    // Anyways, I don't expect these values to change.
    switch (type) {
    case RecurrenceTypeNone:
        break;
    case RecurrenceTypeDaily:
        tabText += i18nc("@title:tab Daily recurring event, capital first letter only", " (D)");
        break;
    case RecurrenceTypeWeekly:
        tabText += i18nc("@title:tab Weekly recurring event, capital first letter only", " (W)");
        break;
    case RecurrenceTypeMonthly:
        tabText += i18nc("@title:tab Monthly recurring event, capital first letter only", " (M)");
        break;
    case RecurrenceTypeYearly:
        tabText += i18nc("@title:tab Yearly recurring event, capital first letter only", " (Y)");
        break;
    case RecurrenceTypeException:
        tabText += i18nc("@title:tab Exception to a recurring event, capital first letter only",
                         " (E)");
        break;
    default:
        Q_ASSERT_X(false, "handleRecurrenceChange", "Fix your program");
    }

mUi->mTabWidget->setTabText(RecurrenceTab, tabText);
}

QString IncidenceDialogPrivate::typeToString(const int type) const
{
    // Do not translate.
    switch (type) {
    case KCalCore::Incidence::TypeEvent:
        return QStringLiteral("Event");
    case KCalCore::Incidence::TypeTodo:
        return QStringLiteral("Todo");
    case KCalCore::Incidence::TypeJournal:
        return QStringLiteral("Journal");
    default:
        return QStringLiteral("Unknown");
    }
}

void IncidenceDialogPrivate::loadTemplate(const QString &templateName)
{
    Q_Q(IncidenceDialog);

KCalCore::MemoryCalendar::Ptr cal(new KCalCore::MemoryCalendar(QTimeZone::systemTimeZone()));

const QString fileName = QStandardPaths::locate(
        QStandardPaths::GenericDataLocation,
        QStringLiteral("/korganizer/templates/")
        +typeToString(mEditor->type()) + QLatin1Char('/')
        +templateName);

if (fileName.isEmpty()) {
        KMessageBox::error(
            q,
            i18nc("@info", "Unable to find template '%1'.", templateName));
        return;
    }

KCalCore::ICalFormat format;
    if (!format.load(cal, fileName)) {
        KMessageBox::error(
            q,
            i18nc("@info", "Error loading template file '%1'.", fileName));
        return;
    }

KCalCore::Incidence::List incidences = cal->incidences();
    if (incidences.isEmpty()) {
        KMessageBox::error(
            q,
            i18nc("@info", "Template does not contain a valid incidence."));
        return;
    }

mIeDateTime->setActiveDate(QDate());
    KCalCore::Incidence::Ptr newInc = KCalCore::Incidence::Ptr(incidences.first()->clone());
    newInc->setUid(KCalCore::CalFormat::createUniqueId());

// We add a custom property so that some fields aren't loaded, dates for example
    newInc->setCustomProperty(QByteArray("kdepim"), "isTemplate", QStringLiteral("true"));
    mEditor->load(newInc);
    newInc->removeCustomProperty(QByteArray(), "isTemplate");
}

void IncidenceDialogPrivate::manageTemplates()
{
    Q_Q(IncidenceDialog);

QStringList &templates
        = IncidenceEditorNG::EditorConfig::instance()->templates(mEditor->type());

QPointer<IncidenceEditorNG::TemplateManagementDialog> dialog(
        new IncidenceEditorNG::TemplateManagementDialog(
            q, templates, KCalUtils::Stringify::incidenceType(mEditor->type())));

q->connect(dialog, SIGNAL(loadTemplate(QString)),
               SLOT(loadTemplate(QString)));
    q->connect(dialog, SIGNAL(templatesChanged(QStringList)),
               SLOT(storeTemplatesInConfig(QStringList)));
    q->connect(dialog, SIGNAL(saveTemplate(QString)),
               SLOT(saveTemplate(QString)));
    dialog->exec();
    delete dialog;
}

void IncidenceDialogPrivate::saveTemplate(const QString &templateName)
{
    Q_ASSERT(!templateName.isEmpty());

KCalCore::MemoryCalendar::Ptr cal(new KCalCore::MemoryCalendar(QTimeZone::systemTimeZone()));

switch (mEditor->type()) {
    case KCalCore::Incidence::TypeEvent:
    {
        KCalCore::Event::Ptr event(new KCalCore::Event());
        mEditor->save(event);
        cal->addEvent(KCalCore::Event::Ptr(event->clone()));
        break;
    }
    case KCalCore::Incidence::TypeTodo:
    {
        KCalCore::Todo::Ptr todo(new KCalCore::Todo);
        mEditor->save(todo);
        cal->addTodo(KCalCore::Todo::Ptr(todo->clone()));
        break;
    }
    case KCalCore::Incidence::TypeJournal:
    {
        KCalCore::Journal::Ptr journal(new KCalCore::Journal);
        mEditor->save(journal);
        cal->addJournal(KCalCore::Journal::Ptr(journal->clone()));
        break;
    }
    default:
        Q_ASSERT_X(false, "saveTemplate", "Fix your program");
    }

QString fileName = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)
                       +QStringLiteral("/korganizer/templates/") + typeToString(mEditor->type())
                       + QLatin1Char('/');
    QDir().mkpath(fileName);
    fileName += templateName;

KCalCore::ICalFormat format;
    format.save(cal, fileName);
}

void IncidenceDialogPrivate::storeTemplatesInConfig(const QStringList &templateNames)
{
    // I find this somewhat broken. templates() returns a reference, maybe it should
    // be changed by adding a setTemplates method.
    const QStringList origTemplates
        = IncidenceEditorNG::EditorConfig::instance()->templates(mEditor->type());
    const QString defaultPath
        = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)
          +QStringLiteral("korganizer/templates/")
          +typeToString(mEditor->type()) + QLatin1Char('/');
    QDir().mkpath(defaultPath);
    for (const QString &tmpl : origTemplates) {
        if (!templateNames.contains(tmpl)) {
            const QString fileName = defaultPath + tmpl;
            QFile file(fileName);
            if (file.exists()) {
                file.remove();
            }
        }
    }

IncidenceEditorNG::EditorConfig::instance()->templates(mEditor->type()) = templateNames;
    IncidenceEditorNG::EditorConfig::instance()->config()->save();
}

void IncidenceDialogPrivate::updateAttachmentCount(int newCount)
{
    if (newCount > 0) {
        mUi->mTabWidget->setTabText(
            AttachmentsTab,
            i18nc("@title:tab Tab to modify attachments of an event or todo",
                  "Attac&hments (%1)", newCount));
    } else {
        mUi->mTabWidget->setTabText(
            AttachmentsTab,
            i18nc("@title:tab Tab to modify attachments of an event or todo",
                  "Attac&hments"));
    }
}

void IncidenceDialogPrivate::updateAttendeeCount(int newCount)
{
    if (newCount > 0) {
        mUi->mTabWidget->setTabText(
            AttendeesTab,
            i18nc("@title:tab Tab to modify attendees of an event or todo",
                  "&Attendees (%1)", newCount));
    } else {
        mUi->mTabWidget->setTabText(
            AttendeesTab,
            i18nc("@title:tab Tab to modify attendees of an event or todo",
                  "&Attendees"));
    }
}

void IncidenceDialogPrivate::updateResourceCount(int newCount)
{
    if (newCount > 0) {
        mUi->mTabWidget->setTabText(
            ResourcesTab,
            i18nc("@title:tab Tab to modify attendees of an event or todo",
                  "&Resources (%1)", newCount));
    } else {
        mUi->mTabWidget->setTabText(
            ResourcesTab,
            i18nc("@title:tab Tab to modify attendees of an event or todo",
                  "&Resources"));
    }
}

void IncidenceDialogPrivate::updateButtonStatus(bool isDirty)
{
    mUi->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(isDirty || mInitiallyDirty);
}

bool IncidenceDialogPrivate::containsPayloadIdentifiers(
    const QSet<QByteArray> &partIdentifiers) const
{
    return partIdentifiers.contains(QByteArray("PLD:RFC822"));
}

void IncidenceDialogPrivate::handleItemSaveFail(EditorItemManager::SaveAction,
                                                const QString &errorMessage)
{
    Q_Q(IncidenceDialog);

bool retry = false;

if (!errorMessage.isEmpty()) {
        const QString message = i18nc("@info",
                                      "Unable to store the incidence in the calendar. Try again?\n\n "
                                      "Reason: %1",
                                      errorMessage);
        retry = (KMessageBox::warningYesNo(q, message) == KMessageBox::Yes);
    }

if (retry) {
        mItemManager->save();
    } else {
        updateButtonStatus(isDirty());
        mUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
        mUi->buttonBox->button(QDialogButtonBox::Cancel)->setEnabled(true);
    }
}

void IncidenceDialogPrivate::handleItemSaveFinish(EditorItemManager::SaveAction saveAction)
{
    Q_Q(IncidenceDialog);

if (mCloseOnSave) {
        q->accept();
    } else {
        const Akonadi::Item item = mItemManager->item();
        Q_ASSERT(item.isValid());
        Q_ASSERT(item.hasPayload());
        Q_ASSERT(item.hasPayload<KCalCore::Incidence::Ptr>());
        // Now the item is succesfull saved, reload it in the editor in order to
        // reset the dirty status of the editor.
        mEditor->load(item.payload<KCalCore::Incidence::Ptr>());
        mEditor->load(item);

// Set the buttons to a reasonable state as well (ok and apply should be
        // disabled at this point).
        mUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
        mUi->buttonBox->button(QDialogButtonBox::Cancel)->setEnabled(true);
        mUi->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(isDirty());
    }

if (saveAction == EditorItemManager::Create) {
        Q_EMIT q->incidenceCreated(mItemManager->item());
    }
}

bool IncidenceDialogPrivate::hasSupportedPayload(const Akonadi::Item &item) const
{
    return CalendarSupport::incidence(item);
}

bool IncidenceDialogPrivate::isDirty() const
{
    if (mItem.isValid()) {
        return mEditor->isDirty()
               || mCalSelector->currentCollection().id() != mItem.storageCollectionId();
    } else {
        return mEditor->isDirty();
    }
}

bool IncidenceDialogPrivate::isValid() const
{
    Q_Q(const IncidenceDialog);
    if (mEditor->isValid()) {
        // Check if there's a selected collection.
        if (mCalSelector->currentCollection().isValid()) {
            return true;
        } else {
            qCWarning(INCIDENCEEDITOR_LOG) << "Select a collection first";
            Q_EMIT q->invalidCollection();
        }
    }

return false;
}

void IncidenceDialogPrivate::load(const Akonadi::Item &item)
{
    Q_Q(IncidenceDialog);

Q_ASSERT(hasSupportedPayload(item));

if (CalendarSupport::hasJournal(item)) {
        //mUi->mTabWidget->removeTab(5);
        mUi->mTabWidget->removeTab(AttachmentsTab);
        mUi->mTabWidget->removeTab(RecurrenceTab);
        mUi->mTabWidget->removeTab(AlarmsTab);
        mUi->mTabWidget->removeTab(AttendeesTab);
        mUi->mTabWidget->removeTab(ResourcesTab);
    }

mEditor->load(CalendarSupport::incidence(item));
    mEditor->load(item);

const KCalCore::Incidence::Ptr incidence = CalendarSupport::incidence(item);
    const QStringList allEmails = IncidenceEditorNG::EditorConfig::instance()->allEmails();
    KCalCore::Attendee::Ptr me = incidence->attendeeByMails(allEmails);

if (incidence->attendeeCount() > 1     // >1 because you won't drink alone
        && me && (me->status() == KCalCore::Attendee::NeedsAction
                  || me->status() == KCalCore::Attendee::Tentative
                  || me->status() == KCalCore::Attendee::InProcess)) {
        // Show the invitation bar: "You are invited [accept] [decline]"
        mUi->mInvitationBar->show();
    } else {
        mUi->mInvitationBar->hide();
    }

qCDebug(INCIDENCEEDITOR_LOG) << "Loading item " << item.id() << "; parent "
                                 << item.parentCollection().id()
                                 << "; storage " << item.storageCollectionId();

if (item.storageCollectionId() > -1) {
        mCalSelector->setDefaultCollection(Akonadi::Collection(item.storageCollectionId()));
    }

if (!mCalSelector->mimeTypeFilter().contains(QStringLiteral("text/calendar"))
        || !mCalSelector->mimeTypeFilter().contains(incidence->mimeType())) {
        mCalSelector->setMimeTypeFilter(QStringList() << incidence->mimeType()
                                                      << QStringLiteral("text/calendar"));
    }

if (mEditor->type() == KCalCore::Incidence::TypeTodo) {
        q->setWindowIcon(QIcon::fromTheme(QStringLiteral("view-calendar-tasks")));
    } else if (mEditor->type() == KCalCore::Incidence::TypeEvent) {
        q->setWindowIcon(QIcon::fromTheme(QStringLiteral("view-calendar-day")));
    } else if (mEditor->type() == KCalCore::Incidence::TypeJournal) {
        q->setWindowIcon(QIcon::fromTheme(QStringLiteral("view-pim-journal")));
    }

// Initialize tab's titles
    updateAttachmentCount(incidence->attachments().size());
    updateResourceCount(mIeResource->resourceCount());
    updateAttendeeCount(mIeAttendee->attendeeCount());
    handleRecurrenceChange(mIeRecurrence->currentRecurrenceType());
    handleAlarmCountChange(incidence->alarms().count());

mItem = item;

q->show();
}

Akonadi::Item IncidenceDialogPrivate::save(const Akonadi::Item &item)
{
    Q_ASSERT(mEditor->incidence<KCalCore::Incidence>());

KCalCore::Incidence::Ptr incidenceInEditor = mEditor->incidence<KCalCore::Incidence>();
    KCalCore::Incidence::Ptr newIncidence(incidenceInEditor->clone());

Akonadi::Item result = item;
    result.setMimeType(newIncidence->mimeType());

// There's no editor that has the relatedTo property. We must set it here, by hand.
    // Otherwise it gets lost.
    // FIXME: Why don't we clone() incidenceInEditor then pass the clone to save(),
    // I wonder if we're not leaking other properties.
    newIncidence->setRelatedTo(incidenceInEditor->relatedTo());

mEditor->save(newIncidence);
    mEditor->save(result);

// TODO: Remove this once we support moving of events/todo's
    mCalSelector->setEnabled(false);

// Make sure that we don't loose uid for existing incidence
    newIncidence->setUid(mEditor->incidence<KCalCore::Incidence>()->uid());

// Mark the incidence as changed
    if (mItem.isValid()) {
        newIncidence->setRevision(newIncidence->revision() + 1);
    }

result.setPayload<KCalCore::Incidence::Ptr>(newIncidence);
    return result;
}

Akonadi::Collection IncidenceDialogPrivate::selectedCollection() const
{
    return mCalSelector->currentCollection();
}

void IncidenceDialogPrivate::reject(RejectReason reason, const QString &errorMessage)
{
    Q_UNUSED(reason);

Q_Q(IncidenceDialog);
    qCCritical(INCIDENCEEDITOR_LOG) << "Rejecting:" << errorMessage;
    q->deleteLater();
}

/// IncidenceDialog

IncidenceDialog::IncidenceDialog(Akonadi::IncidenceChanger *changer, QWidget *parent,
                                 Qt::WindowFlags flags)
    : QDialog(parent, flags)
    , d_ptr(new IncidenceDialogPrivate(changer, this))
{
    Q_D(IncidenceDialog);
    setAttribute(Qt::WA_DeleteOnClose);

d->mUi->mTabWidget->setCurrentIndex(0);
    d->mUi->mSummaryEdit->setFocus();

d->mUi->buttonBox->button(QDialogButtonBox::Apply)->setToolTip(i18nc("@info:tooltip",
                                                                         "Save current changes"));
    d->mUi->buttonBox->button(QDialogButtonBox::Ok)->setToolTip(i18nc("@action:button",
                                                                      "Save changes and close dialog"));
    d->mUi->buttonBox->button(QDialogButtonBox::Cancel)->setToolTip(i18nc("@action:button",
                                                                          "Discard changes and close dialog"));
    d->mUi->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);

auto defaultButton = d->mUi->buttonBox->button(QDialogButtonBox::RestoreDefaults);
    defaultButton->setText(i18nc("@action:button", "&Templates..."));
    defaultButton->setIcon(QIcon::fromTheme(QStringLiteral("project-development-new-template")));
    defaultButton->setToolTip(i18nc("@info:tooltip", "Manage templates for this item"));
    defaultButton->setWhatsThis(
        i18nc("@info:whatsthis",
              "Push this button to show a dialog that helps "
              "you manage a set of templates. Templates "
              "can make creating new items easier and faster "
              "by putting your favorite default values into "
              "the editor automatically."));

connect(d->mUi->buttonBox, &QDialogButtonBox::clicked, this,
            &IncidenceDialog::slotButtonClicked);

setModal(false);

connect(d->mUi->mAcceptInvitationButton, &QAbstractButton::clicked,
            d->mIeAttendee, &IncidenceAttendee::acceptForMe);
    connect(d->mUi->mAcceptInvitationButton, &QAbstractButton::clicked,
            d->mUi->mInvitationBar, &QWidget::hide);
    connect(d->mUi->mDeclineInvitationButton, &QAbstractButton::clicked,
            d->mIeAttendee, &IncidenceAttendee::declineForMe);
    connect(d->mUi->mDeclineInvitationButton, &QAbstractButton::clicked,
            d->mUi->mInvitationBar, &QWidget::hide);
    connect(this, SIGNAL(invalidCollection()),
            this, SLOT(slotInvalidCollection()));
    readConfig();
}

IncidenceDialog::~IncidenceDialog()
{
    writeConfig();
    delete d_ptr;
}

void IncidenceDialog::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "IncidenceDialog");
    group.writeEntry("Size", size());

const Akonadi::Collection col = d_ptr->mCalSelector->currentCollection();
    // col might not be valid if the collection wasn't found yet (the combo is async), skip saving in that case
    if (col.isValid()
        && col.id() != IncidenceEditorNG::IncidenceEditorSettings::self()->lastSelectedFolder()) {
        IncidenceEditorNG::IncidenceEditorSettings::self()->setLastSelectedFolder(col.id());
        IncidenceEditorNG::IncidenceEditorSettings::self()->save();
    }
}

void IncidenceDialog::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "IncidenceDialog");
    const QSize size = group.readEntry("Size", QSize());
    if (size.isValid()) {
        resize(size);
    } else {
        resize(QSize(500, 500).expandedTo(minimumSizeHint()));
    }
}

void IncidenceDialog::load(const Akonadi::Item &item, const QDate &activeDate)
{
    Q_D(IncidenceDialog);
    d->mIeDateTime->setActiveDate(activeDate);
    if (item.isValid()) {   // We're editing
        d->mItemManager->load(item);
        // TODO: Remove this once we support moving of events/todo's
        d->mCalSelector->setEnabled(false);
    } else { // We're creating
        Q_ASSERT(d->hasSupportedPayload(item));
        d->load(item);
        show();
    }
}

void IncidenceDialog::selectCollection(const Akonadi::Collection &collection)
{
    Q_D(IncidenceDialog);
    if (collection.isValid()) {
        d->mCalSelector->setDefaultCollection(collection);
    } else {
        d->mCalSelector->setCurrentIndex(0);
    }
}

void IncidenceDialog::setIsCounterProposal(bool isCounterProposal)
{
    Q_D(IncidenceDialog);
    d->mItemManager->setIsCounterProposal(isCounterProposal);
}

QObject *IncidenceDialog::typeAheadReceiver() const
{
    Q_D(const IncidenceDialog);
    return d->mUi->mSummaryEdit;
}

void IncidenceDialog::slotButtonClicked(QAbstractButton *button)
{
    Q_D(IncidenceDialog);

if (d->mUi->buttonBox->button(QDialogButtonBox::Ok) == button) {
        if (d->isDirty() || d->mInitiallyDirty) {
            d->mUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
            d->mUi->buttonBox->button(QDialogButtonBox::Cancel)->setEnabled(false);
            d->mUi->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
            d->mCloseOnSave = true;
            d->mInitiallyDirty = false;
            d->mItemManager->save();
        } else {
            close();
        }
    } else if (d->mUi->buttonBox->button(QDialogButtonBox::Apply) == button) {
        d->mUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
        d->mUi->buttonBox->button(QDialogButtonBox::Cancel)->setEnabled(false);
        d->mUi->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);

d->mCloseOnSave = false;
        d->mInitiallyDirty = false;
        d->mItemManager->save();
    } else if (d->mUi->buttonBox->button(QDialogButtonBox::Cancel) == button) {
        if (d->isDirty()
            && KMessageBox::questionYesNo(
                this,
                i18nc("@info", "Do you really want to cancel?"),
                i18nc("@title:window", "KOrganizer Confirmation")) == KMessageBox::Yes) {
            QDialog::reject(); // Discard current changes
        } else if (!d->isDirty()) {
            QDialog::reject(); // No pending changes, just close the dialog.
        } // else { // the user wasn't finished editting after all }
    } else if (d->mUi->buttonBox->button(QDialogButtonBox::RestoreDefaults)) {
        d->manageTemplates();
    } else {
        Q_ASSERT(false);   // Shouldn't happen
    }
}

void IncidenceDialog::closeEvent(QCloseEvent *event)
{
    Q_D(IncidenceDialog);
    if (d->isDirty()
        && KMessageBox::questionYesNo(
            this,
            i18nc("@info", "Do you really want to cancel?"),
            i18nc("@title:window", "KOrganizer Confirmation")) == KMessageBox::Yes) {
        QDialog::reject(); // Discard current changes
        QDialog::closeEvent(event);
    } else if (!d->isDirty()) {
        QDialog::reject(); // No pending changes, just close the dialog.
        QDialog::closeEvent(event);
    } else {
        event->ignore();
    }
}

void IncidenceDialog::setInitiallyDirty(bool initiallyDirty)
{
    Q_D(IncidenceDialog);
    d->mInitiallyDirty = initiallyDirty;
}

Akonadi::Item IncidenceDialog::item() const
{
    Q_D(const IncidenceDialog);
    return d->mItemManager->item();
}

void IncidenceDialog::handleSelectedCollectionChange(const Akonadi::Collection &collection)
{
    Q_D(IncidenceDialog);
    if (d->mItem.parentCollection().isValid()) {
        d->mUi->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(
            collection.id() != d->mItem.parentCollection().id());
    }
}

#include "moc_incidencedialog.cpp"
07070111A0195B000081A40000000200000002000000015AA55A8600001197000000FD0000001000000000000000000000004900000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedialog.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 INCIDENCEEDITOR_INCIDENCEDIALOG_H
#define INCIDENCEEDITOR_INCIDENCEDIALOG_H

#include "incidenceeditor_export.h"
#include "editoritemmanager.h"

#include <QDate>
#include <QDialog>

class QAbstractButton;

namespace Akonadi {
class IncidenceChanger;
}

namespace IncidenceEditorNG {
class IncidenceDialogPrivate;

class INCIDENCEEDITOR_EXPORT IncidenceDialog : public QDialog
{
    Q_OBJECT
public:
    explicit IncidenceDialog(Akonadi::IncidenceChanger *changer = nullptr,
                             QWidget *parent = nullptr, Qt::WindowFlags flags = 0);
    ~IncidenceDialog();

/**
     * Loads the @param item into the dialog.
     *
     * To create a new Incidence pass an invalid item with either an
     * KCalCore::Event:Ptr or a KCalCore::Todo:Ptr set as payload. Note: When the
     * item is invalid, i.e. it has an invalid id, a valid payload <em>must</em>
     * be set.
     *
     * When the item has is valid this method will fetch the payload when this is
     * not already set.
     */
    virtual void load(const Akonadi::Item &item, const QDate &activeDate = QDate());

/**
     * Sets the Collection combobox to @param collection.
     */
    virtual void selectCollection(const Akonadi::Collection &collection);

virtual void setIsCounterProposal(bool isCounterProposal);

/**
      Returns the object that will receive all key events.
    */
    QObject *typeAheadReceiver() const;

/**
       By default, if you load an incidence into the editor ( load(item) ), then press [OK]
       without changing anything, the dialog is dismissed, and the incidence isn't saved
       to akonadi.

Call this method with @p initiallyDirty = true if you want the incidence to be saved,
       It's useful if you're creating a dialog with an already crafted content, like in kmail's
       "Create Todo/Reminder Feature".
    */
    void setInitiallyDirty(bool initiallyDirty);

Akonadi::Item item() const;

Q_SIGNALS:
    /**
     * This signal is emitted when an incidence is created.
     * @param collection The collection where it was created.
     */
    void incidenceCreated(const Akonadi::Item &);
    void invalidCollection() const;
protected:
    void closeEvent(QCloseEvent *event) override;

protected Q_SLOTS:
    void slotButtonClicked(QAbstractButton *button);
    void handleSelectedCollectionChange(const Akonadi::Collection &collection);

private:
    IncidenceDialogPrivate *const d_ptr;
    Q_DECLARE_PRIVATE(IncidenceDialog)
    Q_DISABLE_COPY(IncidenceDialog)

void writeConfig();
    void readConfig();

Q_PRIVATE_SLOT(d_ptr, void handleAlarmCountChange(int))
    Q_PRIVATE_SLOT(d_ptr, void handleItemSaveFinish(
                       IncidenceEditorNG::EditorItemManager::SaveAction))
    Q_PRIVATE_SLOT(d_ptr,
                   void handleItemSaveFail(IncidenceEditorNG::EditorItemManager::SaveAction,
                                           QString))
    Q_PRIVATE_SLOT(d_ptr, void handleRecurrenceChange(IncidenceEditorNG::RecurrenceType))
    Q_PRIVATE_SLOT(d_ptr, void loadTemplate(QString))
    Q_PRIVATE_SLOT(d_ptr, void saveTemplate(QString))
    Q_PRIVATE_SLOT(d_ptr, void storeTemplatesInConfig(QStringList))
    Q_PRIVATE_SLOT(d_ptr, void updateAttachmentCount(int))
    Q_PRIVATE_SLOT(d_ptr, void updateAttendeeCount(int))
    Q_PRIVATE_SLOT(d_ptr, void updateResourceCount(int))
    Q_PRIVATE_SLOT(d_ptr, void updateButtonStatus(bool))
    Q_PRIVATE_SLOT(d_ptr, void showMessage(QString, KMessageWidget::MessageType))
    Q_PRIVATE_SLOT(d_ptr, void slotInvalidCollection())
};
}

#endif
07070111A0195C000081A40000000200000002000000015AA55A86000015A8000000FD0000001000000000000000000000005200000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedialogfactory.cpp/*
  Copyright (C) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidencedialogfactory.h"
#include "incidencedialog.h"
#include "incidencedefaults.h"

#include <KCalCore/Event>
#include <KCalCore/Todo>
#include <Item>
#include <Akonadi/Calendar/IncidenceChanger>

using namespace IncidenceEditorNG;
using namespace KCalCore;

IncidenceDialog *IncidenceDialogFactory::create(bool needsSaving,
                                                KCalCore::IncidenceBase::IncidenceType type,
                                                Akonadi::IncidenceChanger *changer, QWidget *parent,
                                                Qt::WindowFlags flags)
{
    switch (type) {
    case KCalCore::IncidenceBase::TypeEvent: // Fall through
    case KCalCore::IncidenceBase::TypeTodo:
    case KCalCore::IncidenceBase::TypeJournal:
    {
        IncidenceDialog *dialog = new IncidenceDialog(changer, parent, flags);

// needs to be save to akonadi?, apply button should be turned on if so.
        dialog->setInitiallyDirty(needsSaving /* mInitiallyDirty */);

return dialog;
    }
    default:
        return nullptr;
    }
}

IncidenceDialog *IncidenceDialogFactory::createTodoEditor(const QString &summary,
                                                          const QString &description,
                                                          const QStringList &attachments,
                                                          const QStringList &attendees,
                                                          const QStringList &attachmentMimetypes,
                                                          const QStringList &attachmentLabels,
                                                          bool inlineAttachment,
                                                          const Akonadi::Collection &defaultCollection, bool cleanupAttachmentTempFiles, QWidget *parent,
                                                          Qt::WindowFlags flags)
{
    IncidenceDefaults defaults
        = IncidenceDefaults::minimalIncidenceDefaults(cleanupAttachmentTempFiles);

// if attach or attendee list is empty, these methods don't do anything, so
    // it's safe to call them in every case
    defaults.setAttachments(attachments, attachmentMimetypes, attachmentLabels, inlineAttachment);
    defaults.setAttendees(attendees);

Todo::Ptr todo(new Todo);
    defaults.setDefaults(todo);

todo->setSummary(summary);
    todo->setDescription(description);

Akonadi::Item item;
    item.setPayload(todo);

IncidenceDialog *dialog = create(true,  /* no need for, we're not editing an existing to-do */
                                     KCalCore::Incidence::TypeTodo,
                                     nullptr,
                                     parent, flags);
    dialog->selectCollection(defaultCollection);
    dialog->load(item);
    return dialog;
}

IncidenceDialog *IncidenceDialogFactory::createEventEditor(const QString &summary,
                                                           const QString &description,
                                                           const QStringList &attachments,
                                                           const QStringList &attendees,
                                                           const QStringList &attachmentMimetypes,
                                                           const QStringList &attachmentLabels,
                                                           bool inlineAttachment,
                                                           const Akonadi::Collection &defaultCollection, bool cleanupAttachmentTempFiles, QWidget *parent,
                                                           Qt::WindowFlags flags)
{
    IncidenceDefaults defaults
        = IncidenceDefaults::minimalIncidenceDefaults(cleanupAttachmentTempFiles);

Event::Ptr event(new Event);
    defaults.setDefaults(event);

event->setSummary(summary);
    event->setDescription(description);

Akonadi::Item item;
    item.setPayload(event);

IncidenceDialog *dialog
        = create(false, // not needed for saving, as we're not editing an existing incidence
                 KCalCore::Incidence::TypeEvent,
                 nullptr,
                 parent, flags);

dialog->selectCollection(defaultCollection);
    dialog->load(item);

return dialog;
}
07070111A0195D000081A40000000200000002000000015AA55A8600000BE9000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencedialogfactory.h/*
  Copyright (C) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 INCIDENCEEDITOR_INCIDENCEDIALOGFACTORY_H
#define INCIDENCEEDITOR_INCIDENCEDIALOGFACTORY_H

#include "incidenceeditor_export.h"

#include <KCalCore/IncidenceBase>
#include <Collection>

namespace Akonadi {
class IncidenceChanger;
}

namespace IncidenceEditorNG {
class IncidenceDialog;

namespace IncidenceDialogFactory {
/**
 * Creates a new IncidenceDialog for given type. Returns 0 for unsupported types.
 *
 * @param needsSaving If true, the editor will be initialy dirty, and needs saving.
 *                    Apply button will be turned on. This is used for example when
 *                    we fill the editor with data that's not yet in akonadi, like
 *                    the "Create To-do/Reminder" in KMail.
 * @param type   The Incidence type for which to create a dialog.
 * @param parent The parent widget of the dialog
 * @param flags  The window flags for the dialog.
 *
 * TODO: Implement support for Journals.
 * NOTE: There is no editor for Incidence::TypeFreeBusy
 */
INCIDENCEEDITOR_EXPORT IncidenceDialog *create(
    bool needsSaving, KCalCore::IncidenceBase::IncidenceType type,
    Akonadi::IncidenceChanger *changer, QWidget *parent = nullptr, Qt::WindowFlags flags = 0);

INCIDENCEEDITOR_EXPORT IncidenceDialog *createTodoEditor(
    const QString &summary, const QString &description, const QStringList &attachments,
    const QStringList &attendees, const QStringList &attachmentMimetypes,
    const QStringList &attachmentLabels, bool inlineAttachment,
    const Akonadi::Collection &defaultCollection, bool cleanupAttachmentTemp,
    QWidget *parent = nullptr, Qt::WindowFlags flags = 0);

INCIDENCEEDITOR_EXPORT IncidenceDialog *createEventEditor(
    const QString &summary, const QString &description, const QStringList &attachments,
    const QStringList &attendees, const QStringList &attachmentMimetypes,
    const QStringList &attachmentLabels, bool inlineAttachment,
    const Akonadi::Collection &defaultCollection, bool cleanupAttachmentTempFiles,
    QWidget *parent = nullptr, Qt::WindowFlags flags = 0);
} // namespace IncidenceDialogFactory
} // namespace IncidenceEditorNG

#endif
07070111A0195E000081A40000000200000002000000015AA55A86000010E8000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceeditor-ng.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_NG_H
#define INCIDENCEEDITOR_NG_H

#include "incidenceeditor_export.h"

#include <KCalCore/Incidence>
#include <AkonadiCore/Item>
namespace IncidenceEditorNG {
/**
 * KCal Incidences are complicated objects. The user interfaces to create/modify
 * are therefore complex too. The IncedenceEditor class is a divide and conquer
 * approach to this complexity. An IncidenceEditor is an editor for a specific
 * part(s) of an Incidence.
 */
class INCIDENCEEDITOR_EXPORT IncidenceEditor : public QObject
{
    Q_OBJECT
public:
    ~IncidenceEditor() override;

/**
     * Load the values of @param incidence into the editor widgets. The passed
     * incidence is kept for comparing with the current values of the editor.
     */
    virtual void load(const KCalCore::Incidence::Ptr &incidence) = 0;
    /// This was introduced to replace categories with Akonadi::Tags
    virtual void load(const Akonadi::Item &item);

/**
     * Store the current values of the editor into @param incidince.
     */
    virtual void save(const KCalCore::Incidence::Ptr &incidence) = 0;
    /// This was introduced to replace categories with Akonadi::Tags
    virtual void save(Akonadi::Item &item);

/**
     * Returns whether or not the current values in the editor differ from the
     * initial values.
     */
    virtual bool isDirty() const = 0;

/**
     * Returns whether or not the content of this editor is valid. The default
     * implementation returns always true.
     */
    virtual bool isValid() const;

/**
       Returns the last error, which is set in isValid() on error,
       and cleared on success.
    */
    QString lastErrorString() const;

/**
     * Sets focus on the invalid field.
     */
    virtual void focusInvalidField();

/**
     * Returns the type of the Incidence that is currently loaded.
     */
    KCalCore::IncidenceBase::IncidenceType type() const;

/** Convenience method to get a pointer for a specific const Incidence Type. */
    template<typename IncidenceT>
    QSharedPointer<IncidenceT> incidence() const
    {
        return mLoadedIncidence.dynamicCast<IncidenceT>();
    }

/**
       Re-implement this and print important member values and widget
       enabled/disabled states that could have lead to isDirty() returning
       true when the user didn't do any interaction with the editor.

This method is called in CombinedIncidenceEditor before crashing
       due to assert( !editor->isDirty() )
    */
    virtual void printDebugInfo() const;

Q_SIGNALS:
    /**
     * Signals whether the dirty status of this editor has changed. The new dirty
     * status is passed as argument.
     */
    void dirtyStatusChanged(bool isDirty);

public Q_SLOTS:
    /**
     * Checks if the dirty status has changed until last check and emits the
     * dirtyStatusChanged signal if needed.
     */
    void checkDirtyStatus();

protected:
    /** Only subclasses can instantiate IncidenceEditors */
    IncidenceEditor(QObject *parent = nullptr);

template<typename IncidenceT>
    QSharedPointer<IncidenceT> incidence(const KCalCore::Incidence::Ptr &inc)
    {
        return inc.dynamicCast<IncidenceT>();
    }

protected:
    KCalCore::Incidence::Ptr mLoadedIncidence;
    mutable QString mLastErrorString;
    bool mWasDirty;
    bool mLoadingIncidence;
};
} // IncidenceEditorNG

#endif // INCIDENCEEDITOR_H
07070111A0195F000081A40000000200000002000000015AA55A8600000930000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceeditor.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidenceeditor-ng.h"

#include "incidenceeditor_debug.h"

using namespace IncidenceEditorNG;

IncidenceEditor::IncidenceEditor(QObject *parent)
    : QObject(parent)
    , mWasDirty(false)
    , mLoadingIncidence(false)
{
}

IncidenceEditor::~IncidenceEditor()
{
}

void IncidenceEditor::checkDirtyStatus()
{
    if (!mLoadedIncidence) {
        qCDebug(INCIDENCEEDITOR_LOG) << "checkDirtyStatus called on an invalid incidence";
        return;
    }

if (mLoadingIncidence) {
        // Still loading the incidence, ignore changes to widgets.
        return;
    }
    const bool dirty = isDirty();
    if (mWasDirty != dirty) {
        mWasDirty = dirty;
        Q_EMIT dirtyStatusChanged(dirty);
    }
}

bool IncidenceEditor::isValid() const
{
    mLastErrorString.clear();
    return true;
}

QString IncidenceEditor::lastErrorString() const
{
    return mLastErrorString;
}

void IncidenceEditor::focusInvalidField()
{
}

KCalCore::IncidenceBase::IncidenceType IncidenceEditor::type() const
{
    if (mLoadedIncidence) {
        return mLoadedIncidence->type();
    } else {
        return KCalCore::IncidenceBase::TypeUnknown;
    }
}

void IncidenceEditor::printDebugInfo() const
{
    // implement this in derived classes.
}

void IncidenceEditor::load(const Akonadi::Item &item)
{
    Q_UNUSED(item);
}

void IncidenceEditor::save(Akonadi::Item &item)
{
    Q_UNUSED(item);
}

#include "moc_incidenceeditor-ng.cpp"
07070111A01962000081A40000000200000002000000015AA55A86000004E0000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceeditor.kcfg<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE kcfg SYSTEM
    "http://www.kde.org/standards/kcfg/1.0/kcfg.dtd">
<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="incidenceeditorrc"/>

<group name="AttachmentHandling">
    <entry type="Enum" name="DefaultEmailAttachMethod">
      <label>Default Email Attachment Method</label>
      <whatsthis>The default way of attaching dropped emails to an event</whatsthis>
      <choices>
        <choice name="Ask">
          <label>Always ask</label>
        </choice>
        <choice name="Link">
          <label>Only attach link to message</label>
        </choice>
        <choice name="InlineFull">
          <label>Attach complete message</label>
        </choice>
        <choice name="InlineBody">
          <label>Attach message without attachments</label>
        </choice>
      </choices>
      <default>Ask</default>
    </entry>
  </group>
  <group name="Collection">
      <entry name="LastSelectedFolder" type="LongLong">
        <default>-1</default>
      </entry>
  </group>
</kcfg>
07070111A01963000081A40000000200000002000000015AA55A8600000552000000FD0000001000000000000000000000005300000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceeditorsettings.cpp/*
    Copyright (C) 2010 Klarälvdalens Datakonsult AB,
        a KDAB Group company, info@kdab.net,
        author Tobias Koenig <tokoe@kdab.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 "incidenceeditorsettings.h"

using namespace IncidenceEditorNG;

IncidenceEditorSettings *IncidenceEditorSettings::mSelf = nullptr;

IncidenceEditorSettings *IncidenceEditorSettings::self()
{
    if (!mSelf) {
        mSelf = new IncidenceEditorSettings();
        mSelf->load();
    }

return mSelf;
}

IncidenceEditorSettings::IncidenceEditorSettings()
{
}

IncidenceEditorSettings::~IncidenceEditorSettings()
{
}
07070111A01964000081A40000000200000002000000015AA55A860000059A000000FD0000001000000000000000000000005100000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceeditorsettings.h/*
    Copyright (C) 2010 Klarälvdalens Datakonsult AB,
        a KDAB Group company, info@kdab.net,
        author Tobias Koenig <tokoe@kdab.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.
*/

#ifndef INCIDENCEEDITORSETTINGS_H
#define INCIDENCEEDITORSETTINGS_H

#include "incidenceeditor_export.h"

#include "globalsettings_incidenceeditor.h"

namespace IncidenceEditorNG {
class INCIDENCEEDITOR_EXPORT IncidenceEditorSettings : public IncidenceEditorNG::
    IncidenceEditorSettingsBase
{
    Q_OBJECT

public:
    static IncidenceEditorSettings *self();

private:
    IncidenceEditorSettings();
    ~IncidenceEditorSettings() override;
    static IncidenceEditorSettings *mSelf;
};
}

#endif
07070111A01965000081A40000000200000002000000015AA55A86000093E4000000FD0000001000000000000000000000004F00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencerecurrence.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "incidencerecurrence.h"
#include "incidencedatetime.h"
#include "ui_dialogdesktop.h"

#include "incidenceeditor_debug.h"
#include <KLocalizedString>
#include <QLocale>

using namespace IncidenceEditorNG;

enum {
    // Keep in sync with mRecurrenceEndCombo
    RecurrenceEndNever = 0,
    RecurrenceEndOn,
    RecurrenceEndAfter
};

/**

Description of available recurrence types:

0 - None
1 -
2 -
3 - rDaily
4 - rWeekly
5 - rMonthlyPos  - 3rd Saturday of month, last Wednesday of month...
6 - rMonthlyDay  - 17th day of month
7 - rYearlyMonth - 10th of July
8 - rYearlyDay   - on the 117th day of the year
9 - rYearlyPos   - 1st Wednesday of July
*/

enum {
    // Indexes of the month combo, keep in sync with descriptions.
    ComboIndexMonthlyDay = 0,     // 11th of June
    ComboIndexMonthlyDayInverted, // 20th of June ( 11 to end )
    ComboIndexMonthlyPos,         // 1st Monday of the Month
    ComboIndexMonthlyPosInverted  // Last Monday of the Month
};

enum {
    // Indexes of the year combo, keep in sync with descriptions.
    ComboIndexYearlyMonth = 0,
    ComboIndexYearlyMonthInverted,
    ComboIndexYearlyPos,
    ComboIndexYearlyPosInverted,
    ComboIndexYearlyDay
};

IncidenceRecurrence::IncidenceRecurrence(IncidenceDateTime *dateTime, Ui::EventOrTodoDesktop *ui)
    : mUi(ui)
    , mDateTime(dateTime)
    , mMonthlyInitialType(0)
    , mYearlyInitialType(0)
{
    setObjectName(QStringLiteral("IncidenceRecurrence"));
    // Set some sane defaults
    mUi->mRecurrenceTypeCombo->setCurrentIndex(RecurrenceTypeNone);
    mUi->mRecurrenceEndCombo->setCurrentIndex(RecurrenceEndNever);
    mUi->mRecurrenceEndStack->setCurrentIndex(0);
    mUi->mRepeatStack->setCurrentIndex(0);
    mUi->mEndDurationEdit->setValue(1);
    handleEndAfterOccurrencesChange(1);
    toggleRecurrenceWidgets(RecurrenceTypeNone);
    fillCombos();
    const QList<QLineEdit *> lineEdits { mUi->mExceptionDateEdit->lineEdit(), mUi->mRecurrenceEndDate->lineEdit()};
    for (QLineEdit *lineEdit : lineEdits) {
        if (lineEdit) {
            lineEdit->setClearButtonEnabled(false);
        }
    }

connect(mDateTime, &IncidenceDateTime::startDateTimeToggled, this,
            &IncidenceRecurrence::handleDateTimeToggle);

connect(mDateTime, &IncidenceDateTime::startDateChanged, this,
            &IncidenceRecurrence::handleStartDateChange);

connect(mUi->mExceptionAddButton, &QPushButton::clicked, this,
            &IncidenceRecurrence::addException);
    connect(mUi->mExceptionRemoveButton, &QPushButton::clicked, this,
            &IncidenceRecurrence::removeExceptions);
    connect(mUi->mExceptionDateEdit, &KDateComboBox::dateChanged, this,
            &IncidenceRecurrence::handleExceptionDateChange);
    connect(mUi->mExceptionList, &QListWidget::itemSelectionChanged, this,
            &IncidenceRecurrence::updateRemoveExceptionButton);
    connect(mUi->mRecurrenceTypeCombo, QOverload<int>::of(&KComboBox::currentIndexChanged), this, &IncidenceRecurrence::handleRecurrenceTypeChange);
    connect(mUi->mEndDurationEdit, QOverload<int>::of(&QSpinBox::valueChanged), this, &IncidenceRecurrence::handleEndAfterOccurrencesChange);
    connect(mUi->mFrequencyEdit, QOverload<int>::of(&QSpinBox::valueChanged), this, &IncidenceRecurrence::handleFrequencyChange);

// Check the dirty status when the user changes values.
    connect(mUi->mRecurrenceTypeCombo, QOverload<int>::of(&KComboBox::currentIndexChanged), this, &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mFrequencyEdit, QOverload<int>::of(&QSpinBox::valueChanged), this, &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mFrequencyEdit, QOverload<int>::of(&QSpinBox::valueChanged), this, &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mWeekDayCombo, &KPIM::KWeekdayCheckCombo::checkedItemsChanged, this,
            &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mMonthlyCombo, QOverload<int>::of(&KComboBox::currentIndexChanged), this, &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mYearlyCombo, QOverload<int>::of(&KComboBox::currentIndexChanged), this, &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mRecurrenceEndCombo, QOverload<int>::of(&KComboBox::currentIndexChanged), this, &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mEndDurationEdit, QOverload<int>::of(&QSpinBox::valueChanged), this, &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mRecurrenceEndDate, &KDateComboBox::dateChanged, this,
            &IncidenceRecurrence::checkDirtyStatus);
    connect(mUi->mThisAndFutureCheck, &QCheckBox::stateChanged, this,
            &IncidenceRecurrence::checkDirtyStatus);
}

// this method must be at the top of this file in order to ensure
// that its message to translators appears before any usages of this method.
KLocalizedString IncidenceRecurrence::subsOrdinal(const KLocalizedString &text, int number) const
{
    QString q = i18nc("In several of the messages below, "
                      "an ordinal number is substituted into the message. "
                      "Translate this as \"0\" if English ordinal suffixes "
                      "should be added (1st, 22nd, 123rd); "
                      "translate this as \"1\" if just the number itself "
                      "should be substituted (1, 22, 123).",
                      "0");
    if (q == QLatin1String("0")) {
        const QString ordinal = numberToString(number);
        return text.subs(ordinal);
    } else {
        return text.subs(number);
    }
}

void IncidenceRecurrence::load(const KCalCore::Incidence::Ptr &incidence)
{
    Q_ASSERT(incidence);

mLoadedIncidence = incidence;
    // We must be sure that the date/time in mDateTime is the correct date time.
    // So don't depend on CombinedIncidenceEditor or whatever external factor to
    // load the date/time before loading the recurrence

mCurrentDate = mLoadedIncidence->dateTime(KCalCore::IncidenceBase::RoleRecurrenceStart).date();

mDateTime->load(incidence);
    mDateTime->endDate();
    fillCombos();
    setDefaults();

//This is an exception
    if (mLoadedIncidence->hasRecurrenceId()) {
        handleRecurrenceTypeChange(RecurrenceTypeException);
        mUi->mThisAndFutureCheck->setChecked(mLoadedIncidence->thisAndFuture());
        mWasDirty = false;
        return;
    }

int f = 0;
    KCalCore::Recurrence *r = nullptr;
    if (mLoadedIncidence->recurrenceType() != KCalCore::Recurrence::rNone) {
        r = mLoadedIncidence->recurrence();
        f = r->frequency();
    }

switch (mLoadedIncidence->recurrenceType()) {
    case KCalCore::Recurrence::rNone:
        mUi->mRecurrenceTypeCombo->setCurrentIndex(RecurrenceTypeNone);
        handleRecurrenceTypeChange(RecurrenceTypeNone);
        break;
    case KCalCore::Recurrence::rDaily:
        mUi->mRecurrenceTypeCombo->setCurrentIndex(RecurrenceTypeDaily);
        handleRecurrenceTypeChange(RecurrenceTypeDaily);
        setFrequency(f);
        break;
    case KCalCore::Recurrence::rWeekly:
    {
        mUi->mRecurrenceTypeCombo->setCurrentIndex(RecurrenceTypeWeekly);
        handleRecurrenceTypeChange(RecurrenceTypeWeekly);
        QBitArray disableDays(7 /*size*/, 0 /*default value*/);
        // dayOfWeek returns between 1 and 7
        disableDays.setBit(currentDate().dayOfWeek() - 1, 1);
        mUi->mWeekDayCombo->setDays(r->days(), disableDays);
        setFrequency(f);
        break;
    }
    case KCalCore::Recurrence::rMonthlyPos: // Fall through
    case KCalCore::Recurrence::rMonthlyDay:
        mUi->mRecurrenceTypeCombo->setCurrentIndex(RecurrenceTypeMonthly);
        handleRecurrenceTypeChange(RecurrenceTypeMonthly);
        selectMonthlyItem(r, mLoadedIncidence->recurrenceType());
        setFrequency(f);
        break;
    case KCalCore::Recurrence::rYearlyMonth: // Fall through
    case KCalCore::Recurrence::rYearlyPos:   // Fall through
    case KCalCore::Recurrence::rYearlyDay:
        mUi->mRecurrenceTypeCombo->setCurrentIndex(RecurrenceTypeYearly);
        handleRecurrenceTypeChange(RecurrenceTypeYearly);
        selectYearlyItem(r, mLoadedIncidence->recurrenceType());
        setFrequency(f);
        break;
    default:
        break;
    }

if (mLoadedIncidence->recurs() && r) {
        setDuration(r->duration());
        if (r->duration() == 0) {
            mUi->mRecurrenceEndDate->setDate(r->endDate());
        }
    }

setExceptionDates(mLoadedIncidence->recurrence()->exDates());
    handleDateTimeToggle();
    mWasDirty = false;
}

void IncidenceRecurrence::writeToIncidence(const KCalCore::Incidence::Ptr &incidence) const
{
    // clear out any old settings;
    KCalCore::Recurrence *r = incidence->recurrence();
    r->unsetRecurs(); // Why not clear() ?

const RecurrenceType recurrenceType = currentRecurrenceType();

if (recurrenceType == RecurrenceTypeException) {
        incidence->setThisAndFuture(mUi->mThisAndFutureCheck->isChecked());
        return;
    }

if (recurrenceType == RecurrenceTypeNone
        || !mUi->mRecurrenceTypeCombo->isEnabled()) {
        return;
    }

const int lDuration = duration();
    QDate endDate;
    if (lDuration == 0) {
        endDate = mUi->mRecurrenceEndDate->date();
    }

if (recurrenceType == RecurrenceTypeDaily) {
        r->setDaily(mUi->mFrequencyEdit->value());
    } else if (recurrenceType == RecurrenceTypeWeekly) {
        r->setWeekly(mUi->mFrequencyEdit->value(), mUi->mWeekDayCombo->days());
    } else if (recurrenceType == RecurrenceTypeMonthly) {
        r->setMonthly(mUi->mFrequencyEdit->value());

if (mUi->mMonthlyCombo->currentIndex() == ComboIndexMonthlyDay) {
            // Every nth
            r->addMonthlyDate(dayOfMonthFromStart());
        } else if (mUi->mMonthlyCombo->currentIndex() == ComboIndexMonthlyDayInverted) {
            // Every (last - n)th last day
            r->addMonthlyDate(-dayOfMonthFromEnd());
        } else if (mUi->mMonthlyCombo->currentIndex() == ComboIndexMonthlyPos) {
            // Every ith weekday
            r->addMonthlyPos(monthWeekFromStart(), weekday());
        } else {
            // Every (last - i)th last weekday
            r->addMonthlyPos(-monthWeekFromEnd(), weekday());
        }
    } else if (recurrenceType == RecurrenceTypeYearly) {
        r->setYearly(mUi->mFrequencyEdit->value());

if (mUi->mYearlyCombo->currentIndex() == ComboIndexYearlyMonth) {
            //Every nth of month
            r->addYearlyDate(dayOfMonthFromStart());
            r->addYearlyMonth(currentDate().month());
        } else if (mUi->mYearlyCombo->currentIndex() == ComboIndexYearlyMonthInverted) {
            //Every (last - n)th last day of month
            r->addYearlyDate(-dayOfMonthFromEnd());
            r->addYearlyMonth(currentDate().month());
        } else if (mUi->mYearlyCombo->currentIndex() == ComboIndexYearlyPos) {
            //Every ith weekday of month
            r->addYearlyMonth(currentDate().month());
            r->addYearlyPos(monthWeekFromStart(), weekday());
        } else if (mUi->mYearlyCombo->currentIndex() == ComboIndexYearlyPosInverted) {
            //Every (last - i)th last weekday of month
            r->addYearlyMonth(currentDate().month());
            r->addYearlyPos(-monthWeekFromEnd(), weekday());
        } else {
            // The lth day of the year (l : 1 - 356)
            r->addYearlyDay(dayOfYearFromStart());
        }
    }

r->setDuration(lDuration);
    if (lDuration == 0) {
        r->setEndDate(endDate);
    }

r->setExDates(mExceptionDates);
}

void IncidenceRecurrence::save(const KCalCore::Incidence::Ptr &incidence)
{
    writeToIncidence(incidence);
    mMonthlyInitialType = mUi->mMonthlyCombo->currentIndex();
    mYearlyInitialType = mUi->mYearlyCombo->currentIndex();
}

bool IncidenceRecurrence::isDirty() const
{
    const RecurrenceType recurrenceType = currentRecurrenceType();
    if (mLoadedIncidence->recurs()
        && recurrenceType == RecurrenceTypeNone) {
        return true;
    }

if (recurrenceType == RecurrenceTypeException) {
        return mLoadedIncidence->thisAndFuture() != mUi->mThisAndFutureCheck->isChecked();
    }

if (!mLoadedIncidence->recurs() && recurrenceType != IncidenceEditorNG::RecurrenceTypeNone) {
        return true;
    }

// The incidence is not recurring and that hasn't changed, so don't check the
    // other values.
    if (recurrenceType == RecurrenceTypeNone) {
        return false;
    }

const KCalCore::Recurrence *recurrence = mLoadedIncidence->recurrence();
    switch (recurrence->recurrenceType()) {
    case KCalCore::Recurrence::rDaily:
        if (recurrenceType != RecurrenceTypeDaily
            || mUi->mFrequencyEdit->value() != recurrence->frequency()) {
            return true;
        }

break;
    case KCalCore::Recurrence::rWeekly:
        if (recurrenceType != RecurrenceTypeWeekly
            || mUi->mFrequencyEdit->value() != recurrence->frequency()
            || mUi->mWeekDayCombo->days() != recurrence->days()) {
            return true;
        }
        break;
    case KCalCore::Recurrence::rMonthlyDay:
        if (recurrenceType != RecurrenceTypeMonthly
            || mUi->mFrequencyEdit->value() != recurrence->frequency()
            || mUi->mMonthlyCombo->currentIndex() != mMonthlyInitialType) {
            return true;
        }
        break;
    case KCalCore::Recurrence::rMonthlyPos:
        if (recurrenceType != RecurrenceTypeMonthly
            || mUi->mFrequencyEdit->value() != recurrence->frequency()
            || mUi->mMonthlyCombo->currentIndex() != mMonthlyInitialType) {
            return true;
        }
        break;
    case KCalCore::Recurrence::rYearlyDay:
        if (recurrenceType != RecurrenceTypeYearly
            || mUi->mFrequencyEdit->value() != recurrence->frequency()
            || mUi->mYearlyCombo->currentIndex() != mYearlyInitialType) {
            return true;
        }
        break;
    case KCalCore::Recurrence::rYearlyMonth:
        if (recurrenceType != RecurrenceTypeYearly
            || mUi->mFrequencyEdit->value() != recurrence->frequency()
            || mUi->mYearlyCombo->currentIndex() != mYearlyInitialType) {
            return true;
        }
        break;
    case KCalCore::Recurrence::rYearlyPos:
        if (recurrenceType != RecurrenceTypeYearly
            || mUi->mFrequencyEdit->value() != recurrence->frequency()
            || mUi->mYearlyCombo->currentIndex() != mYearlyInitialType) {
            return true;
        }
        break;
    }

// Recurrence end
    // -1 means "recurs forever"
    if (recurrence->duration() == -1
        && mUi->mRecurrenceEndCombo->currentIndex() != RecurrenceEndNever) {
        return true;
    } else if (recurrence->duration() == 0) {
        // 0 means "end date is set"
        if (mUi->mRecurrenceEndCombo->currentIndex() != RecurrenceEndOn
            || recurrence->endDate() != mUi->mRecurrenceEndDate->date()) {
            return true;
        }
    } else if (recurrence->duration() > 0) {
        if (mUi->mEndDurationEdit->value() != recurrence->duration()
            || mUi->mRecurrenceEndCombo->currentIndex() != RecurrenceEndAfter) {
            return true;
        }
    }

// Exceptions
    if (mExceptionDates != recurrence->exDates()) {
        return true;
    }

return false;
}

bool IncidenceRecurrence::isValid() const
{
    mLastErrorString.clear();
    if (currentRecurrenceType() == IncidenceEditorNG::RecurrenceTypeException) {
        //Nothing you can do wrong here
        return true;
    }
    KCalCore::Incidence::Ptr incidence(mLoadedIncidence->clone());

// Write start and end dates to the incidence
    mDateTime->save(incidence);

// Write new recurring parameters to incidence
    writeToIncidence(incidence);

// Check if the incidence will occur at least once
    if (incidence->recurs()) {
        // dtStart for events, dtDue for to-dos
        const QDateTime referenceDate
            = incidence->dateTime(KCalCore::Incidence::RoleRecurrenceStart);

if (referenceDate.isValid()) {
            if (!(incidence->recurrence()->recursOn(referenceDate.date(), referenceDate.timeZone())
                  || incidence->recurrence()->getNextDateTime(referenceDate).isValid())) {
                mLastErrorString = i18n("A recurring event or to-do must occur at least once. "
                                        "Adjust the recurring parameters.");
                qCDebug(INCIDENCEEDITOR_LOG) << mLastErrorString;
                return false;
            }
        } else {
            mLastErrorString = i18n("The incidence's start date is invalid.");
            qCDebug(INCIDENCEEDITOR_LOG) << mLastErrorString;
            return false;
        }

if (mUi->mRecurrenceEndCombo->currentIndex() == RecurrenceEndOn
            && !mUi->mRecurrenceEndDate->date().isValid()) {
            qCWarning(INCIDENCEEDITOR_LOG) << "Recurrence end date is invalid."; // TODO: strings after freeze
            return false;
        }
    }

return true;
}

void IncidenceRecurrence::addException()
{
    const QDate date = mUi->mExceptionDateEdit->date();
    if (!date.isValid()) {
        qCWarning(INCIDENCEEDITOR_LOG) << "Refusing to add invalid date";
        return;
    }

const QString dateStr = QLocale().toString(date);
    if (mUi->mExceptionList->findItems(dateStr, Qt::MatchExactly).isEmpty()) {
        mExceptionDates.append(date);
        mUi->mExceptionList->addItem(dateStr);
    }

mUi->mExceptionAddButton->setEnabled(false);
    checkDirtyStatus();
}

void IncidenceRecurrence::fillCombos()
{
    if (!currentDate().isValid()) {
        // Can happen if you're editing with keyboard
        return;
    }

// Next the monthly combo. This contains the following elements:
    // - nth day of the month
    // - (month.lastDay() - n)th day of the month
    // - the ith ${weekday} of the month
    // - the (month.weekCount() - i)th day of the month
    const int currentMonthlyIndex = mUi->mMonthlyCombo->currentIndex();
    mUi->mMonthlyCombo->clear();
    const QDate date = mDateTime->startDate();

QString item = subsOrdinal(
        ki18nc("example: the 30th", "the %1"), dayOfMonthFromStart()).toString();
    mUi->mMonthlyCombo->addItem(item);

item = subsOrdinal(ki18nc("example: the 4th to last day",
                              "the %1 to last day"), dayOfMonthFromEnd()).toString();
    mUi->mMonthlyCombo->addItem(item);

item = subsOrdinal(
        ki18nc("example: the 5th Wednesday", "the %1 %2"), monthWeekFromStart()).
           subs(QLocale::system().dayName(date.dayOfWeek(),
                                          QLocale::QLocale::LongFormat)).toString();
    mUi->mMonthlyCombo->addItem(item);

if (monthWeekFromEnd() == 1) {
        item = ki18nc("example: the last Wednesday", "the last %1").
               subs(QLocale::system().dayName(date.dayOfWeek(), QLocale::LongFormat)).toString();
    } else {
        item = subsOrdinal(
            ki18nc("example: the 5th to last Wednesday", "the %1 to last %2"), monthWeekFromEnd()).
               subs(QLocale::system().dayName(date.dayOfWeek(), QLocale::LongFormat)).toString();
    }
    mUi->mMonthlyCombo->addItem(item);
    mUi->mMonthlyCombo->setCurrentIndex(currentMonthlyIndex == -1 ? 0 : currentMonthlyIndex);

// Finally the yearly combo. This contains the following options:
    // - ${n}th of ${long-month-name}
    // - ${month.lastDay() - n}th last day of ${long-month-name}
    // - the ${i}th ${weekday} of ${long-month-name}
    // - the ${month.weekCount() - i}th day of ${long-month-name}
    // - the ${m}th day of the year
    const int currentYearlyIndex = mUi->mYearlyCombo->currentIndex();
    mUi->mYearlyCombo->clear();
    const QString longMonthName = QLocale::system().monthName(date.month(), QLocale::LongFormat);
    item = subsOrdinal(ki18nc("example: the 5th of June", "the %1 of %2"), date.day()).
           subs(longMonthName).toString();
    mUi->mYearlyCombo->addItem(item);

item = subsOrdinal(
        ki18nc("example: the 3rd to last day of June", "the %1 to last day of %2"),
        date.daysInMonth() - date.day()).subs(longMonthName).toString();
    mUi->mYearlyCombo->addItem(item);

item = subsOrdinal(
        ki18nc("example: the 4th Wednesday of June", "the %1 %2 of %3"), monthWeekFromStart()).
           subs(QLocale::system().dayName(date.dayOfWeek(), QLocale::LongFormat)).
           subs(longMonthName).toString();
    mUi->mYearlyCombo->addItem(item);

if (monthWeekFromEnd() == 1) {
        item = ki18nc("example: the last Wednesday of June", "the last %1 of %2").
               subs(QLocale::system().dayName(date.dayOfWeek(), QLocale::LongFormat)).
               subs(longMonthName).toString();
    } else {
        item = subsOrdinal(
            ki18nc("example: the 4th to last Wednesday of June", "the %1 to last %2 of %3 "),
            monthWeekFromEnd()).
               subs(QLocale::system().dayName(date.dayOfWeek(), QLocale::LongFormat)).
               subs(longMonthName).toString();
    }
    mUi->mYearlyCombo->addItem(item);

item = subsOrdinal(
        ki18nc("example: the 15th day of the year", "the %1 day of the year"),
        date.dayOfYear()).toString();
    mUi->mYearlyCombo->addItem(item);
    mUi->mYearlyCombo->setCurrentIndex(currentYearlyIndex == -1 ? 0 : currentYearlyIndex);
}

void IncidenceRecurrence::handleDateTimeToggle()
{
    QWidget *parent = mUi->mRepeatStack->parentWidget(); // Take the parent of a toplevel widget;
    if (parent) {
        parent->setEnabled(mDateTime->startDateTimeEnabled());
    }
}

void IncidenceRecurrence::handleEndAfterOccurrencesChange(int currentValue)
{
    mUi->mRecurrenceOccurrencesLabel->setText(
        i18ncp("Recurrence ends after n occurrences", "occurrence", "occurrences", currentValue));
}

void IncidenceRecurrence::handleExceptionDateChange(const QDate &currentDate)
{
    const QDate date = mUi->mExceptionDateEdit->date();
    const QString dateStr = QLocale().toString(date);

mUi->mExceptionAddButton->setEnabled(
        currentDate >= mDateTime->startDate()
        && mUi->mExceptionList->findItems(dateStr, Qt::MatchExactly).isEmpty());
}

void IncidenceRecurrence::handleFrequencyChange()
{
    handleRecurrenceTypeChange(currentRecurrenceType());
}

void IncidenceRecurrence::handleRecurrenceTypeChange(int currentIndex)
{
    toggleRecurrenceWidgets(currentIndex);
    QString labelFreq;
    QString freqKey;
    int frequency = mUi->mFrequencyEdit->value();
    switch (currentIndex) {
    case 2:
        labelFreq = i18ncp("repeat every N >weeks<", "week", "weeks", frequency);
        freqKey = QLatin1Char('w');
        break;
    case 3:
        labelFreq = i18ncp("repeat every N >months<", "month", "months", frequency);
        freqKey = QLatin1Char('m');
        break;
    case 4:
        labelFreq = i18ncp("repeat every N >years<", "year", "years", frequency);
        freqKey = QLatin1Char('y');
        break;
    default:
        labelFreq = i18ncp("repeat every N >days<", "day", "days", frequency);
        freqKey = QLatin1Char('d');
    }

const QString labelEvery = ki18ncp("repeat >every< N years/months/...; "
                         "dynamic context 'type': 'd' days, 'w' weeks, "
                         "'m' months, 'y' years",
                         "every", "every").
                 subs(frequency).inContext(QStringLiteral("type"), freqKey).toString();
    mUi->mFrequencyLabel->setText(labelEvery);
    mUi->mRecurrenceRuleLabel->setText(labelFreq);

Q_EMIT recurrenceChanged(static_cast<RecurrenceType>(currentIndex));
}

void IncidenceRecurrence::removeExceptions()
{
    const QList<QListWidgetItem *> selectedExceptions = mUi->mExceptionList->selectedItems();
    for (QListWidgetItem *selectedException : selectedExceptions) {
        const int row = mUi->mExceptionList->row(selectedException);
        mExceptionDates.removeAt(row);
        delete mUi->mExceptionList->takeItem(row);
    }

handleExceptionDateChange(mUi->mExceptionDateEdit->date());
    checkDirtyStatus();
}

void IncidenceRecurrence::updateRemoveExceptionButton()
{
    mUi->mExceptionRemoveButton->setEnabled(!mUi->mExceptionList->selectedItems().isEmpty());
}

void IncidenceRecurrence::updateWeekDays(const QDate &newStartDate)
{
    const int oldStartDayIndex = mUi->mWeekDayCombo->weekdayIndex(mCurrentDate);
    const int newStartDayIndex = mUi->mWeekDayCombo->weekdayIndex(newStartDate);

if (oldStartDayIndex >= 0) {
        mUi->mWeekDayCombo->setItemCheckState(oldStartDayIndex, Qt::Unchecked);
        mUi->mWeekDayCombo->setItemEnabled(oldStartDayIndex, true);
    }

if (newStartDayIndex >= 0) {
        mUi->mWeekDayCombo->setItemCheckState(newStartDayIndex, Qt::Checked);
        mUi->mWeekDayCombo->setItemEnabled(newStartDayIndex, false);
    }

if (newStartDate.isValid()) {
        mCurrentDate = newStartDate;
    }
}

short IncidenceRecurrence::dayOfMonthFromStart() const
{
    return currentDate().day();
}

short IncidenceRecurrence::dayOfMonthFromEnd() const
{
    const QDate start = currentDate();
    return start.daysInMonth() - start.day() + 1;
}

short IncidenceRecurrence::dayOfYearFromStart() const
{
    return currentDate().dayOfYear();
}

int IncidenceRecurrence::duration() const
{
    if (mUi->mRecurrenceEndCombo->currentIndex() == RecurrenceEndNever) {
        return -1;
    } else if (mUi->mRecurrenceEndCombo->currentIndex() == RecurrenceEndAfter) {
        return mUi->mEndDurationEdit->value();
    } else {
        // 0 means "end date set"
        return 0;
    }
}

short IncidenceRecurrence::monthWeekFromStart() const
{
    const QDate date = currentDate();
    int count;
    if (date.isValid()) {
        count = 1;
        QDate tmp = date.addDays(-7);
        while (tmp.month() == date.month()) {
            tmp = tmp.addDays(-7);   // Count backward
            ++count;
        }
    } else {
        // date can be invalid if you're editing the date with your keyboard
        count = -1;
    }

// 1 is the first week, 4/5 is the last week of the month
    return count;
}

short IncidenceRecurrence::monthWeekFromEnd() const
{
    const QDate date = currentDate();
    int count;
    if (date.isValid()) {
        count = 1;
        QDate tmp = date.addDays(7);
        while (tmp.month() == date.month()) {
            tmp = tmp.addDays(7);    // Count forward
            ++count;
        }
    } else {
        // date can be invalid if you're editing the date with your keyboard
        count = -1;
    }

// 1 is the last week, 4/5 is the first week of the month
    return count;
}

QString IncidenceRecurrence::numberToString(int number) const
{
    // The code in here was adapted from an article by Johnathan Wood, see:
    // http://www.blackbeltcoder.com/Articles/strings/converting-numbers-to-ordinal-strings

static QString _numSuffixes[] = {
        QStringLiteral("th"), QStringLiteral("st"), QStringLiteral("nd"), QStringLiteral("rd"),
        QStringLiteral("th"), QStringLiteral("th"), QStringLiteral("th"), QStringLiteral("th"),
        QStringLiteral(
            "th"), QStringLiteral("th")
    };

int i = (number % 100);
    int j = (i > 10 && i < 20) ? 0 : (number % 10);
    return QString::number(number) + _numSuffixes[j];
}

void IncidenceRecurrence::selectMonthlyItem(KCalCore::Recurrence *recurrence, ushort recurenceType)
{
    Q_ASSERT(recurenceType == KCalCore::Recurrence::rMonthlyPos
             || recurenceType == KCalCore::Recurrence::rMonthlyDay);

if (recurenceType == KCalCore::Recurrence::rMonthlyPos) {
        QList<KCalCore::RecurrenceRule::WDayPos> rmp = recurrence->monthPositions();
        if (rmp.isEmpty()) {
            return; // Use the default values. Probably marks the editor as dirty
        }

if (rmp.first().pos() > 0) {   // nth day
            // TODO if ( rmp.first().pos() != mDateTime->startDate().day() ) { warn user }
            // NOTE: This silencly changes the recurrence when:
            //       rmp.first().pos() != mDateTime->startDate().day()
            mUi->mMonthlyCombo->setCurrentIndex(ComboIndexMonthlyPos);
        } else { // (month.last() - n)th day
            // TODO: Handle recurrences we cannot represent
            // QDate startDate = mDateTime->startDate();
            // const int dayFromEnd = startDate.daysInMonth() - startDate.day();
            // if ( qAbs( rmp.first().pos() ) != dayFromEnd ) { /* warn user */ }
            mUi->mMonthlyCombo->setCurrentIndex(ComboIndexMonthlyPosInverted);
        }
    } else { // Monthly by day
        // check if we have any setting for which day (vcs import is broken and
        // does not set any day, thus we need to check)
        const int day = recurrence->monthDays().isEmpty() ? currentDate().day()
                        : recurrence->monthDays().at(0);

// Days from the end are after the ones from the begin, so correct for the
        // negative sign and add 30 (index starting at 0)
        // TODO: Do similar checks as in the monthlyPos case
        if (day > 0 && day <= 31) {
            mUi->mMonthlyCombo->setCurrentIndex(ComboIndexMonthlyDay);
        } else if (day < 0) {
            mUi->mMonthlyCombo->setCurrentIndex(ComboIndexMonthlyDayInverted);
        }
    }

// So we can easily detect if the user changed the type, without going through this logic ^
    mMonthlyInitialType = mUi->mMonthlyCombo->currentIndex();
}

void IncidenceRecurrence::selectYearlyItem(KCalCore::Recurrence *recurrence, ushort recurenceType)
{
    Q_ASSERT(recurenceType == KCalCore::Recurrence::rYearlyDay
             || recurenceType == KCalCore::Recurrence::rYearlyMonth
             || recurenceType == KCalCore::Recurrence::rYearlyPos);

if (recurenceType == KCalCore::Recurrence::rYearlyDay) {
        /*
        const int day = recurrence->yearDays().isEmpty() ? currentDate().dayOfYear() :
                                                           recurrence->yearDays().first();
        */
        // TODO Check if day has actually the same value as in the combo.
        mUi->mYearlyCombo->setCurrentIndex(ComboIndexYearlyDay);
    } else if (recurenceType == KCalCore::Recurrence::rYearlyMonth) {
        const int day = recurrence->yearDates().isEmpty() ? currentDate().day()
                        : recurrence->yearDates().at(0);

/*
        int month = currentDate().month();
        if ( !recurrence->yearMonths().isEmpty() ) {
          month = recurrence->yearMonths().first();
        }
        */

// TODO check month and day to be correct values with respect to what is
        //      presented in the combo box.
        if (day > 0) {
            mUi->mYearlyCombo->setCurrentIndex(ComboIndexYearlyMonth);
        } else {
            mUi->mYearlyCombo->setCurrentIndex(ComboIndexYearlyMonthInverted);
        }
    } else { //KCalCore::Recurrence::rYearlyPos
        /*
        int month = currentDate().month();
        if ( !recurrence->yearMonths().isEmpty() ) {
          month = recurrence->yearMonths().first();
        }
        */

// count is the nth weekday of the month or the ith last weekday of the month.
        int count = (currentDate().day() - 1) / 7;
        if (!recurrence->yearPositions().isEmpty()) {
            count = recurrence->yearPositions().at(0).pos();
        }

// TODO check month,count and day to be correct values with respect to what is
        //      presented in the combo box.
        if (count > 0) {
            mUi->mYearlyCombo->setCurrentIndex(ComboIndexYearlyPos);
        } else {
            mUi->mYearlyCombo->setCurrentIndex(ComboIndexYearlyPosInverted);
        }
    }

// So we can easily detect if the user changed the type, without going through this logic ^
    mYearlyInitialType = mUi->mYearlyCombo->currentIndex();
}

void IncidenceRecurrence::setDefaults()
{
    mUi->mRecurrenceEndCombo->setCurrentIndex(RecurrenceEndNever);
    mUi->mRecurrenceEndDate->setDate(currentDate());
    mUi->mRecurrenceTypeCombo->setCurrentIndex(RecurrenceTypeNone);

setFrequency(1);

// -1 because we want between 0 and 6
    const int day = currentDate().dayOfWeek() - 1;

QBitArray checkDays(7, 0);
    checkDays.setBit(day);

QBitArray disableDays(7, 0);
    disableDays.setBit(day);

mUi->mWeekDayCombo->setDays(checkDays, disableDays);

mUi->mMonthlyCombo->setCurrentIndex(0);   // Recur on the nth of the month
    mUi->mYearlyCombo->setCurrentIndex(0);    // Recur on the nth of the month
}

void IncidenceRecurrence::setDuration(int duration)
{
    if (duration == -1) {   // No end date
        mUi->mRecurrenceEndCombo->setCurrentIndex(RecurrenceEndNever);
        mUi->mRecurrenceEndStack->setCurrentIndex(0);
    } else if (duration == 0) {
        mUi->mRecurrenceEndCombo->setCurrentIndex(RecurrenceEndOn);
        mUi->mRecurrenceEndStack->setCurrentIndex(1);
    } else {
        mUi->mRecurrenceEndCombo->setCurrentIndex(RecurrenceEndAfter);
        mUi->mRecurrenceEndStack->setCurrentIndex(2);
        mUi->mEndDurationEdit->setValue(duration);
    }
}

void IncidenceRecurrence::setExceptionDates(const KCalCore::DateList &dates)
{
    mUi->mExceptionList->clear();
    mExceptionDates.clear();
    KCalCore::DateList::ConstIterator dit;
    for (dit = dates.begin(); dit != dates.end(); ++dit) {
        mUi->mExceptionList->addItem(QLocale().toString(*dit));
        mExceptionDates.append(*dit);
    }
}

void IncidenceRecurrence::setFrequency(int frequency)
{
    if (frequency < 1) {
        frequency = 1;
    }

mUi->mFrequencyEdit->setValue(frequency);
}

void IncidenceRecurrence::toggleRecurrenceWidgets(int recurrenceType)
{
    bool enable = (recurrenceType != RecurrenceTypeNone)
                  && (recurrenceType != RecurrenceTypeException);
    mUi->mRecurrenceTypeCombo->setVisible(recurrenceType != RecurrenceTypeException);
    mUi->mRepeatLabel->setVisible(recurrenceType != RecurrenceTypeException);
    mUi->mRecurrenceEndLabel->setVisible(enable);
    mUi->mOnLabel->setVisible(enable && recurrenceType != RecurrenceTypeDaily);
    if (!enable) {
        // So we can hide the exceptions labels and not trigger column resizing.
        mUi->mRepeatLabel->setMinimumSize(mUi->mExceptionsLabel->sizeHint());
    }

mUi->mFrequencyLabel->setVisible(enable);
    mUi->mFrequencyEdit->setVisible(enable);
    mUi->mRecurrenceRuleLabel->setVisible(enable);
    mUi->mRepeatStack->setVisible(enable && recurrenceType != RecurrenceTypeDaily);
    mUi->mRepeatStack->setCurrentIndex(recurrenceType);
    mUi->mRecurrenceEndCombo->setVisible(enable);
    mUi->mEndDurationEdit->setVisible(enable);
    mUi->mRecurrenceEndStack->setVisible(enable);

// Exceptions widgets
    mUi->mExceptionsLabel->setVisible(enable);
    mUi->mExceptionDateEdit->setVisible(enable);
    mUi->mExceptionAddButton->setVisible(enable);
    mUi->mExceptionAddButton->setEnabled(mUi->mExceptionDateEdit->date() >= currentDate());
    mUi->mExceptionRemoveButton->setVisible(enable);
    mUi->mExceptionRemoveButton->setEnabled(!mUi->mExceptionList->selectedItems().isEmpty());
    mUi->mExceptionList->setVisible(enable);
    mUi->mThisAndFutureCheck->setVisible(recurrenceType == RecurrenceTypeException);
}

QBitArray IncidenceRecurrence::weekday() const
{
    QBitArray days(7);
    // QDate::dayOfWeek() -> returns [1 - 7], 1 == monday
    days.setBit(currentDate().dayOfWeek() - 1, true);
    return days;
}

int IncidenceRecurrence::weekdayCountForMonth(const QDate &date) const
{
    Q_ASSERT(date.isValid());
    // This methods returns how often the weekday specified by @param date occurs
    // in the month represented by @param date.

int count = 1;
    QDate tmp = date.addDays(-7);
    while (tmp.month() == date.month()) {
        tmp = tmp.addDays(-7);
        ++count;
    }

tmp = date.addDays(7);
    while (tmp.month() == date.month()) {
        tmp = tmp.addDays(7);
        ++count;
    }

return count;
}

RecurrenceType IncidenceRecurrence::currentRecurrenceType() const
{
    if (mLoadedIncidence && mLoadedIncidence->hasRecurrenceId()) {
        return RecurrenceTypeException;
    }

const int currentIndex = mUi->mRecurrenceTypeCombo->currentIndex();
    Q_ASSERT_X(currentIndex >= 0 && currentIndex < RecurrenceTypeUnknown, "currentRecurrenceType",
               "Keep the combo-box values in sync with the enum");
    return static_cast<RecurrenceType>(currentIndex);
}

void IncidenceRecurrence::handleStartDateChange(const QDate &date)
{
    if (currentDate().isValid()) {
        fillCombos();
        updateWeekDays(date);
        mUi->mExceptionDateEdit->setDate(date);
    }
}

QDate IncidenceRecurrence::currentDate() const
{
    return mDateTime->startDate();
}
07070111A01966000081A40000000200000002000000015AA55A8600001232000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencerecurrence.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_INCIDENCERECURRENCE_H
#define INCIDENCEEDITOR_INCIDENCERECURRENCE_H

#include "incidenceeditor-ng.h"

#include <KLocalizedString>
#include <QDate>
namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class IncidenceDateTime;

/// Keep this in sync with the values in mUi->mRecurrenceTypeCombo
enum RecurrenceType {
    RecurrenceTypeNone = 0,
    RecurrenceTypeDaily,
    RecurrenceTypeWeekly,
    RecurrenceTypeMonthly,
    RecurrenceTypeYearly,
    RecurrenceTypeUnknown, // keep this one at the end of the ones which are also in the combobox
    RecurrenceTypeException
};

class IncidenceRecurrence : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual

IncidenceRecurrence(IncidenceDateTime *dateTime, Ui::EventOrTodoDesktop *ui);

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;
    bool isValid() const override;

RecurrenceType currentRecurrenceType() const;

Q_SIGNALS:
    void recurrenceChanged(IncidenceEditorNG::RecurrenceType type);

private:
    void addException();
    void fillCombos();
    void handleDateTimeToggle();
    void handleEndAfterOccurrencesChange(int currentValue);
    void handleExceptionDateChange(const QDate &currentDate);
    void handleFrequencyChange();
    void handleRecurrenceTypeChange(int currentIndex);
    void removeExceptions();
    void updateRemoveExceptionButton();
    void updateWeekDays(const QDate &newStartDate);
    void handleStartDateChange(const QDate &);

/**
       I needed save() to be const, so created this func.
       save() calls this now, and changes members outside.
    */
    void writeToIncidence(const KCalCore::Incidence::Ptr &incidence) const;

KLocalizedString subsOrdinal(const KLocalizedString &text, int number) const;
    /**
     * Return the day in the month/year on which the event recurs, starting at the
     * beginning/end. Both return a positive number.
     */
    short dayOfMonthFromStart() const;
    short dayOfMonthFromEnd() const;
    short dayOfYearFromStart() const; // We don't need from end for year
    int duration() const;

/** Returns the week number (1-5) of the month in which the start date occurs. */
    short monthWeekFromStart() const;
    short monthWeekFromEnd() const;

/** DO NOT USE THIS METHOD DIRECTLY
        use subsOrdinal() instead for i18n * */
    QString numberToString(int number) const;
    void selectMonthlyItem(KCalCore::Recurrence *recurrence, ushort recurenceType);
    void selectYearlyItem(KCalCore::Recurrence *recurrence, ushort recurenceType);
    void setDefaults();
    void setDuration(int duration);
    void setExceptionDates(const KCalCore::DateList &dates);
    void setFrequency(int freq);
    void toggleRecurrenceWidgets(int enable);
    /** Returns an array with the weekday on which the event occurs set to 1 */
    QBitArray weekday() const;

/**
     * Return how many times the weekday represented by @param date occurs in
     * the month of @param date.
     */
    int weekdayCountForMonth(const QDate &date) const;

QDate currentDate() const;

private:
    Ui::EventOrTodoDesktop *mUi = nullptr;
    QDate mCurrentDate;
    IncidenceDateTime *mDateTime = nullptr;
    KCalCore::DateList mExceptionDates;

// So we can easily detect if the user changed the type,
    // without going through complicated recurrence logic:
    int mMonthlyInitialType = -1;
    int mYearlyInitialType = -1;
};
}

#endif
07070111A01968000081A40000000200000002000000015AA55A8600001EDE000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceresource.cpp/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#include "incidenceresource.h"
#include "resourcemanagement.h"
#include "resourcemodel.h"
#include "attendeecomboboxdelegate.h"
#include "attendeelineeditdelegate.h"
#include "incidencedatetime.h"

#include "ui_dialogdesktop.h"

#include <KDescendantsProxyModel>
#include <KEmailAddress>

#include <QCompleter>

using namespace IncidenceEditorNG;

class SwitchRoleProxy : public QSortFilterProxyModel
{
public:
    explicit SwitchRoleProxy(QObject *parent = nullptr)
        : QSortFilterProxyModel(parent)
    {
    }

QVariant data(const QModelIndex &index, int role) const override
    {
        QVariant d;
        if (role == Qt::DisplayRole || role == Qt::EditRole) {
            d = QSortFilterProxyModel::data(index, ResourceModel::FullName);
            return d;
        }
        d = QSortFilterProxyModel::data(index, role);
        return d;
    }
};

IncidenceResource::IncidenceResource(IncidenceAttendee *ieAttendee, IncidenceDateTime *dateTime,
                                     Ui::EventOrTodoDesktop *ui)
    : IncidenceEditor(nullptr)
    , mUi(ui)
    , dataModel(ieAttendee->dataModel())
    , mDateTime(dateTime)
    , resourceDialog(new ResourceManagement())
{
    setObjectName(QStringLiteral("IncidenceResource"));
    connect(resourceDialog, &ResourceManagement::accepted, this,
            &IncidenceResource::dialogOkPressed);

connect(mDateTime, &IncidenceDateTime::startDateChanged, this,
            &IncidenceResource::slotDateChanged);
    connect(mDateTime, &IncidenceDateTime::endDateChanged, this,
            &IncidenceResource::slotDateChanged);

QStringList attrs;
    attrs << QStringLiteral("cn") <<  QStringLiteral("mail");

completer = new QCompleter(this);
    ResourceModel *model = new ResourceModel(attrs, this);

KDescendantsProxyModel *proxyModel = new KDescendantsProxyModel(this);
    proxyModel->setSourceModel(model);
    SwitchRoleProxy *proxyModel2 = new SwitchRoleProxy(this);
    proxyModel2->setSourceModel(proxyModel);

completer->setModel(proxyModel2);
    completer->setCompletionRole(ResourceModel::FullName);
    completer->setWrapAround(false);
    mUi->mNewResource->setCompleter(completer);

AttendeeLineEditDelegate *attendeeDelegate = new AttendeeLineEditDelegate(this);

ResourceFilterProxyModel *filterProxyModel = new ResourceFilterProxyModel(this);
    filterProxyModel->setDynamicSortFilter(true);
    filterProxyModel->setSourceModel(dataModel);

mUi->mResourcesTable->setModel(filterProxyModel);
    mUi->mResourcesTable->setItemDelegateForColumn(AttendeeTableModel::Role,
                                                   ieAttendee->roleDelegate());
    mUi->mResourcesTable->setItemDelegateForColumn(AttendeeTableModel::FullName, attendeeDelegate);
    mUi->mResourcesTable->setItemDelegateForColumn(AttendeeTableModel::Status,
                                                   ieAttendee->stateDelegate());
    mUi->mResourcesTable->setItemDelegateForColumn(AttendeeTableModel::Response,
                                                   ieAttendee->responseDelegate());

connect(mUi->mFindResourcesButton, &QPushButton::clicked, this,
            &IncidenceResource::findResources);
    connect(mUi->mBookResourceButton, &QPushButton::clicked, this,
            &IncidenceResource::bookResource);
    connect(filterProxyModel, &ResourceFilterProxyModel::layoutChanged, this,
            &IncidenceResource::layoutChanged);
    connect(filterProxyModel, &ResourceFilterProxyModel::layoutChanged, this,
            &IncidenceResource::updateCount);
    connect(filterProxyModel, &ResourceFilterProxyModel::rowsInserted, this,
            &IncidenceResource::updateCount);
    connect(filterProxyModel, &ResourceFilterProxyModel::rowsRemoved, this,
            &IncidenceResource::updateCount);
    // only update when FullName is changed
    connect(filterProxyModel, &ResourceFilterProxyModel::dataChanged, this,
            &IncidenceResource::updateCount);
}

void IncidenceResource::load(const KCalCore::Incidence::Ptr &incidence)
{
    Q_UNUSED(incidence);
    slotDateChanged();
}

void IncidenceResource::slotDateChanged()
{
    resourceDialog->slotDateChanged(mDateTime->startDate(), mDateTime->endDate());
}

void IncidenceResource::save(const KCalCore::Incidence::Ptr &incidence)
{
    Q_UNUSED(incidence);
    //all logic inside IncidenceAtendee (using same model)
}

bool IncidenceResource::isDirty() const
{
    //all logic inside IncidenceAtendee (using same model)
    return false;
}

void IncidenceResource::bookResource()
{
    if (mUi->mNewResource->text().trimmed().isEmpty()) {
        return;
    }
    QString name, email;
    KEmailAddress::extractEmailAddressAndName(mUi->mNewResource->text(), email, name);
    KCalCore::Attendee::Ptr attendee(new KCalCore::Attendee(name, email));
    attendee->setCuType(KCalCore::Attendee::Resource);
    dataModel->insertAttendee(dataModel->rowCount(), attendee);
}

void IncidenceResource::findResources()
{
    resourceDialog->show();
}

void IncidenceResource::dialogOkPressed()
{
    ResourceItem::Ptr item = resourceDialog->selectedItem();
    if (item) {
        const QString name = QString::fromLatin1(item->ldapObject().value(QStringLiteral("cn")));
        const QString email = QString::fromLatin1(item->ldapObject().value(QStringLiteral("mail")));
        KCalCore::Attendee::Ptr attendee(new KCalCore::Attendee(name, email));
        attendee->setCuType(KCalCore::Attendee::Resource);
        dataModel->insertAttendee(dataModel->rowCount(), attendee);
    }
}

void IncidenceResource::layoutChanged()
{
    QHeaderView *headerView = mUi->mResourcesTable->horizontalHeader();
    headerView->setSectionHidden(AttendeeTableModel::CuType, true);
    headerView->setSectionHidden(AttendeeTableModel::Name, true);
    headerView->setSectionHidden(AttendeeTableModel::Email, true);
    headerView->setSectionResizeMode(AttendeeTableModel::Role, QHeaderView::ResizeToContents);
    headerView->setSectionResizeMode(AttendeeTableModel::FullName, QHeaderView::Stretch);
    headerView->setSectionResizeMode(AttendeeTableModel::Available, QHeaderView::ResizeToContents);
    headerView->setSectionResizeMode(AttendeeTableModel::Status, QHeaderView::ResizeToContents);
    headerView->setSectionResizeMode(AttendeeTableModel::Response, QHeaderView::ResizeToContents);
}

void IncidenceResource::updateCount()
{
    Q_EMIT resourceCountChanged(resourceCount());
}

int IncidenceResource::resourceCount() const
{
    int c = 0;
    QModelIndex index;
    QAbstractItemModel *model = mUi->mResourcesTable->model();
    if (!model) {
        return 0;
    }
    const int nbRow = model->rowCount(QModelIndex());
    for (int i = 0; i < nbRow; ++i) {
        index = model->index(i, AttendeeTableModel::FullName);
        if (!model->data(index).toString().isEmpty()) {
            ++c;
        }
    }
    return c;
}
07070111A01969000081A40000000200000002000000015AA55A8600000A27000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidenceresource.h/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#ifndef INCIDENCEEDITOR_INCIDENCERESOURCE_H
#define INCIDENCEEDITOR_INCIDENCERESOURCE_H

#include "incidenceeditor-ng.h"
#include "incidenceattendee.h"
#include "attendeetablemodel.h"

#include <QCompleter>

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class ResourceManagement;

class IncidenceResource : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual

explicit IncidenceResource(IncidenceAttendee *mIeAttendee, IncidenceDateTime *dateTime,
                               Ui::EventOrTodoDesktop *ui);

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;

/** resturn the count of resources */
    int resourceCount() const;

Q_SIGNALS:
    /** is emitted it the count of the resources is changed.
     * @arg: new count of resources.
     */
    void resourceCountChanged(int);
private:
    void findResources();
    void bookResource();
    void layoutChanged();
    void updateCount();

void slotDateChanged();

void dialogOkPressed();
    Ui::EventOrTodoDesktop *mUi = nullptr;

/** completer for findResources */
    QCompleter *completer = nullptr;

/** used dataModel to rely on*/
    AttendeeTableModel *dataModel = nullptr;
    IncidenceDateTime *mDateTime = nullptr;

ResourceManagement *resourceDialog = nullptr;
};
}

#endif
07070111A0196A000081A40000000200000002000000015AA55A8600000AB3000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencesecrecy.cpp/*
  Copyright (C) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "incidencesecrecy.h"
#include "ui_dialogdesktop.h"

#include <KCalUtils/Stringify>

using namespace IncidenceEditorNG;

IncidenceSecrecy::IncidenceSecrecy(Ui::EventOrTodoDesktop *ui)
    : mUi(ui)
{
    setObjectName(QStringLiteral("IncidenceSecrecy"));
    mUi->mSecrecyCombo->addItems(KCalUtils::Stringify::incidenceSecrecyList());
    connect(mUi->mSecrecyCombo, QOverload< int>::of(&KComboBox::currentIndexChanged), this, &IncidenceSecrecy::checkDirtyStatus);
}

void IncidenceSecrecy::load(const KCalCore::Incidence::Ptr &incidence)
{
    mLoadedIncidence = incidence;
    if (mLoadedIncidence) {
        Q_ASSERT(mUi->mSecrecyCombo->count()
                 == KCalUtils::Stringify::incidenceSecrecyList().count());
        mUi->mSecrecyCombo->setCurrentIndex(mLoadedIncidence->secrecy());

if (incidence->type() == KCalCore::Incidence::TypeJournal) {
            mUi->mSecrecyCombo->setVisible(false);
            mUi->mSecrecyLabel->setVisible(false);
        }
    } else {
        mUi->mSecrecyCombo->setCurrentIndex(0);
    }

mWasDirty = false;
}

void IncidenceSecrecy::save(const KCalCore::Incidence::Ptr &incidence)
{
    Q_ASSERT(incidence);
    switch (mUi->mSecrecyCombo->currentIndex()) {
    case 1:
        incidence->setSecrecy(KCalCore::Incidence::SecrecyPrivate);
        break;
    case 2:
        incidence->setSecrecy(KCalCore::Incidence::SecrecyConfidential);
        break;
    default:
        incidence->setSecrecy(KCalCore::Incidence::SecrecyPublic);
    }
}

bool IncidenceSecrecy::isDirty() const
{
    if (mLoadedIncidence) {
        if (mLoadedIncidence->secrecy() != mUi->mSecrecyCombo->currentIndex()) {
            return true;
        }
    } else {
        if (mUi->mSecrecyCombo->currentIndex() != 0) {
            return true;
        }
    }

return false;
}
07070111A0196B000081A40000000200000002000000015AA55A8600000680000000FD0000001000000000000000000000004A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencesecrecy.h/*
  Copyright (C) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_INCIDENCESECRECY_H
#define INCIDENCEEDITOR_INCIDENCESECRECY_H

#include "incidenceeditor-ng.h"

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
class IncidenceSecrecy : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual

explicit IncidenceSecrecy(Ui::EventOrTodoDesktop *ui);

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;

private:
    Ui::EventOrTodoDesktop *mUi = nullptr;
};
}

#endif
07070111A0196C000081A40000000200000002000000015AA55A8600000C19000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencewhatwhere.cpp/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "incidencewhatwhere.h"
#include "ui_dialogdesktop.h"

#include "incidenceeditor_debug.h"
#include <KLocalizedString>

using namespace IncidenceEditorNG;

IncidenceWhatWhere::IncidenceWhatWhere(Ui::EventOrTodoDesktop *ui)
    : IncidenceEditor(nullptr)
    , mUi(ui)
{
    setObjectName(QStringLiteral("IncidenceWhatWhere"));
    connect(mUi->mSummaryEdit, &QLineEdit::textChanged, this,
            &IncidenceWhatWhere::checkDirtyStatus);
    connect(mUi->mLocationEdit, &QLineEdit::textChanged, this,
            &IncidenceWhatWhere::checkDirtyStatus);
}

void IncidenceWhatWhere::load(const KCalCore::Incidence::Ptr &incidence)
{
    qCDebug(INCIDENCEEDITOR_LOG);
    mLoadedIncidence = incidence;
    if (mLoadedIncidence) {
        mUi->mSummaryEdit->setText(mLoadedIncidence->summary());
        mUi->mLocationEdit->setText(mLoadedIncidence->location());
    } else {
        mUi->mSummaryEdit->clear();
        mUi->mLocationEdit->clear();
    }

mUi->mLocationEdit->setVisible(type() != KCalCore::Incidence::TypeJournal);
    mUi->mLocationLabel->setVisible(type() != KCalCore::Incidence::TypeJournal);

mWasDirty = false;
}

void IncidenceWhatWhere::save(const KCalCore::Incidence::Ptr &incidence)
{
    Q_ASSERT(incidence);
    incidence->setSummary(mUi->mSummaryEdit->text());
    incidence->setLocation(mUi->mLocationEdit->text());
}

bool IncidenceWhatWhere::isDirty() const
{
    if (mLoadedIncidence) {
        return
            (mUi->mSummaryEdit->text() != mLoadedIncidence->summary())
            || (mUi->mLocationEdit->text() != mLoadedIncidence->location());
    } else {
        return
            mUi->mSummaryEdit->text().isEmpty()
            && mUi->mLocationEdit->text().isEmpty();
    }
}

bool IncidenceWhatWhere::isValid() const
{
    if (mUi->mSummaryEdit->text().isEmpty()) {
        qCDebug(INCIDENCEEDITOR_LOG) << "Specify a title";
        mLastErrorString = i18nc("@info", "Please specify a title.");
        return false;
    } else {
        mLastErrorString.clear();
        return true;
    }
}

void IncidenceWhatWhere::validate()
{
    if (mUi->mSummaryEdit->text().isEmpty()) {
        mUi->mSummaryEdit->setFocus();
    }
}
07070111A0196D000081A40000000200000002000000015AA55A860000075C000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/incidencewhatwhere.h/*
  Copyright (c) 2010 Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_INCIDENCEWHATWHERE_H
#define INCIDENCEEDITOR_INCIDENCEWHATWHERE_H

#include "incidenceeditor-ng.h"

namespace Ui {
class EventOrTodoDesktop;
}

namespace IncidenceEditorNG {
/**
 * The IncidenceGeneralEditor keeps track of the following Incidence parts:
 * - Summary
 * - Location
 * - Categories
 */
class IncidenceWhatWhere : public IncidenceEditor
{
    Q_OBJECT
public:
    using IncidenceEditorNG::IncidenceEditor::save; // So we don't trigger -Woverloaded-virtual
    using IncidenceEditorNG::IncidenceEditor::load; // So we don't trigger -Woverloaded-virtual

explicit IncidenceWhatWhere(Ui::EventOrTodoDesktop *ui);

void load(const KCalCore::Incidence::Ptr &incidence) override;
    void save(const KCalCore::Incidence::Ptr &incidence) override;
    bool isDirty() const override;
    bool isValid() const override;
    virtual void validate();

private:
    Ui::EventOrTodoDesktop *mUi = nullptr;
};
} // IncidenceEditorNG

#endif
07070111A0196E000081A40000000200000002000000015AA55A8600003121000000FD0000001000000000000000000000005A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/individualmailcomponentfactory.cpp/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#include "individualmailcomponentfactory.h"
#include "individualmaildialog.h"

#include <CalendarSupport/KCalPrefs>

#include <KMessageBox>

#include <QDBusConnection>
#include <QDBusConnectionInterface>

using namespace IncidenceEditorNG;

// IndividualMessageQueueJob

IndividualMessageQueueJob::IndividualMessageQueueJob(const KIdentityManagement::Identity &identity,
                                                     const KCalCore::Attendee::List &update,
                                                     const KCalCore::Attendee::List &edit,
                                                     QObject *parent)
    : MailTransport::MessageQueueJob(parent)
    , mUpdate(update)
    , mEdit(edit)
    , mIdentity(identity)
    , mQueueJob(nullptr)
    , mComposerJob(nullptr)
{
}

void IndividualMessageQueueJob::start()
{
    QSet<QString> attendeesTo(QSet<QString>::fromList(addressAttribute().to()));
    QSet<QString> attendeesCc(QSet<QString>::fromList(addressAttribute().cc()));

QStringList attendeesAutoTo, attendeesAutoCc;
    for (const KCalCore::Attendee::Ptr &attendee : qAsConst(mUpdate)) {
        if (attendeesTo.contains(attendee->email())) {
            attendeesAutoTo.append(attendee->fullName());
        }
        if (attendeesCc.contains(attendee->email())) {
            attendeesAutoCc.append(attendee->fullName());
        }
    }
    if (!attendeesAutoTo.isEmpty() || !attendeesAutoCc.isEmpty()
        || !addressAttribute().bcc().isEmpty()) {
        startQueueJob(attendeesAutoTo, addressAttribute().to(), attendeesAutoCc, addressAttribute().cc());
    }

QStringList attendeesComposerTo, attendeesComposerCc;
    for (const KCalCore::Attendee::Ptr &attendee : qAsConst(mEdit)) {
        if (attendeesTo.contains(attendee->email())) {
            attendeesComposerTo.append(attendee->fullName());
        }
        if (attendeesCc.contains(attendee->email())) {
            attendeesComposerCc.append(attendee->fullName());
        }
    }
    if (!attendeesComposerTo.isEmpty() || !attendeesComposerCc.isEmpty()) {
        startComposerJob(attendeesComposerTo, attendeesComposerCc);
    }

// No subjob has been started
    if (!mQueueJob && !mComposerJob) {
        emitResult();
    }
}

void IndividualMessageQueueJob::startQueueJob(const QStringList &messageTo, const QStringList &to, const QStringList &messageCc, const QStringList &cc)
{
    KMime::Message::Ptr msg(message());
    msg->to()->fromUnicodeString(messageTo.join(QStringLiteral(", ")), "utf-8");
    msg->cc()->fromUnicodeString(messageCc.join(QStringLiteral(", ")), "utf-8");
    msg->assemble();

mQueueJob = new MailTransport::MessageQueueJob(this);
    mQueueJob->setMessage(msg);
    mQueueJob->transportAttribute().setTransportId(mIdentity.isNull() ? transportAttribute().transportId() : mIdentity.transport().toInt());
    mQueueJob->addressAttribute().setFrom(addressAttribute().from());
    mQueueJob->addressAttribute().setTo(to);
    mQueueJob->addressAttribute().setCc(cc);
    mQueueJob->addressAttribute().setBcc(addressAttribute().bcc());

if (mIdentity.disabledFcc()) {
        mQueueJob->sentBehaviourAttribute().setSentBehaviour(MailTransport::SentBehaviourAttribute::Delete);
    } else {
        const Akonadi::Collection sentCollection(mIdentity.fcc().toLongLong());
        if (sentCollection.isValid()) {
            mQueueJob->sentBehaviourAttribute().setSentBehaviour(MailTransport::SentBehaviourAttribute::MoveToCollection);
            mQueueJob->sentBehaviourAttribute().setMoveToCollection(sentCollection);
        } else {
            mQueueJob->sentBehaviourAttribute().setSentBehaviour(
                MailTransport::SentBehaviourAttribute::MoveToDefaultSentCollection);
        }
    }

connect(mQueueJob, &MailTransport::MessageQueueJob::finished, this,
            &IndividualMessageQueueJob::handleJobFinished);
    mQueueJob->start();
}

void IndividualMessageQueueJob::startComposerJob(const QStringList &to, const QStringList &cc)
{
    mComposerJob
        = new OpenComposerJob(this, to.join(QStringLiteral(", ")), cc.join(QStringLiteral(
                                                                               ", ")),
                              QString(), message(), mIdentity);
    connect(mComposerJob, &OpenComposerJob::finished, this,
            &IndividualMessageQueueJob::handleJobFinished);
    mComposerJob->start();
}

void IndividualMessageQueueJob::handleJobFinished(KJob *job)
{
    if (job->error()) {
        if (job == mQueueJob && mComposerJob) {
            mComposerJob->kill();
            mComposerJob = nullptr;
        } else if (job == mComposerJob && mQueueJob) {
            mQueueJob->kill();
            mQueueJob = nullptr;
        }
        setError(job->error());
        setErrorText(job->errorString());
        emitResult();
        return;
    }
    if (job == mQueueJob) {
        if (!mComposerJob) {
            emitResult();
        }
        mQueueJob = nullptr;
    } else {
        if (!mQueueJob) {
            emitResult();
        }
        mComposerJob = nullptr;
    }
}

// IndividualMailAskDelegator

IndividualMailITIPHandlerDialogDelegate::IndividualMailITIPHandlerDialogDelegate(
    const KCalCore::Incidence::Ptr &incidence, KCalCore::iTIPMethod method, QWidget *parent)
    : Akonadi::ITIPHandlerDialogDelegate(incidence, method, parent)
    , mDialog(nullptr)
{
}

void IndividualMailITIPHandlerDialogDelegate::openDialog(const QString &question,
                                                         const KCalCore::Attendee::List &attendees,
                                                         Action action, const KGuiItem &buttonYes,
                                                         const KGuiItem &buttonNo)
{
    switch (action) {
    case ActionSendMessage:
        Q_EMIT setUpdate(mIncidence, attendees);
        Q_EMIT dialogClosed(KMessageBox::Yes, mMethod, mIncidence);
        break;
    case ActionDontSendMessage:
        Q_EMIT dialogClosed(KMessageBox::No, mMethod, mIncidence);
        break;
    default:
        switch (CalendarSupport::KCalPrefs::instance()->sendPolicy()) {
        case (CalendarSupport::KCalPrefs::InvitationPolicySend):
            Q_EMIT setUpdate(mIncidence, attendees);
            Q_EMIT dialogClosed(KMessageBox::Yes, mMethod, mIncidence);
            break;
        case (CalendarSupport::KCalPrefs::InvitationPolicyDontSend):
            Q_EMIT dialogClosed(KMessageBox::No, mMethod, mIncidence);
            break;
        case (CalendarSupport::KCalPrefs::InvitationPolicyAsk):
        default:
            mDialog = new IndividualMailDialog(question, attendees, buttonYes, buttonNo, mParent);
            connect(mDialog, &QDialog::finished, this,
                    &IndividualMailITIPHandlerDialogDelegate::onDialogClosed);
            mDialog->show();
            break;
        }
        break;
    }
}

void IndividualMailITIPHandlerDialogDelegate::openDialogIncidenceCreated(Recipient recipient,
                                                                         const QString &question,
                                                                         Action action,
                                                                         const KGuiItem &buttonYes,
                                                                         const KGuiItem &buttonNo)
{
    if (recipient == Attendees) {
        openDialog(question, mIncidence->attendees(), action, buttonYes, buttonNo);
    } else {
        KCalCore::Attendee::Ptr organizer(new KCalCore::Attendee(
                                              mIncidence->organizer()->name(),
                                              mIncidence->organizer()->email()));
        openDialog(question, KCalCore::Attendee::List() << organizer, action, buttonYes, buttonNo);
    }
}

void IndividualMailITIPHandlerDialogDelegate::openDialogIncidenceModified(
    bool attendeeStatusChanged, Recipient recipient, const QString &question, Action action,
    const KGuiItem &buttonYes, const KGuiItem &buttonNo)
{
    Q_UNUSED(attendeeStatusChanged);
    if (recipient == Attendees) {
        openDialog(question, mIncidence->attendees(), action, buttonYes, buttonNo);
    } else {
        KCalCore::Attendee::Ptr organizer(new KCalCore::Attendee(
                                              mIncidence->organizer()->name(),
                                              mIncidence->organizer()->email()));
        openDialog(question, KCalCore::Attendee::List() << organizer, action, buttonYes, buttonNo);
    }
}

void IndividualMailITIPHandlerDialogDelegate::openDialogIncidenceDeleted(Recipient recipient,
                                                                         const QString &question,
                                                                         Action action,
                                                                         const KGuiItem &buttonYes,
                                                                         const KGuiItem &buttonNo)
{
    if (recipient == Attendees) {
        openDialog(question, mIncidence->attendees(), action, buttonYes, buttonNo);
    } else {
        KCalCore::Attendee::Ptr organizer(new KCalCore::Attendee(
                                              mIncidence->organizer()->name(),
                                              mIncidence->organizer()->email()));
        openDialog(question, KCalCore::Attendee::List() << organizer, action, buttonYes, buttonNo);
    }
}

void IndividualMailITIPHandlerDialogDelegate::onDialogClosed(int result)
{
    if (result == QDialogButtonBox::Yes) {
        Q_EMIT setEdit(mIncidence, mDialog->editAttendees());
        Q_EMIT setUpdate(mIncidence, mDialog->updateAttendees());
        Q_EMIT dialogClosed(KMessageBox::Yes, mMethod, mIncidence);
    } else {
        Q_EMIT dialogClosed(KMessageBox::No, mMethod, mIncidence);
    }
}

// IndividualMailJobFactory
IndividualMailComponentFactory::IndividualMailComponentFactory(QObject *parent)
    : Akonadi::ITIPHandlerComponentFactory(parent)
{
}

MailTransport::MessageQueueJob *IndividualMailComponentFactory::createMessageQueueJob(
    const KCalCore::IncidenceBase::Ptr &incidence, const KIdentityManagement::Identity &identity,
    QObject *parent)
{
    return new IndividualMessageQueueJob(identity, mUpdate.take(incidence->uid()),
                                         mEdit.take(incidence->uid()), parent);
}

Akonadi::ITIPHandlerDialogDelegate *IndividualMailComponentFactory::createITIPHanderDialogDelegate(
    const KCalCore::Incidence::Ptr &incidence, KCalCore::iTIPMethod method, QWidget *parent)
{
    IndividualMailITIPHandlerDialogDelegate *askDelegator
        = new IndividualMailITIPHandlerDialogDelegate(incidence, method, parent);
    connect(askDelegator, &IndividualMailITIPHandlerDialogDelegate::setEdit, this,
            &IndividualMailComponentFactory::onSetEdit);
    connect(askDelegator, &IndividualMailITIPHandlerDialogDelegate::setUpdate, this,
            &IndividualMailComponentFactory::onSetUpdate);

return askDelegator;
}

void IndividualMailComponentFactory::onSetEdit(const KCalCore::Incidence::Ptr &incidence,
                                               const KCalCore::Attendee::List &edit)
{
    mEdit[incidence->uid()] = edit;
}

void IndividualMailComponentFactory::onSetUpdate(const KCalCore::Incidence::Ptr &incidence,
                                                 const KCalCore::Attendee::List &update)
{
    mUpdate[incidence->uid()] = update;
}
07070111A0196F000081A40000000200000002000000015AA55A8600001407000000FD0000001000000000000000000000005800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/individualmailcomponentfactory.h/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#ifndef INCIDENCEEDITOR_INDIVIDUALMAILCOMPONENTFACTORY_H
#define INCIDENCEEDITOR_INDIVIDUALMAILCOMPONENTFACTORY_H

#include "incidenceeditor_export.h"

#include "opencomposerjob.h"

#include <mailtransportakonadi/messagequeuejob.h>
#include <Akonadi/Calendar/IncidenceChanger>

namespace IncidenceEditorNG {
class IndividualMailDialog;

class IndividualMessageQueueJob : public MailTransport::MessageQueueJob
{
    Q_OBJECT
public:
    explicit IndividualMessageQueueJob(const KIdentityManagement::Identity &identity,
                                       const KCalCore::Attendee::List &update,
                                       const KCalCore::Attendee::List &edit, QObject *parent);

void start() override;

private:
    void startQueueJob(const QStringList &messageTo, const QStringList &to,
                       const QStringList &messageCc, const QStringList &cc);
    void startComposerJob(const QStringList &to, const QStringList &cc);
    void handleJobFinished(KJob *job);
    KCalCore::Attendee::List mUpdate;
    KCalCore::Attendee::List mEdit;
    KIdentityManagement::Identity mIdentity;
    MailTransport::MessageQueueJob *mQueueJob = nullptr;
    OpenComposerJob *mComposerJob = nullptr;
};

class IndividualMailITIPHandlerDialogDelegate : public Akonadi::ITIPHandlerDialogDelegate
{
    Q_OBJECT
public:

explicit IndividualMailITIPHandlerDialogDelegate(const KCalCore::Incidence::Ptr &incidence,
                                                     KCalCore::iTIPMethod method, QWidget *parent);

void openDialogIncidenceCreated(
        Recipient recipient,
        const QString &question,
        Action action = ActionAsk,
        const KGuiItem &buttonYes = KGuiItem(i18nc("@action:button dialog positive answer", "Send Email")),
        const KGuiItem &buttonNo = KGuiItem(i18nc("@action:button dialog negative answer", "Do Not Send"))) override;

void openDialogIncidenceModified(
        bool attendeeStatusChanged,
        Recipient recipient,
        const QString &question,
        Action action = ActionAsk,
        const KGuiItem &buttonYes = KGuiItem(i18nc("@action:button dialog positive answer", "Send Email")),
        const KGuiItem &buttonNo = KGuiItem(i18nc("@action:button dialog negative answer", "Do Not Send"))) override;

void openDialogIncidenceDeleted(
        Recipient recipient,
        const QString &question,
        Action action = ActionAsk,
        const KGuiItem &buttonYes = KGuiItem(i18nc("@action:button dialog positive answer", "Send Email")),
        const KGuiItem &buttonNo = KGuiItem(i18nc("@action:button dialog negative answer", "Do Not Send"))) override;

Q_SIGNALS:
    void setEdit(const KCalCore::Incidence::Ptr &incidence, const KCalCore::Attendee::List &edit);
    void setUpdate(const KCalCore::Incidence::Ptr &incidence,
                   const KCalCore::Attendee::List &update);

protected:
    void openDialog(const QString &question, const KCalCore::Attendee::List &attendees,
                    Action action, const KGuiItem &buttonYes, const KGuiItem &buttonNo);

private:
    void onDialogClosed(int result);
    IndividualMailDialog *mDialog = nullptr;
};

class INCIDENCEEDITOR_EXPORT IndividualMailComponentFactory : public Akonadi::
    ITIPHandlerComponentFactory
{
    Q_OBJECT
public:
    explicit IndividualMailComponentFactory(QObject *parent = nullptr);
    MailTransport::MessageQueueJob *createMessageQueueJob(
        const KCalCore::IncidenceBase::Ptr &incidence,
        const KIdentityManagement::Identity &identity, QObject *parent) override;

Akonadi::ITIPHandlerDialogDelegate *createITIPHanderDialogDelegate(
        const KCalCore::Incidence::Ptr &incidence, KCalCore::iTIPMethod method,
        QWidget *parent) override;

public Q_SLOTS:
    void onSetEdit(const KCalCore::Incidence::Ptr &incidence, const KCalCore::Attendee::List &edit);
    void onSetUpdate(const KCalCore::Incidence::Ptr &incidence,
                     const KCalCore::Attendee::List &update);

private:
    QHash<QString, KCalCore::Attendee::List> mEdit;
    QHash<QString, KCalCore::Attendee::List> mUpdate;
};
}
#endif
07070111A01970000081A40000000200000002000000015AA55A8600001428000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/individualmaildialog.cpp/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#include "individualmaildialog.h"

#include <KGuiItem>
#include <KLocalizedString>

#include <QDialogButtonBox>
#include <QGridLayout>
#include <QComboBox>
#include <QLabel>
#include <QPushButton>

using namespace IncidenceEditorNG;

IndividualMailDialog::IndividualMailDialog(const QString &question,
                                           const KCalCore::Attendee::List &attendees,
                                           const KGuiItem &buttonYes, const KGuiItem &buttonNo,
                                           QWidget *parent)
    : QDialog(parent)
{
    setWindowTitle(i18nc("@title:window", "Group Scheduling Email"));
    m_detailsWidget = new QWidget();
    QGridLayout *layout = new QGridLayout(m_detailsWidget);
    int row = 0;
    for (const KCalCore::Attendee::Ptr &attendee : attendees) {
        QComboBox *options = new QComboBox();
        options->addItem(i18nc("@item:inlistbox ITIP Messages for one attendee",
                               "Send update"), QVariant(Update));
        options->addItem(i18nc("@item:inlistbox ITIP Messages for one attendee",
                               "Send no update"), QVariant(NoUpdate));
        options->addItem(i18nc("@item:inlistbox ITIP Messages for one attendee",
                               "Edit mail"), QVariant(Edit));
        mAttendeeDecision[attendee] = options;

layout->addWidget(new QLabel(attendee->fullName()), row, 0);
        layout->addWidget(options, row, 1);
        ++row;
    }
    QSizePolicy sizePolicy = m_detailsWidget->sizePolicy();
    sizePolicy.setHorizontalStretch(1);
    sizePolicy.setVerticalStretch(1);
    m_detailsWidget->setSizePolicy(sizePolicy);

QWidget *mW = new QLabel(question);

auto topLayout = new QVBoxLayout(this);
    topLayout->addWidget(mW);
    topLayout->addWidget(m_detailsWidget);

m_buttons = new QDialogButtonBox(this);
    m_buttons->setStandardButtons(
        QDialogButtonBox::Yes | QDialogButtonBox::No | QDialogButtonBox::Help);
    auto yesButton = m_buttons->button(QDialogButtonBox::Yes);
    yesButton->setText(buttonYes.text());
    connect(yesButton, &QPushButton::clicked, this, [this]() {
        done(QDialogButtonBox::Yes);
    });
    auto noButton = m_buttons->button(QDialogButtonBox::No);
    noButton->setText(buttonNo.text());
    connect(noButton, &QPushButton::clicked, this, [this]() {
        done(QDialogButtonBox::No);
    });
    auto detailsButton = m_buttons->button(QDialogButtonBox::Help);
    detailsButton->setIcon(QIcon::fromTheme(QLatin1String("help-about")));
    connect(detailsButton, &QPushButton::clicked, this, [this]() {
        m_detailsWidget->setVisible(!m_detailsWidget->isVisible());
        updateButtonState();
        adjustSize();
    });
    m_detailsWidget->setVisible(false);
    updateButtonState();

topLayout->addWidget(m_buttons);
}

IndividualMailDialog::~IndividualMailDialog()
{
}

KCalCore::Attendee::List IndividualMailDialog::editAttendees() const
{
    KCalCore::Attendee::List edit;
    for (auto it = mAttendeeDecision.cbegin(), end = mAttendeeDecision.cend(); it != end; ++it) {
        int index = it.value()->currentIndex();
        if (it.value()->itemData(index, Qt::UserRole) == Edit) {
            edit.append(it.key());
        }
    }
    return edit;
}

KCalCore::Attendee::List IndividualMailDialog::updateAttendees() const
{
    KCalCore::Attendee::List update;
    for (auto it = mAttendeeDecision.cbegin(), end = mAttendeeDecision.cend(); it != end; ++it) {
        int index = it.value()->currentIndex();
        if (it.value()->itemData(index, Qt::UserRole) == Update) {
            update.append(it.key());
        }
    }
    return update;
}

void IndividualMailDialog::updateButtonState()
{
    auto detailsButton = m_buttons->button(QDialogButtonBox::Help);
    if (m_detailsWidget->isVisible()) {
        detailsButton->setText(i18nc("@action:button show list of attendees",
                                     "Individual mailsettings <<"));
    } else {
        detailsButton->setText(i18nc("@action:button show list of attendees",
                                     "Individual mailsettings >>"));
    }
}
07070111A01971000081A40000000200000002000000015AA55A860000096D000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/individualmaildialog.h/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#ifndef INCIDENCEEDITOR_INDIVIDUALMAILDIALOG_H
#define INCIDENCEEDITOR_INDIVIDUALMAILDIALOG_H

#include <KCalCore/Attendee>
#include <QDialog>

#include <QComboBox>
#include <QDialogButtonBox>

class KGuiItem;

class TestIndividualMailDialog;

namespace IncidenceEditorNG {
// Shows a dialog with a question and the option to select which attendee should get the mail or to open a composer for him.
// Used to get individual mails for attendees of an event.
class IndividualMailDialog : public QDialog
{
    Q_OBJECT
    friend class ::TestIndividualMailDialog;
public:
    enum Decisions {
        Update,         /**< send automatic mail to attendee */
        NoUpdate,       /**< do not send mail to attendee */
        Edit            /**< open composer for attendee */
    };
    explicit IndividualMailDialog(const QString &question,
                                  const KCalCore::Attendee::List &attendees,
                                  const KGuiItem &buttonYes, const KGuiItem &buttonNo,
                                  QWidget *parent = nullptr);
    ~IndividualMailDialog() override;

KCalCore::Attendee::List editAttendees() const;
    KCalCore::Attendee::List updateAttendees() const;

private:
    void updateButtonState();

QHash<KCalCore::Attendee::Ptr, QComboBox *> mAttendeeDecision;
    QDialogButtonBox *m_buttons = nullptr;
    QWidget *m_detailsWidget = nullptr;
};
}

#endif
07070111A01972000081A40000000200000002000000015AA55A8600000E8B000000FD0000001000000000000000000000005200000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/korganizereditorconfig.cpp/*
  Copyright (c) 2010 Kevin Ottens <ervin@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 "korganizereditorconfig.h"

#include <CalendarSupport/KCalPrefs>

using namespace IncidenceEditorNG;

KOrganizerEditorConfig::KOrganizerEditorConfig()
    : EditorConfig()
{
}

KOrganizerEditorConfig::~KOrganizerEditorConfig()
{
}

KConfigSkeleton *KOrganizerEditorConfig::config() const
{
    return CalendarSupport::KCalPrefs::instance();
}

QString KOrganizerEditorConfig::fullName() const
{
    return CalendarSupport::KCalPrefs::instance()->fullName();
}

QString KOrganizerEditorConfig::email() const
{
    return CalendarSupport::KCalPrefs::instance()->email();
}

bool KOrganizerEditorConfig::thatIsMe(const QString &email) const
{
    return CalendarSupport::KCalPrefs::instance()->thatIsMe(email);
}

QStringList KOrganizerEditorConfig::allEmails() const
{
    return CalendarSupport::KCalPrefs::instance()->allEmails();
}

QStringList KOrganizerEditorConfig::fullEmails() const
{
    return CalendarSupport::KCalPrefs::instance()->fullEmails();
}

bool KOrganizerEditorConfig::showTimeZoneSelectorInIncidenceEditor() const
{
    return CalendarSupport::KCalPrefs::instance()->showTimeZoneSelectorInIncidenceEditor();
}

QDateTime KOrganizerEditorConfig::defaultDuration() const
{
    return CalendarSupport::KCalPrefs::instance()->defaultDuration();
}

QDateTime KOrganizerEditorConfig::startTime() const
{
    return CalendarSupport::KCalPrefs::instance()->startTime();
}

bool KOrganizerEditorConfig::defaultAudioFileReminders() const
{
    return CalendarSupport::KCalPrefs::instance()->defaultAudioFileReminders();
}

QUrl KOrganizerEditorConfig::audioFilePath() const
{
    return QUrl::fromLocalFile(CalendarSupport::KCalPrefs::instance()->audioFilePath());
}

int KOrganizerEditorConfig::reminderTime() const
{
    return CalendarSupport::KCalPrefs::instance()->reminderTime();
}

int KOrganizerEditorConfig::reminderTimeUnits() const
{
    return CalendarSupport::KCalPrefs::instance()->reminderTimeUnits();
}

bool KOrganizerEditorConfig::defaultTodoReminders() const
{
    return CalendarSupport::KCalPrefs::instance()->defaultTodoReminders();
}

bool KOrganizerEditorConfig::defaultEventReminders() const
{
    return CalendarSupport::KCalPrefs::instance()->defaultEventReminders();
}

QStringList KOrganizerEditorConfig::activeDesignerFields() const
{
    return CalendarSupport::KCalPrefs::instance()->activeDesignerFields();
}

QStringList &KOrganizerEditorConfig::templates(KCalCore::IncidenceBase::IncidenceType type)
{
    if (type == KCalCore::IncidenceBase::TypeEvent) {
        //TODO remove mEventTemplates+etc from Prefs::instance()
        return CalendarSupport::KCalPrefs::instance()->mEventTemplates;
    }
    if (type == KCalCore::IncidenceBase::TypeTodo) {
        return CalendarSupport::KCalPrefs::instance()->mTodoTemplates;
    }
    if (type == KCalCore::IncidenceBase::TypeJournal) {
        return CalendarSupport::KCalPrefs::instance()->mJournalTemplates;
    }
    return EditorConfig::templates(type);
}
07070111A01973000081A40000000200000002000000015AA55A86000007C6000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/korganizereditorconfig.h/*
  Copyright (c) 2010 Kevin Ottens <ervin@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 INCIDENCEEDITOR_KORGANIZEREDITORCONFIG_H
#define INCIDENCEEDITOR_KORGANIZEREDITORCONFIG_H

#include "editorconfig.h"

#include <KCalCore/IncidenceBase>

namespace IncidenceEditorNG {
class INCIDENCEEDITOR_EXPORT KOrganizerEditorConfig : public IncidenceEditorNG::EditorConfig
{
public:
    KOrganizerEditorConfig();
    ~KOrganizerEditorConfig() override;

KConfigSkeleton *config() const override;
    QString fullName() const override;
    QString email() const override;
    bool thatIsMe(const QString &email) const override;
    QStringList allEmails() const override;
    QStringList fullEmails() const override;
    bool showTimeZoneSelectorInIncidenceEditor() const override;
    QDateTime defaultDuration() const override;
    QDateTime startTime() const override;
    bool defaultAudioFileReminders() const override;
    QUrl audioFilePath() const override;
    int reminderTime() const override;
    int reminderTimeUnits() const override;
    bool defaultTodoReminders() const override;
    bool defaultEventReminders() const override;
    QStringList activeDesignerFields() const override;
    QStringList &templates(KCalCore::IncidenceBase::IncidenceType type) override;
};
} // IncidenceEditors

#endif
07070111A01974000081A40000000200000002000000015AA55A8600000E9F000000FD0000001000000000000000000000004D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ktimezonecombobox.cpp/*
  Copyright (C) 2007 Bruno Virlet <bruno.virlet@gmail.com>
  Copyright 2008-2009,2013 Allen Winter <winter@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 "ktimezonecombobox.h"

#include <KLocalizedString>

#include <QTimeZone>
#include <QVector>

using namespace IncidenceEditorNG;

class Q_DECL_HIDDEN KTimeZoneComboBox::Private
{
public:
    Private(KTimeZoneComboBox *parent)
        : mParent(parent)
    {
    }

void fillComboBox();
    KTimeZoneComboBox *const mParent;
    QVector<QByteArray> mZones;
};

void KTimeZoneComboBox::Private::fillComboBox()
{
    mParent->clear();
    mZones.clear();

// Read all system time zones
    const QList<QByteArray> lstTimeZoneIds = QTimeZone::availableTimeZoneIds();
    mZones.reserve(lstTimeZoneIds.count());
    std::copy(lstTimeZoneIds.begin(), lstTimeZoneIds.end(), std::back_inserter(mZones));
    std::sort(mZones.begin(), mZones.end());

// Prepend Local, UTC and Floating, for convenience
    mZones.prepend("UTC");        // do not use i18n here  index=2
    mZones.prepend("Floating");   // do not use i18n here  index=1
    mZones.prepend(QTimeZone::systemTimeZoneId());    // index=0

// Put translated zones into the combobox
    for (const auto &z : qAsConst(mZones)) {
        mParent->addItem(i18n(z.constData()).replace(QLatin1Char('_'), QLatin1Char(' ')));
    }
}

KTimeZoneComboBox::KTimeZoneComboBox(QWidget *parent)
    : KComboBox(parent)
    , d(new KTimeZoneComboBox::Private(this))
{
    d->fillComboBox();
}

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

void KTimeZoneComboBox::selectTimeZone(const QTimeZone &zone)
{
    int nCurrentlySet = -1;

int i = 0;
    for (const auto &z : qAsConst(d->mZones)) {
        if (z == zone.id()) {
            nCurrentlySet = i;
            break;
        }
        ++i;
    }

if (nCurrentlySet == -1) {
        if (zone == QTimeZone::utc()) {
            setCurrentIndex(2);   // UTC
        } else if (zone == QTimeZone::systemTimeZone()) {
            setCurrentIndex(0);   // Local
        } else {
            setCurrentIndex(1);   // Floating event
        }
    } else {
        setCurrentIndex(nCurrentlySet);
    }
}

QTimeZone KTimeZoneComboBox::selectedTimeZone() const
{
    QTimeZone zone;
    if (currentIndex() >= 0) {
        if (currentIndex() == 0) {   // Local
            zone = QTimeZone::systemTimeZone();
        } else if (currentIndex() == 1) {   // Floating event
            zone = QTimeZone::systemTimeZone();
        } else if (currentIndex() == 2) {   // UTC
            zone = QTimeZone::utc();
        } else {
            zone = QTimeZone(d->mZones[currentIndex()]);
        }
    }

return zone;
}

void KTimeZoneComboBox::selectLocalTimeZone()
{
    selectTimeZone(QTimeZone::systemTimeZone());
}

void KTimeZoneComboBox::setFloating(bool floating, const QTimeZone &zone)
{
    if (floating) {
        setCurrentIndex(1);
    } else {
        if (zone.isValid()) {
            selectTimeZone(zone);
        } else {
            selectLocalTimeZone();
        }
    }
}
07070111A01975000081A40000000200000002000000015AA55A8600000A1B000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ktimezonecombobox.h/*
  Copyright (C) 2007 Bruno Virlet <bruno.virlet@gmail.com>
  Copyright 2008-2009 Allen Winter <winter@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 INCIDENCEEDITOR_KTIMEZONECOMBOBOX_H
#define INCIDENCEEDITOR_KTIMEZONECOMBOBOX_H

#include "incidenceeditor_export.h"

#include <KComboBox>
#include <QTimeZone>

namespace IncidenceEditorNG {
/**
 * A combobox that shows the system timezones available in QTimeZone
 * and provides methods to easily select the item corresponding to a given
 * QTimeZone or to retrieve the QTimeZone associated with the
 * selected item.
 */
class INCIDENCEEDITOR_EXPORT KTimeZoneComboBox : public KComboBox
{
    Q_OBJECT
public:
    /**
     * Creates a new time zone combobox.
     *
     * @param parent The parent widget.
     */
    explicit KTimeZoneComboBox(QWidget *parent = nullptr);

/**
     * Destroys the time zone combobox.
     */
    ~KTimeZoneComboBox();

/**
     * Selects the item in the combobox corresponding to the given @p zone.
     */
    void selectTimeZone(const QTimeZone &zone);

/**
     * Convenience version of selectTimeZone(const QTimeZone &).
     * Selects the local time zone specified in the user settings.
     */
    void selectLocalTimeZone();

/**
     * If @p floating is true, selects floating time zone, otherwise
     * if @zone is valid, selects @pzone time zone, if not selects
     * local time zone.
     */
    void setFloating(bool floating, const QTimeZone &zone = {});

/**
     * Return the time zone associated with the currently selected item.
     */
    QTimeZone selectedTimeZone() const;

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
}

#endif
07070111A01976000081A40000000200000002000000015AA55A860000085D000000FD0000001000000000000000000000004500000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ldaputils.cpp/*
 * Copyright 2014  Sandro Knauß <knauss@kolabsys.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) 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 <http://www.gnu.org/licenses/>.
 *
 */

#include "ldaputils.h"
#include <KLocalizedString>

QString IncidenceEditorNG::translateLDAPAttributeForDisplay(const QString &attribute)
{
    QString ret = attribute;
    if (attribute == QLatin1String("cn")) {
        ret = i18nc("ldap attribute cn", "Common name");
    } else if (attribute == QLatin1String("mail")) {
        ret = i18nc("ldap attribute mail", "Email");
    } else if (attribute == QLatin1String("givenname")) {
        ret = i18nc("ldap attribute givenname", "Given name");
    } else if (attribute == QLatin1String("sn")) {
        ret = i18nc("ldap attribute sn", "Surname");
    } else if (attribute == QLatin1String("ou")) {
        ret = i18nc("ldap attribute ou", "Organization");
    } else if (attribute == QLatin1String("objectClass")) {
        ret = i18nc("ldap attribute objectClass", "Object class");
    } else if (attribute == QLatin1String("description")) {
        ret = i18nc("ldap attribute description", "Description");
    } else if (attribute == QLatin1String("telephoneNumber")) {
        ret = i18nc("ldap attribute telephoneNumber", "Telephone");
    } else if (attribute == QLatin1String("mobile")) {
        ret = i18nc("ldap attribute mobile", "Mobile");
    }
    return ret;
}
07070111A01978000081A40000000200000002000000015AA55A8600000464000000FD0000001000000000000000000000004300000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ldaputils.h/*
 * Copyright 2014  Sandro Knauß <knauss@kolabsys.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) 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 <http://www.gnu.org/licenses/>.
 *
 */

#ifndef LDAPUTILS_H
#define LDAPUTILS_H

#include <QString>

namespace IncidenceEditorNG {
QString translateLDAPAttributeForDisplay(const QString &attribute);
} // namespace IncidenceEditorNG

#endif //LDAPUTLS_H
07070111A01979000081A40000000200000002000000015AA55A860000188B000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/opencomposerjob.cpp/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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 "opencomposerjob.h"

#include <KDBusServiceStarter>
#include <KLocalizedString>

#include <QDBusConnectionInterface>
#include <QDBusInterface>
#include <QProcess>
#include <QTimer>

using namespace IncidenceEditorNG;

OpenComposerJob::OpenComposerJob(QObject *parent, const QString &to, const QString &cc,
                                 const QString &bcc, const KMime::Message::Ptr &message,
                                 const KIdentityManagement::Identity &identity)
    : KJob(parent)
    , mTo(to)
    , mCc(cc)
    , mBcc(bcc)
    , mMessage(message)
    , mIdentity(identity)
    , mSuccess(false)
{
    connect(
        QDBusConnection::sessionBus().interface(), &QDBusConnectionInterface::serviceOwnerChanged,
        this, &OpenComposerJob::slotServiceOwnerChanged);
}

OpenComposerJob::~OpenComposerJob()
{
}

void OpenComposerJob::start()
{
    mSuccess = false;
    if (QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral(
                                                                           "org.kde.kmail"))) {
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
        QMetaObject::invokeMethod(this, &OpenComposerJob::processMail, Qt::QueuedConnection);
#else
        QMetaObject::invokeMethod(this, "processMail", Qt::QueuedConnection);
#endif
    }
    //Check if Kontact is already running and if not ...
    int result = KDBusServiceStarter::self()->findServiceFor(QStringLiteral("DBUS/Mailer"),
                                                             QString(),
                                                             &mError, &mDBusService);
    if (result != 0) {
        // ... start Kontact
        result = KDBusServiceStarter::self()->startServiceFor(QStringLiteral(
                                                                  "DBUS/Mailer"), QString(),
                                                              &mError, &mDBusService);
        if (result != 0) {
            const bool ok = QProcess::startDetached(QStringLiteral("kontact"));
            if (!ok) {
                setError(KJob::UserDefinedError);
                setErrorText(i18nc("errormessage: can't create a kontact process",
                                   "Can't create composer: Failed to start kontact."));
                emitResult();
                return;
            }
        }
    }

QTimer::singleShot(10000, this, &OpenComposerJob::timeout);
}

void OpenComposerJob::timeout()
{
    if (!mSuccess) {
        setError(KJob::UserDefinedError);
        setErrorText(i18nc(
                         "errormessage: No connection via dbus nor starting kontact process worked.",
                         "Can't create composer: Neither dbus nor kontact responded in time."));
        emitResult();
    }
}

void OpenComposerJob::slotServiceOwnerChanged(const QString &name, const QString &oldOwner,
                                              const QString &newOwner)
{
    Q_UNUSED(oldOwner);
    if (name == QLatin1String("org.kde.kmail") && !newOwner.isEmpty()) {
        processMail();
    }
}

void OpenComposerJob::processMail()
{
    Q_ASSERT(mMessage);
    mSuccess = true;

unsigned int identity = mIdentity.uoid();

QString subject = mMessage->subject()->asUnicodeString();
    QString body = QString::fromUtf8(mMessage->contents()[0]->body());

QList<QVariant> messages;

if (mMessage->contents().count() == 1) {
        const QString messageFile;
        const QStringList attachmentPaths;
        const QStringList customHeaders;
        const QString replyTo;
        const QString inReplyTo;
        bool hidden = false;

messages << mTo << mCc << mBcc << subject << body << hidden
                 << messageFile << attachmentPaths << customHeaders << replyTo << inReplyTo;
    } else {
        KMime::Content *attachment(mMessage->contents().at(1));
        QString attachName = attachment->contentType()->name();
        QByteArray attachCte = attachment->contentTransferEncoding()->as7BitString(false);
        QByteArray attachType = attachment->contentType()->mediaType();
        QByteArray attachSubType = attachment->contentType()->subType();
        QByteArray attachContDisp = attachment->contentDisposition()->as7BitString(false);
        QByteArray attachCharset = attachment->contentType()->charset();

QByteArray attachParamAttr = "method";
        QString attachParamValue = attachment->contentType()->parameter(QStringLiteral("method"));
        QByteArray attachData = attachment->encodedBody();

messages << mTo << mCc << mBcc << subject << body
                 << attachName << attachCte << attachData << attachType << attachSubType
                 << attachParamAttr << attachParamValue << attachContDisp << attachCharset
                 << identity;
    }
    QDBusInterface kmailObj(QStringLiteral("org.kde.kmail"), QStringLiteral(
                                "/KMail"), QStringLiteral("org.kde.kmail.kmail"));

QDBusReply<int> composerDbusPath = kmailObj.callWithArgumentList(QDBus::AutoDetect, QStringLiteral(
                                                                         "openComposer"), messages);

if (!composerDbusPath.isValid()) {
        setError(KJob::UserDefinedError);
        setErrorText(i18nc("errormessage: dbus is running but still no connection kmail",
                           "Cannot connect to email service"));
    }
    emitResult();
}
07070111A0197A000081A40000000200000002000000015AA55A8600000711000000FD0000001000000000000000000000004900000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/opencomposerjob.h/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 */

#ifndef INCIDENCEEDITOR_OPENCOMPOSERJOB_H
#define INCIDENCEEDITOR_OPENCOMPOSERJOB_H

#include <KMime/Message>

#include <KIdentityManagement/Identity>
#include <KJob>

namespace IncidenceEditorNG {
// Opens a Composer with a mail with one attachment (costructed my ITIPHandler)
class OpenComposerJob : public KJob
{
    Q_OBJECT

public:
    explicit OpenComposerJob(QObject *parent, const QString &to, const QString &cc,
                             const QString &bcc, const KMime::Message::Ptr &message,
                             const KIdentityManagement::Identity &identity);
    ~OpenComposerJob() override;

void start() override;

private:
    void slotServiceOwnerChanged(const QString &, const QString &, const QString &);
    void timeout();
    void processMail();
    QString mDBusService;
    QString mError;
    QString mTo, mCc, mBcc;
    KMime::Message::Ptr mMessage;
    KIdentityManagement::Identity mIdentity;
    bool mSuccess;
};
}
#endif
07070111A0197B000081A40000000200000002000000015AA55A860000102D000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/resourceitem.cpp/*
 * Copyright 2014  Sandro Knauß <knauss@kolabsys.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) 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 <http://www.gnu.org/licenses/>.
 *
 */
#include "resourceitem.h"

#include <KLDAP/LdapServer>

using namespace IncidenceEditorNG;

ResourceItem::ResourceItem(const KLDAP::LdapDN &dn, const QStringList &attrs,
                           const KLDAP::LdapClient &ldapClient, const ResourceItem::Ptr &parent)
    : parentItem(parent)
    , dn(dn)
    , mAttrs(attrs)
    , mLdapClient(0, this)
{
    if (!dn.isEmpty()) {
        KLDAP::LdapServer server = ldapClient.server();

server.setScope(KLDAP::LdapUrl::Base);
        server.setBaseDn(dn);
        mLdapClient.setServer(server);

connect(&mLdapClient, &KLDAP::LdapClient::result, this, &ResourceItem::slotLDAPResult);

mAttrs << QStringLiteral("uniqueMember");
        mLdapClient.setAttributes(attrs);
    } else {
        itemData.reserve(mAttrs.count());
        for (const QString &header : qAsConst(mAttrs)) {
            itemData << header;
        }
    }
}

ResourceItem::~ResourceItem()
{
}

ResourceItem::Ptr ResourceItem::child(int number)
{
    return childItems.value(number);
}

int ResourceItem::childCount() const
{
    return childItems.count();
}

int ResourceItem::childNumber() const
{
    if (parentItem) {
        int i = 0;
        for (const ResourceItem::Ptr &child : qAsConst(parentItem->childItems)) {
            if (child == this) {
                return i;
            }
            i++;
        }
    }

return 0;
}

int ResourceItem::columnCount() const
{
    return itemData.count();
}

QVariant ResourceItem::data(int column) const
{
    return itemData.value(column);
}

QVariant ResourceItem::data(const QString &column) const
{
    if (!mLdapObject.attributes()[column].isEmpty()) {
        return QString::fromUtf8(mLdapObject.attributes()[column][0]);
    }
    return QVariant();
}

bool ResourceItem::insertChild(int position, const ResourceItem::Ptr &item)
{
    if (position < 0 || position > childItems.size()) {
        return false;
    }

childItems.insert(position, item);

return true;
}

ResourceItem::Ptr ResourceItem::parent()
{
    return parentItem;
}

bool ResourceItem::removeChildren(int position, int count)
{
    if (position < 0 || position + count > childItems.size()) {
        return false;
    }

for (int row = 0; row < count; ++row) {
        childItems.removeAt(position);
    }

return true;
}

const QStringList &ResourceItem::attributes() const
{
    return mAttrs;
}

const KLDAP::LdapObject &ResourceItem::ldapObject() const
{
    return mLdapObject;
}

void ResourceItem::startSearch()
{
    mLdapClient.startQuery(QStringLiteral("objectclass=*"));
}

void ResourceItem::setLdapObject(const KLDAP::LdapObject &obj)
{
    slotLDAPResult(mLdapClient, obj);
}

const KLDAP::LdapClient &ResourceItem::ldapClient() const
{
    return mLdapClient;
}

void ResourceItem::slotLDAPResult(const KLDAP::LdapClient &client,
                                  const KLDAP::LdapObject &obj)
{
    Q_UNUSED(client);
    mLdapObject = obj;
    for (const QString &header : qAsConst(mAttrs)) {
        if (!obj.attributes()[header].isEmpty()) {
            itemData << QString::fromUtf8(obj.attributes()[header][0]);
        } else {
            itemData << QString();
        }
    }
    Q_EMIT searchFinished();
}
07070111A0197C000081A40000000200000002000000015AA55A8600000DEF000000FD0000001000000000000000000000004600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/resourceitem.h/*
 * Copyright 2014  Sandro Knauß <knauss@kolabsys.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) 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 <http://www.gnu.org/licenses/>.
 *
 */

#ifndef RESOURCEITEM_H
#define RESOURCEITEM_H

#include <Libkdepim/LdapClient>

#include <KLDAP/LdapObject>

#include <QSharedPointer>
#include <QStringList>
#include <QVariant>
#include <QVector>

namespace IncidenceEditorNG {
class ResourceItem : public QObject
{
    Q_OBJECT
public:
    /* Copied from http://qt-project.org/doc/qt-4.8/itemviews-editabletreemodel.html:
     * QT 4.8: Editable Tree Model Example
     */

/**
      A shared pointer to an ResourceItem object.
    */
    typedef QSharedPointer<ResourceItem> Ptr;

ResourceItem(const KLDAP::LdapDN &dn, const QStringList &attrs,
                 const KLDAP::LdapClient &ldapClient,
                 const ResourceItem::Ptr &parent = ResourceItem::Ptr());
    ~ResourceItem();

ResourceItem::Ptr child(int number);
    int childCount() const;
    int columnCount() const;
    QVariant data(int column) const;
    QVariant data(const QString &column) const;
    bool insertChild(int position, const ResourceItem::Ptr &item);
    ResourceItem::Ptr parent();
    bool removeChildren(int position, int count);
    int childNumber() const;

private:
    QList<ResourceItem::Ptr> childItems;
    QVector<QVariant> itemData;
    ResourceItem::Ptr parentItem;

Q_SIGNALS:
    void searchFinished();

public:
    /* Returns the attributes of the requested ldapObject.
     *
     */
    const QStringList &attributes() const;

/* Returns the ldapObject, that is used as data source.
     *
     */
    const KLDAP::LdapObject &ldapObject() const;

/* Set the ldapObject, either directy via this function
     * or use startSearch to request the ldapServer for the ldapObject
     * with the dn specified via the constructor.
     *
     */
    void setLdapObject(const KLDAP::LdapObject &);

/* The used ldapClient.
     *
     */
    const KLDAP::LdapClient &ldapClient() const;

/* Start querying the ldapServer for a object that name is dn
     *
     */
    void startSearch();

private:
    /* data source
     *
     */
    KLDAP::LdapObject mLdapObject;

/* dn of the ldapObject
     *
     */
    const KLDAP::LdapDN dn;

/* Attributes of the ldapObject to request and the header of the Item
     *
     */
    QStringList mAttrs;

/* ldapClient to request
     *
     */
    KLDAP::LdapClient mLdapClient;

private:
    /* Answer of the LdapServer for the given dn
     *
     */
    void slotLDAPResult(const KLDAP::LdapClient &, const KLDAP::LdapObject &);
};
}

//@cond PRIVATE
Q_DECLARE_TYPEINFO(IncidenceEditorNG::ResourceItem::Ptr, Q_MOVABLE_TYPE);
Q_DECLARE_METATYPE(IncidenceEditorNG::ResourceItem::Ptr)
//@endcond
#endif // RESOURCEITEM_H
07070111A0197D000081A40000000200000002000000015AA55A86000028A3000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/resourcemanagement.cpp/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#include "resourcemanagement.h"
#include "ui_resourcemanagement.h"
#include "resourcemodel.h"
#include "CalendarSupport/FreeBusyItem"
#include "CalendarSupport/FreeBusyCalendar"
#include "ldaputils.h"

#include "freebusyganttproxymodel.h"

#include <Akonadi/Calendar/FreeBusyManager>

#include <EventViews/AgendaView>
#include <EventViews/ViewCalendar>

#include <KCalCore/Event>
#include <KCalCore/MemoryCalendar>

#include <KGantt/KGanttGraphicsView>

#include <KLocalizedString>
#include <KSharedConfig>
#include <KConfigGroup>

#include <QDialogButtonBox>
#include <QPushButton>
#include <QStringList>
#include <QLabel>
#include <QColor>

using namespace IncidenceEditorNG;

class FreebusyViewCalendar : public EventViews::ViewCalendar
{
public:
    virtual ~FreebusyViewCalendar()
    {
    }

bool isValid(const KCalCore::Incidence::Ptr &incidence) const override
    {
        return isValid(incidence->uid());
    }

bool isValid(const QString &incidenceIdentifier) const override
    {
        return incidenceIdentifier.startsWith(QStringLiteral("fb-"));
    }

QString displayName(const KCalCore::Incidence::Ptr &incidence) const override
    {
        Q_UNUSED(incidence);
        return QStringLiteral("Freebusy");
    }

QColor resourceColor(const KCalCore::Incidence::Ptr &incidence) const override
    {
        bool ok = false;
        int status = incidence->customProperty(QStringLiteral(
                                                   "FREEBUSY").toLatin1(), QStringLiteral(
                                                   "STATUS").toLatin1()).toInt(&ok);

if (!ok) {
            return QColor(85, 85, 85);
        }

switch (status) {
        case KCalCore::FreeBusyPeriod::Busy:
            return QColor(255, 0, 0);
        case KCalCore::FreeBusyPeriod::BusyTentative:
        case KCalCore::FreeBusyPeriod::BusyUnavailable:
            return QColor(255, 119, 0);
        case KCalCore::FreeBusyPeriod::Free:
            return QColor(0, 255, 0);
        default:
            return QColor(85, 85, 85);
        }
    }

QString iconForIncidence(const KCalCore::Incidence::Ptr &incidence) const override
    {
        Q_UNUSED(incidence);
        return QString();
    }

KCalCore::Calendar::Ptr getCalendar() const override
    {
        return mCalendar;
    }

KCalCore::Calendar::Ptr mCalendar;
};

ResourceManagement::ResourceManagement(QWidget *parent)
    : QDialog(parent)
{
    setWindowTitle(i18n("Resource Management"));
    QDialogButtonBox *buttonBox = new QDialogButtonBox(
        QDialogButtonBox::Ok | QDialogButtonBox::Close, this);
    QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
    okButton->setDefault(true);
    okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    okButton->setText(i18nc("@action:button add resource to attendeelist", "Book resource"));

connect(buttonBox, &QDialogButtonBox::accepted, this, &ResourceManagement::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &ResourceManagement::reject);

mUi = new Ui_resourceManagement;

QWidget *w = new QWidget(this);
    mUi->setupUi(w);
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->addWidget(w);

mainLayout->addWidget(buttonBox);

mModel = new CalendarSupport::FreeBusyItemModel(this);
    mFreebusyCalendar.setModel(mModel);

mAgendaView = new EventViews::AgendaView(QDate(), QDate(), false, false);

FreebusyViewCalendar *fbCalendar = new FreebusyViewCalendar();
    fbCalendar->mCalendar = mFreebusyCalendar.calendar();
    mFbCalendar = EventViews::ViewCalendar::Ptr(fbCalendar);
    mAgendaView->addCalendar(mFbCalendar);

mUi->resourceCalender->addWidget(mAgendaView);

QStringList attrs;
    attrs << QStringLiteral("cn") << QStringLiteral("mail")
          << QStringLiteral("owner") << QStringLiteral("givenname") << QStringLiteral("sn")
          << QStringLiteral("kolabDescAttribute") << QStringLiteral("description");
    ResourceModel *resourcemodel = new ResourceModel(attrs);
    mUi->treeResults->setModel(resourcemodel);

// This doesn't work till now :(-> that's why i use the click signal
    mUi->treeResults->setSelectionMode(QAbstractItemView::SingleSelection);
    selectionModel = mUi->treeResults->selectionModel();

connect(mUi->resourceSearch, &KLineEdit::textChanged, this,
            &ResourceManagement::slotStartSearch);

connect(mUi->treeResults, &QTreeView::clicked, this, &ResourceManagement::slotShowDetails);

connect(resourcemodel, &ResourceModel::layoutChanged, this,
            &ResourceManagement::slotLayoutChanged);
    readConfig();
}

ResourceManagement::~ResourceManagement()
{
    writeConfig();
    delete mModel;
    delete mUi;
}

void ResourceManagement::readConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "ResourceManagement");
    const QSize size = group.readEntry("Size", QSize(600, 400));
    if (size.isValid()) {
        resize(size);
    }
}

void ResourceManagement::writeConfig()
{
    KConfigGroup group(KSharedConfig::openConfig(), "ResourceManagement");
    group.writeEntry("Size", size());
    group.sync();
}

ResourceItem::Ptr ResourceManagement::selectedItem() const
{
    return mSelectedItem;
}

void ResourceManagement::slotStartSearch(const QString &text)
{
    (static_cast<ResourceModel *>(mUi->treeResults->model()))->startSearch(text);
}

void ResourceManagement::slotShowDetails(const QModelIndex &current)
{
    ResourceItem::Ptr item
        = current.model()->data(current, ResourceModel::Resource).value<ResourceItem::Ptr>();
    mSelectedItem = item;
    showDetails(item->ldapObject(), item->ldapClient());
}

void ResourceManagement::showDetails(const KLDAP::LdapObject &obj, const KLDAP::LdapClient &client)
{
    // Clean up formDetails
    QLayoutItem *child = nullptr;
    while ((child = mUi->formDetails->takeAt(0)) != nullptr) {
        delete child->widget();
        delete child;
    }
    mUi->groupOwner->setHidden(true);

// Fill formDetails with data
    for (auto it = obj.attributes().cbegin(), end = obj.attributes().cbegin(); it != end; ++it) {
        const QString &key = it.key();
        if (key == QStringLiteral("objectClass") || key == QLatin1String("email")) {
            continue;
        } else if (key == QStringLiteral("owner")) {
            QStringList attrs;
            attrs << QStringLiteral("cn") << QStringLiteral("mail")
                  << QStringLiteral("mobile") <<  QStringLiteral("telephoneNumber")
                  << QStringLiteral("kolabDescAttribute") << QStringLiteral("description");
            mOwnerItem
                = ResourceItem::Ptr(new ResourceItem(KLDAP::LdapDN(QString::fromUtf8(it.value().at(0))),
                                                     attrs, client));
            connect(
                mOwnerItem.data(), &ResourceItem::searchFinished, this,
                &ResourceManagement::slotOwnerSearchFinished);
            mOwnerItem->startSearch();
            continue;
        }
        QStringList list;
        const QList<QByteArray> values = it.value();
        list.reserve(values.count());
        for (const QByteArray &value: values) {
            list << QString::fromUtf8(value);
        }
        mUi->formDetails->addRow(translateLDAPAttributeForDisplay(key),
                                 new QLabel(list.join(QLatin1Char('\n'))));
    }

QString name = QString::fromUtf8(obj.attributes().value(QStringLiteral("cn"))[0]);
    QString email = QString::fromUtf8(obj.attributes().value(QStringLiteral("mail"))[0]);
    KCalCore::Attendee::Ptr attendee(new KCalCore::Attendee(name, email));
    CalendarSupport::FreeBusyItem::Ptr freebusy(new CalendarSupport::FreeBusyItem(attendee, this));
    mModel->clear();
    mModel->addItem(freebusy);
}

void ResourceManagement::slotLayoutChanged()
{
    const int columnCount = mUi->treeResults->model()->columnCount(QModelIndex());
    for (int i = 1; i < columnCount; ++i) {
        mUi->treeResults->setColumnHidden(i, true);
    }
}

void ResourceManagement::slotOwnerSearchFinished()
{
    // Clean up formDetails
    QLayoutItem *child = nullptr;
    while ((child = mUi->formOwner->takeAt(0)) != nullptr) {
        delete child->widget();
        delete child;
    }
    mUi->groupOwner->setHidden(false);

const KLDAP::LdapObject &obj = mOwnerItem->ldapObject();
    const KLDAP::LdapAttrMap &ldapAttrMap = obj.attributes();
    for (auto it = ldapAttrMap.cbegin(), end = ldapAttrMap.cend(); it != end; ++it) {
        const QString &key = it.key();
        if (key == QStringLiteral("objectClass") ||
            key == QStringLiteral("owner") ||
            key == QStringLiteral("givenname") ||
            key == QStringLiteral("sn")) {
            continue;
        }
        QStringList list;
        const QList<QByteArray> values = it.value();
        list.reserve(values.count());
        for (const QByteArray &value : values) {
            list << QString::fromUtf8(value);
        }
        mUi->formOwner->addRow(translateLDAPAttributeForDisplay(key),
                               new QLabel(list.join(QLatin1Char('\n'))));
    }
}

void ResourceManagement::slotDateChanged(const QDate &start, const QDate &end)
{
    if (start.daysTo(end) < 7) {
        mAgendaView->showDates(start, start.addDays(7));
    }
    mAgendaView->showDates(start, end);
}
07070111A0197E000081A40000000200000002000000015AA55A8600000AA0000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/resourcemanagement.h/*
 * Copyright (c) 2014 Sandro Knauß <knauss@kolabsys.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.
 *
 * As a special exception, permission is given to link this program
 * with any edition of Qt, and distribute the resulting executable,
 * without including the source code for Qt in the source distribution.
 */

#ifndef RESOURCEMANAGEMENT_H
#define RESOURCEMANAGEMENT_H

#include "incidenceeditor_export.h"

#include <Libkdepim/LdapClient>
#include <Libkdepim/LdapClientSearch>

#include "CalendarSupport/FreeBusyCalendar"
#include "resourceitem.h"

#include <EventViews/ViewCalendar>

#include <QDialog>

class Ui_resourceManagement;

class QItemSelectionModel;

namespace EventViews {
class AgendaView;
}

namespace IncidenceEditorNG {
class INCIDENCEEDITOR_EXPORT ResourceManagement : public QDialog
{
    Q_OBJECT
public:
    explicit ResourceManagement(QWidget *parent = nullptr);
    ~ResourceManagement();

ResourceItem::Ptr selectedItem() const;

public Q_SLOTS:
    void slotDateChanged(const QDate &start, const QDate &end);

private:
    /* Shows the details of a resource
     *
     */
    void showDetails(const KLDAP::LdapObject &, const KLDAP::LdapClient &client);

QItemSelectionModel *selectionModel = nullptr;

private:
    /* A new searchString is entered
     *
     */
    void slotStartSearch(const QString &);

/* A detail view is requested
     *
     */
    void slotShowDetails(const QModelIndex &current);

/**
     * The Owner search is done
     */
    void slotOwnerSearchFinished();

void slotLayoutChanged();

private:
    void readConfig();
    void writeConfig();
    CalendarSupport::FreeBusyItemModel *mModel = nullptr;
    CalendarSupport::FreeBusyCalendar mFreebusyCalendar;
    ResourceItem::Ptr mOwnerItem;
    ResourceItem::Ptr mSelectedItem;
    EventViews::ViewCalendar::Ptr mFbCalendar;
    Ui_resourceManagement *mUi = nullptr;
    QMap<QModelIndex, KCalCore::Event::Ptr> mFbEvent;
    EventViews::AgendaView *mAgendaView = nullptr;
};
}
#endif // RESOURCEMANAGEMENT_H
07070111A003C0000081A40000000200000002000000015AA55A8600002024000000FD0000001000000000000000000000004900000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/resourcemodel.cpp/*
 * Copyright 2014  Sandro Knauß <knauss@kolabsys.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) 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 <http://www.gnu.org/licenses/>.
 *
 */
#include "resourcemodel.h"
#include "ldaputils.h"

#include <KEmailAddress>
#include <QDebug>

using namespace IncidenceEditorNG;

ResourceModel::ResourceModel(const QStringList &headers, QObject *parent)
    : QAbstractItemModel(parent)
    , foundCollection(false)
{
    this->headers = headers;
    rootItem = ResourceItem::Ptr(new ResourceItem(KLDAP::LdapDN(), headers, KLDAP::LdapClient(0)));

ldapSearchCollections.setFilter(QStringLiteral(
                                        "&(ou=Resources,*)(objectClass=kolabGroupOfUniqueNames)(objectclass=groupofurls)(!(objectclass=nstombstone))(mail=*)"
                                        "(cn=%1)"));
    ldapSearch.setFilter(QStringLiteral(
                             "&(objectClass=kolabSharedFolder)(kolabFolderType=event)(mail=*)"
                             "(|(cn=%1)(description=%1)(kolabDescAttribute=%1))"));

QStringList attrs = ldapSearchCollections.attributes();
    attrs << QStringLiteral("uniqueMember");
    ldapSearchCollections.setAttributes(attrs);
    ldapSearch.setAttributes(headers);

connect(&ldapSearchCollections, QOverload<const KLDAP::LdapResultObject::List &>::of(& KLDAP :: LdapClientSearch :: searchData), this, &ResourceModel::slotLDAPCollectionData);
    connect(&ldapSearch, QOverload<const KLDAP::LdapResultObject::List &>::of(& KLDAP :: LdapClientSearch :: searchData), this, &ResourceModel::slotLDAPSearchData);

ldapSearchCollections.startSearch(QStringLiteral("*"));
}

ResourceModel::~ResourceModel()
{
}

int ResourceModel::columnCount(const QModelIndex & /* parent */) const
{
    return rootItem->columnCount();
}

QVariant ResourceModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        return QVariant();
    }

if (role == Qt::EditRole || role == Qt::DisplayRole) {
        return getItem(index)->data(index.column());
    } else if (role == Resource) {
        ResourceItem *p = getItem(parent(index));
        return QVariant::fromValue(p->child(index.row()));
    } else if (role == FullName) {
        ResourceItem *item = getItem(index);
        return KEmailAddress::normalizedAddress(item->data(QStringLiteral(
                                                               "cn")).toString(),
                                                item->data(QStringLiteral("mail")).toString());
    }

return QVariant();
}

Qt::ItemFlags ResourceModel::flags(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return nullptr;
    }

return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

ResourceItem *ResourceModel::getItem(const QModelIndex &index) const
{
    if (index.isValid()) {
        ResourceItem *item = static_cast<ResourceItem *>(index.internalPointer());
        if (item) {
            return item;
        }
    }
    return rootItem.data();
}

QVariant ResourceModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
        return translateLDAPAttributeForDisplay(rootItem->data(section).toString());
    }

return QVariant();
}

QModelIndex ResourceModel::index(int row, int column, const QModelIndex &parent) const
{
    ResourceItem *parentItem = getItem(parent);

ResourceItem::Ptr childItem = parentItem->child(row);
    if (row < parentItem->childCount() && childItem) {
        return createIndex(row, column, childItem.data());
    } else {
        return QModelIndex();
    }
}

QModelIndex ResourceModel::parent(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return QModelIndex();
    }
    ResourceItem *childItem = getItem(index);
    ResourceItem::Ptr parentItem = childItem->parent();

if (parentItem == rootItem) {
        return QModelIndex();
    }

return createIndex(parentItem->childNumber(), index.column(), parentItem.data());
}

bool ResourceModel::removeRows(int position, int rows, const QModelIndex &parent)
{
    ResourceItem *parentItem = getItem(parent);

beginRemoveRows(parent, position, position + rows - 1);
    bool success = parentItem->removeChildren(position, rows);
    endRemoveRows();

return success;
}

int ResourceModel::rowCount(const QModelIndex &parent) const
{
    ResourceItem *parentItem = getItem(parent);

return parentItem->childCount();
}

void ResourceModel::startSearch(const QString &query)
{
    searchString = query;

if (foundCollection) {
        startSearch();
    }
}

void ResourceModel::startSearch()
{
    // Delete all resources -> only collection elements are shown
    for (int i = 0; i < rootItem->childCount(); ++i) {
        if (ldapCollections.contains(rootItem->child(i))) {
            QModelIndex parentIndex = index(i, 0, QModelIndex());
            beginRemoveRows(parentIndex, 0, rootItem->child(i)->childCount() - 1);
            rootItem->child(i)->removeChildren(0, rootItem->child(i)->childCount());
            endRemoveRows();
        } else {
            beginRemoveRows(QModelIndex(), i, i);
            rootItem->removeChildren(i, 1);
            endRemoveRows();
        }
    }

if (searchString.isEmpty()) {
        ldapSearch.startSearch(QStringLiteral("*"));
    } else {
        ldapSearch.startSearch(QLatin1Char('*') + searchString + QLatin1Char('*'));
    }
}

void ResourceModel::slotLDAPCollectionData(const KLDAP::LdapResultObject::List &results)
{
    Q_EMIT layoutAboutToBeChanged();

foundCollection = true;
    ldapCollectionsMap.clear();
    ldapCollections.clear();

//qDebug() <<  "Found ldapCollections";

for (const KLDAP::LdapResultObject &result : qAsConst(results)) {
        ResourceItem::Ptr item(new ResourceItem(
                                   result.object.dn(), headers, *result.client, rootItem));
        item->setLdapObject(result.object);

rootItem->insertChild(rootItem->childCount(), item);
        ldapCollections.insert(item);

// Resources in a collection add this link into ldapCollectionsMap
        const auto members = result.object.attributes()[QStringLiteral("uniqueMember")];
        foreach (const QByteArray &member, members) {
            ldapCollectionsMap.insert(QString::fromLatin1(member), item);
        }
    }

Q_EMIT layoutChanged();

startSearch();
}

void ResourceModel::slotLDAPSearchData(const KLDAP::LdapResultObject::List &results)
{
    for (const KLDAP::LdapResultObject &result : qAsConst(results)) {
        //Add the found items to all collections, where it is member
        QList<ResourceItem::Ptr> parents = ldapCollectionsMap.values(result.object.dn().toString());
        if (parents.isEmpty()) {
            parents << rootItem;
        }

for (const ResourceItem::Ptr &parent : qAsConst(parents)) {
            ResourceItem::Ptr item(new ResourceItem(
                                       result.object.dn(), headers, *result.client, parent));
            item->setLdapObject(result.object);

QModelIndex parentIndex;
            if (parent != rootItem) {
                parentIndex = index(parent->childNumber(), 0, parentIndex);
            }
            beginInsertRows(parentIndex, parent->childCount(), parent->childCount());
            parent->insertChild(parent->childCount(), item);
            endInsertRows();
        }
    }
}
07070111A003C1000081A40000000200000002000000015AA55A8600000E95000000FD0000001000000000000000000000004700000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/resourcemodel.h/*
 * Copyright 2014  Sandro Knauß <knauss@kolabsys.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) 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 <http://www.gnu.org/licenses/>.
 *
 */

#ifndef RESOURCEMODEL_H
#define RESOURCEMODEL_H

#include "resourceitem.h"

#include <Libkdepim/LdapClientSearch>

#include <QAbstractItemModel>
#include <QModelIndex>
#include <QSet>

namespace IncidenceEditorNG {
class ResourceModel : public QAbstractItemModel
{
    Q_OBJECT

public:
    /* Copied from http://qt-project.org/doc/qt-4.8/itemviews-editabletreemodel.html:
     * QT 4.8: Editable Tree Model Example
     */
    enum Roles {
        Resource = Qt::UserRole,
        FullName
    };

ResourceModel(const QStringList &headers, QObject *parent = nullptr);
    ~ResourceModel();

QVariant data(const QModelIndex &index, int role) const override;
    QVariant headerData(int section, Qt::Orientation orientation,
                        int role = Qt::DisplayRole) const override;

QModelIndex index(int row, int column,
                      const QModelIndex &parent = QModelIndex()) const override;
    QModelIndex parent(const QModelIndex &index) const override;

int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;

Qt::ItemFlags flags(const QModelIndex &index) const override;

bool removeRows(int position, int rows, const QModelIndex &parent = QModelIndex()) override;
private:
    ResourceItem *getItem(const QModelIndex &index) const;

ResourceItem::Ptr rootItem;

public:

/* Start search on LDAP Server with the given string.
     * If the model is not ready to search, the string is cached and is executed afterwards.
     */
    void startSearch(const QString &);
private:

/* Start search with cached string (stored in searchString)
     *
     */
    void startSearch();

/* Search for collections of resources
     *
     */
    KLDAP::LdapClientSearch ldapSearchCollections;

/* Search for matching resources
     *
     */
    KLDAP::LdapClientSearch ldapSearch;

/* Map from dn of resource -> collectionItem
     * A Resource can be part of different collection, so a QMuliMap is needed
     *
     */
    QMultiMap<QString, ResourceItem::Ptr> ldapCollectionsMap;

/* A Set of all collection ResourceItems
     *
     */
    QSet <ResourceItem::Ptr> ldapCollections;

/* Cached searchString (set by startSearch(QString))
     *
     */
    QString searchString;

/* Is the search of collections ended
     *
     */
    bool foundCollection;

/* List of all attributes in LDAP an the headers of the model
     *
     */
    QStringList headers;

private:
    /* Slot for founded collections
     *
     */
    void slotLDAPCollectionData(const KLDAP::LdapResultObject::List &);

/* Slot for matching resources
     *
     */
    void slotLDAPSearchData(const KLDAP::LdapResultObject::List &);
};
}
#endif // RESOURCEMODEL_H
07070111A003C2000081A40000000200000002000000015AA55A860000223C000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/schedulingdialog.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "schedulingdialog.h"
#include "conflictresolver.h"
#include "CalendarSupport/FreePeriodModel"
#include "visualfreebusywidget.h"
#include <KCalUtils/Stringify>

#include <KLocalizedString>

#include <QDialogButtonBox>
#include <QLocale>
#include <QPushButton>
#include <QVBoxLayout>

using namespace IncidenceEditorNG;

SchedulingDialog::SchedulingDialog(const QDate &startDate, const QTime &startTime, int duration,
                                   ConflictResolver *resolver, QWidget *parent)
    : QDialog(parent)
    , mResolver(resolver)
    , mPeriodModel(new CalendarSupport::FreePeriodModel(this))
{
    setWindowTitle(i18n("Scheduling"));
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    QWidget *w = new QWidget(this);
    setupUi(w);
    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, &SchedulingDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &SchedulingDialog::reject);

mainLayout->addWidget(w);
    mainLayout->addWidget(buttonBox);
    fillCombos();

Q_ASSERT(duration > 0);
    mDuration = duration;

mVisualWidget = new VisualFreeBusyWidget(resolver->model(), 8);
    QVBoxLayout *ganttlayout = new QVBoxLayout(mGanttTab);

mGanttTab->setLayout(ganttlayout);
    ganttlayout->addWidget(mVisualWidget);

connect(mStartDate, &KDateComboBox::dateEdited, mResolver, &ConflictResolver::setEarliestDate);
    connect(mStartTime, &KTimeComboBox::timeEdited, mResolver, &ConflictResolver::setEarliestTime);
    connect(mEndDate, &KDateComboBox::dateEdited, mResolver, &ConflictResolver::setLatestDate);
    connect(mEndTime, &KTimeComboBox::timeEdited, mResolver, &ConflictResolver::setLatestTime);

connect(mStartDate, &KDateComboBox::dateEdited, this, &SchedulingDialog::slotStartDateChanged);

connect(mWeekdayCombo, &KPIM::KWeekdayCheckCombo::checkedItemsChanged, this,
            &SchedulingDialog::slotWeekdaysChanged);
    connect(mWeekdayCombo, &KPIM::KWeekdayCheckCombo::checkedItemsChanged, this,
            &SchedulingDialog::slotMandatoryRolesChanged);

connect(mResolver, &ConflictResolver::freeSlotsAvailable, mPeriodModel,
            &CalendarSupport::FreePeriodModel::slotNewFreePeriods);
    connect(mMoveBeginTimeEdit, &KTimeComboBox::timeEdited, this,
            &SchedulingDialog::slotSetEndTimeLabel);

mTableView->setModel(mPeriodModel);
    connect(
        mTableView->selectionModel(), &QItemSelectionModel::currentRowChanged, this,
        &SchedulingDialog::slotRowSelectionChanged);

mStartDate->setDate(startDate);
    mEndDate->setDate(mStartDate->date().addDays(7));
    mStartTime->setTime(startTime);
    mEndTime->setTime(startTime);

mResolver->setEarliestDate(mStartDate->date());
    mResolver->setEarliestTime(mStartTime->time());
    mResolver->setLatestDate(mEndDate->date());
    mResolver->setLatestTime(mEndTime->time());

mMoveApptGroupBox->hide();
}

SchedulingDialog::~SchedulingDialog()
{
}

void SchedulingDialog::slotUpdateIncidenceStartEnd(const QDateTime &startDateTime,
                                                   const QDateTime &endDateTime)
{
    mVisualWidget->slotUpdateIncidenceStartEnd(startDateTime, endDateTime);
}

void SchedulingDialog::fillCombos()
{
// Note: we depend on the following order
    mRolesCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant")),
                         KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::ReqParticipant));
    mRolesCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-participant-optional")),
                         KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::OptParticipant));
    mRolesCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-observer")),
                         KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::NonParticipant));
    mRolesCombo->addItem(QIcon::fromTheme(QStringLiteral("meeting-chair")),
                         KCalUtils::Stringify::attendeeRole(KCalCore::Attendee::Chair));

mRolesCombo->setWhatsThis(i18nc("@info:whatsthis",
                                    "Edits the role of the attendee."));

mRolesCombo->setItemCheckState(0, Qt::Checked);
    mRolesCombo->setItemCheckState(1, Qt::Checked);
    mRolesCombo->setItemCheckState(2, Qt::Checked);
    mRolesCombo->setItemCheckState(3, Qt::Checked);

QBitArray days(7);
    days.setBit(0);   //Monday
    days.setBit(1);   //Tuesday
    days.setBit(2);   //Wednesday
    days.setBit(3);   //Thursday
    days.setBit(4);   //Friday.. surprise!

mWeekdayCombo->setDays(days);
    mResolver->setAllowedWeekdays(days);
}

void SchedulingDialog::slotStartDateChanged(const QDate &newDate)
{
    QDate oldDate = mStDate;
    mStDate = newDate;
    if (newDate.isValid() && oldDate.isValid()) {
        updateWeekDays(oldDate);
    }
}

void SchedulingDialog::updateWeekDays(const QDate &oldDate)
{
    const int oldStartDayIndex = mWeekdayCombo->weekdayIndex(oldDate);
    const int newStartDayIndex = mWeekdayCombo->weekdayIndex(mStDate);

mWeekdayCombo->setItemCheckState(oldStartDayIndex, Qt::Unchecked);
    mWeekdayCombo->setItemEnabled(oldStartDayIndex, true);
    mWeekdayCombo->setItemCheckState(newStartDayIndex, Qt::Checked);
    mWeekdayCombo->setItemEnabled(newStartDayIndex, false);
}

void SchedulingDialog::slotWeekdaysChanged()
{
    // notify the resolver
    mResolver->setAllowedWeekdays(mWeekdayCombo->days());
}

void SchedulingDialog::slotMandatoryRolesChanged()
{
    QSet<KCalCore::Attendee::Role> roles;
    for (int i = 0; i < mRolesCombo->count(); ++i) {
        if (mRolesCombo->itemCheckState(i) == Qt::Checked) {
            roles << KCalCore::Attendee::Role(i);
        }
    }
    mResolver->setMandatoryRoles(roles);
}

void SchedulingDialog::slotRowSelectionChanged(const QModelIndex &current,
                                               const QModelIndex &previous)
{
    Q_UNUSED(previous);
    if (!current.isValid()) {
        mMoveApptGroupBox->hide();
        return;
    }
    KCalCore::Period period
        = current.data(CalendarSupport::FreePeriodModel::PeriodRole).value<KCalCore::Period>();
    const QDate startDate = period.start().date();

const int dayOfWeek = startDate.dayOfWeek();
    const QString dayLabel
        = ki18nc("@label Day of week followed by day of the month, then the month. "
                 "Example: Monday, 12 June",
                 "%1, %2 %3").
          subs(QLocale::system().dayName(dayOfWeek, QLocale::LongFormat)).
          subs(startDate.day()).
          subs(QLocale::system().monthName(startDate.month(), QLocale::LongFormat)).toString();

mMoveDayLabel->setText(dayLabel);
    mMoveBeginTimeEdit->setTimeRange(period.start().time(),
                                     period.end().addSecs(-mDuration).time());
    mMoveBeginTimeEdit->setTime(period.start().time());
    slotSetEndTimeLabel(period.start().time());
    mMoveApptGroupBox->show();

mSelectedDate = startDate;
}

void SchedulingDialog::slotSetEndTimeLabel(const QTime &startTime)
{
    const QTime endTime = startTime.addSecs(mDuration);
    const QString endTimeLabel
        = ki18nc("@label This is a suffix following a time selecting widget. "
                 "Example: [timeedit] to 10:00am",
                 "to %1").subs(QLocale::system().toString(endTime)).toString();

mMoveEndTimeLabel->setText(endTimeLabel);
    mSelectedTime = startTime;
}

QDate SchedulingDialog::selectedStartDate() const
{
    return mSelectedDate;
}

QTime SchedulingDialog::selectedStartTime() const
{
    return mSelectedTime;
}
07070111A003C3000081A40000000200000002000000015AA55A86000009BC000000FD0000001000000000000000000000004A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/schedulingdialog.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_SCHEDULINGDIALOG_H
#define INCIDENCEEDITOR_SCHEDULINGDIALOG_H

#include "ui_schedulingdialog.h"

#include <QDialog>
#include <QDateTime>

namespace CalendarSupport {
class FreePeriodModel;
}

namespace IncidenceEditorNG {
class ConflictResolver;
class VisualFreeBusyWidget;

class SchedulingDialog : public QDialog, private Ui_Dialog
{
    Q_OBJECT
public:
    SchedulingDialog(const QDate &startDate, const QTime &startTime, int duration,
                     ConflictResolver *resolver, QWidget *parent);
    ~SchedulingDialog();

QDate selectedStartDate() const;
    QTime selectedStartTime() const;

public Q_SLOTS:
    void slotUpdateIncidenceStartEnd(const QDateTime &startDateTime, const QDateTime &endDateTime);

Q_SIGNALS:
    void startDateChanged(const QDate &newDate);
    void startTimeChanged(const QTime &newTime);
    void endDateChanged(const QDate &newDate);
    void endTimeChanged(const QTime &newTime);

private:
    void slotWeekdaysChanged();
    void slotMandatoryRolesChanged();
    void slotStartDateChanged(const QDate &newDate);

void slotRowSelectionChanged(const QModelIndex &current, const QModelIndex &previous);
    void slotSetEndTimeLabel(const QTime &startTime);
    void updateWeekDays(const QDate &oldDate);
    void fillCombos();

QDate mStDate;
    QDate mSelectedDate;
    QTime mSelectedTime;
    int mDuration; //!< In seconds

ConflictResolver *mResolver = nullptr;
    CalendarSupport::FreePeriodModel *mPeriodModel = nullptr;
    VisualFreeBusyWidget *mVisualWidget = nullptr;
};
}

#endif
07070111A003C4000081A40000000200000002000000015AA55A860000218A000000FD0000001000000000000000000000005400000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/templatemanagementdialog.cpp/******************************************************************************
**
** Filename   : templatemanagementdialog.cpp
** Created on : 05 June, 2005
** Copyright  : (c) 2005 Till Adam <adam@kde.org>
** Copyright (C) 2009  Allen Winter <winter@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 "templatemanagementdialog.h"

#include <QInputDialog>
#include <KMessageBox>
#include <KLocalizedString>
#include <KStandardGuiItem>

#include <QTimer>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>
#include <QUrlQuery>
#include <QDesktopServices>

using namespace IncidenceEditorNG;

TemplateManagementDialog::TemplateManagementDialog(
    QWidget *parent, const QStringList &templates, const QString &incidenceType)
    : QDialog(parent)
    , m_templates(templates)
    , m_type(incidenceType)
    , m_changed(false)
{
    QString m_type_translated = i18n(qPrintable(m_type));
    setWindowTitle(i18n("Manage %1 Templates", m_type_translated));
    QDialogButtonBox *buttonBox = new QDialogButtonBox(
        QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Help, 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::rejected, this, &TemplateManagementDialog::reject);
    setObjectName(QStringLiteral("template_management_dialog"));
    connect(buttonBox->button(
                QDialogButtonBox::Help), &QPushButton::clicked, this,
            &TemplateManagementDialog::slotHelp);
    QWidget *widget = new QWidget(this);
    mainLayout->addWidget(widget);
    mainLayout->addWidget(buttonBox);

widget->setObjectName(QStringLiteral("template_management_dialog_base"));
    m_base.setupUi(widget);

m_base.m_listBox->addItems(m_templates);
    m_base.m_listBox->setSelectionMode(QAbstractItemView::SingleSelection);

connect(m_base.m_buttonAdd, &QPushButton::clicked, this,
            &TemplateManagementDialog::slotAddTemplate);
    connect(m_base.m_buttonRemove, &QPushButton::clicked, this,
            &TemplateManagementDialog::slotRemoveTemplate);
    connect(m_base.m_buttonApply, &QPushButton::clicked, this,
            &TemplateManagementDialog::slotApplyTemplate);

connect(m_base.m_listBox, &QListWidget::itemSelectionChanged, this,
            &TemplateManagementDialog::slotItemSelected);
    connect(m_base.m_listBox, &QListWidget::itemDoubleClicked, this,
            &TemplateManagementDialog::slotApplyTemplate);
    connect(okButton, &QPushButton::clicked, this, &TemplateManagementDialog::slotOk);

m_base.m_buttonRemove->setEnabled(false);
    m_base.m_buttonApply->setEnabled(false);
}

void TemplateManagementDialog::slotHelp()
{
    QUrl url
        = QUrl(QStringLiteral("help:/")).resolved(QUrl(QStringLiteral(
                                                           "korganizer/entering-data.html")));
    QUrlQuery query(url);
    query.addQueryItem(QStringLiteral("anchor"),
                       QStringLiteral("entering-data-events-template-buttons"));
    url.setQuery(query);
    // launch khelpcenter, or a browser for URIs not handled by khelpcenter
    QDesktopServices::openUrl(url);
}

void TemplateManagementDialog::slotItemSelected()
{
    m_base.m_buttonRemove->setEnabled(true);
    m_base.m_buttonApply->setEnabled(true);
}

void TemplateManagementDialog::slotAddTemplate()
{
    bool ok;
    bool duplicate = false;
    QString m_type_translated = i18n(qPrintable(m_type));
    const QString newTemplate = QInputDialog::getText(this,
                                                      i18n("Template Name"),
                                                      i18n(
                                                          "Please enter a name for the new template:"), QLineEdit::Normal,
                                                      i18n("New %1 Template",
                                                           m_type_translated), &ok);
    if (newTemplate.isEmpty() || !ok) {
        return;
    }

if (m_templates.contains(newTemplate)) {
        int rc = KMessageBox::warningContinueCancel(
            this,
            i18n("A template with that name already exists, do you want to overwrite it?"),
            i18n("Duplicate Template Name"), KStandardGuiItem::overwrite());
        if (rc == KMessageBox::Cancel) {
            QTimer::singleShot(0, this, &TemplateManagementDialog::slotAddTemplate);
            return;
        }
        duplicate = true;
    }

if (!duplicate) {
        int count = m_base.m_listBox->count();
        m_templates.append(newTemplate);
        m_base.m_listBox->addItem(newTemplate);
        QListWidgetItem *item = m_base.m_listBox->item(count);
        m_base.m_listBox->setItemSelected(item, true);
    }
    m_newTemplate = newTemplate;
    m_changed = true;

// From this point on we need to keep the original event around until the
    // user has closed the dialog, applying a template would make little sense
    //buttonBox->button(QDialogButtonBox::Apply)->setEnabled( false );
    // neither does adding it again
    m_base.m_buttonAdd->setEnabled(false);
}

void TemplateManagementDialog::slotRemoveTemplate()
{
    QListWidgetItem *const item = m_base.m_listBox->selectedItems().first();
    if (!item) {
        return; // can't happen (TM)
    }

int rc = KMessageBox::warningContinueCancel(
        this,
        i18n("Are you sure that you want to remove the template <b>%1</b>?", item->text()),
        i18n("Remove Template"), KStandardGuiItem::remove());

if (rc == KMessageBox::Cancel) {
        return;
    }

int current = m_base.m_listBox->row(item);

m_templates.removeAll(item->text());
    m_base.m_listBox->takeItem(current);

m_base.m_listBox->setItemSelected(
        m_base.m_listBox->item(qMax(current - 1, 0)), true);

updateButtons();

m_changed = true;
}

void TemplateManagementDialog::updateButtons()
{
    m_base.m_buttonAdd->setEnabled(true);
    const bool isNotEmpty = m_base.m_listBox->count() != 0;
    m_base.m_buttonRemove->setEnabled(isNotEmpty);
    m_base.m_buttonApply->setEnabled(isNotEmpty);
}

void TemplateManagementDialog::slotApplyTemplate()
{
    // Once the user has applied the current template to the event,
    // it makes no sense to add it again
    m_base.m_buttonAdd->setEnabled(false);
    QListWidgetItem *item = m_base.m_listBox->currentItem();
    if (item) {
        const QString &cur = item->text();
        if (!cur.isEmpty() && cur != m_newTemplate) {
            Q_EMIT loadTemplate(cur);
            slotOk();
        }
    }
}

void TemplateManagementDialog::slotOk()
{
    // failure is not an option *cough*
    if (!m_newTemplate.isEmpty()) {
        Q_EMIT saveTemplate(m_newTemplate);
    }
    if (m_changed) {
        Q_EMIT templatesChanged(m_templates);
    }
    accept();
}
07070111A003C5000081A40000000200000002000000015AA55A8600000D10000000FD0000001000000000000000000000005200000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/templatemanagementdialog.h/******************************************************************************
**
** Filename   : templatemanagerdialog.h
** Created on : 05 June, 2005
** Copyright  : (c) 2005 Till Adam <adam@kde.org>
** Copyright (C) 2009  Allen Winter <winter@kde.org>
**
******************************************************************************/

#include "ui_template_management_dialog_base.h"

#include <KCalCore/IncidenceBase>

#include <QDialog>
namespace IncidenceEditorNG {
class TemplateManagementDialog : public QDialog
{
    Q_OBJECT
public:
    TemplateManagementDialog(QWidget *parent, const QStringList &templates,
                             const QString &incidenceType);

Q_SIGNALS:
    /* Emitted whenever the user hits apply, indicating that the currently
       selected template should be loaded into to the incidence editor which
       triggered this.
    */
    void loadTemplate(const QString &templateName);

/* Emitted whenever the user wants to add the current incidence as a
       template with the given name.
    */
    void saveTemplate(const QString &templateName);

/* Emitted when the dialog changed the list of templates. Calling code
       can the replace the list that was handed in with the one this signal
       transports.
    */
    void templatesChanged(const QStringList &templates);

protected Q_SLOTS:
    void slotItemSelected();
    void slotAddTemplate();
    void slotRemoveTemplate();
    void slotApplyTemplate();
    void slotOk();

private:
    void slotHelp();
    void updateButtons();
    Ui::TemplateManagementDialog_base m_base;
    QStringList m_templates;
    QString m_type;
    QString m_newTemplate;
    bool m_changed;
};
}

#endif
07070111A400CA000041ED0000000200000002000000025AA55A8600000000000000FD0000001000000000000000000000003D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/tests07070111A400D2000081A40000000200000002000000015AA55A8600000186000000FD0000001000000000000000000000004C00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/tests/CMakeLists.txt
set(testincidenceeditor_SRCS main.cpp)

add_executable(kincidenceeditor ${testincidenceeditor_SRCS})

target_link_libraries(kincidenceeditor
    KF5::AkonadiCalendar
    KF5::AkonadiCore
    KF5::CalendarCore
    KF5::CalendarUtils
    KF5::IncidenceEditor
    KF5::CalendarSupport
    KF5::KdepimDBusInterfaces
    )

install(TARGETS kincidenceeditor ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
07070111A400D3000081A40000000200000002000000015AA55A8600001348000000FD0000001000000000000000000000004600000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/tests/main.cpp/*
  Copyright (C) 2010  Bertjan Broeksema <broeksema@kde.org>
  Copyright (C) 2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 "korganizereditorconfig.h"
#include "incidencedialog.h"
#include "incidencedefaults.h"

#include <CalendarSupport/KCalPrefs>
#include <akonadi/calendar/calendarsettings.h>
#include <Item>

#include <KCalCore/Event>
#include <KCalCore/Todo>
#include <KCalCore/Journal>

#include <QApplication>
#include <QCommandLineParser>
#include <QCommandLineOption>

#include <iostream>

using namespace IncidenceEditorNG;

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    QCoreApplication::setApplicationName(QStringLiteral("IncidenceEditorNGApp"));
    QCoreApplication::setApplicationVersion(QStringLiteral("0.1"));

QCommandLineParser parser;
    parser.addHelpOption();
    parser.addVersionOption();
    parser.addOption(QCommandLineOption(QStringLiteral("new-event"), QStringLiteral("Creates a new event")));
    parser.addOption(QCommandLineOption(QStringLiteral("new-todo"), QStringLiteral("Creates a new todo")));
    parser.addOption(QCommandLineOption(QStringLiteral("new-journal"), QStringLiteral(
                                            "Creates a new journal")));
    parser.addOption(QCommandLineOption(QStringLiteral("item"),
                                        QStringLiteral(
                                            "Loads an existing item, or returns without doing anything "
                                            "when the item is not an event or todo."),
                                        QStringLiteral("id")));
    parser.process(app);

Akonadi::Item item(-1);

IncidenceDefaults defaults;
    // Set the full emails manually here, to avoid that we get dependencies on
    // KCalPrefs all over the place.
    defaults.setFullEmails(CalendarSupport::KCalPrefs::instance()->fullEmails());
    // NOTE: At some point this should be generalized. That is, we now use the
    //       freebusy url as a hack, but this assumes that the user has only one
    //       groupware account. Which doesn't have to be the case necessarily.
    //       This method should somehow depend on the calendar selected to which
    //       the incidence is added.
    if (CalendarSupport::KCalPrefs::instance()->useGroupwareCommunication()) {
        defaults.setGroupWareDomain(
            QUrl(Akonadi::CalendarSettings::self()->freeBusyRetrieveUrl()).host());
    }

if (parser.isSet(QStringLiteral("new-event"))) {
        std::cout << "Creating new event..." << std::endl;
        KCalCore::Event::Ptr event(new KCalCore::Event);
        defaults.setDefaults(event);
        item.setPayload<KCalCore::Event::Ptr>(event);
    } else if (parser.isSet(QStringLiteral("new-todo"))) {
        std::cout << "Creating new todo..." << std::endl;
        KCalCore::Todo::Ptr todo(new KCalCore::Todo);
        defaults.setDefaults(todo);
        item.setPayload<KCalCore::Todo::Ptr>(todo);
    } else if (parser.isSet(QStringLiteral("new-journal"))) {
        std::cout << "Creating new journal..." << std::endl;
        KCalCore::Journal::Ptr journal(new KCalCore::Journal);
        defaults.setDefaults(journal);
        item.setPayload<KCalCore::Journal::Ptr>(journal);
    } else if (parser.isSet(QStringLiteral("item"))) {
        bool ok = false;
        qint64 id = parser.value(QStringLiteral("item")).toLongLong(&ok);
        if (!ok) {
            std::cerr << "Invalid akonadi item id given." << std::endl;
            return 1;
        }

item.setId(id);
        std::cout << "Trying to load Akonadi Item " << QString::number(id).toLatin1().data();
        std::cout << "..." << std::endl;
    } else {
        std::cerr << "Invalid usage." << std::endl << std::endl;
        return 1;
    }

EditorConfig::setEditorConfig(new KOrganizerEditorConfig);

IncidenceDialog *dialog = new IncidenceDialog();

Akonadi::Collection collection(CalendarSupport::KCalPrefs::instance()->defaultCalendarId());

if (collection.isValid()) {
        dialog->selectCollection(collection);
    }

dialog->load(item);   // The dialog will show up once the item is loaded.

return app.exec();
}
07070111A800CD000041ED0000000200000002000000025AA55A8600000000000000FD0000001000000000000000000000003A00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui07070111A800CE000081A40000000200000002000000015AA55A860000442B000000FD0000001000000000000000000000004900000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/alarmdialog.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>AlarmDialog</class>
 <widget class="QWidget" name="AlarmDialog">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>439</width>
    <height>315</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Alarms</string>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item row="0" column="0">
    <widget class="QLabel" name="label">
     <property name="text">
      <string>When:</string>
     </property>
    </widget>
   </item>
   <item row="0" column="1">
    <layout class="QHBoxLayout" name="horizontalLayout">
     <item>
      <widget class="QSpinBox" name="mAlarmOffset">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="toolTip">
        <string>Set the reminder trigger time</string>
       </property>
       <property name="whatsThis">
        <string>This spinbox allows you to set the reminder trigger time. The time unit is set in the combobox immediately adjacent.</string>
       </property>
       <property name="minimum">
        <number>0</number>
       </property>
       <property name="maximum">
        <number>99999</number>
       </property>
       <property name="value">
        <number>15</number>
       </property>
      </widget>
     </item>
     <item>
      <widget class="KComboBox" name="mOffsetUnit">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="toolTip">
        <string>Select the reminder trigger time unit</string>
       </property>
       <property name="whatsThis">
        <string>This combobox allows you to set the units for the reminder trigger time. The trigger time value is set in the spinbox immediately adjacent.</string>
       </property>
       <property name="autoCompletion">
        <bool>false</bool>
       </property>
       <item>
        <property name="text">
         <string comment="@item:inlistbox alarm offset expressed in minutes">minute(s)</string>
        </property>
       </item>
       <item>
        <property name="text">
         <string comment="@item:inlistbox alarm offset expressed in hours">hour(s)</string>
        </property>
       </item>
       <item>
        <property name="text">
         <string comment="@item:inlistbox alarm offset expressed in days">day(s)</string>
        </property>
       </item>
      </widget>
     </item>
     <item>
      <widget class="KComboBox" name="mBeforeAfter">
       <property name="toolTip">
        <string>Select the reminder trigger relative to the start or end time</string>
       </property>
       <property name="whatsThis">
        <string>Use this combobox to specify if you want the reminder to trigger before or after the start or end time.</string>
       </property>
       <item>
        <property name="text">
         <string>before the event starts</string>
        </property>
       </item>
       <item>
        <property name="text">
         <string>after the event starts</string>
        </property>
       </item>
       <item>
        <property name="text">
         <string>before the event ends</string>
        </property>
       </item>
       <item>
        <property name="text">
         <string>after the event ends</string>
        </property>
       </item>
      </widget>
     </item>
    </layout>
   </item>
   <item row="1" column="0">
    <widget class="QLabel" name="label_2">
     <property name="text">
      <string>Repeat:</string>
     </property>
    </widget>
   </item>
   <item row="1" column="1">
    <layout class="QHBoxLayout" name="horizontalLayout_2">
     <item>
      <widget class="QCheckBox" name="mRepeats">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="toolTip">
        <string>Set the reminder to repeat</string>
       </property>
       <property name="whatsThis">
        <string>Check this if you want to the reminder to recur on a periodic interval.</string>
       </property>
       <property name="text">
        <string/>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QSpinBox" name="mRepeatCount">
       <property name="enabled">
        <bool>false</bool>
       </property>
       <property name="toolTip">
        <string>Select how often the reminder should repeat</string>
       </property>
       <property name="whatsThis">
        <string>Use this selector to choose how many times you want the recurring reminder to repeat.</string>
       </property>
       <property name="suffix">
        <string> time(s)</string>
       </property>
       <property name="minimum">
        <number>1</number>
       </property>
       <property name="maximum">
        <number>500</number>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QSpinBox" name="mRepeatInterval">
       <property name="enabled">
        <bool>false</bool>
       </property>
       <property name="toolTip">
        <string>Select the time between reminder repeats</string>
       </property>
       <property name="whatsThis">
        <string>Use this selector to choose the time between repeating reminders.</string>
       </property>
       <property name="suffix">
        <string comment="@label:spinbox repeat interval expressed in minutes"> Minute(s)</string>
       </property>
       <property name="prefix">
        <string comment="repeat every X minutes">every </string>
       </property>
       <property name="minimum">
        <number>1</number>
       </property>
       <property name="maximum">
        <number>999</number>
       </property>
      </widget>
     </item>
    </layout>
   </item>
   <item row="2" column="0">
    <widget class="QLabel" name="label_3">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="text">
      <string>What:</string>
     </property>
     <property name="alignment">
      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
     </property>
    </widget>
   </item>
   <item row="2" column="1">
    <widget class="KComboBox" name="mTypeCombo">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <item>
      <property name="text">
       <string>Display text</string>
      </property>
     </item>
     <item>
      <property name="text">
       <string>Play sound file</string>
      </property>
     </item>
     <item>
      <property name="text">
       <string>Run application / script</string>
      </property>
     </item>
     <item>
      <property name="text">
       <string>Send email</string>
      </property>
     </item>
    </widget>
   </item>
   <item row="3" column="1">
    <widget class="QStackedWidget" name="mTypeStack">
     <property name="currentIndex">
      <number>0</number>
     </property>
     <widget class="QWidget" name="DisplayStack">
      <layout class="QVBoxLayout">
       <property name="spacing">
        <number>6</number>
       </property>
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item>
        <widget class="KTextEdit" name="mDisplayText">
         <property name="toolTip">
          <string notr="true">Provide text to display when the reminder triggers</string>
         </property>
         <property name="whatsThis">
          <string>Specify any text you desire to display in the popup notice when the reminder triggers.</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="AudioStack">
      <layout class="QGridLayout" name="gridLayout_2">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0">
        <widget class="QLabel" name="mSoundFileLabel">
         <property name="text">
          <string>Audio File:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignJustify|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>mSoundFile</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="KUrlRequester" name="mSoundFile">
         <property name="toolTip">
          <string>Specify a file containing a sound to play when the reminder triggers</string>
         </property>
         <property name="whatsThis">
          <string>Use the adjacent file browser to help you find the file you want to use when playing a sound when the reminder triggers.</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0" colspan="2">
        <spacer>
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Expanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>61</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="ApplicationStack">
      <layout class="QGridLayout" name="gridLayout_3">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0">
        <widget class="QLabel" name="mApplicationLabel">
         <property name="text">
          <string>&amp;Application / Script:</string>
         </property>
         <property name="buddy">
          <cstring>mApplication</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="KUrlRequester" name="mApplication">
         <property name="toolTip">
          <string>Specify a file containing the application to run when the reminder triggers</string>
         </property>
         <property name="whatsThis">
          <string>Use the adjacent file browser to help you find the file you want to use when running an application when the reminder triggers.</string>
         </property>
         <property name="filter">
          <string>*|All files</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="mAppArgumentsLabel">
         <property name="text">
          <string>Ar&amp;guments:</string>
         </property>
         <property name="buddy">
          <cstring>mAppArguments</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLineEdit" name="mAppArguments">
         <property name="toolTip">
          <string>Specify arguments to pass to the application when the reminder triggers</string>
         </property>
         <property name="whatsThis">
          <string>Enter the application arguments to use when running an application when the reminder triggers.</string>
         </property>
        </widget>
       </item>
       <item row="2" column="0" colspan="2">
        <spacer>
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Expanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>16</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="EmailStack">
      <layout class="QGridLayout" name="gridLayout_4">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0">
        <widget class="QLabel" name="mEmailToLabel">
         <property name="text">
          <string>&amp;To:</string>
         </property>
         <property name="buddy">
          <cstring>mEmailAddress</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="KPIM::AddresseeLineEdit" name="mEmailAddress">
         <property name="toolTip">
          <string>Specify a list of addresses to send email when the reminder triggers.
If the 'To:' field stays empty the email reminder will be sent to the
default email configured in Kmail (Settings menu/Configure Kmail/Identities).</string>
         </property>
         <property name="whatsThis">
          <string>Enter a list comma-separated addresses to which an email will be sent when the reminder triggers</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="mEmailTextLabel">
         <property name="text">
          <string>&amp;Message:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
         </property>
         <property name="buddy">
          <cstring>mEmailText</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="KTextEdit" name="mEmailText">
         <property name="toolTip">
          <string>Specify text of an email message to send when the reminder triggers</string>
         </property>
         <property name="whatsThis">
          <string>Enter any text you desire for the email message that will be sent when the alarm triggers.</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KPIM::AddresseeLineEdit</class>
   <extends>KLineEdit</extends>
   <header>LibkdepimAkonadi/AddresseeLineEdit</header>
  </customwidget>
  <customwidget>
   <class>KLineEdit</class>
   <extends>QLineEdit</extends>
   <header>klineedit.h</header>
  </customwidget>
  <customwidget>
   <class>KUrlRequester</class>
   <extends>QWidget</extends>
   <header>kurlrequester.h</header>
   <container>1</container>
  </customwidget>
  <customwidget>
   <class>KTextEdit</class>
   <extends>QTextEdit</extends>
   <header>ktextedit.h</header>
  </customwidget>
  <customwidget>
   <class>KComboBox</class>
   <extends>QComboBox</extends>
   <header>kcombobox.h</header>
  </customwidget>
 </customwidgets>
 <includes>
  <include location="global">LibkdepimAkonadi/AddresseeLineEdit</include>
 </includes>
 <resources/>
 <connections>
  <connection>
   <sender>mTypeCombo</sender>
   <signal>currentIndexChanged(int)</signal>
   <receiver>mTypeStack</receiver>
   <slot>setCurrentIndex(int)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>147</x>
     <y>83</y>
    </hint>
    <hint type="destinationlabel">
     <x>216</x>
     <y>97</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>mRepeats</sender>
   <signal>clicked(bool)</signal>
   <receiver>mRepeatCount</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>67</x>
     <y>49</y>
    </hint>
    <hint type="destinationlabel">
     <x>118</x>
     <y>50</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>mRepeats</sender>
   <signal>toggled(bool)</signal>
   <receiver>mRepeatInterval</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>69</x>
     <y>42</y>
    </hint>
    <hint type="destinationlabel">
     <x>284</x>
     <y>48</y>
    </hint>
   </hints>
  </connection>
 </connections>
</ui>
07070111A800D0000081A40000000200000002000000015AA55A8600001A42000000FD0000001000000000000000000000005200000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/attachmenteditdialog.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>AttachmentEditDialog</class>
 <widget class="QWidget" name="AttachmentEditDialog">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>446</width>
    <height>241</height>
   </rect>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item row="0" column="0" colspan="2">
    <layout class="QHBoxLayout" name="horizontalLayout">
     <item>
      <widget class="QLabel" name="mIcon">
       <property name="text">
        <string comment="KDE::DoNotExtract">TextLabel</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="KLineEdit" name="mLabelEdit">
       <property name="toolTip">
        <string comment="@info:tooltip">Give the attachment a name</string>
       </property>
       <property name="whatsThis">
        <string comment="@info:whatsthis">Type any string you desire here for the name of the attachment</string>
       </property>
       <property name="placeholderText">
        <string comment="@label">Attachment name</string>
       </property>
      </widget>
     </item>
    </layout>
   </item>
   <item row="1" column="0" colspan="2">
    <widget class="KSeparator" name="kseparator"/>
   </item>
   <item row="2" column="1">
    <widget class="QLabel" name="mTypeLabel">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="text">
      <string comment="@label File type of attachment is unknown">Unknown</string>
     </property>
    </widget>
   </item>
   <item row="4" column="0" colspan="2">
    <widget class="QCheckBox" name="mInlineCheck">
     <property name="toolTip">
      <string comment="@info:tooltip">Store the attachment file inside the calendar</string>
     </property>
     <property name="whatsThis">
      <string comment="@info:whatsthis">Checking this option will cause the attachment to be stored inside your calendar, which can take a lot of space depending on the size of the attachment. If this option is not checked, then only a link pointing to the attachment will be stored.  Do not use a link for attachments that change often or may be moved (or removed) from their current location.</string>
     </property>
     <property name="text">
      <string comment="@option:check">Store attachment inline</string>
     </property>
    </widget>
   </item>
   <item row="6" column="0" colspan="2">
    <spacer name="verticalSpacer">
     <property name="orientation">
      <enum>Qt::Vertical</enum>
     </property>
     <property name="sizeHint" stdset="0">
      <size>
       <width>434</width>
       <height>109</height>
      </size>
     </property>
    </spacer>
   </item>
   <item row="3" column="0" colspan="2">
    <widget class="QStackedWidget" name="mStackedWidget">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="currentIndex">
      <number>1</number>
     </property>
     <widget class="QWidget" name="page">
      <layout class="QHBoxLayout" name="horizontalLayout_2">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <item>
        <widget class="QLabel" name="label_2">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Location:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item>
        <widget class="KUrlRequester" name="mURLRequester">
         <property name="toolTip">
          <string comment="@info:tooltip">Provide a location for the attachment file</string>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Enter the path to the attachment file or use the file browser by pressing the adjacent button</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="page_2">
      <layout class="QHBoxLayout" name="horizontalLayout_3">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <item>
        <widget class="QLabel" name="label_3">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string comment="@label">Size:</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QLabel" name="mSizeLabel">
         <property name="text">
          <string>0 KB</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </widget>
   </item>
   <item row="2" column="0">
    <widget class="QLabel" name="label">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="text">
      <string>Type:</string>
     </property>
     <property name="alignment">
      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KLineEdit</class>
   <extends>QLineEdit</extends>
   <header>klineedit.h</header>
  </customwidget>
  <customwidget>
   <class>KSeparator</class>
   <extends>QFrame</extends>
   <header>kseparator.h</header>
   <container>1</container>
  </customwidget>
  <customwidget>
   <class>KUrlRequester</class>
   <extends>QWidget</extends>
   <header>kurlrequester.h</header>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections/>
</ui>
07070111A800D3000081A40000000200000002000000015AA55A8600000758000000FD0000001000000000000000000000005100000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/categorydialog_base.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>CategoryDialog_base</class>
 <widget class="QWidget" name="CategoryDialog_base">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>433</width>
    <height>269</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Select Categories</string>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout_2">
   <item>
    <widget class="IncidenceEditorNG::AutoCheckTreeWidget" name="mCategories">
     <property name="columnCount">
      <number>1</number>
     </property>
     <column>
      <property name="text">
       <string>Category</string>
      </property>
     </column>
    </widget>
   </item>
   <item>
    <layout class="QVBoxLayout" name="verticalLayout">
     <item>
      <layout class="QHBoxLayout" name="horizontalLayout">
       <item>
        <widget class="QLineEdit" name="mLineEdit"/>
       </item>
       <item>
        <widget class="QPushButton" name="mButtonAdd">
         <property name="text">
          <string/>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QPushButton" name="mButtonRemove">
         <property name="text">
          <string/>
         </property>
        </widget>
       </item>
      </layout>
     </item>
     <item>
      <widget class="KColorCombo" name="mColorCombo"/>
     </item>
    </layout>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KColorCombo</class>
   <extends>QComboBox</extends>
   <header>kcolorcombo.h</header>
  </customwidget>
  <customwidget>
   <class>IncidenceEditorNG::AutoCheckTreeWidget</class>
   <extends>QTreeWidget</extends>
   <header>autochecktreewidget.h</header>
  </customwidget>
 </customwidgets>
 <tabstops>
  <tabstop>mCategories</tabstop>
 </tabstops>
 <resources/>
 <connections/>
</ui>
07070111A800D5000081A40000000200000002000000015AA55A86000010C3000000FD0000001000000000000000000000005500000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/categoryeditdialog_base.ui<ui version="4.0" >
 <class>CategoryEditDialog_base</class>
 <widget class="QWidget" name="CategoryEditDialog_base" >
  <property name="geometry" >
   <rect>
    <x>0</x>
    <y>0</y>
    <width>386</width>
    <height>270</height>
   </rect>
  </property>
  <property name="windowTitle" >
   <string>Edit Categories</string>
  </property>
  <layout class="QGridLayout" >
   <property name="margin" >
    <number>0</number>
   </property>
   <property name="spacing" >
    <number>6</number>
   </property>
   <item row="1" column="0" colspan="2" >
    <widget class="QLineEdit" name="mEdit" >
     <property name="clearButtonEnabled" >
      <bool>true</bool>
     </property>
     <property name="toolTip" >
      <string>New category entry</string>
     </property>
     <property name="whatsThis" >
      <string>Type in any text you want to use as a new category or sub-category.</string>
     </property>
    </widget>
   </item>
   <item row="0" column="1" >
    <layout class="QVBoxLayout" >
     <property name="spacing" >
      <number>6</number>
     </property>
     <property name="margin" >
      <number>0</number>
     </property>
     <item>
      <widget class="QPushButton" name="mButtonAdd" >
       <property name="toolTip" >
        <string>Add the entry to the category list</string>
       </property>
       <property name="whatsThis" >
        <string>Click this button to insert the entry into the category list.</string>
       </property>
       <property name="text" >
        <string>A&amp;dd</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QPushButton" name="mButtonAddSubcategory" >
       <property name="toolTip" >
        <string>Add the entry as a subcategory of the selected category</string>
       </property>
       <property name="whatsThis" >
        <string>Click this button to insert the entry as a subcategory of the currently selected category.</string>
       </property>
       <property name="text" >
        <string>Add &amp;Subcategory</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QPushButton" name="mButtonRemove" >
       <property name="toolTip" >
        <string>Remove the selected category</string>
       </property>
       <property name="whatsThis" >
        <string>Click this button to remove the selected category from the category list.</string>
       </property>
       <property name="text" >
        <string>&amp;Remove</string>
       </property>
      </widget>
     </item>
     <item>
      <spacer>
       <property name="orientation" >
        <enum>Qt::Vertical</enum>
       </property>
       <property name="sizeType" >
        <enum>QSizePolicy::Expanding</enum>
       </property>
       <property name="sizeHint" stdset="0" >
        <size>
         <width>20</width>
         <height>50</height>
        </size>
       </property>
      </spacer>
     </item>
    </layout>
   </item>
   <item row="0" column="0" >
    <widget class="IncidenceEditorNG::AutoCheckTreeWidget" name="mCategories" >
     <property name="toolTip" >
      <string>Category list</string>
     </property>
     <property name="whatsThis" >
      <string>This is a list of all the categories available. You can create as many sub-categories as you want here.</string>
     </property>
     <property name="selectionMode" >
      <enum>QAbstractItemView::ExtendedSelection</enum>
     </property>
     <property name="allColumnsShowFocus" >
      <bool>true</bool>
     </property>
     <property name="columnCount" >
      <number>1</number>
     </property>
     <property name="autoCheck" stdset="0" >
      <bool>false</bool>
     </property>
     <column>
      <property name="text" >
       <string>Default Category</string>
      </property>
     </column>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>IncidenceEditorNG::AutoCheckTreeWidget</class>
   <extends>QTreeWidget</extends>
   <header>autochecktreewidget.h</header>
  </customwidget>
 </customwidgets>
 <tabstops>
  <tabstop>mCategories</tabstop>
  <tabstop>mEdit</tabstop>
  <tabstop>mButtonAdd</tabstop>
  <tabstop>mButtonAddSubcategory</tabstop>
  <tabstop>mButtonRemove</tabstop>
 </tabstops>
 <resources/>
 <connections/>
</ui>
07070111A800E6000081A40000000200000002000000015AA55A86000008E0000000FD0000001000000000000000000000005700000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/categoryselectdialog_base.ui<ui version="4.0" >
 <class>CategorySelectDialog_base</class>
 <widget class="QWidget" name="CategoryDialog_base" >
  <property name="geometry" >
   <rect>
    <x>0</x>
    <y>0</y>
    <width>387</width>
    <height>280</height>
   </rect>
  </property>
  <property name="windowTitle" >
   <string>Select Categories</string>
  </property>
  <layout class="QVBoxLayout" >
   <property name="margin" >
    <number>0</number>
   </property>
   <property name="spacing" >
    <number>6</number>
   </property>
   <item>
    <widget class="IncidenceEditorNG::AutoCheckTreeWidget" name="mCategories" >
     <property name="columnCount" >
      <number>1</number>
     </property>
     <column>
      <property name="text" >
       <string>Category</string>
      </property>
     </column>
    </widget>
   </item>
   <item>
    <layout class="QHBoxLayout" >
     <property name="margin" >
      <number>0</number>
     </property>
     <property name="spacing" >
      <number>6</number>
     </property>
     <item>
       <spacer>
         <property name="orientation" >
           <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType" >
           <enum>QSizePolicy::Expanding</enum>
         </property>
         <property name="sizeHint" >
           <size>
             <width>20</width>
             <height>20</height>
           </size>
         </property>
       </spacer>
     </item>
     <item>
      <widget class="QPushButton" name="mButtonClear" >
       <property name="text" >
        <string>&amp;Clear Selection</string>
       </property>
      </widget>
     </item>
     <item>
      <widget class="QPushButton" name="mButtonEdit" >
       <property name="text" >
        <string>&amp;Edit Categories...</string>
       </property>
      </widget>
     </item>
    </layout>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>IncidenceEditorNG::AutoCheckTreeWidget</class>
   <extends>QTreeWidget</extends>
   <header>autochecktreewidget.h</header>
   <container>0</container>
   <pixmap></pixmap>
  </customwidget>
 </customwidgets>
 <tabstops>
  <tabstop>mCategories</tabstop>
  <tabstop>mButtonClear</tabstop>
  <tabstop>mButtonEdit</tabstop>
 </tabstops>
 <resources/>
 <connections/>
</ui>
07070111A800E7000081A40000000200000002000000015AA55A860001045B000000FD0000001000000000000000000000004B00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/dialogdesktop.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>EventOrTodoDesktop</class>
 <widget class="QWidget" name="EventOrTodoDesktop">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>661</width>
    <height>660</height>
   </rect>
  </property>
  <layout class="QVBoxLayout" name="mainVerticalLayout">
   <item>
    <widget class="CalendarSupport::MessageWidget" name="mMessageWidget" native="true">
     <property name="visible">
      <bool>false</bool>
     </property>
    </widget>
   </item>
   <item>
    <layout class="QGridLayout" name="gridLayout">
     <property name="leftMargin">
      <number>0</number>
     </property>
     <property name="topMargin">
      <number>0</number>
     </property>
     <property name="rightMargin">
      <number>0</number>
     </property>
     <property name="bottomMargin">
      <number>0</number>
     </property>
     <item row="0" column="0">
      <widget class="QLabel" name="label">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="layoutDirection">
        <enum>Qt::LeftToRight</enum>
       </property>
       <property name="text">
        <string comment="@label:listbox The calendar to which the todo or event must be added">Calen&amp;dar:</string>
       </property>
       <property name="textFormat">
        <enum>Qt::PlainText</enum>
       </property>
       <property name="alignment">
        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
       </property>
       <property name="textInteractionFlags">
        <set>Qt::LinksAccessibleByKeyboard|Qt::LinksAccessibleByMouse</set>
       </property>
      </widget>
     </item>
     <item row="0" column="1">
      <widget class="QWidget" name="mCalSelectorPlaceHolder" native="true"/>
     </item>
     <item row="1" column="1">
      <widget class="QWidget" name="mInvitationBar" native="true">
       <layout class="QHBoxLayout" name="horizontalLayout_10">
        <property name="leftMargin">
         <number>0</number>
        </property>
        <property name="topMargin">
         <number>0</number>
        </property>
        <property name="rightMargin">
         <number>0</number>
        </property>
        <property name="bottomMargin">
         <number>0</number>
        </property>
        <item>
         <widget class="QLabel" name="label_7">
          <property name="text">
           <string comment="@info">You are Invited, what do you want to do?</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="mAcceptInvitationButton">
          <property name="toolTip">
           <string comment="@info:tooltip">Accept the invitation</string>
          </property>
          <property name="whatsThis">
           <string comment="@info:whatsthis">Click this button to accept the invitation.</string>
          </property>
          <property name="text">
           <string comment="@action:button Accept an invitation">Accept</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="mDeclineInvitationButton">
          <property name="text">
           <string comment="@action:button decline an invitation">Decline</string>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="horizontalSpacer_13">
          <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>
      </widget>
     </item>
     <item row="2" column="0">
      <widget class="QLabel" name="label_2">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="font">
        <font>
         <weight>75</weight>
         <bold>true</bold>
        </font>
       </property>
       <property name="toolTip">
        <string comment="@info:tooltip">Set the title</string>
       </property>
       <property name="whatsThis">
        <string comment="@info:whatsthis">Sets the Title of this event or to-do.</string>
       </property>
       <property name="layoutDirection">
        <enum>Qt::LeftToRight</enum>
       </property>
       <property name="text">
        <string comment="@label">&amp;Title:</string>
       </property>
       <property name="alignment">
        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
       </property>
       <property name="buddy">
        <cstring>mSummaryEdit</cstring>
       </property>
      </widget>
     </item>
     <item row="2" column="1">
      <widget class="QLineEdit" name="mSummaryEdit">
       <property name="sizePolicy">
        <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="toolTip">
        <string comment="@info:tooltip">Set the title</string>
       </property>
       <property name="whatsThis">
        <string comment="@info:whatsthis">Sets the Title of this event or to-do.</string>
       </property>
      </widget>
     </item>
     <item row="3" column="0">
      <widget class="QLabel" name="mLocationLabel">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="layoutDirection">
        <enum>Qt::LeftToRight</enum>
       </property>
       <property name="text">
        <string comment="@label">&amp;Location:</string>
       </property>
       <property name="alignment">
        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
       </property>
       <property name="buddy">
        <cstring>mLocationEdit</cstring>
       </property>
      </widget>
     </item>
     <item row="3" column="1">
      <widget class="QLineEdit" name="mLocationEdit">
       <property name="sizePolicy">
        <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="toolTip">
        <string comment="@info:tooltip">Set the location</string>
       </property>
       <property name="whatsThis">
        <string comment="@info:whatsthis">Sets where the event or to-do will take place.</string>
       </property>
      </widget>
     </item>
     <item row="4" column="0" colspan="2">
      <widget class="Line" name="line">
       <property name="orientation">
        <enum>Qt::Horizontal</enum>
       </property>
      </widget>
     </item>
     <item row="5" column="0">
      <widget class="QLabel" name="mTaskLabel">
       <property name="text">
        <string comment="@label line containing to-do specific ui controls">Completion:</string>
       </property>
       <property name="alignment">
        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
       </property>
      </widget>
     </item>
     <item row="5" column="1">
      <widget class="QWidget" name="mCompletionPriorityWidget" native="true">
       <layout class="QHBoxLayout" name="horizontalLayout_8">
        <property name="leftMargin">
         <number>0</number>
        </property>
        <property name="topMargin">
         <number>0</number>
        </property>
        <property name="rightMargin">
         <number>0</number>
        </property>
        <property name="bottomMargin">
         <number>0</number>
        </property>
        <item>
         <widget class="QSlider" name="mCompletionSlider">
          <property name="maximum">
           <number>100</number>
          </property>
          <property name="singleStep">
           <number>10</number>
          </property>
          <property name="tracking">
           <bool>true</bool>
          </property>
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="tickPosition">
           <enum>QSlider::TicksBelow</enum>
          </property>
          <property name="tickInterval">
           <number>10</number>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="mCompletedLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string comment="@label:slider Showed after the to-do percentage completed slider">completed</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="label_9">
          <property name="text">
           <string comment="@label:listbox priority of a to-do">Priority:</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="KComboBox" name="mPriorityCombo">
          <property name="currentIndex">
           <number>5</number>
          </property>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">unspecified</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">1 (highest)</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">2</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">3</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">4</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">5 (medium)</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">6</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">7</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">8</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string comment="@item:inlistbox Priority of a to-do">9 (lowest)</string>
           </property>
          </item>
         </widget>
        </item>
       </layout>
      </widget>
     </item>
     <item row="8" column="1">
      <layout class="QHBoxLayout" name="horizontalLayout_5">
       <item>
        <widget class="QCheckBox" name="mWholeDayCheck">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Set if this to-do's start and due dates have times associated with them.</string>
         </property>
         <property name="text">
          <string comment="@option:check">All Day</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <spacer name="horizontalSpacer_7">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item>
        <widget class="QCheckBox" name="mFreeBusyCheck">
         <property name="text">
          <string comment="@option:check">Blocks me for other events</string>
         </property>
        </widget>
       </item>
       <item>
        <spacer name="horizontalSpacer_12">
         <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="9" column="0">
      <widget class="QLabel" name="mStartLabel">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="layoutDirection">
        <enum>Qt::LeftToRight</enum>
       </property>
       <property name="text">
        <string comment="@label Start date/time of the event or todo">S&amp;tart:</string>
       </property>
       <property name="alignment">
        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
       </property>
       <property name="buddy">
        <cstring>mStartDateEdit</cstring>
       </property>
      </widget>
     </item>
     <item row="9" column="1">
      <layout class="QHBoxLayout" name="horizontalLayout_2">
       <item>
        <widget class="QCheckBox" name="mStartCheck">
         <property name="text">
          <string/>
         </property>
        </widget>
       </item>
       <item>
        <widget class="KDateComboBox" name="mStartDateEdit">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
          <string comment="@info:tooltip">Set the start date</string>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Sets the start date for this to-do</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="KTimeComboBox" name="mStartTimeEdit">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Sets the start time for this to-do.</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="IncidenceEditorNG::KTimeZoneComboBox" name="mTimeZoneComboStart">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Select the timezone for this event. It will also affect recurrences</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QLabel" name="mTimeZoneLabel">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="font">
          <font>
           <underline>false</underline>
          </font>
         </property>
         <property name="text">
          <string comment="@action">&lt;a href=&quot;hide&quot;&gt;&lt;font color='blue'&gt;&amp;lt;&amp;lt; Time zones&lt;/font&gt;&lt;/a&gt;</string>
         </property>
         <property name="textFormat">
          <enum>Qt::RichText</enum>
         </property>
         <property name="alignment">
          <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item>
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </item>
     <item row="10" column="0">
      <widget class="QLabel" name="mEndLabel">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="layoutDirection">
        <enum>Qt::LeftToRight</enum>
       </property>
       <property name="text">
        <string comment="@label end date/time for an event or to-do">E&amp;nd:</string>
       </property>
       <property name="alignment">
        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
       </property>
       <property name="buddy">
        <cstring>mEndDateEdit</cstring>
       </property>
      </widget>
     </item>
     <item row="10" column="1">
      <layout class="QHBoxLayout" name="horizontalLayout_4">
       <item>
        <widget class="QCheckBox" name="mEndCheck">
         <property name="text">
          <string/>
         </property>
        </widget>
       </item>
       <item>
        <widget class="KDateComboBox" name="mEndDateEdit">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Sets the due date for this to-do.</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="KTimeComboBox" name="mEndTimeEdit">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Sets the due time for this to-do.</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="IncidenceEditorNG::KTimeZoneComboBox" name="mTimeZoneComboEnd">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="whatsThis">
          <string comment="@info:whatsthis">Select the timezone for this event. It will also affect recurrences</string>
         </property>
        </widget>
       </item>
       <item>
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>0</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </item>
     <item row="11" column="0" colspan="2">
      <widget class="Line" name="line_2">
       <property name="orientation">
        <enum>Qt::Horizontal</enum>
       </property>
      </widget>
     </item>
     <item row="12" column="0" colspan="2">
      <widget class="QTabWidget" name="mTabWidget">
       <property name="currentIndex">
        <number>0</number>
       </property>
       <widget class="QWidget" name="mGeneralTab">
        <attribute name="title">
         <string comment="@title:tab General settings for an event or to-do">General</string>
        </attribute>
        <layout class="QGridLayout" name="gridLayout_9">
         <item row="2" column="1">
          <widget class="Akonadi::TagWidget" name="mTagWidget" native="true"/>
         </item>
         <item row="2" column="2">
          <widget class="QLabel" name="mSecrecyLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="toolTip">
            <string comment="@info:tooltip">Set the secrecy level</string>
           </property>
           <property name="whatsThis">
            <string comment="@info:whatsthis">Sets whether the access to this event or to-do is restricted. Please note that KOrganizer currently does not use this setting, so the implementation of the restrictions will depend on the groupware server. This means that events or to-dos marked as private or confidential may be visible to others.</string>
           </property>
           <property name="text">
            <string comment="@label:listbox sets the privacy option of the event or to-do">Access:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="0" column="0" colspan="4">
          <layout class="QHBoxLayout" name="horizontalLayout_6">
           <item>
            <widget class="QWidget" name="mEditToolBarPlaceHolder" native="true"/>
           </item>
           <item>
            <widget class="QLabel" name="mRichTextLabel">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="text">
              <string comment="@label">&lt;a href=\&quot;hide\&quot;&gt;&lt;font color='blue'&gt;Rich text &amp;gt;&amp;gt;&lt;/font&gt;&lt;/a&gt;</string>
             </property>
             <property name="textFormat">
              <enum>Qt::RichText</enum>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_9">
             <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="2" column="0">
          <widget class="QLabel" name="mCategoryLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string comment="@label">Categories:</string>
           </property>
          </widget>
         </item>
         <item row="2" column="3">
          <widget class="KComboBox" name="mSecrecyCombo">
           <property name="toolTip">
            <string comment="@info:tooltip">Set the secrecy level</string>
           </property>
           <property name="whatsThis">
            <string comment="@info:whatsthis">Sets whether the access to this event or to-do is restricted. Please note that KOrganizer currently does not use this setting, so the implementation of the restrictions will depend on the groupware server. This means that events or to-dos marked as private or confidential may be visible to others.</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0" colspan="4">
          <widget class="KPIMTextEdit::RichTextComposerWidget" name="mDescriptionEdit"/>
         </item>
        </layout>
       </widget>
       <widget class="QWidget" name="mAttendeesTab">
        <attribute name="title">
         <string comment="@title:tab attendees of this event or to-do">Attendees</string>
        </attribute>
        <layout class="QGridLayout" name="gridLayout_15">
         <item row="3" column="0" colspan="3">
          <widget class="QTableView" name="mAttendeeTable">
           <property name="editTriggers">
            <set>QAbstractItemView::AllEditTriggers</set>
           </property>
           <attribute name="verticalHeaderVisible">
            <bool>false</bool>
           </attribute>
          </widget>
         </item>
         <item row="1" column="0" colspan="2">
          <widget class="QLabel" name="label_3">
           <property name="text">
            <string comment="@label:listbox">Meeting organizer:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="2" column="0">
          <widget class="QLabel" name="label_5">
           <property name="text">
            <string comment="@label participants of this event or to-do">Participants:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="2" column="1" colspan="2">
          <layout class="QHBoxLayout" name="horizontalLayout_7">
           <item>
            <widget class="QLabel" name="mConflictsLabel">
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="mSolveButton">
             <property name="toolTip">
              <string comment="@info:tooltip">Schedule the meeting with your attendees.</string>
             </property>
             <property name="whatsThis">
              <string comment="@info:whatsthis">Opens the scheduling dialog, which will assist in picking a time slot that works for all attendees.</string>
             </property>
             <property name="text">
              <string comment="@action:button">Schedule...</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_5">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>258</width>
               <height>24</height>
              </size>
             </property>
            </spacer>
           </item>
           <item>
            <widget class="QPushButton" name="mGroupSubstitution">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Substitute with group members</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="mSelectButton">
             <property name="toolTip">
              <string comment="@info:tooltip">Select attendees from your address book.</string>
             </property>
             <property name="whatsThis">
              <string comment="@info:whatsthis">Opens your address book, allowing you to select new attendees from it.</string>
             </property>
             <property name="text">
              <string comment="@action:button">Select Attendees...</string>
             </property>
            </widget>
           </item>
          </layout>
         </item>
         <item row="1" column="2">
          <widget class="QStackedWidget" name="mOrganizerStack">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="currentIndex">
            <number>1</number>
           </property>
           <widget class="QWidget" name="page">
            <layout class="QGridLayout" name="gridLayout_2">
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item row="0" column="0">
              <widget class="KComboBox" name="mOrganizerCombo">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string comment="@info:tooltip">Set the organizer identity</string>
               </property>
               <property name="whatsThis">
                <string comment="@info:whatsthis">Sets the identity corresponding to the organizer of this to-do or event. Identities can be set in the 'Personal' section of the KOrganizer configuration. In addition, identities are gathered from your KMail settings and from your address book.</string>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
           <widget class="QWidget" name="page_2">
            <layout class="QGridLayout" name="gridLayout_3">
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item row="0" column="0">
              <widget class="QLabel" name="mOrganizerLabel">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string comment="KDE::DoNotExtract">TextLabel</string>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </widget>
         </item>
        </layout>
       </widget>
       <widget class="QWidget" name="mResourceTab">
        <attribute name="title">
         <string>Resources</string>
        </attribute>
        <layout class="QGridLayout" name="gridLayout_5">
         <item row="0" column="0">
          <widget class="QTableView" name="mResourcesTable">
           <property name="editTriggers">
            <set>QAbstractItemView::AllEditTriggers</set>
           </property>
           <property name="showGrid">
            <bool>true</bool>
           </property>
           <property name="gridStyle">
            <enum>Qt::SolidLine</enum>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
           <attribute name="horizontalHeaderHighlightSections">
            <bool>false</bool>
           </attribute>
           <attribute name="verticalHeaderVisible">
            <bool>false</bool>
           </attribute>
          </widget>
         </item>
         <item row="1" column="0">
          <layout class="QHBoxLayout" name="horizontalLayout_11">
           <item>
            <widget class="KLineEdit" name="mNewResource">
             <property name="trapEnterKeyEvent" stdset="0">
              <bool>true</bool>
             </property>
             <property name="showClearButton" stdset="0">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="mBookResourceButton">
             <property name="text">
              <string>Book resource</string>
             </property>
             <property name="autoDefault">
              <bool>false</bool>
             </property>
             <property name="default">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_14">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeType">
              <enum>QSizePolicy::Preferred</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>0</height>
              </size>
             </property>
            </spacer>
           </item>
           <item>
            <widget class="QPushButton" name="mFindResourcesButton">
             <property name="text">
              <string>Find Resources...</string>
             </property>
            </widget>
           </item>
          </layout>
         </item>
        </layout>
       </widget>
       <widget class="QWidget" name="mReminderTab">
        <attribute name="title">
         <string comment="@title:tab Tab to configure reminders for events or to-do">Reminder</string>
        </attribute>
        <layout class="QGridLayout" name="gridLayout_17">
         <item row="0" column="0">
          <widget class="QLabel" name="mQuickAddReminderLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string comment="@label">Add default reminder:</string>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
          <widget class="KComboBox" name="mAlarmPresetCombo">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
          </widget>
         </item>
         <item row="0" column="2">
          <widget class="QPushButton" name="mAlarmAddPresetButton">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string comment="@action:button Adds an reminder">Add</string>
           </property>
          </widget>
         </item>
         <item row="0" column="3">
          <spacer name="horizontalSpacer_3">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>141</width>
             <height>22</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="1" column="0" rowspan="5" colspan="4">
          <widget class="QListWidget" name="mAlarmList">
           <property name="editTriggers">
            <set>QAbstractItemView::NoEditTriggers</set>
           </property>
          </widget>
         </item>
         <item row="1" column="4">
          <widget class="QPushButton" name="mAlarmNewButton">
           <property name="text">
            <string comment="@action:button create a new reminder">New</string>
           </property>
          </widget>
         </item>
         <item row="2" column="4">
          <widget class="QPushButton" name="mAlarmConfigureButton">
           <property name="text">
            <string comment="@action:button modify the selected reminder">Modify</string>
           </property>
          </widget>
         </item>
         <item row="3" column="4">
          <widget class="QPushButton" name="mAlarmToggleButton">
           <property name="text">
            <string comment="@action:button disables selected reminder">Disable</string>
           </property>
          </widget>
         </item>
         <item row="4" column="4">
          <widget class="QPushButton" name="mAlarmRemoveButton">
           <property name="text">
            <string comment="@action:button removes selected reminders">Remove</string>
           </property>
          </widget>
         </item>
         <item row="5" column="4">
          <spacer name="verticalSpacer">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>88</width>
             <height>126</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </widget>
       <widget class="QWidget" name="mRecurrenceTab">
        <attribute name="title">
         <string comment="@title:tab">Recurrence</string>
        </attribute>
        <layout class="QGridLayout" name="gridLayout_19" columnstretch="0,1,0">
         <item row="0" column="0">
          <widget class="QLabel" name="mRepeatLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string comment="@label whether or not this event or to-do repeats">Repeats:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="0" column="1" colspan="2">
          <layout class="QHBoxLayout" name="horizontalLayout_9">
           <item>
            <widget class="KComboBox" name="mRecurrenceTypeCombo">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Lets the user chose how often an event recurs">Never</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Lets the user chose how often an event recurs">Daily</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Lets the user chose how often an event recurs">Weekly</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Lets the user chose how often an event recurs">Monthly</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Lets the user chose how often an event recurs">Yearly</string>
              </property>
             </item>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="mFrequencyLabel">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="text">
              <string comment="@label repeats every [various options]">every</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QSpinBox" name="mFrequencyEdit">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="minimum">
              <number>1</number>
             </property>
             <property name="maximum">
              <number>999</number>
             </property>
             <property name="value">
              <number>1</number>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="mRecurrenceRuleLabel">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="text">
              <string comment="@label Event or todo recurs every n day(s)">day(s)</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QCheckBox" name="mThisAndFutureCheck">
             <property name="text">
              <string>This and future occurrences.</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_10">
             <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="1" column="1" colspan="2">
          <widget class="QStackedWidget" name="mRepeatStack">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="currentIndex">
            <number>2</number>
           </property>
           <widget class="QWidget" name="never_page"/>
           <widget class="QWidget" name="daily_page">
            <layout class="QGridLayout" name="gridLayout_11">
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
            </layout>
           </widget>
           <widget class="QWidget" name="weekly_page">
            <layout class="QGridLayout" name="gridLayout_4">
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item row="0" column="0">
              <widget class="KPIM::KWeekdayCheckCombo" name="mWeekDayCombo">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="sizeAdjustPolicy">
                <enum>QComboBox::AdjustToContentsOnFirstShow</enum>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
           <widget class="QWidget" name="Monthly">
            <layout class="QGridLayout" name="gridLayout_6">
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item row="0" column="0">
              <widget class="KComboBox" name="mMonthlyCombo">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="sizeAdjustPolicy">
                <enum>QComboBox::AdjustToContents</enum>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <spacer name="horizontalSpacer_11">
               <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>
           </widget>
           <widget class="QWidget" name="yearly_page">
            <layout class="QGridLayout" name="gridLayout_7">
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item row="0" column="0">
              <widget class="KComboBox" name="mYearlyCombo">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="sizeAdjustPolicy">
                <enum>QComboBox::AdjustToContents</enum>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <spacer name="horizontalSpacer_8">
               <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>
           </widget>
          </widget>
         </item>
         <item row="2" column="0">
          <widget class="QLabel" name="mRecurrenceEndLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string comment="@label recurrence ends on|after">Ends:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="2" column="1" colspan="2">
          <layout class="QHBoxLayout" name="horizontalLayout">
           <property name="spacing">
            <number>0</number>
           </property>
           <item>
            <widget class="KComboBox" name="mRecurrenceEndCombo">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Speficies when a recurring events end">never</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Speficies when a recurring events end">on</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string comment="@item:inlistbox Speficies when a recurring events end">after</string>
              </property>
             </item>
            </widget>
           </item>
           <item>
            <widget class="QStackedWidget" name="mRecurrenceEndStack">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="currentIndex">
              <number>2</number>
             </property>
             <widget class="QWidget" name="no_end">
              <layout class="QGridLayout" name="gridLayout_16">
               <property name="leftMargin">
                <number>0</number>
               </property>
               <property name="topMargin">
                <number>0</number>
               </property>
               <property name="rightMargin">
                <number>0</number>
               </property>
               <property name="bottomMargin">
                <number>0</number>
               </property>
              </layout>
             </widget>
             <widget class="QWidget" name="end_on">
              <layout class="QGridLayout" name="gridLayout_14">
               <property name="leftMargin">
                <number>0</number>
               </property>
               <property name="topMargin">
                <number>0</number>
               </property>
               <property name="rightMargin">
                <number>0</number>
               </property>
               <property name="bottomMargin">
                <number>0</number>
               </property>
               <item row="0" column="0">
                <widget class="KDateComboBox" name="mRecurrenceEndDate">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="whatsThis">
                  <string comment="@info:whatsthis">Date after which the event or to-do should stop recurring</string>
                 </property>
                </widget>
               </item>
               <item row="0" column="1">
                <spacer name="horizontalSpacer_6">
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>276</width>
                   <height>18</height>
                  </size>
                 </property>
                </spacer>
               </item>
              </layout>
             </widget>
             <widget class="QWidget" name="end_after">
              <layout class="QGridLayout" name="gridLayout_10">
               <property name="leftMargin">
                <number>0</number>
               </property>
               <property name="topMargin">
                <number>0</number>
               </property>
               <property name="rightMargin">
                <number>0</number>
               </property>
               <property name="bottomMargin">
                <number>0</number>
               </property>
               <property name="horizontalSpacing">
                <number>0</number>
               </property>
               <item row="0" column="0">
                <widget class="QSpinBox" name="mEndDurationEdit">
                 <property name="minimum">
                  <number>1</number>
                 </property>
                 <property name="maximum">
                  <number>9999</number>
                 </property>
                </widget>
               </item>
               <item row="0" column="1">
                <widget class="QLabel" name="mRecurrenceOccurrencesLabel">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="text">
                  <string comment="@label">occurrence(s)</string>
                 </property>
                </widget>
               </item>
              </layout>
             </widget>
            </widget>
           </item>
          </layout>
         </item>
         <item row="3" column="0" rowspan="2">
          <widget class="QLabel" name="mExceptionsLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string comment="@label exceptions for the recurrence">Exceptions:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="3" column="1" rowspan="2" colspan="2">
          <layout class="QHBoxLayout" name="horizontalLayout_3">
           <item>
            <widget class="KDateComboBox" name="mExceptionDateEdit">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="mExceptionAddButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string comment="@action:button adds an exception on the recurrence">Add</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_4">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item row="5" column="1">
          <widget class="QListWidget" name="mExceptionList">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="selectionMode">
            <enum>QAbstractItemView::ExtendedSelection</enum>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
          <widget class="QLabel" name="mOnLabel">
           <property name="text">
            <string comment="@label The event ends on [different options]">on:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item row="5" column="2">
          <layout class="QVBoxLayout" name="verticalLayout">
           <item>
            <widget class="QPushButton" name="mExceptionRemoveButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string comment="@action:button removes an exception">Remove</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="verticalSpacer_5">
             <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>
        </layout>
       </widget>
       <widget class="QWidget" name="mAttachmentsTab">
        <attribute name="title">
         <string comment="@title:tab configure attachments of an event or todo">Attachments</string>
        </attribute>
        <layout class="QGridLayout" name="gridLayout_18">
         <item row="0" column="0" rowspan="3">
          <widget class="QWidget" name="mAttachmentViewPlaceHolder" native="true">
           <property name="sizePolicy">
            <sizepolicy hsizetype="MinimumExpanding" vsizetype="Expanding">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
          <widget class="QPushButton" name="mAddButton">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="toolTip">
            <string comment="@info:tooltip">Add an attachment</string>
           </property>
           <property name="whatsThis">
            <string comment="@info:whatsthis">Shows a dialog used to select an attachment to add to this event or to-do as link or as inline data.</string>
           </property>
           <property name="text">
            <string comment="@action:button adds an attachment">Add</string>
           </property>
          </widget>
         </item>
         <item row="1" column="1">
          <widget class="QPushButton" name="mRemoveButton">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="toolTip">
            <string comment="@info:tooltip">Remove the selected attachment</string>
           </property>
           <property name="whatsThis">
            <string comment="@info:whatsthis">Removes the attachment selected in the list above from this event or to-do.</string>
           </property>
           <property name="text">
            <string comment="@action:button remove an attachment">Remove</string>
           </property>
          </widget>
         </item>
         <item row="2" column="1">
          <spacer name="verticalSpacer_4">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>210</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </widget>
      </widget>
     </item>
     <item row="6" column="0" colspan="2">
      <widget class="KSeparator" name="mTaskSeparator"/>
     </item>
    </layout>
   </item>
   <item>
    <widget class="QDialogButtonBox" name="buttonBox">
     <property name="standardButtons">
      <set>QDialogButtonBox::Apply|QDialogButtonBox::Cancel|QDialogButtonBox::Ok|QDialogButtonBox::RestoreDefaults</set>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KPIM::KCheckComboBox</class>
   <extends>KComboBox</extends>
   <header>Libkdepim/KCheckComboBox</header>
  </customwidget>
  <customwidget>
   <class>KLineEdit</class>
   <extends>QLineEdit</extends>
   <header>klineedit.h</header>
  </customwidget>
  <customwidget>
   <class>KTimeComboBox</class>
   <extends>QComboBox</extends>
   <header>ktimecombobox.h</header>
  </customwidget>
  <customwidget>
   <class>KDateComboBox</class>
   <extends>QComboBox</extends>
   <header>kdatecombobox.h</header>
  </customwidget>
  <customwidget>
   <class>KSeparator</class>
   <extends>QFrame</extends>
   <header>kseparator.h</header>
   <container>1</container>
  </customwidget>
  <customwidget>
   <class>KComboBox</class>
   <extends>QComboBox</extends>
   <header>kcombobox.h</header>
  </customwidget>
  <customwidget>
   <class>KPIMTextEdit::RichTextComposerWidget</class>
   <extends>QWidget</extends>
   <header>kpimtextedit/richtextcomposerwidget.h</header>
  </customwidget>
  <customwidget>
   <class>KPIM::KWeekdayCheckCombo</class>
   <extends>KPIM::KCheckComboBox</extends>
   <header>Libkdepim/KWeekdayCheckCombo</header>
  </customwidget>
  <customwidget>
   <class>IncidenceEditorNG::KTimeZoneComboBox</class>
   <extends>KComboBox</extends>
   <header>ktimezonecombobox.h</header>
  </customwidget>
  <customwidget>
   <class>CalendarSupport::MessageWidget</class>
   <extends>QWidget</extends>
   <header>CalendarSupport/MessageWidget</header>
  </customwidget>
  <customwidget>
   <class>Akonadi::TagWidget</class>
   <extends>QWidget</extends>
   <header location="global">AkonadiWidgets/TagWidget</header>
   <container>1</container>
  </customwidget>
 </customwidgets>
 <tabstops>
  <tabstop>mCalSelectorPlaceHolder</tabstop>
  <tabstop>mAcceptInvitationButton</tabstop>
  <tabstop>mDeclineInvitationButton</tabstop>
  <tabstop>mSummaryEdit</tabstop>
  <tabstop>mLocationEdit</tabstop>
  <tabstop>mCompletionSlider</tabstop>
  <tabstop>mPriorityCombo</tabstop>
  <tabstop>mWholeDayCheck</tabstop>
  <tabstop>mFreeBusyCheck</tabstop>
  <tabstop>mStartCheck</tabstop>
  <tabstop>mStartDateEdit</tabstop>
  <tabstop>mStartTimeEdit</tabstop>
  <tabstop>mTimeZoneComboStart</tabstop>
  <tabstop>mEndCheck</tabstop>
  <tabstop>mEndDateEdit</tabstop>
  <tabstop>mEndTimeEdit</tabstop>
  <tabstop>mTimeZoneComboEnd</tabstop>
  <tabstop>mTabWidget</tabstop>
  <tabstop>mTagWidget</tabstop>
  <tabstop>mSecrecyCombo</tabstop>
  <tabstop>mSolveButton</tabstop>
  <tabstop>mSelectButton</tabstop>
  <tabstop>mOrganizerCombo</tabstop>
  <tabstop>mAlarmPresetCombo</tabstop>
  <tabstop>mAlarmAddPresetButton</tabstop>
  <tabstop>mAlarmList</tabstop>
  <tabstop>mAlarmNewButton</tabstop>
  <tabstop>mAlarmConfigureButton</tabstop>
  <tabstop>mAlarmToggleButton</tabstop>
  <tabstop>mAlarmRemoveButton</tabstop>
  <tabstop>mRecurrenceTypeCombo</tabstop>
  <tabstop>mFrequencyEdit</tabstop>
  <tabstop>mThisAndFutureCheck</tabstop>
  <tabstop>mWeekDayCombo</tabstop>
  <tabstop>mMonthlyCombo</tabstop>
  <tabstop>mYearlyCombo</tabstop>
  <tabstop>mRecurrenceEndCombo</tabstop>
  <tabstop>mRecurrenceEndDate</tabstop>
  <tabstop>mEndDurationEdit</tabstop>
  <tabstop>mExceptionDateEdit</tabstop>
  <tabstop>mExceptionAddButton</tabstop>
  <tabstop>mExceptionList</tabstop>
  <tabstop>mExceptionRemoveButton</tabstop>
  <tabstop>mAddButton</tabstop>
  <tabstop>mRemoveButton</tabstop>
 </tabstops>
 <resources/>
 <connections>
  <connection>
   <sender>mRecurrenceEndCombo</sender>
   <signal>activated(int)</signal>
   <receiver>mRecurrenceEndStack</receiver>
   <slot>setCurrentIndex(int)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>144</x>
     <y>314</y>
    </hint>
    <hint type="destinationlabel">
     <x>144</x>
     <y>314</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>mRecurrenceTypeCombo</sender>
   <signal>activated(int)</signal>
   <receiver>mRepeatStack</receiver>
   <slot>setCurrentIndex(int)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>142</x>
     <y>304</y>
    </hint>
    <hint type="destinationlabel">
     <x>104</x>
     <y>280</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>mNewResource</sender>
   <signal>returnPressed()</signal>
   <receiver>mBookResourceButton</receiver>
   <slot>click()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>271</x>
     <y>805</y>
    </hint>
    <hint type="destinationlabel">
     <x>402</x>
     <y>808</y>
    </hint>
   </hints>
  </connection>
 </connections>
</ui>
07070111A800E8000081A40000000200000002000000015AA55A8600000D5A000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/resourcemanagement.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>resourceManagement</class>
 <widget class="QWidget" name="resourceManagement">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>552</width>
    <height>566</height>
   </rect>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout_5">
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item>
    <widget class="QSplitter" name="splitter_2">
     <property name="orientation">
      <enum>Qt::Horizontal</enum>
     </property>
     <property name="childrenCollapsible">
      <bool>false</bool>
     </property>
     <widget class="QWidget" name="layoutWidget">
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="KLineEdit" name="resourceSearch">
         <property name="showClearButton" stdset="0">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QTreeView" name="treeResults">
         <property name="alternatingRowColors">
          <bool>true</bool>
         </property>
         <property name="selectionBehavior">
          <enum>QAbstractItemView::SelectRows</enum>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
     <widget class="QSplitter" name="splitter">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="childrenCollapsible">
       <bool>false</bool>
      </property>
      <widget class="QWidget" name="layoutWidget">
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <item>
         <widget class="QGroupBox" name="groupDetails">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="title">
           <string>Details</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_4">
           <property name="rightMargin">
            <number>4</number>
           </property>
           <item>
            <layout class="QFormLayout" name="formDetails"/>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupOwner">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="title">
           <string>Owner</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_2">
           <item>
            <layout class="QFormLayout" name="formOwner"/>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="layoutWidget">
       <layout class="QHBoxLayout" name="resourceCalender">
        <property name="sizeConstraint">
         <enum>QLayout::SetDefaultConstraint</enum>
        </property>
       </layout>
      </widget>
     </widget>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KLineEdit</class>
   <extends>QLineEdit</extends>
   <header>klineedit.h</header>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections/>
</ui>
07070111A800E9000081A40000000200000002000000015AA55A86000023BD000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/schedulingdialog.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>Dialog</class>
 <widget class="QWidget" name="Dialog">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>558</width>
    <height>502</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Schedule a time</string>
  </property>
  <layout class="QGridLayout" name="gridLayout_2">
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item row="0" column="0">
    <layout class="QHBoxLayout" name="horizontalLayout_3">
     <item>
      <layout class="QFormLayout" name="formLayout">
       <property name="fieldGrowthPolicy">
        <enum>QFormLayout::ExpandingFieldsGrow</enum>
       </property>
       <item row="0" column="0">
        <widget class="QLabel" name="label">
         <property name="text">
          <string>Earliest time to start:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
          <widget class="KDateComboBox" name="mStartDate"/>
         </item>
         <item>
          <widget class="KTimeComboBox" name="mStartTime"/>
         </item>
        </layout>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label_2">
         <property name="text">
          <string>Latest time to end:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <layout class="QHBoxLayout" name="horizontalLayout_2">
         <item>
          <widget class="KDateComboBox" name="mEndDate"/>
         </item>
         <item>
          <widget class="KTimeComboBox" name="mEndTime"/>
         </item>
        </layout>
       </item>
      </layout>
     </item>
     <item>
      <layout class="QFormLayout" name="formLayout_2">
       <item row="0" column="0">
        <widget class="QLabel" name="label_3">
         <property name="toolTip">
          <string>Check the weekdays to include in the search.</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string>Only the checked weekdays will be included in the free time slot search.</string>
         </property>
         <property name="text">
          <string>Allowed weekdays:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="KPIM::KWeekdayCheckCombo" name="mWeekdayCombo">
         <property name="sizePolicy">
          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
          <string>Check the weekdays to include in the search.</string>
         </property>
         <property name="whatsThis">
          <string>Only the checked weekdays will be included in the free time slot search.</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label_5">
         <property name="toolTip">
          <string>Check the roles to include in the search.</string>
         </property>
         <property name="whatsThis">
          <string>Only the participants with the checked roles will be considered in the free time slot search.</string>
         </property>
         <property name="text">
          <string>Mandatory roles:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="KPIM::KCheckComboBox" name="mRolesCombo">
         <property name="sizePolicy">
          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
          <string>Check the roles to include in the search.</string>
         </property>
         <property name="whatsThis">
          <string>Only the participants with the checked roles will be considered in the free time slot search.</string>
         </property>
        </widget>
       </item>
      </layout>
     </item>
    </layout>
   </item>
   <item row="1" column="0">
    <widget class="QTabWidget" name="mTabWidget">
     <property name="currentIndex">
      <number>0</number>
     </property>
     <widget class="QWidget" name="mTextTab">
      <attribute name="title">
       <string>Automatic Search</string>
      </attribute>
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0">
        <widget class="QTableView" name="mTableView">
         <property name="alternatingRowColors">
          <bool>true</bool>
         </property>
         <property name="selectionMode">
          <enum>QAbstractItemView::SingleSelection</enum>
         </property>
         <property name="selectionBehavior">
          <enum>QAbstractItemView::SelectRows</enum>
         </property>
         <property name="showGrid">
          <bool>false</bool>
         </property>
         <attribute name="horizontalHeaderVisible">
          <bool>false</bool>
         </attribute>
         <attribute name="horizontalHeaderStretchLastSection">
          <bool>true</bool>
         </attribute>
         <attribute name="verticalHeaderVisible">
          <bool>false</bool>
         </attribute>
         <attribute name="verticalHeaderStretchLastSection">
          <bool>false</bool>
         </attribute>
        </widget>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="mGanttTab">
      <attribute name="title">
       <string>Visual Search</string>
      </attribute>
     </widget>
    </widget>
   </item>
   <item row="2" column="0">
    <widget class="QGroupBox" name="mMoveApptGroupBox">
     <property name="title">
      <string>Move your appointment to:</string>
     </property>
     <layout class="QVBoxLayout" name="verticalLayout_3">
      <item>
       <layout class="QHBoxLayout" name="horizontalLayout_4">
        <item>
         <spacer name="horizontalSpacer">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>40</width>
            <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QLabel" name="mMoveDayLabel">
          <property name="text">
           <string>Monday, 12th June</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="KTimeComboBox" name="mMoveBeginTimeEdit"/>
        </item>
        <item>
         <widget class="QLabel" name="mMoveEndTimeLabel">
          <property name="text">
           <string>to 10:00am</string>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="horizontalSpacer_2">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>40</width>
            <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </item>
     </layout>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KPIM::KCheckComboBox</class>
   <extends>KComboBox</extends>
   <header>Libkdepim/KCheckComboBox</header>
  </customwidget>
  <customwidget>
   <class>KComboBox</class>
   <extends>QComboBox</extends>
   <header>kcombobox.h</header>
  </customwidget>
  <customwidget>
   <class>KDateComboBox</class>
   <extends>QComboBox</extends>
   <header>kdatecombobox.h</header>
  </customwidget>
  <customwidget>
   <class>KTimeComboBox</class>
   <extends>QComboBox</extends>
   <header>ktimecombobox.h</header>
  </customwidget>
  <customwidget>
   <class>KPIM::KWeekdayCheckCombo</class>
   <extends>KPIM::KCheckComboBox</extends>
   <header>Libkdepim/KWeekdayCheckCombo</header>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections/>
</ui>
07070111A800EA000081A40000000200000002000000015AA55A8600000F2B000000FD0000001000000000000000000000005D00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/ui/template_management_dialog_base.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>TemplateManagementDialog_base</class>
 <widget class="QWidget" name="TemplateManagementDialog_base">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>664</width>
    <height>390</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Template Management</string>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <property name="margin">
    <number>0</number>
   </property>
   <item row="0" column="0" colspan="2">
    <widget class="QLabel" name="m_introLabel">
     <property name="frameShape">
      <enum>QFrame::NoFrame</enum>
     </property>
     <property name="text">
      <string comment="@label">Select a template and click &lt;i&gt;Apply&lt;/i&gt; to apply it to this item. Click &lt;i&gt;New&lt;/i&gt; to create a new template based on the current item settings.</string>
     </property>
     <property name="wordWrap">
      <bool>true</bool>
     </property>
    </widget>
   </item>
   <item row="1" column="0">
    <widget class="QListWidget" name="m_listBox">
     <property name="sizePolicy">
      <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="toolTip">
      <string>The list of managed templates</string>
     </property>
     <property name="whatsThis">
      <string>This is a list of all the templates you have currently accessible for creating new calendar items.</string>
     </property>
    </widget>
   </item>
   <item row="1" column="1">
    <layout class="QVBoxLayout" name="verticalLayout_2">
     <item>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QPushButton" name="m_buttonAdd">
         <property name="toolTip">
          <string>Create a new template from the current settings</string>
         </property>
         <property name="whatsThis">
          <string>Click on this button to create a new template based on the current settings in the editor. You can use this template to quickly add new items in the future.</string>
         </property>
         <property name="text">
          <string>&amp;New...</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QPushButton" name="m_buttonRemove">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Remove the currently selected template</string>
         </property>
         <property name="whatsThis">
          <string>Clicking this button will permanently remove the selected template from your list of managed templates.</string>
         </property>
         <property name="text">
          <string>&amp;Remove</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QPushButton" name="m_buttonApply">
         <property name="toolTip">
          <string>Apply the selected template settings</string>
         </property>
         <property name="whatsThis">
          <string>Clicking this button will apply the settings from the selected template to the item you are currently editing.</string>
         </property>
         <property name="text">
          <string>Apply</string>
         </property>
        </widget>
       </item>
      </layout>
     </item>
     <item>
      <spacer name="verticalSpacer">
       <property name="orientation">
        <enum>Qt::Vertical</enum>
       </property>
       <property name="sizeHint" stdset="0">
        <size>
         <width>20</width>
         <height>108</height>
        </size>
       </property>
      </spacer>
     </item>
    </layout>
   </item>
  </layout>
 </widget>
 <resources/>
 <connections/>
</ui>
07070111A003C6000081A40000000200000002000000015AA55A8600002CA4000000FD0000001000000000000000000000005000000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/visualfreebusywidget.cpp/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (c) 2009-2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

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 "visualfreebusywidget.h"
#include "freebusyganttproxymodel.h"
#include "CalendarSupport/FreeBusyItemModel"

#include <KGantt/KGanttGraphicsView>
#include <KGantt/KGanttView>
#include <KGantt/KGanttDateTimeGrid>
#include <KGantt/KGanttAbstractRowController>

#include <KComboBox>
#include "incidenceeditor_debug.h"
#include <KLocalizedString>

#include <QHeaderView>
#include <QLabel>
#include <QPointer>
#include <QPushButton>
#include <QScrollBar>
#include <QSplitter>
#include <QTreeView>
#include <QVBoxLayout>

using namespace IncidenceEditorNG;

namespace IncidenceEditorNG {
class RowController : public KGantt::AbstractRowController
{
private:
    static const int ROW_HEIGHT;
    QPointer<QAbstractItemModel> m_model;

public:
    RowController()
    {
        mRowHeight = 20;
    }

void setModel(QAbstractItemModel *model)
    {
        m_model = model;
    }

int headerHeight() const override
    {
        return 2 * mRowHeight + 10;
    }

bool isRowVisible(const QModelIndex &) const override
    {
        return true;
    }

bool isRowExpanded(const QModelIndex &) const override
    {
        return false;
    }

KGantt::Span rowGeometry(const QModelIndex &idx) const override
    {
        return KGantt::Span(idx.row() * mRowHeight, mRowHeight);
    }

int maximumItemHeight() const override
    {
        return mRowHeight / 2;
    }

int totalHeight() const override
    {
        return m_model->rowCount() * mRowHeight;
    }

QModelIndex indexAt(int height) const override
    {
        return m_model->index(height / mRowHeight, 0);
    }

QModelIndex indexBelow(const QModelIndex &idx) const override
    {
        if (!idx.isValid()) {
            return QModelIndex();
        }
        return idx.model()->index(idx.row() + 1, idx.column(), idx.parent());
    }

QModelIndex indexAbove(const QModelIndex &idx) const override
    {
        if (!idx.isValid()) {
            return QModelIndex();
        }
        return idx.model()->index(idx.row() - 1, idx.column(), idx.parent());
    }

void setRowHeight(int height)
    {
        mRowHeight = height;
    }

private:
    int mRowHeight;
};

class GanttHeaderView : public QHeaderView
{
public:
    explicit GanttHeaderView(QWidget *parent = nullptr) : QHeaderView(Qt::Horizontal, parent)
    {
    }

QSize sizeHint() const override
    {
        QSize s = QHeaderView::sizeHint();
        s.rheight() *= 2;
        return s;
    }
};
}

VisualFreeBusyWidget::VisualFreeBusyWidget(CalendarSupport::FreeBusyItemModel *model, int spacing,
                                           QWidget *parent)
    : QWidget(parent)
    , mGanttGrid(nullptr)
    , mScaleCombo(nullptr)
{
    QVBoxLayout *topLayout = new QVBoxLayout(this);
    topLayout->setSpacing(spacing);

// The control panel for the gantt widget
    QBoxLayout *controlLayout = new QHBoxLayout();
    controlLayout->setSpacing(topLayout->spacing());
    topLayout->addItem(controlLayout);

QLabel *label = new QLabel(i18nc("@label", "Scale: "), this);
    controlLayout->addWidget(label);

mScaleCombo = new KComboBox(this);
    mScaleCombo->setToolTip(
        i18nc("@info:tooltip", "Set the Gantt chart zoom level"));
    mScaleCombo->setWhatsThis(
        xi18nc("@info:whatsthis",
               "Select the Gantt chart zoom level from one of the following:<nl/>"
               "'Hour' shows a range of several hours,<nl/>"
               "'Day' shows a range of a few days,<nl/>"
               "'Week' shows a range of a few months,<nl/>"
               "and 'Month' shows a range of a few years,<nl/>"
               "while 'Automatic' selects the range most "
               "appropriate for the current event or to-do."));
    mScaleCombo->addItem(i18nc("@item:inlistbox range in hours", "Hour"),
                         QVariant::fromValue<int>(KGantt::DateTimeGrid::ScaleHour));
    mScaleCombo->addItem(i18nc("@item:inlistbox range in days", "Day"),
                         QVariant::fromValue<int>(KGantt::DateTimeGrid::ScaleDay));
    mScaleCombo->addItem(i18nc("@item:inlistbox range in weeks", "Week"),
                         QVariant::fromValue<int>(KGantt::DateTimeGrid::ScaleWeek));
    mScaleCombo->addItem(i18nc("@item:inlistbox range in months", "Month"),
                         QVariant::fromValue<int>(KGantt::DateTimeGrid::ScaleMonth));
    mScaleCombo->addItem(i18nc("@item:inlistbox range is computed automatically", "Automatic"),
                         QVariant::fromValue<int>(KGantt::DateTimeGrid::ScaleAuto));
    mScaleCombo->setCurrentIndex(0);   // start with "hour"
    connect(mScaleCombo, QOverload< int>::of(&KComboBox::activated), this, &VisualFreeBusyWidget::slotScaleChanged);
    controlLayout->addWidget(mScaleCombo);

QPushButton *button = new QPushButton(i18nc("@action:button", "Center on Start"), this);
    button->setToolTip(
        i18nc("@info:tooltip",
              "Center the Gantt chart on the event start date and time"));
    button->setWhatsThis(
        i18nc("@info:whatsthis",
              "Click this button to center the Gantt chart on the start "
              "time and day of this event."));
    connect(button, &QPushButton::clicked, this, &VisualFreeBusyWidget::slotCenterOnStart);
    controlLayout->addWidget(button);

controlLayout->addStretch(1);

button = new QPushButton(i18nc("@action:button", "Pick Date"), this);
    button->setToolTip(
        i18nc("@info:tooltip",
              "Move the event to a date and time when all "
              "attendees are available"));
    button->setWhatsThis(
        i18nc("@info:whatsthis",
              "Click this button to move the event to a date "
              "and time when all the attendees have time "
              "available in their Free/Busy lists."));
    button->setEnabled(false);
    connect(button, &QPushButton::clicked, this, &VisualFreeBusyWidget::slotPickDate);
    controlLayout->addWidget(button);

controlLayout->addStretch(1);

button = new QPushButton(i18nc("@action:button reload freebusy data", "Reload"), this);
    button->setToolTip(
        i18nc("@info:tooltip",
              "Reload Free/Busy data for all attendees"));
    button->setWhatsThis(
        i18nc("@info:whatsthis",
              "Pressing this button will cause the Free/Busy data for all "
              "attendees to be reloaded from their corresponding servers."));
    controlLayout->addWidget(button);
    connect(button, &QPushButton::clicked, this, &VisualFreeBusyWidget::manualReload);

QSplitter *splitter = new QSplitter(Qt::Horizontal, this);
    connect(splitter, &QSplitter::splitterMoved, this, &VisualFreeBusyWidget::splitterMoved);
    mLeftView = new QTreeView(this);
    mLeftView->setModel(model);
    mLeftView->setHeader(new GanttHeaderView);
    mLeftView->header()->setStretchLastSection(true);
    mLeftView->setRootIsDecorated(false);
    mLeftView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    mLeftView->setContextMenuPolicy(Qt::CustomContextMenu);
    mGanttGraphicsView = new KGantt::GraphicsView(this);
    mGanttGraphicsView->setObjectName(QStringLiteral("mGanttGraphicsView"));
    mGanttGraphicsView->setToolTip(
        i18nc("@info:tooltip",
              "Shows the Free/Busy status of all attendees"));
    mGanttGraphicsView->setWhatsThis(
        i18nc("@info:whatsthis",
              "Shows the Free/Busy status of all attendees. "
              "Double-clicking on an attendee's entry in the "
              "list will allow you to enter the location of "
              "their Free/Busy Information."));
    mModel = new FreeBusyGanttProxyModel(this);
    mModel->setSourceModel(model);

mRowController = new RowController;
    mRowController->setRowHeight(fontMetrics().height());   //TODO: detect

mRowController->setModel(mModel);
    mGanttGraphicsView->setRowController(mRowController);

mGanttGrid = new KGantt::DateTimeGrid;
    mGanttGrid->setScale(KGantt::DateTimeGrid::ScaleHour);
    mGanttGrid->setDayWidth(800);
    mGanttGrid->setRowSeparators(true);
    mGanttGraphicsView->setGrid(mGanttGrid);
    mGanttGraphicsView->setModel(mModel);
    mGanttGraphicsView->viewport()->setFixedWidth(800 * 30);

splitter->addWidget(mLeftView);
    splitter->addWidget(mGanttGraphicsView);

topLayout->addWidget(splitter);
    topLayout->setStretchFactor(splitter, 100);

// Initially, show 15 days back and forth
    // set start to even hours, i.e. to 12:AM 0 Min 0 Sec
    QDateTime horizonStart
        = QDateTime(QDateTime::currentDateTime().addDays(-15).date());
    mGanttGrid->setStartDateTime(horizonStart);

connect(mLeftView, &QTreeView::customContextMenuRequested, this,
            &VisualFreeBusyWidget::showAttendeeStatusMenu);

}

VisualFreeBusyWidget::~VisualFreeBusyWidget()
{
}

void VisualFreeBusyWidget::showAttendeeStatusMenu()
{
}

void VisualFreeBusyWidget::slotCenterOnStart()
{
    KGantt::DateTimeGrid *grid = static_cast<KGantt::DateTimeGrid *>(mGanttGraphicsView->grid());
    int daysTo = grid->startDateTime().daysTo(mDtStart);
    mGanttGraphicsView->horizontalScrollBar()->setValue(daysTo * 800);
}

void VisualFreeBusyWidget::slotIntervalColorRectangleMoved(const QDateTime &start,
                                                           const QDateTime &end)
{
    mDtStart = start;
    mDtEnd = end;
    Q_EMIT dateTimesChanged(start, end);
}

/*!
  This slot is called when the user clicks the "Pick a date" button.
*/
void VisualFreeBusyWidget::slotPickDate()
{
}

void VisualFreeBusyWidget::slotScaleChanged(int newScale)
{
    const QVariant var = mScaleCombo->itemData(newScale);
    Q_ASSERT(var.isValid());

int value = var.toInt();
    mGanttGrid->setScale((KGantt::DateTimeGrid::Scale)value);
}

void VisualFreeBusyWidget::slotUpdateIncidenceStartEnd(const QDateTime &dtFrom,
                                                       const QDateTime &dtTo)
{
    mDtStart = dtFrom;
    mDtEnd = dtTo;
    QDateTime horizonStart = QDateTime(dtFrom.addDays(-15).date());
    KGantt::DateTimeGrid *grid = static_cast<KGantt::DateTimeGrid *>(mGanttGraphicsView->grid());
    grid->setStartDateTime(horizonStart);
    slotCenterOnStart();
    mGanttGrid->setStartDateTime(horizonStart);
}

void VisualFreeBusyWidget::slotZoomToTime()
{
#if 0
    mGanttGraphicsView->zoomToFit();
#else
    qCDebug(INCIDENCEEDITOR_LOG) << "Disabled code, port to KDGantt2";
#endif
}

void VisualFreeBusyWidget::splitterMoved()
{
}
07070111A003C7000081A40000000200000002000000015AA55A8600000928000000FD0000001000000000000000000000004E00000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/src/visualfreebusywidget.h/*
  Copyright (C) 2010 Casey Link <unnamedrambler@gmail.com>
  Copyright (C) 2009-2010 Klaralvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>

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 INCIDENCEEDITOR_VISUALFREEBUSYWIDGET_H
#define INCIDENCEEDITOR_VISUALFREEBUSYWIDGET_H

#include <QDateTime>
#include <QWidget>

namespace KGantt {
class DateTimeGrid;
class GraphicsView;
}

namespace CalendarSupport {
class FreeBusyItemModel;
}

class KComboBox;
class QTreeView;

namespace IncidenceEditorNG {
class FreeBusyGanttProxyModel;
class RowController;

class VisualFreeBusyWidget : public QWidget
{
    Q_OBJECT
public:
    explicit VisualFreeBusyWidget(CalendarSupport::FreeBusyItemModel *model, int spacing = 8,
                                  QWidget *parent = nullptr);
    ~VisualFreeBusyWidget();

public Q_SLOTS:
    void slotUpdateIncidenceStartEnd(const QDateTime &, const QDateTime &);

Q_SIGNALS:
    void dateTimesChanged(const QDateTime &, const QDateTime &);
    void manualReload();

protected Q_SLOTS:
    void slotScaleChanged(int);
    void slotCenterOnStart();
    void slotZoomToTime();
    void slotPickDate();
    void showAttendeeStatusMenu();
    void slotIntervalColorRectangleMoved(const QDateTime &start, const QDateTime &end);

private:
    void splitterMoved();
    KGantt::GraphicsView *mGanttGraphicsView = nullptr;
    QTreeView *mLeftView = nullptr;
    RowController *mRowController = nullptr;
    KGantt::DateTimeGrid *mGanttGrid = nullptr;

KComboBox *mScaleCombo = nullptr;
    FreeBusyGanttProxyModel *mModel = nullptr;

QDateTime mDtStart, mDtEnd;
};
}
#endif
07070111AC00D3000041ED0000000200000002000000025AA55A8600000000000000FD0000001000000000000000000000003900000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/tests07070111AC00D4000081A40000000200000002000000015AA55A8600000213000000FD0000001000000000000000000000004800000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/tests/CMakeLists.txtset( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )

include_directories(
 ../
)

set(resourcemanagement_gui_SRCS resourcemanagment_gui.cpp)
add_executable(resourcemanagement_gui ${resourcemanagement_gui_SRCS})
target_link_libraries(resourcemanagement_gui
  Qt5::Core
  Qt5::Gui
  KF5::Mime
  KF5::IncidenceEditor
  KF5::Libkdepim
  KF5::Ldap
)

add_executable(individualmaildialog_test individualmaildialog_test.cpp ../src/individualmaildialog.cpp)
target_link_libraries(individualmaildialog_test
    KF5::IncidenceEditor
)
07070111AC00D5000081A40000000200000002000000015AA55A8600000684000000FD0000001000000000000000000000005700000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/tests/individualmaildialog_test.cpp/*
    Copyright (C) 2017 Volker Krause <vkrause@kde.org>

This program 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 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 Library 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 <http://www.gnu.org/licenses/>.
*/

#include "../src/individualmaildialog.h"

#include <KGuiItem>
#include <QApplication>

using namespace IncidenceEditorNG;

int main(int argc, char **argv)
{
    QApplication app(argc, argv);

KCalCore::Attendee::List attendees;
    KGuiItem buttonYes = KGuiItem(QStringLiteral("Send Email"));
    KGuiItem buttonNo = KGuiItem(QStringLiteral("Do not send"));

attendees << attendee1 << attendee2 << attendee3;

IndividualMailDialog dialog(QStringLiteral("title"), attendees, buttonYes, buttonNo, nullptr);
    dialog.show();
    return app.exec();
}
07070111AC00D7000081A40000000200000002000000015AA55A8600000520000000FD0000001000000000000000000000005300000000incidenceeditor-VERSIONgit.20180311T173414~fbfddcd/tests/resourcemanagment_gui.cpp/* Copyright 2014 Sandro Knauß <knauss@kolabsys.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) 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 <http://www.gnu.org/licenses/>.
*/

#include "resourcemanagement.h"

#include <QApplication>
#include <QCommandLineParser>

using namespace IncidenceEditorNG;

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    QCommandLineParser parser;
    parser.addVersionOption();
    parser.addHelpOption();
    parser.process(app);

ResourceManagement *dialog = new ResourceManagement();

dialog->show();

return app.exec();
}
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!1763 blocks

Places

File _service:obs_scm:incidenceeditor-VERSIONgit.20180311T173414~fbfddcd.obscpio of Package incidenceeditor (Revision 82f0bbe0a5edc96ade20f7588511225d)

Places