File _service:obs_scm:kdialog-VERSIONgit.20180919T13... of Package kdialog

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:kdialog-VERSIONgit.20180919T132129~f28a206bb.obscpio of Package kdialog (Revision 138bc37bd459d4bd51aecf52f0394482)

Currently displaying revision 138bc37bd459d4bd51aecf52f0394482 , Show latest

0707010CCEFA6A000081A40000000200000002000000015BA231390000027D000000FD0000001000000000000000000000003C00000000kdialog-VERSIONgit.20180919T132129~f28a206bb/CMakeLists.txtcmake_minimum_required(VERSION 2.8.12)

project(KDialog)

# ECM setup
find_package(ECM 1.7.0 CONFIG REQUIRED)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(FeatureSummary)
include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)

# Build dependencies
find_package(KF5 REQUIRED COMPONENTS TextWidgets Notifications GuiAddons IconThemes WindowSystem KIO DBusAddons)
find_package(Qt5DBus CONFIG)

find_package(X11)
if(X11_FOUND)
   set(HAVE_X11 1)
endif()

add_definitions(-DQT_NO_URL_CAST_FROM_STRING)

add_subdirectory(src)

feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
0707010CCEFA6B000081A40000000200000002000000015BA2313900004761000000FD0000001000000000000000000000003500000000kdialog-VERSIONgit.20180919T132129~f28a206bb/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 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

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.
0707010CCEFA6C000081A40000000200000002000000015BA23139000059B2000000FD0000001000000000000000000000003900000000kdialog-VERSIONgit.20180919T132129~f28a206bb/COPYING.DOC
                GNU Free Documentation License
                 Version 1.3, 3 November 2008

Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
     <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other
functional and useful document "free" in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way
to get credit for their work, while not being considered responsible
for modifications made by others.

This License is a kind of "copyleft", which means that derivative
works of the document must themselves be free in the same sense.  It
complements the GNU General Public License, which is a copyleft
license designed for free software.

We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free
program should come with manuals providing the same freedoms that the
software does.  But this License is not limited to software manuals;
it can be used for any textual work, regardless of subject matter or
whether it is published as a printed book.  We recommend this License
principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License.  Such a notice grants a
world-wide, royalty-free license, unlimited in duration, to use that
work under the conditions stated herein.  The "Document", below,
refers to any such manual or work.  Any member of the public is a
licensee, and is addressed as "you".  You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.

A "Modified Version" of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document's overall
subject (or to related matters) and contains nothing that could fall
directly within that overall subject.  (Thus, if the Document is in
part a textbook of mathematics, a Secondary Section may not explain
any mathematics.)  The relationship could be a matter of historical
connection with the subject or with related matters, or of legal,
commercial, philosophical, ethical or political position regarding
them.

The "Invariant Sections" are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License.  If a
section does not fit the above definition of Secondary then it is not
allowed to be designated as Invariant.  The Document may contain zero
Invariant Sections.  If the Document does not identify any Invariant
Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License.  A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or
for automatic translation to a variety of formats suitable for input
to text formatters.  A copy made in an otherwise Transparent file
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
of text.  A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
or XML using a publicly available DTD, and standard-conforming simple
HTML, PostScript or PDF designed for human modification.  Examples of
transparent image formats include PNG, XCF and JPG.  Opaque formats
include proprietary formats that can be read and edited only by
proprietary word processors, SGML or XML for which the DTD and/or
processing tools are not generally available, and the
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page.  For works in
formats which do not have any title page as such, "Title Page" means
the text near the most prominent appearance of the work's title,
preceding the beginning of the body of the text.

The "publisher" means any person or entity that distributes copies of
the Document to the public.

A section "Entitled XYZ" means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language.  (Here XYZ stands for a
specific section name mentioned below, such as "Acknowledgements",
"Dedications", "Endorsements", or "History".)  To "Preserve the Title"
of such a section when you modify the Document means that it remains a
section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which
states that this License applies to the Document.  These Warranty
Disclaimers are considered to be included by reference in this
License, but only as regards disclaiming warranties: any other
implication that these Warranty Disclaimers may have is void and has
no effect on the meaning of this License.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
copyright notices, and the license notice saying this License applies
to the Document are reproduced in all copies, and that you add no
other conditions whatsoever to those of this License.  You may not use
technical measures to obstruct or control the reading or further
copying of the copies you make or distribute.  However, you may accept
compensation in exchange for copies.  If you distribute a large enough
number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and
you may publicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
Document's license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover.  Both covers must also clearly and legibly identify
you as the publisher of these copies.  The front cover must present
the full title with all words of the title equally prominent and
visible.  You may add other material on the covers in addition.
Copying with changes limited to the covers, as long as they preserve
the title of the Document and satisfy these conditions, can be treated
as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit
legibly, you should put the first ones listed (as many as fit
reasonably) on the actual cover, and continue the rest onto adjacent
pages.

If you publish or distribute Opaque copies of the Document numbering
more than 100, you must either include a machine-readable Transparent
copy along with each Opaque copy, or state in or with each Opaque copy
a computer-network location from which the general network-using
public has access to download using public-standard network protocols
a complete Transparent copy of the Document, free of added material.
If you use the latter option, you must take reasonably prudent steps,
when you begin distribution of Opaque copies in quantity, to ensure
that this Transparent copy will remain thus accessible at the stated
location until at least one year after the last time you distribute an
Opaque copy (directly or through your agents or retailers) of that
edition to the public.

It is requested, but not required, that you contact the authors of the
Document well before redistributing any large number of copies, to
give them a chance to provide you with an updated version of the
Document.

4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release
the Modified Version under precisely this License, with the Modified
Version filling the role of the Document, thus licensing distribution
and modification of the Modified Version to whoever possesses a copy
of it.  In addition, you must do these things in the Modified Version:

A. Use in the Title Page (and on the covers, if any) a title distinct
   from that of the Document, and from those of previous versions
   (which should, if there were any, be listed in the History section
   of the Document).  You may use the same title as a previous version
   if the original publisher of that version gives permission.
B. List on the Title Page, as authors, one or more persons or entities
   responsible for authorship of the modifications in the Modified
   Version, together with at least five of the principal authors of the
   Document (all of its principal authors, if it has fewer than five),
   unless they release you from this requirement.
C. State on the Title page the name of the publisher of the
   Modified Version, as the publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications
   adjacent to the other copyright notices.
F. Include, immediately after the copyright notices, a license notice
   giving the public permission to use the Modified Version under the
   terms of this License, in the form shown in the Addendum below.
G. Preserve in that license notice the full lists of Invariant Sections
   and required Cover Texts given in the Document's license notice.
H. Include an unaltered copy of this License.
I. Preserve the section Entitled "History", Preserve its Title, and add
   to it an item stating at least the title, year, new authors, and
   publisher of the Modified Version as given on the Title Page.  If
   there is no section Entitled "History" in the Document, create one
   stating the title, year, authors, and publisher of the Document as
   given on its Title Page, then add an item describing the Modified
   Version as stated in the previous sentence.
J. Preserve the network location, if any, given in the Document for
   public access to a Transparent copy of the Document, and likewise
   the network locations given in the Document for previous versions
   it was based on.  These may be placed in the "History" section.
   You may omit a network location for a work that was published at
   least four years before the Document itself, or if the original
   publisher of the version it refers to gives permission.
K. For any section Entitled "Acknowledgements" or "Dedications",
   Preserve the Title of the section, and preserve in the section all
   the substance and tone of each of the contributor acknowledgements
   and/or dedications given therein.
L. Preserve all the Invariant Sections of the Document,
   unaltered in their text and in their titles.  Section numbers
   or the equivalent are not considered part of the section titles.
M. Delete any section Entitled "Endorsements".  Such a section
   may not be included in the Modified Version.
N. Do not retitle any existing section to be Entitled "Endorsements"
   or to conflict in title with any Invariant Section.
O. Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all
of these sections as invariant.  To do this, add their titles to the
list of Invariant Sections in the Modified Version's license notice.
These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains
nothing but endorsements of your Modified Version by various
parties--for example, statements of peer review or that the text has
been approved by an organization as the authoritative definition of a
standard.

You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list
of Cover Texts in the Modified Version.  Only one passage of
Front-Cover Text and one of Back-Cover Text may be added by (or
through arrangements made by) any one entity.  If the Document already
includes a cover text for the same cover, previously added by you or
by arrangement made by the same entity you are acting on behalf of,
you may not add another; but you may replace the old one, on explicit
permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License
give permission to use their names for publicity for or to assert or
imply endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified
versions, provided that you include in the combination all of the
Invariant Sections of all of the original documents, unmodified, and
list them all as Invariant Sections of your combined work in its
license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and
multiple identical Invariant Sections may be replaced with a single
copy.  If there are multiple Invariant Sections with the same name but
different contents, make the title of each such section unique by
adding at the end of it, in parentheses, the name of the original
author or publisher of that section if known, or else a unique number.
Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History"
in the various original documents, forming one section Entitled
"History"; likewise combine any sections Entitled "Acknowledgements",
and any sections Entitled "Dedications".  You must delete all sections
Entitled "Endorsements".

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other
documents released under this License, and replace the individual
copies of this License in the various documents with a single copy
that is included in the collection, provided that you follow the rules
of this License for verbatim copying of each of the documents in all
other respects.

You may extract a single document from such a collection, and
distribute it individually under this License, provided you insert a
copy of this License into the extracted document, and follow this
License in all other respects regarding verbatim copying of that
document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
distribution medium, is called an "aggregate" if the copyright
resulting from the compilation is not used to limit the legal rights
of the compilation's users beyond what the individual works permit.
When the Document is included in an aggregate, this License does not
apply to the other works in the aggregate which are not themselves
derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one half of
the entire aggregate, the Document's Cover Texts may be placed on
covers that bracket the Document within the aggregate, or the
electronic equivalent of covers if the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole
aggregate.

8. TRANSLATION

Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section 4.
Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include
translations of some or all Invariant Sections in addition to the
original versions of these Invariant Sections.  You may include a
translation of this License, and all the license notices in the
Document, and any Warranty Disclaimers, provided that you also include
the original English version of this License and the original versions
of those notices and disclaimers.  In case of a disagreement between
the translation and the original version of this License or a notice
or disclaimer, the original version will prevail.

If a section in the Document is Entitled "Acknowledgements",
"Dedications", or "History", the requirement (section 4) to Preserve
its Title (section 1) will typically require changing the actual
title.

9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense, or distribute it is void, and
will automatically terminate your rights under this License.

However, if you cease all violation of this License, then your license
from a particular copyright holder is reinstated (a) provisionally,
unless and until the copyright holder explicitly and finally
terminates your license, and (b) permanently, if the copyright holder
fails to notify you of the violation by some reasonable means prior to
60 days after the cessation.

Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, receipt of a copy of some or all of the same material does
not give you any rights to use it.

10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions of the
GNU Free Documentation 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.  See
http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this
License "or any later version" applies to it, you have the option of
following the terms and conditions either of that specified version or
of any later version that has been published (not as a draft) by the
Free Software Foundation.  If the Document does not specify a version
number of this License, you may choose any version ever published (not
as a draft) by the Free Software Foundation.  If the Document
specifies that a proxy can decide which future versions of this
License can be used, that proxy's public statement of acceptance of a
version permanently authorizes you to choose that version for the
Document.

11. RELICENSING

"Massive Multiauthor Collaboration Site" (or "MMC Site") means any
World Wide Web server that publishes copyrightable works and also
provides prominent facilities for anybody to edit those works.  A
public wiki that anybody can edit is an example of such a server.  A
"Massive Multiauthor Collaboration" (or "MMC") contained in the site
means any set of copyrightable works thus published on the MMC site.

"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 
license published by Creative Commons Corporation, a not-for-profit 
corporation with a principal place of business in San Francisco, 
California, as well as future copyleft versions of that license 
published by that same organization.

"Incorporate" means to publish or republish a Document, in whole or in 
part, as part of another Document.

An MMC is "eligible for relicensing" if it is licensed under this 
License, and if all works that were first published under this License 
somewhere other than this MMC, and subsequently incorporated in whole or 
in part into the MMC, (1) had no cover texts or invariant sections, and 
(2) were thus incorporated prior to November 1, 2008.

The operator of an MMC Site may republish an MMC contained in the site
under CC-BY-SA on the same site at any time before August 1, 2009,
provided the MMC is eligible for relicensing.

ADDENDUM: How to use this License for your documents

To use this License in a document you have written, include a copy of
the License in the document and put the following copyright and
license notices just after the title page:

Copyright (c)  YEAR  YOUR NAME.
    Permission is granted to copy, distribute and/or modify this document
    under the terms of the GNU Free Documentation License, Version 1.3
    or any later version published by the Free Software Foundation;
    with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
    A copy of the license is included in the section entitled "GNU
    Free Documentation License".

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
replace the "with...Texts." line with this:

with the Invariant Sections being LIST THEIR TITLES, with the
    Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.

If you have Invariant Sections without Cover Texts, or some other
combination of the three, merge those two alternatives to suit the
situation.

