--- /dev/null
+{
+ "phabricator.uri" : "https://phabricator.kde.org/"
+}
--- /dev/null
+cmake_minimum_required(VERSION 3.5)
+
+set(KF5_VERSION "5.54.0") # handled by release scripts
+project(KGuiAddons VERSION ${KF5_VERSION})
+
+include(FeatureSummary)
+find_package(ECM 5.54.0 NO_MODULE)
+set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
+feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
+
+
+set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
+
+include(KDEInstallDirs)
+include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
+include(KDECMakeSettings)
+set(REQUIRED_QT_VERSION 5.9.0)
+find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
+
+if (NOT APPLE AND NOT WIN32)
+ find_package(X11 MODULE)
+ find_package(XCB MODULE COMPONENTS XCB)
+endif()
+
+
+include(GenerateExportHeader)
+include(ECMSetupVersion)
+include(ECMGenerateHeaders)
+include(ECMAddQch)
+
+ecm_setup_version(PROJECT VARIABLE_PREFIX KGUIADDONS
+ VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/kguiaddons_version.h"
+ PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5GuiAddonsConfigVersion.cmake"
+ SOVERSION 5)
+
+option(BUILD_QCH "Build API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)" OFF)
+add_feature_info(QCH ${BUILD_QCH} "API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)")
+#add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x060000)
+
+add_subdirectory(src)
+if (BUILD_TESTING)
+ add_subdirectory(autotests)
+ add_subdirectory(tests)
+endif()
+
+# create a Config.cmake and a ConfigVersion.cmake file and install them
+set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5GuiAddons")
+
+if (BUILD_QCH)
+ ecm_install_qch_export(
+ TARGETS KF5GuiAddons_QCH
+ FILE KF5GuiAddonsQchTargets.cmake
+ DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
+ COMPONENT Devel
+ )
+ set(PACKAGE_INCLUDE_QCHTARGETS "include(\"\${CMAKE_CURRENT_LIST_DIR}/KF5GuiAddonsQchTargets.cmake\")")
+endif()
+
+include(CMakePackageConfigHelpers)
+
+configure_package_config_file("${CMAKE_CURRENT_SOURCE_DIR}/KF5GuiAddonsConfig.cmake.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/KF5GuiAddonsConfig.cmake"
+ INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR}
+ )
+
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/KF5GuiAddonsConfig.cmake"
+ "${CMAKE_CURRENT_BINARY_DIR}/KF5GuiAddonsConfigVersion.cmake"
+ DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
+ COMPONENT Devel )
+
+
+install(EXPORT KF5GuiAddonsTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
+ FILE KF5GuiAddonsTargets.cmake NAMESPACE KF5:: COMPONENT Devel)
+
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/kguiaddons_version.h
+ DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5} COMPONENT Devel )
+
+feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
--- /dev/null
+NOTE! 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.
+\f
+ 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.)
+\f
+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.
+\f
+ 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.
+\f
+ 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.
--- /dev/null
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations
+below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it
+becomes a de-facto standard. To achieve this, non-free programs must
+be allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control
+compilation and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+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 Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+\f
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at least
+ three years, to give the same user the materials specified in
+ Subsection 6a, above, for a charge no more than the cost of
+ performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+\f
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply, and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License
+may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+\f
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms
+of the ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library.
+It is safest to attach them to the start of each source file to most
+effectively convey the exclusion of warranty; and each file should
+have at least the "copyright" line and a pointer to where the full
+notice is found.
+
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or
+your school, if any, to sign a "copyright disclaimer" for the library,
+if necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James
+ Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+
--- /dev/null
+@PACKAGE_INIT@
+
+# Any changes in this file will be overwritten by CMake.
+
+include(CMakeFindDependencyMacro)
+find_dependency(Qt5Gui @REQUIRED_QT_VERSION@)
+
+
+include("${CMAKE_CURRENT_LIST_DIR}/KF5GuiAddonsTargets.cmake")
+@PACKAGE_INCLUDE_QCHTARGETS@
--- /dev/null
+# KDE GUI Addons
+
+Utilities for graphical user interfaces
+
+## Introduction
+
+The KDE GUI addons provide utilities for graphical user interfaces in the areas
+of colors, fonts, text, images, keyboard input.
+
--- /dev/null
+find_package(Qt5 ${REQUIRED_QT_VERSION} CONFIG REQUIRED Test)
+
+remove_definitions(-DQT_NO_CAST_FROM_ASCII)
+
+include(ECMAddTests)
+
+ecm_add_tests(
+ kwordwraptest.cpp
+ kcolorutilstest.cpp
+ kiconutilstest.cpp
+ LINK_LIBRARIES KF5::GuiAddons Qt5::Test
+)
--- /dev/null
+#include "kcolorutilstest.h"
+
+#include <QtTestGui>
+
+#include <kcolorutils.h>
+#include "../colors/kcolorspaces_p.h" // private header
+#include "../colors/kcolorspaces.cpp" // private implementation
+
+void tst_KColorUtils::testOverlay()
+{
+ QColor color1(10, 10, 100);
+ QColor color2(10, 10, 160);
+ QColor blended = KColorUtils::overlayColors(color1, color2);
+ QCOMPARE(blended, color2); // no transparency.
+
+ QColor previous;
+ // check that when altering the alpha of color2 to be less and less transparent this
+ // means we are moving more and more towards color2
+ for (int i = 10; i <= 255; i += 10) {
+ color2.setAlpha(i);
+ blended = KColorUtils::overlayColors(color1, color2);
+ if (previous.isValid()) {
+ QCOMPARE(previous.red(), 10);
+ QCOMPARE(previous.green(), 10);
+ QVERIFY(previous.blue() <= blended.blue());
+ }
+ previous = blended;
+ }
+
+ // only the alpha of color 2 alters the output
+ color2.setAlpha(255); //opaque
+ color1.setAlpha(80); //opaque
+ blended = KColorUtils::overlayColors(color2, color2);
+ QCOMPARE(blended.red(), color2.red());
+ QCOMPARE(blended.green(), color2.green());
+ QCOMPARE(blended.blue(), color2.blue());
+
+ // merge from itself to itself gives; TADA; itself again ;)
+ color2.setAlpha(127);
+ blended = KColorUtils::overlayColors(color2, color2);
+ QCOMPARE(blended.red(), color2.red());
+ QCOMPARE(blended.green(), color2.green());
+ QCOMPARE(blended.blue(), color2.blue());
+}
+
+#define compareColors(c1, c2) \
+ if ( c1 != c2 ) { \
+ fprintf( stderr, "%08x != expected value %08x\n", c1.rgb(), c2.rgb() ); \
+ QCOMPARE( c1, c2 ); \
+ } (void)0
+
+void tst_KColorUtils::testMix()
+{
+ int r, g, b, k;
+ for (r = 0; r < 52; r++) {
+ for (g = 0; g < 52; g++) {
+ for (b = 0; b < 52; b++) {
+ QColor color(r * 5, g * 5, b * 5);
+ // Test blend-to-black spectrum
+ for (k = 5; k >= 0; k--) {
+ QColor result = KColorUtils::mix(Qt::black, color, k * 0.2);
+ compareColors(result, QColor(r * k, g * k, b * k));
+ }
+ // Test blend-to-white spectrum
+ for (k = 5; k >= 0; k--) {
+ int n = 51 * (5 - k);
+ QColor result = KColorUtils::mix(Qt::white, color, k * 0.2);
+ compareColors(result, QColor(n + r * k, n + g * k, n + b * k));
+ }
+ // Test blend-to-self across a couple bias values
+ for (k = 5; k >= 0; k--) {
+ QColor result = KColorUtils::mix(color, color, k * 0.2);
+ compareColors(result, color);
+ }
+ }
+ }
+ }
+}
+
+void tst_KColorUtils::testHCY()
+{
+ int r, g, b;
+ for (r = 0; r < 256; r += 5) {
+ for (g = 0; g < 256; g += 5) {
+ for (b = 0; b < 256; b += 5) {
+ QColor color(r, g, b);
+ KColorSpaces::KHCY hcy(color);
+ compareColors(hcy.qColor(), color);
+ }
+ }
+ }
+}
+
+void tst_KColorUtils::testContrast()
+{
+ QCOMPARE(KColorUtils::contrastRatio(Qt::black, Qt::white), qreal(21.0));
+ QCOMPARE(KColorUtils::contrastRatio(Qt::white, Qt::black), qreal(21.0));
+ QCOMPARE(KColorUtils::contrastRatio(Qt::black, Qt::black), qreal(1.0));
+ QCOMPARE(KColorUtils::contrastRatio(Qt::white, Qt::white), qreal(1.0));
+
+ // TODO better tests :-)
+}
+
+void checkIsGray(const QColor &color, int line)
+{
+ KColorSpaces::KHCY hcy(color);
+ if (hcy.c != qreal(0.0)) {
+ fprintf(stderr, "%08x has chroma %g, expected gray!\n", color.rgb(), hcy.c);
+ }
+ QTest::qCompare(hcy.c, qreal(0.0), "hcy.c", "0.0", __FILE__, line);
+}
+
+void tst_KColorUtils::testShading()
+{
+ const QColor testGray(128, 128, 128); // Qt::gray isn't pure gray!
+
+ // Test that KHCY gets chroma correct for white/black, grays
+ checkIsGray(Qt::white, __LINE__);
+ checkIsGray(testGray, __LINE__);
+ checkIsGray(Qt::black, __LINE__);
+
+ // Test that lighten/darken/shade don't change chroma for grays
+ checkIsGray(KColorUtils::shade(Qt::white, -0.1), __LINE__);
+ checkIsGray(KColorUtils::shade(Qt::black, 0.1), __LINE__);
+ checkIsGray(KColorUtils::darken(Qt::white, 0.1), __LINE__);
+ checkIsGray(KColorUtils::darken(testGray, 0.1), __LINE__);
+ checkIsGray(KColorUtils::darken(testGray, -0.1), __LINE__);
+ checkIsGray(KColorUtils::darken(Qt::black, -0.1), __LINE__);
+ checkIsGray(KColorUtils::lighten(Qt::black, 0.1), __LINE__);
+ checkIsGray(KColorUtils::lighten(testGray, 0.1), __LINE__);
+ checkIsGray(KColorUtils::lighten(testGray, -0.1), __LINE__);
+ checkIsGray(KColorUtils::lighten(Qt::white, -0.1), __LINE__);
+}
+
+QTEST_MAIN(tst_KColorUtils)
--- /dev/null
+#ifndef KCOLORUTILSTEST_H
+#define KCOLORUTILSTEST_H
+
+#include <QObject>
+
+class tst_KColorUtils : public QObject
+{
+ Q_OBJECT
+private Q_SLOTS:
+ void testOverlay();
+ void testMix();
+ void testHCY();
+ void testContrast();
+ void testShading();
+};
+
+#endif // KCOLORUTILSTEST_H
--- /dev/null
+/*
+ Copyright (C) 2013 Martin Klapetek <mklapetek@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "kiconutilstest.h"
+#include <kiconutils.h>
+
+#include <QtTest>
+#include <QPixmap>
+#include <QPainter>
+#include <QIcon>
+
+QTEST_MAIN(KIconUtilsTest)
+
+void KIconUtilsTest::addOverlayTest()
+{
+ QPixmap rectanglePixmap(32, 32);
+ rectanglePixmap.fill(Qt::red);
+
+ QIcon icon(rectanglePixmap);
+
+ QPixmap overlay(32, 32);
+ overlay.fill(Qt::blue);
+
+ QIcon overlayIcon(overlay);
+
+ QIcon iconWithOverlay = KIconUtils::addOverlay(icon, overlayIcon, Qt::BottomRightCorner);
+ QImage result = iconWithOverlay.pixmap(32, 32).toImage();
+
+ int bluePixels = 0;
+ int redPixels = 0;
+
+ // Go over the image and count red and blue pixels
+ for (int y = 0; y < result.height(); ++y) {
+ for (int x = 0; x < result.width(); ++x) {
+ if (qRed(result.pixel(x, y)) == 255) {
+ redPixels++;
+ } else if (qBlue(result.pixel(x, y)) == 255) {
+ bluePixels++;
+ }
+ }
+ }
+
+ // For icon of size 32x32, the overlay should be 16x16 (=256)
+ QCOMPARE(bluePixels, 256);
+ QCOMPARE(redPixels, 768);
+
+ // Try different size and position
+ rectanglePixmap = rectanglePixmap.scaled(96, 96);
+
+ icon = QIcon(rectanglePixmap);
+
+ overlay = overlay.scaled(96, 96);
+
+ overlayIcon = QIcon(overlay);
+
+ iconWithOverlay = KIconUtils::addOverlay(icon, overlayIcon, Qt::BottomRightCorner);
+
+ // Test if unsetting the overlay works;
+ // the result should have just one blue square
+ iconWithOverlay = KIconUtils::addOverlay(icon, QIcon(), Qt::BottomRightCorner);
+
+ iconWithOverlay = KIconUtils::addOverlay(icon, overlayIcon, Qt::TopLeftCorner);
+ result = iconWithOverlay.pixmap(96, 96).toImage();
+
+ bluePixels = 0;
+ redPixels = 0;
+
+ for (int y = 0; y < result.height(); ++y) {
+ for (int x = 0; x < result.width(); ++x) {
+ if (qRed(result.pixel(x, y)) == 255) {
+ redPixels++;
+ } else if (qBlue(result.pixel(x, y)) == 255) {
+ bluePixels++;
+ }
+ }
+ }
+
+ // 96x96 big icon will have 32x32 big overlay (=1024 blue pixels)
+ QCOMPARE(bluePixels, 1024);
+ QCOMPARE(redPixels, 8192);
+
+ // Try paint method
+ icon = QIcon(rectanglePixmap);
+ iconWithOverlay = KIconUtils::addOverlay(icon, overlayIcon, Qt::TopLeftCorner);
+
+ QPixmap a(96, 96);
+ QPainter p(&a);
+ iconWithOverlay.paint(&p, a.rect(), Qt::AlignCenter, QIcon::Normal, QIcon::Off);
+
+ result = a.toImage();
+
+ bluePixels = 0;
+ redPixels = 0;
+
+ for (int y = 0; y < result.height(); ++y) {
+ for (int x = 0; x < result.width(); ++x) {
+ if (qRed(result.pixel(x, y)) == 255) {
+ redPixels++;
+ } else if (qBlue(result.pixel(x, y)) == 255) {
+ bluePixels++;
+ }
+ }
+ }
+
+ // 96x96 big icon will have 32x32 big overlay (=1024 blue pixels)
+ QCOMPARE(bluePixels, 1024);
+ QCOMPARE(redPixels, 8192);
+}
+
+void KIconUtilsTest::addOverlaysTest()
+{
+ QPixmap rectanglePixmap(32, 32);
+ rectanglePixmap.fill(Qt::red);
+
+ QIcon icon(rectanglePixmap);
+
+ QPixmap overlay(32, 32);
+ overlay.fill(Qt::blue);
+
+ QIcon overlayIcon(overlay);
+
+ QHash<Qt::Corner, QIcon> overlays;
+ overlays.insert(Qt::BottomRightCorner, overlayIcon);
+ overlays.insert(Qt::TopLeftCorner, overlayIcon);
+
+ QIcon iconWithOverlay = KIconUtils::addOverlays(icon, overlays);
+ QImage result = iconWithOverlay.pixmap(32, 32).toImage();
+
+ int bluePixels = 0;
+ int redPixels = 0;
+
+ // Go over the image and count red and blue pixels
+ for (int y = 0; y < result.height(); ++y) {
+ for (int x = 0; x < result.width(); ++x) {
+ if (qRed(result.pixel(x, y)) == 255) {
+ redPixels++;
+ } else if (qBlue(result.pixel(x, y)) == 255) {
+ bluePixels++;
+ }
+ }
+ }
+
+ // Two blue overlays in icon size 32x32 would intersect with 16 pixels,
+ // so the amount of blue pixels should be 2x256-16 = 496
+ QCOMPARE(bluePixels, 496);
+ QCOMPARE(redPixels, 528);
+
+ // Try different size
+
+ rectanglePixmap = rectanglePixmap.scaled(96, 96);
+ icon = QIcon(rectanglePixmap);
+ overlay = overlay.scaled(96, 96);
+ overlayIcon = QIcon(overlay);
+
+ // Clear the old sizes first
+ overlays.clear();
+ overlays.insert(Qt::BottomRightCorner, overlayIcon);
+ overlays.insert(Qt::TopRightCorner, overlayIcon);
+ overlays.insert(Qt::TopLeftCorner, overlayIcon);
+
+ // Now it will have 3 overlays
+ iconWithOverlay = KIconUtils::addOverlays(icon, overlays);
+
+ QPixmap a(96, 96);
+ QPainter p(&a);
+ iconWithOverlay.paint(&p, a.rect(), Qt::AlignCenter, QIcon::Normal, QIcon::Off);
+
+ result = a.toImage();
+
+ bluePixels = 0;
+ redPixels = 0;
+
+ for (int y = 0; y < result.height(); ++y) {
+ for (int x = 0; x < result.width(); ++x) {
+ if (qRed(result.pixel(x, y)) == 255) {
+ redPixels++;
+ } else if (qBlue(result.pixel(x, y)) == 255) {
+ bluePixels++;
+ }
+ }
+ }
+
+ // 96x96 big icon will have 32x32 big overlays (=3072 blue pixels)
+ QCOMPARE(bluePixels, 3072);
+ QCOMPARE(redPixels, 6144);
+}
+
--- /dev/null
+/*
+ Copyright (C) 2013 Martin Klapetek <mklapetek@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICONUTILSTEST_H
+#define KICONUTILSTEST_H
+
+#include <QObject>
+
+class KIconUtilsTest : public QObject
+{
+ Q_OBJECT
+private Q_SLOTS:
+ void addOverlayTest();
+ void addOverlaysTest();
+};
+
+#endif // KICONUTILSTEST_H
--- /dev/null
+/*
+ * Copyright 2003, 2008 David Faure <faure@kde.org>
+ *
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QFontMetrics>
+
+#include <QtTestGui>
+
+#include <QObject>
+#include "kwordwrap.h"
+
+class KWordWrap_UnitTest : public QObject
+{
+ Q_OBJECT
+
+private Q_SLOTS:
+ void initTestCase()
+ {
+ // Qt5 TODO: how to set the dpi?
+ // Only found readonly QScreen::logicalDotsPerInch...
+#if 0
+ QX11Info::setAppDpiX(0, 96);
+ QX11Info::setAppDpiY(0, 96);
+#endif
+ }
+
+ void oldTruncationTest()
+ {
+ QFont font(QStringLiteral("helvetica"), 12); // let's hope we all have the same...
+ QFontMetrics fm(font);
+ QRect r(0, 0, 100, -1);
+ QString str = QStringLiteral("test wadabada [/foo/bar/waba] and some more text here");
+ KWordWrap ww = KWordWrap::formatText(fm, r, 0, str);
+ //qDebug() << str << " => " << ww.truncatedString();
+ QVERIFY(ww.truncatedString().endsWith("..."));
+
+ str = QStringLiteral("</p></p></p></p>");
+ for (; r.width() > 0; r.setWidth(r.width() - 10)) {
+ ww = KWordWrap::formatText(fm, r, 0, str);
+ //qDebug() << str << " => " << ww.truncatedString();
+ QVERIFY(ww.truncatedString().endsWith("..."));
+ }
+ }
+
+ void testWithExistingNewlines() // when the input string has \n already
+ {
+ QRect r(0, 0, 1000, -1); // very wide
+ QFont font(QStringLiteral("helvetica"), 12); // let's hope we all have the same...
+ QFontMetrics fm(font);
+ QString inputString = QStringLiteral("The title here\nFoo (bar)\nFoo2 (bar2)");
+ KWordWrap ww = KWordWrap::formatText(fm, r, 0, inputString);
+ QString str = ww.wrappedString();
+ QCOMPARE(str, inputString);
+ }
+};
+
+QTEST_MAIN(KWordWrap_UnitTest)
+
+#include "kwordwraptest.moc"
--- /dev/null
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+
+import sys
+
+sys.path.append(sys.argv[1])
+
+from PyQt5 import QtCore
+from PyQt5 import QtGui
+
+from PyKF5 import KGuiAddons
+
+def main():
+ app = QtGui.QGuiApplication(sys.argv)
+
+ colorCollection = KGuiAddons.KColorCollection()
+
+ colorCollection.addColor(QtCore.Qt.blue)
+ colorCollection.addColor(QtCore.Qt.red)
+
+ assert(colorCollection.count() == 2)
+
+ painter = QtGui.QPainter()
+ p = QtCore.QSizeF()
+ foo = KGuiAddons.KFontUtils.adaptFontSize(painter, "foo", p)
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+maintainer:
+description: Addons to QtGui
+tier: 1
+type: functional
+platforms:
+ - name: Linux
+ - name: FreeBSD
+ - name: Windows
+ - name: MacOSX
+ - name: Android
+portingAid: false
+deprecated: false
+release: true
+libraries:
+ - qmake: KGuiAddons
+ cmake: "KF5::GuiAddons"
+cmakename: KF5GuiAddons
+
+public_lib: true
+group: Frameworks
+subgroup: Tier 1
--- /dev/null
+
+set(kguiaddons_LIB_SRCS
+ colors/kcolorspaces.cpp
+ colors/kcolorutils.cpp
+ colors/kcolorcollection.cpp
+ colors/kcolormimedata.cpp
+ text/kdatevalidator.cpp
+ text/kwordwrap.cpp
+ fonts/kfontutils.cpp
+ util/kiconutils.cpp
+ util/klocalimagecacheimpl.cpp
+ util/kmodifierkeyinfo.cpp
+ util/kmodifierkeyinfoprovider.cpp
+ util/urlhandler.cpp
+)
+
+set (kmodifierkeyinfoprovider_impl "dummy")
+if (NOT APPLE AND X11_FOUND AND X11_Xkb_FOUND AND XCB_XCB_FOUND)
+ find_package(Qt5X11Extras ${REQUIRED_QT_VERSION} NO_MODULE)
+ if (Qt5X11Extras_FOUND)
+ include_directories (
+ ${X11_Xkb_INCLUDE_PATH}
+ ${X11_Xlib_INCLUDE_PATH}
+ ${XCB_XCB_INCLUDE_DIR}
+ )
+ set (kmodifierkeyinfoprovider_impl "x11")
+ endif()
+endif ()
+
+set (kguiaddons_LIB_SRCS ${kguiaddons_LIB_SRCS} util/kmodifierkeyinfoprovider_${kmodifierkeyinfoprovider_impl}.cpp)
+
+add_library(KF5GuiAddons ${kguiaddons_LIB_SRCS})
+
+generate_export_header(KF5GuiAddons BASE_NAME KGuiAddons)
+add_library(KF5::GuiAddons ALIAS KF5GuiAddons)
+
+set(kguiaddons_INCLUDES
+ ${CMAKE_CURRENT_SOURCE_DIR}/colors
+ ${CMAKE_CURRENT_SOURCE_DIR}/fonts
+ ${CMAKE_CURRENT_SOURCE_DIR}/text
+ ${CMAKE_CURRENT_SOURCE_DIR}/util
+ )
+target_include_directories(KF5GuiAddons PUBLIC "$<BUILD_INTERFACE:${kguiaddons_INCLUDES}>")
+target_include_directories(KF5GuiAddons INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/KGuiAddons>" )
+target_compile_definitions(KF5GuiAddons INTERFACE "$<INSTALL_INTERFACE:KGUIADDONS_LIB>")
+target_link_libraries(KF5GuiAddons PUBLIC Qt5::Gui)
+
+if (kmodifierkeyinfoprovider_impl STREQUAL "x11")
+ target_link_libraries(KF5GuiAddons LINK_PRIVATE ${X11_LIBRARIES} ${XCB_XCB_LIBRARY} Qt5::X11Extras)
+endif()
+
+set_target_properties(KF5GuiAddons PROPERTIES VERSION ${KGUIADDONS_VERSION_STRING}
+ SOVERSION ${KGUIADDONS_SOVERSION}
+ EXPORT_NAME GuiAddons
+)
+
+ecm_generate_headers(KGuiAddons_HEADERS
+ HEADER_NAMES
+ KColorUtils
+ KColorCollection
+ KColorMimeData
+
+ RELATIVE colors
+ REQUIRED_HEADERS KGuiAddons_HEADERS
+)
+ecm_generate_headers(KGuiAddons_HEADERS
+ HEADER_NAMES
+ KDateValidator
+ KWordWrap
+
+ RELATIVE text
+ REQUIRED_HEADERS KGuiAddons_HEADERS
+)
+ecm_generate_headers(KGuiAddons_HEADERS
+ HEADER_NAMES
+ KFontUtils
+
+ RELATIVE fonts
+ REQUIRED_HEADERS KGuiAddons_HEADERS
+)
+ecm_generate_headers(KGuiAddons_HEADERS
+ HEADER_NAMES
+ KIconUtils
+ KImageCache
+ KModifierKeyInfo
+
+ RELATIVE util
+ REQUIRED_HEADERS KGuiAddons_HEADERS
+)
+
+find_package(PythonModuleGeneration)
+
+if (PythonModuleGeneration_FOUND)
+ ecm_generate_python_binding(
+ TARGET KF5::GuiAddons
+ PYTHONNAMESPACE PyKF5
+ MODULENAME KGuiAddons
+ SIP_DEPENDS
+ QtGui/QtGuimod.sip
+ HEADERS
+ colors/kcolorutils.h
+ colors/kcolorcollection.h
+ colors/kcolormimedata.h
+ text/kdatevalidator.h
+ text/kwordwrap.h
+ fonts/kfontutils.h
+ util/kiconutils.h
+ util/kimagecache.h
+ util/kmodifierkeyinfo.h
+ )
+endif()
+
+install(TARGETS KF5GuiAddons EXPORT KF5GuiAddonsTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})
+install(FILES
+ ${CMAKE_CURRENT_BINARY_DIR}/kguiaddons_export.h
+ util/klocalimagecacheimpl.h # implementation detail, no forwarding header
+ ${KGuiAddons_HEADERS}
+ DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/KGuiAddons COMPONENT Devel
+)
+
+if(BUILD_QCH)
+ ecm_add_qch(
+ KF5GuiAddons_QCH
+ NAME KGuiAddons
+ BASE_NAME KF5GuiAddons
+ VERSION ${KF5_VERSION}
+ ORG_DOMAIN org.kde
+ SOURCES # using only public headers, to cover only public API
+ ${KGuiAddons_HEADERS}
+ MD_MAINPAGE "${CMAKE_SOURCE_DIR}/README.md"
+ LINK_QCHS
+ Qt5Gui_QCH
+ BLANK_MACROS
+ KGUIADDONS_EXPORT
+ TAGFILE_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
+ QCH_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
+ COMPONENT Devel
+ )
+endif()
+
+include(ECMGeneratePriFile)
+ecm_generate_pri_file(BASE_NAME KGuiAddons LIB_NAME KF5GuiAddons DEPS "gui" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/KGuiAddons)
+install(FILES ${PRI_FILENAME} DESTINATION ${ECM_MKSPECS_INSTALL_DIR})
--- /dev/null
+/* This file is part of the KDE libraries
+ Copyright (C) 1999 Waldo Bastian (bastian@kde.org)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+//-----------------------------------------------------------------------------
+// KDE color collection
+
+#include "kcolorcollection.h"
+
+#include <QFile>
+#include <QDir>
+#include <QTextStream>
+#include <qsavefile.h>
+#include <qstandardpaths.h>
+
+//BEGIN KColorCollectionPrivate
+class KColorCollectionPrivate
+{
+public:
+ KColorCollectionPrivate(const QString &);
+ KColorCollectionPrivate(const KColorCollectionPrivate &);
+ ~KColorCollectionPrivate() {}
+ struct ColorNode {
+ ColorNode(const QColor &c, const QString &n)
+ : color(c), name(n) {}
+ QColor color;
+ QString name;
+ };
+ QList<ColorNode> colorList;
+
+ QString name;
+ QString desc;
+ KColorCollection::Editable editable;
+};
+
+KColorCollectionPrivate::KColorCollectionPrivate(const QString &_name)
+ : name(_name)
+{
+ if (name.isEmpty()) {
+ return;
+ }
+
+ QString filename = QStandardPaths::locate(QStandardPaths::GenericConfigLocation, QLatin1String("colors/") + name);
+ if (filename.isEmpty()) {
+ return;
+ }
+
+ QFile paletteFile(filename);
+ if (!paletteFile.exists()) {
+ return;
+ }
+ if (!paletteFile.open(QIODevice::ReadOnly)) {
+ return;
+ }
+
+ // Read first line
+ // Expected "GIMP Palette"
+ QString line = QString::fromLocal8Bit(paletteFile.readLine());
+ if (line.contains(QLatin1String(" Palette"))) {
+ return;
+ }
+
+ while (!paletteFile.atEnd()) {
+ line = QString::fromLocal8Bit(paletteFile.readLine());
+ if (line[0] == QLatin1Char('#')) {
+ // This is a comment line
+ line = line.mid(1); // Strip '#'
+ line = line.trimmed(); // Strip remaining white space..
+ if (!line.isEmpty()) {
+ desc += line + QLatin1Char('\n'); // Add comment to description
+ }
+ } else {
+ // This is a color line, hopefully
+ line = line.trimmed();
+ if (line.isEmpty()) {
+ continue;
+ }
+ int r, g, b;
+ int pos = 0;
+ if (sscanf(line.toLatin1().constData(), "%d %d %d%n", &r, &g, &b, &pos) >= 3) {
+ r = qBound(0, r, 255);
+ g = qBound(0, g, 255);
+ b = qBound(0, b, 255);
+ QString name = line.mid(pos).trimmed();
+ colorList.append(ColorNode(QColor(r, g, b), name));
+ }
+ }
+ }
+}
+
+KColorCollectionPrivate::KColorCollectionPrivate(const KColorCollectionPrivate &p)
+ : colorList(p.colorList), name(p.name), desc(p.desc), editable(p.editable)
+{
+}
+//END KColorCollectionPrivate
+
+QStringList KColorCollection::installedCollections()
+{
+ const QStringList paletteDirs = QStandardPaths::locateAll(QStandardPaths::GenericConfigLocation,
+ QStringLiteral("colors"),
+ QStandardPaths::LocateDirectory);
+
+ QStringList paletteList;
+ for (const QString &dir : paletteDirs) {
+ paletteList += QDir(dir).entryList(QDir::Files | QDir::NoDotAndDotDot);
+ }
+ paletteList.removeDuplicates();
+
+ return paletteList;
+}
+
+KColorCollection::KColorCollection(const QString &name)
+{
+ d = new KColorCollectionPrivate(name);
+}
+
+KColorCollection::KColorCollection(const KColorCollection &p)
+{
+ d = new KColorCollectionPrivate(*p.d);
+}
+
+KColorCollection::~KColorCollection()
+{
+ // Need auto-save?
+ delete d;
+}
+
+bool
+KColorCollection::save()
+{
+ QString filename = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + QLatin1String("/colors/")
+ + d->name;
+ QSaveFile sf(filename);
+ if (!sf.open(QIODevice::WriteOnly)) {
+ return false;
+ }
+
+ QTextStream str(&sf);
+
+ QString description = d->desc.trimmed();
+ description = QLatin1Char('#') + description.split(QLatin1Char('\n'), QString::KeepEmptyParts).join(QStringLiteral("\n#"));
+
+ str << QLatin1String("KDE RGB Palette\n");
+ str << description << QLatin1Char('\n');
+ foreach (const KColorCollectionPrivate::ColorNode &node, d->colorList) {
+ int r, g, b;
+ node.color.getRgb(&r, &g, &b);
+ str << r << " " << g << " " << b << " " << node.name << "\n";
+ }
+
+ return sf.commit();
+}
+
+QString KColorCollection::description() const
+{
+ return d->desc;
+}
+
+void KColorCollection::setDescription(const QString &desc)
+{
+ d->desc = desc;
+}
+
+QString KColorCollection::name() const
+{
+ return d->name;
+}
+
+void KColorCollection::setName(const QString &name)
+{
+ d->name = name;
+}
+
+KColorCollection::Editable KColorCollection::editable() const
+{
+ return d->editable;
+}
+
+void KColorCollection::setEditable(Editable editable)
+{
+ d->editable = editable;
+}
+
+int KColorCollection::count() const
+{
+ return d->colorList.count();
+}
+
+KColorCollection &
+KColorCollection::operator=(const KColorCollection &p)
+{
+ if (&p == this) {
+ return *this;
+ }
+ d->colorList = p.d->colorList;
+ d->name = p.d->name;
+ d->desc = p.d->desc;
+ d->editable = p.d->editable;
+ return *this;
+}
+
+QColor
+KColorCollection::color(int index) const
+{
+ if ((index < 0) || (index >= count())) {
+ return QColor();
+ }
+
+ return d->colorList[index].color;
+}
+
+int
+KColorCollection::findColor(const QColor &color) const
+{
+ for (int i = 0; i < d->colorList.size(); ++i) {
+ if (d->colorList[i].color == color) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+QString
+KColorCollection::name(int index) const
+{
+ if ((index < 0) || (index >= count())) {
+ return QString();
+ }
+
+ return d->colorList[index].name;
+}
+
+QString KColorCollection::name(const QColor &color) const
+{
+ return name(findColor(color));
+}
+
+int
+KColorCollection::addColor(const QColor &newColor, const QString &newColorName)
+{
+ d->colorList.append(KColorCollectionPrivate::ColorNode(newColor, newColorName));
+ return count() - 1;
+}
+
+int
+KColorCollection::changeColor(int index,
+ const QColor &newColor,
+ const QString &newColorName)
+{
+ if ((index < 0) || (index >= count())) {
+ return -1;
+ }
+
+ KColorCollectionPrivate::ColorNode &node = d->colorList[index];
+ node.color = newColor;
+ node.name = newColorName;
+
+ return index;
+}
+
+int KColorCollection::changeColor(const QColor &oldColor,
+ const QColor &newColor,
+ const QString &newColorName)
+{
+ return changeColor(findColor(oldColor), newColor, newColorName);
+}
+
--- /dev/null
+/* This file is part of the KDE libraries
+ Copyright (C) 1999 Waldo Bastian (bastian@kde.org)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; version
+ 2 of the License.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+//-----------------------------------------------------------------------------
+// KDE color collection.
+
+#ifndef KDELIBS_KCOLORCOLLECTION_H
+#define KDELIBS_KCOLORCOLLECTION_H
+
+#include <kguiaddons_export.h>
+
+#include <QColor>
+#include <QList>
+#include <QString>
+#include <QStringList>
+
+/**
+ * @class KColorCollection kcolorcollection.h KColorCollection
+ *
+ * Class for handling color collections ("palettes").
+ *
+ * This class makes it easy to handle color collections, sometimes referred to
+ * as "palettes". This class can read and write collections from and to a file.
+ *
+ * This class uses the "GIMP" palette file format.
+ *
+ * @author Waldo Bastian (bastian@kde.org)
+ **/
+class KGUIADDONS_EXPORT KColorCollection
+{
+public:
+ /**
+ * Query which KDE color collections are installed.
+ *
+ * @return A list with installed color collection names.
+ */
+ static QStringList installedCollections();
+
+ /**
+ * KColorCollection constructor. Creates a KColorCollection from a file
+ * the filename is derived from the name.
+ * @param name The name of collection as returned by installedCollections()
+ **/
+ explicit KColorCollection(const QString &name = QString());
+
+ /**
+ * KColorCollection copy constructor.
+ **/
+ KColorCollection(const KColorCollection &);
+
+ /**
+ * KColorCollection destructor.
+ **/
+ ~KColorCollection();
+
+ /**
+ * KColorCollection assignment operator
+ **/
+ KColorCollection &operator=(const KColorCollection &);
+
+ /**
+ * Save the collection
+ *
+ * @return 'true' if successful
+ **/
+ bool save();
+
+ /**
+ * Get the description of the collection.
+ * @return the description of the collection.
+ **/
+ QString description() const;
+
+ /**
+ * Set the description of the collection.
+ * @param desc the new description
+ **/
+ void setDescription(const QString &desc);
+
+ /**
+ * Get the name of the collection.
+ * @return the name of the collection
+ **/
+ QString name() const;
+
+ /**
+ * Set the name of the collection.
+ * @param name the name of the collection
+ **/
+ void setName(const QString &name);
+
+ /**
+ * Used to specify whether a collection may be edited.
+ * @see editable()
+ * @see setEditable()
+ */
+ enum Editable { Yes, ///< Collection may be edited
+ No, ///< Collection may not be edited
+ Ask ///< Ask user before editing
+ };
+
+ /**
+ * Returns whether the collection may be edited.
+ * @return the state of the collection
+ **/
+ Editable editable() const;
+
+ /**
+ * Change whether the collection may be edited.
+ * @param editable the state of the collection
+ **/
+ void setEditable(Editable editable);
+
+ /**
+ * Return the number of colors in the collection.
+ * @return the number of colors
+ **/
+ int count() const;
+
+ /**
+ * Find color by index.
+ * @param index the index of the desired color
+ * @return The @p index -th color of the collection, null if not found.
+ **/
+ QColor color(int index) const;
+
+ /**
+ * Find index by @p color.
+ * @param color the color to find
+ * @return The index of the color in the collection or -1 if the
+ * color is not found.
+ **/
+ int findColor(const QColor &color) const;
+
+ /**
+ * Find color name by @p index.
+ * @param index the index of the color
+ * @return The name of the @p index -th color.
+ * Note that not all collections have named the colors. Null is
+ * returned if the color does not exist or has no name.
+ **/
+ QString name(int index) const;
+
+ /**
+ * Find color name by @p color.
+ * @return The name of color according to this collection.
+ * Note that not all collections have named the colors.
+ * Note also that each collection can give the same color
+ * a different name.
+ **/
+ QString name(const QColor &color) const;
+
+ /**
+ * Add a color.
+ * @param newColor The color to add.
+ * @param newColorName The name of the color, null to remove
+ * the name.
+ * @return The index of the added color.
+ **/
+ int addColor(const QColor &newColor,
+ const QString &newColorName = QString());
+
+ /**
+ * Change a color.
+ * @param index Index of the color to change
+ * @param newColor The new color.
+ * @param newColorName The new color name, null to remove
+ * the name.
+ * @return The index of the new color or -1 if the color couldn't
+ * be changed.
+ **/
+ int changeColor(int index,
+ const QColor &newColor,
+ const QString &newColorName = QString());
+
+ /**
+ * Change a color.
+ * @param oldColor The original color
+ * @param newColor The new color.
+ * @param newColorName The new color name, null to remove
+ * the name.
+ * @return The index of the new color or -1 if the color couldn't
+ * be changed.
+ **/
+ int changeColor(const QColor &oldColor,
+ const QColor &newColor,
+ const QString &newColorName = QString());
+
+private:
+ class KColorCollectionPrivate *d;
+};
+
+#endif // KDELIBS_KCOLORCOLLECTION_H
+
--- /dev/null
+/* This file is part of the KDE libraries
+ Copyright (C) 1999 Steffen Hansen (hansen@kde.org)
+ Copyright (C) 2005 Joseph Wenninger (jowenn@kde.org)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kcolormimedata.h"
+
+#include <QColor>
+#include <QDrag>
+#include <QMimeData>
+#include <QPainter>
+
+void
+KColorMimeData::populateMimeData(QMimeData *mimeData, const QColor &color)
+{
+ mimeData->setColorData(color);
+ mimeData->setText(color.name());
+}
+
+bool
+KColorMimeData::canDecode(const QMimeData *mimeData)
+{
+ if (mimeData->hasColor()) {
+ return true;
+ }
+ if (mimeData->hasText()) {
+ const QString colorName = mimeData->text();
+ if ((colorName.length() >= 4) && (colorName[0] == QLatin1Char('#'))) {
+ return true;
+ }
+ }
+ return false;
+}
+
+QColor
+KColorMimeData::fromMimeData(const QMimeData *mimeData)
+{
+ if (mimeData->hasColor()) {
+ return mimeData->colorData().value<QColor>();
+ }
+ if (canDecode(mimeData)) {
+ return QColor(mimeData->text());
+ }
+ return QColor();
+}
+
+QDrag *
+KColorMimeData::createDrag(const QColor &color, QObject *dragsource)
+{
+ QDrag *drag = new QDrag(dragsource);
+ QMimeData *mime = new QMimeData;
+ populateMimeData(mime, color);
+ drag->setMimeData(mime);
+ QPixmap colorpix(25, 20);
+ colorpix.fill(color);
+ QPainter p(&colorpix);
+ p.setPen(Qt::black);
+ p.drawRect(0, 0, 24, 19);
+ p.end();
+ drag->setPixmap(colorpix);
+ drag->setHotSpot(QPoint(-5, -7));
+ return drag;
+}
--- /dev/null
+/* This file is part of the KDE libraries
+ Copyright (C) 1999 Steffen Hansen (hansen@kde.org)
+ Copyright (C) 2005 Joseph Wenninger (jowenn@kde.org)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#ifndef _KCOLORMIMEDATA_H
+#define _KCOLORMIMEDATA_H
+
+#include <kguiaddons_export.h>
+
+class QColor;
+class QDrag;
+class QMimeData;
+class QObject;
+
+/**
+ * Drag-and-drop and clipboard mimedata manipulation for QColor objects. The according MIME type
+ * is set to application/x-color.
+ *
+ * See the Qt drag'n'drop documentation.
+ */
+namespace KColorMimeData
+{
+/**
+ * Sets the color and text representation fields for the specified color in the mimedata object:
+ * application/x-color and text/plain types are set
+ */
+KGUIADDONS_EXPORT void populateMimeData(QMimeData *mimeData, const QColor &color);
+
+/**
+ * Returns true if the MIME data @p mimeData contains a color object.
+ * First checks for application/x-color and if that fails, for a text/plain entry, which
+ * represents a color in the format \#hexnumbers
+ */
+KGUIADDONS_EXPORT bool canDecode(const QMimeData *mimeData);
+
+/**
+ * Decodes the MIME data @p mimeData and returns the resulting color.
+ * First tries application/x-color and if that fails, a text/plain entry, which
+ * represents a color in the format \#hexnumbers. If this fails too,
+ * an invalid QColor object is returned, use QColor::isValid() to test it.
+ */
+KGUIADDONS_EXPORT QColor fromMimeData(const QMimeData *mimeData);
+
+/**
+ * Creates a color drag object. Either you have to start this drag or delete it
+ * The drag object's mime data has the application/x-color and text/plain type set and a pixmap
+ * filled with the specified color, which is going to be displayed next to the mouse cursor
+ */
+KGUIADDONS_EXPORT QDrag *createDrag(const QColor &color, QObject *dragsource);
+}
+
+#endif // _KCOLORMIMEDATA_H
--- /dev/null
+/* This file is part of the KDE project
+ * Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
+ * Copyright (C) 2007 Olaf Schmidt <ojschmidt@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+#include "kcolorspaces_p.h"
+#include "kguiaddons_colorhelpers_p.h"
+
+#include <QColor>
+
+#include <math.h>
+
+using namespace KColorSpaces;
+
+static inline qreal wrap(qreal a, qreal d = 1.0)
+{
+ qreal r = fmod(a, d);
+ return (r < 0.0 ? d + r : (r > 0.0 ? r : 0.0));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// HCY color space
+
+#define HCY_REC 709 // use 709 for now
+#if HCY_REC == 601
+static const qreal yc[3] = { 0.299, 0.587, 0.114 };
+#elif HCY_REC == 709
+static const qreal yc[3] = {0.2126, 0.7152, 0.0722};
+#else // use Qt values
+static const qreal yc[3] = { 0.34375, 0.5, 0.15625 };
+#endif
+
+qreal KHCY::gamma(qreal n)
+{
+ return pow(normalize(n), 2.2);
+}
+
+qreal KHCY::igamma(qreal n)
+{
+ return pow(normalize(n), 1.0 / 2.2);
+}
+
+qreal KHCY::lumag(qreal r, qreal g, qreal b)
+{
+ return r * yc[0] + g * yc[1] + b * yc[2];
+}
+
+KHCY::KHCY(qreal h_, qreal c_, qreal y_, qreal a_)
+{
+ h = h_;
+ c = c_;
+ y = y_;
+ a = a_;
+}
+
+KHCY::KHCY(const QColor &color)
+{
+ qreal r = gamma(color.redF());
+ qreal g = gamma(color.greenF());
+ qreal b = gamma(color.blueF());
+ a = color.alphaF();
+
+ // luma component
+ y = lumag(r, g, b);
+
+ // hue component
+ qreal p = qMax(qMax(r, g), b);
+ qreal n = qMin(qMin(r, g), b);
+ qreal d = 6.0 * (p - n);
+ if (n == p) {
+ h = 0.0;
+ } else if (r == p) {
+ h = ((g - b) / d);
+ } else if (g == p) {
+ h = ((b - r) / d) + (1.0 / 3.0);
+ } else {
+ h = ((r - g) / d) + (2.0 / 3.0);
+ }
+
+ // chroma component
+ if (r == g && g == b) {
+ c = 0.0;
+ } else {
+ c = qMax((y - n) / y, (p - y) / (1 - y));
+ }
+}
+
+QColor KHCY::qColor() const
+{
+ // start with sane component values
+ qreal _h = wrap(h);
+ qreal _c = normalize(c);
+ qreal _y = normalize(y);
+
+ // calculate some needed variables
+ qreal _hs = _h * 6.0, th, tm;
+ if (_hs < 1.0) {
+ th = _hs;
+ tm = yc[0] + yc[1] * th;
+ } else if (_hs < 2.0) {
+ th = 2.0 - _hs;
+ tm = yc[1] + yc[0] * th;
+ } else if (_hs < 3.0) {
+ th = _hs - 2.0;
+ tm = yc[1] + yc[2] * th;
+ } else if (_hs < 4.0) {
+ th = 4.0 - _hs;
+ tm = yc[2] + yc[1] * th;
+ } else if (_hs < 5.0) {
+ th = _hs - 4.0;
+ tm = yc[2] + yc[0] * th;
+ } else {
+ th = 6.0 - _hs;
+ tm = yc[0] + yc[2] * th;
+ }
+
+ // calculate RGB channels in sorted order
+ qreal tn, to, tp;
+ if (tm >= _y) {
+ tp = _y + _y * _c * (1.0 - tm) / tm;
+ to = _y + _y * _c * (th - tm) / tm;
+ tn = _y - (_y * _c);
+ } else {
+ tp = _y + (1.0 - _y) * _c;
+ to = _y + (1.0 - _y) * _c * (th - tm) / (1.0 - tm);
+ tn = _y - (1.0 - _y) * _c * tm / (1.0 - tm);
+ }
+
+ // return RGB channels in appropriate order
+ if (_hs < 1.0) {
+ return QColor::fromRgbF(igamma(tp), igamma(to), igamma(tn), a);
+ } else if (_hs < 2.0) {
+ return QColor::fromRgbF(igamma(to), igamma(tp), igamma(tn), a);
+ } else if (_hs < 3.0) {
+ return QColor::fromRgbF(igamma(tn), igamma(tp), igamma(to), a);
+ } else if (_hs < 4.0) {
+ return QColor::fromRgbF(igamma(tn), igamma(to), igamma(tp), a);
+ } else if (_hs < 5.0) {
+ return QColor::fromRgbF(igamma(to), igamma(tn), igamma(tp), a);
+ } else {
+ return QColor::fromRgbF(igamma(tp), igamma(tn), igamma(to), a);
+ }
+}
+
+qreal KHCY::luma(const QColor &color)
+{
+ return lumag(gamma(color.redF()),
+ gamma(color.greenF()),
+ gamma(color.blueF()));
+}
+
--- /dev/null
+/* This file is part of the KDE project
+ * Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+/*
+ * If you use KColorSpaces in your own KDE code, please drop me a line at
+ * mw_triad@users.sourceforge.net, as I would like to track if people find it
+ * useful. Thanks!
+ */
+
+#ifndef KCOLORSPACES_H
+#define KCOLORSPACES_H
+
+#include <QColor>
+
+namespace KColorSpaces
+{
+
+class KHCY
+{
+public:
+ explicit KHCY(const QColor &);
+ explicit KHCY(qreal h_, qreal c_, qreal y_, qreal a_ = 1.0);
+ QColor qColor() const;
+ qreal h, c, y, a;
+ static qreal luma(const QColor &);
+private:
+ static qreal gamma(qreal);
+ static qreal igamma(qreal);
+ static qreal lumag(qreal, qreal, qreal);
+};
+
+}
+
+#endif
--- /dev/null
+/* This file is part of the KDE project
+ * Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
+ * Copyright (C) 2007 Thomas Zander <zander@kde.org>
+ * Copyright (C) 2007 Zack Rusin <zack@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+#include <kcolorutils.h>
+#include "kcolorspaces_p.h"
+#include "kguiaddons_colorhelpers_p.h"
+
+#include <QColor>
+#include <QImage>
+#include <QtNumeric> // qIsNaN
+
+#include <math.h>
+
+// BEGIN internal helper functions
+static inline qreal mixQreal(qreal a, qreal b, qreal bias)
+{
+ return a + (b - a) * bias;
+}
+// END internal helper functions
+
+qreal KColorUtils::luma(const QColor &color)
+{
+ return KColorSpaces::KHCY::luma(color);
+}
+
+void KColorUtils::getHcy(const QColor &color, qreal *h, qreal *c, qreal *y, qreal *a)
+{
+ if (!c || !h || !y) {
+ return;
+ }
+ KColorSpaces::KHCY khcy(color);
+ *c = khcy.c;
+ *h = khcy.h;
+ *y = khcy.y;
+ if (a) {
+ *a = khcy.a;
+ }
+}
+
+static qreal contrastRatioForLuma(qreal y1, qreal y2)
+{
+ if (y1 > y2) {
+ return (y1 + 0.05) / (y2 + 0.05);
+ } else {
+ return (y2 + 0.05) / (y1 + 0.05);
+ }
+}
+
+qreal KColorUtils::contrastRatio(const QColor &c1, const QColor &c2)
+{
+ return contrastRatioForLuma(luma(c1), luma(c2));
+}
+
+QColor KColorUtils::lighten(const QColor &color, qreal ky, qreal kc)
+{
+ KColorSpaces::KHCY c(color);
+ c.y = 1.0 - normalize((1.0 - c.y) * (1.0 - ky));
+ c.c = 1.0 - normalize((1.0 - c.c) * kc);
+ return c.qColor();
+}
+
+QColor KColorUtils::darken(const QColor &color, qreal ky, qreal kc)
+{
+ KColorSpaces::KHCY c(color);
+ c.y = normalize(c.y * (1.0 - ky));
+ c.c = normalize(c.c * kc);
+ return c.qColor();
+}
+
+QColor KColorUtils::shade(const QColor &color, qreal ky, qreal kc)
+{
+ KColorSpaces::KHCY c(color);
+ c.y = normalize(c.y + ky);
+ c.c = normalize(c.c + kc);
+ return c.qColor();
+}
+
+static QColor tintHelper(const QColor &base, qreal baseLuma, const QColor &color, qreal amount)
+{
+ KColorSpaces::KHCY result(KColorUtils::mix(base, color, pow(amount, 0.3)));
+ result.y = mixQreal(baseLuma, result.y, amount);
+
+ return result.qColor();
+}
+
+QColor KColorUtils::tint(const QColor &base, const QColor &color, qreal amount)
+{
+ if (amount <= 0.0) {
+ return base;
+ }
+ if (amount >= 1.0) {
+ return color;
+ }
+ if (qIsNaN(amount)) {
+ return base;
+ }
+
+ qreal baseLuma = luma(base); //cache value because luma call is expensive
+ double ri = contrastRatioForLuma(baseLuma, luma(color));
+ double rg = 1.0 + ((ri + 1.0) * amount * amount * amount);
+ double u = 1.0, l = 0.0;
+ QColor result;
+ for (int i = 12; i; --i) {
+ double a = 0.5 * (l + u);
+ result = tintHelper(base, baseLuma, color, a);
+ double ra = contrastRatioForLuma(baseLuma, luma(result));
+ if (ra > rg) {
+ u = a;
+ } else {
+ l = a;
+ }
+ }
+ return result;
+}
+
+QColor KColorUtils::mix(const QColor &c1, const QColor &c2, qreal bias)
+{
+ if (bias <= 0.0) {
+ return c1;
+ }
+ if (bias >= 1.0) {
+ return c2;
+ }
+ if (qIsNaN(bias)) {
+ return c1;
+ }
+
+ qreal r = mixQreal(c1.redF(), c2.redF(), bias);
+ qreal g = mixQreal(c1.greenF(), c2.greenF(), bias);
+ qreal b = mixQreal(c1.blueF(), c2.blueF(), bias);
+ qreal a = mixQreal(c1.alphaF(), c2.alphaF(), bias);
+
+ return QColor::fromRgbF(r, g, b, a);
+}
+
+QColor KColorUtils::overlayColors(const QColor &base, const QColor &paint,
+ QPainter::CompositionMode comp)
+{
+ // This isn't the fastest way, but should be "fast enough".
+ // It's also the only safe way to use QPainter::CompositionMode
+ QImage img(1, 1, QImage::Format_ARGB32_Premultiplied);
+ QPainter p(&img);
+ QColor start = base;
+ start.setAlpha(255); // opaque
+ p.fillRect(0, 0, 1, 1, start);
+ p.setCompositionMode(comp);
+ p.fillRect(0, 0, 1, 1, paint);
+ p.end();
+ return img.pixel(0, 0);
+}
--- /dev/null
+/* This file is part of the KDE project
+ * Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
+ * Copyright (C) 2007 Thomas Zander <zander@kde.org>
+ * Copyright (C) 2007 Zack Rusin <zack@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KCOLORUTILS_H
+#define KCOLORUTILS_H
+
+#include <kguiaddons_export.h>
+#include <QPainter>
+
+class QColor;
+
+/**
+ * A set of methods used to work with colors.
+ */
+namespace KColorUtils
+{
+/**
+ * Calculate the luma of a color. Luma is weighted sum of gamma-adjusted
+ * R'G'B' components of a color. The result is similar to qGray. The range
+ * is from 0.0 (black) to 1.0 (white).
+ *
+ * KColorUtils::darken(), KColorUtils::lighten() and KColorUtils::shade()
+ * operate on the luma of a color.
+ *
+ * @see http://en.wikipedia.org/wiki/Luma_(video)
+ */
+KGUIADDONS_EXPORT qreal luma(const QColor &);
+
+/**
+ * Calculate hue, chroma and luma of a color in one call.
+ * @since 5.0
+ */
+KGUIADDONS_EXPORT void getHcy(const QColor &, qreal *hue, qreal *chroma, qreal *luma, qreal *alpha = nullptr);
+
+/**
+ * Calculate the contrast ratio between two colors, according to the
+ * W3C/WCAG2.0 algorithm, (Lmax + 0.05)/(Lmin + 0.05), where Lmax and Lmin
+ * are the luma values of the lighter color and the darker color,
+ * respectively.
+ *
+ * A contrast ration of 5:1 (result == 5.0) is the minimum for "normal"
+ * text to be considered readable (large text can go as low as 3:1). The
+ * ratio ranges from 1:1 (result == 1.0) to 21:1 (result == 21.0).
+ *
+ * @see KColorUtils::luma
+ */
+KGUIADDONS_EXPORT qreal contrastRatio(const QColor &, const QColor &);
+
+/**
+ * Adjust the luma of a color by changing its distance from white.
+ *
+ * @li amount == 1.0 gives white
+ * @li amount == 0.5 results in a color whose luma is halfway between 1.0
+ * and that of the original color
+ * @li amount == 0.0 gives the original color
+ * @li amount == -1.0 gives a color that is 'twice as far from white' as
+ * the original color, that is luma(result) == 1.0 - 2*(1.0 - luma(color))
+ *
+ * @param amount factor by which to adjust the luma component of the color
+ * @param chromaInverseGain (optional) factor by which to adjust the chroma
+ * component of the color; 1.0 means no change, 0.0 maximizes chroma
+ * @see KColorUtils::shade
+ */
+KGUIADDONS_EXPORT QColor lighten(const QColor &, qreal amount = 0.5, qreal chromaInverseGain = 1.0);
+
+/**
+ * Adjust the luma of a color by changing its distance from black.
+ *
+ * @li amount == 1.0 gives black
+ * @li amount == 0.5 results in a color whose luma is halfway between 0.0
+ * and that of the original color
+ * @li amount == 0.0 gives the original color
+ * @li amount == -1.0 gives a color that is 'twice as far from black' as
+ * the original color, that is luma(result) == 2*luma(color)
+ *
+ * @param amount factor by which to adjust the luma component of the color
+ * @param chromaGain (optional) factor by which to adjust the chroma
+ * component of the color; 1.0 means no change, 0.0 minimizes chroma
+ * @see KColorUtils::shade
+ */
+KGUIADDONS_EXPORT QColor darken(const QColor &, qreal amount = 0.5, qreal chromaGain = 1.0);
+
+/**
+ * Adjust the luma and chroma components of a color. The amount is added
+ * to the corresponding component.
+ *
+ * @param lumaAmount amount by which to adjust the luma component of the
+ * color; 0.0 results in no change, -1.0 turns anything black, 1.0 turns
+ * anything white
+ * @param chromaAmount (optional) amount by which to adjust the chroma
+ * component of the color; 0.0 results in no change, -1.0 minimizes chroma,
+ * 1.0 maximizes chroma
+ * @see KColorUtils::luma
+ */
+KGUIADDONS_EXPORT QColor shade(const QColor &, qreal lumaAmount, qreal chromaAmount = 0.0);
+
+/**
+ * Create a new color by tinting one color with another. This function is
+ * meant for creating additional colors withings the same class (background,
+ * foreground) from colors in a different class. Therefore when @p amount
+ * is low, the luma of @p base is mostly preserved, while the hue and
+ * chroma of @p color is mostly inherited.
+ *
+ * @param base color to be tinted
+ * @param color color with which to tint
+ * @param amount how strongly to tint the base; 0.0 gives @p base,
+ * 1.0 gives @p color
+ */
+KGUIADDONS_EXPORT QColor tint(const QColor &base, const QColor &color, qreal amount = 0.3);
+
+/**
+ * Blend two colors into a new color by linear combination.
+ * @code
+ QColor lighter = KColorUtils::mix(myColor, Qt::white)
+ * @endcode
+ * @param c1 first color.
+ * @param c2 second color.
+ * @param bias weight to be used for the mix. @p bias <= 0 gives @p c1,
+ * @p bias >= 1 gives @p c2. @p bias == 0.5 gives a 50% blend of @p c1
+ * and @p c2.
+ */
+KGUIADDONS_EXPORT QColor mix(const QColor &c1, const QColor &c2,
+ qreal bias = 0.5);
+
+/**
+ * Blend two colors into a new color by painting the second color over the
+ * first using the specified composition mode.
+ * @code
+ QColor white(Qt::white);
+ white.setAlphaF(0.5);
+ QColor lighter = KColorUtils::overlayColors(myColor, white);
+ @endcode
+ * @param base the base color (alpha channel is ignored).
+ * @param paint the color to be overlayed onto the base color.
+ * @param comp the CompositionMode used to do the blending.
+ */
+KGUIADDONS_EXPORT QColor overlayColors(const QColor &base, const QColor &paint,
+ QPainter::CompositionMode comp = QPainter::CompositionMode_SourceOver);
+
+}
+
+#endif // KCOLORUTILS_H
--- /dev/null
+/* This file is part of the KDE project
+ * Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
+ * Copyright (C) 2007 Olaf Schmidt <ojschmidt@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KGUIADDONS_COLORHELPERS_P_H
+#define KGUIADDONS_COLORHELPERS_P_H
+
+// normalize: like qBound(a, 0.0, 1.0) but without needing the args and with
+// "safer" behavior on NaN (isnan(a) -> return 0.0)
+static inline qreal normalize(qreal a)
+{
+ return (a < 1.0 ? (a > 0.0 ? a : 0.0) : 1.0);
+}
+
+#endif // KGUIADDONS_KCOLORHELPERS_P_H
--- /dev/null
+/*********************************************************************************
+ * *
+ * Copyright (C) 2005, 2009, 2014 by Albert Astals Cid <aacid@kde.org> *
+ * *
+ * This library is free software; you can redistribute it and/or *
+ * modify it under the terms of the GNU Lesser General Public *
+ * License as published by the Free Software Foundation; either *
+ * version 2.1 of the License, or (at your option) version 3, or any *
+ * later version accepted by the membership of KDE e.V. (or its *
+ * successor approved by the membership of KDE e.V.), which shall *
+ * act as a proxy defined in Section 6 of version 3 of the license. *
+ * *
+ * This library is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
+ * Lesser General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU Lesser General Public *
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>. *
+ * *
+ *********************************************************************************/
+
+#include "kfontutils.h"
+
+#include <qmath.h>
+#include <qpainter.h>
+
+static bool checkFits(QPainter &painter, const QString &string, qreal width, qreal height, qreal size, KFontUtils::AdaptFontSizeOptions flags)
+{
+ QFont f = painter.font();
+ f.setPointSizeF(size);
+ painter.setFont(f);
+ int qtFlags = Qt::AlignCenter | Qt::TextWordWrap;
+ if (flags & KFontUtils::DoNotAllowWordWrap) {
+ qtFlags &= ~Qt::TextWordWrap;
+ }
+ const QRectF boundingRect = painter.boundingRect(QRectF(0, 0, width, height), qtFlags, string);
+ if (boundingRect.width() == 0.0 || boundingRect.height() == 0.0) {
+ return false;
+ } else if (boundingRect.width() > width || boundingRect.height() > height) {
+ return false;
+ }
+ return true;
+}
+
+qreal KFontUtils::adaptFontSize(QPainter &painter, const QString &string, qreal width, qreal height, qreal maxFontSize, qreal minFontSize, AdaptFontSizeOptions flags)
+{
+ // A invalid range is an error (-1)
+ if (maxFontSize < minFontSize)
+ return -1;
+
+ // If the max font size already fits, return it
+ if (checkFits(painter, string, width, height, maxFontSize, flags))
+ return maxFontSize;
+
+ qreal fontSizeDoesNotFit = maxFontSize;
+
+ // If the min font size does not fit, try to see if a font size of 1 fits,
+ // if it does not return error (-1)
+ // if it does, we'll return a fontsize smaller than the minFontSize as documented
+ if (!checkFits(painter, string, width, height, minFontSize, flags)) {
+ fontSizeDoesNotFit = minFontSize;
+
+ minFontSize = 1;
+ if (!checkFits(painter, string, width, height, minFontSize, flags))
+ return -1;
+ }
+
+ qreal fontSizeFits = minFontSize;
+ qreal nextFontSizeToTry = (fontSizeDoesNotFit + fontSizeFits) / 2;
+
+ while (qFloor(fontSizeFits) != qFloor(nextFontSizeToTry)) {
+ if (checkFits(painter, string, width, height, nextFontSizeToTry, flags)) {
+ fontSizeFits = nextFontSizeToTry;
+ nextFontSizeToTry = (fontSizeDoesNotFit + fontSizeFits) / 2;
+ } else {
+ fontSizeDoesNotFit = nextFontSizeToTry;
+ nextFontSizeToTry = (nextFontSizeToTry + fontSizeFits) / 2;
+ }
+ }
+
+ QFont f = painter.font();
+ f.setPointSizeF(fontSizeFits);
+ painter.setFont(f);
+
+ return fontSizeFits;
+}
+
+qreal KFontUtils::adaptFontSize(QPainter &painter, const QString &text, const QSizeF &availableSize, qreal maxFontSize, qreal minFontSize, AdaptFontSizeOptions flags)
+{
+ return adaptFontSize(painter, text, availableSize.width(), availableSize.height(), maxFontSize, minFontSize, flags);
+}
+
--- /dev/null
+/*********************************************************************************
+ * *
+ * Copyright (C) 2005, 2009 by Albert Astals Cid <aacid@kde.org> *
+ * *
+ * This library is free software; you can redistribute it and/or *
+ * modify it under the terms of the GNU Lesser General Public *
+ * License as published by the Free Software Foundation; either *
+ * version 2.1 of the License, or (at your option) version 3, or any *
+ * later version accepted by the membership of KDE e.V. (or its *
+ * successor approved by the membership of KDE e.V.), which shall *
+ * act as a proxy defined in Section 6 of version 3 of the license. *
+ * *
+ * This library is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
+ * Lesser General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU Lesser General Public *
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>. *
+ * *
+ *********************************************************************************/
+
+#ifndef KFONTUTILS_H
+#define KFONTUTILS_H
+
+#include <kguiaddons_export.h>
+
+#include <qglobal.h>
+
+class QPainter;
+class QSizeF;
+class QString;
+
+/**
+ * @namespace KFontUtils
+ * Provides utility functions for font data.
+ */
+namespace KFontUtils
+{
+/** Modifiers for the adaptFontSize function */
+enum AdaptFontSizeOption {
+ NoFlags = 0x01, ///< No modifier
+ DoNotAllowWordWrap = 0x02 ///< Do not use word wrapping
+};
+Q_DECLARE_FLAGS(AdaptFontSizeOptions, AdaptFontSizeOption)
+
+/** Helper function that calculates the biggest font size (in points) used
+ drawing a centered text using word wrapping.
+ @param painter The painter where the text will be painted. The font set
+ in the painter is used for the calculation. Note the
+ painter font size is modified by this call
+ @param text The text you want to draw
+ @param width The available width for drawing
+ @param height The available height for drawing
+ @param maxFontSize The maximum font size (in points) to consider
+ @param minFontSize The minimum font size (in points) to consider
+ @param flags The modifiers for how the text is painted
+ @return The calculated biggest font size (in points) that draws the text
+ in the given dimensions. Can return smaller than minFontSize,
+ that means the text doesn't fit in the given rectangle. Can
+ return -1 on error
+ @since 4.7
+*/
+qreal KGUIADDONS_EXPORT adaptFontSize(QPainter &painter,
+ const QString &text,
+ qreal width,
+ qreal height,
+ qreal maxFontSize = 28.0,
+ qreal minFontSize = 1.0,
+ AdaptFontSizeOptions flags = NoFlags);
+
+/** Convenience function for adaptFontSize that accepts a QSizeF instead two qreals
+ @since 4.7
+*/
+qreal KGUIADDONS_EXPORT adaptFontSize(QPainter &painter,
+ const QString &text,
+ const QSizeF &availableSize,
+ qreal maxFontSize = 28.0,
+ qreal minFontSize = 1.0,
+ AdaptFontSizeOptions flags = NoFlags);
+}
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(KFontUtils::AdaptFontSizeOptions)
+
+#endif
+
--- /dev/null
+/* -*- C++ -*-
+ This file is part of the KDE libraries
+ Copyright (C) 1997 Tim D. Gilman (tdgilman@best.org)
+ (C) 1998-2001 Mirko Boehm (mirko@kde.org)
+ (C) 2007 John Layt <john@layt.net>
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kdatevalidator.h"
+
+#include <QDate>
+#include <QLocale>
+
+class Q_DECL_HIDDEN KDateValidator::KDateValidatorPrivate
+{
+public:
+ KDateValidatorPrivate(KDateValidator *q): q(q)
+ {
+ }
+
+ ~KDateValidatorPrivate()
+ {
+ }
+
+ KDateValidator *q;
+};
+
+KDateValidator::KDateValidator(QObject *parent) : QValidator(parent), d(nullptr)
+{
+ Q_UNUSED(d);
+}
+
+QValidator::State KDateValidator::validate(QString &text, int &unused) const
+{
+ Q_UNUSED(unused);
+
+ QDate temp;
+ // ----- everything is tested in date():
+ return date(text, temp);
+}
+
+QValidator::State KDateValidator::date(const QString &text, QDate &d) const
+{
+ QLocale::FormatType formats[] = { QLocale::LongFormat, QLocale::ShortFormat, QLocale::NarrowFormat };
+ QLocale locale;
+
+ for (int i = 0; i < 3; i++) {
+ QDate tmp = locale.toDate(text, formats[i]);
+ if (tmp.isValid()) {
+ d = tmp;
+ return Acceptable;
+ }
+ }
+
+ return QValidator::Intermediate;
+}
+
+void KDateValidator::fixup(QString &) const
+{
+}
+
--- /dev/null
+/* -*- C++ -*-
+ This file is part of the KDE libraries
+ Copyright (C) 1997 Tim D. Gilman (tdgilman@best.org)
+ (C) 1998-2001 Mirko Boehm (mirko@kde.org)
+ (C) 2007 John Layt <john@layt.net>
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#ifndef KDATEVALIDATOR_H
+#define KDATEVALIDATOR_H
+
+#include <kguiaddons_export.h>
+
+#include <QValidator>
+
+/**
+ * @class KDateValidator kdatevalidator.h KDateValidator
+ *
+ * Validates user-entered dates.
+ */
+class KGUIADDONS_EXPORT KDateValidator : public QValidator
+{
+ Q_OBJECT
+public:
+ explicit KDateValidator(QObject *parent = nullptr);
+ State validate(QString &text, int &e) const override;
+ void fixup(QString &input) const override;
+ State date(const QString &text, QDate &date) const;
+private:
+ class KDateValidatorPrivate;
+ friend class KDateValidatorPrivate;
+ KDateValidatorPrivate *const d;
+};
+
+#endif // KDATEVALIDATOR_H
--- /dev/null
+/* This file is part of the KDE libraries
+ Copyright (C) 2001 David Faure <faure@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kwordwrap.h"
+
+#include <QPainter>
+#include <QVector>
+
+class KWordWrapPrivate : public QSharedData
+{
+public:
+ QRect m_constrainingRect;
+ QVector<int> m_breakPositions;
+ QVector<int> m_lineWidths;
+ QRect m_boundingRect;
+ QString m_text;
+};
+
+KWordWrap::KWordWrap(const QRect &r)
+ : d(new KWordWrapPrivate)
+{
+ d->m_constrainingRect = r;
+}
+
+KWordWrap KWordWrap::formatText(QFontMetrics &fm, const QRect &r, int /*flags*/, const QString &str, int len)
+{
+ KWordWrap kw(r);
+ // The wordwrap algorithm
+ // The variable names and the global shape of the algorithm are inspired
+ // from QTextFormatterBreakWords::format().
+ //qDebug() << "KWordWrap::formatText " << str << " r=" << r.x() << "," << r.y() << " " << r.width() << "x" << r.height();
+ int height = fm.height();
+ if (len == -1) {
+ kw.d->m_text = str;
+ } else {
+ kw.d->m_text = str.left(len);
+ }
+ if (len == -1) {
+ len = str.length();
+ }
+ int lastBreak = -1;
+ int lineWidth = 0;
+ int x = 0;
+ int y = 0;
+ int w = r.width();
+ int textwidth = 0;
+ bool isBreakable = false;
+ bool wasBreakable = false; // value of isBreakable for last char (i-1)
+ bool isParens = false; // true if one of ({[
+ bool wasParens = false; // value of isParens for last char (i-1)
+ QString inputString = str;
+
+ for (int i = 0; i < len; ++i) {
+ const QChar c = inputString.at(i);
+ const int ww = fm.charWidth(inputString, i);
+
+ isParens = (c == QLatin1Char('(') || c == QLatin1Char('[')
+ || c == QLatin1Char('{'));
+ // isBreakable is true when we can break _after_ this character.
+ isBreakable = (c.isSpace() || c.isPunct() || c.isSymbol()) & !isParens;
+
+ // Special case for '(', '[' and '{': we want to break before them
+ if (!isBreakable && i < len - 1) {
+ const QChar nextc = inputString.at(i + 1); // look at next char
+ isBreakable = (nextc == QLatin1Char('(')
+ || nextc == QLatin1Char('[')
+ || nextc == QLatin1Char('{'));
+ }
+ // Special case for '/': after normal chars it's breakable (e.g. inside a path),
+ // but after another breakable char it's not (e.g. "mounted at /foo")
+ // Same thing after a parenthesis (e.g. "dfaure [/fool]")
+ if (c == QLatin1Char('/') && (wasBreakable || wasParens)) {
+ isBreakable = false;
+ }
+
+ /*qDebug() << "c='" << QString(c) << "' i=" << i << "/" << len
+ << " x=" << x << " ww=" << ww << " w=" << w
+ << " lastBreak=" << lastBreak << " isBreakable=" << isBreakable << endl;*/
+ int breakAt = -1;
+ if (x + ww > w && lastBreak != -1) { // time to break and we know where
+ breakAt = lastBreak;
+ }
+ if (x + ww > w - 4 && lastBreak == -1) { // time to break but found nowhere [-> break here]
+ breakAt = i;
+ }
+ if (i == len - 2 && x + ww + fm.charWidth(inputString, i + 1) > w) { // don't leave the last char alone
+ breakAt = lastBreak == -1 ? i - 1 : lastBreak;
+ }
+ if (c == QLatin1Char('\n')) { // Forced break here
+ if (breakAt == -1 && lastBreak != -1) { // only break if not already breaking
+ breakAt = i - 1;
+ lastBreak = -1;
+ }
+ // remove the line feed from the string
+ kw.d->m_text.remove(i, 1);
+ inputString.remove(i, 1);
+ len--;
+ }
+ if (breakAt != -1) {
+ //qDebug() << "KWordWrap::formatText breaking after " << breakAt;
+ kw.d->m_breakPositions.append(breakAt);
+ int thisLineWidth = lastBreak == -1 ? x + ww : lineWidth;
+ kw.d->m_lineWidths.append(thisLineWidth);
+ textwidth = qMax(textwidth, thisLineWidth);
+ x = 0;
+ y += height;
+ wasBreakable = true;
+ wasParens = false;
+ if (lastBreak != -1) {
+ // Breakable char was found, restart from there
+ i = lastBreak;
+ lastBreak = -1;
+ continue;
+ }
+ } else if (isBreakable) {
+ lastBreak = i;
+ lineWidth = x + ww;
+ }
+ x += ww;
+ wasBreakable = isBreakable;
+ wasParens = isParens;
+ }
+ textwidth = qMax(textwidth, x);
+ kw.d->m_lineWidths.append(x);
+ y += height;
+ //qDebug() << "KWordWrap::formatText boundingRect:" << r.x() << "," << r.y() << " " << textwidth << "x" << y;
+ if (r.height() >= 0 && y > r.height()) {
+ textwidth = r.width();
+ }
+ int realY = y;
+ if (r.height() >= 0) {
+ while (realY > r.height()) {
+ realY -= height;
+ }
+ realY = qMax(realY, 0);
+ }
+ kw.d->m_boundingRect.setRect(0, 0, textwidth, realY);
+ return kw;
+}
+
+KWordWrap::~KWordWrap()
+{
+}
+
+KWordWrap::KWordWrap(const KWordWrap &other)
+ : d(other.d)
+{
+}
+
+KWordWrap &KWordWrap::operator=(const KWordWrap &other)
+{
+ d = other.d;
+ return *this;
+}
+
+QString KWordWrap::wrappedString() const
+{
+ // We use the calculated break positions to insert '\n' into the string
+ QString ws;
+ int start = 0;
+ for (int i = 0; i < d->m_breakPositions.count(); ++i) {
+ int end = d->m_breakPositions.at(i);
+ ws += d->m_text.midRef(start, end - start + 1);
+ ws += QLatin1Char('\n');
+ start = end + 1;
+ }
+ ws += d->m_text.midRef(start);
+ return ws;
+}
+
+QString KWordWrap::truncatedString(bool dots) const
+{
+ if (d->m_breakPositions.isEmpty()) {
+ return d->m_text;
+ }
+
+ QString ts = d->m_text.left(d->m_breakPositions.first() + 1);
+ if (dots) {
+ ts += QLatin1String("...");
+ }
+ return ts;
+}
+
+static QColor mixColors(double p1, QColor c1, QColor c2)
+{
+ return QColor(int(c1.red() * p1 + c2.red() * (1.0 - p1)),
+ int(c1.green() * p1 + c2.green() * (1.0 - p1)),
+ int(c1.blue() * p1 + c2.blue() * (1.0 - p1)));
+}
+
+void KWordWrap::drawFadeoutText(QPainter *p, int x, int y, int maxW,
+ const QString &t)
+{
+ QFontMetrics fm = p->fontMetrics();
+ QColor bgColor = p->background().color();
+ QColor textColor = p->pen().color();
+
+ if ((fm.boundingRect(t).width() > maxW) && (t.length() > 1)) {
+ int tl = 0;
+ int w = 0;
+ while (tl < t.length()) {
+ w += fm.charWidth(t, tl);
+ if (w >= maxW) {
+ break;
+ }
+ tl++;
+ }
+
+ int n = qMin(tl, 3);
+ if (t.isRightToLeft()) {
+ x += maxW; // start from the right side for RTL string
+ if (tl > 3) {
+#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
+ x -= fm.horizontalAdvance(t.left(tl - 3));
+#else
+ x -= fm.width(t.left(tl - 3));
+#endif
+ p->drawText(x, y, t.left(tl - 3));
+ }
+ for (int i = 0; i < n; i++) {
+ p->setPen(mixColors(0.70 - i * 0.25, textColor, bgColor));
+ QString s(t.at(tl - n + i));
+#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
+ x -= fm.horizontalAdvance(s);
+#else
+ x -= fm.width(s);
+#endif
+ p->drawText(x, y, s);
+ }
+ } else {
+ if (tl > 3) {
+ p->drawText(x, y, t.left(tl - 3));
+#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
+ x += fm.horizontalAdvance(t.left(tl - 3));
+#else
+ x += fm.width(t.left(tl - 3));
+#endif
+ }
+ for (int i = 0; i < n; i++) {
+ p->setPen(mixColors(0.70 - i * 0.25, textColor, bgColor));
+ QString s(t.at(tl - n + i));
+ p->drawText(x, y, s);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
+ x += fm.horizontalAdvance(s);
+#else
+ x += fm.width(s);
+#endif
+ }
+ }
+ } else {
+ p->drawText(x, y, t);
+ }
+}
+
+void KWordWrap::drawTruncateText(QPainter *p, int x, int y, int maxW,
+ const QString &t)
+{
+ QString tmpText = p->fontMetrics().elidedText(t, Qt::ElideRight, maxW);
+ p->drawText(x, y, tmpText);
+}
+
+void KWordWrap::drawText(QPainter *painter, int textX, int textY, int flags) const
+{
+ //qDebug() << "KWordWrap::drawText text=" << wrappedString() << " x=" << textX << " y=" << textY;
+ // We use the calculated break positions to draw the text line by line using QPainter
+ int start = 0;
+ int y = 0;
+ QFontMetrics fm = painter->fontMetrics();
+ int height = fm.height(); // line height
+ int ascent = fm.ascent();
+ int maxwidth = d->m_boundingRect.width();
+ int i;
+ int lwidth = 0;
+ int end = 0;
+ for (i = 0; i < d->m_breakPositions.count(); ++i) {
+ // if this is the last line, leave the loop
+ if ((d->m_constrainingRect.height() >= 0) &&
+ ((y + 2 * height) > d->m_constrainingRect.height())) {
+ break;
+ }
+ end = d->m_breakPositions.at(i);
+ lwidth = d->m_lineWidths.at(i);
+ int x = textX;
+ if (flags & Qt::AlignHCenter) {
+ x += (maxwidth - lwidth) / 2;
+ } else if (flags & Qt::AlignRight) {
+ x += maxwidth - lwidth;
+ }
+ painter->drawText(x, textY + y + ascent, d->m_text.mid(start, end - start + 1));
+ y += height;
+ start = end + 1;
+ }
+
+ // Draw the last line
+ lwidth = d->m_lineWidths.last();
+ int x = textX;
+ if (flags & Qt::AlignHCenter) {
+ x += (maxwidth - lwidth) / 2;
+ } else if (flags & Qt::AlignRight) {
+ x += maxwidth - lwidth;
+ }
+ if ((d->m_constrainingRect.height() < 0) ||
+ ((y + height) <= d->m_constrainingRect.height())) {
+ if (i == d->m_breakPositions.count()) {
+ painter->drawText(x, textY + y + ascent, d->m_text.mid(start));
+ } else if (flags & FadeOut)
+ drawFadeoutText(painter, textX, textY + y + ascent,
+ d->m_constrainingRect.width(),
+ d->m_text.mid(start));
+ else if (flags & Truncate)
+ drawTruncateText(painter, textX, textY + y + ascent,
+ d->m_constrainingRect.width(),
+ d->m_text.mid(start));
+ else
+ painter->drawText(x, textY + y + ascent,
+ d->m_text.mid(start));
+ }
+}
+
+QRect KWordWrap::boundingRect() const
+{
+ return d->m_boundingRect;
+}
+
--- /dev/null
+/* This file is part of the KDE libraries
+ Copyright (C) 2001 David Faure <faure@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#ifndef kwordwrap_h
+#define kwordwrap_h
+
+#include <kguiaddons_export.h>
+#include <QSharedDataPointer>
+#include <qnamespace.h>
+
+class QFontMetrics;
+class QRect;
+class QString;
+class QPainter;
+class KWordWrapPrivate;
+
+/**
+ * @class KWordWrap kwordwrap.h KWordWrap
+ *
+ * Word-wrap algorithm that takes into account beautifulness ;)
+ *
+ * That means:
+ * @li not letting a letter alone on the last line,
+ * @li breaking at punctuation signs (not only at spaces)
+ * @li improved handling of (), [] and {}
+ * @li improved handling of '/' (e.g. for paths)
+ *
+ * Usage: call the static method, formatText, with the text to
+ * wrap and the constraining rectangle etc., it will return an instance of KWordWrap
+ * containing internal data, result of the word-wrapping.
+ * From that instance you can retrieve the boundingRect, and invoke drawing.
+ *
+ * This design allows to call the word-wrap algorithm only when the text changes
+ * and not every time we want to know the bounding rect or draw the text.
+ *
+ * @author David Faure <faure@kde.org>
+ */
+class KGUIADDONS_EXPORT KWordWrap
+{
+public:
+ /**
+ * Use this flag in drawText() if you want to fade out the text if it does
+ * not fit into the constraining rectangle.
+ */
+ enum { FadeOut = 0x10000000, Truncate = 0x20000000 };
+
+ /**
+ * Main method for wrapping text.
+ *
+ * @param fm Font metrics, for the chosen font. Better cache it, creating a QFontMetrics is expensive.
+ * @param r Constraining rectangle. Only the width and height matter. With
+ * negative height the complete text will be rendered
+ * @param flags currently unused
+ * @param str The text to be wrapped.
+ * @param len Length of text to wrap (default is -1 for all).
+ * @return a KWordWrap instance. The caller is responsible for storing and deleting the result.
+ */
+ static KWordWrap formatText(QFontMetrics &fm, const QRect &r, int flags, const QString &str, int len = -1);
+
+ /**
+ * @return the bounding rect, calculated by formatText. The width is the
+ * width of the widest text line, and never wider than
+ * the rectangle given to formatText. The height is the
+ * text block. X and Y are always 0.
+ */
+ QRect boundingRect() const;
+
+ /**
+ * @return the original string, with '\n' inserted where
+ * the text is broken by the wordwrap algorithm.
+ */
+ QString wrappedString() const; // gift for Dirk :)
+
+ /**
+ * @return the original string, truncated to the first line.
+ * If @p dots was set, '...' is appended in case the string was truncated.
+ * Bug: Note that the '...' come out of the bounding rect.
+ */
+ QString truncatedString(bool dots = true) const;
+
+ /**
+ * Draw the text that has been previously wrapped, at position x,y.
+ * Flags are for alignment, e.g. Qt::AlignHCenter. Default is
+ * Qt::AlignAuto.
+ * @param painter the QPainter to use.
+ * @param x the horizontal position of the text
+ * @param y the vertical position of the text
+ * @param flags the ORed text alignment flags from the Qt namespace,
+ * ORed with FadeOut if you want the text to fade out if it
+ * does not fit (the @p painter's background must be set
+ * accordingly)
+ */
+ void drawText(QPainter *painter, int x, int y, int flags = Qt::AlignLeft) const;
+
+ /**
+ * Destructor.
+ */
+ ~KWordWrap();
+
+ /**
+ * Copy constructor
+ */
+ KWordWrap(const KWordWrap &other);
+ /**
+ * Assignment operator
+ */
+ KWordWrap &operator=(const KWordWrap &other);
+
+ /**
+ * Draws the string @p t at the given coordinates, if it does not
+ * @p fit into @p maxW the text will be faded out.
+ * @param p the painter to use. Must have set the pen for the text
+ * color and the background for the color to fade out
+ * @param x the horizontal position of the text
+ * @param y the vertical position of the text
+ * @param maxW the maximum width of the text (including the fade-out
+ * effect)
+ * @param t the text to draw
+ */
+ static void drawFadeoutText(QPainter *p, int x, int y, int maxW,
+ const QString &t);
+
+ /**
+ * Draws the string @p t at the given coordinates, if it does not
+ * @p fit into @p maxW the text will be truncated.
+ * @param p the painter to use
+ * @param x the horizontal position of the text
+ * @param y the vertical position of the text
+ * @param maxW the maximum width of the text (including the '...')
+ * @param t the text to draw
+ */
+ static void drawTruncateText(QPainter *p, int x, int y, int maxW,
+ const QString &t);
+
+private:
+ KWordWrap(const QRect &r);
+ QExplicitlySharedDataPointer<KWordWrapPrivate> d;
+};
+
+#endif
--- /dev/null
+/*
+ Copyright (C) 2013 Martin Klapetek <mklapetek@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "kiconutils.h"
+
+#include <QIconEngine>
+#include <QPainter>
+#include <QHash>
+
+class KOverlayIconEngine : public QIconEngine
+{
+public:
+ KOverlayIconEngine(const QIcon &icon, const QIcon &overlay, Qt::Corner position);
+ KOverlayIconEngine(const QIcon &icon, const QHash<Qt::Corner, QIcon> &overlays);
+ void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state) override;
+ QIconEngine *clone() const override;
+
+ QSize actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state) override;
+ QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) override;
+
+ void addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state) override;
+ void addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state) override;
+
+private:
+ QIcon m_base;
+ QHash<Qt::Corner, QIcon> m_overlays;
+};
+
+KOverlayIconEngine::KOverlayIconEngine(const QIcon &icon, const QIcon &overlay, Qt::Corner position)
+ : QIconEngine()
+{
+ m_base = icon;
+ m_overlays.insert(position, overlay);
+}
+
+KOverlayIconEngine::KOverlayIconEngine(const QIcon &icon, const QHash<Qt::Corner, QIcon> &overlays)
+ : QIconEngine()
+{
+ m_base = icon;
+ m_overlays = overlays;
+}
+
+QIconEngine *KOverlayIconEngine::clone() const
+{
+ return new KOverlayIconEngine(*this);
+}
+
+QSize KOverlayIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+ return m_base.actualSize(size, mode, state);
+}
+
+QPixmap KOverlayIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+ QPixmap pixmap(size);
+ pixmap.fill(Qt::transparent);
+ QPainter p(&pixmap);
+
+ paint(&p, pixmap.rect(), mode, state);
+
+ return pixmap;
+}
+
+void KOverlayIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)
+{
+ m_base.addPixmap(pixmap, mode, state);
+}
+
+void KOverlayIconEngine::addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+ m_base.addFile(fileName, size, mode, state);
+}
+
+void KOverlayIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
+{
+ // Paint the base icon as the first layer
+ m_base.paint(painter, rect, Qt::AlignCenter, mode, state);
+
+ if (m_overlays.isEmpty()) {
+ return;
+ }
+
+ const int width = rect.width();
+ const int height = rect.height();
+ const int iconSize = qMin(width, height);
+ // Determine the overlay icon size
+ int overlaySize;
+ if (iconSize < 32) {
+ overlaySize = 8;
+ } else if (iconSize <= 48) {
+ overlaySize = 16;
+ } else if (iconSize <= 64) {
+ overlaySize = 22;
+ } else if (iconSize <= 96) {
+ overlaySize = 32;
+ } else if (iconSize <= 128) {
+ overlaySize = 48;
+ } else {
+ overlaySize = (int)(iconSize / 4);
+ }
+
+ // Iterate over stored overlays
+ QHash<Qt::Corner, QIcon>::const_iterator i = m_overlays.constBegin();
+ while (i != m_overlays.constEnd()) {
+
+ const QPixmap overlayPixmap = i.value().pixmap(overlaySize, overlaySize, mode, state);
+ if (overlayPixmap.isNull()) {
+ ++i;
+ continue;
+ }
+
+ QPoint startPoint;
+ switch (i.key()) {
+ case Qt::BottomLeftCorner:
+ startPoint = QPoint(2, height - overlaySize - 2);
+ break;
+ case Qt::BottomRightCorner:
+ startPoint = QPoint(width - overlaySize - 2, height - overlaySize - 2);
+ break;
+ case Qt::TopRightCorner:
+ startPoint = QPoint(width - overlaySize - 2, 2);
+ break;
+ case Qt::TopLeftCorner:
+ startPoint = QPoint(2, 2);
+ break;
+ }
+
+ // Draw the overlay pixmap
+ painter->drawPixmap(startPoint, overlayPixmap);
+
+ ++i;
+ }
+}
+
+// ============================================================================
+
+namespace KIconUtils
+{
+
+QIcon addOverlay(const QIcon &icon, const QIcon &overlay, Qt::Corner position)
+{
+ return QIcon(new KOverlayIconEngine(icon, overlay, position));
+}
+
+QIcon addOverlays(const QIcon &icon, const QHash<Qt::Corner, QIcon> &overlays)
+{
+ return QIcon(new KOverlayIconEngine(icon, overlays));
+}
+
+}
--- /dev/null
+/*
+ Copyright (C) 2013 Martin Klapetek <mklapetek@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICONUTILS_H
+#define KICONUTILS_H
+
+#include <kguiaddons_export.h>
+
+#include <QIcon>
+
+/**
+ * @namespace KIconUtils
+ * Provides utility functions for icons.
+ */
+namespace KIconUtils
+{
+
+/**
+ * Adds the \a overlay over the \a icon in the specified \a position
+ *
+ * The \a overlay icon is scaled down approx. to 1/3 or 1/4 (depending on the icon size)
+ * and placed in one of the corners of the base icon.
+ */
+KGUIADDONS_EXPORT QIcon addOverlay(const QIcon &icon, const QIcon &overlay, Qt::Corner position);
+
+/**
+ * Adds \a overlays over the \a icon
+ *
+ * The \a overlays is a QHash of Qt::Corner and QIcon. The Qt::Corner value
+ * decides where the overlay icon will be painted, the QIcon value
+ * is the overlay icon to be painted.
+ *
+ * The overlay icon is scaled down to 1/3 or 1/4 (depending on the icon size)
+ * and placed in one of the corners of the base icon.
+ */
+KGUIADDONS_EXPORT QIcon addOverlays(const QIcon &icon, const QHash<Qt::Corner, QIcon> &overlays);
+}
+
+#endif // KICONUTILS_H
--- /dev/null
+/*
+ * This file is part of the KDE project.
+ * Copyright © 2010 Michael Pyne <mpyne@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KIMAGECACHE_H
+#define KIMAGECACHE_H
+
+// check that KGUIADDONS_LIB is defined in case the application is not using CMake
+// (if KGUIADDONS_LIB is not defined, we cannot assume that KCOREADDONS_LIB not being
+// defined means that we are not linked against KCoreAddons)
+#if defined(KGUIADDONS_LIB) && !defined(KCOREADDONS_LIB)
+#ifdef __GNUC__
+#warning "KImageCache requires KF5CoreAddons (for kshareddatacache.h)"
+#else
+#pragma message("KImageCache requires KF5CoreAddons (for kshareddatacache.h)")
+#endif
+#endif
+
+#include <klocalimagecacheimpl.h>
+#include <kshareddatacache.h>
+#include <QPixmap>
+#include <QImage>
+
+#define KImageCache KSharedPixmapCacheMixin<KSharedDataCache>
+
+/**
+ * @brief A simple wrapping layer over KSharedDataCache to support caching
+ * images and pixmaps.
+ *
+ * This class can be used to share images between different processes, which
+ * is useful when it is known that such images will be used across many
+ * processes, or when creating the image is expensive.
+ *
+ * In addition, the class also supports caching QPixmaps <em>in a single
+ * process</em> using the setPixmapCaching() function.
+ *
+ * Tips for use: If you already have QPixmaps that you intend to use, and
+ * you do not need access to the actual image data, then try to store and
+ * retrieve QPixmaps for use.
+ *
+ * On the other hand, if you will need to store and retrieve actual image
+ * data (to modify the image after retrieval for instance) then you should
+ * use QImage to save the conversion cost from QPixmap to QImage.
+ *
+ * KSharedPixmapCacheMixin is a subclass of KSharedDataCache, so all of the methods that
+ * can be used with KSharedDataCache can be used with KSharedPixmapCacheMixin,
+ * <em>with the exception of KSharedDataCache::insert() and
+ * KSharedDataCache::find()</em>.
+ *
+ * @author Michael Pyne <mpyne@kde.org>
+ * @since 4.5
+ */
+template<class T>
+class KSharedPixmapCacheMixin : public T, private KLocalImageCacheImplementation
+{
+public:
+ /**
+ * Constructs an image cache, named by @p cacheName, with a default
+ * size of @p defaultCacheSize.
+ *
+ * @param cacheName Name of the cache to use.
+ * @param defaultCacheSize The default size, in bytes, of the cache.
+ * The actual on-disk size will be slightly larger. If the cache already
+ * exists, it will not be resized. If it is required to resize the
+ * cache then use the deleteCache() function to remove that cache first.
+ * @param expectedItemSize The expected general size of the items to be
+ * added to the image cache, in bytes. Use 0 if you just want a default
+ * item size.
+ */
+ KSharedPixmapCacheMixin(const QString &cacheName,
+ unsigned defaultCacheSize,
+ unsigned expectedItemSize = 0)
+ : T(cacheName, defaultCacheSize, expectedItemSize),
+ KLocalImageCacheImplementation(defaultCacheSize) {}
+
+ /**
+ * Inserts the pixmap given by @p pixmap to the cache, accessible with
+ * @p key. The pixmap must be converted to a QImage in order to be stored
+ * into shared memory. In order to prevent unnecessary conversions from
+ * taking place @p pixmap will also be cached (but not in shared
+ * memory) and would be accessible using findPixmap() if pixmap caching is
+ * enabled.
+ *
+ * @param key Name to access @p pixmap with.
+ * @param pixmap The pixmap to add to the cache.
+ * @return true if the pixmap was successfully cached, false otherwise.
+ * @see setPixmapCaching()
+ */
+ bool insertPixmap(const QString &key, const QPixmap &pixmap)
+ {
+ insertLocalPixmap(key, pixmap);
+
+ // One thing to think about is only inserting things to the shared cache
+ // that are frequently used. But that would require tracking the use count
+ // in our local cache too, which I think is probably too much work.
+
+ return insertImage(key, pixmap.toImage());
+ }
+
+ /**
+ * Inserts the @p image into the shared cache, accessible with @p key. This
+ * variant is preferred over insertPixmap() if your source data is already a
+ * QImage, if it is essential that the image be in shared memory (such as
+ * for SVG icons which have a high render time), or if it will need to be
+ * in QImage form after it is retrieved from the cache.
+ *
+ * @param key Name to access @p image with.
+ * @param image The image to add to the shared cache.
+ * @return true if the image was successfully cached, false otherwise.
+ */
+ bool insertImage(const QString &key, const QImage &image)
+ {
+ if (this->insert(key, serializeImage(image))) {
+ updateModifiedTime();
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Copies the cached pixmap identified by @p key to @p destination. If no such
+ * pixmap exists @p destination is unchanged.
+ *
+ * @return true if the pixmap identified by @p key existed, false otherwise.
+ * @see setPixmapCaching()
+ */
+ bool findPixmap(const QString &key, QPixmap *destination) const
+ {
+ if (findLocalPixmap(key, destination)) {
+ return true;
+ }
+
+ QByteArray cachedData;
+ if (!this->find(key, &cachedData) || cachedData.isNull()) {
+ return false;
+ }
+
+ if (destination) {
+ destination->loadFromData(cachedData, "PNG");
+
+ // Manually re-insert to pixmap cache if we'll be using this one.
+ insertLocalPixmap(key, *destination);
+ }
+
+ return true;
+ }
+
+ /**
+ * Copies the cached image identified by @p key to @p destination. If no such
+ * image exists @p destination is unchanged.
+ *
+ * @return true if the image identified by @p key existed, false otherwise.
+ */
+ bool findImage(const QString &key, QImage *destination) const
+ {
+ QByteArray cachedData;
+ if (!this->find(key, &cachedData) || cachedData.isNull()) {
+ return false;
+ }
+
+ if (destination) {
+ destination->loadFromData(cachedData, "PNG");
+ }
+
+ return true;
+ }
+
+ /**
+ * Removes all entries from the cache. In addition any cached pixmaps (as per
+ * setPixmapCaching()) are also removed.
+ */
+ void clear()
+ {
+ clearLocalCache();
+ T::clear();
+ }
+
+ /**
+ * @return The time that an image or pixmap was last inserted into a cache.
+ */
+ using KLocalImageCacheImplementation::lastModifiedTime;
+
+ /**
+ * @return if QPixmaps added with insertPixmap() will be stored in a local
+ * pixmap cache as well as the shared image cache. The default is to cache
+ * pixmaps locally.
+ */
+ using KLocalImageCacheImplementation::pixmapCaching;
+
+ /**
+ * Enables or disables local pixmap caching. If it is anticipated that a pixmap
+ * will be frequently needed then this can actually save memory overall since the
+ * X server or graphics card will not have to store duplicate copies of the same
+ * image.
+ *
+ * @param enable Enables pixmap caching if true, disables otherwise.
+ */
+ using KLocalImageCacheImplementation::setPixmapCaching;
+
+ /**
+ * @return The highest memory size in bytes to be used by cached pixmaps.
+ * @since 4.6
+ */
+ using KLocalImageCacheImplementation::pixmapCacheLimit;
+
+ /**
+ * Sets the highest memory size the pixmap cache should use.
+ *
+ * @param size The size in bytes
+ * @since 4.6
+ */
+ using KLocalImageCacheImplementation::setPixmapCacheLimit;
+};
+
+#endif /* KIMAGECACHE_H */
--- /dev/null
+/*
+ * This file is part of the KDE project.
+ * Copyright © 2010 Michael Pyne <mpyne@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "klocalimagecacheimpl.h"
+
+#include <QBuffer>
+#include <QCache>
+#include <QCoreApplication>
+#include <QDateTime>
+
+#include <QImage>
+#include <QPixmap>
+
+/**
+ * This is a QObject subclass so we can catch the signal that the application is about
+ * to close and properly release any QPixmaps we have cached.
+ */
+class KLocalImageCacheImplementationPrivate : public QObject
+{
+ Q_OBJECT
+
+public:
+ KLocalImageCacheImplementationPrivate(QObject *parent = nullptr)
+ : QObject(parent)
+ , timestamp(QDateTime::currentDateTime())
+ , enablePixmapCaching(true)
+ {
+ QObject::connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
+ this, &KLocalImageCacheImplementationPrivate::clearPixmaps);
+ }
+
+ /**
+ * Inserts a pixmap into the pixmap cache if the pixmap cache is enabled, with
+ * weighting based on image size and bit depth.
+ */
+ bool insertPixmap(const QString &key, QPixmap *pixmap)
+ {
+ if (enablePixmapCaching && pixmap && !pixmap->isNull()) {
+ // "cost" parameter is based on both image size and depth to make cost
+ // based on size in bytes instead of area on-screen.
+ return pixmapCache.insert(key, pixmap,
+ pixmap->width() * pixmap->height() * pixmap->depth() / 8);
+ }
+
+ return false;
+ }
+
+public Q_SLOTS:
+ void clearPixmaps()
+ {
+ pixmapCache.clear();
+ }
+
+public:
+ QDateTime timestamp;
+
+ /**
+ * This is used to cache pixmaps as they are inserted, instead of always
+ * converting to image data and storing that in shared memory.
+ */
+ QCache<QString, QPixmap> pixmapCache;
+
+ bool enablePixmapCaching;
+};
+
+KLocalImageCacheImplementation::KLocalImageCacheImplementation(unsigned defaultCacheSize)
+ : d(new KLocalImageCacheImplementationPrivate)
+{
+ // Use at least 16 KiB for the pixmap cache
+ d->pixmapCache.setMaxCost(qMax(defaultCacheSize / 8, (unsigned int) 16384));
+}
+
+KLocalImageCacheImplementation::~KLocalImageCacheImplementation()
+{
+ delete d;
+}
+
+void KLocalImageCacheImplementation::updateModifiedTime()
+{
+ d->timestamp = QDateTime::currentDateTime();
+}
+
+QByteArray KLocalImageCacheImplementation::serializeImage(const QImage &image) const
+{
+ QBuffer buffer;
+ buffer.open(QBuffer::WriteOnly);
+ image.save(&buffer, "PNG");
+ return buffer.buffer();
+}
+
+bool KLocalImageCacheImplementation::insertLocalPixmap(const QString &key, const QPixmap &pixmap) const
+{
+ return d->insertPixmap(key, new QPixmap(pixmap));
+}
+
+bool KLocalImageCacheImplementation::findLocalPixmap(const QString &key, QPixmap *destination) const
+{
+ if (d->enablePixmapCaching) {
+ QPixmap *cachedPixmap = d->pixmapCache.object(key);
+ if (cachedPixmap) {
+ if (destination) {
+ *destination = *cachedPixmap;
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void KLocalImageCacheImplementation::clearLocalCache()
+{
+ d->pixmapCache.clear();
+}
+
+QDateTime KLocalImageCacheImplementation::lastModifiedTime() const
+{
+ return d->timestamp;
+}
+
+bool KLocalImageCacheImplementation::pixmapCaching() const
+{
+ return d->enablePixmapCaching;
+}
+
+void KLocalImageCacheImplementation::setPixmapCaching(bool enable)
+{
+ if (enable != d->enablePixmapCaching) {
+ d->enablePixmapCaching = enable;
+ if (!enable) {
+ d->pixmapCache.clear();
+ }
+ }
+}
+
+int KLocalImageCacheImplementation::pixmapCacheLimit() const
+{
+ return d->pixmapCache.maxCost();
+}
+
+void KLocalImageCacheImplementation::setPixmapCacheLimit(int size)
+{
+ d->pixmapCache.setMaxCost(size);
+}
+
+#include "klocalimagecacheimpl.moc"
--- /dev/null
+/*
+ * This file is part of the KDE project.
+ * Copyright © 2010 Michael Pyne <mpyne@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KLOCALIMAGECACHEIMPL_H
+#define KLOCALIMAGECACHEIMPL_H
+
+#include <kguiaddons_export.h>
+class KLocalImageCacheImplementationPrivate;
+
+class QImage;
+class QPixmap;
+class QByteArray;
+class QDateTime;
+class QString;
+
+/**
+ * You are not supposed to use this class directly, use KImageCache instead
+ *
+ * @internal
+ */
+class KGUIADDONS_EXPORT KLocalImageCacheImplementation
+{
+private:
+ explicit KLocalImageCacheImplementation(unsigned defaultCacheSize);
+
+public:
+ virtual ~KLocalImageCacheImplementation();
+
+ QDateTime lastModifiedTime() const;
+
+ bool pixmapCaching() const;
+ void setPixmapCaching(bool enable);
+
+ int pixmapCacheLimit() const;
+ void setPixmapCacheLimit(int size);
+
+protected:
+ void updateModifiedTime();
+ QByteArray serializeImage(const QImage &image) const;
+
+ bool insertLocalPixmap(const QString &key, const QPixmap &pixmap) const;
+ bool findLocalPixmap(const QString &key, QPixmap *destination) const;
+ void clearLocalCache();
+
+private:
+ KLocalImageCacheImplementationPrivate *const d; ///< @internal
+
+ template<class T> friend class KSharedPixmapCacheMixin;
+};
+
+#endif /* KLOCALIMAGECACHEIMPL_H */
--- /dev/null
+/*
+ Copyright 2009 Michael Leupold <lemma@confuego.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "kmodifierkeyinfo.h"
+#include "kmodifierkeyinfoprovider_p.h"
+
+KModifierKeyInfo::KModifierKeyInfo(QObject *parent)
+ : QObject(parent), p(new KModifierKeyInfoProvider)
+{
+ connect(p, &KModifierKeyInfoProvider::keyPressed,
+ this, &KModifierKeyInfo::keyPressed);
+ connect(p, &KModifierKeyInfoProvider::keyLatched,
+ this, &KModifierKeyInfo::keyLatched);
+ connect(p, &KModifierKeyInfoProvider::keyLocked,
+ this, &KModifierKeyInfo::keyLocked);
+ connect(p, &KModifierKeyInfoProvider::buttonPressed,
+ this, &KModifierKeyInfo::buttonPressed);
+ connect(p, &KModifierKeyInfoProvider::keyAdded,
+ this, &KModifierKeyInfo::keyAdded);
+ connect(p, &KModifierKeyInfoProvider::keyRemoved,
+ this, &KModifierKeyInfo::keyRemoved);
+}
+
+KModifierKeyInfo::~KModifierKeyInfo()
+{
+ delete p;
+}
+
+bool KModifierKeyInfo::knowsKey(Qt::Key key) const
+{
+ return p->knowsKey(key);
+}
+
+const QList<Qt::Key> KModifierKeyInfo::knownKeys() const
+{
+ return p->knownKeys();
+}
+
+bool KModifierKeyInfo::isKeyPressed(Qt::Key key) const
+{
+ return p->isKeyPressed(key);
+}
+
+bool KModifierKeyInfo::isKeyLatched(Qt::Key key) const
+{
+ return p->isKeyLatched(key);
+}
+
+bool KModifierKeyInfo::setKeyLatched(Qt::Key key, bool latched)
+{
+ return p->setKeyLatched(key, latched);
+}
+
+bool KModifierKeyInfo::isKeyLocked(Qt::Key key) const
+{
+ return p->isKeyLocked(key);
+}
+
+bool KModifierKeyInfo::setKeyLocked(Qt::Key key, bool locked)
+{
+ return p->setKeyLocked(key, locked);
+}
+
+bool KModifierKeyInfo::isButtonPressed(Qt::MouseButton button) const
+{
+ return p->isButtonPressed(button);
+}
+
--- /dev/null
+/*
+ Copyright 2009 Michael Leupold <lemma@confuego.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef KMODIFIERKEYINFO_H
+#define KMODIFIERKEYINFO_H
+
+#include <kguiaddons_export.h>
+
+#include <QObject>
+
+class KModifierKeyInfoProvider;
+
+/**
+ * @class KModifierKeyInfo kmodifierkeyinfo.h KModifierKeyInfo
+ *
+ * Get information about the state of the keyboard's modifier keys.
+ *
+ * This class provides cross-platform information about the state of the
+ * keyboard's modifier keys and the mouse buttons and allows to change the
+ * state as well.
+ *
+ * It recognizes two states a key can be in:
+ * <ul><li><i>locked</i>: eg. caps-locked (aka toggled)</li>
+ * <li><i>latched</i>: the key is temporarily locked but will be unlocked upon
+ * the next keypress.</li></ul>
+ *
+ * An application can either query the states synchronously (@see isKeyLatched,
+ * @see isKeyLocked) or connect to KModifierKeyInfo's signals to be notified about
+ * changes (@see keyLatched, @see keyLocked).
+ */
+class KGUIADDONS_EXPORT KModifierKeyInfo : public QObject
+{
+ Q_OBJECT
+
+public:
+ /**
+ * Default constructor
+ */
+ explicit KModifierKeyInfo(QObject *parent = nullptr);
+
+ /**
+ * Destructor
+ */
+ virtual ~KModifierKeyInfo();
+
+ /**
+ * Check if a key is known by the underlying window system and can be queried.
+ *
+ * @param key The key to check
+ * @return true if the key is available, false if it is unknown
+ */
+ bool knowsKey(Qt::Key key) const;
+
+ /**
+ * Get a list of known keys.
+ *
+ * @return A list of known keys of which states will be reported.
+ */
+ const QList<Qt::Key> knownKeys() const;
+
+ /**
+ * Synchronously check if a key is pressed.
+ *
+ * @param key The key to check
+ * @return true if the key is pressed, false if the key is not pressed or unknown.
+ * @see isKeyLatched, @see isKeyLocked, @see keyPressed
+ */
+ bool isKeyPressed(Qt::Key key) const;
+
+ /**
+ * Synchronously check if a key is latched.
+ *
+ * @param key The key to check
+ * @return true if the key is latched, false if the key is not latched or unknown.
+ * @see isKeyPressed, @see isKeyLocked, @see keyLatched
+ */
+ bool isKeyLatched(Qt::Key key) const;
+
+ /**
+ * Set the latched state of a key.
+ *
+ * @param key The key to latch
+ * @param latched true to latch the key, false to unlatch it.
+ * @return false if the key is unknown. true doesn't guarantee you the
+ * operation worked.
+ */
+ bool setKeyLatched(Qt::Key key, bool latched);
+
+ /**
+ * Synchronously check if a key is locked.
+ *
+ * @param key The key to check
+ * @return true if the key is locked, false if the key is not locked or unknown.
+ * @see isKeyPressed, @see isKeyLatched, @see keyLocked
+ */
+ bool isKeyLocked(Qt::Key key) const;
+
+ /**
+ * Set the locked state of a key.
+ *
+ * @param key The key to lock
+ * @param latched true to lock the key, false to unlock it.
+ * @return false if the key is unknown. true doesn't guarantee you the
+ * operation worked.
+ */
+ bool setKeyLocked(Qt::Key key, bool locked);
+
+ /**
+ * Synchronously check if a mouse button is pressed.
+ *
+ * @param button The mouse button to check
+ * @return true if the mouse button is pressed, false if the mouse button
+ * is not pressed or its state is unknown.
+ */
+ bool isButtonPressed(Qt::MouseButton button) const;
+
+Q_SIGNALS:
+ /**
+ * This signal is emitted whenever the pressed state of a key changes
+ * (key press or key release).
+ *
+ * @param key The key that changed state
+ * @param pressed true if the key is now pressed, false if is released.
+ */
+ void keyPressed(Qt::Key key, bool pressed);
+
+ /**
+ * This signal is emitted whenever the latched state of a key changes.
+ *
+ * @param key The key that changed state
+ * @param latched true if the key is now latched, false if it isn't
+ */
+ void keyLatched(Qt::Key key, bool latched);
+
+ /**
+ * This signal is emitted whenever the locked state of a key changes.
+ *
+ * @param key The key that changed state
+ * @param locked true if the key is now locked, false if it isn't
+ */
+ void keyLocked(Qt::Key key, bool locked);
+
+ /**
+ * This signal is emitted whenever the pressed state of a mouse button
+ * changes (mouse button press or release).
+ *
+ * @param button The mouse button that changed state
+ * @param pressed true if the mouse button is now pressed, false if
+ * is released.
+ */
+ void buttonPressed(Qt::MouseButton button, bool pressed);
+
+ /**
+ * This signal is emitted whenever a new modifier is found due to
+ * the keyboard mapping changing.
+ *
+ * @param key The key that was discovered
+ */
+ void keyAdded(Qt::Key key);
+
+ /**
+ * This signal is emitted whenever a previously known modifier no
+ * longer exists due to the keyboard mapping changing.
+ *
+ * @param key The key that vanished
+ */
+ void keyRemoved(Qt::Key key);
+
+private:
+ Q_DISABLE_COPY(KModifierKeyInfo)
+ KModifierKeyInfoProvider *const p; // krazy:exclude=dpointer
+};
+
+#endif
--- /dev/null
+/*
+ Copyright 2009 Michael Leupold <lemma@confuego.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "kmodifierkeyinfoprovider_p.h"
+
+bool KModifierKeyInfoProvider::isKeyPressed(Qt::Key key) const
+{
+ if (m_modifierStates.contains(key)) {
+ return m_modifierStates[key] & Pressed;
+ }
+ return false;
+}
+
+bool KModifierKeyInfoProvider::isKeyLatched(Qt::Key key) const
+{
+ if (m_modifierStates.contains(key)) {
+ return m_modifierStates[key] & Latched;
+ }
+ return false;
+}
+
+bool KModifierKeyInfoProvider::isKeyLocked(Qt::Key key) const
+{
+ if (m_modifierStates.contains(key)) {
+ return m_modifierStates[key] & Locked;
+ }
+ return false;
+}
+
+bool KModifierKeyInfoProvider::isButtonPressed(Qt::MouseButton button) const
+{
+ if (m_buttonStates.contains(button)) {
+ return m_buttonStates[button];
+ }
+ return false;
+}
+
+bool KModifierKeyInfoProvider::knowsKey(Qt::Key key) const
+{
+ return m_modifierStates.contains(key);
+}
+
+const QList<Qt::Key> KModifierKeyInfoProvider::knownKeys() const
+{
+ return m_modifierStates.keys();
+}
+
+#include "moc_kmodifierkeyinfoprovider_p.cpp"
--- /dev/null
+/*
+ Copyright 2009 Michael Leupold <lemma@confuego.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "kmodifierkeyinfo.h"
+#include "kmodifierkeyinfoprovider_p.h"
+
+KModifierKeyInfoProvider::KModifierKeyInfoProvider()
+ : QObject(0)
+{
+}
+
+KModifierKeyInfoProvider::~KModifierKeyInfoProvider()
+{
+}
+
+bool KModifierKeyInfoProvider::setKeyLatched(Qt::Key key, bool latched)
+{
+ Q_UNUSED(key);
+ Q_UNUSED(latched);
+ return false;
+}
+
+bool KModifierKeyInfoProvider::setKeyLocked(Qt::Key key, bool locked)
+{
+ Q_UNUSED(key);
+ Q_UNUSED(locked);
+ return false;
+}
+
+bool KModifierKeyInfoProvider::nativeEventFilter(const QByteArray &eventType, void *message, long int *result)
+{
+ Q_UNUSED(eventType)
+ Q_UNUSED(message)
+ Q_UNUSED(result)
+ return false;
+}
--- /dev/null
+/*
+ Copyright 2009 Michael Leupold <lemma@confuego.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef KMODIFIERKEYINFOPROVIDER_P_H
+#define KMODIFIERKEYINFOPROVIDER_P_H
+
+#include <QAbstractNativeEventFilter>
+#include <QHash>
+#include <QObject>
+
+/**
+ * Background class that implements the behaviour of KModifierKeyInfo for
+ * the different supported platforms.
+ * @internal
+ */
+class KModifierKeyInfoProvider : public QObject, public QAbstractNativeEventFilter
+{
+ Q_OBJECT
+
+public:
+ enum ModifierState {
+ Nothing = 0x0,
+ Pressed = 0x1,
+ Latched = 0x2,
+ Locked = 0x4
+ };
+ Q_DECLARE_FLAGS(ModifierStates, ModifierState)
+
+ KModifierKeyInfoProvider();
+ ~KModifierKeyInfoProvider() override;
+
+ /**
+ * Detect if a key is pressed.
+ * @param key Modifier key to query
+ * @return true if the key is pressed, false if it isn't.
+ */
+ bool isKeyPressed(Qt::Key key) const;
+
+ /**
+ * Detect if a key is latched.
+ * @param key Modifier key to query
+ * @return true if the key is latched, false if it isn't.
+ */
+ bool isKeyLatched(Qt::Key key) const;
+
+ /**
+ * Set the latched state of a key.
+ * @param key Modifier to set the latched state for
+ * @param latched true to latch the key, false to unlatch it
+ * @return true if the key is known, false else
+ */
+ bool setKeyLatched(Qt::Key key, bool latched);
+
+ /**
+ * Detect if a key is locked.
+ * @param key Modifier key to query
+ * @return true if the key is locked, false if it isn't.
+ */
+ bool isKeyLocked(Qt::Key key) const;
+
+ /**
+ * Set the locked state of a key.
+ * @param key Modifier to set the locked state for
+ * @param latched true to lock the key, false to unlock it
+ * @return true if the key is known, false else
+ */
+ bool setKeyLocked(Qt::Key key, bool locked);
+
+ /**
+ * Check if a mouse button is pressed.
+ * @param button Mouse button to check
+ * @return true if pressed, false else
+ */
+ bool isButtonPressed(Qt::MouseButton button) const;
+
+ /**
+ * Check if a key is known/can be queried
+ * @param key Modifier key to check
+ * @return true if the key is known, false if it isn't.
+ */
+ bool knowsKey(Qt::Key key) const;
+
+ /**
+ * Get a list of known keys
+ * @return List of known keys.
+ */
+ const QList<Qt::Key> knownKeys() const;
+
+ bool nativeEventFilter(const QByteArray &eventType, void *message, long int *result) override;
+
+Q_SIGNALS:
+ void keyLatched(Qt::Key key, bool state);
+ void keyLocked(Qt::Key key, bool state);
+ void keyPressed(Qt::Key key, bool state);
+ void buttonPressed(Qt::MouseButton button, bool state);
+ void keyAdded(Qt::Key key);
+ void keyRemoved(Qt::Key key);
+
+protected:
+ void xkbUpdateModifierMapping();
+ void xkbModifierStateChanged(unsigned char mods, unsigned char latched_mods,
+ unsigned char locked_mods);
+ void xkbButtonStateChanged(unsigned short ptr_buttons);
+
+private:
+ // the state of each known modifier
+ QHash<Qt::Key, ModifierStates> m_modifierStates;
+ // the state of each known mouse button
+ QHash<Qt::MouseButton, bool> m_buttonStates;
+
+ int m_xkbEv;
+ bool m_xkbAvailable;
+
+ // maps a Qt::Key to a modifier mask
+ QHash<Qt::Key, unsigned int> m_xkbModifiers;
+ // maps a Qt::MouseButton to a button mask
+ QHash<Qt::MouseButton, unsigned short> m_xkbButtons;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(KModifierKeyInfoProvider::ModifierStates)
+
+#endif
--- /dev/null
+/*
+ Copyright 2009 Michael Leupold <lemma@confuego.org>
+ Copyright 2013 Martin Gräßlin <mgraesslin@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "kmodifierkeyinfo.h"
+#include "kmodifierkeyinfoprovider_p.h"
+
+#include <QGuiApplication>
+#include <QX11Info>
+
+#define XK_MISCELLANY
+#define XK_XKB_KEYS
+#include <X11/XKBlib.h>
+#include <X11/keysymdef.h>
+#include <xcb/xcb.h>
+
+struct ModifierDefinition {
+ ModifierDefinition(Qt::Key _key, unsigned int _mask, const char *_name, KeySym _keysym)
+ {
+ key = _key;
+ mask = _mask;
+ name = _name;
+ keysym = _keysym;
+ }
+ Qt::Key key;
+ unsigned int mask;
+ const char *name; // virtual modifier name
+ KeySym keysym;
+};
+
+/*
+ * Get the real modifiers related to a virtual modifier.
+ */
+unsigned int xkbVirtualModifier(XkbDescPtr xkb, const char *name)
+{
+ Q_ASSERT(xkb != nullptr);
+
+ unsigned int mask = 0;
+ bool nameEqual;
+ for (int i = 0; i < XkbNumVirtualMods; ++i) {
+ char *modStr = XGetAtomName(xkb->dpy, xkb->names->vmods[i]);
+ if (modStr != nullptr) {
+ nameEqual = (strcmp(name, modStr) == 0);
+ XFree(modStr);
+ if (nameEqual) {
+ XkbVirtualModsToReal(xkb, 1 << i, &mask);
+ break;
+ }
+ }
+ }
+ return mask;
+}
+
+KModifierKeyInfoProvider::KModifierKeyInfoProvider()
+ : QObject(nullptr)
+ , QAbstractNativeEventFilter()
+ , m_xkbEv(0)
+ , m_xkbAvailable(false)
+{
+ if (qApp) {
+ if (qApp->platformName() == QStringLiteral("xcb")) {
+ int code, xkberr, maj, min;
+ m_xkbAvailable = XkbQueryExtension(QX11Info::display(), &code, &m_xkbEv, &xkberr, &maj, &min);
+ }
+ }
+ if (m_xkbAvailable) {
+ XkbSelectEvents(QX11Info::display(), XkbUseCoreKbd,
+ XkbStateNotifyMask | XkbMapNotifyMask,
+ XkbStateNotifyMask | XkbMapNotifyMask);
+ unsigned long int stateMask = XkbModifierStateMask | XkbModifierBaseMask |
+ XkbModifierLatchMask | XkbModifierLockMask |
+ XkbPointerButtonMask;
+ XkbSelectEventDetails(QX11Info::display(), XkbUseCoreKbd, XkbStateNotifyMask,
+ stateMask, stateMask);
+ }
+
+ xkbUpdateModifierMapping();
+
+ // add known pointer buttons
+ m_xkbButtons.insert(Qt::LeftButton, Button1Mask);
+ m_xkbButtons.insert(Qt::MidButton, Button2Mask);
+ m_xkbButtons.insert(Qt::RightButton, Button3Mask);
+ m_xkbButtons.insert(Qt::XButton1, Button4Mask);
+ m_xkbButtons.insert(Qt::XButton2, Button5Mask);
+
+ // get the initial state
+ if (m_xkbAvailable) {
+ XkbStateRec state;
+ XkbGetState(QX11Info::display(), XkbUseCoreKbd, &state);
+ xkbModifierStateChanged(state.mods, state.latched_mods, state.locked_mods);
+ xkbButtonStateChanged(state.ptr_buttons);
+
+ QCoreApplication::instance()->installNativeEventFilter(this);
+ }
+}
+
+KModifierKeyInfoProvider::~KModifierKeyInfoProvider()
+{
+ if (m_xkbAvailable) {
+ QCoreApplication::instance()->removeNativeEventFilter(this);
+ }
+}
+
+bool KModifierKeyInfoProvider::setKeyLatched(Qt::Key key, bool latched)
+{
+ if (!m_xkbModifiers.contains(key)) {
+ return false;
+ }
+
+ return XkbLatchModifiers(QX11Info::display(), XkbUseCoreKbd,
+ m_xkbModifiers[key], latched ? m_xkbModifiers[key] : 0);
+}
+
+bool KModifierKeyInfoProvider::setKeyLocked(Qt::Key key, bool locked)
+{
+ if (!m_xkbModifiers.contains(key)) {
+ return false;
+ }
+
+ return XkbLockModifiers(QX11Info::display(), XkbUseCoreKbd,
+ m_xkbModifiers[key], locked ? m_xkbModifiers[key] : 0);
+}
+
+// HACK: xcb-xkb is not yet a public part of xcb. Because of that we have to include the event structure.
+namespace
+{
+typedef struct _xcb_xkb_map_notify_event_t {
+ uint8_t response_type;
+ uint8_t xkbType;
+ uint16_t sequence;
+ xcb_timestamp_t time;
+ uint8_t deviceID;
+ uint8_t ptrBtnActions;
+ uint16_t changed;
+ xcb_keycode_t minKeyCode;
+ xcb_keycode_t maxKeyCode;
+ uint8_t firstType;
+ uint8_t nTypes;
+ xcb_keycode_t firstKeySym;
+ uint8_t nKeySyms;
+ xcb_keycode_t firstKeyAct;
+ uint8_t nKeyActs;
+ xcb_keycode_t firstKeyBehavior;
+ uint8_t nKeyBehavior;
+ xcb_keycode_t firstKeyExplicit;
+ uint8_t nKeyExplicit;
+ xcb_keycode_t firstModMapKey;
+ uint8_t nModMapKeys;
+ xcb_keycode_t firstVModMapKey;
+ uint8_t nVModMapKeys;
+ uint16_t virtualMods;
+ uint8_t pad0[2];
+} _xcb_xkb_map_notify_event_t;
+typedef struct _xcb_xkb_state_notify_event_t {
+ uint8_t response_type;
+ uint8_t xkbType;
+ uint16_t sequence;
+ xcb_timestamp_t time;
+ uint8_t deviceID;
+ uint8_t mods;
+ uint8_t baseMods;
+ uint8_t latchedMods;
+ uint8_t lockedMods;
+ uint8_t group;
+ int16_t baseGroup;
+ int16_t latchedGroup;
+ uint8_t lockedGroup;
+ uint8_t compatState;
+ uint8_t grabMods;
+ uint8_t compatGrabMods;
+ uint8_t lookupMods;
+ uint8_t compatLoockupMods;
+ uint16_t ptrBtnState;
+ uint16_t changed;
+ xcb_keycode_t keycode;
+ uint8_t eventType;
+ uint8_t requestMajor;
+ uint8_t requestMinor;
+} _xcb_xkb_state_notify_event_t;
+typedef union {
+ /* All XKB events share these fields. */
+ struct {
+ uint8_t response_type;
+ uint8_t xkbType;
+ uint16_t sequence;
+ xcb_timestamp_t time;
+ uint8_t deviceID;
+ } any;
+ _xcb_xkb_map_notify_event_t map_notify;
+ _xcb_xkb_state_notify_event_t state_notify;
+} _xkb_event;
+}
+
+bool KModifierKeyInfoProvider::nativeEventFilter(const QByteArray &eventType, void *message, long int *result)
+{
+ Q_UNUSED(result)
+ if (!m_xkbAvailable || eventType != "xcb_generic_event_t") {
+ return false;
+ }
+ xcb_generic_event_t *event = static_cast<xcb_generic_event_t *>(message);
+ if ((event->response_type & ~0x80) == m_xkbEv + XkbEventCode) {
+ _xkb_event *kbevt = reinterpret_cast<_xkb_event *>(event);
+ unsigned int stateMask = XkbModifierStateMask | XkbModifierBaseMask |
+ XkbModifierLatchMask | XkbModifierLockMask;
+ if (kbevt->any.xkbType == XkbMapNotify) {
+ xkbUpdateModifierMapping();
+ } else if (kbevt->any.xkbType == XkbStateNotify) {
+ if (kbevt->state_notify.changed & stateMask) {
+ xkbModifierStateChanged(kbevt->state_notify.mods, kbevt->state_notify.latchedMods,
+ kbevt->state_notify.lockedMods);
+ } else if (kbevt->state_notify.changed & XkbPointerButtonMask) {
+ xkbButtonStateChanged(kbevt->state_notify.ptrBtnState);
+ }
+ }
+ }
+ return false;
+}
+
+void KModifierKeyInfoProvider::xkbModifierStateChanged(unsigned char mods,
+ unsigned char latched_mods,
+ unsigned char locked_mods)
+{
+ // detect keyboard modifiers
+ ModifierStates oldState;
+ ModifierStates newState;
+
+ QHash<Qt::Key, unsigned int>::const_iterator it;
+ QHash<Qt::Key, unsigned int>::const_iterator end = m_xkbModifiers.constEnd();
+ for (it = m_xkbModifiers.constBegin(); it != end; ++it) {
+ if (!m_modifierStates.contains(it.key())) {
+ continue;
+ }
+ newState = Nothing;
+ oldState = m_modifierStates[it.key()];
+
+ // determine the new state
+ if (mods & it.value()) {
+ newState |= Pressed;
+ }
+ if (latched_mods & it.value()) {
+ newState |= Latched;
+ }
+ if (locked_mods & it.value()) {
+ newState |= Locked;
+ }
+
+ if (newState != oldState) {
+ m_modifierStates[it.key()] = newState;
+
+ if ((newState ^ oldState) & Pressed) {
+ emit keyPressed(it.key(), newState & Pressed);
+ }
+ if ((newState ^ oldState) & Latched) {
+ emit keyLatched(it.key(), newState & Latched);
+ }
+ if ((newState ^ oldState) & Locked) {
+ emit keyLocked(it.key(), newState & Locked);
+ }
+ }
+ }
+}
+
+void KModifierKeyInfoProvider::xkbButtonStateChanged(unsigned short ptr_buttons)
+{
+ // detect mouse button states
+ bool newButtonState;
+
+ QHash<Qt::MouseButton, unsigned short>::const_iterator it;
+ QHash<Qt::MouseButton, unsigned short>::const_iterator end = m_xkbButtons.constEnd();
+ for (it = m_xkbButtons.constBegin(); it != end; ++it) {
+ newButtonState = (ptr_buttons & it.value());
+ if (newButtonState != m_buttonStates[it.key()]) {
+ m_buttonStates[it.key()] = newButtonState;
+ emit buttonPressed(it.key(), newButtonState);
+ }
+ }
+}
+
+void KModifierKeyInfoProvider::xkbUpdateModifierMapping()
+{
+ if (!m_xkbAvailable) {
+ return;
+ }
+ m_xkbModifiers.clear();
+
+ QList<ModifierDefinition> srcModifiers;
+ srcModifiers << ModifierDefinition(Qt::Key_Shift, ShiftMask, nullptr, 0)
+ << ModifierDefinition(Qt::Key_Control, ControlMask, nullptr, 0)
+ << ModifierDefinition(Qt::Key_Alt, 0, "Alt", XK_Alt_L)
+ // << { 0, 0, I18N_NOOP("Win"), "superkey", "" }
+ << ModifierDefinition(Qt::Key_Meta, 0, "Meta", XK_Meta_L)
+ << ModifierDefinition(Qt::Key_Super_L, 0, "Super", XK_Super_L)
+ << ModifierDefinition(Qt::Key_Hyper_L, 0, "Hyper", XK_Hyper_L)
+ << ModifierDefinition(Qt::Key_AltGr, 0, "AltGr", 0)
+ << ModifierDefinition(Qt::Key_NumLock, 0, "NumLock", XK_Num_Lock)
+ << ModifierDefinition(Qt::Key_CapsLock, LockMask, nullptr, 0)
+ << ModifierDefinition(Qt::Key_ScrollLock, 0, "ScrollLock", XK_Scroll_Lock);
+
+ XkbDescPtr xkb = XkbGetKeyboard(QX11Info::display(), XkbAllComponentsMask, XkbUseCoreKbd);
+
+ QList<ModifierDefinition>::const_iterator it;
+ QList<ModifierDefinition>::const_iterator end = srcModifiers.constEnd();
+ for (it = srcModifiers.constBegin(); it != end; ++it) {
+ unsigned int mask = it->mask;
+ if (mask == 0 && xkb != nullptr) {
+ // try virtual modifier first
+ if (it->name != nullptr) {
+ mask = xkbVirtualModifier(xkb, it->name);
+ }
+ if (mask == 0 && it->keysym != 0) {
+ mask = XkbKeysymToModifiers(QX11Info::display(), it->keysym);
+ } else if (mask == 0) {
+ // special case for AltGr
+ mask = XkbKeysymToModifiers(QX11Info::display(), XK_Mode_switch) |
+ XkbKeysymToModifiers(QX11Info::display(), XK_ISO_Level3_Shift) |
+ XkbKeysymToModifiers(QX11Info::display(), XK_ISO_Level3_Latch) |
+ XkbKeysymToModifiers(QX11Info::display(), XK_ISO_Level3_Lock);
+ }
+ }
+
+ if (mask != 0) {
+ m_xkbModifiers.insert(it->key, mask);
+ // previously unknown modifier
+ if (!m_modifierStates.contains(it->key)) {
+ m_modifierStates.insert(it->key, Nothing);
+ emit keyAdded(it->key);
+ }
+ }
+ }
+
+ // remove modifiers which are no longer available
+ QMutableHashIterator<Qt::Key, ModifierStates> i(m_modifierStates);
+ while (i.hasNext()) {
+ i.next();
+ if (!m_xkbModifiers.contains(i.key())) {
+ Qt::Key key = i.key();
+ i.remove();
+ emit keyRemoved(key);
+ }
+ }
+
+ if (xkb != nullptr) {
+ XkbFreeKeyboard(xkb, 0, true);
+ }
+}
--- /dev/null
+/*********************************************************************************
+ * *
+ * Copyright (C) 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.com> *
+ * *
+ * This library is free software; you can redistribute it and/or *
+ * modify it under the terms of the GNU Lesser General Public *
+ * License as published by the Free Software Foundation; either *
+ * version 2.1 of the License, or (at your option) version 3, or any *
+ * later version accepted by the membership of KDE e.V. (or its *
+ * successor approved by the membership of KDE e.V.), which shall *
+ * act as a proxy defined in Section 6 of version 3 of the license. *
+ * *
+ * This library is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
+ * Lesser General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU Lesser General Public *
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>. *
+ * *
+ *********************************************************************************/
+
+#include <QObject>
+#include <QUrl>
+#include <QStandardPaths>
+#include <QCoreApplication>
+#include <QProcess>
+#include <QDesktopServices>
+#include <QLocale>
+
+class UrlHandler : public QObject
+{
+ Q_OBJECT
+public:
+ explicit UrlHandler(QObject *parent = nullptr) : QObject(parent) {}
+
+public Q_SLOTS:
+ void openHelp(const QUrl &url)
+ {
+ QUrl u(url);
+ if (u.path() == QLatin1String("/")) {
+ u.setPath(QCoreApplication::applicationName());
+ }
+
+ const QString helpcenter = QStandardPaths::findExecutable(QStringLiteral("khelpcenter"));
+ if (helpcenter.isEmpty()) {
+ if (QCoreApplication::organizationDomain() == QLatin1String("kde.org")) {
+ //if khelpcenter is not installed and it's a KDE application, use docs.kde.org
+ const QUrl httpUrl(QStringLiteral("https://docs.kde.org/index.php?branch=stable5&language=")+QLocale().name()+QStringLiteral("&application=") +
+ QCoreApplication::applicationName() + QStringLiteral("&path=") + url.path());
+ QDesktopServices::openUrl(httpUrl);
+ } else
+ QDesktopServices::openUrl(u);
+ } else {
+ QProcess::startDetached(helpcenter, QStringList(u.toString()));
+ }
+ }
+};
+
+Q_GLOBAL_STATIC(UrlHandler, s_handler)
+
+static void initializeGlobalSettings()
+{
+ QDesktopServices::setUrlHandler(QStringLiteral("help"), s_handler, "openHelp");
+}
+
+Q_COREAPP_STARTUP_FUNCTION(initializeGlobalSettings)
+
+#include "urlhandler.moc"
--- /dev/null
+remove_definitions(-DQT_NO_CAST_FROM_ASCII)
+remove_definitions(-DQT_NO_CAST_TO_ASCII)
+
+include(ECMMarkAsTest)
+
+find_package(Qt5 ${REQUIRED_QT_VERSION} CONFIG REQUIRED Test Widgets)
+
+macro(kguiaddons_executable_tests)
+ foreach(_testname ${ARGN})
+ add_executable(${_testname} ${_testname}.cpp)
+ target_link_libraries(${_testname} Qt5::Widgets KF5::GuiAddons)
+ ecm_mark_as_test(${_testname})
+ endforeach(_testname)
+endmacro()
+
+kguiaddons_executable_tests(
+ kcolorcollectiontest
+ kmodifierkeyinfotest
+ openurltest
+)
--- /dev/null
+
+#include <QWidget>
+#include <QTimer>
+#include <QApplication>
+#include <QStringList>
+
+#include <kcolorcollection.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+ QApplication::setApplicationName(QStringLiteral("KColorCollectionTest"));
+ QApplication a(argc, argv);
+
+ QStringList collections = KColorCollection::installedCollections();
+ for (QStringList::ConstIterator it = collections.constBegin();
+ it != collections.constEnd(); ++it) {
+ printf("Palette = %s\n", (*it).toLatin1().constData());
+
+ KColorCollection myColorCollection = KColorCollection(*it);
+
+ printf("Palette Name = \"%s\"\n", myColorCollection.name().toLatin1().constData());
+ printf("Description:\n\"%s\"\n", myColorCollection.description().toLatin1().constData());
+ printf("Nr of Colors = %d\n", myColorCollection.count());
+ for (int i = 0; i < myColorCollection.count(); i++) {
+ int r, g, b;
+ myColorCollection.color(i).getRgb(&r, &g, &b);
+ printf("#%d Name = \"%s\" #%02x%02x%02x\n",
+ i, myColorCollection.name(i).toLatin1().constData(), r, g, b);
+ }
+ }
+}
+
--- /dev/null
+/*
+ Copyright 2009 Michael Leupold <lemma@confuego.org>
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License or (at your option) version 3 or any later version
+ accepted by the membership of KDE e.V. (or its successor approved
+ by the membership of KDE e.V.), which shall act as a proxy
+ defined in Section 14 of version 3 of the license.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <QApplication>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QMap>
+#include <QWidget>
+#include <QPushButton>
+#include <QDebug>
+#include <QCheckBox>
+
+#include "kmodifierkeyinfo.h"
+
+template <typename A, typename B, typename C>
+class Triple
+{
+public:
+ Triple() {}
+ Triple(const A _first, const B _second, const C _third)
+ : first(_first), second(_second), third(_third) {};
+ A first;
+ B second;
+ C third;
+};
+
+class TestWidget : public QWidget
+{
+ Q_OBJECT
+
+public:
+ TestWidget();
+
+protected Q_SLOTS:
+ void keyPressed(Qt::Key key, bool state);
+ void keyLatched(Qt::Key key, bool state);
+ void keyLocked(Qt::Key key, bool state);
+ void mouseButtonPressed(Qt::MouseButton button, bool state);
+ void latch();
+ void lock();
+ void keyAdded(Qt::Key)
+ {
+ qDebug() << "Key added";
+ }
+ void keyRemoved(Qt::Key)
+ {
+ qDebug() << "Key removed";
+ }
+
+private:
+ KModifierKeyInfo m_lock;
+ QMap<Qt::Key, Triple<QCheckBox *, QCheckBox *, QCheckBox *> > m_leds;
+ QMap<Qt::MouseButton, QCheckBox *> m_mouseLeds;
+};
+
+TestWidget::TestWidget() : QWidget(nullptr), m_lock(this)
+{
+ QMap<Qt::Key, QString> mods;
+ mods.insert(Qt::Key_Shift, QStringLiteral("Shift"));
+ mods.insert(Qt::Key_Control, QStringLiteral("Ctrl"));
+ mods.insert(Qt::Key_Alt, QStringLiteral("Alt"));
+ mods.insert(Qt::Key_Meta, QStringLiteral("Meta"));
+ mods.insert(Qt::Key_Super_L, QStringLiteral("Super"));
+ mods.insert(Qt::Key_Hyper_L, QStringLiteral("Hyper"));
+ mods.insert(Qt::Key_AltGr, QStringLiteral("AltGr"));
+ mods.insert(Qt::Key_NumLock, QStringLiteral("NumLock"));
+ mods.insert(Qt::Key_CapsLock, QStringLiteral("CapsLock"));
+ mods.insert(Qt::Key_ScrollLock, QStringLiteral("ScrollLock"));
+
+ QMap<Qt::MouseButton, QString> buttons;
+ buttons.insert(Qt::LeftButton, QStringLiteral("Left Button"));
+ buttons.insert(Qt::RightButton, QStringLiteral("Right Button"));
+ buttons.insert(Qt::MidButton, QStringLiteral("Middle Button"));
+ buttons.insert(Qt::XButton1, QStringLiteral("First X Button"));
+ buttons.insert(Qt::XButton2, QStringLiteral("Second X Button"));
+
+ QVBoxLayout *layout = new QVBoxLayout(this);
+
+ QMap<Qt::Key, QString>::const_iterator it;
+ QMap<Qt::Key, QString>::const_iterator end = mods.constEnd();
+ for (it = mods.constBegin(); it != end; ++it) {
+ if (m_lock.knowsKey(it.key())) {
+ QHBoxLayout *hlayout = new QHBoxLayout;
+ QCheckBox *pressed = new QCheckBox(this);
+ QCheckBox *latched = new QCheckBox(this);
+ QCheckBox *locked = new QCheckBox(this);
+ QPushButton *latch = new QPushButton(QStringLiteral("latch"), this);
+ latch->setProperty("modifier", it.key());
+ connect(latch, &QAbstractButton::clicked, this, &TestWidget::latch);
+ QPushButton *lock = new QPushButton(QStringLiteral("lock"), this);
+ lock->setProperty("modifier", it.key());
+ connect(lock, &QAbstractButton::clicked, this, &TestWidget::lock);
+ pressed->setChecked(m_lock.isKeyPressed(it.key()));
+ latched->setChecked(m_lock.isKeyLatched(it.key()));
+ locked->setChecked(m_lock.isKeyLocked(it.key()));
+ m_leds.insert(it.key(), Triple<QCheckBox *, QCheckBox *, QCheckBox *>(pressed, latched, locked));
+ hlayout->addWidget(pressed);
+ hlayout->addWidget(latched);
+ hlayout->addWidget(locked);
+ hlayout->addWidget(new QLabel(it.value()));
+ hlayout->addWidget(latch);
+ hlayout->addWidget(lock);
+ layout->addLayout(hlayout);
+ }
+ }
+
+ QMap<Qt::MouseButton, QString>::const_iterator it2;
+ QMap<Qt::MouseButton, QString>::const_iterator end2 = buttons.constEnd();
+ for (it2 = buttons.constBegin(); it2 != end2; ++it2) {
+ QHBoxLayout *hlayout = new QHBoxLayout;
+ QCheckBox *pressed = new QCheckBox(this);
+ pressed->setChecked(m_lock.isButtonPressed(it2.key()));
+ m_mouseLeds.insert(it2.key(), pressed);
+ hlayout->addWidget(pressed);
+ hlayout->addWidget(new QLabel(it2.value()));
+ layout->addLayout(hlayout);
+ }
+
+ setLayout(layout);
+
+ connect(&m_lock, &KModifierKeyInfo::keyPressed,
+ this, &TestWidget::keyPressed);
+ connect(&m_lock, &KModifierKeyInfo::keyLatched,
+ this, &TestWidget::keyLatched);
+ connect(&m_lock, &KModifierKeyInfo::keyLocked,
+ this, &TestWidget::keyLocked);
+ connect(&m_lock, &KModifierKeyInfo::buttonPressed,
+ this, &TestWidget::mouseButtonPressed);
+ connect(&m_lock, &KModifierKeyInfo::keyAdded,
+ this, &TestWidget::keyAdded);
+ connect(&m_lock, &KModifierKeyInfo::keyRemoved,
+ this, &TestWidget::keyRemoved);
+}
+
+void TestWidget::keyPressed(Qt::Key key, bool pressed)
+{
+ if (m_leds.contains(key)) {
+ m_leds[key].first->setChecked(pressed);
+ }
+}
+
+void TestWidget::keyLatched(Qt::Key key, bool latched)
+{
+ if (m_leds.contains(key)) {
+ m_leds[key].second->setChecked(latched);
+ }
+}
+
+void TestWidget::keyLocked(Qt::Key key, bool locked)
+{
+ if (m_leds.contains(key)) {
+ m_leds[key].third->setChecked(locked);
+ }
+}
+
+void TestWidget::mouseButtonPressed(Qt::MouseButton button, bool pressed)
+{
+ if (m_mouseLeds.contains(button)) {
+ m_mouseLeds[button]->setChecked(pressed);
+ }
+}
+
+void TestWidget::latch()
+{
+ Qt::Key key = (Qt::Key)sender()->property("modifier").toInt();
+ m_lock.setKeyLatched(key, !m_lock.isKeyLatched(key));
+}
+
+void TestWidget::lock()
+{
+ Qt::Key key = (Qt::Key)sender()->property("modifier").toInt();
+ m_lock.setKeyLocked(key, !m_lock.isKeyLocked(key));
+}
+
+int main(int argc, char *argv[])
+{
+ QApplication::setApplicationName(QStringLiteral("simple"));
+
+ QApplication app(argc, argv);
+ TestWidget mainWidget;
+ mainWidget.show();
+
+ return app.exec();
+}
+
+#include "kmodifierkeyinfotest.moc"
--- /dev/null
+/* This file is part of the KDE libraries
+ * Copyright 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.com>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2 of the License or ( at
+ * your option ) version 3 or, at the discretion of KDE e.V. ( which shall
+ * act as a proxy as in section 14 of the GPLv3 ), any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QDesktopServices>
+#include <QGuiApplication>
+#include <QDebug>
+#include <QUrl>
+
+int main(int argc, char **argv)
+{
+ QGuiApplication app(argc, argv);
+ if (app.arguments().count() <= 1 || app.arguments().last() == QStringLiteral("--help")) {
+ qDebug() << "please use ./openurltest <url>";
+ return 0;
+ }
+ QDesktopServices::openUrl(QUrl(app.arguments().last()));
+
+ QMetaObject::invokeMethod(&app, "quit", Qt::QueuedConnection);
+ return app.exec();
+}
projects / kguiaddons.git / commitdiff