If your document contains nontrivial examples of program code, we
recommend releasing these examples in parallel under your choice of
free software license, such as the GNU General Public License,
to permit their use in free software.
0707010CCEFA6D000081A40000000200000002000000015BA2313900000230000000FD0000001000000000000000000000003400000000kdialog-VERSIONgit.20180919T132129~f28a206bb/READMEkdialog allows you to display dialog boxes from shell scripts.
The syntax is very much inspired from the "dialog" command
(which shows text mode dialogs).

However the width and height attributes have been removed for
most dialogs - Qt/KDE have layouts ;)

A tutorial on using kdialog is available at
http://techbase.kde.org/Development/Tutorials/Shell_Scripting_with_KDE_Dialogs
If you change or add any functionality, please contact Brad
Hards <bradh@frogmouth.net> to ensure it is reflected in the
tutorial.

Current maintainer: David Faure <faure@kde.org>
0707010CF47386000041ED0000000200000002000000025BA2313900000000000000FD0000001000000000000000000000003100000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src0707010CF47387000081A40000000200000002000000015BA2313900000524000000FD0000001000000000000000000000004000000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/CMakeLists.txtconfigure_file(config-kdialog.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kdialog.h)

set(kdialog_SRCS
    kdialog.cpp
    widgets.cpp
    utils.cpp
    klistboxdialog.cpp
)

add_executable(kdialog ${kdialog_SRCS})

target_link_libraries(kdialog
    KF5::KIOWidgets
    KF5::TextWidgets
    KF5::Notifications
    KF5::IconThemes
    KF5::GuiAddons
    KF5::WindowSystem
)

if(Qt5DBus_FOUND)
    target_link_libraries(kdialog Qt5::DBus)
endif()

if (HAVE_X11)
  target_link_libraries(kdialog ${X11_X11_LIB})
endif()

install(TARGETS kdialog ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})
install(FILES org.kde.kdialog.ProgressDialog.xml DESTINATION ${KDE_INSTALL_DBUSINTERFACEDIR})

################################################################################

set(kdialog_progress_helper_SRCS
    kdialog_progress_helper.cpp
    utils.cpp
    progressdialog.cpp
)

qt5_add_dbus_adaptor(kdialog_progress_helper_SRCS org.kde.kdialog.ProgressDialog.xml progressdialog.h ProgressDialog)

add_executable(kdialog_progress_helper ${kdialog_progress_helper_SRCS})

target_link_libraries(kdialog_progress_helper
    KF5::DBusAddons
    KF5::I18n
    Qt5::Widgets
)

if (HAVE_X11)
  target_link_libraries(kdialog_progress_helper ${X11_X11_LIB})
endif()

install(TARGETS kdialog_progress_helper ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})

0707010CF47388000081A40000000200000002000000015BA231390000003C000000FD0000001000000000000000000000003D00000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/Messages.sh#! /usr/bin/env bash
$XGETTEXT *.cpp -o $podir/kdialog.pot 
0707010CF47389000081A40000000200000002000000015BA2313900000072000000FD0000001000000000000000000000004800000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/config-kdialog.h.cmake/* Define to 1 if the QtDBus module is present. */
#cmakedefine Qt5DBus_FOUND 1
#cmakedefine HAVE_X11 ${HAVE_X11}
0707010CF4738A000081A40000000200000002000000015BA2313900006B96000000FD0000001000000000000000000000004300000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/dialog-compat.txtu	It would be very useful in some circumstances if kdialog 
could be used as a direct replacement for dialog and/or xdialog.

In general, the differences between the kdialog we shipped with
KDE3 and the dialog / xdialog options are pretty minor, except
for two things:
1. KDE3 kdialog doesn't accept (and doesn't need) the size options
(height and width). We don't need them because of the use of layouts
in KDE.
2. There are some dialog types that aren't supported by KDE3 kdialog.

There is more than one kind of dialog, and they take different options.
See below for the cdialog options:
 - - - -
cdialog (ComeOn Dialog!) version 1.0-20051107
Copyright (C) 2005 Thomas E. Dickey
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

* Display dialog boxes from shell scripts *

Usage: dialog <options> { --and-widget <options> }
where options are "common" options, followed by "box" options

Special options:
  [--create-rc "file"]
Common options:
  [--aspect <ratio>] [--backtitle <backtitle>] [--begin <y> <x>]
  [--cancel-label <str>] [--clear] [--colors] [--cr-wrap]
  [--default-item <str>] [--defaultno] [--exit-label <str>]
  [--extra-button] [--extra-label <str>] [--help-button]
  [--help-label <str>] [--help-status] [--ignore] [--input-fd <fd>]
  [--insecure] [--item-help] [--keep-window] [--max-input <n>]
  [--no-cancel] [--no-collapse] [--no-kill] [--no-label <str>]
  [--no-shadow] [--ok-label <str>] [--output-fd <fd>] [--print-maxsize]
  [--print-size] [--print-version] [--separate-output]
  [--separate-widget <str>] [--shadow] [--single-quoted] [--size-err]
  [--sleep <secs>] [--stderr] [--stdout] [--tab-correct] [--tab-len <n>]
  [--timeout <secs>] [--title <title>] [--trim] [--visit-items]
  [--version] [--yes-label <str>]
Box options:
  --calendar     <text> <height> <width> <day> <month> <year>
  --checklist    <text> <height> <width> <list height> <tag1> <item1> <status1>...
  --form         <text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>...
  --fselect      <filepath> <height> <width>
  --gauge        <text> <height> <width> [<percent>]
  --infobox      <text> <height> <width>
  --inputbox     <text> <height> <width> [<init>]
  --inputmenu    <text> <height> <width> <menu height> <tag1> <item1>...
  --menu         <text> <height> <width> <menu height> <tag1> <item1>...
  --msgbox       <text> <height> <width>
  --passwordbox  <text> <height> <width> [<init>]
  --pause        <text> <height> <width> <seconds>
  --radiolist    <text> <height> <width> <list height> <tag1> <item1> <status1>...
  --tailbox      <file> <height> <width>
  --tailboxbg    <file> <height> <width>
  --textbox      <file> <height> <width>
  --timebox      <text> <height> <width> <hour> <minute> <second>
  --yesno        <text> <height> <width>

Auto-size with height and width = 0. Maximize with height and width = -1.
Global-auto-size if also menu_height/list_height = 0.

- - - -

The Dragonfly BSD version (and presumably other BSD flavours)
takes a different set of options.

NAME

dialog - display dialog boxes from shell scripts

SYNOPSIS

dialog --clear
       dialog --create-rc file
       dialog  [ --title title ] [ --clear ] [ --hline line ] [ --hfile file ]
       box-options

DESCRIPTION

Dialog is a program which allows you to present a variety of  questions
       or  display  messages in dialog box form from a shell script.  The fol-
       lowing types of dialog objects are currently supported:

yes/no box, menu box, input box,  message  box,  text  box,  info  box,
       checklist box, program box, ftree and tree boxes.

OPTIONS

--clear
              The screen will be cleared to the screen attribute on exit.

--create-rc file
              Since  dialog  supports run-time configuration, this can be used
              to dump a sample configuration file to  the  file  specified  by
              file.

--title title
              Specifies  a title string to be displayed at the top of the dia-
              log box.

--hline line
              Specifies a line string to be displayed at  the  bottom  of  the
              dialog box.

--hfile file
              Specifies a file to be displayed by pressing ? or F1.

Box Options

--yesno text height width
              A yes/no dialog box of size height rows by width columns will be
              displayed. The string specified by text is displayed inside  the
              dialog  box.  If  this string is too long to fit in one line, it
              will be automatically divided into multiple lines at the  appro-
              priate  points.  The text string may also contain the sub-string
              "\n" or newline characters `\n' to control line breaking explic-
              itly.   This  dialog  box  is  useful  for asking questions that
              require the user to answer either yes or no.  The dialog box has
              a  Yes  button  and  a  No  button, in which the user can switch
              between by pressing the TAB key.

--msgbox text height width
              A message box is very similar to a yes/no box.  The only differ-
              ence  between  a  message box and a yes/no box is that a message
              box has only a single OK button. You can use this dialog box  to
              display  any  message  you like.  After reading the message, the
              user can press the ENTER key so that dialog will  exit  and  the
              calling shell script can continue its operation.

--infobox text height width
              An  info box is basically a message box.  However, in this case,
              dialog will exit immediately after displaying the message to the
              user.  The  screen is not cleared when dialog exits, so that the
              message will remain on the screen until the calling shell script
              clears it later. This is useful when you want to inform the user
              that some operations are carrying on that may require some  time
              to finish.

--inputbox text height width
              An  input  box  is  useful  when  you want to ask questions that
              require the user to input a string as the answer. When  inputing
              the  string,  the  BACKSPACE  key  can be used to correct typing
              errors. If the input string is longer than can be fitted in  the
              dialog box, the input field will be scrolled. On exit, the input
              string will be printed on stderr.

--textbox file height width
              A text box lets you display the contents of a  text  file  in  a
              dialog  box.  It is like a simple text file viewer. The user can
              move through the  file  by  using  the  UP/DOWN,  PGUP/PGDN  and
              HOME/END keys available on most keyboards.  If the lines are too
              long to be displayed in the box, the LEFT/RIGHT keys can be used
              to  scroll  the  text region horizontally. For more convenience,
              forward and backward searching functions are also provided.

--menu text height width menu-height [ tag item ] ...
              As its name suggests, a menu box is a dialog  box  that  can  be
              used  to present a list of choices in the form of a menu for the
              user to choose. Each menu entry consists of a tag string and  an
              item  string.  The  tag gives the entry a name to distinguish it
              from the other entries in the menu. The item is a short descrip-
              tion  of the option that the entry represents. The user can move
              between the menu entries by pressing the UP/DOWN keys, the first
              letter  of  the  tag as a hot-key, or the number keys 1-9. There
              are menu-height entries displayed in the menu at one  time,  but
              the  menu  will be scrolled if there are more entries than that.
              When dialog exits, the tag of the  chosen  menu  entry  will  be
              printed on stderr.

--prgbox command height width
              A  program box lets you display output of command in dialog box.

--checklist text height width list-height [ tag item status ] ...
              A checklist box is similar to a menu box in that there are  mul-
              tiple entries presented in the form of a menu. Instead of choos-
              ing one entry among the entries, each entry can be turned on  or
              off by the user. The initial on/off state of each entry is spec-
              ified by status.  On exit, a list of the tag  strings  of  those
              entries that are turned on will be printed on stderr.

--ftree file FS text height width menu-height
              ftree box is a dialog box showing the tree described by the data
              from the file file.  The data  in  the  file  should  look  like
              find(1)   output.  For  the  find output, the field separator FS
              will be '/'. If height and width are positive numbers, they  set
              the  absolute  size  of the whole ftree box. If height and width
              are negative numbers, the size of the ftree box will be selected
              automatically.   menu-height sets the height of the tree subwin-
              dow inside the ftree box and must be set.  text is shown  inside
              the  ftree  box above the tree subwindow and can contain newline
              characters '\n' to split lines. One can navigate in the tree  by
              pressing  UP/DOWN  or  '+'/'-',  PG_UP/PG_DOWN  or 'b'/SPACE and
              HOME/END or 'g'/'G'.  A leaf of the tree is selected by pressing
              TAB  or  LEFT/RIGHT  the  OK  button  and  pressing  ENTER.  The
              selected leaf (to be more exact, the full path to  it  from  the
              root  of  the  tree)  is  printed to stderr.  If Cancel and then
              ENTER is pressed, nothing is printed to stderr.  file  may  con-
              tain  data  like  find(1)  output, as well as like the output of
              find(1) with -d option. Some  of  the  transient  paths  to  the
              leaves  of  the  tree may be absent. Such data is corrected when
              fed from file.

--tree FS text height width menu-height [ item ] ...
              tree box is like ftree box with some exceptions. First, the data
              is  not  entered  from a file, but from the command line as item
              item ...  Second, the data thus entered is not corrected in  any
              way.   Thus,  the data like the output of find(1) with -d option
              will look incorrectly.

RUN-TIME CONFIGURATION
       1.  Create a sample configuration file by typing:

"dialog --create-rc <file>"

2.  At start, dialog determines the settings to use as follows:

a)  if environment variable DIALOGRC is set, its  value  determines
               the name of the configuration file.

b)  if the file in (a) can't be found, use the file $HOME/.dialogrc
               as the configuration file.

c)  if the file in (b) can't be found, use compiled in defaults.

3.  Edit the sample configuration file and copy it to some  place  that
           dialog can find, as stated in step 2 above.

ENVIRONMENT

DIALOGRC       Define  this variable if you want to specify the name of
                      the configuration file to use.

FILES

$HOME/.dialogrc     default configuration file

DIAGNOSTICS

Exit status is 0 if dialog is exited by pressing the Yes or OK  button,
       and 1 if the No or Cancel button is pressed. Otherwise, if errors occur
       inside dialog or dialog is exited by pressing the  ESC  key,  the  exit
       status is -1.

- - - -
Xdialog has an inordinately large collection of options. As of 2.3.1, the
help text offers the following:
[<common options>] [<transient options>] <box option> ...

Transient options:
  --fixed-font
  --password (may be repeated 2 or 3 times before --2inputsbox or --3inputsbox)
  --password=1|2 (for --2inputsbox or --3inputsbox)
  --editable
  --time-stamp | --date-stamp
  --reverse
  --keep-colors
  --interval <timeout>
  --timeout <timeout> (in seconds)
  --no-tags
  --item-help (if used, the {...} parameters are needed in menus/lists widgets)
  --default-item <tag>
  --icon <xpm filename>
  --no-ok
  --no-cancel
  --no-buttons
  --default-no
  --wizard
  --help <help>
  --print <printer> (1)
  --check <label> [<status>]
  --ok-label <label>
  --cancel-label <label>
  --beep
  --beep-after
  --begin <Yorg> <Xorg>
  --ignore-eof
  --smooth

Box options:
  --yesno       <text> <height> <width>
  --msgbox      <text> <height> <width>
  --infobox     <text> <height> <width> [<timeout>]
  --gauge       <text> <height> <width> [<percent>]
  --progress    <text> <height> <width> [<maxdots> [[-]<msglen>]]
  --inputbox    <text> <height> <width> [<init>]
  --2inputsbox  <text> <height> <width> <label1> <init1> <label2> <init2>
  --3inputsbox  <text> <height> <width> <label1> <init1> <label2> <init2> <label3> <init3>
  --combobox    <text> <height> <width> <item1> ... <itemN>
  --rangebox    <text> <height> <width> <min value> <max value> [<default value>]
  --2rangesbox  <text> <height> <width> <label1> <min1> <max1> <def1> <label2> <min2> <max2> <def2>
  --3rangesbox  <text> <height> <width> <label1> <min1> <max1> <def1> ... <label3> <min3> <max3> <def3>
  --spinbox     <text> <height> <width> <min value> <max value> <default value> <label>
  --2spinsbox   <text> <height> <width> <min1> <max1> <def1> <label1> <min2> <max2> <def2> <label2>
  --3spinsbox   <text> <height> <width> <min1> <max1> <def1> <label1> ... <min3> <max3> <def3> <label3>
  --textbox     <file> <height> <width>
  --editbox     <file> <height> <width>
  --tailbox     <file> <height> <width>
  --logbox      <file> <height> <width>
  --menubox     <text> <height> <width> <menu height> <tag1> <item1> {<help1>}...
  --checklist   <text> <height> <width> <list height> <tag1> <item1> <status1> {<help1>}...
  --radiolist   <text> <height> <width> <list height> <tag1> <item1> <status1> {<help1>}...
  --buildlist   <text> <height> <width> <list height> <tag1> <item1> <status1> {<help1>}...
  --treeview    <text> <height> <width> <list height> <tag1> <item1> <status1> <item_depth1> {<help1>}...
  --fselect     <file> <height> <width>
  --dselect     <directory> <height> <width>
  --colorsel    <text> <height> <width> [<red> <green> <blue>]
  --fontsel     <font name> <height> <width>
  --calendar    <text> <height> <width> [<day> <month> <year>]
  --timebox     <text> <height> <width> [<hours> <minutes> <seconds>]

Special options:
  --version             (prints version number to stderr and exits).
  --print-version       (same as above in a cdialog-compatible way).
  --print-maxsize       (prints maximum menu size in characters and exits).

Note that <height> and <width> are in characters and may be replaced by a single
XSIZExYSIZE[+/-XORG+/-YORG] parameter (like the one passed in the -geometry option
of X) which will represent the size of the Xdialog window in pixels. Specifying
a size of 0 0 (or 0x0) will auto-size Xdialog, while a size of -1 -1 (or -1x-1)
will maximize it.

- - - -
The KDE3 version of kdialog has yet another set of options:

Usage: kdialog [Qt-options] [KDE-options] [options] [arg]

KDialog can be used to show nice dialog boxes from shell scripts

Generic options:
  --help                    Show help about options
  --help-qt                 Show Qt specific options
  --help-kde                Show KDE specific options
  --help-all                Show all options
  --author                  Show author information
  -v, --version             Show version information
  --license                 Show license information
  --                        End of options

Options:
  --yesno <text>            Question message box with yes/no buttons
  --yesnocancel <text>      Question message box with yes/no/cancel buttons
  --warningyesno <text>     Warning message box with yes/no buttons
  --warningcontinuecancel <text> Warning message box with continue/cancel buttons
  --warningyesnocancel <text> Warning message box with yes/no/cancel buttons
  --sorry <text>            'Sorry' message box
  --error <text>            'Error' message box
  --msgbox <text>           Message Box dialog
  --inputbox <text> <init>  Input Box dialog
  --password <text>         Password dialog
  --textbox <file> [width] [height] Text Box dialog
  --textinputbox <text> <init> [width] [height] Text Input Box dialog
  --combobox <text> [tag item] [tag item] ... ComboBox dialog
  --menu <text> [tag item] [tag item] ... Menu dialog
  --checklist <text> [tag item status] ... Check List dialog
  --radiolist <text> [tag item status] ... Radio List dialog
  --passivepopup <text> <timeout> Passive Popup
  --getopenfilename [startDir] [filter] File dialog to open an existing file
  --getsavefilename [startDir] [filter] File dialog to save a file
  --getexistingdirectory [startDir] File dialog to select an existing directory
  --getopenurl [startDir] [filter] File dialog to open an existing URL
  --getsaveurl [startDir] [filter] File dialog to save a URL
  --geticon [group] [context] Icon chooser dialog
  --progressbar <text> [totalsteps] Progress bar dialog, returns a DCOP reference for communication
  --title <text>            Dialog title
  --default <text>          Default entry to use for combobox and menu
  --multiple                Allows the --getopenurl and --getopenfilename options to return multiple files
  --separate-output         Return list items on separate lines (for checklist option and file open with --multiple)
  --print-winid             Outputs the winId of each dialog
  --embed <winid>           Makes the dialog transient for an X app specified by winid
  --dontagain <file:entry>  Config file and option name for saving the "dont-show/ask-again" state

Arguments:
  arg                       Arguments - depending on main option

- - - -

Some of those options are common

So the dialog types we need for KDE4 are:
  --yesno <text>
  --yesno <text> <height> <width>
  --yesnocancel <text>
  --warningyesno <text>
  --warningcontinuecancel <text>
  --warningyesnocancel <text>
  --sorry <text>
  --error <text>
  --msgbox <text>
  --msgbox <text> <height> <width>
  --infobox <text> <height> <width> [<timeout>]
  --inputbox <text> <init>
  --inputbox <text> <height> <width> [<init>]
  --inputmenu <text> <height> <width> <menu height> <tag1> <item1>...
  --textinputbox <text> <init> [width] [height]
  --password <text>
  --passwordbox  <text> <height> <width> [<init>]
  --textbox <file> [width] [height]
  --combobox <text> [tag item] [tag item] ...
  --combobox <text> <height> <width> <item1> ... <itemN>
  --menu <text> [tag item] [tag item] ...
  --menu <text> <height> <width> <menu height> <tag1> <item1>...
  --menubox <text> <height> <width> <menu height> <tag1> <item1> {<help1>}...
  --checklist <text> [tag item status] ...
  --checklist <text> <height> <width> <list height> <tag1> <item1> <status1> {<help1>}...
  --checklist <text> <height> <width> <list height> <tag1> <item1> <status1>...
  --radiolist <text> [tag item status] ...
  --radiolist <text> <height> <width> <list height> <tag1> <item1> <status1>...
  --passivepopup <text> <timeout>
  --getopenfilename [startDir] [filter]
  --fselect     <file> <height> <width>
  --getsavefilename [startDir] [filter]
  --getexistingdirectory [startDir]
  --dselect     <directory> <height> <width>
  --getopenurl [startDir] [filter]
  --getsaveurl [startDir] [filter]
  --geticon [group] [context]
  --progressbar <text> [totalsteps]
  --gauge  <text> <height> <width> [<percent>]
  (also guage)
  --progress    <text> <height> <width> [<maxdots> [[-]<msglen>]]
  --prgbox command height width
  --2inputsbox  <text> <height> <width> <label1> <init1> <label2> <init2>
  --3inputsbox  <text> <height> <width> <label1> <init1> <label2> <init2> <label3> <init3>
  --rangebox    <text> <height> <width> <min value> <max value> [<default value>]
  --2rangesbox  <text> <height> <width> <label1> <min1> <max1> <def1> <label2> <min2> <max2> <def2>
  --3rangesbox  <text> <height> <width> <label1> <min1> <max1> <def1> ... <label3> <min3> <max3> <def3>
  --spinbox     <text> <height> <width> <min value> <max value> <default value> <label>
  --2spinsbox   <text> <height> <width> <min1> <max1> <def1> <label1> <min2> <max2> <def2> <label2>
  --3spinsbox   <text> <height> <width> <min1> <max1> <def1> <label1> ... <min3> <max3> <def3> <label3>
  --editbox     <file> <height> <width>
  --tailbox     <file> <height> <width>
  --logbox      <file> <height> <width>
  --radiolist   <text> <height> <width> <list height> <tag1> <item1> <status1> {<help1>}...
  --buildlist   <text> <height> <width> <list height> <tag1> <item1> <status1> {<help1>}...
  --treeview    <text> <height> <width> <list height> <tag1> <item1> <status1> <item_depth1> {<help1>}...
  --colorsel    <text> <height> <width> [<red> <green> <blue>]
  --fontsel     <font name> <height> <width>
  --calendar    <text> <height> <width> [<day> <month> <year>]
  --timebox     <text> <height> <width> [<hours> <minutes> <seconds>]
  --ftree file FS text height width menu-height
  --tree FS text height width menu-height [ item ] ...
  --calendar     <text> <height> <width> <day> <month> <year>
  --form         <text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>...
  --pause        <text> <height> <width> <seconds>
  --tailbox      <file> <height> <width>
  --tailboxbg    <file> <height> <width>

The non-specific options we need to handle include:
  --title <text>            Dialog title
  --default <text>          Default entry to use for combobox and menu
  --multiple                Allows the --getopenurl and --getopenfilename options to return multiple files
  --separate-output         Return list items on separate lines (for checklist option and file open with --multiple)
  --print-winid             Outputs the winId of each dialog
  --embed <winid>           Makes the dialog transient for an X app specified by winid
  --dontagain <file:entry>  Config file and option name for saving the "dont-show/ask-again" state
  --caption <caption>       Use 'caption' as name in the titlebar
  --icon <icon>             Use 'icon' as the application icon
  --miniicon <icon>         Use 'icon' as the icon in the titlebar
  --config <filename>       Use alternative configuration file
  --dcopserver <server>     Use the DCOP Server specified by 'server'
  --nocrashhandler          Disable crash handler, to get core dumps
  --waitforwm               Waits for a WM_NET compatible windowmanager
  --style <style>           sets the application GUI style
  --geometry <geometry>     sets the client geometry of the main widget - see man X for the argument format
  --display <displayname>   Use the X-server display 'displayname'
  --session <sessionId>     Restore the application for the given 'sessionId'
  --cmap                    Causes the application to install a private color
                            map on an 8-bit display
  --ncols <count>           Limits the number of colors allocated in the color
                            cube on an 8-bit display, if the application is
                            using the QApplication::ManyColor color
                            specification
  --nograb                  tells Qt to never grab the mouse or the keyboard
  --dograb                  running under a debugger can cause an implicit
                            -nograb, use -dograb to override
  --sync                    switches to synchronous mode for debugging
  --fn, --font <fontname>   defines the application font
  --bg, --background <color> sets the default background color and an
                            application palette (light and dark shades are
                            calculated)
  --fg, --foreground <color> sets the default foreground color
  --btn, --button <color>   sets the default button color
  --name <name>             sets the application name
  --title <title>           sets the application title (caption)
  --visual TrueColor        forces the application to use a TrueColor visual on
                            an 8-bit display
  --inputstyle <inputstyle> sets XIM (X Input Method) input style. Possible
                            values are onthespot, overthespot, offthespot and
                            root
  --im <XIM server>         set XIM server
  --noxim                   disable XIM
  --reverse                 mirrors the whole layout of widgets
  --version             (prints version number to stderr and exits).
  --print-version       (same as above in a cdialog-compatible way).
  --print-maxsize       (prints maximum menu size in characters and exits).
  --wmclass <name>
  --rc-file <gtkrc filename>
  --backtitle <backtitle>
  --title <title>
  --allow-close | --no-close
  --screen-center | --under-mouse | --auto-placement
  --center | --right | --left | --fill
  --no-wrap | --wrap
  --cr-wrap | --no-cr-wrap
  --stderr | --stdout
  --separator <character> | --separate-output
  --buttons-style default|icon|text
  --fixed-font
  --password (may be repeated 2 or 3 times before --2inputsbox or --3inputsbox)
  --password=1|2 (for --2inputsbox or --3inputsbox)
  --editable
  --time-stamp | --date-stamp
  --reverse
  --keep-colors
  --interval <timeout>
  --timeout <timeout> (in seconds)
  --no-tags
  --item-help (if used, the {...} parameters are needed in menus/lists widgets)
  --default-item <tag>
  --icon <xpm filename>
  --no-ok
  --no-cancel
  --no-buttons
  --default-no
  --wizard
  --help <help>
  --print <printer> (1)
  --check <label> [<status>]
  --ok-label <label>
  --cancel-label <label>
  --beep
  --beep-after
  --begin <Yorg> <Xorg>
  --ignore-eof
  --smooth
  --clear
  --create-rc file
  --title title
  --hline line
  --hfile file
  --aspect <ratio>
  --backtitle <backtitle>
  --begin <y> <x>
  --cancel-label <str>
  --clear
  --colors
  --cr-wrap
  --default-item <str>
  --defaultno
  --exit-label <str>
  --extra-button
  --extra-label <str>
  --help-button
  --help-label <str>
  --help-status
  --ignore
  --input-fd <fd>
  --insecure
  --item-help
  --keep-window
  --max-input <n>
  --no-cancel
  --no-collapse
  --no-kill
  --no-label <str>
  --no-shadow
  --ok-label <str>
  --output-fd <fd>
  --print-maxsize
  --print-size
  --print-version
  --separate-output
  --separate-widget <str>
  --shadow
  --single-quoted
  --size-err
  --sleep <secs>
  --stderr
  --stdout
  --tab-correct
  --tab-len <n>
  --timeout <secs>
  --title <title>
  --trim
  --visit-items
  --version
  --yes-label <str>

0707010CF4738B000081A40000000200000002000000015BA231390000AAC4000000FD0000001000000000000000000000003D00000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/kdialog.cpp//
//  Copyright (C) 1998 Matthias Hoelzer <hoelzer@kde.org>
//  Copyright (C) 2002, 2016 David Faure <faure@kde.org>
//  Copyright (C) 2005 Brad Hards <bradh@frogmouth.net>
//  Copyright (C) 2008 by Dmitry Suzdalev <dimsuz@gmail.com>
//  Copyright (C) 2011 Kai Uwe Broulik <kde@privat.broulik.de>
//
//  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 the7 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 "config-kdialog.h"
#include "widgets.h"
#include "utils.h"

#include <kmessagebox.h>
#include <kpassivepopup.h>
#include <krecentdocument.h>

#include <kaboutdata.h>
#include <kconfig.h>
#include <kfileitem.h>
#include <kicondialog.h>
#include <kcolormimedata.h>
#include <kwindowsystem.h>
#include <kiconloader.h>
#include <KLocalizedString>

#include <QApplication>
#include <QDate>
#include <QClipboard>
#include <QColorDialog>
#include <QDBusServiceWatcher>
#include <QDebug>
#include <QDesktopWidget>
#include <QFileDialog>
#include <QUrl>
#include <QProcess>
#include <QRegularExpression>
#include <QTimer>

#include <iostream>

#if defined HAVE_X11
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#endif

#include "config-kdialog.h"
#ifdef Qt5DBus_FOUND
#include <QDBusConnection>
#include <QDBusConnectionInterface>
#endif

#ifdef Q_WS_WIN
#include <QFileDialog>
#endif
#include <unistd.h>
#include <QCommandLineParser>
#include <QCommandLineOption>

using namespace std;

// this class hooks into the eventloop and outputs the id
// of shown dialogs or makes the dialog transient for other winids.
// Will destroy itself on app exit.
class WinIdEmbedder: public QObject
{
public:
    WinIdEmbedder(bool printID, WId winId):
        QObject(qApp), print(printID), id(winId)
    {
        if (qApp)
            qApp->installEventFilter(this);
    }
protected:
    bool eventFilter(QObject *o, QEvent *e) Q_DECL_OVERRIDE;
private:
    bool print;
    WId id;
};

bool WinIdEmbedder::eventFilter(QObject *o, QEvent *e)
{
    if (e->type() == QEvent::Show && o->isWidgetType()
        && o->inherits("QDialog"))
    {
        QWidget *w = static_cast<QWidget*>(o);
        if (print)
            cout << "winId: " << w->winId() << endl;
        if (id)
            KWindowSystem::setMainWindow(w, id);
        deleteLater(); // WinIdEmbedder is not needed anymore after the first dialog was shown
        return false;
    }
    return QObject::eventFilter(o, e);
}

/**
 * Display a passive notification popup using the D-Bus interface, if possible.
 * @return true if the notification was successfully sent, false otherwise.
 */
static bool sendVisualNotification(const QString &text, const QString &title, const QString &icon, int timeout)
{
#ifdef Qt5DBus_FOUND
  const QString dbusServiceName = QStringLiteral("org.freedesktop.Notifications");
  const QString dbusInterfaceName = QStringLiteral("org.freedesktop.Notifications");
  const QString dbusPath = QStringLiteral("/org/freedesktop/Notifications");

// check if service already exists on plugin instantiation
  QDBusConnectionInterface* interface = QDBusConnection::sessionBus().interface();

if (!interface || !interface->isServiceRegistered(dbusServiceName)) {
    //kDebug() << dbusServiceName << "D-Bus service not registered";
    return false;
  }

if (timeout == 0)
    timeout = 10 * 1000;

QDBusMessage m = QDBusMessage::createMethodCall(dbusServiceName, dbusPath, dbusInterfaceName, QStringLiteral("Notify"));
  QList<QVariant> args;

args.append(QStringLiteral("kdialog")); // app_name
  args.append(0U); // replaces_id
  args.append(icon); // app_icon
  args.append(title); // summary
  args.append(text); // body
  args.append(QStringList()); // actions - unused for plain passive popups
  args.append(QVariantMap()); // hints - unused atm
  args.append(timeout); // expire timout

m.setArguments(args);

QDBusMessage replyMsg = QDBusConnection::sessionBus().call(m);
  if(replyMsg.type() == QDBusMessage::ReplyMessage) {
    if (!replyMsg.arguments().isEmpty()) {
      return true;
    }
    // Not displaying any error messages as this is optional for kdialog
    // and KPassivePopup is a perfectly valid fallback.
    //else {
    //  kDebug() << "Error: received reply with no arguments.";
    //}
  } else if (replyMsg.type() == QDBusMessage::ErrorMessage) {
    //kDebug() << "Error: failed to send D-Bus message";
    //kDebug() << replyMsg;
  } else {
    //kDebug() << "Unexpected reply type";
  }
#endif
  return false;
}

static void outputStringList(const QStringList &list, bool separateOutput)
{
    if ( separateOutput) {
        for ( QStringList::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it ) {
            cout << (*it).toLocal8Bit().data() << endl;
        }
    } else {
        for ( QStringList::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it ) {
            cout << (*it).toLocal8Bit().data() << " ";
        }
        cout << endl;
    }
}

static void outputStringList(const QList<QUrl> &list, bool separateOutput)
{
    if ( separateOutput) {
        for ( auto it = list.constBegin(); it != list.constEnd(); ++it ) {
            cout << (*it).toDisplayString().toLocal8Bit().data() << endl;
        }
    } else {
        for ( auto it = list.constBegin(); it != list.constEnd(); ++it ) {
            cout << (*it).toDisplayString().toLocal8Bit().data() << " ";
        }
        cout << endl;
    }
}

static KGuiItem configuredYes(const QString &text)
{
  return KGuiItem( text, QStringLiteral("dialog-ok") );
}

static KGuiItem configuredNo(const QString &text)
{
  return KGuiItem( text, QStringLiteral("process-stop") );
}

static KGuiItem configuredCancel(const QString &text)
{
  return KGuiItem( text, QStringLiteral("dialog-cancel") );
}

static KGuiItem configuredContinue(const QString &text)
{
  return KGuiItem( text, QStringLiteral("arrow-right") );
}

static void setFileDialogFilter(QFileDialog &dlg, const QString &filter)
{
    if (filter.contains(QStringLiteral("*"))) {
        QString qtFilter = filter;
        dlg.setNameFilter(qtFilter.replace(QLatin1Char('|'),QLatin1Char('\n')));
    } else if (!filter.isEmpty()) {
        dlg.setMimeTypeFilters(filter.trimmed().split(QLatin1Char(' ')));
    }
}

// taken from qfiledialog.cp
static QString initialSelection(const QUrl &url)
{
    if (url.isEmpty()) {
        return QString();
    }
    if (url.isLocalFile()) {
        QFileInfo info(url.toLocalFile());
        if (!info.isDir()) {
            return info.fileName();
        } else {
            return QString();
        }
    }
    // With remote URLs we can only assume.
    return url.fileName();
}

static QUrl initialDirectory(const QUrl &url)
{
    if (url.isLocalFile() && QFileInfo(url.toLocalFile()).isDir()) {
        return url;
    }
    return url.adjusted(QUrl::RemoveFilename);
}

int main(int argc, char *argv[])
{
    // Bug 373677: Qt removes various arguments it treats internally (such as title and icon) from args
    // and applies them to the first Qt::Window, while here we only show dialogs
    // so we need to store them before we even create our QApplication
    QStringList rawArgs;
    for (int i = 0; i < argc; ++i) {
        rawArgs << QString::fromLocal8Bit(argv[i]);
    }

QApplication app(argc, argv);
    KLocalizedString::setApplicationDomain("kdialog");

// enable high dpi support
    app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);

KAboutData aboutData( QStringLiteral("kdialog"), i18n("KDialog"),
            QStringLiteral("2.0"), i18n( "KDialog can be used to show nice dialog boxes from shell scripts" ),
            KAboutLicense::GPL,
            i18n("(C) 2000, Nick Thompson"));
    aboutData.addAuthor(i18n("David Faure"), i18n("Current maintainer"),QStringLiteral("faure@kde.org"));
    aboutData.addAuthor(i18n("Brad Hards"), QString(), QStringLiteral("bradh@frogmouth.net"));
    aboutData.addAuthor(i18n("Nick Thompson"),QString(), QString()/*"nickthompson@lucent.com" bounces*/);
    aboutData.addAuthor(i18n("Matthias Hölzer"),QString(),QStringLiteral("hoelzer@kde.org"));
    aboutData.addAuthor(i18n("David Gümbel"),QString(),QStringLiteral("david.guembel@gmx.net"));
    aboutData.addAuthor(i18n("Richard Moore"),QString(),QStringLiteral("rich@kde.org"));
    aboutData.addAuthor(i18n("Dawit Alemayehu"),QString(),QStringLiteral("adawit@kde.org"));
    aboutData.addAuthor(i18n("Kai Uwe Broulik"),QString(),QStringLiteral("kde@privat.broulik.de"));
    KAboutData::setApplicationData(aboutData);
    QApplication::setWindowIcon(QIcon::fromTheme(QStringLiteral("system-run")));

QCommandLineParser parser;
    aboutData.setupCommandLine(&parser);

parser.addOption(QCommandLineOption(QStringList() << QLatin1String("yesno"), i18n("Question message box with yes/no buttons"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("yesnocancel"), i18n("Question message box with yes/no/cancel buttons"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("warningyesno"), i18n("Warning message box with yes/no buttons"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("warningcontinuecancel"), i18n("Warning message box with continue/cancel buttons"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("warningyesnocancel"), i18n("Warning message box with yes/no/cancel buttons"), QLatin1String("text")));

parser.addOption(QCommandLineOption(QStringList() << QLatin1String("yes-label"), i18n("Use text as Yes button label"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("no-label"), i18n("Use text as No button label"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("cancel-label"), i18n("Use text as Cancel button label"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("continue-label"), i18n("Use text as Continue button label"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("sorry"), i18n("'Sorry' message box"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("detailedsorry"), i18n("'Sorry' message box with expandable Details field"), QLatin1String("text> <details")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("error"), i18n("'Error' message box"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("detailederror"), i18n("'Error' message box with expandable Details field"), QLatin1String("text> <details")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("msgbox"), i18n("Message Box dialog"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("inputbox"), i18n("Input Box dialog"), QLatin1String("text> <init")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("password"), i18n("Password dialog"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("newpassword"), i18n("New Password dialog"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("textbox"), i18n("Text Box dialog"), QLatin1String("file")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("textinputbox"), i18n("Text Input Box dialog"), QLatin1String("text> <init")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("combobox"), i18n("ComboBox dialog"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("menu"), i18n("Menu dialog"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("checklist"), i18n("Check List dialog"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("radiolist"), i18n("Radio List dialog"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("passivepopup"), i18n("Passive Popup"), QLatin1String("text> <timeout")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("icon"), i18n("Passive popup icon"), QLatin1String("icon")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("getopenfilename"), i18n("File dialog to open an existing file (arguments [startDir] [filter])")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("getsavefilename"), i18n("File dialog to save a file (arguments [startDir] [filter])")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("getexistingdirectory"), i18n("File dialog to select an existing directory (arguments [startDir])")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("getopenurl"), i18n("File dialog to open an existing URL (arguments [startDir] [filter])")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("getsaveurl"), i18n("File dialog to save a URL (arguments [startDir] [filter])")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("geticon"), i18n("Icon chooser dialog (arguments [group] [context])")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("progressbar"), i18n("Progress bar dialog, returns a D-Bus reference for communication"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("getcolor"), i18n("Color dialog to select a color")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("format"), i18n("Allow --getcolor to specify output format"), QLatin1String("text")));
    // TODO gauge stuff, reading values from stdin
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("title"), i18n("Dialog title"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("default"), i18n("Default entry to use for combobox, menu and color"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("multiple"), i18n("Allows the --getopenurl and --getopenfilename options to return multiple files")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("separate-output"), i18n("Return list items on separate lines (for checklist option and file open with --multiple)")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("print-winid"), i18n("Outputs the winId of each dialog")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("dontagain"), i18n("Config file and option name for saving the \"do-not-show/ask-again\" state"), QLatin1String("file:entry")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("slider"), i18n( "Slider dialog box, returns selected value" ), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("calendar"), i18n( "Calendar dialog box, returns selected date" ), QLatin1String("text")));
    /* kdialog originally used --embed for attaching the dialog box.  However this is misleading and so we changed to --attach.
     * For backwards compatibility, we silently map --embed to --attach */
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("attach"), i18n("Makes the dialog transient for an X app specified by winid"), QLatin1String("winid")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("embed"), i18n("A synonym for --attach"), QLatin1String("winid")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("geometry"), i18n("Dialog geometry: [=][<width>{xX}<height>][{+-}<xoffset>{+-}<yoffset>]"), QLatin1String("geometry")));

parser.addPositionalArgument(QLatin1String("[arg]"), i18n("Arguments - depending on main option"));

parser.process(rawArgs);
    aboutData.processCommandLine(&parser);

// execute kdialog command

const QStringList args = parser.positionalArguments();
    const QString title = parser.value(QStringLiteral("title"));
    const bool separateOutput = parser.isSet(QStringLiteral("separate-output"));
    const bool printWId = parser.isSet(QStringLiteral("print-winid"));
    QString defaultEntry;
    const QString geometry = parser.value(QStringLiteral("geometry"));
    Utils::setGeometry(geometry);

WId winid = 0;
    bool attach = parser.isSet(QStringLiteral("attach"));
    if(attach) {
#ifdef Q_WS_WIN
        winid = reinterpret_cast<WId>(parser.value(QStringLiteral("attach")).toLong(&attach, 0));  //C style parsing.  If the string begins with "0x", base 16 is used; if the string begins with "0", base 8 is used; otherwise, base 10 is used.
#else
        winid = parser.value(QStringLiteral("attach")).toLong(&attach, 0);  //C style parsing.  If the string begins with "0x", base 16 is used; if the string begins with "0", base 8 is used; otherwise, base 10 is used.
#endif
    } else if(parser.isSet(QStringLiteral("embed"))) {
        /* KDialog originally used --embed for attaching the dialog box.  However this is misleading and so we changed to --attach.
         * For consistancy, we silently map --embed to --attach */
        attach = true;
#ifdef Q_WS_WIN
        winid = reinterpret_cast<WId>(parser.value(QStringLiteral("embed")).toLong(&attach, 0));  //C style parsing.  If the string begins with "0x", base 16 is used; if the string begins with "0", base 8 is used; otherwise, base 10 is used.
#else
        winid = parser.value(QStringLiteral("embed")).toLong(&attach, 0);  //C style parsing.  If the string begins with "0x", base 16 is used; if the string begins with "0", base 8 is used; otherwise, base 10 is used.
#endif
    }

if (printWId || attach)
    {
      (void)new WinIdEmbedder(printWId, winid);
    }

// button labels
    // Initialize with default labels
    KGuiItem yesButton = KStandardGuiItem::yes();
    KGuiItem noButton = KStandardGuiItem::no();
    KGuiItem cancelButton = KStandardGuiItem::cancel();
    KGuiItem continueButton = KStandardGuiItem::cont();

// Customize the asked labels
    if (parser.isSet(QStringLiteral("yes-label"))) {
          yesButton = configuredYes( parser.value(QStringLiteral("yes-label")) );
    }
    if (parser.isSet(QStringLiteral("no-label"))) {
        noButton = configuredNo( parser.value(QStringLiteral("no-label")) );
    }
    if (parser.isSet(QStringLiteral("cancel-label"))) {
        cancelButton = configuredCancel( parser.value(QStringLiteral("cancel-label") ));
    }
    if (parser.isSet(QStringLiteral("continue-label"))) {
        continueButton = configuredContinue( parser.value(QStringLiteral("continue-label")) );
    }

// --yesno and other message boxes
    KMessageBox::DialogType type = static_cast<KMessageBox::DialogType>(0);
    QByteArray option;
    if (parser.isSet(QStringLiteral("yesno"))) {
        option = "yesno";
        type = KMessageBox::QuestionYesNo;
    }
    else if (parser.isSet(QStringLiteral("yesnocancel"))) {
        option = "yesnocancel";
        type = KMessageBox::QuestionYesNoCancel;
    }
    else if (parser.isSet(QStringLiteral("warningyesno"))) {
        option = "warningyesno";
        type = KMessageBox::WarningYesNo;
    }
    else if (parser.isSet(QStringLiteral("warningcontinuecancel"))) {
        option = "warningcontinuecancel";
        type = KMessageBox::WarningContinueCancel;
    }
    else if (parser.isSet(QStringLiteral("warningyesnocancel"))) {
        option = "warningyesnocancel";
        type = KMessageBox::WarningYesNoCancel;
    }
    else if (parser.isSet(QStringLiteral("sorry"))) {
        option = "sorry";
        type = KMessageBox::Sorry;
    }
    else if (parser.isSet(QStringLiteral("detailedsorry"))) {
        option = "detailedsorry";
    }
    else if (parser.isSet(QStringLiteral("error"))) {
        option = "error";
        type = KMessageBox::Error;
    }
    else if (parser.isSet(QStringLiteral("detailederror"))) {
        option = "detailederror";
    }
    else if (parser.isSet(QStringLiteral("msgbox"))) {
        option = "msgbox";
        type = KMessageBox::Information;
    }

if ( !option.isEmpty() )
    {
        KConfig* dontagaincfg = nullptr;
        // --dontagain
        QString dontagain; // QString()
        if (parser.isSet(QStringLiteral("dontagain")))
        {
          QString value = parser.value(QStringLiteral("dontagain"));
          QStringList values = value.split( QLatin1Char(':'), QString::SkipEmptyParts );
          if( values.count() == 2 )
          {
            dontagaincfg = new KConfig( values[ 0 ] );
            KMessageBox::setDontShowAgainConfig( dontagaincfg );
            dontagain = values[ 1 ];
          }
          else
            qDebug( "Incorrect --dontagain!" );
        }
        int ret = 0;

QString text = Utils::parseString(parser.value(QString::fromLatin1(option)));

QString details;
        if (args.count() == 1) {
            details = Utils::parseString(args.at(0));
        }

if ( type == KMessageBox::WarningContinueCancel ) {
            ret = KMessageBox::messageBox( nullptr, type, text, title, continueButton,
                noButton, cancelButton, dontagain );
        } else if (option == "detailedsorry") {
            KMessageBox::detailedSorry( nullptr, text, details, title );
        } else if (option == "detailederror") {
            KMessageBox::detailedError( nullptr, text, details, title );
        } else {
            ret = KMessageBox::messageBox( nullptr, type, text, title,
                yesButton, noButton, cancelButton, dontagain );
        }
        delete dontagaincfg;
        // ret is 1 for Ok, 2 for Cancel, 3 for Yes, 4 for No and 5 for Continue.
        // We want to return 0 for ok, yes and continue, 1 for no and 2 for cancel
        return (ret == KMessageBox::Ok || ret == KMessageBox::Yes || ret == KMessageBox::Continue) ? 0
                     : ( ret == KMessageBox::No ? 1 : 2 );
    }

// --inputbox text [init]
    if (parser.isSet(QStringLiteral("inputbox")))
    {
      QString result;
      QString init;

if (args.count() > 0) {
          init = args.at(0);
      }

const bool retcode = Widgets::inputBox(nullptr, title, parser.value(QStringLiteral("inputbox")), init, result);
      cout << result.toLocal8Bit().data() << endl;
      return retcode ? 0 : 1;
    }

// --password text
    if (parser.isSet(QStringLiteral("password")))
    {
      QString result;
      const bool retcode = Widgets::passwordBox(nullptr, title, parser.value(QStringLiteral("password")), result);
      cout << qPrintable(result) << endl;
      return retcode ? 0 : 1;
    }
    
    // --newpassword text
    if (parser.isSet(QStringLiteral("newpassword")))
    {
      QString result;
      const bool retcode = Widgets::newPasswordBox(nullptr, title, parser.value(QStringLiteral("newpassword")), result);
      cout << qPrintable(result) << endl;
      return retcode ? 0 : 1;
    }

// --passivepopup
    if (parser.isSet(QStringLiteral("passivepopup")))
    {
        int timeout = 0;
        if (args.count() > 0) {
            timeout = 1000 * args.at(0).toInt();
        }

if (timeout < 0) {
            timeout = -1;
        }

// Use --icon parameter for passivepopup as well
        QString icon;
        if (parser.isSet(QStringLiteral("icon"))) {
          icon = parser.value(QStringLiteral("icon"));
        } else {
          icon = QStringLiteral("dialog-information");        // Use generic (i)-icon if none specified
        }

// try to use more stylish notifications
        if (sendVisualNotification(Utils::parseString(parser.value(QStringLiteral("passivepopup"))), title, icon, timeout))
          return 0;

// ...did not work, use KPassivePopup as fallback

// parse timeout time again, so it does not auto-close the fallback (timer cannot handle -1 time)
        if (args.count() > 0) {
            timeout = 1000 * args.at(0).toInt();
        }
        if (timeout <= 0) {
            timeout = 10*1000;    // 10 seconds should be a decent time for auto-closing (you can override this using a parameter)
        }

QPixmap passiveicon;
        if (parser.isSet(QStringLiteral("icon"))) {  // Only show icon if explicitly requested
            passiveicon = KIconLoader::global()->loadIcon(icon, KIconLoader::Dialog);
        }
        KPassivePopup *popup = KPassivePopup::message( KPassivePopup::Boxed, // style
                                                       title,
                                                       Utils::parseString(parser.value(QStringLiteral("passivepopup"))),
                                                       passiveicon,
                                                       (QWidget*)0UL, // parent
                                                       timeout );
        QTimer *timer = new QTimer();
        QObject::connect( timer, SIGNAL(timeout()), qApp, SLOT(quit()) );
        QObject::connect( popup, SIGNAL(clicked()), qApp, SLOT(quit()) );
        timer->setSingleShot( true );
        timer->start( timeout );

#ifdef HAVE_X11
        if ( !geometry.isEmpty()) {
            int x, y;
            int w, h;
            int m = XParseGeometry( geometry.toLatin1().constData(), &x, &y, (unsigned int*)&w, (unsigned int*)&h);
            if ( (m & XNegative) )
                x = QApplication::desktop()->width()  + x - w;
            if ( (m & YNegative) )
                y = QApplication::desktop()->height() + y - h;
            popup->setAnchor( QPoint(x, y) );
        }
#endif
        qApp->exec();
        return 0;
    }

// --textbox file [width] [height]
    if (parser.isSet(QStringLiteral("textbox")))
    {
        int w = 0;
        int h = 0;

if (args.count() == 2) {
            w = args.at(0).toInt();
            h = args.at(1).toInt();
        }

return Widgets::textBox(nullptr, w, h, title, parser.value(QStringLiteral("textbox")));
    }

// --textinputbox file [width] [height]
    if (parser.isSet(QStringLiteral("textinputbox")))
    {
      int w = 400;
      int h = 200;

if (args.count() >= 3) {
        w = args.at(1).toInt();
        h = args.at(2).toInt();
      }

QString init;
      if (args.count() >= 1) {
          init = Utils::parseString(args.at(0));
      }

QString result;
      int ret = Widgets::textInputBox(nullptr, w, h, title, Utils::parseString(parser.value(QStringLiteral("textinputbox"))), init, result);
      cout << qPrintable(result) << endl;
      return ret;
    }

// --combobox <text> item [item] ..."
    if (parser.isSet(QStringLiteral("combobox"))) {
        QStringList list;
        if (args.count() >= 1) {
            for (int i = 0; i < args.count(); i++) {
                list.append(args.at(i));
            }
            const QString text = Utils::parseString(parser.value(QStringLiteral("combobox")));
            if (parser.isSet(QStringLiteral("default"))) {
                defaultEntry = parser.value(QStringLiteral("default"));
            }
            QString result;
            const bool retcode = Widgets::comboBox(nullptr, title, text, list, defaultEntry, result);
            cout << result.toLocal8Bit().data() << endl;
            return retcode ? 0 : 1;
        }
        cerr << qPrintable(i18n("Syntax: --combobox <text> item [item] ...")) << endl;
        return -1;
    }

// --menu text [tag item] [tag item] ...
    if (parser.isSet(QStringLiteral("menu"))) {
        QStringList list;
        if (args.count() >= 2) {
            for (int i = 0; i < args.count(); i++) {
                list.append(args.at(i));
            }
            const QString text = Utils::parseString(parser.value(QStringLiteral("menu")));
            if (parser.isSet(QStringLiteral("default"))) {
                defaultEntry = parser.value(QStringLiteral("default"));
            }
            QString result;
            const bool retcode = Widgets::listBox(nullptr, title, text, list, defaultEntry, result);
            if (1 == retcode) { // OK was selected
                cout << result.toLocal8Bit().data() << endl;
            }
            return retcode ? 0 : 1;
        }
        cerr << qPrintable(i18n("Syntax: --menu text [tag item] [tag item] ...")) << endl;
        return -1;
    }

// --checklist text [tag item status] [tag item status] ...
    if (parser.isSet(QStringLiteral("checklist"))) {
        QStringList list;
        if (args.count() >= 3) {
            for (int i = 0; i < args.count(); i++) {
                list.append(args.at(i));
            }

const QString text = Utils::parseString(parser.value(QStringLiteral("checklist")));
            QStringList result;

const bool retcode = Widgets::checkList(nullptr, title, text, list, separateOutput, result);

for (int i=0; i<result.count(); i++)
                if (!result.at(i).isEmpty()) {
                    cout << result.at(i).toLocal8Bit().data() << endl;
                }
            return retcode ? 0 : 1;
        }
        cerr << qPrintable(i18n("Syntax: --checklist text [tag item on/off] [tag item on/off]")) << endl;
        return -1;
    }

// --radiolist text [tag item status] ...
    if (parser.isSet(QStringLiteral("radiolist"))) {
        QStringList list;
        if (args.count() >= 3) {
            for (int i = 0; i < args.count(); i++) {
                list.append(args.at(i));
            }

const QString text = Utils::parseString(parser.value(QStringLiteral("radiolist")));
            QString result;
            const bool retcode = Widgets::radioBox(nullptr, title, text, list, result);
            cout << result.toLocal8Bit().data() << endl;
            return retcode ? 0 : 1;
        }
        cerr << qPrintable(i18n("Syntax: --radiolist text [tag item on/off] ...")) << endl;
        return -1;
    }

// getopenfilename [startDir] [filter]
    // getopenurl [startDir] [filter]
    if (parser.isSet(QStringLiteral("getopenfilename")) || parser.isSet(QStringLiteral("getopenurl"))) {
        QString startDir = args.count() > 0 ? args.at(0) : QString();
        const QUrl startUrl = QUrl::fromUserInput(startDir);
        QString filter;
        if (args.count() > 1)  {
            filter = Utils::parseString(args.at(1));
        }
        const bool multiple = parser.isSet(QStringLiteral("multiple"));

QFileDialog dlg;
        dlg.setAcceptMode(QFileDialog::AcceptOpen);
        dlg.setDirectoryUrl(initialDirectory(startUrl));
        dlg.selectFile(initialSelection(startUrl));

if (multiple) {
            dlg.setFileMode(QFileDialog::ExistingFiles);
        } else {
            dlg.setFileMode(QFileDialog::ExistingFile);
        }
        const bool openUrls = parser.isSet(QStringLiteral("getopenurl"));
        if (!openUrls) {
            dlg.setSupportedSchemes({QStringLiteral("file")});
        }
        setFileDialogFilter(dlg, filter);
        Utils::handleXGeometry(&dlg);
        dlg.setWindowTitle(title.isEmpty() ? i18nc("@title:window", "Open") : title);
        if (!dlg.exec()) {
            return 1; // canceled
        }

if (openUrls) {
            const QList<QUrl> result = dlg.selectedUrls();
            if (!result.isEmpty()) {
                if (multiple) {
                    outputStringList(result, separateOutput);
                    return 0;
                } else {
                    cout << result.at(0).url().toLocal8Bit().data() << endl;
                    return 0;
                }
            }
        } else {
            const QStringList result = dlg.selectedFiles();
            if (!result.isEmpty())  {
                if (multiple) {
                    outputStringList(result, separateOutput);
                    return 0;
                } else {
                    cout << result.at(0).toLocal8Bit().data() << endl;
                    return 0;
                }
            }
        }
        return 1;
    }

// getsaveurl [startDir] [filter]
    // getsavefilename [startDir] [filter]
    if ( (parser.isSet(QStringLiteral("getsavefilename")) ) || (parser.isSet(QStringLiteral("getsaveurl")) ) ) {
        QString startDir = args.count() > 0 ? args.at(0) : QString();
        QString filter;
        const QUrl startUrl = QUrl::fromUserInput(startDir);

if (args.count() > 1)  {
            filter = Utils::parseString(args.at(1));
        }
        QFileDialog dlg;
        dlg.setAcceptMode(QFileDialog::AcceptSave);
        dlg.setFileMode(QFileDialog::AnyFile);
        dlg.setDirectoryUrl(initialDirectory(startUrl));
        dlg.selectFile(initialSelection(startUrl));
        setFileDialogFilter(dlg, filter);
        const bool saveUrls = parser.isSet(QStringLiteral("getsaveurl"));
        if (!saveUrls) {
            dlg.setSupportedSchemes({QStringLiteral("file")});
        }
        Utils::handleXGeometry(&dlg);
        dlg.setWindowTitle(title.isEmpty() ? i18nc("@title:window", "Save As") : title);
        if (!dlg.exec()) {
            return 1; // canceled
        }

if (saveUrls) {
            const QList<QUrl> result = dlg.selectedUrls();
            if (!result.isEmpty())  {
                cout << result.at(0).toString().toLocal8Bit().data() << endl;
                return 0;
            }
        } else { // getsavefilename
            const QStringList result = dlg.selectedFiles();
            if (!result.isEmpty())  {
                const QString file = result.at(0);
                KRecentDocument::add(QUrl::fromLocalFile(file));
                cout << file.toLocal8Bit().data() << endl;
                return 0;
            }
        }
        return 1; // canceled
    }

// getexistingdirectory [startDir]
    if (parser.isSet(QStringLiteral("getexistingdirectory"))) {
        QString startDir = args.count() > 0 ? args.at(0) : QString();
        const QUrl startUrl = QUrl::fromUserInput(startDir);

QFileDialog dlg;
        dlg.setFileMode(QFileDialog::DirectoryOnly);
        dlg.setOption(QFileDialog::ShowDirsOnly, true);
        dlg.setDirectoryUrl(initialDirectory(startUrl));
        dlg.selectFile(initialSelection(startUrl));
        Utils::handleXGeometry(&dlg);
        dlg.setWindowTitle(title.isEmpty() ? i18nc("@title:window", "Select Directory") : title);
        if (!dlg.exec()) {
            return 1; // canceled
        }
        const QList<QUrl> urls = dlg.selectedUrls();
        if (!urls.isEmpty()) {
            cout << qPrintable(urls.at(0).toDisplayString(QUrl::PreferLocalFile)) << endl;
            return 0;
        }
        return 1; // canceled
    }

// geticon [group] [context]
    if (parser.isSet(QStringLiteral("geticon"))) {
        QString groupStr, contextStr;
        groupStr = parser.value(QStringLiteral("geticon"));
        if (args.count() >= 1)  {
            contextStr = args.at(0);
        }
        const KIconLoader::Group group =
            ( groupStr == QLatin1String( "Desktop" ) ) ?     KIconLoader::Desktop :
            ( groupStr == QLatin1String( "Toolbar" ) ) ?     KIconLoader::Toolbar :
            ( groupStr == QLatin1String( "MainToolbar" ) ) ? KIconLoader::MainToolbar :
            ( groupStr == QLatin1String( "Small" ) ) ?       KIconLoader::Small :
            ( groupStr == QLatin1String( "Panel" ) ) ?       KIconLoader::Panel :
            ( groupStr == QLatin1String( "Dialog" ) ) ?      KIconLoader::Dialog :
            ( groupStr == QLatin1String( "User" ) ) ?        KIconLoader::User :
            /* else */                                       KIconLoader::NoGroup;

const KIconLoader::Context context =
            ( contextStr == QLatin1String( "Action" ) ) ?        KIconLoader::Action :
            ( contextStr == QLatin1String( "Application" ) ) ?   KIconLoader::Application :
            ( contextStr == QLatin1String( "Device" ) ) ?        KIconLoader::Device :
            ( contextStr == QLatin1String( "FileSystem" ) ) ?    KIconLoader::FileSystem :
            ( contextStr == QLatin1String( "MimeType" ) ) ?      KIconLoader::MimeType :
            ( contextStr == QLatin1String( "Animation" ) ) ?     KIconLoader::Animation :
            ( contextStr == QLatin1String( "Category" ) ) ?      KIconLoader::Category :
            ( contextStr == QLatin1String( "Emblem" ) ) ?        KIconLoader::Emblem :
            ( contextStr == QLatin1String( "Emote" ) ) ?         KIconLoader::Emote :
            ( contextStr == QLatin1String( "International" ) ) ? KIconLoader::International :
            ( contextStr == QLatin1String( "Place" ) ) ?         KIconLoader::Place :
            ( contextStr == QLatin1String( "StatusIcon" ) ) ?    KIconLoader::StatusIcon :
            // begin: KDE3 compatibility (useful?)
            ( contextStr == QLatin1String( "Devices" ) ) ?       KIconLoader::Device :
            ( contextStr == QLatin1String( "MimeTypes" ) ) ?     KIconLoader::MimeType :
            ( contextStr == QLatin1String( "FileSystems" ) ) ?   KIconLoader::FileSystem :
            ( contextStr == QLatin1String( "Applications" ) ) ?  KIconLoader::Application :
            ( contextStr == QLatin1String( "Actions" ) ) ?       KIconLoader::Action :
            // end: KDE3 compatibility
            /* else */                                           KIconLoader::Any;

KIconDialog dlg((QWidget*)Q_NULLPTR);
        dlg.setup( group, context);
        dlg.setIconSize(KIconLoader::SizeHuge);

if (!title.isEmpty())
            dlg.setWindowTitle(title);

Utils::handleXGeometry(&dlg);

const QString result = dlg.openDialog();

if (!result.isEmpty())  {
            cout << result.toLocal8Bit().data() << endl;
            return 0;
        }
        return 1; // canceled
    }

// --progressbar text totalsteps
    if (parser.isSet(QStringLiteral("progressbar")))
    {
       const QString text = Utils::parseString(parser.value(QStringLiteral("progressbar")));

QProcess process;
       QStringList arguments;
       arguments << QStringLiteral("--progressbar");
       arguments << text;
       arguments << QStringLiteral("--title");
       arguments << title;
       if (args.count() == 1) {
           arguments << args.at(0);
       }
       qint64 pid = 0;
       if (process.startDetached(QStringLiteral("kdialog_progress_helper"), arguments, QString(), &pid)) {
           QDBusConnection dbus = QDBusConnection::sessionBus();
           const QString serviceName = QStringLiteral("org.kde.kdialog-") + QString::number(pid);
           QDBusServiceWatcher watcher(serviceName, dbus, QDBusServiceWatcher::WatchForRegistration);
           QObject::connect(&watcher, &QDBusServiceWatcher::serviceRegistered, [serviceName](){
                   std::cout << serviceName.toLatin1().constData() << " /ProgressDialog" << std::endl << std::flush;
                   qApp->quit();
           });
           qApp->exec();
           return 0;
       }
       qWarning() << "Error starting kdialog_progress_helper";
       return 1;
    }

// --getcolor
    if (parser.isSet(QStringLiteral("getcolor"))) {
        QColorDialog dlg;

if (parser.isSet(QStringLiteral("default"))) {
            defaultEntry = parser.value(QStringLiteral("default"));
            dlg.setCurrentColor(defaultEntry);
        } else {
            QColor color = KColorMimeData::fromMimeData(QApplication::clipboard()->mimeData(QClipboard::Clipboard));
            if (color.isValid()) {
                dlg.setCurrentColor(color);
            }
        }

Utils::handleXGeometry(&dlg);
        dlg.setWindowTitle(title.isEmpty() ? i18nc("@title:window", "Choose Color") : title);

if (dlg.exec()) {
            QString result;
            const QColor color = dlg.selectedColor();
            if (color.isValid() && parser.isSet(QStringLiteral("format"))) {
                bool found = false;
                QString format = parser.value(QStringLiteral("format"));
                format.remove(QLatin1Char('*')); // stripped out * for safety
                QList<QRegularExpression> pattern_pool;
                pattern_pool << QRegularExpression(QStringLiteral("(%#?[-+]?\\d*\\.?\\d*(?:ll|hh|l|h)?[diouxX])"))
                        << QRegularExpression(QStringLiteral("(%#?[-+]?\\d*\\.?\\d*[l]?[efgEFG])"));

for (int i = 0; i < pattern_pool.size(); i++) {
                    QRegularExpressionMatchIterator itor = pattern_pool.at(i).globalMatch(format);
                    QRegularExpressionMatch match;
                    int match_count = 0;
                    while (itor.hasNext()) {
                        match = itor.next();
                        if (match.hasMatch()) {
                            match_count++;
                        }
                    }
                    // currently only handle RGB, when alpha is ready, should hit 4
                    if (3 == match_count) {
                        found = true;
                        if (match.captured(0).contains(QRegularExpression(QStringLiteral("[diouxX]")))) {
                            result = QString::asprintf(format.toUtf8().constData(), color.red(), color.green(), color.blue());
                        } else {
                            result = QString::asprintf(format.toUtf8().constData(), color.redF(), color.greenF(), color.blueF());
                        }
                        break;
                    }
                }
                if (false == found) {
                    cout << "Invalid format pattern";
                }
            } else {
                result = color.name();
            }
            cout << result.toLocal8Bit().data() << endl;
            return 0;
        }
        return 1; // cancelled
    }
    if (parser.isSet(QStringLiteral("slider")))
    {
       int miniValue = 0;
       int maxValue = 0;
       int step = 0;
       const QString text = Utils::parseString(parser.value(QStringLiteral("slider")));
       if (args.count() == 3) {
           miniValue = args.at(0).toInt();
           maxValue = args.at( 1 ).toInt();
           step = args.at( 2 ).toInt();
       }
       int result = 0;

const bool returnCode = Widgets::slider(nullptr, title, text, miniValue, maxValue, step, result);
       if ( returnCode )
           cout << result << endl;
       return returnCode;
    }
    if (parser.isSet(QStringLiteral("calendar")))
    {
       const QString text = Utils::parseString(parser.value(QStringLiteral("calendar")));
       QDate result;

const bool returnCode = Widgets::calendar(nullptr, title, text, result);
       if ( returnCode )
           cout << result.toString().toLocal8Bit().data() << endl;
       return returnCode;
    }

parser.showHelp();
    return -2; // NOTREACHED
}
0707010CF4738C000081A40000000200000002000000015BA2313900000A3A000000FD0000001000000000000000000000004D00000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/kdialog_progress_helper.cpp//  Copyright (C) 2017 David Faure <faure@kde.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the7 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 <KDBusService>
#include <QApplication>
#include <QCommandLineOption>
#include <QCommandLineParser>
#include <KLocalizedString>
#include "progressdialog.h"
#include "utils.h"

#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char **argv)
{
    QStringList rawArgs;
    for (int i = 0; i < argc; ++i) {
        rawArgs << QString::fromLocal8Bit(argv[i]);
    }

// This code was given by Thiago as a solution for the issue that
    // otherwise bash waits for a SIGPIPE from kdialog that never comes in.
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, STDIN_FILENO);
    dup2(fd, STDOUT_FILENO);
    dup2(fd, STDERR_FILENO);
    close(fd);

QApplication app(argc, argv);
    app.setApplicationName(QStringLiteral("kdialog"));
    app.setOrganizationDomain(QStringLiteral("kde.org"));
    KLocalizedString::setApplicationDomain("kdialog");

KDBusService dbusService(KDBusService::Multiple);

QCommandLineParser parser;
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("progressbar"), i18n("Progress bar dialog, returns a D-Bus reference for communication"), QLatin1String("text")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("title"), i18n("Dialog title"), QLatin1String("text")));
    parser.addPositionalArgument(QLatin1String("[arg]"), i18n("Arguments - depending on main option"));
    parser.process(rawArgs);

const QStringList args = parser.positionalArguments();

const QString text = Utils::parseString(parser.value(QStringLiteral("progressbar")));
    const QString title = parser.value(QStringLiteral("title"));

int totalsteps = 100;
    if (args.count() == 1)
        totalsteps = args.at(0).toInt();

ProgressDialog dlg(nullptr, title, text, totalsteps);
    return dlg.exec() ? 0 : 1;
}
0707010CF4738D000081A40000000200000002000000015BA23139000007D4000000FD0000001000000000000000000000004400000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/klistboxdialog.cpp//
//  Copyright (C) 1998-2005 Matthias Hoelzer
//  email:  hoelzer@physik.uni-wuerzburg.de
//
//  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 the7 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 "klistboxdialog.h"

#include <QLabel>
#include <QVBoxLayout>
#include <QDialogButtonBox>

KListBoxDialog::KListBoxDialog(const QString &text, QWidget *parent)
    : QDialog(parent)
{
    setModal(true);
    QVBoxLayout *vLayout = new QVBoxLayout(this);

label = new QLabel(text, this);
    vLayout->addWidget(label);
    label->setAlignment(Qt::AlignCenter);

table = new QListWidget(this);
    vLayout->addWidget(table);
    table->setFocus();

QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
    vLayout->addWidget(buttonBox);

connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
    connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));

}

void KListBoxDialog::insertItem(const QString& item)
{
    table->addItem(item);
    table->setCurrentItem(nullptr);
}

void KListBoxDialog::setCurrentItem(const QString& item)
{
    for (int i=0; i < table->count(); ++i) {
        if (table->item(i)->text() == item) {
            table->setCurrentItem(table->item(i));
            break;
        }
    }
}

int KListBoxDialog::currentItem() const
{
    return table->currentRow();
}
0707010CF4738E000081A40000000200000002000000015BA231390000052F000000FD0000001000000000000000000000004200000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/klistboxdialog.h//
//  Copyright (C) 1998-2005 Matthias Hoelzer
//  email:  hoelzer@physik.uni-wuerzburg.de
//
//  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 the7 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 KLISTBOXDIALOG_H
#define KLISTBOXDIALOG_H

#include <qdialog.h>

#include <QListWidget>

class QLabel;

class KListBoxDialog : public QDialog
{
  Q_OBJECT

public:

explicit KListBoxDialog(const QString &text, QWidget *parent=nullptr);
  ~KListBoxDialog() {}

QListWidget &getTable() { return *table; }

void insertItem( const QString& text );
  void setCurrentItem ( const QString& text );
  int currentItem() const;

protected:

QListWidget *table;
  QLabel *label;

};

#endif
0707010CF4738F000081A40000000200000002000000015BA23139000002C8000000FD0000001000000000000000000000005400000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/org.kde.kdialog.ProgressDialog.xml<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node>
  <interface name="org.kde.kdialog.ProgressDialog">
    <property name="maximum" type="i" access="readwrite"/>
    <property name="value" type="i" access="readwrite"/>
    <property name="autoClose" type="b" access="readwrite"/>
    <method name="setLabelText">
      <arg type="s" name="label" direction="in"/>
    </method>
    <method name="showCancelButton">
      <arg name="value" type="b" direction="in"/>
    </method>
    <method name="wasCancelled">
      <arg type="b" direction="out"/>
    </method>
    <method name="close"/>
  </interface>
</node>
0707010CF47390000081A40000000200000002000000015BA23139000005AA000000FD0000001000000000000000000000004400000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/progressdialog.cpp//
//  Copyright (C) 2004-2005 Stephan Binner <binner@kde.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the7 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 "progressdialog.h"
#include "utils.h"
#include "progressdialogadaptor.h"
#include <KLocalizedString>

ProgressDialog::ProgressDialog(QWidget* parent, const QString& caption, const QString& text, int totalSteps)
    : QProgressDialog(parent)
{
    setWindowTitle(caption);
    setLabelText(text);
    (void)new ProgressDialogAdaptor( this );
    QDBusConnection::sessionBus().registerObject( QLatin1String("/ProgressDialog"), this );
    setAutoClose( false );
    setMaximum( totalSteps );
    Utils::handleXGeometry(this);
}

void ProgressDialog::showCancelButton(bool show)
{
    setCancelButtonText(show ? i18n("Cancel") : QString());
}
0707010CF47391000081A40000000200000002000000015BA2313900000504000000FD0000001000000000000000000000004200000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/progressdialog.h//
//  Copyright (C) 2004-2005 Stephan Binner <binner@kde.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the7 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 PROGRESSDIALOG_H
#define PROGRESSDIALOG_H

#include <qprogressdialog.h>

class ProgressDialog : public QProgressDialog
{
    Q_OBJECT

public:
    explicit ProgressDialog(QWidget* parent = Q_NULLPTR,
                            const QString& caption = QString(),
                            const QString& text = QString(), int totalSteps = 100);

void showCancelButton(bool show);
    bool wasCancelled() const { return wasCanceled(); }
};

#endif // PROGRESSDIALOG_H
0707010CF47392000081A40000000200000002000000015BA2313900000A01000000FD0000001000000000000000000000003B00000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/utils.cpp//  Copyright (C) 2017 David Faure <faure@kde.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the7 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 "utils.h"
#include <QApplication>
#include <QDebug>
#include <QDesktopWidget>
#include "config-kdialog.h"

#if defined HAVE_X11 && ! defined K_WS_QTONLY
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#endif

static QString xGeometry;

void Utils::setGeometry(const QString &geometry)
{
    xGeometry = geometry;
}

void Utils::handleXGeometry(QWidget * dlg)
{
#ifdef HAVE_X11
    if ( !xGeometry.isEmpty()) {
        int x, y;
        int w, h;
        int m = XParseGeometry( xGeometry.toLatin1().constData(), &x, &y, (unsigned int*)&w, (unsigned int*)&h);
        if ( (m & XNegative) )
            x = QApplication::desktop()->width() + x - w;
        if ( (m & YNegative) )
            y = QApplication::desktop()->height() + y - h;
        dlg->setGeometry(x, y, w, h);
        qDebug() << "x: " << x << "  y: " << y << "  w: " << w << "  h: " << h;
    }
#endif
}

QString Utils::parseString(const QString &str)
{
    QString ret;
    ret.reserve(str.size());
    bool escaped = false;
    for (int i = 0; i < str.size(); i++) {
       QChar c = str.at(i);
       if (escaped) {
           escaped = false;
           if (c == QLatin1Char('\\')) {
               ret += c;
           } else if (c == QLatin1Char('n')) {
               ret += QLatin1Char('\n');
           } else {
               qWarning() << qPrintable(QString::fromLatin1("Unrecognized escape sequence \\%1").arg(c));
               ret += QLatin1Char('\\');
               ret += c;
           }
       } else {
           if (c == QLatin1Char('\\')) {
               escaped = true;
           } else {
               ret += c;
           }
       }
    }
    if (escaped) {
        qWarning() << "Unterminated escape sequence";
        ret += QLatin1Char('\\');
    }
    return ret;
}

0707010CF47393000081A40000000200000002000000015BA23139000003FE000000FD0000001000000000000000000000003900000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/utils.h//  Copyright (C) 2017 David Faure <faure@kde.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the7 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 UTILS_P_H
#define UTILS_P_H

#include <QString>
class QWidget;

namespace Utils
{
    void setGeometry(const QString &geometry);
    void handleXGeometry(QWidget * dlg);
    QString parseString(const QString &str);
}

#endif
0707010CF47394000081A40000000200000002000000015BA2313900002483000000FD0000001000000000000000000000003D00000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/widgets.cpp//
//  Copyright (C) 1998 Matthias Hoelzer <hoelzer@kde.org>
//  Copyright (C) 2002-2005 David Faure <faure@kde.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the7 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.
//

// Own
#include "config-kdialog.h"
#include "widgets.h"
#include "utils.h"

// Qt
#include <QComboBox>
#include <QDebug>
#include <QFile>
#include <QDesktopWidget>
#include <QInputDialog>
#include <QTextStream>
#include <QTextCursor>
#include <QLabel>
#include <QVBoxLayout>

// KDE
#include <kpassworddialog.h>
#include <knewpassworddialog.h>
#include <ktextedit.h>
#include <kdatepicker.h>
#include <klocalizedstring.h>

// Local
#include "klistboxdialog.h"
#include "progressdialog.h"

static void addButtonBox(QDialog &dlg, QDialogButtonBox::StandardButtons buttons = QDialogButtonBox::Ok | QDialogButtonBox::Cancel)
{
    QDialogButtonBox *buttonBox = new QDialogButtonBox(buttons, &dlg);
    dlg.layout()->addWidget(buttonBox);
    QObject::connect(buttonBox, SIGNAL(accepted()), &dlg, SLOT(accept()));
    QObject::connect(buttonBox, SIGNAL(rejected()), &dlg, SLOT(reject()));
}

bool Widgets::inputBox(QWidget *parent, const QString& title, const QString& text, const QString& init, QString &result)
{
    bool ok;
    const QString str = QInputDialog::getText(parent, title, text, QLineEdit::Normal, init, &ok);
    if (ok)
        result = str;
    return ok;
}

bool Widgets::passwordBox(QWidget *parent, const QString& title, const QString& text, QString &result)
{
  KPasswordDialog dlg( parent );
  dlg.setWindowTitle(title);
  dlg.setPrompt(text);

Utils::handleXGeometry(&dlg);

bool retcode = (dlg.exec() == QDialog::Accepted);
  if ( retcode )
    result = dlg.password();
  return retcode;
}

bool Widgets::newPasswordBox(QWidget *parent, const QString& title, const QString& text, QString &result)
{
  KNewPasswordDialog dlg( parent );
  dlg.setWindowTitle(title);
  dlg.setPrompt(text);
  
  Utils::handleXGeometry(&dlg);

bool retcode = (dlg.exec() == QDialog::Accepted);
  if ( retcode )
    result = dlg.password();
  return retcode;
}

int Widgets::textBox(QWidget *parent, int width, int height, const QString& title, const QString& file)
{
    QDialog dlg(parent);
    dlg.setWindowTitle(title);

QVBoxLayout *mainLayout = new QVBoxLayout(&dlg);

KTextEdit *edit = new KTextEdit(&dlg);
    mainLayout->addWidget(edit);
    edit->setReadOnly(true);
    edit->setFocus();

addButtonBox(dlg, QDialogButtonBox::Ok);

if (file == QLatin1String("-")) {
        QTextStream s(stdin, QIODevice::ReadOnly);
        while (!s.atEnd())
            edit->append(s.readLine());
    } else {
        QFile f(file);
        if (!f.open(QIODevice::ReadOnly)) {
            qWarning() << i18n("kdialog: could not open file %1", file);
            return -1;
        }
        QTextStream s(&f);
        while (!s.atEnd())
            edit->append(s.readLine());
    }

edit->setTextCursor(QTextCursor(edit->document()));

if (width > 0 && height > 0)
        dlg.resize(QSize(width, height));

Utils::handleXGeometry(&dlg);
    dlg.setWindowTitle(title);
    return (dlg.exec() == QDialog::Accepted) ? 0 : 1;
}

int Widgets::textInputBox(QWidget *parent, int width, int height, const QString& title, const QString& text, const QString& init, QString &result)
{
    QDialog dlg(parent);
    dlg.setWindowTitle(title);
    QVBoxLayout *mainLayout = new QVBoxLayout(&dlg);

if (!text.isEmpty()) {
        QLabel *label = new QLabel(&dlg);
        mainLayout->addWidget(label);
        label->setText(text);
    }

KTextEdit *edit = new KTextEdit(&dlg);
    mainLayout->addWidget(edit);
    edit->setReadOnly(false);
    edit->setFocus();
    edit->insertPlainText(init);

addButtonBox(dlg, QDialogButtonBox::Ok);

if (width > 0 && height > 0)
        dlg.resize(QSize(width, height));

Utils::handleXGeometry(&dlg);
    dlg.setWindowTitle(title);
    const int returnDialogCode = dlg.exec();
    result = edit->toPlainText();
    return (returnDialogCode == QDialog::Accepted ? 0 : 1);
}

bool Widgets::comboBox(QWidget *parent, const QString& title, const QString& text, const QStringList& args,
                       const QString& defaultEntry, QString &result)
{
    QDialog dlg(parent);
    dlg.setWindowTitle(title);

QVBoxLayout *mainLayout = new QVBoxLayout(&dlg);

QLabel *label = new QLabel(&dlg);
    label->setText(text);
    mainLayout->addWidget(label);
    QComboBox *combo = new QComboBox(&dlg);
    combo->addItems(args);
    combo->setCurrentIndex(combo->findText(defaultEntry));
    combo->setFocus();
    mainLayout->addWidget(combo);
    addButtonBox(dlg);
    Utils::handleXGeometry(&dlg);

bool retcode = (dlg.exec() == QDialog::Accepted);

if (retcode)
        result = combo->currentText();

return retcode;
}

bool Widgets::listBox(QWidget *parent, const QString& title, const QString& text, const QStringList& args,
                      const QString& defaultEntry, QString &result)
{
  KListBoxDialog box(text,parent);

box.setWindowTitle(title);

for (int i = 0; i+1<args.count(); i += 2) {
    box.insertItem(args[i+1]);
  }
  box.setCurrentItem( defaultEntry );

Utils::handleXGeometry(&box);

const bool retcode = (box.exec() == QDialog::Accepted);
  if ( retcode )
    result = args[ box.currentItem()*2 ];
  return retcode;
}

bool Widgets::checkList(QWidget *parent, const QString& title, const QString& text, const QStringList& args, bool separateOutput, QStringList &result)
{
  QStringList entries, tags;
  QString rs;

result.clear();

KListBoxDialog box(text,parent);

QListWidget &table = box.getTable();

box.setWindowTitle(title);

for (int i=0; i+2<args.count(); i += 3) {
    tags.append(args[i]);
    entries.append(args[i+1]);
  }

table.addItems(entries);
  table.setSelectionMode(QListWidget::MultiSelection);
  table.setCurrentItem(nullptr); // This is to circumvent a Qt bug

for (int i=0; i+2<args.count(); i += 3) {
    table.item( i/3 )->setSelected( args[i+2] == QLatin1String("on") );
  }

Utils::handleXGeometry(&box);

const bool retcode = (box.exec() == QDialog::Accepted);

if ( retcode ) {
    if (separateOutput) {
      for (int i=0; i<table.count(); i++)
        if (table.item(i)->isSelected())
          result.append(tags[i]);
    } else {
      for (int i=0; i<table.count(); i++)
        if (table.item(i)->isSelected())
          rs += QLatin1String("\"") + tags[i] + QLatin1String("\" ");
      result.append(rs);
    }
  }
  return retcode;
}

bool Widgets::radioBox(QWidget *parent, const QString& title, const QString& text, const QStringList& args, QString &result)
{
  QStringList entries, tags;

KListBoxDialog box(text,parent);

QListWidget &table = box.getTable();

box.setWindowTitle(title);

for (int i=0; i+2<args.count(); i += 3) {
    tags.append(args[i]);
    entries.append(args[i+1]);
  }

table.addItems(entries);

for (int i=0; i+2<args.count(); i += 3) {
    if (args[i+2] == QLatin1String("on")) {
      table.setCurrentRow(i/3);
    }
  }

Utils::handleXGeometry(&box);

const bool retcode = (box.exec() == QDialog::Accepted);
  if ( retcode )
    result = tags[ table.currentRow() ];
  return retcode;
}

bool Widgets::slider(QWidget *parent, const QString& title, const QString& text, int minValue, int maxValue, int step, int &result)
{
    QDialog dlg(parent);
    dlg.setWindowTitle(title);

QVBoxLayout *mainLayout = new QVBoxLayout(&dlg);

QLabel *label = new QLabel(&dlg);
    mainLayout->addWidget(label);
    label->setText (text);
    QSlider *slider = new QSlider(&dlg);
    mainLayout->addWidget(slider);
    slider->setMinimum(minValue);
    slider->setMaximum(maxValue);
    slider->setSingleStep(step);
    slider->setTickPosition(QSlider::TicksAbove);
    slider->setOrientation(Qt::Horizontal);
    slider->setFocus();
    Utils::handleXGeometry(&dlg);

addButtonBox(dlg);

const bool retcode = (dlg.exec() == QDialog::Accepted);

if (retcode)
        result = slider->value();

return retcode;
}

bool Widgets::calendar( QWidget *parent, const QString &title, const QString &text, QDate & result )
{
    QDialog dlg(parent);
    dlg.setWindowTitle(title);

QVBoxLayout *mainLayout = new QVBoxLayout(&dlg);

QLabel *label = new QLabel(&dlg);
    mainLayout->addWidget(label);
    label->setText(text);
    KDatePicker *dateWidget = new KDatePicker(&dlg);
    mainLayout->addWidget(dateWidget);
    dateWidget->setFocus();
    addButtonBox(dlg);
    Utils::handleXGeometry(&dlg);

const bool retcode = (dlg.exec() == QDialog::Accepted);

if (retcode)
        result = dateWidget->date();

return retcode;
}

0707010CF47395000081A40000000200000002000000015BA2313900000922000000FD0000001000000000000000000000003B00000000kdialog-VERSIONgit.20180919T132129~f28a206bb/src/widgets.h//
//  Copyright (C) 1998 Matthias Hoelzer <hoelzer@kde.org>
//  Copyright (C) 2002-2005 David Faure <faure@kde.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the7 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 WIDGETS_H
#define WIDGETS_H

#include <QDate>
#include <QWidget>
#include <QStringList>

namespace Widgets
{
    bool inputBox(QWidget *parent, const QString& title, const QString& text, const QString& init, QString &result);
    bool passwordBox(QWidget *parent, const QString& title, const QString& text, QString &result);
    bool newPasswordBox(QWidget *parent, const QString& title, const QString& text, QString &result);
    int textBox(QWidget *parent, int width, int height, const QString& title, const QString& file);
    int textInputBox(QWidget *parent, int width, int height, const QString& title, const QString& text, const QString& init, QString &result);
    bool listBox(QWidget *parent, const QString& title, const QString& text, const QStringList& args, const QString &defaultEntry, QString &result);
    bool checkList(QWidget *parent, const QString& title, const QString& text, const QStringList& args, bool separateOutput, QStringList &result);
    bool radioBox(QWidget *parent, const QString& title, const QString& text, const QStringList& args, QString &result);
    bool comboBox(QWidget *parent, const QString& title, const QString& text, const QStringList& args, const QString& defaultEntry, QString &result);
    bool slider( QWidget *parent, const QString& title, const QString& test, int minValue, int maxValue, int step, int &result );
    bool calendar( QWidget *parent, const QString &title, const QString &text, QDate & result );
}

#endif
0707010CF47396000041ED0000000200000002000000025BA2313900000000000000FD0000001000000000000000000000003300000000kdialog-VERSIONgit.20180919T132129~f28a206bb/tests0707010CF47397000081ED0000000200000002000000015BA23139000001C0000000FD0000001000000000000000000000004600000000kdialog-VERSIONgit.20180919T132129~f28a206bb/tests/progresscanceldemodbusRef=`kdialog --progressbar "Press Cancel at Any time" 10`
qdbus $dbusRef org.kde.kdialog.ProgressDialog.showCancelButton true

while test "false" = "`qdbus $dbusRef org.kde.kdialog.ProgressDialog.wasCancelled 2>/dev/null`"; do
  inc=$((`qdbus $dbusRef org.freedesktop.DBus.Properties.Get org.kde.kdialog.ProgressDialog value` + 1))
  qdbus $dbusRef org.freedesktop.DBus.Properties.Set org.kde.kdialog.ProgressDialog value $inc;
  sleep 1
done

0707010CF47398000081ED0000000200000002000000015BA23139000001AA000000FD0000001000000000000000000000004000000000kdialog-VERSIONgit.20180919T132129~f28a206bb/tests/progressdemodbusRef=`kdialog --geometry 300x200+100-100 --progressbar "Initialising" 6`
qdbus $dbusRef value 1
qdbus $dbusRef setLabelText "Thinking really hard"
sleep 2
qdbus $dbusRef value 2
sleep 2
qdbus $dbusRef setLabelText "Thinking some more"
qdbus $dbusRef value 3
sleep 2
qdbus $dbusRef value 4
sleep 2
qdbus $dbusRef setLabelText "Finishing up"
qdbus $dbusRef value 5
sleep 1
qdbus $dbusRef value 6
sleep 1
qdbus $dbusRef close
0707010CF47399000081ED0000000200000002000000015BA2313900000B3F000000FD0000001000000000000000000000003800000000kdialog-VERSIONgit.20180919T132129~f28a206bb/tests/testecho "yesno box:"
kdialog --geometry 400x300+100+50 --title "This is a yesno box" --yesno "Choose: yes or no"
if [ $? = 0 ]; then
  echo " your choice was: yes"
else
  echo " your choice was: no"
fi

echo "continue or cancel warning box:"
kdialog --geometry 200x300+100-50 --title "This is a warningcontinuecancel box" --warningcontinuecancel "Choose: continue or cancel"
if [ $? = 0 ]; then
  echo " your choice was: continue"
else
  echo " your choice was: cancel"
fi

echo "message box:"
kdialog --geometry 300x400-100-50 --title "This is a message" --msgbox "Well, this is it:\nthe message"

echo "input box:"
kdialog --title "This is a input box" --inputbox "What is your name" "Joe User"
if [ $? = 0 ]; then
  echo " you accepted"
else
  echo " you did not accept"
fi

echo "input box, with geometry:"
kdialog --geometry 300x400-100-50 --title "This is a input box" --inputbox "What is your name" "Joe User"
if [ $? = 0 ]; then
  echo " you accepted"
else
  echo " you did not accept"
fi

echo "text box:"
kdialog --geometry 300x400-100-50 --icon "about-kde" --title "This is a text box" --textbox widgets.h 400 300

echo "menu:"
kdialog --icon "about-kde" --geometry 300x400-100-50 --title "This is a menu" --default "French" --menu "Choose one of these" a English b German c French d Spanish

echo "checklist:"
kdialog --geometry 400x300+100+50 --icon "about-kde" --title "This is a checklist" --checklist "Choose some of these" a English on  b German off  c French off d Spanish on

echo "radiolist:"
kdialog --geometry 400x300+100+50 --icon "about-kde" --title "This is a radiolist" --radiolist "Choose one of these" a English off b German off c French on d Spanish off

echo "combobox:"
kdialog --geometry 400x300+100+50 --icon "about-kde" --default "Chocolate" --title "This is a combobox" --combobox "Pick your favorite ice-cream flavor:" "Vanilla" "Chocolate" "Strawberry" "Fudge"

echo "passivepopup:"
kdialog --geometry 1x1+200+350 --title "This is a passive popup" --passivepopup "It will disappear in about 10 seconds" 10

echo "password:"
kdialog --title "This is a password dialog" --geometry 400x300+100+50 --icon "desktop" --icon "about-kde" --password "Enter the password:"

echo "Open File:"
kdialog --getopenfilename . "*.cpp *.cc *.c |C and C++ Source Files"

echo "Open multiple files:"
kdialog --multiple --getopenfilename . "*.cpp *.cc *.c |C and C++ Source Files"

echo "Open multiple files, output on separate lines:"
kdialog --multiple --separate-output --getopenfilename . "*.cpp *.cc *.c |C and C++ Source Files"

echo "Open URL:"
kdialog --getopenurl . "*.cpp *.cc *.c |C and C++ Source Files"

echo "Open multiple URLs:"
kdialog --multiple --getopenurl . "*.cpp *.cc *.c |C and C++ Source Files"

echo "Open multiple URLs, output on separate lines:"
kdialog --multiple --separate-output --getopenurl . "*.cpp *.cc *.c |C and C++ Source Files"
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!289 blocks

Places

File _service:obs_scm:kdialog-VERSIONgit.20180919T132129~f28a206bb.obscpio of Package kdialog (Revision 138bc37bd459d4bd51aecf52f0394482)

Places