File _service:obs_scm:plasma-active-window-control-1... of Package plasma-applet-active-window-control

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:plasma-active-window-control-116.7736a87.obscpio of Package plasma-applet-active-window-control

07070100000000000081A40000000000000000000000016626CF9D00000038000000000000000000000000000000000000004000000000plasma-active-window-control-116.7736a87/.git-blame-ignore-revs# clang-format
d191b4e5d50df6c04131f64ed0e0aa0fb5ec4dda
07070100000001000081A40000000000000000000000016626CF9D0000001E000000000000000000000000000000000000003400000000plasma-active-window-control-116.7736a87/.gitignorebuild/
update-translations.sh
07070100000002000081A40000000000000000000000016626CF9D000000CB000000000000000000000000000000000000003800000000plasma-active-window-control-116.7736a87/.gitlab-ci.yml# SPDX-FileCopyrightText: None
# SPDX-License-Identifier: CC0-1.0

include:
  - project: sysadmin/ci-utilities
    file:
      - /gitlab-templates/linux-qt6.yml
      - /gitlab-templates/freebsd-qt6.yml
07070100000003000081A40000000000000000000000016626CF9D0000046B000000000000000000000000000000000000003500000000plasma-active-window-control-116.7736a87/.kde-ci.yml# SPDX-FileCopyrightText: None
# SPDX-License-Identifier: CC0-1.0

Dependencies:
- 'on': ['@all']
  'require':
    'frameworks/extra-cmake-modules': '@latest-kf6'
    'frameworks/kconfig': '@latest-kf6'
    'frameworks/kdoctools': '@latest-kf6'
    'frameworks/kio': '@latest-kf6'
    'frameworks/ki18n': '@latest-kf6'
    'frameworks/kwidgetsaddons': '@latest-kf6'
    'frameworks/karchive': '@latest-kf6'
    'frameworks/kcoreaddons': '@latest-kf6'
    'frameworks/kguiaddons': '@latest-kf6'
    'frameworks/kdbusaddons': '@latest-kf6'
    'frameworks/kcrash': '@latest-kf6'
    'frameworks/kdeclarative': '@latest-kf6'
    'frameworks/kglobalaccel': '@latest-kf6'
    'frameworks/kirigami': '@latest-kf6'
    'frameworks/ki18n': '@latest-kf6'
    'frameworks/kiconthemes': '@latest-kf6'
    'frameworks/knewstuff': '@latest-kf6'
    'frameworks/knotifications': '@latest-kf6'
    'frameworks/kwindowsystem': '@latest-kf6'
    'frameworks/kxmlgui': '@latest-kf6'
    'plasma/kwayland': '@latest-kf6'
    'plasma/libplasma': '@latest-kf6'
    'plasma/plasma-workspace': '@latest-kf6'
    'plasma/plasma-activities': '@latest-kf6'
07070100000004000081A40000000000000000000000016626CF9D000003F1000000000000000000000000000000000000003800000000plasma-active-window-control-116.7736a87/CMakeLists.txtcmake_minimum_required(VERSION 3.16)

set(QT_MIN_VERSION "6.0.0")
set(KF6_MIN_VERSION "6.0.0")

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(ECM 0.0.11 REQUIRED NO_MODULE)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDECompilerSettings)
include(ECMQtDeclareLoggingCategory)
include(KDEClangFormat)
include(KDEGitCommitHooks)

find_package(Qt6 ${REQUIRED_QT_VERSION} CONFIG REQUIRED Quick Widgets DBus)
find_package(KF6 ${KF6_MIN_VERSION} REQUIRED COMPONENTS Config WindowSystem I18n)
find_package(Plasma ${KF6_MIN_VERSION} REQUIRED)
find_package(LibTaskManager REQUIRED)
add_subdirectory(plugin)
add_subdirectory(lib)

plasma_install_package(package org.kde.activeWindowControl)

# add clang-format target for all our real source files
file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h)
kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})
kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)

ki18n_install(po)
07070100000005000081A40000000000000000000000016626CF9D00000136000000000000000000000000000000000000003100000000plasma-active-window-control-116.7736a87/INSTALLINSTALATION INSTRUCTIONS

Build dependencies (exact package names may differ by distribution):
cmake
extra-cmake-modules
qtbase5-dev
qtdeclarative5-dev
libkf5windowsystem-dev
libkf5plasma-dev
libsm-dev
libqt5x11extras5-dev

$ mkdir build
$ cd build
$ cmake .. -DCMAKE_INSTALL_PREFIX=/usr
$ make
$ make install
07070100000006000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000003200000000plasma-active-window-control-116.7736a87/LICENSES07070100000007000081A40000000000000000000000016626CF9D00001B88000000000000000000000000000000000000003E00000000plasma-active-window-control-116.7736a87/LICENSES/CC0-1.0.txtCreative Commons Legal Code

CC0 1.0 Universal

CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
    HEREUNDER.

Statement of Purpose

The laws of most jurisdictions throughout the world automatically confer
exclusive Copyright and Related Rights (defined below) upon the creator
and subsequent owner(s) (each and all, an "owner") of an original work of
authorship and/or a database (each, a "Work").

Certain owners wish to permanently relinquish those rights to a Work for
the purpose of contributing to a commons of creative, cultural and
scientific works ("Commons") that the public can reliably and without fear
of later claims of infringement build upon, modify, incorporate in other
works, reuse and redistribute as freely as possible in any form whatsoever
and for any purposes, including without limitation commercial purposes.
These owners may contribute to the Commons to promote the ideal of a free
culture and the further production of creative, cultural and scientific
works, or to gain reputation or greater distribution for their Work in
part through the use and efforts of others.

For these and/or other purposes and motivations, and without any
expectation of additional consideration or compensation, the person
associating CC0 with a Work (the "Affirmer"), to the extent that he or she
is an owner of Copyright and Related Rights in the Work, voluntarily
elects to apply CC0 to the Work and publicly distribute the Work under its
terms, with knowledge of his or her Copyright and Related Rights in the
Work and the meaning and intended legal effect of CC0 on those rights.

1. Copyright and Related Rights. A Work made available under CC0 may be
protected by copyright and related or neighboring rights ("Copyright and
Related Rights"). Copyright and Related Rights include, but are not
limited to, the following:

i. the right to reproduce, adapt, distribute, perform, display,
     communicate, and translate a Work;
 ii. moral rights retained by the original author(s) and/or performer(s);
iii. publicity and privacy rights pertaining to a person's image or
     likeness depicted in a Work;
 iv. rights protecting against unfair competition in regards to a Work,
     subject to the limitations in paragraph 4(a), below;
  v. rights protecting the extraction, dissemination, use and reuse of data
     in a Work;
 vi. database rights (such as those arising under Directive 96/9/EC of the
     European Parliament and of the Council of 11 March 1996 on the legal
     protection of databases, and under any national implementation
     thereof, including any amended or successor version of such
     directive); and
vii. other similar, equivalent or corresponding rights throughout the
     world based on applicable law or treaty, and any national
     implementations thereof.

2. Waiver. To the greatest extent permitted by, but not in contravention
of, applicable law, Affirmer hereby overtly, fully, permanently,
irrevocably and unconditionally waives, abandons, and surrenders all of
Affirmer's Copyright and Related Rights and associated claims and causes
of action, whether now known or unknown (including existing as well as
future claims and causes of action), in the Work (i) in all territories
worldwide, (ii) for the maximum duration provided by applicable law or
treaty (including future time extensions), (iii) in any current or future
medium and for any number of copies, and (iv) for any purpose whatsoever,
including without limitation commercial, advertising or promotional
purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
member of the public at large and to the detriment of Affirmer's heirs and
successors, fully intending that such Waiver shall not be subject to
revocation, rescission, cancellation, termination, or any other legal or
equitable action to disrupt the quiet enjoyment of the Work by the public
as contemplated by Affirmer's express Statement of Purpose.

3. Public License Fallback. Should any part of the Waiver for any reason
be judged legally invalid or ineffective under applicable law, then the
Waiver shall be preserved to the maximum extent permitted taking into
account Affirmer's express Statement of Purpose. In addition, to the
extent the Waiver is so judged Affirmer hereby grants to each affected
person a royalty-free, non transferable, non sublicensable, non exclusive,
irrevocable and unconditional license to exercise Affirmer's Copyright and
Related Rights in the Work (i) in all territories worldwide, (ii) for the
maximum duration provided by applicable law or treaty (including future
time extensions), (iii) in any current or future medium and for any number
of copies, and (iv) for any purpose whatsoever, including without
limitation commercial, advertising or promotional purposes (the
"License"). The License shall be deemed effective as of the date CC0 was
applied by Affirmer to the Work. Should any part of the License for any
reason be judged legally invalid or ineffective under applicable law, such
partial invalidity or ineffectiveness shall not invalidate the remainder
of the License, and in such case Affirmer hereby affirms that he or she
will not (i) exercise any of his or her remaining Copyright and Related
Rights in the Work or (ii) assert any associated claims and causes of
action with respect to the Work, in either case contrary to Affirmer's
express Statement of Purpose.

4. Limitations and Disclaimers.

a. No trademark or patent rights held by Affirmer are waived, abandoned,
    surrendered, licensed or otherwise affected by this document.
 b. Affirmer offers the Work as-is and makes no representations or
    warranties of any kind concerning the Work, express, implied,
    statutory or otherwise, including without limitation warranties of
    title, merchantability, fitness for a particular purpose, non
    infringement, or the absence of latent or other defects, accuracy, or
    the present or absence of errors, whether or not discoverable, all to
    the greatest extent permissible under applicable law.
 c. Affirmer disclaims responsibility for clearing rights of other persons
    that may apply to the Work or any use thereof, including without
    limitation any person's Copyright and Related Rights in the Work.
    Further, Affirmer disclaims responsibility for obtaining any necessary
    consents, permissions or other rights required for any use of the
    Work.
 d. Affirmer understands and acknowledges that Creative Commons is not a
    party to this document and has no duty or obligation with respect to
    this CC0 or use of the Work.
07070100000008000081A40000000000000000000000016626CF9D0000437D000000000000000000000000000000000000004300000000plasma-active-window-control-116.7736a87/LICENSES/GPL-2.0-only.txtGNU GENERAL PUBLIC LICENSE
Version 2, June 1991

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 Lesser 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.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7. If, as a consequence of a court judgment or allegation of patent infringement
or for any other reason (not limited to patent issues), conditions are imposed
on you (whether by court order, agreement or otherwise) that contradict the
conditions of this License, they do not excuse you from the conditions of
this License. If you cannot distribute so as to satisfy simultaneously your
obligations under this License and any other pertinent obligations, then as
a consequence you may not distribute the Program at all. For example, if a
patent license would not permit royalty-free redistribution of the Program
by all those who receive copies directly or indirectly through you, then the
only way you could satisfy both it and this License would be to refrain entirely
from distribution of the Program.

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

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

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

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

9. The Free Software Foundation may publish revised and/or new versions of
the General Public License from time to time. Such new versions will be similar
in spirit to the present version, but may differ in detail to address new
problems or concerns.

Each version is given a distinguishing version number. If the Program specifies
a version number of this License which applies to it and "any later version",
you have the option of following the terms and conditions either of that version
or of any later version published by the Free Software Foundation. If the
Program does not specify a version number of this License, you may choose
any version ever published by the Free Software Foundation.

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

NO WARRANTY

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM
"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH
HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest possible
use to the public, the best way to achieve this is to make it free software
which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program. It is safest to attach
them to the start of each source file to most effectively convey the exclusion
of warranty; and each file should have at least the "copyright" line and a
pointer to where the full notice is found.

one line to give the program's name and an idea of what it does. Copyright
(C) yyyy 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.

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) year 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
07070100000009000081A40000000000000000000000016626CF9D0000437D000000000000000000000000000000000000004700000000plasma-active-window-control-116.7736a87/LICENSES/GPL-2.0-or-later.txtGNU GENERAL PUBLIC LICENSE
Version 2, June 1991

Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.

Preamble

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.

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

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

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.

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

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

NO WARRANTY

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs

one line to give the program's name and an idea of what it does. Copyright
(C) yyyy name of author

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

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
0707010000000A000081A40000000000000000000000016626CF9D0000870F000000000000000000000000000000000000004300000000plasma-active-window-control-116.7736a87/LICENSES/GPL-3.0-only.txtGNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007

Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.

Preamble

The GNU General Public License is a free, copyleft license for software and
other kinds of works.

The licenses for most software and other practical works are designed to take
away your freedom to share and change the works. By contrast, the GNU General
Public License is intended to guarantee your freedom to share and change all
versions of a program--to make sure it remains free software for all its users.
We, the Free Software Foundation, use the GNU General Public License for most
of our software; it applies also to any other work released this way by its
authors. You can apply it to your programs, too.

When we speak of free software, we are referring to freedom, not price. Our
General Public Licenses are designed to make sure that you have the freedom
to distribute copies of free software (and charge for them if you wish), that
you receive source code or can get it if you want it, that you can change
the software or use pieces of it in new free programs, and that you know you
can do these things.

To protect your rights, we need to prevent others from denying you these rights
or asking you to surrender the rights. Therefore, you have certain responsibilities
if you distribute copies of the software, or if you modify it: responsibilities
to respect the freedom of others.

For example, if you distribute copies of such a program, whether gratis or
for a fee, you must pass on to the recipients the same freedoms that you received.
You must make sure that they, too, receive or can get the source code. And
you must show them these terms so they know their rights.

Developers that use the GNU GPL protect your rights with two steps: (1) assert
copyright on the software, and (2) offer you this License giving you legal
permission to copy, distribute and/or modify it.

For the developers' and authors' protection, the GPL clearly explains that
there is no warranty for this free software. For both users' and authors'
sake, the GPL requires that modified versions be marked as changed, so that
their problems will not be attributed erroneously to authors of previous versions.

Some devices are designed to deny users access to install or run modified
versions of the software inside them, although the manufacturer can do so.
This is fundamentally incompatible with the aim of protecting users' freedom
to change the software. The systematic pattern of such abuse occurs in the
area of products for individuals to use, which is precisely where it is most
unacceptable. Therefore, we have designed this version of the GPL to prohibit
the practice for those products. If such problems arise substantially in other
domains, we stand ready to extend this provision to those domains in future
versions of the GPL, as needed to protect the freedom of users.

Finally, every program is threatened constantly by software patents. States
should not allow patents to restrict development and use of software on general-purpose
computers, but in those that do, we wish to avoid the special danger that
patents applied to a free program could make it effectively proprietary. To
prevent this, the GPL assures that patents cannot be used to render the program
non-free.

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

TERMS AND CONDITIONS

0. Definitions.

“This License” refers to version 3 of the GNU General Public License.

“Copyright” also means copyright-like laws that apply to other kinds of works,
such as semiconductor masks.

“The Program” refers to any copyrightable work licensed under this License.
Each licensee is addressed as “you”. “Licensees” and “recipients” may be individuals
or organizations.

To “modify” a work means to copy from or adapt all or part of the work in
a fashion requiring copyright permission, other than the making of an exact
copy. The resulting work is called a “modified version” of the earlier work
or a work “based on” the earlier work.

A “covered work” means either the unmodified Program or a work based on the
Program.

To “propagate” a work means to do anything with it that, without permission,
would make you directly or secondarily liable for infringement under applicable
copyright law, except executing it on a computer or modifying a private copy.
Propagation includes copying, distribution (with or without modification),
making available to the public, and in some countries other activities as
well.

To “convey” a work means any kind of propagation that enables other parties
to make or receive copies. Mere interaction with a user through a computer
network, with no transfer of a copy, is not conveying.

An interactive user interface displays “Appropriate Legal Notices” to the
extent that it includes a convenient and prominently visible feature that
(1) displays an appropriate copyright notice, and (2) tells the user that
there is no warranty for the work (except to the extent that warranties are
provided), that licensees may convey the work under this License, and how
to view a copy of this License. If the interface presents a list of user commands
or options, such as a menu, a prominent item in the list meets this criterion.

1. Source Code.
The “source code” for a work means the preferred form of the work for making
modifications to it. “Object code” means any non-source form of a work.

A “Standard Interface” means an interface that either is an official standard
defined by a recognized standards body, or, in the case of interfaces specified
for a particular programming language, one that is widely used among developers
working in that language.

The “System Libraries” of an executable work include anything, other than
the work as a whole, that (a) is included in the normal form of packaging
a Major Component, but which is not part of that Major Component, and (b)
serves only to enable use of the work with that Major Component, or to implement
a Standard Interface for which an implementation is available to the public
in source code form. A “Major Component”, in this context, means a major essential
component (kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to produce
the work, or an object code interpreter used to run it.

The “Corresponding Source” for a work in object code form means all the source
code needed to generate, install, and (for an executable work) run the object
code and to modify the work, including scripts to control those activities.
However, it does not include the work's System Libraries, or general-purpose
tools or generally available free programs which are used unmodified in performing
those activities but which are not part of the work. For example, Corresponding
Source includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically linked
subprograms that the work is specifically designed to require, such as by
intimate data communication or control flow between those subprograms and
other parts of the work.

The Corresponding Source need not include anything that users can regenerate
automatically from other parts of the Corresponding Source.

The Corresponding Source for a work in source code form is that same work.

2. Basic Permissions.
All rights granted under this License are granted for the term of copyright
on the Program, and are irrevocable provided the stated conditions are met.
This License explicitly affirms your unlimited permission to run the unmodified
Program. The output from running a covered work is covered by this License
only if the output, given its content, constitutes a covered work. This License
acknowledges your rights of fair use or other equivalent, as provided by copyright
law.

You may make, run and propagate covered works that you do not convey, without
conditions so long as your license otherwise remains in force. You may convey
covered works to others for the sole purpose of having them make modifications
exclusively for you, or provide you with facilities for running those works,
provided that you comply with the terms of this License in conveying all material
for which you do not control copyright. Those thus making or running the covered
works for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of your copyrighted
material outside their relationship with you.

Conveying under any other circumstances is permitted solely under the conditions
stated below. Sublicensing is not allowed; section 10 makes it unnecessary.

3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological measure
under any applicable law fulfilling obligations under article 11 of the WIPO
copyright treaty adopted on 20 December 1996, or similar laws prohibiting
or restricting circumvention of such measures.

When you convey a covered work, you waive any legal power to forbid circumvention
of technological measures to the extent such circumvention is effected by
exercising rights under this License with respect to the covered work, and
you disclaim any intention to limit operation or modification of the work
as a means of enforcing, against the work's users, your or third parties'
legal rights to forbid circumvention of technological measures.

4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you receive
it, in any medium, provided that you conspicuously and appropriately publish
on each copy an appropriate copyright notice; keep intact all notices stating
that this License and any non-permissive terms added in accord with section
7 apply to the code; keep intact all notices of the absence of any warranty;
and give all recipients a copy of this License along with the Program.

You may charge any price or no price for each copy that you convey, and you
may offer support or warranty protection for a fee.

5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to produce
it from the Program, in the form of source code under the terms of section
4, provided that you also meet all of these conditions:

a) The work must carry prominent notices stating that you modified it, and
giving a relevant date.

b) The work must carry prominent notices stating that it is released under
this License and any conditions added under section 7. This requirement modifies
the requirement in section 4 to “keep intact all notices”.

c) You must license the entire work, as a whole, under this License to anyone
who comes into possession of a copy. This License will therefore apply, along
with any applicable section 7 additional terms, to the whole of the work,
and all its parts, regardless of how they are packaged. This License gives
no permission to license the work in any other way, but it does not invalidate
such permission if you have separately received it.

d) If the work has interactive user interfaces, each must display Appropriate
Legal Notices; however, if the Program has interactive interfaces that do
not display Appropriate Legal Notices, your work need not make them do so.

A compilation of a covered work with other separate and independent works,
which are not by their nature extensions of the covered work, and which are
not combined with it such as to form a larger program, in or on a volume of
a storage or distribution medium, is called an “aggregate” if the compilation
and its resulting copyright are not used to limit the access or legal rights
of the compilation's users beyond what the individual works permit. Inclusion
of a covered work in an aggregate does not cause this License to apply to
the other parts of the aggregate.

6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms of sections
4 and 5, provided that you also convey the machine-readable Corresponding
Source under the terms of this License, in one of these ways:

a) Convey the object code in, or embodied in, a physical product (including
a physical distribution medium), accompanied by the Corresponding Source fixed
on a durable physical medium customarily used for software interchange.

b) Convey the object code in, or embodied in, a physical product (including
a physical distribution medium), accompanied by a written offer, valid for
at least three years and valid for as long as you offer spare parts or customer
support for that product model, to give anyone who possesses the object code
either (1) a copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical medium customarily
used for software interchange, for a price no more than your reasonable cost
of physically performing this conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.

c) Convey individual copies of the object code with a copy of the written
offer to provide the Corresponding Source. This alternative is allowed only
occasionally and noncommercially, and only if you received the object code
with such an offer, in accord with subsection 6b.

d) Convey the object code by offering access from a designated place (gratis
or for a charge), and offer equivalent access to the Corresponding Source
in the same way through the same place at no further charge. You need not
require recipients to copy the Corresponding Source along with the object
code. If the place to copy the object code is a network server, the Corresponding
Source may be on a different server (operated by you or a third party) that
supports equivalent copying facilities, provided you maintain clear directions
next to the object code saying where to find the Corresponding Source. Regardless
of what server hosts the Corresponding Source, you remain obligated to ensure
that it is available for as long as needed to satisfy these requirements.

e) Convey the object code using peer-to-peer transmission, provided you inform
other peers where the object code and Corresponding Source of the work are
being offered to the general public at no charge under subsection 6d.

A separable portion of the object code, whose source code is excluded from
the Corresponding Source as a System Library, need not be included in conveying
the object code work.

A “User Product” is either (1) a “consumer product”, which means any tangible
personal property which is normally used for personal, family, or household
purposes, or (2) anything designed or sold for incorporation into a dwelling.
In determining whether a product is a consumer product, doubtful cases shall
be resolved in favor of coverage. For a particular product received by a particular
user, “normally used” refers to a typical or common use of that class of product,
regardless of the status of the particular user or of the way in which the
particular user actually uses, or expects or is expected to use, the product.
A product is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent the
only significant mode of use of the product.

“Installation Information” for a User Product means any methods, procedures,
authorization keys, or other information required to install and execute modified
versions of a covered work in that User Product from a modified version of
its Corresponding Source. The information must suffice to ensure that the
continued functioning of the modified object code is in no case prevented
or interfered with solely because modification has been made.

If you convey an object code work under this section in, or with, or specifically
for use in, a User Product, and the conveying occurs as part of a transaction
in which the right of possession and use of the User Product is transferred
to the recipient in perpetuity or for a fixed term (regardless of how the
transaction is characterized), the Corresponding Source conveyed under this
section must be accompanied by the Installation Information. But this requirement
does not apply if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has been installed
in ROM).

The requirement to provide Installation Information does not include a requirement
to continue to provide support service, warranty, or updates for a work that
has been modified or installed by the recipient, or for the User Product in
which it has been modified or installed. Access to a network may be denied
when the modification itself materially and adversely affects the operation
of the network or violates the rules and protocols for communication across
the network.

Corresponding Source conveyed, and Installation Information provided, in accord
with this section must be in a format that is publicly documented (and with
an implementation available to the public in source code form), and must require
no special password or key for unpacking, reading or copying.

7. Additional Terms.
“Additional permissions” are terms that supplement the terms of this License
by making exceptions from one or more of its conditions. Additional permissions
that are applicable to the entire Program shall be treated as though they
were included in this License, to the extent that they are valid under applicable
law. If additional permissions apply only to part of the Program, that part
may be used separately under those permissions, but the entire Program remains
governed by this License without regard to the additional permissions.

When you convey a copy of a covered work, you may at your option remove any
additional permissions from that copy, or from any part of it. (Additional
permissions may be written to require their own removal in certain cases when
you modify the work.) You may place additional permissions on material, added
by you to a covered work, for which you have or can give appropriate copyright
permission.

Notwithstanding any other provision of this License, for material you add
to a covered work, you may (if authorized by the copyright holders of that
material) supplement the terms of this License with terms:

a) Disclaiming warranty or limiting liability differently from the terms of
sections 15 and 16 of this License; or

b) Requiring preservation of specified reasonable legal notices or author
attributions in that material or in the Appropriate Legal Notices displayed
by works containing it; or

c) Prohibiting misrepresentation of the origin of that material, or requiring
that modified versions of such material be marked in reasonable ways as different
from the original version; or

d) Limiting the use for publicity purposes of names of licensors or authors
of the material; or

e) Declining to grant rights under trademark law for use of some trade names,
trademarks, or service marks; or

f) Requiring indemnification of licensors and authors of that material by
anyone who conveys the material (or modified versions of it) with contractual
assumptions of liability to the recipient, for any liability that these contractual
assumptions directly impose on those licensors and authors.

All other non-permissive additional terms are considered “further restrictions”
within the meaning of section 10. If the Program as you received it, or any
part of it, contains a notice stating that it is governed by this License
along with a term that is a further restriction, you may remove that term.
If a license document contains a further restriction but permits relicensing
or conveying under this License, you may add to a covered work material governed
by the terms of that license document, provided that the further restriction
does not survive such relicensing or conveying.

If you add terms to a covered work in accord with this section, you must place,
in the relevant source files, a statement of the additional terms that apply
to those files, or a notice indicating where to find the applicable terms.

Additional terms, permissive or non-permissive, may be stated in the form
of a separately written license, or stated as exceptions; the above requirements
apply either way.

8. Termination.
You may not propagate or modify a covered work except as expressly provided
under this License. Any attempt otherwise to propagate or modify it is void,
and will automatically terminate your rights under this License (including
any patent licenses granted under the third paragraph of section 11).

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

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

Termination of your rights under this section does not terminate the licenses
of parties who have received copies or rights from you under this License.
If your rights have been terminated and not permanently reinstated, you do
not qualify to receive new licenses for the same material under section 10.

9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or run a copy
of the Program. Ancillary propagation of a covered work occurring solely as
a consequence of using peer-to-peer transmission to receive a copy likewise
does not require acceptance. However, nothing other than this License grants
you permission to propagate or modify any covered work. These actions infringe
copyright if you do not accept this License. Therefore, by modifying or propagating
a covered work, you indicate your acceptance of this License to do so.

10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically receives
a license from the original licensors, to run, modify and propagate that work,
subject to this License. You are not responsible for enforcing compliance
by third parties with this License.

An “entity transaction” is a transaction transferring control of an organization,
or substantially all assets of one, or subdividing an organization, or merging
organizations. If propagation of a covered work results from an entity transaction,
each party to that transaction who receives a copy of the work also receives
whatever licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the Corresponding
Source of the work from the predecessor in interest, if the predecessor has
it or can get it with reasonable efforts.

You may not impose any further restrictions on the exercise of the rights
granted or affirmed under this License. For example, you may not impose a
license fee, royalty, or other charge for exercise of rights granted under
this License, and you may not initiate litigation (including a cross-claim
or counterclaim in a lawsuit) alleging that any patent claim is infringed
by making, using, selling, offering for sale, or importing the Program or
any portion of it.

11. Patents.
A “contributor” is a copyright holder who authorizes use under this License
of the Program or a work on which the Program is based. The work thus licensed
is called the contributor's “contributor version”.

A contributor's “essential patent claims” are all patent claims owned or controlled
by the contributor, whether already acquired or hereafter acquired, that would
be infringed by some manner, permitted by this License, of making, using,
or selling its contributor version, but do not include claims that would be
infringed only as a consequence of further modification of the contributor
version. For purposes of this definition, “control” includes the right to
grant patent sublicenses in a manner consistent with the requirements of this
License.

Each contributor grants you a non-exclusive, worldwide, royalty-free patent
license under the contributor's essential patent claims, to make, use, sell,
offer for sale, import and otherwise run, modify and propagate the contents
of its contributor version.

In the following three paragraphs, a “patent license” is any express agreement
or commitment, however denominated, not to enforce a patent (such as an express
permission to practice a patent or covenant not to sue for patent infringement).
To “grant” such a patent license to a party means to make such an agreement
or commitment not to enforce a patent against the party.

If you convey a covered work, knowingly relying on a patent license, and the
Corresponding Source of the work is not available for anyone to copy, free
of charge and under the terms of this License, through a publicly available
network server or other readily accessible means, then you must either (1)
cause the Corresponding Source to be so available, or (2) arrange to deprive
yourself of the benefit of the patent license for this particular work, or
(3) arrange, in a manner consistent with the requirements of this License,
to extend the patent license to downstream recipients. “Knowingly relying”
means you have actual knowledge that, but for the patent license, your conveying
the covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that country
that you have reason to believe are valid.

If, pursuant to or in connection with a single transaction or arrangement,
you convey, or propagate by procuring conveyance of, a covered work, and grant
a patent license to some of the parties receiving the covered work authorizing
them to use, propagate, modify or convey a specific copy of the covered work,
then the patent license you grant is automatically extended to all recipients
of the covered work and works based on it.

A patent license is “discriminatory” if it does not include within the scope
of its coverage, prohibits the exercise of, or is conditioned on the non-exercise
of one or more of the rights that are specifically granted under this License.
You may not convey a covered work if you are a party to an arrangement with
a third party that is in the business of distributing software, under which
you make payment to the third party based on the extent of your activity of
conveying the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory patent
license (a) in connection with copies of the covered work conveyed by you
(or copies made from those copies), or (b) primarily for and in connection
with specific products or compilations that contain the covered work, unless
you entered into that arrangement, or that patent license was granted, prior
to 28 March 2007.

Nothing in this License shall be construed as excluding or limiting any implied
license or other defenses to infringement that may otherwise be available
to you under applicable patent law.

12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or otherwise)
that contradict the conditions of this License, they do not excuse you from
the conditions of this License. If you cannot convey a covered work so as
to satisfy simultaneously your obligations under this License and any other
pertinent obligations, then as a consequence you may not convey it at all.
For example, if you agree to terms that obligate you to collect a royalty
for further conveying from those to whom you convey the Program, the only
way you could satisfy both those terms and this License would be to refrain
entirely from conveying the Program.

13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have permission to
link or combine any covered work with a work licensed under version 3 of the
GNU Affero General Public License into a single combined work, and to convey
the resulting work. The terms of this License will continue to apply to the
part which is the covered work, but the special requirements of the GNU Affero
General Public License, section 13, concerning interaction through a network
will apply to the combination as such.

14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of the
GNU General Public License from time to time. Such new versions will be similar
in spirit to the present version, but may differ in detail to address new
problems or concerns.

Each version is given a distinguishing version number. If the Program specifies
that a certain numbered version of the GNU General Public License “or any
later version” applies to it, you have the option of following the terms and
conditions either of that numbered version or of any later version published
by the Free Software Foundation. If the Program does not specify a version
number of the GNU General Public License, you may choose any version ever
published by the Free Software Foundation.

If the Program specifies that a proxy can decide which future versions of
the GNU General Public License can be used, that proxy's public statement
of acceptance of a version permanently authorizes you to choose that version
for the Program.

Later license versions may give you additional or different permissions. However,
no additional obligations are imposed on any author or copyright holder as
a result of your choosing to follow a later version.

15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER
EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM
PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
CORRECTION.

16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM
AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO
USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE
PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided above cannot
be given local legal effect according to their terms, reviewing courts shall
apply local law that most closely approximates an absolute waiver of all civil
liability in connection with the Program, unless a warranty or assumption
of liability accompanies a copy of the Program in return for a fee.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs

To do so, attach the following notices to the program. It is safest to attach
them to the start of each source file to most effectively state the exclusion
of warranty; and each file should have at least the “copyright” line and a
pointer to where the full notice is found.

<one line to give the program's name and a brief idea of what it does.>
     Copyright (C) <year>  <name of author>

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

You should have received a copy of the GNU General Public License along with
this program.  If not, see <http://www.gnu.org/licenses/>.

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

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

<program>  Copyright (C) <year>  <name of author>
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it under certain
conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands might
be different; for a GUI interface, you would use an “about box”.

You should also get your employer (if you work as a programmer) or school,
if any, to sign a “copyright disclaimer” for the program, if necessary. For
more information on this, and how to apply and follow the GNU GPL, see <http://www.gnu.org/licenses/>.

The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General Public
License instead of this License. But first, please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.
0707010000000B000081A40000000000000000000000016626CF9D000060CE000000000000000000000000000000000000004800000000plasma-active-window-control-116.7736a87/LICENSES/LGPL-2.0-or-later.txtGNU LIBRARY GENERAL PUBLIC LICENSE

Version 2, June 1991

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 library GPL.  It is numbered 2
because it goes with version 2 of the ordinary GPL.]

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 Library General Public License, applies to some specially
designated Free Software Foundation software, and to any other libraries whose
authors decide to use it. You can use it for your libraries, too.

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
a program 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.

Our method of protecting your rights has two steps: (1) copyright the library,
and (2) offer you this license which gives you legal permission to copy, distribute
and/or modify the library.

Also, for each distributor's protection, we want to make certain that everyone
understands that there is no warranty for this free library. If the library
is modified by someone else and passed on, we want its recipients to know
that what they have is not the original version, 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 companies distributing free software will individually
obtain patent licenses, thus in effect transforming the program into proprietary
software. To prevent this, we have made it clear that any patent must be licensed
for everyone's free use or not licensed at all.

Most GNU software, including some libraries, is covered by the ordinary GNU
General Public License, which was designed for utility programs. This license,
the GNU Library General Public License, applies to certain designated libraries.
This license is quite different from the ordinary one; be sure to read it
in full, and don't assume that anything in it is the same as in the ordinary
license.

The reason we have a separate public license for some libraries is that they
blur the distinction we usually make between modifying or adding to a program
and simply using it. Linking a program with a library, without changing the
library, is in some sense simply using the library, and is analogous to running
a utility program or application program. However, in a textual and legal
sense, the linked executable is a combined work, a derivative of the original
library, and the ordinary General Public License treats it as such.

Because of this blurred distinction, using the ordinary General Public License
for libraries did not effectively promote software sharing, because most developers
did not use the libraries. We concluded that weaker conditions might promote
sharing better.

However, unrestricted linking of non-free programs would deprive the users
of those programs of all benefit from the free status of the libraries themselves.
This Library General Public License is intended to permit developers of non-free
programs to use free libraries, while preserving your freedom as a user of
such programs to change the free libraries that are incorporated in them.
(We have not seen how to achieve this as regards changes in header files,
but we have achieved it as regards changes in the actual functions of the
Library.) The hope is that this will lead to faster development of free libraries.

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, while the latter only works together with the library.

Note that it is possible for a library to be covered by the ordinary General
Public License rather than by this special one.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

6. As an exception to the Sections above, you may also compile 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) 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.

c) 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.

d) 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 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.

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

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

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

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

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

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

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

11. If, as a consequence of a court judgment or allegation of patent infringement
or for any other reason (not limited to patent issues), conditions are imposed
on you (whether by court order, agreement or otherwise) that contradict the
conditions of this License, they do not excuse you from the conditions of
this License. If you cannot distribute so as to satisfy simultaneously your
obligations under this License and any other pertinent obligations, then as
a consequence you may not distribute the Library at all. For example, if a
patent license would not permit royalty-free redistribution of the Library
by all those who receive copies directly or indirectly through you, then the
only way you could satisfy both it and this License would be to refrain entirely
from distribution of the Library.

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

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

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

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

13. The Free Software Foundation may publish revised and/or new versions of
the Library General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to address
new problems or concerns.

Each version is given a distinguishing version number. If the Library specifies
a version number of this License which applies to it and "any later version",
you have the option of following the terms and conditions either of that version
or of any later version published by the Free Software Foundation. If the
Library does not specify a license version number, you may choose any version
ever published by the Free Software Foundation.

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

NO WARRANTY

15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY
"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH
HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Libraries

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

To apply these terms, attach the following notices to the library. It is safest
to attach them to the start of each source file to most effectively convey
the exclusion of warranty; and each file should have at least the "copyright"
line and a pointer to where the full notice is found.

one line to give the library's name and an 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 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; 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!
0707010000000C000081A40000000000000000000000016626CF9D00000296000000000000000000000000000000000000005200000000plasma-active-window-control-116.7736a87/LICENSES/LicenseRef-KDE-Accepted-GPL.txtThis library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 3 of
the license or (at your option) at any later version that is
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 as 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.
0707010000000D000081ED0000000000000000000000016626CF9D00000091000000000000000000000000000000000000003500000000plasma-active-window-control-116.7736a87/Messages.sh#!/bin/sh

$XGETTEXT `find "package/contents" -name \*.qml -o -name \*.js` -L JavaScript -o $podir/plasma_applet_org.kde.activeWindowControl.pot
0707010000000E000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000002D00000000plasma-active-window-control-116.7736a87/lib0707010000000F000081A40000000000000000000000016626CF9D0000017B000000000000000000000000000000000000003C00000000plasma-active-window-control-116.7736a87/lib/CMakeLists.txtset(appmenuapplet_SRCS
  appmenuapplet.cpp
)

add_library(plasma_applet_activewindowcontrol MODULE ${appmenuapplet_SRCS})

target_link_libraries(plasma_applet_activewindowcontrol
  Qt::Widgets
  Qt::Quick
  Qt::DBus
  Plasma::Plasma
  KF6::WindowSystem
  PW::LibTaskManager)

install(TARGETS plasma_applet_activewindowcontrol DESTINATION ${KDE_INSTALL_PLUGINDIR}/plasma/applets)
07070100000010000081A40000000000000000000000016626CF9D00002F1E000000000000000000000000000000000000003F00000000plasma-active-window-control-116.7736a87/lib/appmenuapplet.cpp/*
    SPDX-FileCopyrightText: 2016 Kai Uwe Broulik <kde@privat.broulik.de>

SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#include "appmenuapplet.h"
#include "../plugin/appmenumodel.h"

#include <QAction>
#include <QDir>
#include <QDBusConnection>
#include <QDBusConnectionInterface>
#include <QKeyEvent>
#include <QMenu>
#include <QMouseEvent>
#include <QQuickItem>
#include <QQuickWindow>
#include <QScreen>
#include <QTimer>

#include <KConfig>
#include <KShell>

int AppMenuApplet::s_refs = 0;
namespace
{
QString viewService()
{
    return QStringLiteral("org.kde.kappmenuview");
}
}

AppMenuApplet::AppMenuApplet(QObject *parent, const KPluginMetaData &data, const QVariantList &args)
    : Plasma::Applet(parent, data, args)
{
    /*it registers or unregisters the service when the destroyed value of the applet change,
      and not in the dtor, because:
      when we "delete" an applet, it just hides it for about a minute setting its status
      to destroyed, in order to be able to do a clean undo: if we undo, there will be
      another destroyedchanged and destroyed will be false.
      When this happens, if we are the only appmenu applet existing, the dbus interface
      will have to be registered again*/
    connect(this, &Applet::destroyedChanged, this, [this](bool destroyed) {
        if (destroyed) {
            unregisterService();
        } else {
            registerService();
        }
    });

// get current aurorae decoration theme if there is one set
    refreshAuroraeTheme();
}

AppMenuApplet::~AppMenuApplet() = default;

void AppMenuApplet::init()
{
}

QAbstractItemModel *AppMenuApplet::model() const
{
    return m_model;
}

void AppMenuApplet::refreshAuroraeTheme()
{
    const KConfig kwinConfig(QString("kwinrc"), KConfig::OpenFlag::SimpleConfig);
    const QByteArray decorationGroupName = QString("org.kde.kdecoration2").toUtf8();
    if (!kwinConfig.hasGroup(decorationGroupName)) {
        return;
    }
    const KConfigGroup decorationGroup = kwinConfig.group(decorationGroupName);
    const QString decorationLibrary = decorationGroup.readEntry(QString("library"), QString());
    if (decorationLibrary == QString("org.kde.kwin.aurorae")) {
        const QString decorationTheme = decorationGroup.readEntry(QString("theme"), QString());
        if (decorationTheme.startsWith(QString("__aurorae__"))) {
            const QString separator("__");
            const QString themeName = decorationTheme.section(separator, -1, -1);
            const QString themeType = decorationTheme.section(separator, -2, -2);
            QString themePath =
                QStandardPaths::locate(QStandardPaths::GenericDataLocation, QString("aurorae/themes/") + themeName, QStandardPaths::LocateDirectory);
            if (!themePath.isEmpty()) {
                m_auroraeDecorationPath = themePath;
                m_auroraeDecorationType = themeType;
                emit auroraeThemePathChanged();
                emit auroraeThemeTypeChanged();
                return;
            }
        }
    }
    m_auroraeDecorationPath = QString();
    emit auroraeThemePathChanged();
}

QString AppMenuApplet::auroraeThemePath() const
{
    return m_auroraeDecorationPath;
}

QString AppMenuApplet::auroraeThemeType() const
{
    return m_auroraeDecorationType;
}

QString AppMenuApplet::extensionForTheme(const QString &themeDirectoryPath)
{
    if (themeDirectoryPath.isEmpty()) {
        return QString();
    }
    qDebug() << "determine theme extension from path " << themeDirectoryPath;
    QDir themeDir(themeDirectoryPath);
    QStringList nameFilters(QString("close.svgz"));
    QStringList filteredFiles = themeDir.entryList(nameFilters);
    qDebug() << "filtered: " << filteredFiles;
    if (!filteredFiles.isEmpty()) {
        return QString("svgz");
    }
    return QString("svg");
}

QString AppMenuApplet::translateThemePath(const QString &themeDirectoryPath)
{
    qDebug() << "translating path " << themeDirectoryPath;
    return KShell::tildeExpand(themeDirectoryPath);
}

void AppMenuApplet::registerService()
{
    qDebug() << "registering appmenu service";
    ++s_refs;
    //if we're the first, regster the service
    if (s_refs == 1) {
        qDebug() << " -> connecting to DBus";
        QDBusConnection::sessionBus().interface()->registerService(viewService(),
                QDBusConnectionInterface::QueueService,
                QDBusConnectionInterface::DontAllowReplacement);
    }
}

void AppMenuApplet::unregisterService()
{
    qDebug() << "unregistering from appmenu service";
    //if we were the last, unregister
    if (--s_refs == 0) {
        qDebug() << " -> disconnecting from DBus";
        QDBusConnection::sessionBus().interface()->unregisterService(viewService());
    }
    if (s_refs < 0) {
        s_refs = 0;
    }
}

bool AppMenuApplet::enabled() const
{
    return m_enabled;
}

void AppMenuApplet::setEnabled(bool enabled)
{
    if (enabled == m_enabled) {
        return;
    }
    if (enabled) {
        registerService();
    } else {
        unregisterService();
    }
    m_enabled = enabled;
}

void AppMenuApplet::setModel(QAbstractItemModel *model)
{
    if (m_model != model) {
        m_model = model;
        Q_EMIT modelChanged();
    }
}

int AppMenuApplet::view() const
{
    return m_viewType;
}

void AppMenuApplet::setView(int type)
{
    if (m_viewType != type) {
        m_viewType = type;
        Q_EMIT viewChanged();
    }
}

int AppMenuApplet::currentIndex() const
{
    return m_currentIndex;
}

void AppMenuApplet::setCurrentIndex(int currentIndex)
{
    if (m_currentIndex != currentIndex) {
        m_currentIndex = currentIndex;
        Q_EMIT currentIndexChanged();
    }
}

QQuickItem *AppMenuApplet::buttonGrid() const
{
    return m_buttonGrid;
}

void AppMenuApplet::setButtonGrid(QQuickItem *buttonGrid)
{
    if (m_buttonGrid != buttonGrid) {
        m_buttonGrid = buttonGrid;
        Q_EMIT buttonGridChanged();
    }
}

QMenu *AppMenuApplet::createMenu(int idx) const
{
    QMenu *menu = nullptr;

if (view() == CompactView) {
        if (QAction *menuAction = m_model->data(QModelIndex(), AppMenuModel::ActionRole).value<QAction *>()) {
            menu = menuAction->menu();
        }
    } else if (view() == FullView) {
        const QModelIndex index = m_model->index(idx, 0);
        if (QAction *action = m_model->data(index, AppMenuModel::ActionRole).value<QAction *>()) {
            menu = action->menu();
        }
    }

return menu;
}

void AppMenuApplet::onMenuAboutToHide()
{
    setCurrentIndex(-1);
}

Qt::Edges edgeFromLocation(Plasma::Types::Location location)
{
    switch (location) {
    case Plasma::Types::TopEdge:
        return Qt::TopEdge;
    case Plasma::Types::BottomEdge:
        return Qt::BottomEdge;
    case Plasma::Types::LeftEdge:
        return Qt::LeftEdge;
    case Plasma::Types::RightEdge:
        return Qt::RightEdge;
    case Plasma::Types::Floating:
    case Plasma::Types::Desktop:
    case Plasma::Types::FullScreen:
        break;
    }
    return Qt::Edges();
}

void AppMenuApplet::trigger(QQuickItem *ctx, int idx)
{
    if (m_currentIndex == idx) {
        return;
    }

if (!ctx || !ctx->window() || !ctx->window()->screen()) {
        return;
    }

QMenu *actionMenu = createMenu(idx);
    if (actionMenu) {
        // this is a workaround where Qt will fail to realize a mouse has been released
        // this happens if a window which does not accept focus spawns a new window that takes focus and X grab
        // whilst the mouse is depressed
        // https://bugreports.qt.io/browse/QTBUG-59044
        // this causes the next click to go missing

// by releasing manually we avoid that situation
        auto ungrabMouseHack = [ctx]() {
            if (ctx && ctx->window() && ctx->window()->mouseGrabberItem()) {
                // FIXME event forge thing enters press and hold move mode :/
                ctx->window()->mouseGrabberItem()->ungrabMouse();
            }
        };

QTimer::singleShot(0, ctx, ungrabMouseHack);
        // end workaround

const auto &geo = ctx->window()->screen()->availableVirtualGeometry();

QPoint pos = ctx->window()->mapToGlobal(ctx->mapToScene(QPointF()).toPoint());

const Qt::Edges edges = edgeFromLocation(location());
        actionMenu->setProperty("_breeze_menu_seamless_edges", QVariant::fromValue(edges));

if (location() == Plasma::Types::TopEdge) {
            pos.setY(pos.y() + ctx->height());
        }

actionMenu->adjustSize();

pos = QPoint(qBound(geo.x(), pos.x(), geo.x() + geo.width() - actionMenu->width()),
                     qBound(geo.y(), pos.y(), geo.y() + geo.height() - actionMenu->height()));

if (view() == FullView) {
            actionMenu->installEventFilter(this);
        }

actionMenu->winId(); // create window handle
        actionMenu->windowHandle()->setTransientParent(ctx->window());

// hide the old menu only after showing the new one to avoid brief focus flickering on X11.
        // on wayland, you can't have more than one grabbing popup at a time so we show it after
        // the menu has hidden. thankfully, wayland doesn't have this flickering.
        if (!KWindowSystem::isPlatformWayland()) {
            actionMenu->popup(pos);
        }

if (view() == FullView) {
            QMenu *oldMenu = m_currentMenu;
            m_currentMenu = actionMenu;
            if (oldMenu && oldMenu != actionMenu) {
                // don't initialize the currentIndex when another menu is already shown
                disconnect(oldMenu, &QMenu::aboutToHide, this, &AppMenuApplet::onMenuAboutToHide);
                oldMenu->hide();
            }
        }

if (KWindowSystem::isPlatformWayland()) {
            actionMenu->popup(pos);
        }

setCurrentIndex(idx);

// FIXME TODO connect only once
        connect(actionMenu, &QMenu::aboutToHide, this, &AppMenuApplet::onMenuAboutToHide, Qt::UniqueConnection);
    } else { // is it just an action without a menu?
        if (QAction *action = m_model->index(idx, 0).data(AppMenuModel::ActionRole).value<QAction *>()) {
            Q_ASSERT(!action->menu());
            action->trigger();
        }
    }
}

// FIXME TODO doesn't work on submenu
bool AppMenuApplet::eventFilter(QObject *watched, QEvent *event)
{
    auto *menu = qobject_cast<QMenu *>(watched);
    if (!menu) {
        return false;
    }

if (event->type() == QEvent::KeyPress) {
        auto *e = static_cast<QKeyEvent *>(event);

// TODO right to left languages
        if (e->key() == Qt::Key_Left) {
            int desiredIndex = m_currentIndex - 1;
            Q_EMIT requestActivateIndex(desiredIndex);
            return true;
        } else if (e->key() == Qt::Key_Right) {
            if (menu->activeAction() && menu->activeAction()->menu()) {
                return false;
            }

int desiredIndex = m_currentIndex + 1;
            Q_EMIT requestActivateIndex(desiredIndex);
            return true;
        }

} else if (event->type() == QEvent::MouseMove) {
        auto *e = static_cast<QMouseEvent *>(event);

if (!m_buttonGrid || !m_buttonGrid->window()) {
            return false;
        }

// FIXME the panel margin breaks Fitt's law :(
        const QPointF &windowLocalPos = m_buttonGrid->window()->mapFromGlobal(e->globalPosition());
        const QPointF &buttonGridLocalPos = m_buttonGrid->mapFromScene(windowLocalPos);
        auto *item = m_buttonGrid->childAt(buttonGridLocalPos.x(), buttonGridLocalPos.y());
        if (!item) {
            return false;
        }

bool ok;
        const int buttonIndex = item->property("buttonIndex").toInt(&ok);
        if (!ok) {
            return false;
        }

Q_EMIT requestActivateIndex(buttonIndex);
    }

return false;
}

K_PLUGIN_CLASS(AppMenuApplet)

#include "appmenuapplet.moc"
#include "moc_appmenuapplet.cpp"
07070100000011000081A40000000000000000000000016626CF9D00000AD0000000000000000000000000000000000000003D00000000plasma-active-window-control-116.7736a87/lib/appmenuapplet.h/*
    SPDX-FileCopyrightText: 2016 Kai Uwe Broulik <kde@privat.broulik.de>

SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#pragma once

#include <Plasma/Applet>

#include <QAbstractItemModel>
#include <QPointer>

class QQuickItem;
class QMenu;

class AppMenuApplet : public Plasma::Applet
{
    Q_OBJECT

Q_PROPERTY(QObject *containment READ containment CONSTANT)
    Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelChanged)

Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)

Q_PROPERTY(int view READ view WRITE setView NOTIFY viewChanged)

Q_PROPERTY(int currentIndex READ currentIndex NOTIFY currentIndexChanged)

Q_PROPERTY(QQuickItem *buttonGrid READ buttonGrid WRITE setButtonGrid NOTIFY buttonGridChanged)

Q_PROPERTY(QString auroraeThemePath READ auroraeThemePath NOTIFY auroraeThemePathChanged)

Q_PROPERTY(QString auroraeThemeType READ auroraeThemeType NOTIFY auroraeThemeTypeChanged)

public:
    enum ViewType {
        FullView,
        CompactView,
    };

explicit AppMenuApplet(QObject *parent, const KPluginMetaData &data, const QVariantList &args);
    ~AppMenuApplet() override;

void init() override;

int currentIndex() const;

QQuickItem *buttonGrid() const;
    void setButtonGrid(QQuickItem *buttonGrid);

QAbstractItemModel *model() const;
    void setModel(QAbstractItemModel *model);

bool enabled() const;
    void setEnabled(bool enabled);

int view() const;
    void setView(int type);

void registerService();
    void unregisterService();

QString auroraeThemePath() const;
    QString auroraeThemeType() const;
    Q_INVOKABLE QString extensionForTheme(const QString &themeDirectoryPath);
    Q_INVOKABLE QString translateThemePath(const QString &themeDirectoryPath);
    Q_INVOKABLE void refreshAuroraeTheme();

Q_SIGNALS:
    void modelChanged();
    void enabledChanged();
    void viewChanged();
    void currentIndexChanged();
    void buttonGridChanged();
    void requestActivateIndex(int index);
    void auroraeThemePathChanged();
    void auroraeThemeTypeChanged();

public Q_SLOTS:
    void trigger(QQuickItem *ctx, int idx);

protected:
    bool eventFilter(QObject *watched, QEvent *event) override;

private:
    QMenu *createMenu(int idx) const;
    void setCurrentIndex(int currentIndex);
    void onMenuAboutToHide();

int m_currentIndex = -1;
    bool m_enabled = false;
    int m_viewType = FullView;
    QPointer<QMenu> m_currentMenu;
    QPointer<QQuickItem> m_buttonGrid;
    QPointer<QAbstractItemModel> m_model;
    static int s_refs;
    QString m_auroraeDecorationPath = QString();
    QString m_auroraeDecorationType = QString("svg");
};
07070100000012000081A40000000000000000000000016626CF9D00000029000000000000000000000000000000000000003100000000plasma-active-window-control-116.7736a87/lib/rev4c9957c8a8878e6df08fd95433f561a06d16bc4e
07070100000013000041ED0000000000000000000000036626CF9D00000000000000000000000000000000000000000000003100000000plasma-active-window-control-116.7736a87/package07070100000014000041ED0000000000000000000000056626CF9D00000000000000000000000000000000000000000000003A00000000plasma-active-window-control-116.7736a87/package/contents07070100000015000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000004100000000plasma-active-window-control-116.7736a87/package/contents/config07070100000016000081A40000000000000000000000016626CF9D00000328000000000000000000000000000000000000004C00000000plasma-active-window-control-116.7736a87/package/contents/config/config.qmlimport QtQuick 2.2
import org.kde.plasma.configuration 2.0

ConfigModel {
    ConfigCategory {
         name: i18n("Appearance")
         icon: "preferences-desktop-color"
         source: "config/ConfigAppearance.qml"
    }
    ConfigCategory {
         name: i18n("Behaviour")
         icon: "preferences-desktop"
         source: "config/ConfigBehaviour.qml"
    }
    ConfigCategory {
         name: i18n("Buttons")
         icon: "preferences-other"
         source: "config/ConfigButtons.qml"
    }
    ConfigCategory {
         name: i18n("Mouse Control")
         icon: "preferences-desktop-mouse"
         source: "config/ConfigMouseControl.qml"
    }
    ConfigCategory {
         name: i18n("Application Menu")
         icon: "application-menu"
         source: "config/ConfigAppMenu.qml"
    }
}
07070100000017000081A40000000000000000000000016626CF9D00001C23000000000000000000000000000000000000004A00000000plasma-active-window-control-116.7736a87/package/contents/config/main.xml<?xml version="1.0" encoding="UTF-8"?>
<kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
      http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
    <kcfgfile name=""/>

<group name="Appearance">
        <entry name="showControlButtons" type="Bool">
            <default>true</default>
        </entry>
        <entry name="showMinimize" type="Bool">
            <default>false</default>
        </entry>
        <entry name="showMaximize" type="Bool">
            <default>false</default>
        </entry>
        <entry name="showPinToAllDesktops" type="Bool">
            <default>false</default>
        </entry>
        <entry name="buttonOrder" type="String">
            <default>close|maximize|minimize|pin</default>
        </entry>
        <entry name="automaticButtonThemeEnabled" type="Bool">
            <default>true</default>
        </entry>
        <entry name="customAuroraeThemePath" type="String">
            <default></default>
        </entry>
        <entry name="doNotHideControlButtons" type="Bool">
            <default>false</default>
        </entry>
        <entry name="buttonsStandalone" type="Bool">
            <default>false</default>
        </entry>
        <entry name="buttonsBetweenIconAndText" type="Bool">
            <default>false</default>
        </entry>
        <entry name="buttonsDynamicWidth" type="Bool">
            <default>false</default>
        </entry>
        <entry name="slidingIconAndText" type="Bool">
            <default>false</default>
        </entry>
        <entry name="showButtonOnlyWhenMaximized" type="Bool">
            <default>false</default>
        </entry>
        <entry name="buttonsPosition" type="Enum">
            <choices>
                <choice name="UpperLeft"/>
                <choice name="UpperRight"/>
                <choice name="BottomLeft"/>
                <choice name="BottomRight"/>
            </choices>
            <default>0</default>
        </entry>
        <entry name="buttonsVerticalCenter" type="Bool">
            <default>false</default>
        </entry>
        <entry name="buttonSize" type="Double">
            <default>0.5</default>
        </entry>
        <entry name="controlButtonsSpacing" type="Double">
            <default>10</default>
        </entry>

<entry name="autoFillWidth" type="Bool">
            <default>false</default>
        </entry>
        <entry name="horizontalScreenWidthPercent" type="Double">
            <default>0.2</default>
        </entry>
        <entry name="widthFineTuning" type="Double">
            <default>0.0</default>
        </entry>
        <entry name="showWindowTitle" type="Bool">
            <default>true</default>
        </entry>
        <entry name="textType" type="Int">
            <default>0</default>
        </entry>
        <entry name="fitText" type="Int">
            <default>0</default>
        </entry>
        <entry name="tooltipTextType" type="Int">
            <default>0</default>
        </entry>
        <entry name="useWindowTitleReplace" type="Bool">
            <default>false</default>
        </entry>
        <entry name="replaceTextRegex" type="String">
            <default>^(.*)\s*[—–\-:]\s*(Mozilla )?([^—–\-:]+)$</default>
        </entry>
        <entry name="replaceTextReplacement" type="String">
            <default>$3 — $1</default>
        </entry>
        <entry name="noWindowText" type="String">
            <default>Plasma Desktop :: %activity%</default>
        </entry>
        <entry name="noWindowIcon" type="String">
            <default></default>
        </entry>
        <entry name="limitTextWidth" type="Bool">
            <default>false</default>
        </entry>
        <entry name="textWidthLimit" type="Int">
            <default>1000</default>
        </entry>
        <entry name="showWindowIcon" type="Bool">
            <default>true</default>
        </entry>
        <entry name="windowIconOnTheRight" type="Bool">
            <default>false</default>
        </entry>
        <entry name="boldFontWeight" type="Bool">
            <default>false</default>
        </entry>
        <entry name="fontFamily" type="String">
            <default></default>
        </entry>
        <entry name="iconAndTextSpacing" type="Double">
            <default>5</default>
        </entry>
        <entry name="fontSizeScale" type="Double">
            <default>1</default>
        </entry>
    </group>

<group name="Behaviour">
        <entry name="showForCurrentScreenOnly" type="Bool">
            <default>false</default>
        </entry>
    </group>

<group name="AppMenu">
        <entry name="appmenuEnabled" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuNextToButtons" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuFillHeight" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuFontBold" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuDoNotHide" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuNextToIconAndText" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuSwitchSidesWithIconAndText" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuSeparatorEnabled" type="Bool">
            <default>true</default>
        </entry>
        <entry name="appmenuBoldTitleWhenMenuDisplayed" type="Bool">
            <default>false</default>
        </entry>
        <entry name="appmenuOuterSideMargin" type="Int">
            <default>0</default>
        </entry>
        <entry name="appmenuIconAndTextOpacity" type="Double">
            <default>0.1</default>
        </entry>
        <entry name="appmenuButtonTextSizeScale" type="Double">
            <default>1.0</default>
        </entry>
    </group>

<group name="MouseControl">
        <entry name="doubleClickMaximizes" type="Bool">
            <default>true</default>
        </entry>
        <entry name="leftClickAction" type="Enum">
            <choices>
                <choice name="Disabled"/>
                <choice name="Expose"/>
                <choice name="ExposeAll"/>
                <choice name="ExposeClass"/>
            </choices>
            <default>0</default>
        </entry>
        <entry name="middleClickAction" type="Enum">
            <choices>
                <choice name="Disabled"/>
                <choice name="Close"/>
                <choice name="Fullscreen"/>
            </choices>
            <default>0</default>
        </entry>
        <entry name="wheelUpMaximizes" type="Bool">
            <default>false</default>
        </entry>
        <entry name="wheelDownAction" type="Enum">
            <choices>
                <choice name="Minimize"/>
                <choice name="Unmaximize"/>
            </choices>
            <default>0</default>
        </entry>
    </group>

</kcfg>
07070100000018000041ED0000000000000000000000046626CF9D00000000000000000000000000000000000000000000004000000000plasma-active-window-control-116.7736a87/package/contents/icons07070100000019000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000004C00000000plasma-active-window-control-116.7736a87/package/contents/icons/breeze-dark0707010000001A000081A40000000000000000000000016626CF9D00004054000000000000000000000000000000000000005C00000000plasma-active-window-control-116.7736a87/package/contents/icons/breeze-dark/alldesktops.svg<?xml version="1.0" encoding="UTF-8" standalone="no"?>

Item {
    id: appmenu
    anchors.fill: parent

property bool appmenuEnabled: plasmoid.configuration.appmenuEnabled
    property bool appmenuNextToButtons: plasmoid.configuration.appmenuNextToButtons
    property bool appmenuFillHeight: plasmoid.configuration.appmenuFillHeight
    property bool appmenuFontBold: plasmoid.configuration.appmenuFontBold
    property bool appmenuDoNotHide: plasmoid.configuration.appmenuDoNotHide
    property bool appmenuEnabledAndNonEmpty: appmenuEnabled && appMenuModel !== null && appMenuModel.menuAvailable
    property bool appmenuOpened: appmenuEnabled && plasmoid.nativeInterface.currentIndex > -1
    property var appMenuModel: null

property bool appmenuButtonsOffsetEnabled: !buttonsStandalone && appmenuNextToButtons && childrenRect.width > 0
    property double appmenuOffsetWidth: visible && appmenuNextToIconAndText && !appmenuSwitchSidesWithIconAndText
                                                ? appmenu.childrenRect.width + (appmenuButtonsOffsetEnabled ? controlButtonsArea.width : 0) + appmenuSideMargin*2
                                                : 0

visible: appmenuEnabledAndNonEmpty && !noWindowActive && (appmenuDoNotHide || mouseHover || appmenuOpened)

GridLayout {
        id: buttonGrid

Layout.minimumWidth: implicitWidth
        Layout.minimumHeight: implicitHeight

flow: GridLayout.LeftToRight
        rowSpacing: 0
        columnSpacing: 0

anchors.top: parent.top
        anchors.left: parent.left

property double placementOffsetButtons: appmenuNextToButtons && controlButtonsArea.visible ? controlButtonsArea.width + appmenuSideMargin : 0
        property double placementOffset: appmenuNextToIconAndText && appmenuSwitchSidesWithIconAndText
                                            ? activeWindowListView.anchors.leftMargin + windowTitleText.anchors.leftMargin + windowTitleText.contentWidth + appmenuSideMargin
                                            : placementOffsetButtons

anchors.leftMargin: (bp === 1 || bp === 3) ? parent.width - width - placementOffset : placementOffset
        anchors.topMargin: (bp === 2 || bp === 3) ? 0 : parent.height - height

Component.onCompleted: {
            plasmoid.nativeInterface.buttonGrid = buttonGrid
            plasmoid.nativeInterface.enabled = appmenuEnabled
        }

Connections {
            target: plasmoid.nativeInterface
            onRequestActivateIndex: {
                var idx = Math.max(0, Math.min(buttonRepeater.count - 1, index))
                var button = buttonRepeater.itemAt(index)
                if (button) {
                    button.clicked(null)
                }
            }
        }

Repeater {
            id: buttonRepeater
            model: null

MouseArea {
                id: appmenuButton

hoverEnabled: true
                visible: appmenuButtonTitle.text !== ""

readonly property int buttonIndex: index

property bool menuOpened: plasmoid.nativeInterface.currentIndex === index

Layout.preferredWidth: appmenuButtonBackground.width
                Layout.preferredHeight: appmenuButtonBackground.height

Rectangle {
                    id: appmenuButtonBackground
                    border.color: 'transparent'
                    width: appmenuButtonTitle.implicitWidth + units.smallSpacing * 3
                    height: appmenuFillHeight ? appmenu.height : appmenuButtonTitle.implicitHeight + units.smallSpacing
                    color: menuOpened ? theme.highlightColor : 'transparent'
                    radius: units.smallSpacing / 2
                }

PlasmaComponents.Label {
                    id: appmenuButtonTitle
                    anchors.top: appmenuButtonBackground.top
                    anchors.bottom: appmenuButtonBackground.bottom
                    verticalAlignment: Text.AlignVCenter
                    anchors.horizontalCenter: appmenuButtonBackground.horizontalCenter
                    font.pixelSize: fontPixelSize * plasmoid.configuration.appmenuButtonTextSizeScale
                    text: activeMenu.replace('&', '')
                    font.weight: appmenuFontBold ? Font.Bold : theme.defaultFont.weight
                }

onClicked: {
                    plasmoid.nativeInterface.trigger(this, index)
                }

onEntered: {
                    appmenuButtonBackground.border.color = theme.highlightColor
                }

onExited: {
                    appmenuButtonBackground.border.color = 'transparent'
                }
            }
        }
    }

Rectangle {
        id: separator
        anchors.left: buttonGrid.left
        anchors.leftMargin: appmenuSwitchSidesWithIconAndText ? - appmenuSideMargin * 0.5 : buttonGrid.width + appmenuSideMargin * 0.5
        anchors.verticalCenter: buttonGrid.verticalCenter
        height: 0.8 * parent.height
        width: 1
        visible: appmenuNextToIconAndText && plasmoid.configuration.appmenuSeparatorEnabled
        color: theme.textColor
        opacity: 0.4
    }

function resetAppmenuModel() {
        if (appmenuEnabled) {
            initializeAppModel()
            if (appMenuModel === null) {
                return
            }
            print('setting model in QML: ' + appMenuModel)
            for (var key in appMenuModel) {
                print('  ' + key + ' -> ' + appMenuModel[key])
            }
            plasmoid.nativeInterface.model = appMenuModel
            buttonRepeater.model = appMenuModel
        } else {
            plasmoid.nativeInterface.model = null
            buttonRepeater.model = null
        }
    }

onAppmenuEnabledChanged: {
        appmenu.resetAppmenuModel()
        if (appMenuModel !== null) {
            plasmoid.nativeInterface.enabled = appmenuEnabled
        }
    }

}
07070100000025000081A40000000000000000000000016626CF9D000008A1000000000000000000000000000000000000004F00000000plasma-active-window-control-116.7736a87/package/contents/ui/ControlButton.qml/*
    SPDX-FileCopyrightText: 2015 Martin Kotelnik <clearmartin@seznam.cz>

SPDX-License-Identifier: GPL-2.0-or-later
*/
import QtQuick 2.2
import org.kde.plasma.plasmoid 2.0
import org.kde.ksvg as KSvg

MouseArea {
    id: controlButton

height: controlButtonsArea.height
    width: controlButtonsArea.controlButtonsHeight

property bool mouseInside: false
    property bool iconActive: (iconName !== 'alldesktops' && iconName !== 'maximize') || (iconName === 'alldesktops' && main.isActiveWindowPinned) || (iconName === 'maximize' && main.currentWindowMaximized)

property string themeName: textColorLight ? 'breeze-dark' : 'default'
    property string customAuroraeThemePath: main.automaticButtonThemeEnabled ? plasmoid.nativeInterface.auroraeThemePath : manualAuroraeThemePathResolved
    property string customAuroraeImageExt: main.automaticButtonThemeEnabled ? plasmoid.nativeInterface.auroraeThemeType : manualAuroraeThemeExtension
    property bool usingAuroraeTheme: customAuroraeThemePath ? true : false
    property string buttonImagePath: customAuroraeThemePath ? customAuroraeThemePath + '/' + iconName + '.' + customAuroraeImageExt : Qt.resolvedUrl('../icons/' + themeName + '/' + iconName + '.svg')
    property string svgElementId: usingAuroraeTheme
                                    ? (iconActive && iconName === 'alldesktops') ? (mouseInside ? 'pressed-center' : 'pressed-center') : (mouseInside ? 'hover-center' : 'active-center')
                                    : iconActive ? (mouseInside ? 'active-hover' : 'active-idle') : (mouseInside ? 'inactive-hover' : 'inactive-idle')

KSvg.Svg {
        id: buttonSvg
        imagePath: buttonImagePath
    }

// icon
    KSvg.SvgItem {
        id: svgItem
        width: parent.width
        height: width
        svg: buttonSvg
        elementId: svgElementId
        anchors.verticalCenter: parent.verticalCenter
    }

hoverEnabled: true

onEntered: {
        mouseInside = true
    }

onExited: {
        mouseInside = false
    }

// trigger active window action
    onClicked: {
        controlButtonsArea.mouseInWidget = true
        main.performActiveWindowAction(windowOperation)
    }
}
07070100000026000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000004400000000plasma-active-window-control-116.7736a87/package/contents/ui/config07070100000027000081A40000000000000000000000016626CF9D00000F5C000000000000000000000000000000000000005600000000plasma-active-window-control-116.7736a87/package/contents/ui/config/ConfigAppMenu.qmlimport QtQuick 2.20
import QtQuick.Controls
import QtQuick.Layouts
import org.kde.kcmutils as KCMUtils

KCMUtils.SimpleKCM {
    id: main

property alias cfg_appmenuEnabled: appmenuEnabled.checked
    property alias cfg_appmenuNextToButtons: appmenuNextToButtons.checked
    property alias cfg_appmenuFillHeight: appmenuFillHeight.checked
    property alias cfg_appmenuFontBold: appmenuFontBold.checked
    property alias cfg_appmenuDoNotHide: appmenuDoNotHide.checked
    property alias cfg_appmenuNextToIconAndText: appmenuNextToIconAndText.checked
    property alias cfg_appmenuSwitchSidesWithIconAndText: appmenuSwitchSidesWithIconAndText.checked
    property alias cfg_appmenuSeparatorEnabled: appmenuSeparatorEnabled.checked
    property alias cfg_appmenuBoldTitleWhenMenuDisplayed: appmenuBoldTitleWhenMenuDisplayed.checked
    property alias cfg_appmenuOuterSideMargin: appmenuOuterSideMargin.value
    property alias cfg_appmenuIconAndTextOpacity: appmenuIconAndTextOpacity.value
    property alias cfg_appmenuButtonTextSizeScale: appmenuButtonTextSizeScale.value

GroupBox {
        id: appmenuEnabled
        title: i18n("Enable application menu")
        checkable: true
        flat: true

GridLayout {
            columns: 2

Item {
                width: 2
                height: 10
                Layout.columnSpan: 2
            }

CheckBox {
                id: appmenuFillHeight
                text: i18n("Fill height")
                Layout.columnSpan: 2
            }

CheckBox {
                id: appmenuFontBold
                text: i18n("Bold font")
                Layout.columnSpan: 2
            }

CheckBox {
                id: appmenuDoNotHide
                text: i18n("Do not hide on mouse out")
            }

CheckBox {
                id: appmenuNextToButtons
                text: i18n("Show next to buttons")
                Layout.columnSpan: 2
            }

CheckBox {
                id: appmenuNextToIconAndText
                text: i18n("Show next to icon and text")
                Layout.columnSpan: 2
            }

CheckBox {
                id: appmenuSwitchSidesWithIconAndText
                text: i18n("Switch sides with icon and text")
                Layout.columnSpan: 2
                enabled: appmenuNextToIconAndText.checked
            }

CheckBox {
                id: appmenuSeparatorEnabled
                text: i18n("Show separator")
                Layout.columnSpan: 2
                enabled: appmenuNextToIconAndText.checked
            }

CheckBox {
                id: appmenuBoldTitleWhenMenuDisplayed
                text: i18n("Make window title bold when menu is displayed")
                Layout.columnSpan: 2
            }

Label {
                text: i18n('Side margin:')
                Layout.alignment: Qt.AlignRight
            }
            SpinBox {
                id: appmenuOuterSideMargin
                decimals: 0
                stepSize: 1
                minimumValue: 0
                maximumValue: 100
                suffix: i18nc('Abbreviation for pixels', 'px')
            }

Label {
                text: i18n('Icon and text opacity:')
                Layout.alignment: Qt.AlignRight
            }
            SpinBox {
                id: appmenuIconAndTextOpacity
                decimals: 2
                stepSize: 0.1
                minimumValue: 0
                maximumValue: 1
            }

Label {
                text: i18n('Menu button text size scale:')
                Layout.alignment: Qt.AlignRight
            }
            SpinBox {
                id: appmenuButtonTextSizeScale
                decimals: 2
                stepSize: 0.1
                minimumValue: 0.5
                maximumValue: 5
            }
        }
    }

}
07070100000028000081A40000000000000000000000016626CF9D00002E39000000000000000000000000000000000000005900000000plasma-active-window-control-116.7736a87/package/contents/ui/config/ConfigAppearance.qmlimport QtQuick 2.20
import QtQuick.Controls
import QtQuick.Layouts
import org.kde.plasma.plasma5support as Plasma5Support
import org.kde.kcmutils as KCMUtils

KCMUtils.SimpleKCM {
    id: appearancePage

signal configurationChanged

property alias cfg_autoFillWidth: autoFillWidth.checked
    property alias cfg_horizontalScreenWidthPercent: horizontalScreenWidthPercent.value
    property alias cfg_widthFineTuning: widthFineTuning.value

property alias cfg_showWindowTitle: showWindowTitle.checked
    property alias cfg_textType: textTypeCombo.currentIndex
    property alias cfg_fitText: fitTextCombo.currentIndex
    property alias cfg_tooltipTextType: tooltipTextTypeCombo.currentIndex
    property alias cfg_showWindowIcon: showWindowIcon.checked
    property alias cfg_windowIconOnTheRight: windowIconOnTheRight.checked
    property alias cfg_useWindowTitleReplace: useWindowTitleReplace.checked
    property alias cfg_replaceTextRegex: replaceTextRegex.text
    property alias cfg_replaceTextReplacement: replaceTextReplacement.text
    property alias cfg_noWindowText: noWindowText.text
    property string cfg_noWindowIcon: plasmoid.configuration.noWindowIcon
    property alias cfg_limitTextWidth: limitTextWidth.checked
    property alias cfg_textWidthLimit: textWidthLimit.value

property alias cfg_boldFontWeight: boldFontWeight.checked
    property string cfg_fontFamily
    property alias cfg_iconAndTextSpacing: iconAndTextSpacing.value
    property alias cfg_fontSizeScale: fontSizeScale.value

Plasma5Support.DataSource {
        id: executableDS
        engine: 'executable'

property string cmdBorderlessRead: 'kreadconfig5 --file kwinrc --group Windows --key BorderlessMaximizedWindows'
        property string cmdBorderlessWrite: 'kwriteconfig5 --file kwinrc --group Windows --key BorderlessMaximizedWindows --type bool {borderless}'
        property string cmdReconfigure: 'qdbus org.kde.KWin /KWin reconfigure'

connectedSources: []

onNewData: {
            connectedSources.length = 0
            print('sourceName: ' + sourceName)
            if (sourceName === cmdBorderlessRead) {
                var trimmedStdout = data.stdout.trim()
                print('current value: ' + trimmedStdout)
                toggleBorderlessMaximizedWindows.checked = trimmedStdout === 'true'
            } else if (sourceName.indexOf('kwriteconfig5') === 0) {
                connectedSources.push(cmdReconfigure)
            }
        }
    }

/* copied from /usr/share/plasma/plasmoids/org.kde.plasma.digitalclock/contents/ui/configAppearance.qml */
    onCfg_fontFamilyChanged: {
        // HACK by the time we populate our model and/or the ComboBox is finished the value is still undefined
        if (cfg_fontFamily) {
            for (var i = 0, j = fontsModel.count; i < j; ++i) {
                if (fontsModel.get(i).value == cfg_fontFamily) {
                    fontFamilyComboBox.currentIndex = i
                    break
                }
            }
        }
    }

ListModel {
        id: fontsModel
        Component.onCompleted: {
            var arr = [ {text: i18nc("Use default font", "Default"), value: ""} ]
            Qt.fontFamilies().forEach(function (font) {
                arr.push({text: font, value: font})
            })
            append(arr)
            cfg_fontFamilyChanged();
        }
    }

Component.onCompleted: {
        executableDS.connectedSources.push(executableDS.cmdBorderlessRead)
    }

GridLayout {
        columns: 2

Label {
            text: i18n('Plasmoid version: ') + '1.7.4'
            Layout.alignment: Qt.AlignRight
            Layout.columnSpan: 2
        }

Label {
            text: i18n("Width in horizontal panel:")
            Layout.alignment: Qt.AlignVCenter|Qt.AlignLeft
            Layout.columnSpan: 2
        }

CheckBox {
            id: autoFillWidth
            text: i18n("Fill width")
            Layout.columnSpan: 2
        }

GridLayout {
            columns: 2
            Layout.columnSpan: 2
            enabled: !autoFillWidth.checked

Slider {
                id: horizontalScreenWidthPercent
                stepSize: 0.001
                minimumValue: 0.001
                maximumValue: 1
                Layout.preferredWidth: appearancePage.width
                Layout.columnSpan: 2
            }

Label {
                text: i18n("Fine tuning:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }
            SpinBox {
                id: widthFineTuning
                decimals: 1
                stepSize: 0.5
                minimumValue: -100
                maximumValue: 100
            }
        }

Item {
            width: 2
            height: 10
            Layout.columnSpan: 2
        }

CheckBox {
            id: toggleBorderlessMaximizedWindows
            text: i18n("Hide titlebar for maximized windows (takes effect immediately)")
            Layout.columnSpan: 2
            onCheckedChanged: {
                var preparedCmd = executableDS.cmdBorderlessWrite.replace('{borderless}', String(checked))
                executableDS.connectedSources.push(preparedCmd)
            }
        }

Item {
            width: 2
            height: 10
            Layout.columnSpan: 2
        }

GroupBox {
            id: showWindowTitle
            title: i18n("Show window title")
            checkable: true
            flat: true
            Layout.columnSpan: 2

GridLayout {
                columns: 2

Item {
                    width: 2
                    height: 10
                    Layout.columnSpan: 2
                }

Label {
                    text: i18n('Text type:')
                    Layout.alignment: Qt.AlignRight
                }
                ComboBox {
                    id: textTypeCombo
                    model: [i18n('Window title'), i18n('Application name')]
                }

Label {
                    text: i18n('Fit text:')
                    Layout.alignment: Qt.AlignRight
                }
                ComboBox {
                    id: fitTextCombo
                    model: [i18n('Just elide'), i18n('Fit on hover'), i18n('Always fit')]
                }

Label {
                    text: i18n('Tooltip text:')
                    Layout.alignment: Qt.AlignRight
                }
                ComboBox {
                    id: tooltipTextTypeCombo
                    model: [i18n('No tooltip'), i18n('Window title'), i18n('Application name')]
                }

CheckBox {
                    id: useWindowTitleReplace
                    text: '"' + i18n('Window title') + '".replace(/'
                    Layout.alignment: Qt.AlignRight
                }
                GridLayout {
                    columns: 4

TextField {
                        id: replaceTextRegex
                        placeholderText: '^(.*)\\s+[—–\\-:]\\s+([^—–\\-:]+)$'
                        Layout.preferredWidth: 300
                        onTextChanged: cfg_replaceTextRegex = text
                        enabled: useWindowTitleReplace.checked
                    }

Label {
                        text: '/, "'
                    }

TextField {
                        id: replaceTextReplacement
                        placeholderText: '$2 — $1'
                        Layout.preferredWidth: 100
                        onTextChanged: cfg_replaceTextReplacement = text
                        enabled: useWindowTitleReplace.checked
                    }

Label {
                        text: '");'
                    }
                }

Label {
                    text: i18n('No window text:')
                    Layout.alignment: Qt.AlignRight
                }
                GridLayout {
                    columns: 2

TextField {
                        id: noWindowText
                        placeholderText: 'Plasma Desktop :: %activity%'
                        onTextChanged: cfg_noWindowText = text
                        Layout.preferredWidth: 300
                    }

Label {
                        text: i18n('Use %activity% placeholder to show current activity name.')
                        Layout.preferredWidth: 200
                        wrapMode: Text.Wrap
                    }
                }

Label {
                    text: i18n("No window icon:")
                    Layout.alignment: Qt.AlignRight
                }
                IconPicker {
                    currentIcon: cfg_noWindowIcon
                    defaultIcon: ''
                    onIconChanged: cfg_noWindowIcon = iconName
                }

CheckBox {
                    id: limitTextWidth
                    text: i18n('Limit text width')
                    Layout.alignment: Qt.AlignRight
                }
                SpinBox {
                    id: textWidthLimit
                    decimals: 0
                    stepSize: 10
                    minimumValue: 0
                    maximumValue: 10000
                    enabled: limitTextWidth.checked
                    suffix: i18nc('Abbreviation for pixels', 'px')
                }
            }
        }

Item {
            width: 2
            height: 10
            Layout.columnSpan: 2
        }

CheckBox {
            id: showWindowIcon
            text: i18n("Show window icon")
            Layout.columnSpan: 2
        }

CheckBox {
            id: windowIconOnTheRight
            text: i18n("Window icon on the right")
            Layout.columnSpan: 2
        }

Item {
            width: 2
            height: 10
            Layout.columnSpan: 2
        }

GridLayout {
            columns: 2

Layout.columnSpan: 2

Item {
                width: 2
                height: 10
            }
            CheckBox {
                id: boldFontWeight
                text: i18n("Bold text")
            }

Label {
                text: i18n('Text font:')
                Layout.alignment: Qt.AlignRight
            }
            ComboBox {
                id: fontFamilyComboBox
                // ComboBox's sizing is just utterly broken
                Layout.minimumWidth: units.gridUnit * 10
                model: fontsModel
                // doesn't autodeduce from model because we manually populate it
                textRole: "text"
                onCurrentIndexChanged: {
                    var current = model.get(currentIndex)
                    if (current) {
                        cfg_fontFamily = current.value
                        appearancePage.configurationChanged()
                        console.log('change: ' + cfg_fontFamily)
                    }
                }
            }

Label {
                text: i18n("Icon and text spacing:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }
            SpinBox {
                id: iconAndTextSpacing
                decimals: 1
                stepSize: 0.5
                minimumValue: 0.5
                maximumValue: 300
            }

Label {
                text: i18n("Font size scale:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }
            SpinBox {
                id: fontSizeScale
                decimals: 2
                stepSize: 0.05
                minimumValue: 0
                maximumValue: 3
            }

}

}
07070100000029000081A40000000000000000000000016626CF9D000001AF000000000000000000000000000000000000005800000000plasma-active-window-control-116.7736a87/package/contents/ui/config/ConfigBehaviour.qmlimport QtQuick 2.20
import QtQuick.Controls
import QtQuick.Layouts
import org.kde.kcmutils as KCMUtils

KCMUtils.SimpleKCM {

property alias cfg_showForCurrentScreenOnly: showForCurrentScreenOnly.checked

GridLayout {
        columns: 2

CheckBox {
            id: showForCurrentScreenOnly
            text: i18n("Show active window only for plasmoid's screen")
            Layout.columnSpan: 2
        }

}

}
0707010000002A000081A40000000000000000000000016626CF9D00002561000000000000000000000000000000000000005600000000plasma-active-window-control-116.7736a87/package/contents/ui/config/ConfigButtons.qmlimport QtQuick 2.20
import QtQuick.Controls
import QtQuick.Layouts
import QtQml.Models
import org.kde.kcmutils as KCMUtils

KCMUtils.SimpleKCM {

property alias cfg_showControlButtons: showControlButtons.checked
    property alias cfg_doNotHideControlButtons: doNotHideControlButtons.checked
    property int cfg_buttonsPosition
    property alias cfg_buttonsVerticalCenter: buttonsVerticalCenter.checked
    property alias cfg_buttonsStandalone: buttonsStandalone.checked
    property alias cfg_buttonsBetweenIconAndText: buttonsBetweenIconAndText.checked
    property alias cfg_buttonsDynamicWidth: buttonsDynamicWidth.checked
    property alias cfg_slidingIconAndText: slidingIconAndText.checked
    property alias cfg_showButtonOnlyWhenMaximized: showButtonOnlyWhenMaximized.checked
    property alias cfg_showMinimize: showMinimize.checked
    property alias cfg_showMaximize: showMaximize.checked
    property alias cfg_showPinToAllDesktops: showPinToAllDesktops.checked
    property alias cfg_buttonSize: buttonSize.value
    property alias cfg_controlButtonsSpacing: controlButtonsSpacing.value
    property string cfg_buttonOrder
    property alias cfg_automaticButtonThemeEnabled: automaticButtonThemeEnabled.checked
    property alias cfg_customAuroraeThemePath: customAuroraeThemePath.text

onCfg_buttonsPositionChanged: {
        switch (cfg_buttonsPosition) {
        case 0:
            buttonsPositionGroup.current = upperLeftRadio;
            break;
        case 1:
            buttonsPositionGroup.current = upperRightRadio;
            break;
        case 2:
            buttonsPositionGroup.current = bottomLeftRadio;
            break;
        case 3:
            buttonsPositionGroup.current = bottomRightRadio;
            break;
        default:
            buttonsPositionGroup.current = upperLeftRadio;
        }
    }

Component.onCompleted: {
        cfg_buttonsPositionChanged()
        sortButtonOrder()
    }

ListModel {
        id: buttonsToSpend
        ListElement {
            text: "close"
        }
        ListElement {
            text: "minimize"
        }
        ListElement {
            text: "maximize"
        }
        ListElement {
            text: "alldesktops"
        }
    }

ExclusiveGroup {
        id: buttonsPositionGroup
    }

GroupBox {
        id: showControlButtons
        title: i18n("Enable Control Buttons")
        checkable: true
        flat: true

GridLayout {
            columns: 2

Item {
                width: 2
                height: 10
                Layout.columnSpan: 2
            }

Item {
                width: 2
                height: 2
                Layout.rowSpan: 3
            }

CheckBox {
                id: showMinimize
                text: i18n("Show minimize button")
            }

CheckBox {
                id: showMaximize
                text: i18n("Show maximize button")
            }

CheckBox {
                id: showPinToAllDesktops
                text: i18n("Show pin to all desktops")
            }

Item {
                width: 2
                height: 10
                Layout.columnSpan: 2
            }

Label {
                text: i18n("Button order:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }

OrderableListView {
                id: buttonOrder
                height: units.gridUnit * 2
                width: height * 4
                model: ListModel {
                    // will be filled initially by sortButtonOrder() method
                }
                orientation: ListView.Horizontal
                itemWidth: width / 4
                itemHeight: itemWidth

onModelOrderChanged: {
                    var orderStr = '';
                    for (var i = 0; i < model.count; i++) {
                        var item = model.get(i)
                        if (orderStr.length > 0) {
                            orderStr += '|';
                        }
                        orderStr += item.text;
                    }
                    cfg_buttonOrder = orderStr;
                    print('written: ' + cfg_buttonOrder);
                }
            }

Item {
                width: 2
                height: 10
                Layout.columnSpan: 2
            }

Label {
                text: i18n("Behaviour:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }

CheckBox {
                id: doNotHideControlButtons
                text: i18n("Do not hide on mouse out")
            }

Item {
                width: 2
                height: 2
                Layout.rowSpan: 5
            }

CheckBox {
                id: showButtonOnlyWhenMaximized
                text: i18n("Show only when maximized")
            }

CheckBox {
                id: buttonsStandalone
                text: i18n("Buttons next to icon and text")
            }

CheckBox {
                id: buttonsBetweenIconAndText
                text: i18n("Buttons between icon and text")
                enabled: buttonsStandalone.checked
            }

CheckBox {
                id: buttonsDynamicWidth
                text: i18n("Dynamic width")
                enabled: buttonsStandalone.checked
            }

CheckBox {
                id: slidingIconAndText
                text: i18n("Sliding icon and text")
                enabled: buttonsStandalone.checked
            }

Item {
                width: 2
                height: 10
                Layout.columnSpan: 2
            }

Label {
                text: i18n("Position:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }
            RadioButton {
                id: upperLeftRadio
                exclusiveGroup: buttonsPositionGroup
                text: i18n("Upper left")
                onCheckedChanged: if (checked) cfg_buttonsPosition = 0;
            }
            Item {
                width: 2
                height: 2
                Layout.rowSpan: 4
            }
            RadioButton {
                id: upperRightRadio
                exclusiveGroup: buttonsPositionGroup
                text: i18n("Upper right")
                onCheckedChanged: if (checked) cfg_buttonsPosition = 1;
            }
            RadioButton {
                id: bottomLeftRadio
                exclusiveGroup: buttonsPositionGroup
                text: i18n("Bottom left")
                onCheckedChanged: if (checked) cfg_buttonsPosition = 2;
            }
            RadioButton {
                id: bottomRightRadio
                exclusiveGroup: buttonsPositionGroup
                text: i18n("Bottom right")
                onCheckedChanged: if (checked) cfg_buttonsPosition = 3;
            }

CheckBox {
                id: buttonsVerticalCenter
                text: i18n("Vertical center")
            }

Item {
                width: 2
                height: 10
                Layout.columnSpan: 2
            }

Label {
                text: i18n("Button size:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }
            Slider {
                id: buttonSize
                stepSize: 0.1
                minimumValue: 0.1
                tickmarksEnabled: true
                width: parent.width
            }

Label {
                text: i18n("Buttons spacing:")
                Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
            }
            Slider {
                id: controlButtonsSpacing
                stepSize: 1
                minimumValue: 0
                maximumValue: 20
                tickmarksEnabled: true
                width: parent.width
            }

Item {
                width: 2
                height: 10
                Layout.columnSpan: 2
            }

Label {
                text: i18n("Theme")
                Layout.columnSpan: parent.columns
                font.bold: true
            }
            CheckBox {
                id: automaticButtonThemeEnabled
                text: i18n("Automatic")
            }
            TextField {
                id: customAuroraeThemePath
                placeholderText: i18n("Absolute path to aurorae button theme folder")
                Layout.preferredWidth: 350
                onTextChanged: cfg_customAuroraeThemePath = text
                enabled: !automaticButtonThemeEnabled.checked
            }
        }
    }

}
0707010000002B000081A40000000000000000000000016626CF9D0000170F000000000000000000000000000000000000005B00000000plasma-active-window-control-116.7736a87/package/contents/ui/config/ConfigMouseControl.qmlimport QtQuick 2.20
import QtQuick.Controls
import QtQuick.Layouts
import org.kde.kcmutils as KCMUtils

KCMUtils.SimpleKCM {
    id: appearancePage

property alias cfg_doubleClickMaximizes: doubleClickMaximizes.checked
    property int cfg_leftClickAction
    property int cfg_middleClickAction

property alias cfg_wheelUpMaximizes: wheelUpMaximizes.checked
    property int cfg_wheelDownAction

onCfg_leftClickActionChanged: {
        switch (cfg_leftClickAction) {
        case 1:
            leftClickActionGroup.current = leftClickExposeRadio;
            break;
        case 2:
            leftClickActionGroup.current = leftClickExposeAllRadio;
            break;
        case 3:
            leftClickActionGroup.current = leftClickExposeClassRadio;
            break;
        case 0:
        default:
            leftClickActionGroup.current = leftClickDisabledRadio;
        }
    }

onCfg_middleClickActionChanged: {
        switch (cfg_middleClickAction) {
        case 1:
            middleClickActionGroup.current = middleClickCloseRadio;
            break;
        case 2:
            middleClickActionGroup.current = middleClickFullscreenRadio;
            break;
        case 0:
        default:
            middleClickActionGroup.current = middleClickDisabledRadio;
        }
    }

onCfg_wheelDownActionChanged: {
        switch (cfg_wheelDownAction) {
        case 1:
            wheelDownActionGroup.current = wheelDownMinimizesRadio;
            break;
        case 2:
            wheelDownActionGroup.current = wheelDownUnmaximizesRadio;
            break;
        case 0:
        default:
            wheelDownActionGroup.current = wheelDownDisabledRadio;
        }
    }

Component.onCompleted: {
        cfg_leftClickActionChanged()
        cfg_middleClickActionChanged()
        cfg_wheelDownActionChanged()
    }

ExclusiveGroup {
        id: leftClickActionGroup
    }

ExclusiveGroup {
        id: middleClickActionGroup
    }

ExclusiveGroup {
        id: wheelDownActionGroup
    }

GridLayout {
        id: displayPosition
        columns: 2

Label {
            text: i18n("Mouse Buttons:")
            Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
        }
        CheckBox {
            id: doubleClickMaximizes
            text: i18n("Doubleclick to toggle maximizing")
            onCheckedChanged: if (checked) leftClickDisabledRadio.checked = true
        }

Item {
            width: 2
            height: 10
            Layout.rowSpan: 4
        }
        RadioButton {
            id: leftClickDisabledRadio
            exclusiveGroup: leftClickActionGroup
            text: i18n("Left click disabled")
            onCheckedChanged: if (checked) cfg_leftClickAction = 0;
            enabled: !doubleClickMaximizes.checked
        }
        RadioButton {
            id: leftClickExposeRadio
            exclusiveGroup: leftClickActionGroup
            text: i18n("Left click to present windows (Current Desktop)")
            onCheckedChanged: if (checked) cfg_leftClickAction = 1;
            enabled: !doubleClickMaximizes.checked
        }
        RadioButton {
            id: leftClickExposeAllRadio
            exclusiveGroup: leftClickActionGroup
            text: i18n("Left click to present windows (All Desktops)")
            onCheckedChanged: if (checked) cfg_leftClickAction = 2;
            enabled: !doubleClickMaximizes.checked
        }
        RadioButton {
            id: leftClickExposeClassRadio
            exclusiveGroup: leftClickActionGroup
            text: i18n("Left click to present windows (Window Class)")
            onCheckedChanged: if (checked) cfg_leftClickAction = 3;
            enabled: !doubleClickMaximizes.checked
        }

Item {
            width: 2
            height: 10
            Layout.columnSpan: 2
        }
        Item {
            width: 2
            height: 2
            Layout.rowSpan: 3
        }
        RadioButton {
            id: middleClickDisabledRadio
            exclusiveGroup: middleClickActionGroup
            text: i18n("Middle click disabled")
            onCheckedChanged: if (checked) cfg_middleClickAction = 0;
        }
        RadioButton {
            id: middleClickCloseRadio
            exclusiveGroup: middleClickActionGroup
            text: i18n("Middle click to close active window")
            onCheckedChanged: if (checked) cfg_middleClickAction = 1;
        }
        RadioButton {
            id: middleClickFullscreenRadio
            exclusiveGroup: middleClickActionGroup
            text: i18n("Middle click to toggle fullscreen")
            onCheckedChanged: if (checked) cfg_middleClickAction = 2;
        }

Item {
            width: 2
            height: 10
            Layout.columnSpan: 2
        }

Label {
            text: i18n("Mouse Wheel:")
            Layout.alignment: Qt.AlignVCenter|Qt.AlignRight
        }
        CheckBox {
            id: wheelUpMaximizes
            text: i18n("Mouse wheel up to maximize")
        }
        Item {
            width: 2
            height: 2
            Layout.rowSpan: 3
        }
        RadioButton {
            id: wheelDownDisabledRadio
            exclusiveGroup: wheelDownActionGroup
            text: i18n("Mouse wheel down disabled")
            onCheckedChanged: if (checked) cfg_wheelDownAction = 0;
        }
        RadioButton {
            id: wheelDownMinimizesRadio
            exclusiveGroup: wheelDownActionGroup
            text: i18n("Mouse wheel down to minimize")
            onCheckedChanged: if (checked) cfg_wheelDownAction = 1;
        }
        RadioButton {
            id: wheelDownUnmaximizesRadio
            exclusiveGroup: wheelDownActionGroup
            text: i18n("Mouse wheel down to unmaximize")
            onCheckedChanged: if (checked) cfg_wheelDownAction = 2;
        }
    }

}
0707010000002C000081A40000000000000000000000016626CF9D00000A29000000000000000000000000000000000000005300000000plasma-active-window-control-116.7736a87/package/contents/ui/config/IconPicker.qml/*
    SPDX-FileCopyrightText: 2015 Martin Kotelnik <clearmartin@seznam.cz>

SPDX-License-Identifier: GPL-2.0-or-later
*/
import QtQuick 2.20
import QtQuick.Controls
import QtQuick.Layouts
import org.kde.kquickcontrolsaddons as KQuickAddons
import org.kde.plasma.core as PlasmaCore
import org.kde.plasma.extras as PlasmaExtras
import org.kde.plasma.components as PlasmaComponents
import org.kde.ksvg as KSvg
import org.kde.kirigami as Kirigami

// basically taken from kickoff
Button {
    id: iconButton

property string currentIcon
    property string defaultIcon

signal iconChanged(string iconName)

Layout.minimumWidth: Kirigami.Units.iconSizes.large + Kirigami.Units.smallSpacing * 2
    Layout.maximumWidth: Layout.minimumWidth

checkable: true
    enabled: useCustomIcon.checked

KQuickAddons.IconDialog {
        id: iconDialog
        onIconNameChanged: {
            iconPreview.source = iconName
            iconChanged(iconName)
        }
    }

// just to provide some visual feedback, cannot have checked without checkable enabled
    onClicked: {
        checked = Qt.binding(function() { // never actually allow it being checked
            return iconMenu.status === PlasmaExtras.Menu.Open
        })

iconMenu.open(0, height)
    }

KSvg.FrameSvgItem {
        id: previewFrame
        anchors.centerIn: parent
        imagePath: plasmoid.location === PlasmaCore.Types.Vertical || plasmoid.location === PlasmaCore.Types.Horizontal
                    ? "widgets/panel-background" : "widgets/background"
        width: units.iconSizes.large + fixedMargins.left + fixedMargins.right
        height: units.iconSizes.large + fixedMargins.top + fixedMargins.bottom

Kirigami.Icon {
            id: iconPreview
            anchors.centerIn: parent
            width: units.iconSizes.large
            height: width
            source: currentIcon
        }
    }

function setDefaultIcon() {
        iconPreview.source = defaultIcon
        iconChanged(defaultIcon)
    }

// QQC Menu can only be opened at cursor position, not a random one
    PlasmaExtras.Menu {
        id: iconMenu
        visualParent: iconButton

PlasmaExtras.MenuItem {
            text: i18nc("@item:inmenu Open icon chooser dialog", "Choose...")
            icon: "document-open-folder"
            onClicked: iconDialog.open()
        }
        PlasmaExtras.MenuItem {
            text: i18nc("@item:inmenu Reset icon to default", "Clear Icon")
            icon: "edit-clear"
            onClicked: cfg_icon = "folder-symbolic";
        }
    }
}
0707010000002D000081A40000000000000000000000016626CF9D00000A2E000000000000000000000000000000000000005600000000plasma-active-window-control-116.7736a87/package/contents/ui/config/OrderableItem.qmlimport QtQuick 2.0

Item {
    id: root

default property Item contentItem

// This item will become the parent of the dragged item during the drag operation
    property Item listViewParent

signal moveItemRequested(int from, int to)

width: contentItem.width
    height: contentItem.height

// Make contentItem a child of contentItemWrapper
    onContentItemChanged: {
        contentItem.parent = contentItemWrapper;
    }

Item {
        id: contentItemWrapper
        anchors.fill: parent
        Drag.active: dragArea.drag.active
        Drag.hotSpot {
            x: contentItem.width / 2
            y: contentItem.height / 2
        }

MouseArea {
            id: dragArea
            anchors.fill: parent
            drag.target: parent
            // Keep the dragged item at the same X position. Nice for lists, but not mandatory
            drag.axis: orientation == ListView.Vertical ? Drag.YAxis : Drag.XAxis
            // Disable smoothed so that the Item pixel from where we started the drag remains
            // under the mouse cursor
            drag.smoothed: false

cursorShape: Qt.OpenHandCursor

onReleased: {
                if (drag.active) {
                    emitMoveItemRequested();
                }
            }
        }
    }

states: [
        State {
            when: dragArea.drag.active
            name: 'dragging'

ParentChange {
                target: contentItemWrapper
                parent: listViewParent
            }
            PropertyChanges {
                target: contentItemWrapper
                opacity: 0.9
                anchors.fill: undefined
                width: contentItem.width
                height: contentItem.height
            }
            PropertyChanges {
                target: root
                height: 0
            }
        }
    ]

DropArea {
        id: itemDropArea
        anchors.fill: parent

property int dropIndex: model.index

Rectangle {
            id: dropIndicator
            anchors.fill: parent
            border.width: 1
            border.color: theme.highlightColor
            color: 'transparent'
            opacity: itemDropArea.containsDrag ? 1 : 0
        }
    }

function emitMoveItemRequested() {
        var dropArea = contentItemWrapper.Drag.target;
        if (!dropArea) {
            return;
        }
        var dropIndex = dropArea.dropIndex;

if (model.index === dropIndex) {
            return;
        }
        root.moveItemRequested(model.index, dropIndex);
    }
}
0707010000002E000081A40000000000000000000000016626CF9D00000621000000000000000000000000000000000000005A00000000plasma-active-window-control-116.7736a87/package/contents/ui/config/OrderableListView.qmlimport QtQuick 2.20
import QtQuick.Controls
import org.kde.ksvg as KSvg

Item {
    id: mainContent

property var model
    property int orientation
    property double itemWidth
    property double itemHeight
    property bool interactive

width: itemWidth * (orientation == ListView.Vertical ? 1 : model.count)
    height: itemHeight * (orientation == ListView.Horizontal ? 1 : model.count)

SystemPalette {
        id: palette
    }

// theme + svg
    property bool textColorLight: ((palette.text.r + palette.text.g + palette.text.b) / 3) > 0.5
    property string themeName: textColorLight ? 'breeze-dark' : 'default'

signal modelOrderChanged()

ListView {
        id: listView
        anchors.fill: parent
        model: mainContent.model
        orientation: mainContent.orientation
        delegate: OrderableItem {

listViewParent: listView.parent

Item {
                height: itemWidth
                width: itemHeight

// icon
                KSvg.SvgItem {
                    id: svgItem
                    anchors.fill: parent
                    width: parent.width
                    height: width
                    svg: buttonSvg
                    elementId: 'active-idle'
                    imagePath: Qt.resolvedUrl('../../icons/' + themeName + '/' + model.text + '.svg')
                }
            }

onMoveItemRequested: {
                mainContent.model.move(from, to, 1);
                mainContent.modelOrderChanged()
            }
        }
    }
}

0707010000002F000081A40000000000000000000000016626CF9D00005FAD000000000000000000000000000000000000004600000000plasma-active-window-control-116.7736a87/package/contents/ui/main.qml/*
    SPDX-FileCopyrightText: 2015 Martin Kotelnik <clearmartin@seznam.cz>

SPDX-License-Identifier: GPL-2.0-or-later
*/
import QtQuick 2.20
import Qt5Compat.GraphicalEffects
import QtQuick.Layouts
import QtQuick.Window
import org.kde.plasma.plasmoid
import org.kde.plasma.core as PlasmaCore
import org.kde.plasma.components as PlasmaComponents
import org.kde.taskmanager as TaskManager
import org.kde.activities as Activities
import org.kde.kirigami as Kirigami
import org.kde.plasma.plasma5support as Plasma5Support

PlasmoidItem {
    id: main

property bool vertical: (plasmoid.formFactor == PlasmaCore.Types.Vertical)

property double horizontalScreenWidthPercent: plasmoid.configuration.horizontalScreenWidthPercent
    property double buttonSize: plasmoid.configuration.buttonSize
    property bool autoFillWidth: plasmoid.configuration.autoFillWidth
    property double widthForHorizontalPanel: (Screen.width * horizontalScreenWidthPercent + plasmoid.configuration.widthFineTuning) - ((!controlButtonsArea.visible && buttonsStandalone && plasmoid.configuration.buttonsDynamicWidth) ? controlButtonsArea.width : 0)
    anchors.fill: parent
    Layout.fillWidth: plasmoid.configuration.autoFillWidth
    Layout.preferredWidth: autoFillWidth ? -1 : (vertical ? parent.width : (widthForHorizontalPanel > 0 ? widthForHorizontalPanel : 0.0001))
    Layout.minimumWidth: Layout.preferredWidth
    Layout.maximumWidth: Layout.preferredWidth
    Layout.preferredHeight: parent === null ? 0 : vertical ? Math.min(theme.defaultFont.pointSize * 4, parent.width) : parent.height
    Layout.minimumHeight: Layout.preferredHeight
    Layout.maximumHeight: Layout.preferredHeight

property int textType: plasmoid.configuration.textType
    property int fitText: plasmoid.configuration.fitText
    property int tooltipTextType: plasmoid.configuration.tooltipTextType
    property string tooltipText: ''

property bool windowIconOnTheRight: plasmoid.configuration.windowIconOnTheRight
    property double iconAndTextSpacing: plasmoid.configuration.iconAndTextSpacing
    property bool slidingIconAndText: plasmoid.configuration.slidingIconAndText
    property double fontPixelSize: theme.defaultFont.pixelSize * plasmoid.configuration.fontSizeScale
    property bool fontBold: plasmoid.configuration.boldFontWeight
    property string fontFamily: plasmoid.configuration.fontFamily

property bool noWindowActive: true
    property bool currentWindowMaximized: false
    property bool canShowButtonsAccordingMaximized: showButtonOnlyWhenMaximized ? currentWindowMaximized : true

property int controlButtonsSpacing: plasmoid.configuration.controlButtonsSpacing

property int bp: plasmoid.configuration.buttonsPosition;
    property bool buttonsVerticalCenter: plasmoid.configuration.buttonsVerticalCenter
    property bool showControlButtons: plasmoid.configuration.showControlButtons
    property bool showButtonOnlyWhenMaximized: plasmoid.configuration.showButtonOnlyWhenMaximized
    property bool showMinimize: showControlButtons && plasmoid.configuration.showMinimize
    property bool showMaximize: showControlButtons && plasmoid.configuration.showMaximize
    property bool showPinToAllDesktops: showControlButtons && plasmoid.configuration.showPinToAllDesktops
    property string buttonOrder: plasmoid.configuration.buttonOrder
    property bool doubleClickMaximizes: plasmoid.configuration.doubleClickMaximizes
    property int leftClickAction: plasmoid.configuration.leftClickAction
    property string chosenLeftClickSource: leftClickAction === 1 ? shortcutDS.presentWindows : leftClickAction === 2 ? shortcutDS.presentWindowsAll : leftClickAction === 3 ? shortcutDS.presentWindowsClass : ''
    property bool middleClickClose: plasmoid.configuration.middleClickAction === 1
    property bool middleClickFullscreen: plasmoid.configuration.middleClickAction === 2
    property bool wheelUpMaximizes: plasmoid.configuration.wheelUpMaximizes
    property bool wheelDownMinimizes: plasmoid.configuration.wheelDownAction === 1
    property bool wheelDownUnmaximizes: plasmoid.configuration.wheelDownAction === 2

property bool buttonsStandalone: showControlButtons && plasmoid.configuration.buttonsStandalone
    property bool buttonsBetweenIconAndText: buttonsStandalone && plasmoid.configuration.buttonsBetweenIconAndText
    property bool doNotHideControlButtons: showControlButtons && plasmoid.configuration.doNotHideControlButtons

property bool textColorLight: ((theme.textColor.r + theme.textColor.g + theme.textColor.b) / 3) > 0.5

property bool mouseHover: false
    property bool isActiveWindowPinned: false
    property bool isActiveWindowMaximized: false

property bool appmenuNextToIconAndText: plasmoid.configuration.appmenuNextToIconAndText
    property double appmenuSideMargin: plasmoid.configuration.appmenuOuterSideMargin
    property bool appmenuSwitchSidesWithIconAndText: plasmoid.configuration.appmenuSwitchSidesWithIconAndText
    property bool appmenuBoldTitleWhenMenuDisplayed: plasmoid.configuration.appmenuBoldTitleWhenMenuDisplayed

property var activeTaskLocal: null
    property int activityActionCount: 0

property bool automaticButtonThemeEnabled: plasmoid.configuration.automaticButtonThemeEnabled
    property string manualAuroraeThemePath: plasmoid.configuration.customAuroraeThemePath
    property string manualAuroraeThemePathResolved: ''
    property string manualAuroraeThemeExtension: 'svg'

preferredRepresentation: Plasmoid.fullRepresentation

Plasmoid.status: {
        if (appmenu.appmenuOpened) {
            return PlasmaCore.Types.NeedsAttentionStatus;
        } else if (!appmenu.appmenuOpened && appmenu.appmenuEnabledAndNonEmpty){
            return PlasmaCore.Types.ActiveStatus;
        } else {
            return PlasmaCore.Types.PassiveStatus;
        }
    }

//
    // MODEL
    //
    TaskManager.TasksModel {
        id: tasksModel
        sortMode: TaskManager.TasksModel.SortVirtualDesktop
        groupMode: TaskManager.TasksModel.GroupDisabled

screenGeometry: plasmoid.screenGeometry
        filterByScreen: plasmoid.configuration.showForCurrentScreenOnly

onActiveTaskChanged: {
            updateActiveWindowInfo()
        }
        onDataChanged: {
            updateActiveWindowInfo()
        }
        onCountChanged: {
            updateActiveWindowInfo()
        }
    }

TaskManager.ActivityInfo {
        id: activityInfo

onCurrentActivityChanged: {
            if (noWindowActive) {
                updateActiveWindowInfo();
            }
            reAddActivityActions()
        }
        onNumberOfRunningActivitiesChanged: {
            reAddActivityActions()
        }
    }

Activities.ActivityModel {
        id: activityModel
    }

function activeTask() {
        return activeTaskLocal
    }

function activeTaskExists() {
        return activeTaskLocal.display !== undefined
    }

onTooltipTextTypeChanged: updateTooltip()

function updateTooltip() {
        if (tooltipTextType === 1) {
            tooltipText = replaceTitle(activeTask().display || '')
        } else if (tooltipTextType === 2) {
            tooltipText = activeTask().AppName || ''
        } else {
            tooltipText = ''
        }
    }

function composeNoWindowText() {
        return plasmoid.configuration.noWindowText.replace('%activity%', activityInfo.activityName(activityInfo.currentActivity))
    }

function updateActiveWindowInfo() {

var activeTaskIndex = tasksModel.activeTask

// fallback for Plasma 5.8
        var abstractTasksModel = TaskManager.AbstractTasksModel || {}
        var isActive = abstractTasksModel.IsActive || 271
        var appName = abstractTasksModel.AppName || 258
        var isMaximized = abstractTasksModel.IsMaximized || 276
        var virtualDesktop = abstractTasksModel.VirtualDesktop || 286

if (!tasksModel.data(activeTaskIndex, isActive)) {
            activeTaskLocal = {}
        } else {
            activeTaskLocal = {
                display: tasksModel.data(activeTaskIndex, Qt.DisplayRole),
                decoration: tasksModel.data(activeTaskIndex, Qt.DecorationRole),
                AppName: tasksModel.data(activeTaskIndex, appName),
                IsMaximized: tasksModel.data(activeTaskIndex, isMaximized),
                VirtualDesktop: tasksModel.data(activeTaskIndex, virtualDesktop)
            }
        }

var actTask = activeTask()
        noWindowActive = !activeTaskExists()
        currentWindowMaximized = !noWindowActive && actTask.IsMaximized === true
        isActiveWindowPinned = actTask.VirtualDesktop === -1;
        if (noWindowActive) {
            windowTitleText.text = composeNoWindowText()
            iconItem.source = plasmoid.configuration.noWindowIcon
        } else {
            windowTitleText.text = (textType === 1 ? actTask.AppName : null) || replaceTitle(actTask.display)
            iconItem.source = actTask.decoration
        }
        updateTooltip()
    }

function toggleMaximized() {
        tasksModel.requestToggleMaximized(tasksModel.activeTask);
    }

function toggleMinimized() {
        tasksModel.requestToggleMinimized(tasksModel.activeTask);
    }

function toggleClose() {
        tasksModel.requestClose(tasksModel.activeTask);
    }

function toggleFullscreen() {
        tasksModel.requestToggleFullScreen(tasksModel.activeTask);
    }

function togglePinToAllDesktops() {
        tasksModel.requestVirtualDesktop(tasksModel.activeTask, 0);
    }

function setMaximized(maximized) {
        if ((maximized && !activeTask().IsMaximized)
            || (!maximized && activeTask().IsMaximized)) {
            print('toggle maximized')
            toggleMaximized()
        }
    }

function setMinimized() {
        if (!activeTask().IsMinimized) {
            toggleMinimized()
        }
    }

//
    // ACTIVE WINDOW INFO
    //
    Item {
        id: activeWindowListView

anchors.top: parent.top
        anchors.bottom: parent.bottom

property double appmenuOffsetLeft: (bp === 0 || bp === 2) ? appmenu.appmenuOffsetWidth : 0
        property double appmenuOffsetRight: (bp === 1 || bp === 3) ? appmenu.appmenuOffsetWidth : 0
        property double controlButtonsAreaWidth: noWindowActive ? 0 : controlButtonsArea.width
        property bool buttonsVisible: buttonsStandalone && (!slidingIconAndText || controlButtonsArea.mouseInWidget || doNotHideControlButtons) && (canShowButtonsAccordingMaximized || !slidingIconAndText)
        property double buttonsBetweenAddition: buttonsVisible && buttonsBetweenIconAndText ? controlButtonsAreaWidth + iconAndTextSpacing : 0

anchors.left: parent.left
        anchors.leftMargin: buttonsVisible && (bp === 0 || bp === 2) && !buttonsBetweenIconAndText ? controlButtonsAreaWidth + iconAndTextSpacing + appmenuOffsetLeft : 0 + appmenuOffsetLeft
        anchors.right: parent.right
        anchors.rightMargin: buttonsVisible && (bp === 1 || bp === 3) && !buttonsBetweenIconAndText ? controlButtonsAreaWidth + iconAndTextSpacing + appmenuOffsetRight : 0 + appmenuOffsetRight

Behavior on anchors.leftMargin {
            NumberAnimation {
                duration: 150
                easing.type: Easing.Linear
            }
        }
        Behavior on anchors.rightMargin {
            NumberAnimation {
                duration: 150
                easing.type: Easing.Linear
            }
        }

width: parent.width - anchors.leftMargin - anchors.rightMargin

opacity: appmenu.visible && !appmenuNextToIconAndText ? plasmoid.configuration.appmenuIconAndTextOpacity : 1

Item {
            width: parent.width
            height: main.height

// window icon
            Kirigami.Icon {
                id: iconItem

anchors.left: parent.left
                anchors.leftMargin: windowIconOnTheRight ? parent.width - iconItem.width : 0

width: parent.height
                height: parent.height

source: plasmoid.configuration.noWindowIcon
                visible: plasmoid.configuration.showWindowIcon
            }

// window title
            PlasmaComponents.Label {
                id: windowTitleText

property double iconMargin: (plasmoid.configuration.showWindowIcon ? iconItem.width : 0)
                property double properWidth: parent.width - iconMargin - iconAndTextSpacing
                property double properHeight: parent.height
                property bool noElide: fitText === 2 || (fitText === 1 && mouseHover)
                property int allowFontSizeChange: 3
                property int minimumPixelSize: 8
                property double iconMarginForAnchor: noWindowActive && plasmoid.configuration.noWindowIcon === '' ? 0 : iconMargin
                property bool limitTextWidth: plasmoid.configuration.limitTextWidth
                property int textWidthLimit: plasmoid.configuration.textWidthLimit
                property double computedWidth: (limitTextWidth ? (implicitWidth > textWidthLimit ? textWidthLimit : implicitWidth) : properWidth) - activeWindowListView.buttonsBetweenAddition

anchors.left: parent.left
                anchors.leftMargin: windowIconOnTheRight ? 0 : iconMarginForAnchor + iconAndTextSpacing + activeWindowListView.buttonsBetweenAddition
                anchors.top: parent.top
                anchors.bottom: parent.bottom
                verticalAlignment: Text.AlignVCenter
                text: plasmoid.configuration.noWindowText
                wrapMode: Text.Wrap
                width: computedWidth
                elide: noElide ? Text.ElideNone : Text.ElideRight
                visible: plasmoid.configuration.showWindowTitle
                font.pixelSize: fontPixelSize
                font.pointSize: -1
                font.weight: fontBold || (appmenuBoldTitleWhenMenuDisplayed && appmenu.visible) ? Font.Bold : theme.defaultFont.weight
                font.family: fontFamily || theme.defaultFont.family

onTextChanged: {
                    font.pixelSize = fontPixelSize
                    allowFontSizeChange = 3
                }

onNoElideChanged: {
                    font.pixelSize = fontPixelSize
                    allowFontSizeChange = 3
                }

onPaintedHeightChanged: {
                    if (allowFontSizeChange > 0 && noElide && paintedHeight > properHeight) {
                        var newPixelSize = (properHeight / paintedHeight) * fontPixelSize
                        font.pixelSize = newPixelSize < minimumPixelSize ? minimumPixelSize : newPixelSize
                    }
                    allowFontSizeChange--
                }
            }

}
    }

function replaceTitle(title) {
        if (!plasmoid.configuration.useWindowTitleReplace) {
            return title
        }
        return title.replace(new RegExp(plasmoid.configuration.replaceTextRegex), plasmoid.configuration.replaceTextReplacement);
    }

MouseArea {
        anchors.fill: parent

hoverEnabled: true

acceptedButtons: Qt.LeftButton | Qt.MiddleButton

onEntered: {
            mouseHover = true
            controlButtonsArea.mouseInWidget = showControlButtons && !noWindowActive
        }

onExited: {
            mouseHover = false
            controlButtonsArea.mouseInWidget = false
        }

onWheel: {
            if (wheel.angleDelta.y > 0) {
                if (wheelUpMaximizes) {
                    setMaximized(true)
                }
            } else {
                if (wheelDownMinimizes) {
                    setMinimized()
                } else if (wheelDownUnmaximizes) {
                    setMaximized(false)
                }
            }
        }

onDoubleClicked: {
            if (doubleClickMaximizes && mouse.button == Qt.LeftButton) {
                toggleMaximized()
            }
        }

onClicked: {
            if (chosenLeftClickSource !== '' && !doubleClickMaximizes && mouse.button == Qt.LeftButton) {
                shortcutDS.connectedSources.push(chosenLeftClickSource)
                controlButtonsArea.mouseInWidget = false
                return
            }
            if (mouse.button == Qt.MiddleButton) {
                if (middleClickFullscreen) {
                    toggleFullscreen()
                } else if (middleClickClose) {
                    toggleClose()
                }
            }
        }

PlasmaCore.ToolTipArea {

anchors.fill: parent

active: tooltipTextType > 0 && tooltipText !== ''
            interactive: true
            location: plasmoid.location

mainItem: Row {

spacing: 0

Layout.minimumWidth: fullText.width + units.largeSpacing
                Layout.minimumHeight: childrenRect.height
                Layout.maximumWidth: Layout.minimumWidth
                Layout.maximumHeight: Layout.minimumHeight

Item {
                    width: units.largeSpacing / 2
                    height: 2
                }

PlasmaComponents.Label {
                    id: fullText
                    text: tooltipText
                }
            }
        }

AppMenu {
            id: appmenu
        }

ListView {
            id: controlButtonsArea

property bool mouseInWidget: false
            property double controlButtonsHeight: parent.height * buttonSize
            property double buttonsBetweenMargin: buttonsBetweenIconAndText ? activeWindowListView.appmenuOffsetLeft + activeWindowListView.appmenuOffsetRight + iconItem.width + iconAndTextSpacing : 0

orientation: ListView.Horizontal
            visible: showControlButtons && (doNotHideControlButtons || mouseInWidget || appmenu.appmenuOpened) && (currentWindowMaximized || !showButtonOnlyWhenMaximized) && !noWindowActive

spacing: controlButtonsSpacing

height: buttonsVerticalCenter ? parent.height : controlButtonsHeight
            width: controlButtonsHeight + ((controlButtonsModel.count - 1) * (controlButtonsHeight + controlButtonsSpacing))

anchors.top: parent.top
            anchors.left: parent.left

anchors.leftMargin: buttonsBetweenIconAndText ? (windowIconOnTheRight ? parent.width - width - buttonsBetweenMargin : buttonsBetweenMargin) : ((bp === 1 || bp === 3) ? parent.width - width : 0)
            anchors.topMargin: (bp === 2 || bp === 3) ? parent.height - height : 0

model: controlButtonsModel

delegate: ControlButton { }
        }

}

ListModel {
        id: controlButtonsModel
    }

onManualAuroraeThemePathChanged: {
        manualAuroraeThemeExtension = plasmoid.nativeInterface.extensionForTheme(manualAuroraeThemePath);
        manualAuroraeThemePathResolved = plasmoid.nativeInterface.translateThemePath(manualAuroraeThemePath);
        print('manualAuroraeThemePath=' + manualAuroraeThemePath)
        print('manualAuroraeThemePathResolved=' + manualAuroraeThemePathResolved)
        print('manualAuroraeThemeExtension=' + manualAuroraeThemeExtension)
    }

function initializeControlButtonsModel() {

var preparedArray = []
        buttonOrder.split('|').forEach(function (buttonName) {
            addButton(preparedArray, buttonName);
        });

controlButtonsModel.clear()

if (bp === 1 || bp === 3) {
            for (var i = preparedArray.length - 1; i >= 0; i--) {
                controlButtonsModel.append(preparedArray[i])
            }
        } else {
            for (var i = 0; i < preparedArray.length; i++) {
                controlButtonsModel.append(preparedArray[i])
            }
        }
    }

function performActiveWindowAction(windowOperation) {
        if (bp === 4 || !controlButtonsArea.visible) {
            return;
        }
        if (windowOperation === 'close') {
            toggleClose()
        } else if (windowOperation === 'toggleMaximized') {
            toggleMaximized()
        } else if (windowOperation === 'toggleMinimized') {
            toggleMinimized()
        } else if (windowOperation === 'togglePinToAllDesktops') {
            togglePinToAllDesktops()
        }
    }

function action_close() {
        toggleClose()
    }

function action_maximise() {
        toggleMaximized()
    }

function action_minimise() {
        toggleMinimized()
    }

function action_pinToAllDesktops() {
        togglePinToAllDesktops()
    }

function action_reloadTheme() {
        plasmoid.nativeInterface.refreshAuroraeTheme();
    }

function actionTriggered(actionName) {
        if (actionName.indexOf("switchToActivity_") == 0) {
            var activityIndex = actionName.replace("switchToActivity_", "")
            var activityId = activityInfo.runningActivities()[activityIndex]
            activityModel.setCurrentActivity(activityId, function() {});
        }
    }

function reAddActivityActions() {
        plasmoid.removeAction("separator1")
        for (var i = 0; i < activityActionCount; i++) {
            plasmoid.removeAction('switchToActivity_' + i)
        }
        plasmoid.removeAction("separator2")

var runningActivities = activityInfo.runningActivities()
        activityActionCount = runningActivities.length
        if (activityActionCount === 0) {
            return
        }
        plasmoid.setActionSeparator("separator1")
        activityInfo.runningActivities().forEach(function (activityId, index) {
            if (activityId === activityInfo.currentActivity) {
                return;
            }
            var activityName = activityInfo.activityName(activityId)
            plasmoid.setAction('switchToActivity_' + index, i18n('Switch to activity: %1', activityName), 'activities')
        })
        plasmoid.setActionSeparator("separator2")
    }

Component.onCompleted: {
        initializeControlButtonsModel()
        updateActiveWindowInfo()
        plasmoid.setAction('close', i18n('Close'), 'window-close');
        plasmoid.setAction('maximise', i18n('Toggle Maximise'), 'arrow-up-double');
        plasmoid.setAction('minimise', i18n('Minimise'), 'draw-arrow-down');
        plasmoid.setAction('pinToAllDesktops', i18n('Toggle Pin To All Desktops'), 'window-pin');
        plasmoid.setActionSeparator("separator0")
        plasmoid.setAction('reloadTheme', i18n('Reload Theme'), 'system-reboot');
        reAddActivityActions()
    }

onShowMaximizeChanged: initializeControlButtonsModel()
    onShowMinimizeChanged: initializeControlButtonsModel()
    onShowPinToAllDesktopsChanged: initializeControlButtonsModel()
    onBpChanged: initializeControlButtonsModel()
    onButtonOrderChanged: initializeControlButtonsModel()

Plasma5Support.DataSource {
        // FIXME replace with dbus bindings
        id: shortcutDS
        engine: 'executable'

property string presentWindows: 'qdbus org.kde.kglobalaccel /component/kwin invokeShortcut "Expose"'
        property string presentWindowsAll: 'qdbus org.kde.kglobalaccel /component/kwin invokeShortcut "ExposeAll"'
        property string presentWindowsClass: 'qdbus org.kde.kglobalaccel /component/kwin invokeShortcut "ExposeClass"'

connectedSources: []

onNewData: {
            connectedSources.length = 0
        }
    }

}
07070100000030000081A40000000000000000000000016626CF9D000018E3000000000000000000000000000000000000003F00000000plasma-active-window-control-116.7736a87/package/metadata.json{
    "KPlugin": {
        "Authors": [
            {
                "Email": "clearmartin@seznam.cz",
                "Name": "Kotelnik"
            }
        ],
        "Category": "Windows and Tasks",
        "Description": "Plasmoid for advanced active window control.",
        "Description[az]": "Əlavə aktiv pəncərələri idarə etmək üçün plasmoid.",
        "Description[be]": "Плазмоід для дадатковага кіравання актыўнымі вокнамі.",
        "Description[bg]": "Минипрограма на Plasma за разширен контрол на активни прозорци",
        "Description[ca@valencia]": "Plasmoide per al control avançat de les finestres actives.",
        "Description[ca]": "Plasmoide per al control avançat de les finestres actives.",
        "Description[cs]": "Plasmoid pro pokročilé ovládání aktivních oken.",
        "Description[da]": "Plasmoid til avanceret styring af aktivt vindue.",
        "Description[de]": "Plasmoid für die erweiterte Steuerung aktiver Fenster.",
        "Description[el]": "Γραφικό συστατικό για προηγμένο έλεγχο του ενεργού παραθύρου.",
        "Description[en_GB]": "Plasmoid for advanced active window control.",
        "Description[es]": "Plasmoide para el control avanzado de la ventana activa.",
        "Description[et]": "Plasmoid aktiivse akna täiustatud juhtimiseks.",
        "Description[eu]": "Leiho aktiboaren kontrol aurreraturako plasmoidea.",
        "Description[fi]": "Sovelma edistyneeseen aktiivisen ikkunan hallintaan.",
        "Description[fr]": "Composant graphique permettant de contrôler la fenêtre active de manière avancée.",
        "Description[gl]": "Plasmoide para o control avanzado da xanela activa.",
        "Description[hu]": "Plasmoid az aktív ablakok irányításához.",
        "Description[ia]": "Plasmoid per controlo avantiate de fenestra active.",
        "Description[id]": "Plasmoid untuk kontrol jendela aktif tingkat lanjut",
        "Description[it]": "Plasmoide per il controllo avanzato della finestra attiva.",
        "Description[ka]": "პლაზმოიდი აქტიური ფანჯრის დამატებითი კონტროლისთვის.",
        "Description[ko]": "진보된 활성 창 관리를 도와 주는 Plasmoid.",
        "Description[lt]": "Plasma įskiepis, skirtas išplėstiniam aktyvaus lango valdymui.",
        "Description[nl]": "Plasmoid voor geavanceerde besturing van het actieve venster.",
        "Description[nn]": "Skjermelement for avanserte kontroll over aktive vindauge.",
        "Description[pl]": "Plazmoid do zaawansowanego sterowania aktynym oknem",
        "Description[pt]": "Plasmóide para o controlo avançado da janela activa.",
        "Description[pt_BR]": "Plasmoide para o controle avançado da janela ativa.",
        "Description[ro]": "Plasmoid pentru control avansat al ferestrelor active.",
        "Description[ru]": "Виджет для дополнительных действий над активным окном.",
        "Description[sk]": "Plazmoid na pokročilé ovládanie aktívnych okien.",
        "Description[sl]": "Plazmoid za napredno krmiljenje oken.",
        "Description[sv]": "Plasmoid för avancerad styrning av aktivt fönster.",
        "Description[tr]": "Gelişmiş etkin pencere denetimi için Plasmoid.",
        "Description[uk]": "Плазмоїд для розширеного керування активним вікном.",
        "Description[x-test]": "xxPlasmoid for advanced active window control.xx",
        "Description[zh_CN]": "用于进行高级活动窗口控制的 Plasma 部件。",
        "Description[zh_TW]": "用來進一步控制使用中視窗設定與操作的 Plasmoid。",
        "Icon": "window-close",
        "Id": "org.kde.activeWindowControl",
        "License": "GPL2",
        "Name": "Active Window Control",
        "Name[az]": "Aktiv Pəncərə İdarəetməsi",
        "Name[be]": "Кіраванне актыўнымі вокнамі",
        "Name[bg]": "Контрол на активен прозорец",
        "Name[ca@valencia]": "Control de la finestra activa",
        "Name[ca]": "Control de la finestra activa",
        "Name[cs]": "Ovládání aktivních oken",
        "Name[da]": "Styring af aktivt vindue",
        "Name[de]": "Steuerung aktiver Fenster",
        "Name[el]": "Έλεγχος ενεργού παραθύρου",
        "Name[en_GB]": "Active Window Control",
        "Name[es]": "Control de la ventana activa",
        "Name[et]": "Aktiivse akna juhtimine",
        "Name[eu]": "Leiho aktiboaren kontrola",
        "Name[fi]": "Aktiivisen ikkunan hallinta",
        "Name[fr]": "Contrôle de la fenêtre active",
        "Name[gl]": "Control da xanela activa",
        "Name[hu]": "Ablakvezérlő",
        "Name[ia]": "Controlo de Fenestra active",
        "Name[id]": "Active Jendela Control",
        "Name[it]": "Controllo della finestra attiva",
        "Name[ka]": "აქტიური ფანჯრის კონტროლი",
        "Name[ko]": "활성 창 관리",
        "Name[lt]": "Aktyvaus lango valdymas",
        "Name[nl]": "Besturing van het actieve venster",
        "Name[nn]": "Aktiv vindaugskontroll",
        "Name[pl]": "Sterowanie aktywnym oknem",
        "Name[pt]": "Controlo da Janela Activa",
        "Name[pt_BR]": "Controle da janela ativa",
        "Name[ro]": "Control fereastră activă",
        "Name[ru]": "Управление текущим окном",
        "Name[sk]": "Ovládanie aktívneho okna",
        "Name[sl]": "Active Window Control",
        "Name[sv]": "Aktiv fönsterstyrning",
        "Name[tr]": "Etkin Pencere Denetimi",
        "Name[uk]": "Керування активним вікном",
        "Name[x-test]": "xxActive Window Controlxx",
        "Name[zh_CN]": "活动窗口控制",
        "Name[zh_TW]": "控制使用中視窗",
        "ServiceTypes": [
            "Plasma/Applet"
        ],
        "Version": "1.1",
        "Website": "https://invent.kde.org/plasma/plasma-active-window-control"
    },
    "X-Plasma-API": "declarativeappletscript",
    "X-Plasma-API-Minimum-Version": "6.0",
    "X-Plasma-MainScript": "ui/main.qml"
}
07070100000031000041ED0000000000000000000000036626CF9D00000000000000000000000000000000000000000000003000000000plasma-active-window-control-116.7736a87/plugin07070100000032000081A40000000000000000000000016626CF9D0000034C000000000000000000000000000000000000003F00000000plasma-active-window-control-116.7736a87/plugin/CMakeLists.txtset(appmenuapplet_SRCS
    appmenumodel.cpp
    appmenuplugin.cpp
    appmenumodel.h
    appmenuplugin.h
)

add_library(appmenuplugin SHARED ${appmenuapplet_SRCS})
# load dbusmenuqt
#find_package(Qt6 ${REQUIRED_QT_VERSION} CONFIG REQUIRED Widgets DBus)
cmake_policy(SET CMP0063 NEW)
add_subdirectory(libdbusmenuqt)

target_link_libraries(appmenuplugin
                      Qt::Core
                      Qt::Widgets
                      Qt::Quick
                      Plasma::Plasma
                      KF6::WindowSystem
                      KF6::I18n
                      PW::LibTaskManager
                      dbusmenuqt)
# install plugin
install(TARGETS appmenuplugin DESTINATION ${KDE_INSTALL_QMLDIR}/org/kde/private/activeWindowControl)

install(FILES qmldir DESTINATION ${KDE_INSTALL_QMLDIR}/org/kde/private/activeWindowControl)
07070100000033000081A40000000000000000000000016626CF9D00000076000000000000000000000000000000000000003700000000plasma-active-window-control-116.7736a87/plugin/READMETODO: get rid of this shamelessly copied appmenumodel and libdbusmenuqt when it is available as a proper data engine.
07070100000034000081A40000000000000000000000016626CF9D00002A9C000000000000000000000000000000000000004100000000plasma-active-window-control-116.7736a87/plugin/appmenumodel.cpp/*
    SPDX-FileCopyrightText: 2016 Kai Uwe Broulik <kde@privat.broulik.de>
    SPDX-FileCopyrightText: 2016 Chinmoy Ranjan Pradhan <chinmoyrp65@gmail.com>

SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#include "appmenumodel.h"

#include <QDBusConnection>
#include <QDBusConnectionInterface>
#include <QDBusServiceWatcher>
#include <QGuiApplication>
#include <QMenu>

// Includes for the menu search.
#include <KLocalizedString>
#include <QLineEdit>
#include <QListView>
#include <QWidgetAction>

#include <abstracttasksmodel.h>
#include <dbusmenuimporter.h>

class KDBusMenuImporter : public DBusMenuImporter
{
public:
    KDBusMenuImporter(const QString &service, const QString &path, QObject *parent)
        : DBusMenuImporter(service, path, parent)
    {
    }

protected:
    QIcon iconForName(const QString &name) override
    {
        return QIcon::fromTheme(name);
    }
};

AppMenuModel::AppMenuModel(QObject *parent)
    : QAbstractListModel(parent)
    , m_tasksModel(new TaskManager::TasksModel(this))
    , m_serviceWatcher(new QDBusServiceWatcher(this))
{
    m_tasksModel->setFilterByScreen(true);
    connect(m_tasksModel, &TaskManager::TasksModel::activeTaskChanged, this, &AppMenuModel::onActiveWindowChanged);
    connect(m_tasksModel,
            &TaskManager::TasksModel::dataChanged,
            [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QList<int> &roles = QList<int>()) {
                Q_UNUSED(topLeft)
                Q_UNUSED(bottomRight)
                if (roles.contains(TaskManager::AbstractTasksModel::ApplicationMenuObjectPath)
                    || roles.contains(TaskManager::AbstractTasksModel::ApplicationMenuServiceName) || roles.isEmpty()) {
                    onActiveWindowChanged();
                }
            });
    connect(m_tasksModel, &TaskManager::TasksModel::activityChanged, this, &AppMenuModel::onActiveWindowChanged);
    connect(m_tasksModel, &TaskManager::TasksModel::virtualDesktopChanged, this, &AppMenuModel::onActiveWindowChanged);
    connect(m_tasksModel, &TaskManager::TasksModel::countChanged, this, &AppMenuModel::onActiveWindowChanged);
    connect(m_tasksModel, &TaskManager::TasksModel::screenGeometryChanged, this, &AppMenuModel::screenGeometryChanged);

connect(this, &AppMenuModel::modelNeedsUpdate, this, [this] {
        if (!m_updatePending) {
            m_updatePending = true;
            QMetaObject::invokeMethod(this, "update", Qt::QueuedConnection);
        }
    });

onActiveWindowChanged();

m_serviceWatcher->setConnection(QDBusConnection::sessionBus());
    // if our current DBus connection gets lost, close the menu
    // we'll select the new menu when the focus changes
    connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, [this](const QString &serviceName) {
        if (serviceName == m_serviceName) {
            setMenuAvailable(false);
            Q_EMIT modelNeedsUpdate();
        }
    });

// X11 has funky menu behaviour that prevents this from working properly.
    if (KWindowSystem::isPlatformWayland()) {
        m_searchAction = new QAction(this);
        m_searchAction->setText(i18n("Search"));
        m_searchAction->setObjectName(QStringLiteral("appmenu"));

m_searchMenu.reset(new QMenu);
        auto searchAction = new QWidgetAction(this);
        auto searchBar = new QLineEdit;
        searchBar->setClearButtonEnabled(true);
        searchBar->setPlaceholderText(i18n("Search…"));
        searchBar->setMinimumWidth(200);
        searchBar->setContentsMargins(4, 4, 4, 4);
        connect(m_tasksModel, &TaskManager::TasksModel::activeTaskChanged, searchBar, [searchBar]() {
            searchBar->setText(QString());
        });
        connect(searchBar, &QLineEdit::textChanged, this, [searchBar, this]() mutable {
            insertSearchActionsIntoMenu(searchBar->text());
        });
        connect(searchBar, &QLineEdit::returnPressed, this, [this]() mutable {
            if (!m_currentSearchActions.empty()) {
                m_currentSearchActions.constFirst()->trigger();
            }
        });
        connect(this, &AppMenuModel::modelNeedsUpdate, searchBar, [this, searchBar]() mutable {
            insertSearchActionsIntoMenu(searchBar->text());
        });
        searchAction->setDefaultWidget(searchBar);
        m_searchMenu->addAction(searchAction);
        m_searchMenu->addSeparator();
        m_searchAction->setMenu(m_searchMenu.get());
    }
}

AppMenuModel::~AppMenuModel() = default;

bool AppMenuModel::menuAvailable() const
{
    return m_menuAvailable;
}

void AppMenuModel::setMenuAvailable(bool set)
{
    if (m_menuAvailable != set) {
        m_menuAvailable = set;
        setVisible(true);
        Q_EMIT menuAvailableChanged();
    }
}

bool AppMenuModel::visible() const
{
    return m_visible;
}

void AppMenuModel::setVisible(bool visible)
{
    if (m_visible != visible) {
        m_visible = visible;
        Q_EMIT visibleChanged();
    }
}

QRect AppMenuModel::screenGeometry() const
{
    return m_tasksModel->screenGeometry();
}

void AppMenuModel::setScreenGeometry(QRect geometry)
{
    m_tasksModel->setScreenGeometry(geometry);
}

int AppMenuModel::rowCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    if (!m_menuAvailable || !m_menu) {
        return 0;
    }

return m_menu->actions().count() + (m_searchAction ? 1 : 0);
}

void AppMenuModel::removeSearchActionsFromMenu()
{
    for (auto action : std::as_const(m_currentSearchActions)) {
        m_searchAction->menu()->removeAction(action);
    }
    m_currentSearchActions = QList<QAction *>();
}

void AppMenuModel::insertSearchActionsIntoMenu(const QString &filter)
{
    removeSearchActionsFromMenu();
    if (filter.isEmpty()) {
        return;
    }
    const auto actions = flatActionList();
    for (const auto &action : actions) {
        if (action->text().contains(filter, Qt::CaseInsensitive)) {
            m_searchAction->menu()->addAction(action);
            m_currentSearchActions << action;
        }
    }
}

void AppMenuModel::update()
{
    beginResetModel();
    endResetModel();
    m_updatePending = false;
}

void AppMenuModel::onActiveWindowChanged()
{
    // Do not change active window when panel gets focus
    // See ShellCorona::init() in shell/shellcorona.cpp
    if (m_containmentStatus == Plasma::Types::AcceptingInputStatus) {
        return;
    }

const QModelIndex activeTaskIndex = m_tasksModel->activeTask();
    const QString objectPath = m_tasksModel->data(activeTaskIndex, TaskManager::AbstractTasksModel::ApplicationMenuObjectPath).toString();
    const QString serviceName = m_tasksModel->data(activeTaskIndex, TaskManager::AbstractTasksModel::ApplicationMenuServiceName).toString();

if (!objectPath.isEmpty() && !serviceName.isEmpty()) {
        setMenuAvailable(true);
        updateApplicationMenu(serviceName, objectPath);
        setVisible(true);
        Q_EMIT modelNeedsUpdate();
    } else {
        setMenuAvailable(false);
        setVisible(false);
    }
}

QHash<int, QByteArray> AppMenuModel::roleNames() const
{
    QHash<int, QByteArray> roleNames;
    roleNames[MenuRole] = QByteArrayLiteral("activeMenu");
    roleNames[ActionRole] = QByteArrayLiteral("activeActions");
    return roleNames;
}

QList<QAction *> AppMenuModel::flatActionList()
{
    QList<QAction *> ret;
    if (!m_menuAvailable || !m_menu) {
        return ret;
    }
    const auto actions = m_menu->findChildren<QAction *>();
    for (auto &action : actions) {
        if (action->menu() == nullptr) {
            ret << action;
        }
    }
    return ret;
}

QVariant AppMenuModel::data(const QModelIndex &index, int role) const
{
    if (!m_menuAvailable || !m_menu) {
        return QVariant();
    }

if (!index.isValid()) {
        if (role == MenuRole) {
            return QString();
        } else if (role == ActionRole) {
            return QVariant::fromValue(m_menu->menuAction());
        }
    }

const auto actions = m_menu->actions();
    const int row = index.row();
    if (row == actions.count() && m_searchAction) {
        if (role == MenuRole) {
            return m_searchAction->text();
        } else if (role == ActionRole) {
            return QVariant::fromValue(m_searchAction.data());
        }
    }
    if (row >= actions.count()) {
        return QVariant();
    }

if (role == MenuRole) { // TODO this should be Qt::DisplayRole
        return actions.at(row)->text();
    } else if (role == ActionRole) {
        return QVariant::fromValue(actions.at(row));
    }

return QVariant();
}

void AppMenuModel::updateApplicationMenu(const QString &serviceName, const QString &menuObjectPath)
{
    if (m_serviceName == serviceName && m_menuObjectPath == menuObjectPath) {
        if (m_importer) {
            QMetaObject::invokeMethod(m_importer, "updateMenu", Qt::QueuedConnection);
        }
        return;
    }

m_serviceName = serviceName;
    m_serviceWatcher->setWatchedServices(QStringList({m_serviceName}));

m_menuObjectPath = menuObjectPath;

if (m_importer) {
        m_importer->deleteLater();
    }

m_importer = new KDBusMenuImporter(serviceName, menuObjectPath, this);
    QMetaObject::invokeMethod(m_importer, "updateMenu", Qt::QueuedConnection);

connect(m_importer.data(), &DBusMenuImporter::menuUpdated, this, [=, this](QMenu *menu) {
        m_menu = m_importer->menu();
        if (m_menu.isNull() || menu != m_menu) {
            return;
        }

// cache first layer of sub menus, which we'll be popping up
        const auto actions = m_menu->actions();
        for (QAction *a : actions) {
            // signal dataChanged when the action changes
            connect(a, &QAction::changed, this, [this, a] {
                if (m_menuAvailable && m_menu) {
                    const int actionIdx = m_menu->actions().indexOf(a);
                    if (actionIdx > -1) {
                        const QModelIndex modelIdx = index(actionIdx, 0);
                        Q_EMIT dataChanged(modelIdx, modelIdx);
                    }
                }
            });

connect(a, &QAction::destroyed, this, &AppMenuModel::modelNeedsUpdate);

if (a->menu()) {
                m_importer->updateMenu(a->menu());
            }
        }

setMenuAvailable(true);
        Q_EMIT modelNeedsUpdate();
    });

connect(m_importer.data(), &DBusMenuImporter::actionActivationRequested, this, [this](QAction *action) {
        // TODO submenus
        if (!m_menuAvailable || !m_menu) {
            return;
        }

const auto actions = m_menu->actions();
        auto it = std::find(actions.begin(), actions.end(), action);
        if (it != actions.end()) {
            Q_EMIT requestActivateIndex(it - actions.begin());
        }
    });
}
07070100000035000081A40000000000000000000000016626CF9D00000B07000000000000000000000000000000000000003F00000000plasma-active-window-control-116.7736a87/plugin/appmenumodel.h/*
    SPDX-FileCopyrightText: 2016 Chinmoy Ranjan Pradhan <chinmoyrp65@gmail.com>

SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#pragma once

#include <KWindowSystem>
#include <QAbstractListModel>
#include <QAction>
#include <QPointer>
#include <QRect>
#include <QStringList>
#include <tasksmodel.h>

#include <Plasma/Containment>

class QMenu;
class QModelIndex;
class QDBusServiceWatcher;
class KDBusMenuImporter;

class AppMenuModel : public QAbstractListModel
{
    Q_OBJECT

Q_PROPERTY(bool menuAvailable READ menuAvailable WRITE setMenuAvailable NOTIFY menuAvailableChanged)
    Q_PROPERTY(bool visible READ visible NOTIFY visibleChanged)

Q_PROPERTY(Plasma::Types::ItemStatus containmentStatus MEMBER m_containmentStatus NOTIFY containmentStatusChanged)
    Q_PROPERTY(QRect screenGeometry READ screenGeometry WRITE setScreenGeometry NOTIFY screenGeometryChanged)

public:
    explicit AppMenuModel(QObject *parent = nullptr);
    ~AppMenuModel() override;

enum AppMenuRole {
        MenuRole = Qt::UserRole + 1, // TODO this should be Qt::DisplayRole
        ActionRole,
    };

QVariant data(const QModelIndex &index, int role) const override;
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    QHash<int, QByteArray> roleNames() const override;

void updateApplicationMenu(const QString &serviceName, const QString &menuObjectPath);

bool menuAvailable() const;
    void setMenuAvailable(bool set);

bool visible() const;

QRect screenGeometry() const;
    void setScreenGeometry(QRect geometry);
    QList<QAction *> flatActionList();

Q_SIGNALS:
    void requestActivateIndex(int index);
    void bringToFocus(int index);

private Q_SLOTS:
    void onActiveWindowChanged();
    void setVisible(bool visible);
    void update();

Q_SIGNALS:
    void menuAvailableChanged();
    void modelNeedsUpdate();
    void containmentStatusChanged();
    void screenGeometryChanged();
    void visibleChanged();

private:
    bool m_menuAvailable;
    bool m_updatePending = false;
    bool m_visible = true;

Plasma::Types::ItemStatus m_containmentStatus = Plasma::Types::PassiveStatus;
    TaskManager::TasksModel *m_tasksModel;

//! current active window used
    WId m_currentWindowId = 0;
    //! window that its menu initialization may be delayed
    WId m_delayedMenuWindowId = 0;

std::unique_ptr<QMenu> m_searchMenu;
    QPointer<QMenu> m_menu;
    QPointer<QAction> m_searchAction;
    QList<QAction *> m_currentSearchActions;

void removeSearchActionsFromMenu();
    void insertSearchActionsIntoMenu(const QString &filter = QString());

QDBusServiceWatcher *m_serviceWatcher;
    QString m_serviceName;
    QString m_menuObjectPath;

QPointer<KDBusMenuImporter> m_importer;
};
07070100000036000081A40000000000000000000000016626CF9D000001BD000000000000000000000000000000000000004200000000plasma-active-window-control-116.7736a87/plugin/appmenuplugin.cpp/*
    SPDX-FileCopyrightText: 2016 Chinmoy Ranjan Pradhan <chinmoyrp65@gmail.com>

SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#include "appmenuplugin.h"
#include "appmenumodel.h"
#include <QQmlEngine>

void AppmenuPlugin::registerTypes(const char *uri)
{
    Q_ASSERT(uri == QLatin1String("org.kde.private.activeWindowControl"));
    qmlRegisterType<AppMenuModel>(uri, 1, 0, "AppMenuModel");
}
07070100000037000081A40000000000000000000000016626CF9D000001A3000000000000000000000000000000000000004000000000plasma-active-window-control-116.7736a87/plugin/appmenuplugin.h/*
    SPDX-FileCopyrightText: 2016 Chinmoy Ranjan Pradhan <chinmoyrp65@gmail.com>

SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#pragma once

#include <QQmlExtensionPlugin>

class AppmenuPlugin : public QQmlExtensionPlugin
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")

public:
    void registerTypes(const char *uri) override;
};
07070100000038000081A40000000000000000000000016626CF9D0000043C000000000000000000000000000000000000004300000000plasma-active-window-control-116.7736a87/plugin/config-X11.h.cmake/* Define if you have the XRandR extension */
#cmakedefine HAVE_XRANDR 1

/* Define if you have the XDamage extension */
#cmakedefine HAVE_XDAMAGE 1

/* Define if you have the XKB extension */
#cmakedefine HAVE_XKB 1

/* Define if you have the Xinerama extension */
#cmakedefine HAVE_XINERAMA 1

/* Define if you have the XSHM (MIT SHM) extension */
#cmakedefine HAVE_XSHM 1

/* Define if you have the XComposite extension */
#cmakedefine HAVE_XCOMPOSITE 1

/* Define to 1 if you have Xcursor */
#cmakedefine HAVE_XCURSOR 1

/* Define if you have the xf86misc extension */
#cmakedefine HAVE_XF86MISC 1

/* Define if you have the XFixes extension */
#cmakedefine HAVE_XFIXES 1

/* Define if you have the XTest extension */
#cmakedefine HAVE_XTEST 1

/* Define if your system has XRender support */
#cmakedefine HAVE_XRENDER 1

/* Define if you have OpenGL */
#cmakedefine HAVE_OPENGL 1

/* Define if you have the XSync extension */
#cmakedefine HAVE_XSYNC 1

/* Define if you have XRandR 1.3 */
#cmakedefine HAS_RANDR_1_3 1

/* Define if you have X11 at all */
#cmakedefine01 HAVE_X11
07070100000039000041ED0000000000000000000000036626CF9D00000000000000000000000000000000000000000000003E00000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt0707010000003A000081A40000000000000000000000016626CF9D0000042B000000000000000000000000000000000000004D00000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/CMakeLists.txtset(libdbusmenu_SRCS
dbusmenuimporter.cpp
dbusmenushortcut_p.cpp
dbusmenutypes_p.cpp
utils.cpp
dbusmenuimporter.h
dbusmenushortcut_p.h
dbusmenutypes_p.h
)

ecm_qt_declare_logging_category(libdbusmenu_SRCS HEADER debug.h
                                            IDENTIFIER DBUSMENUQT
                                            CATEGORY_NAME org.kde.libdbusmenuqt
                                            DEFAULT_SEVERITY Info
                                            DESCRIPTION "libdbusmenu debug"
                                            EXPORT PLASMAWORKSPACE
                                        )

set_source_files_properties(com.canonical.dbusmenu.xml PROPERTIES
   NO_NAMESPACE true
   INCLUDE "dbusmenutypes_p.h"
   CLASSNAME DBusMenuInterface
)
qt_add_dbus_interface(libdbusmenu_SRCS com.canonical.dbusmenu.xml dbusmenu_interface)

add_library(dbusmenuqt STATIC ${libdbusmenu_SRCS})
target_link_libraries(dbusmenuqt
    Qt::DBus
    Qt::Widgets
)

set_property(TARGET dbusmenuqt PROPERTY POSITION_INDEPENDENT_CODE ON)

add_subdirectory(test)
0707010000003B000081A40000000000000000000000016626CF9D00000077000000000000000000000000000000000000004500000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/READMEContains a patched version of the import path of libdbusmenu-qt
Remove when next version of libdbusmenu-qt is released.0707010000003C000081A40000000000000000000000016626CF9D00000879000000000000000000000000000000000000005900000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/com.canonical.dbusmenu.xml<interface name="com.canonical.dbusmenu">
    <property name="Version" type="u" access="read"/>
    <property name="Status" type="s" access="read"/>
    <signal name="ItemsPropertiesUpdated">
    <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="DBusMenuItemList"/>
    <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="DBusMenuItemKeysList"/>
    <arg type="a(ia{sv})" direction="out"/>
    <arg type="a(ias)" direction="out"/>
    </signal>
    <signal name="LayoutUpdated">
    <arg name="revision" type="u" direction="out"/>
    <arg name="parentId" type="i" direction="out"/>
    </signal>
    <signal name="ItemActivationRequested">
    <arg name="id" type="i" direction="out"/>
    <arg name="timeStamp" type="u" direction="out"/>
    </signal>
    <method name="Event">
    <arg name="id" type="i" direction="in"/>
    <arg name="eventId" type="s" direction="in"/>
    <arg name="data" type="v" direction="in"/>
    <arg name="timestamp" type="u" direction="in"/>
    <annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
    </method>
    <method name="GetProperty">
    <arg type="v" direction="out"/>
    <arg name="id" type="i" direction="in"/>
    <arg name="property" type="s" direction="in"/>
    </method>
    <method name="GetLayout">
    <arg type="u" direction="out"/>
    <arg name="parentId" type="i" direction="in"/>
    <arg name="recursionDepth" type="i" direction="in"/>
    <arg name="propertyNames" type="as" direction="in"/>
    <arg name="item" type="(ia{sv}av)" direction="out"/>
    <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="DBusMenuLayoutItem"/>
    </method>
    <method name="GetGroupProperties">
    <arg type="a(ia{sv})" direction="out"/>
    <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="DBusMenuItemList"/>
    <arg name="ids" type="ai" direction="in"/>
    <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QList&lt;int&gt;"/>
    <arg name="propertyNames" type="as" direction="in"/>
    </method>
    <method name="AboutToShow">
    <arg type="b" direction="out"/>
    <arg name="id" type="i" direction="in"/>
    </method>
</interface>
0707010000003D000081A40000000000000000000000016626CF9D0000458E000000000000000000000000000000000000005300000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/dbusmenuimporter.cpp/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2009 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include "dbusmenuimporter.h"

#include "debug.h"

// Qt
#include <QActionGroup>
#include <QCoreApplication>
#include <QDBusConnection>
#include <QDBusInterface>
#include <QDBusReply>
#include <QDBusVariant>
#include <QDebug>
#include <QFont>
#include <QMenu>
#include <QPointer>
#include <QSet>
#include <QTime>
#include <QTimer>
#include <QToolButton>
#include <QWidgetAction>

// Local
#include "dbusmenushortcut_p.h"
#include "dbusmenutypes_p.h"
#include "utils_p.h"

// Generated
#include "dbusmenu_interface.h"

// #define BENCHMARK
#ifdef BENCHMARK
static QTime sChrono;
#endif

#define DMRETURN_IF_FAIL(cond)                                                                                                                                 \
    if (!(cond)) {                                                                                                                                             \
        qCWarning(DBUSMENUQT) << "Condition failed: " #cond;                                                                                                   \
        return;                                                                                                                                                \
    }

static const char *DBUSMENU_PROPERTY_ID = "_dbusmenu_id";
static const char *DBUSMENU_PROPERTY_ICON_NAME = "_dbusmenu_icon_name";
static const char *DBUSMENU_PROPERTY_ICON_DATA_HASH = "_dbusmenu_icon_data_hash";

static QAction *createKdeTitle(QAction *action, QWidget *parent)
{
    QToolButton *titleWidget = new QToolButton(nullptr);
    QFont font = titleWidget->font();
    font.setBold(true);
    titleWidget->setFont(font);
    titleWidget->setIcon(action->icon());
    titleWidget->setText(action->text());
    titleWidget->setDown(true);
    titleWidget->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

QWidgetAction *titleAction = new QWidgetAction(parent);
    titleAction->setDefaultWidget(titleWidget);
    return titleAction;
}

class DBusMenuImporterPrivate
{
public:
    DBusMenuImporter *q;

DBusMenuInterface *m_interface;
    QMenu *m_menu = nullptr;
    using ActionForId = QMap<int, QAction *>;
    ActionForId m_actionForId;
    QTimer m_pendingLayoutUpdateTimer;

QSet<int> m_idsRefreshedByAboutToShow;
    QSet<int> m_pendingLayoutUpdates;

QDBusPendingCallWatcher *refresh(int id)
    {
        auto call = m_interface->GetLayout(id, 1, QStringList());
        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(call, q);
        watcher->setProperty(DBUSMENU_PROPERTY_ID, id);
        QObject::connect(watcher, &QDBusPendingCallWatcher::finished, q, &DBusMenuImporter::slotGetLayoutFinished);

return watcher;
    }

QMenu *createMenu(QWidget *parent)
    {
        QMenu *menu = q->createMenu(parent);
        return menu;
    }

/**
     * Init all the immutable action properties here
     * TODO: Document immutable properties?
     *
     * Note: we remove properties we handle from the map (using QMap::take()
     * instead of QMap::value()) to avoid warnings about these properties in
     * updateAction()
     */
    QAction *createAction(int id, const QVariantMap &_map, QWidget *parent)
    {
        QVariantMap map = _map;
        QAction *action = new QAction(parent);
        action->setProperty(DBUSMENU_PROPERTY_ID, id);

QString type = map.take(QStringLiteral("type")).toString();
        if (type == QLatin1String("separator")) {
            action->setSeparator(true);
        }

if (map.take(QStringLiteral("children-display")).toString() == QLatin1String("submenu")) {
            QMenu *menu = createMenu(parent);
            action->setMenu(menu);
        }

QString toggleType = map.take(QStringLiteral("toggle-type")).toString();
        if (!toggleType.isEmpty()) {
            action->setCheckable(true);
            if (toggleType == QLatin1String("radio")) {
                QActionGroup *group = new QActionGroup(action);
                group->addAction(action);
            }
        }

bool isKdeTitle = map.take(QStringLiteral("x-kde-title")).toBool();
        updateAction(action, map, map.keys());

if (isKdeTitle) {
            action = createKdeTitle(action, parent);
        }

return action;
    }

/**
     * Update mutable properties of an action. A property may be listed in
     * requestedProperties but not in map, this means we should use the default value
     * for this property.
     *
     * @param action the action to update
     * @param map holds the property values
     * @param requestedProperties which properties has been requested
     */
    void updateAction(QAction *action, const QVariantMap &map, const QStringList &requestedProperties)
    {
        for (const QString &key : requestedProperties) {
            updateActionProperty(action, key, map.value(key));
        }
    }

void updateActionProperty(QAction *action, const QString &key, const QVariant &value)
    {
        if (key == QLatin1String("label")) {
            updateActionLabel(action, value);
        } else if (key == QLatin1String("enabled")) {
            updateActionEnabled(action, value);
        } else if (key == QLatin1String("toggle-state")) {
            updateActionChecked(action, value);
        } else if (key == QLatin1String("icon-name")) {
            updateActionIconByName(action, value);
        } else if (key == QLatin1String("icon-data")) {
            updateActionIconByData(action, value);
        } else if (key == QLatin1String("visible")) {
            updateActionVisible(action, value);
        } else if (key == QLatin1String("shortcut")) {
            updateActionShortcut(action, value);
        } else {
            qDebug(DBUSMENUQT) << "Unhandled property update" << key;
        }
    }

void updateActionLabel(QAction *action, const QVariant &value)
    {
        QString text = swapMnemonicChar(value.toString(), '_', '&');
        action->setText(text);
    }

void updateActionEnabled(QAction *action, const QVariant &value)
    {
        action->setEnabled(value.isValid() ? value.toBool() : true);
    }

void updateActionChecked(QAction *action, const QVariant &value)
    {
        if (action->isCheckable() && value.isValid()) {
            action->setChecked(value.toInt() == 1);
        }
    }

void updateActionIconByName(QAction *action, const QVariant &value)
    {
        const QString iconName = value.toString();
        const QString previous = action->property(DBUSMENU_PROPERTY_ICON_NAME).toString();
        if (previous == iconName) {
            return;
        }
        action->setProperty(DBUSMENU_PROPERTY_ICON_NAME, iconName);
        if (iconName.isEmpty()) {
            action->setIcon(QIcon());
            return;
        }
        action->setIcon(q->iconForName(iconName));
    }

void updateActionIconByData(QAction *action, const QVariant &value)
    {
        const QByteArray data = value.toByteArray();
        uint dataHash = qHash(data);
        uint previousDataHash = action->property(DBUSMENU_PROPERTY_ICON_DATA_HASH).toUInt();
        if (previousDataHash == dataHash) {
            return;
        }
        action->setProperty(DBUSMENU_PROPERTY_ICON_DATA_HASH, dataHash);
        QPixmap pix;
        if (!pix.loadFromData(data)) {
            qDebug(DBUSMENUQT) << "Failed to decode icon-data property for action" << action->text();
            action->setIcon(QIcon());
            return;
        }
        action->setIcon(QIcon(pix));
    }

void updateActionVisible(QAction *action, const QVariant &value)
    {
        action->setVisible(value.isValid() ? value.toBool() : true);
    }

void updateActionShortcut(QAction *action, const QVariant &value)
    {
        QDBusArgument arg = value.value<QDBusArgument>();
        DBusMenuShortcut dmShortcut;
        arg >> dmShortcut;
        QKeySequence keySequence = dmShortcut.toKeySequence();
        action->setShortcut(keySequence);
    }

QMenu *menuForId(int id) const
    {
        if (id == 0) {
            return q->menu();
        }
        QAction *action = m_actionForId.value(id);
        if (!action) {
            return nullptr;
        }
        return action->menu();
    }

void slotItemsPropertiesUpdated(const DBusMenuItemList &updatedList, const DBusMenuItemKeysList &removedList);

void sendEvent(int id, const QString &eventId)
    {
        m_interface->Event(id, eventId, QDBusVariant(QString()), 0u);
    }
};

DBusMenuImporter::DBusMenuImporter(const QString &service, const QString &path, QObject *parent)
    : QObject(parent)
    , d(new DBusMenuImporterPrivate)
{
    DBusMenuTypes_register();

d->q = this;
    d->m_interface = new DBusMenuInterface(service, path, QDBusConnection::sessionBus(), this);

d->m_pendingLayoutUpdateTimer.setSingleShot(true);
    connect(&d->m_pendingLayoutUpdateTimer, &QTimer::timeout, this, &DBusMenuImporter::processPendingLayoutUpdates);

connect(d->m_interface, &DBusMenuInterface::LayoutUpdated, this, &DBusMenuImporter::slotLayoutUpdated);
    connect(d->m_interface, &DBusMenuInterface::ItemActivationRequested, this, &DBusMenuImporter::slotItemActivationRequested);
    connect(d->m_interface,
            &DBusMenuInterface::ItemsPropertiesUpdated,
            this,
            [this](const DBusMenuItemList &updatedList, const DBusMenuItemKeysList &removedList) {
                d->slotItemsPropertiesUpdated(updatedList, removedList);
            });

d->refresh(0);
}

DBusMenuImporter::~DBusMenuImporter()
{
    // Do not use "delete d->m_menu": even if we are being deleted we should
    // leave enough time for the menu to finish what it was doing, for example
    // if it was being displayed.
    if (d->m_menu) {
        // If StatusNotifierItemSource is gone before PlasmaDBusMenuImporter::menuUpdated, there is no menu
        d->m_menu->deleteLater();
    }
    delete d;
}

void DBusMenuImporter::slotLayoutUpdated(uint revision, int parentId)
{
    Q_UNUSED(revision)
    if (d->m_idsRefreshedByAboutToShow.remove(parentId)) {
        return;
    }
    d->m_pendingLayoutUpdates << parentId;
    if (!d->m_pendingLayoutUpdateTimer.isActive()) {
        d->m_pendingLayoutUpdateTimer.start();
    }
}

void DBusMenuImporter::processPendingLayoutUpdates()
{
    const QSet<int> ids = d->m_pendingLayoutUpdates;
    d->m_pendingLayoutUpdates.clear();
    for (int id : ids) {
        d->refresh(id);
    }
}

QMenu *DBusMenuImporter::menu() const
{
    if (!d->m_menu) {
        d->m_menu = d->createMenu(nullptr);
    }
    return d->m_menu;
}

void DBusMenuImporterPrivate::slotItemsPropertiesUpdated(const DBusMenuItemList &updatedList, const DBusMenuItemKeysList &removedList)
{
    for (const DBusMenuItem &item : updatedList) {
        QAction *action = m_actionForId.value(item.id);
        if (!action) {
            // We don't know this action. It probably is in a menu we haven't fetched yet.
            continue;
        }

QVariantMap::ConstIterator it = item.properties.constBegin(), end = item.properties.constEnd();
        for (; it != end; ++it) {
            updateActionProperty(action, it.key(), it.value());
        }
    }

for (const DBusMenuItemKeys &item : removedList) {
        QAction *action = m_actionForId.value(item.id);
        if (!action) {
            // We don't know this action. It probably is in a menu we haven't fetched yet.
            continue;
        }

const auto properties{item.properties};
        for (const QString &key : properties) {
            updateActionProperty(action, key, QVariant());
        }
    }
}

QAction *DBusMenuImporter::actionForId(int id) const
{
    return d->m_actionForId.value(id);
}

void DBusMenuImporter::slotItemActivationRequested(int id, uint /*timestamp*/)
{
    QAction *action = d->m_actionForId.value(id);
    DMRETURN_IF_FAIL(action);
    actionActivationRequested(action);
}

void DBusMenuImporter::slotGetLayoutFinished(QDBusPendingCallWatcher *watcher)
{
    int parentId = watcher->property(DBUSMENU_PROPERTY_ID).toInt();
    watcher->deleteLater();

QMenu *menu = d->menuForId(parentId);

QDBusPendingReply<uint, DBusMenuLayoutItem> reply = *watcher;
    if (!reply.isValid()) {
        qDebug(DBUSMENUQT) << reply.error().message();
        if (menu) {
            Q_EMIT menuUpdated(menu);
        }
        return;
    }

#ifdef BENCHMARK
    DMDEBUG << "- items received:" << sChrono.elapsed() << "ms";
#endif
    DBusMenuLayoutItem rootItem = reply.argumentAt<1>();

if (!menu) {
        qDebug(DBUSMENUQT) << "No menu for id" << parentId;
        return;
    }

// remove outdated actions
    QSet<int> newDBusMenuItemIds;
    newDBusMenuItemIds.reserve(rootItem.children.count());
    for (const DBusMenuLayoutItem &item : std::as_const(rootItem.children)) {
        newDBusMenuItemIds << item.id;
    }
    for (QAction *action : menu->actions()) {
        int id = action->property(DBUSMENU_PROPERTY_ID).toInt();
        if (!newDBusMenuItemIds.contains(id)) {
            // Not calling removeAction() as QMenu will immediately close when it becomes empty,
            // which can happen when an application completely reloads this menu.
            // When the action is deleted deferred, it is removed from the menu.
            action->deleteLater();
            if (action->menu()) {
                action->menu()->deleteLater();
            }
            d->m_actionForId.remove(id);
        }
    }

// insert or update new actions into our menu
    for (const DBusMenuLayoutItem &dbusMenuItem : std::as_const(rootItem.children)) {
        DBusMenuImporterPrivate::ActionForId::Iterator it = d->m_actionForId.find(dbusMenuItem.id);
        QAction *action = nullptr;
        if (it == d->m_actionForId.end()) {
            int id = dbusMenuItem.id;
            action = d->createAction(id, dbusMenuItem.properties, menu);
            d->m_actionForId.insert(id, action);

connect(action, &QObject::destroyed, this, [this, id]() {
                d->m_actionForId.remove(id);
            });

connect(action, &QAction::triggered, this, [id, this]() {
                sendClickedEvent(id);
            });

if (QMenu *menuAction = action->menu()) {
                connect(menuAction, &QMenu::aboutToShow, this, &DBusMenuImporter::slotMenuAboutToShow, Qt::UniqueConnection);
            }
            connect(menu, &QMenu::aboutToHide, this, &DBusMenuImporter::slotMenuAboutToHide, Qt::UniqueConnection);

menu->addAction(action);
        } else {
            action = *it;
            QStringList filteredKeys = dbusMenuItem.properties.keys();
            filteredKeys.removeOne(QStringLiteral("type"));
            filteredKeys.removeOne(QStringLiteral("toggle-type"));
            filteredKeys.removeOne(QStringLiteral("children-display"));
            d->updateAction(*it, dbusMenuItem.properties, filteredKeys);
            // Move the action to the tail so we can keep the order same as the dbus request.
            menu->removeAction(action);
            menu->addAction(action);
        }
    }

Q_EMIT menuUpdated(menu);
}

void DBusMenuImporter::sendClickedEvent(int id)
{
    d->sendEvent(id, QStringLiteral("clicked"));
}

void DBusMenuImporter::updateMenu()
{
    updateMenu(DBusMenuImporter::menu());
}

void DBusMenuImporter::updateMenu(QMenu *menu)
{
    Q_ASSERT(menu);

QAction *action = menu->menuAction();
    Q_ASSERT(action);

int id = action->property(DBUSMENU_PROPERTY_ID).toInt();

auto call = d->m_interface->AboutToShow(id);
    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(call, this);
    watcher->setProperty(DBUSMENU_PROPERTY_ID, id);
    connect(watcher, &QDBusPendingCallWatcher::finished, this, &DBusMenuImporter::slotAboutToShowDBusCallFinished);

// Firefox deliberately ignores "aboutToShow" whereas Qt ignores" opened", so we'll just send both all the time...
    d->sendEvent(id, QStringLiteral("opened"));
}

void DBusMenuImporter::slotAboutToShowDBusCallFinished(QDBusPendingCallWatcher *watcher)
{
    int id = watcher->property(DBUSMENU_PROPERTY_ID).toInt();
    watcher->deleteLater();

QMenu *menu = d->menuForId(id);
    if (!menu) {
        return;
    }

QDBusPendingReply<bool> reply = *watcher;
    if (reply.isError()) {
        qDebug(DBUSMENUQT) << "Call to AboutToShow() failed:" << reply.error().message();
        Q_EMIT menuUpdated(menu);
        return;
    }
    // Note, this isn't used by Qt's QPT - but we get a LayoutChanged emitted before
    // this returns, which equates to the same thing
    bool needRefresh = reply.argumentAt<0>();

if (needRefresh || menu->actions().isEmpty()) {
        d->m_idsRefreshedByAboutToShow << id;
        d->refresh(id);
    } else if (menu) {
        Q_EMIT menuUpdated(menu);
    }
}

void DBusMenuImporter::slotMenuAboutToHide()
{
    QMenu *menu = qobject_cast<QMenu *>(sender());
    Q_ASSERT(menu);

QAction *action = menu->menuAction();
    Q_ASSERT(action);

int id = action->property(DBUSMENU_PROPERTY_ID).toInt();
    d->sendEvent(id, QStringLiteral("closed"));
}

void DBusMenuImporter::slotMenuAboutToShow()
{
    QMenu *menu = qobject_cast<QMenu *>(sender());
    Q_ASSERT(menu);

updateMenu(menu);
}

QMenu *DBusMenuImporter::createMenu(QWidget *parent)
{
    return new QMenu(parent);
}

QIcon DBusMenuImporter::iconForName(const QString &name)
{
    return QIcon::fromTheme(name);
}

#include "moc_dbusmenuimporter.cpp"
0707010000003E000081A40000000000000000000000016626CF9D00000997000000000000000000000000000000000000005100000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/dbusmenuimporter.h/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2009 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#pragma once

// Qt
#include <QObject>

class QAction;
class QDBusPendingCallWatcher;
class QIcon;
class QMenu;

class DBusMenuImporterPrivate;

/**
 * A DBusMenuImporter instance can recreate a menu serialized over DBus by
 * DBusMenuExporter
 */
class DBusMenuImporter : public QObject
{
    Q_OBJECT
public:
    /**
     * Creates a DBusMenuImporter listening over DBus on service, path
     */
    DBusMenuImporter(const QString &service, const QString &path, QObject *parent = nullptr);

~DBusMenuImporter() override;

QAction *actionForId(int id) const;

/**
     * The menu created from listening to the DBusMenuExporter over DBus
     */
    QMenu *menu() const;

public Q_SLOTS:
    /**
     * Load the menu
     *
     * Will Q_EMIT menuUpdated() when complete.
     * This should be done before showing a menu
     */
    void updateMenu();

void updateMenu(QMenu *menu);

Q_SIGNALS:
    /**
     * Emitted after a call to updateMenu().
     * @see updateMenu()
     */
    void menuUpdated(QMenu *);

/**
     * Emitted when the exporter was asked to activate an action
     */
    void actionActivationRequested(QAction *);

protected:
    /**
     * Must create a menu, may be customized to fit host appearance.
     * Default implementation creates a simple QMenu.
     */
    virtual QMenu *createMenu(QWidget *parent);

/**
     * Must convert a name into an icon.
     * Default implementation returns a null icon.
     */
    virtual QIcon iconForName(const QString &);

private Q_SLOTS:
    void sendClickedEvent(int);
    void slotMenuAboutToShow();
    void slotMenuAboutToHide();
    void slotAboutToShowDBusCallFinished(QDBusPendingCallWatcher *);
    void slotItemActivationRequested(int id, uint timestamp);
    void processPendingLayoutUpdates();
    void slotLayoutUpdated(uint revision, int parentId);
    void slotGetLayoutFinished(QDBusPendingCallWatcher *);

private:
    Q_DISABLE_COPY(DBusMenuImporter)
    DBusMenuImporterPrivate *const d;
    friend class DBusMenuImporterPrivate;

// Use Q_PRIVATE_SLOT to avoid exposing DBusMenuItemList
    Q_PRIVATE_SLOT(d, void slotItemsPropertiesUpdated(const DBusMenuItemList &updatedList, const DBusMenuItemKeysList &removedList))
};
0707010000003F000081A40000000000000000000000016626CF9D00000986000000000000000000000000000000000000005500000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/dbusmenushortcut_p.cpp/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2009 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include "dbusmenushortcut_p.h"

// Qt
#include <QKeySequence>

static const int QT_COLUMN = 0;
static const int DM_COLUMN = 1;

static void processKeyTokens(QStringList *tokens, int srcCol, int dstCol)
{
    struct Row {
        const char *zero;
        const char *one;
        const char *operator[](int col) const
        {
            return col == 0 ? zero : one;
        }
    };
    static const Row table[] = {{"Meta", "Super"},
                                {"Ctrl", "Control"},
                                // Special cases for compatibility with libdbusmenu-glib which uses
                                // "plus" for "+" and "minus" for "-".
                                // cf https://bugs.launchpad.net/libdbusmenu-qt/+bug/712565
                                {"+", "plus"},
                                {"-", "minus"},
                                {nullptr, nullptr}};

const Row *ptr = table;
    for (; ptr->zero != nullptr; ++ptr) {
        const char *from = (*ptr)[srcCol];
        const char *to = (*ptr)[dstCol];
        tokens->replaceInStrings(from, to);
    }
}

DBusMenuShortcut DBusMenuShortcut::fromKeySequence(const QKeySequence &sequence)
{
    QString string = sequence.toString();
    DBusMenuShortcut shortcut;
    QStringList tokens = string.split(QStringLiteral(", "));
    Q_FOREACH (QString token, tokens) {
        // Hack: Qt::CTRL | Qt::Key_Plus is turned into the string "Ctrl++",
        // but we don't want the call to token.split() to consider the
        // second '+' as a separator so we replace it with its final value.
        token.replace(QLatin1String("++"), QLatin1String("+plus"));
        QStringList keyTokens = token.split('+');
        processKeyTokens(&keyTokens, QT_COLUMN, DM_COLUMN);
        shortcut << keyTokens;
    }
    return shortcut;
}

QKeySequence DBusMenuShortcut::toKeySequence() const
{
    QStringList tmp;
    Q_FOREACH (const QStringList &keyTokens_, *this) {
        QStringList keyTokens = keyTokens_;
        processKeyTokens(&keyTokens, DM_COLUMN, QT_COLUMN);
        tmp << keyTokens.join(QLatin1String("+"));
    }
    QString string = tmp.join(QLatin1String(", "));
    return QKeySequence::fromString(string);
}
07070100000040000081A40000000000000000000000016626CF9D000001D9000000000000000000000000000000000000005300000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/dbusmenushortcut_p.h/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2009 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#pragma once

// Qt
#include <QMetaType>
#include <QStringList>

class QKeySequence;

class DBusMenuShortcut : public QList<QStringList>
{
public:
    QKeySequence toKeySequence() const;
    static DBusMenuShortcut fromKeySequence(const QKeySequence &);
};
07070100000041000081A40000000000000000000000016626CF9D00000D5A000000000000000000000000000000000000005200000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/dbusmenutypes_p.cpp/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2009 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include "dbusmenutypes_p.h"

// Local
#include "dbusmenushortcut_p.h"

// Qt
#include <QDBusArgument>
#include <QDBusMetaType>

//// DBusMenuItem
QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuItem &obj)
{
    argument.beginStructure();
    argument << obj.id << obj.properties;
    argument.endStructure();
    return argument;
}

const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuItem &obj)
{
    argument.beginStructure();
    argument >> obj.id >> obj.properties;
    argument.endStructure();
    return argument;
}

//// DBusMenuItemKeys
QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuItemKeys &obj)
{
    argument.beginStructure();
    argument << obj.id << obj.properties;
    argument.endStructure();
    return argument;
}

const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuItemKeys &obj)
{
    argument.beginStructure();
    argument >> obj.id >> obj.properties;
    argument.endStructure();
    return argument;
}

//// DBusMenuLayoutItem
QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuLayoutItem &obj)
{
    argument.beginStructure();
    argument << obj.id << obj.properties;
    argument.beginArray(qMetaTypeId<QDBusVariant>());
    Q_FOREACH (const DBusMenuLayoutItem &child, obj.children) {
        argument << QDBusVariant(QVariant::fromValue<DBusMenuLayoutItem>(child));
    }
    argument.endArray();
    argument.endStructure();
    return argument;
}

const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuLayoutItem &obj)
{
    argument.beginStructure();
    argument >> obj.id >> obj.properties;
    argument.beginArray();
    while (!argument.atEnd()) {
        QDBusVariant dbusVariant;
        argument >> dbusVariant;
        QDBusArgument childArgument = dbusVariant.variant().value<QDBusArgument>();

DBusMenuLayoutItem child;
        childArgument >> child;
        obj.children.append(child);
    }
    argument.endArray();
    argument.endStructure();
    return argument;
}

//// DBusMenuShortcut
QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuShortcut &obj)
{
    argument.beginArray(qMetaTypeId<QStringList>());
    typename QList<QStringList>::ConstIterator it = obj.constBegin();
    typename QList<QStringList>::ConstIterator end = obj.constEnd();
    for (; it != end; ++it)
        argument << *it;
    argument.endArray();
    return argument;
}

const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuShortcut &obj)
{
    argument.beginArray();
    obj.clear();
    while (!argument.atEnd()) {
        QStringList item;
        argument >> item;
        obj.push_back(item);
    }
    argument.endArray();
    return argument;
}

void DBusMenuTypes_register()
{
    static bool registered = false;
    if (registered) {
        return;
    }
    qDBusRegisterMetaType<DBusMenuItem>();
    qDBusRegisterMetaType<DBusMenuItemList>();
    qDBusRegisterMetaType<DBusMenuItemKeys>();
    qDBusRegisterMetaType<DBusMenuItemKeysList>();
    qDBusRegisterMetaType<DBusMenuLayoutItem>();
    qDBusRegisterMetaType<DBusMenuLayoutItemList>();
    qDBusRegisterMetaType<DBusMenuShortcut>();
    registered = true;
}
07070100000042000081A40000000000000000000000016626CF9D000006DF000000000000000000000000000000000000005000000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/dbusmenutypes_p.h/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2009 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#pragma once

// Qt
#include <QList>
#include <QStringList>
#include <QVariant>

class QDBusArgument;

//// DBusMenuItem
/**
 * Internal struct used to communicate on DBus
 */
struct DBusMenuItem {
    int id;
    QVariantMap properties;
};

QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuItem &item);
const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuItem &item);

typedef QList<DBusMenuItem> DBusMenuItemList;

//// DBusMenuItemKeys
/**
 * Represents a list of keys for a menu item
 */
struct DBusMenuItemKeys {
    int id;
    QStringList properties;
};

QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuItemKeys &);
const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuItemKeys &);

typedef QList<DBusMenuItemKeys> DBusMenuItemKeysList;

//// DBusMenuLayoutItem
/**
 * Represents an item with its children. GetLayout() returns a
 * DBusMenuLayoutItemList.
 */
struct DBusMenuLayoutItem;
struct DBusMenuLayoutItem {
    int id;
    QVariantMap properties;
    QList<DBusMenuLayoutItem> children;
};

QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuLayoutItem &);
const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuLayoutItem &);

typedef QList<DBusMenuLayoutItem> DBusMenuLayoutItemList;

//// DBusMenuShortcut

class DBusMenuShortcut;

QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuShortcut &);
const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuShortcut &);

void DBusMenuTypes_register();07070100000043000081A40000000000000000000000016626CF9D00000029000000000000000000000000000000000000004200000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/rev6ec2af55ed474479f568c44ba0d5ee0c5c822464
07070100000044000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000004300000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/test07070100000045000081A40000000000000000000000016626CF9D0000006C000000000000000000000000000000000000005200000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/test/CMakeLists.txtadd_executable(appmenutest main.cpp)
target_link_libraries(appmenutest
                        Qt::Widgets)
07070100000046000081A40000000000000000000000016626CF9D0000009F000000000000000000000000000000000000004A00000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/test/READMEApp with a menu, designed for use testing appmenu QPTs/applets/kded modules
small enough that we can attach debuggers and breakpoints without drowning in data
07070100000047000081A40000000000000000000000016626CF9D000005A6000000000000000000000000000000000000004C00000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/test/main.cpp/*
    SPDX-FileCopyrightText: 2017 David Edmundson <davidedmundson@kde.org>
    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include <QApplication>

#include <QDateTime>
#include <QDebug>
#include <QIcon>
#include <QMainWindow>
#include <QMenuBar>

class MainWindow : public QMainWindow
{
public:
    MainWindow();
};

MainWindow::MainWindow()
    : QMainWindow()
{
    /*set an initial menu with the following
    Menu A
      - Item
      - Checkable Item
      - Item With Icon
      - A separator
      - Menu B
         - Item B1
     Menu C
      - DynamicItem ${timestamp}

TopLevelItem
    */

QAction *t;
    auto menuA = new QMenu("Menu A", this);
    menuA->addAction("Item");

t = menuA->addAction("Checkable Item");
    t->setCheckable(true);

t = menuA->addAction(QIcon::fromTheme("document-edit"), "Item with icon");

menuA->addSeparator();

auto menuB = new QMenu("Menu B", this);
    menuB->addAction("Item B1");
    menuA->addMenu(menuB);

menuBar()->addMenu(menuA);

auto menuC = new QMenu("Menu C", this);
    connect(menuC, &QMenu::aboutToShow, this, [menuC]() {
        menuC->clear();
        menuC->addAction("Dynamic Item " + QDateTime::currentDateTime().toString());
    });

menuBar()->addMenu(menuC);

menuBar()->addAction("Top Level Item");
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    MainWindow mw;
    mw.show();
    return app.exec();
}
07070100000048000081A40000000000000000000000016626CF9D00000538000000000000000000000000000000000000004800000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/utils.cpp/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2010 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include "utils_p.h"

// Qt
#include <QString>

QString swapMnemonicChar(const QString &in, const char src, const char dst)
{
    QString out;
    bool mnemonicFound = false;

for (int pos = 0; pos < in.length();) {
        QChar ch = in[pos];
        if (ch == src) {
            if (pos == in.length() - 1) {
                // 'src' at the end of string, skip it
                ++pos;
            } else {
                if (in[pos + 1] == src) {
                    // A real 'src'
                    out += src;
                    pos += 2;
                } else if (!mnemonicFound) {
                    // We found the mnemonic
                    mnemonicFound = true;
                    out += dst;
                    ++pos;
                } else {
                    // We already have a mnemonic, just skip the char
                    ++pos;
                }
            }
        } else if (ch == dst) {
            // Escape 'dst'
            out += dst;
            out += dst;
            ++pos;
        } else {
            out += ch;
            ++pos;
        }
    }

return out;
}
07070100000049000081A40000000000000000000000016626CF9D00000187000000000000000000000000000000000000004800000000plasma-active-window-control-116.7736a87/plugin/libdbusmenuqt/utils_p.h/* This file is part of the dbusmenu-qt library
    SPDX-FileCopyrightText: 2010 Canonical
    SPDX-FileContributor: Aurelien Gateau <aurelien.gateau@canonical.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#pragma once

class QString;

/**
 * Swap mnemonic char: Qt uses '&', while dbusmenu uses '_'
 */
QString swapMnemonicChar(const QString &in, const char src, const char dst);
0707010000004A000081A40000000000000000000000016626CF9D0000003C000000000000000000000000000000000000003700000000plasma-active-window-control-116.7736a87/plugin/qmldirmodule org.kde.plasma.private.appmenu

plugin appmenuplugin
0707010000004B000081A40000000000000000000000016626CF9D00000029000000000000000000000000000000000000003400000000plasma-active-window-control-116.7736a87/plugin/rev3038aa55a6f2a54f9831d9ea09c2ffdfa61625b4
0707010000004C000041ED0000000000000000000000286626CF9D00000000000000000000000000000000000000000000002C00000000plasma-active-window-control-116.7736a87/po0707010000004D000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000002F00000000plasma-active-window-control-116.7736a87/po/az0707010000004E000081A40000000000000000000000016626CF9D00002DE4000000000000000000000000000000000000005C00000000plasma-active-window-control-116.7736a87/po/az/plasma_applet_org.kde.activeWindowControl.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the plasma-active-window-control package.
#
# Xəyyam Qocayev <xxmn77@gmail.com>, 2020, 2022.
msgid ""
msgstr ""
"Project-Id-Version: plasma-active-window-control\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2021-05-23 00:18+0000\n"
"PO-Revision-Date: 2022-07-03 14:23+0400\n"
"Last-Translator: Kheyyam <xxmn77@gmail.com>\n"
"Language-Team: Azerbaijani <kde-i18n-doc@kde.org>\n"
"Language: az\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Lokalize 22.04.2\n"

#: package/contents/config/config.qml:6
msgid "Appearance"
msgstr "Xarici görünüş"

#: package/contents/config/config.qml:11
msgid "Behaviour"
msgstr "Davranış"

#: package/contents/config/config.qml:16
msgid "Buttons"
msgstr "Düymələr"

#: package/contents/config/config.qml:21
msgid "Mouse Control"
msgstr "Siçan İdarəetməsi"

#: package/contents/config/config.qml:26
msgid "Application Menu"
msgstr "Tətbiq menyusu"

#: package/contents/ui/config/ConfigAppearance.qml:73
msgctxt "Use default font"
msgid "Default"
msgstr "Standart"

#: package/contents/ui/config/ConfigAppearance.qml:90
msgid "Plasmoid version: "
msgstr "Plasmoid versiyası: "

#: package/contents/ui/config/ConfigAppearance.qml:96
msgid "Width in horizontal panel:"
msgstr "Üfüqi panelin eni:"

#: package/contents/ui/config/ConfigAppearance.qml:103
msgid "Fill width"
msgstr "Eninə doldurmaq"

#: package/contents/ui/config/ConfigAppearance.qml:122
msgid "Fine tuning:"
msgstr "Dəqiq ölçü:"

#: package/contents/ui/config/ConfigAppearance.qml:142
msgid "Hide titlebar for maximized windows (takes effect immediately)"
msgstr "Açılmış pəncərələrin çərçivəsini gizlətmək (dərhal işə düşür)"

#: package/contents/ui/config/ConfigAppearance.qml:158
msgid "Show window title"
msgstr "Pəncərə başlığını gizlətmək"

#: package/contents/ui/config/ConfigAppearance.qml:173
msgid "Text type:"
msgstr "Mətn növü:"

#: package/contents/ui/config/ConfigAppearance.qml:178
#: package/contents/ui/config/ConfigAppearance.qml:196
#: package/contents/ui/config/ConfigAppearance.qml:201
msgid "Window title"
msgstr "Pəncərə başlığı"

#: package/contents/ui/config/ConfigAppearance.qml:178
#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "Application name"
msgstr "Tətbiqin adı"

#: package/contents/ui/config/ConfigAppearance.qml:182
msgid "Fit text:"
msgstr "Mətn doldurma:"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Just elide"
msgstr "Kəsmək"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Fit on hover"
msgstr "Üzərində olduqda açmaq"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Always fit"
msgstr "Tam göstərmək"

#: package/contents/ui/config/ConfigAppearance.qml:191
msgid "Tooltip text:"
msgstr "İpucları mətni:"

#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "No tooltip"
msgstr "İpucları yoxdur:"

#: package/contents/ui/config/ConfigAppearance.qml:233
msgid "No window text:"
msgstr "Pəncərə mətni yoxdur:"

#: package/contents/ui/config/ConfigAppearance.qml:247
msgid "Use %activity% placeholder to show current activity name."
msgstr ""
"Cari İş otağının adını göstərmək üçün %iş_otağı% doldurucusundan istifadə "
"edin."

#: package/contents/ui/config/ConfigAppearance.qml:254
msgid "No window icon:"
msgstr "Pəncırı nişanı yoxdur:"

#: package/contents/ui/config/ConfigAppearance.qml:265
msgid "Limit text width"
msgstr "Məhdud mətn eni"

#: package/contents/ui/config/ConfigAppearance.qml:275
#: package/contents/ui/config/ConfigAppMenu.qml:95
msgctxt "Abbreviation for pixels"
msgid "px"
msgstr "piksel"

#: package/contents/ui/config/ConfigAppearance.qml:288
msgid "Show window icon"
msgstr "Pəncərə nişanını göstərmək"

#: package/contents/ui/config/ConfigAppearance.qml:294
msgid "Window icon on the right"
msgstr "Pəncərə nişanı sağda"

#: package/contents/ui/config/ConfigAppearance.qml:315
msgid "Bold text"
msgstr "Qalın mətn"

#: package/contents/ui/config/ConfigAppearance.qml:319
msgid "Text font:"
msgstr "Mətnin şrifti:"

#: package/contents/ui/config/ConfigAppearance.qml:340
msgid "Icon and text spacing:"
msgstr "Nişan və mətn arası boşluq:"

#: package/contents/ui/config/ConfigAppearance.qml:352
msgid "Font size scale:"
msgstr "Şrift ölçüsünün miqyası:"

#: package/contents/ui/config/ConfigAppMenu.qml:23
msgid "Enable application menu"
msgstr "Tətbiq menyusunu aktiv etmək"

#: package/contents/ui/config/ConfigAppMenu.qml:38
msgid "Fill height"
msgstr "Bütün hündürlüyü doldurmaq"

#: package/contents/ui/config/ConfigAppMenu.qml:44
msgid "Bold font"
msgstr "Qalın şrift"

#: package/contents/ui/config/ConfigAppMenu.qml:50
#: package/contents/ui/config/ConfigButtons.qml:173
msgid "Do not hide on mouse out"
msgstr "Kursor üzərində olmayanda belə söndürməmək"

#: package/contents/ui/config/ConfigAppMenu.qml:55
msgid "Show next to buttons"
msgstr "Düymələrdən sonra göstərmək"

#: package/contents/ui/config/ConfigAppMenu.qml:61
msgid "Show next to icon and text"
msgstr "Nişan və mətndən sonra göstərmək"

#: package/contents/ui/config/ConfigAppMenu.qml:67
msgid "Switch sides with icon and text"
msgstr "Kənarları naşan və mətn ilə dəyişdirmək"

#: package/contents/ui/config/ConfigAppMenu.qml:74
msgid "Show separator"
msgstr "Ayiricinı göstərmək"

#: package/contents/ui/config/ConfigAppMenu.qml:81
msgid "Make window title bold when menu is displayed"
msgstr "Menyu göstərildikdə pəncərə başlığını qalın etmək"

#: package/contents/ui/config/ConfigAppMenu.qml:86
msgid "Side margin:"
msgstr "Yan tərəf:"

#: package/contents/ui/config/ConfigAppMenu.qml:99
msgid "Icon and text opacity:"
msgstr "Nişan və mətn qeyri-şəffaflığı:"

#: package/contents/ui/config/ConfigAppMenu.qml:111
msgid "Menu button text size scale:"
msgstr "Menyu düyməsi mətnin ölçüsü:"

#: package/contents/ui/config/ConfigBehaviour.qml:14
msgid "Show active window only for plasmoid's screen"
msgstr "Aktiv menyunu yalnız plasmod ekranı üçün göstərmək"

#: package/contents/ui/config/ConfigButtons.qml:90
msgid "Enable Control Buttons"
msgstr "İdarəetmə düymələrini aktiv etmək"

#: package/contents/ui/config/ConfigButtons.qml:111
msgid "Show minimize button"
msgstr "\"Yığmaq\" düyməsini göstərmək"

#: package/contents/ui/config/ConfigButtons.qml:116
msgid "Show maximize button"
msgstr "\"Açmaq\" düyməsini göstərmək"

#: package/contents/ui/config/ConfigButtons.qml:121
msgid "Show pin to all desktops"
msgstr "\"Sancaqlamaq\" düyməsini bütün iş masalarında göstərmək"

#: package/contents/ui/config/ConfigButtons.qml:131
msgid "Button order:"
msgstr "Düymələrin düzülüşü:"

#: package/contents/ui/config/ConfigButtons.qml:167
msgid "Behaviour:"
msgstr "Davranış:"

#: package/contents/ui/config/ConfigButtons.qml:184
msgid "Show only when maximized"
msgstr "Yalnız tam açıldığında göstərmək"

#: package/contents/ui/config/ConfigButtons.qml:189
msgid "Buttons next to icon and text"
msgstr "Düymələr, nişan və mətndən sonra"

#: package/contents/ui/config/ConfigButtons.qml:194
msgid "Buttons between icon and text"
msgstr "Düymələr, nişan və mətnin arasında"

#: package/contents/ui/config/ConfigButtons.qml:200
msgid "Dynamic width"
msgstr "Dinamik en"

#: package/contents/ui/config/ConfigButtons.qml:206
msgid "Sliding icon and text"
msgstr "Nişan və mətn yerdəyişməsi"

#: package/contents/ui/config/ConfigButtons.qml:218
msgid "Position:"
msgstr "Mövqeyi:"

#: package/contents/ui/config/ConfigButtons.qml:224
msgid "Upper left"
msgstr "Yuxarı sola"

#: package/contents/ui/config/ConfigButtons.qml:235
msgid "Upper right"
msgstr "Yuxarı sağa"

#: package/contents/ui/config/ConfigButtons.qml:241
msgid "Bottom left"
msgstr "Aşağı sola"

#: package/contents/ui/config/ConfigButtons.qml:247
msgid "Bottom right"
msgstr "Aşağı sağa"

#: package/contents/ui/config/ConfigButtons.qml:253
msgid "Vertical center"
msgstr "Şaqulu mərkəz"

#: package/contents/ui/config/ConfigButtons.qml:263
msgid "Button size:"
msgstr "Düymənin ölçüsü:"

#: package/contents/ui/config/ConfigButtons.qml:275
msgid "Buttons spacing:"
msgstr "Düymələr arası məsafə:"

#: package/contents/ui/config/ConfigButtons.qml:294
msgid "Theme"
msgstr "Mövzu"

#: package/contents/ui/config/ConfigButtons.qml:300
msgid "Automatic"
msgstr "Avtomatik"

#: package/contents/ui/config/ConfigButtons.qml:304
msgid "Absolute path to aurorae button theme folder"
msgstr "Aurorae düyməsi mövzusu qovluğuna mütləq yol"

#: package/contents/ui/config/ConfigMouseControl.qml:84
msgid "Mouse Buttons:"
msgstr "Siçan düymələri:"

#: package/contents/ui/config/ConfigMouseControl.qml:89
msgid "Doubleclick to toggle maximizing"
msgstr "İki dəfə vurmaqla açmaq"

#: package/contents/ui/config/ConfigMouseControl.qml:101
msgid "Left click disabled"
msgstr "Sol klik söndürülüb"

#: package/contents/ui/config/ConfigMouseControl.qml:108
msgid "Left click to present windows (Current Desktop)"
msgstr "Sol klik pəncərələri göstərmək üçün (Cari İş masası)"

#: package/contents/ui/config/ConfigMouseControl.qml:115
msgid "Left click to present windows (All Desktops)"
msgstr "Sol klik pəncərələri göstərmək üçün (Bütün İş Masaları)"

#: package/contents/ui/config/ConfigMouseControl.qml:122
msgid "Left click to present windows (Window Class)"
msgstr "Sol klik pəncərələri göstərmək üçün (Pəncərə Sinifi)"

#: package/contents/ui/config/ConfigMouseControl.qml:140
msgid "Middle click disabled"
msgstr "Orta düymə klikini söndürmək"

#: package/contents/ui/config/ConfigMouseControl.qml:146
msgid "Middle click to close active window"
msgstr "Orta kliklə aktiv pəncərəni bağlamaq"

#: package/contents/ui/config/ConfigMouseControl.qml:152
msgid "Middle click to toggle fullscreen"
msgstr "Orta kliklə tam ekran açmaq/bağlamq"

#: package/contents/ui/config/ConfigMouseControl.qml:163
msgid "Mouse Wheel:"
msgstr "Siçan diyircəyi:"

#: package/contents/ui/config/ConfigMouseControl.qml:168
msgid "Mouse wheel up to maximize"
msgstr "Siçan ditircəyinin \"yuxarı\" fırlatmaqla açmaq"

#: package/contents/ui/config/ConfigMouseControl.qml:178
msgid "Mouse wheel down disabled"
msgstr "Siçan diyircəyi söndürülüb"

#: package/contents/ui/config/ConfigMouseControl.qml:184
msgid "Mouse wheel down to minimize"
msgstr "Siçan diyircəyini \"aşağı\" fırlatmaqla yığmaq"

#: package/contents/ui/config/ConfigMouseControl.qml:190
msgid "Mouse wheel down to unmaximize"
msgstr "\"Aşağı\" fırlatmaqla gizlətmək"

#: package/contents/ui/config/IconPicker.qml:73
msgctxt "@item:inmenu Open icon chooser dialog"
msgid "Choose..."
msgstr "Seçim..."

#: package/contents/ui/config/IconPicker.qml:78
msgctxt "@item:inmenu Reset icon to default"
msgid "Clear Icon"
msgstr "Nişanı təmizləmək"

#: package/contents/ui/main.qml:583
msgid "Switch to activity: %1"
msgstr "İş masasında göstərmək: %1"

#: package/contents/ui/main.qml:591
msgid "Close"
msgstr "Bağlamaq"

#: package/contents/ui/main.qml:592
msgid "Toggle Maximise"
msgstr "Açmaq"

#: package/contents/ui/main.qml:593
msgid "Minimise"
msgstr "Yığmaq"

#: package/contents/ui/main.qml:594
msgid "Toggle Pin To All Desktops"
msgstr "Bütün İş Masalarına bərkitmək"

#: package/contents/ui/main.qml:596
msgid "Reload Theme"
msgstr "Mövzunu yenidən yükləmək"
0707010000004F000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000002F00000000plasma-active-window-control-116.7736a87/po/be07070100000050000081A40000000000000000000000016626CF9D000035C9000000000000000000000000000000000000005C00000000plasma-active-window-control-116.7736a87/po/be/plasma_applet_org.kde.activeWindowControl.po# Zmicier <zmicerturok@gmail.com>, 2023.
msgid ""
msgstr ""
"Project-Id-Version: 86ff119b1606fcaa910d6b44fc14b611\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2021-05-23 00:18+0000\n"
"PO-Revision-Date: 2023-01-20 17:01\n"
"Last-Translator: Zmicier <zmicerturok@gmail.com>\n"
"Language-Team: Belarusian\n"
"Language: be\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || n%10>=5 && n%10<=9 || n"
"%100>=11 && n%100<=14 ? 2 : 3);\n"
"X-Generator: Lokalize 22.12.1\n"
"X-Crowdin-Project: 86ff119b1606fcaa910d6b44fc14b611\n"
"X-Crowdin-Project-ID: 127\n"
"X-Crowdin-Language: be\n"
"X-Crowdin-File: /main/be/plasma-active-window-control/plasma_applet_org.kde."
"activeWindowControl.po\n"
"X-Crowdin-File-ID: 9078\n"

#: package/contents/config/config.qml:6
msgid "Appearance"
msgstr "Выгляд"

#: package/contents/config/config.qml:11
msgid "Behaviour"
msgstr "Паводзіны"

#: package/contents/config/config.qml:16
msgid "Buttons"
msgstr "Кнопкі"

#: package/contents/config/config.qml:21
msgid "Mouse Control"
msgstr "Кіраванне мышшу"

#: package/contents/config/config.qml:26
msgid "Application Menu"
msgstr "Меню праграмы"

#: package/contents/ui/config/ConfigAppearance.qml:73
msgctxt "Use default font"
msgid "Default"
msgstr "Прадвызначана"

#: package/contents/ui/config/ConfigAppearance.qml:90
msgid "Plasmoid version: "
msgstr "Версія плазмоіда: "

#: package/contents/ui/config/ConfigAppearance.qml:96
msgid "Width in horizontal panel:"
msgstr "Шырыня на гарызантальнай панэлі:"

#: package/contents/ui/config/ConfigAppearance.qml:103
msgid "Fill width"
msgstr "Шырыня запаўнення"

#: package/contents/ui/config/ConfigAppearance.qml:122
msgid "Fine tuning:"
msgstr "Глыбокае наладжванне:"

#: package/contents/ui/config/ConfigAppearance.qml:142
msgid "Hide titlebar for maximized windows (takes effect immediately)"
msgstr "Хаваць панэль загалоўка для разгорнутых акон (набывае моц неадкладна)"

#: package/contents/ui/config/ConfigAppearance.qml:158
msgid "Show window title"
msgstr "Паказваць загаловак акна"

#: package/contents/ui/config/ConfigAppearance.qml:173
msgid "Text type:"
msgstr "Тып тэксту:"

#: package/contents/ui/config/ConfigAppearance.qml:178
#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "Application name"
msgstr "Назва праграмы"

#: package/contents/ui/config/ConfigAppearance.qml:182
msgid "Fit text:"
msgstr "Запаўненне тэкстам:"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Just elide"
msgstr "Проста паказаць"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Fit on hover"
msgstr "Паказваць пры навядзенні"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Always fit"
msgstr "Заўсёды паказваць"

#: package/contents/ui/config/ConfigAppearance.qml:191
msgid "Tooltip text:"
msgstr "Тэкст падказкі:"

#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "No tooltip"
msgstr "Без падказак"

#: package/contents/ui/config/ConfigAppearance.qml:233
msgid "No window text:"
msgstr "Тэкст акна:"

#: package/contents/ui/config/ConfigAppearance.qml:247
msgid "Use %activity% placeholder to show current activity name."
msgstr ""
"Выкарыстоўвайце запаўняльнік \"%activity%\", каб паказвалася назва бягучага "
"пакоя."

#: package/contents/ui/config/ConfigAppearance.qml:254
msgid "No window icon:"
msgstr "Значок акна:"

#: package/contents/ui/config/ConfigAppearance.qml:265
msgid "Limit text width"
msgstr "Абмежаванне шырыні тэксту"

#: package/contents/ui/config/ConfigAppearance.qml:275
#: package/contents/ui/config/ConfigAppMenu.qml:95
msgctxt "Abbreviation for pixels"
msgid "px"
msgstr "пікс."

#: package/contents/ui/config/ConfigAppearance.qml:288
msgid "Show window icon"
msgstr "Паказваць значкі акон"

#: package/contents/ui/config/ConfigAppearance.qml:294
msgid "Window icon on the right"
msgstr "Паказваць значкі акон справа"

#: package/contents/ui/config/ConfigAppearance.qml:315
msgid "Bold text"
msgstr "Тоўсты тэкст"

#: package/contents/ui/config/ConfigAppearance.qml:319
msgid "Text font:"
msgstr "Шрыфт тэксту:"

#: package/contents/ui/config/ConfigAppearance.qml:340
msgid "Icon and text spacing:"
msgstr "Прамежак паміж значкамі і тэкстам:"

#: package/contents/ui/config/ConfigAppearance.qml:352
msgid "Font size scale:"
msgstr "Маштабаванне памеру шрыфту:"

#: package/contents/ui/config/ConfigAppMenu.qml:23
msgid "Enable application menu"
msgstr "Уключыць меню праграмы"

#: package/contents/ui/config/ConfigAppMenu.qml:38
msgid "Fill height"
msgstr "Запаўненне па вышыні"

#: package/contents/ui/config/ConfigAppMenu.qml:44
msgid "Bold font"
msgstr "Тоўсты шрыфт"

#: package/contents/ui/config/ConfigAppMenu.qml:50
#: package/contents/ui/config/ConfigButtons.qml:173
msgid "Do not hide on mouse out"
msgstr "Не хаваць пасля прыбірання мышы"

#: package/contents/ui/config/ConfigAppMenu.qml:55
msgid "Show next to buttons"
msgstr "Паказваць пасля кнопак"

#: package/contents/ui/config/ConfigAppMenu.qml:61
msgid "Show next to icon and text"
msgstr "Паказваць пасля значкоў і тэксту"

#: package/contents/ui/config/ConfigAppMenu.qml:67
msgid "Switch sides with icon and text"
msgstr "Памяняць месцамі са значкамі і тэкстам"

#: package/contents/ui/config/ConfigAppMenu.qml:74
msgid "Show separator"
msgstr "Паказваць падзяляльнік"

#: package/contents/ui/config/ConfigAppMenu.qml:81
msgid "Make window title bold when menu is displayed"
msgstr "Рабіць загаловак акна тоўстым, калі паказваецца меню"

#: package/contents/ui/config/ConfigAppMenu.qml:86
msgid "Side margin:"
msgstr "Бакавое поле:"

#: package/contents/ui/config/ConfigAppMenu.qml:99
msgid "Icon and text opacity:"
msgstr "Непразрыстасць значкоў і тэксту:"

#: package/contents/ui/config/ConfigAppMenu.qml:111
msgid "Menu button text size scale:"
msgstr "Маштабаванне памеру тэксту кнопкі меню:"

#: package/contents/ui/config/ConfigBehaviour.qml:14
msgid "Show active window only for plasmoid's screen"
msgstr "Паказваць актыўнае акно толькі для экрана плазмоіда"

#: package/contents/ui/config/ConfigButtons.qml:90
msgid "Enable Control Buttons"
msgstr "Уключыць кнопкі кіравання"

#: package/contents/ui/config/ConfigButtons.qml:111
msgid "Show minimize button"
msgstr "Паказваць кнопку згортвання"

#: package/contents/ui/config/ConfigButtons.qml:116
msgid "Show maximize button"
msgstr "Паказваць кнопку разгортвання"

#: package/contents/ui/config/ConfigButtons.qml:121
msgid "Show pin to all desktops"
msgstr "Паказваць на ўсіх працоўных сталах"

#: package/contents/ui/config/ConfigButtons.qml:131
msgid "Button order:"
msgstr "Парадак кнопак:"

#: package/contents/ui/config/ConfigButtons.qml:167
msgid "Behaviour:"
msgstr "Паводзіны:"

#: package/contents/ui/config/ConfigButtons.qml:184
msgid "Show only when maximized"
msgstr "Паказваць толькі пры разгорнутым стане"

#: package/contents/ui/config/ConfigButtons.qml:189
msgid "Buttons next to icon and text"
msgstr "Размяшчаць кнопкі пасля значкоў і тэксту"

#: package/contents/ui/config/ConfigButtons.qml:194
msgid "Buttons between icon and text"
msgstr "Размяшчаць кнопкі перад значкамі і тэкстам"

#: package/contents/ui/config/ConfigButtons.qml:200
msgid "Dynamic width"
msgstr "Дынамічная шырыня"

#: package/contents/ui/config/ConfigButtons.qml:206
msgid "Sliding icon and text"
msgstr "Рухомыя значкі і тэкст"

#: package/contents/ui/config/ConfigButtons.qml:218
msgid "Position:"
msgstr "Пазіцыя:"

#: package/contents/ui/config/ConfigButtons.qml:224
msgid "Upper left"
msgstr "Уверсе злева"

#: package/contents/ui/config/ConfigButtons.qml:235
msgid "Upper right"
msgstr "Уверсе справа"

#: package/contents/ui/config/ConfigButtons.qml:241
msgid "Bottom left"
msgstr "Унізе злева"

#: package/contents/ui/config/ConfigButtons.qml:247
msgid "Bottom right"
msgstr "Унізе справа"

#: package/contents/ui/config/ConfigButtons.qml:253
msgid "Vertical center"
msgstr "Па цэнтры"

#: package/contents/ui/config/ConfigButtons.qml:263
msgid "Button size:"
msgstr "Памеры кнопак:"

#: package/contents/ui/config/ConfigButtons.qml:275
msgid "Buttons spacing:"
msgstr "Прамежак паміж кнопкамі:"

#: package/contents/ui/config/ConfigButtons.qml:294
msgid "Theme"
msgstr "Тэма"

#: package/contents/ui/config/ConfigButtons.qml:300
msgid "Automatic"
msgstr "Аўтаматычна"

#: package/contents/ui/config/ConfigButtons.qml:304
msgid "Absolute path to aurorae button theme folder"
msgstr "Абсалютны шлях да тэмы кнопак aurorae"

#: package/contents/ui/config/ConfigMouseControl.qml:84
msgid "Mouse Buttons:"
msgstr "Кнопкі мышы:"

#: package/contents/ui/config/ConfigMouseControl.qml:89
msgid "Doubleclick to toggle maximizing"
msgstr "Падвойнае пстрыканне для разгортвання або згортвання"

#: package/contents/ui/config/ConfigMouseControl.qml:101
msgid "Left click disabled"
msgstr "Пстрыканне левай кнопкай мышы адключана"

#: package/contents/ui/config/ConfigMouseControl.qml:108
msgid "Left click to present windows (Current Desktop)"
msgstr "Пстрыканне левай кнопкай мышы паказвае вокны (бягучы працоўны стол)"

#: package/contents/ui/config/ConfigMouseControl.qml:115
msgid "Left click to present windows (All Desktops)"
msgstr "Пстрыканне левай кнопкай мышы паказвае вокны (усе працоўныя сталы)"

#: package/contents/ui/config/ConfigMouseControl.qml:122
msgid "Left click to present windows (Window Class)"
msgstr "Пстрыканне левай кнопкай мышы паказвае вокны (клас акон)"

#: package/contents/ui/config/ConfigMouseControl.qml:140
msgid "Middle click disabled"
msgstr "Пстрыканне сярэдняй кнопкай мышы адключана"

#: package/contents/ui/config/ConfigMouseControl.qml:146
msgid "Middle click to close active window"
msgstr "Пстрыканне сярэдняй кнопкай мышы закрывае актыўнае акно"

#: package/contents/ui/config/ConfigMouseControl.qml:152
msgid "Middle click to toggle fullscreen"
msgstr "Пстрыканне сярэдняй кнопкай мышы пераключае поўнаэкранны рэжым"

#: package/contents/ui/config/ConfigMouseControl.qml:163
msgid "Mouse Wheel:"
msgstr "Кола мышы:"

#: package/contents/ui/config/ConfigMouseControl.qml:168
msgid "Mouse wheel up to maximize"
msgstr "Пракручванне колам мышы ўверх разгортвае акно"

#: package/contents/ui/config/ConfigMouseControl.qml:178
msgid "Mouse wheel down disabled"
msgstr "Пракручванне колам мышы ўніз адключана"

#: package/contents/ui/config/ConfigMouseControl.qml:184
msgid "Mouse wheel down to minimize"
msgstr "Пракручванне колам мышы ўніз згортвае акно"

#: package/contents/ui/config/ConfigMouseControl.qml:190
msgid "Mouse wheel down to unmaximize"
msgstr "Пракручванне колам мышы ўніз скасоўвае разгортванне акна"

#: package/contents/ui/config/IconPicker.qml:73
msgctxt "@item:inmenu Open icon chooser dialog"
msgid "Choose..."
msgstr "Абраць..."

#: package/contents/ui/config/IconPicker.qml:78
msgctxt "@item:inmenu Reset icon to default"
msgid "Clear Icon"
msgstr "Прыбраць значок"

#: package/contents/ui/main.qml:583
msgid "Switch to activity: %1"
msgstr "Пераключыцца на пакой: %1"

#: package/contents/ui/main.qml:591
msgid "Close"
msgstr "Закрыць"

#: package/contents/ui/main.qml:592
msgid "Toggle Maximise"
msgstr "Разгарнуць або згарнуць"

#: package/contents/ui/main.qml:593
msgid "Minimise"
msgstr "Згарнуць"

#: package/contents/ui/main.qml:594
msgid "Toggle Pin To All Desktops"
msgstr "Уключыць або адключыць замацаванне для ўсіх працоўных сталоў"

#: package/contents/ui/main.qml:596
msgid "Reload Theme"
msgstr "Перазагрузіць тэму"
07070100000051000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000002F00000000plasma-active-window-control-116.7736a87/po/bg07070100000052000081A40000000000000000000000016626CF9D000036E8000000000000000000000000000000000000005C00000000plasma-active-window-control-116.7736a87/po/bg/plasma_applet_org.kde.activeWindowControl.po# Bulgarian translations for plasma-active-window-control package.
# Copyright (C) 2022 This file is copyright:
# This file is distributed under the same license as the plasma-active-window-control package.
#
# Automatically generated, 2022.
# Mincho Kondarev <mkondarev@yahoo.de>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: plasma-active-window-control\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2021-05-23 00:18+0000\n"
"PO-Revision-Date: 2022-07-10 15:00+0200\n"
"Last-Translator: Mincho Kondarev <mkondarev@yahoo.de>\n"
"Language-Team: Bulgarian <kde-i18n-doc@kde.org>\n"
"Language: bg\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 22.04.2\n"

#: package/contents/config/config.qml:6
msgid "Appearance"
msgstr "Външен вид"

#: package/contents/config/config.qml:11
msgid "Behaviour"
msgstr "Поведение"

#: package/contents/config/config.qml:16
msgid "Buttons"
msgstr "Бутони"

#: package/contents/config/config.qml:21
msgid "Mouse Control"
msgstr "Контрол с мишката"

#: package/contents/config/config.qml:26
msgid "Application Menu"
msgstr "Меню с приложения"

#: package/contents/ui/config/ConfigAppearance.qml:73
msgctxt "Use default font"
msgid "Default"
msgstr "По подразбиране"

#: package/contents/ui/config/ConfigAppearance.qml:90
msgid "Plasmoid version: "
msgstr "Версия на плазмоид: "

#: package/contents/ui/config/ConfigAppearance.qml:96
msgid "Width in horizontal panel:"
msgstr "Широчина в хоризонтален панел:"

#: package/contents/ui/config/ConfigAppearance.qml:103
msgid "Fill width"
msgstr "Изпълване на широчина"

#: package/contents/ui/config/ConfigAppearance.qml:122
msgid "Fine tuning:"
msgstr "Фина настройка"

#: package/contents/ui/config/ConfigAppearance.qml:142
msgid "Hide titlebar for maximized windows (takes effect immediately)"
msgstr ""
"Скриване на заглавната лента за максимизирани прозорци (влиза в сила веднага)"

#: package/contents/ui/config/ConfigAppearance.qml:158
msgid "Show window title"
msgstr "Показване на заглавие на прозорец"

#: package/contents/ui/config/ConfigAppearance.qml:173
msgid "Text type:"
msgstr "Вид на текст:"

#: package/contents/ui/config/ConfigAppearance.qml:178
#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "Application name"
msgstr "Име на приложение"

#: package/contents/ui/config/ConfigAppearance.qml:182
msgid "Fit text:"
msgstr "Напасване на текст:"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Just elide"
msgstr "Просто пренебрегване"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Fit on hover"
msgstr "Напасване при посочване"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Always fit"
msgstr "Винаги да се напасва"

#: package/contents/ui/config/ConfigAppearance.qml:191
msgid "Tooltip text:"
msgstr "Текст на подсказка:"

#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "No tooltip"
msgstr "Без подсказка"

#: package/contents/ui/config/ConfigAppearance.qml:233
msgid "No window text:"
msgstr "Без текст на прозорец:"

#: package/contents/ui/config/ConfigAppearance.qml:247
msgid "Use %activity% placeholder to show current activity name."
msgstr ""
"Използване на заместителя %activity% за показване на името на текущата "
"дейност."

#: package/contents/ui/config/ConfigAppearance.qml:254
msgid "No window icon:"
msgstr "Без икона на прозорец:"

#: package/contents/ui/config/ConfigAppearance.qml:265
msgid "Limit text width"
msgstr "Ограничение на широчина на текст"

#: package/contents/ui/config/ConfigAppearance.qml:275
#: package/contents/ui/config/ConfigAppMenu.qml:95
msgctxt "Abbreviation for pixels"
msgid "px"
msgstr "px"

#: package/contents/ui/config/ConfigAppearance.qml:288
msgid "Show window icon"
msgstr "Показване на икона на прозорец"

#: package/contents/ui/config/ConfigAppearance.qml:294
msgid "Window icon on the right"
msgstr "Икона на прозорец в дясно"

#: package/contents/ui/config/ConfigAppearance.qml:315
msgid "Bold text"
msgstr "Удебелен текст"

#: package/contents/ui/config/ConfigAppearance.qml:319
msgid "Text font:"
msgstr "Шрифт за текста:"

#: package/contents/ui/config/ConfigAppearance.qml:340
msgid "Icon and text spacing:"
msgstr "Отстояние на икони и текст:"

#: package/contents/ui/config/ConfigAppearance.qml:352
msgid "Font size scale:"
msgstr "Мащаб на шрифта:"

#: package/contents/ui/config/ConfigAppMenu.qml:23
msgid "Enable application menu"
msgstr "Активиране на Меню с приложения"

#: package/contents/ui/config/ConfigAppMenu.qml:38
msgid "Fill height"
msgstr "Изпълване на височина"

#: package/contents/ui/config/ConfigAppMenu.qml:44
msgid "Bold font"
msgstr "Получер шрифт"

#: package/contents/ui/config/ConfigAppMenu.qml:50
#: package/contents/ui/config/ConfigButtons.qml:173
msgid "Do not hide on mouse out"
msgstr "Да не се скрива при отдалечаване на мишката"

#: package/contents/ui/config/ConfigAppMenu.qml:55
msgid "Show next to buttons"
msgstr "Показване до бутоните"

#: package/contents/ui/config/ConfigAppMenu.qml:61
msgid "Show next to icon and text"
msgstr "Показване до икони и текст"

#: package/contents/ui/config/ConfigAppMenu.qml:67
msgid "Switch sides with icon and text"
msgstr "Смяна на страните с икона и текст"

#: package/contents/ui/config/ConfigAppMenu.qml:74
msgid "Show separator"
msgstr "Показване на разделител"

#: package/contents/ui/config/ConfigAppMenu.qml:81
msgid "Make window title bold when menu is displayed"
msgstr "Удебеляване на заглавието на прозореца, когато се показва менюто"

#: package/contents/ui/config/ConfigAppMenu.qml:86
msgid "Side margin:"
msgstr "Странично разстояние:"

#: package/contents/ui/config/ConfigAppMenu.qml:99
msgid "Icon and text opacity:"
msgstr "Прозрачност на икони и текст:"

#: package/contents/ui/config/ConfigAppMenu.qml:111
msgid "Menu button text size scale:"
msgstr "Размер на текста на меню бутона:"

#: package/contents/ui/config/ConfigBehaviour.qml:14
msgid "Show active window only for plasmoid's screen"
msgstr "Показване на активен прозорец само за екран на плазмоид"

#: package/contents/ui/config/ConfigButtons.qml:90
msgid "Enable Control Buttons"
msgstr "Активиране на контролните бутони"

#: package/contents/ui/config/ConfigButtons.qml:111
msgid "Show minimize button"
msgstr "Показване на бутона за минимизиране"

#: package/contents/ui/config/ConfigButtons.qml:116
msgid "Show maximize button"
msgstr "Показване на бутона за максимизиране"

#: package/contents/ui/config/ConfigButtons.qml:121
msgid "Show pin to all desktops"
msgstr "Показване на бутона Закачане на всички работни плотове"

#: package/contents/ui/config/ConfigButtons.qml:131
msgid "Button order:"
msgstr "Подредба на бутоните:"

#: package/contents/ui/config/ConfigButtons.qml:167
msgid "Behaviour:"
msgstr "Поведение:"

#: package/contents/ui/config/ConfigButtons.qml:184
msgid "Show only when maximized"
msgstr "Показване само при максимизиране"

#: package/contents/ui/config/ConfigButtons.qml:189
msgid "Buttons next to icon and text"
msgstr "Бутони до икони и текст"

#: package/contents/ui/config/ConfigButtons.qml:194
msgid "Buttons between icon and text"
msgstr "Бутони между текст и икона"

#: package/contents/ui/config/ConfigButtons.qml:200
msgid "Dynamic width"
msgstr "Динамична широчина"

#: package/contents/ui/config/ConfigButtons.qml:206
msgid "Sliding icon and text"
msgstr "Плъзгаща се икона и текст"

#: package/contents/ui/config/ConfigButtons.qml:218
msgid "Position:"
msgstr "Позиция:"

#: package/contents/ui/config/ConfigButtons.qml:224
msgid "Upper left"
msgstr "Горе вляво"

#: package/contents/ui/config/ConfigButtons.qml:235
msgid "Upper right"
msgstr "Горе вдясно"

#: package/contents/ui/config/ConfigButtons.qml:241
msgid "Bottom left"
msgstr "Долу вляво"

#: package/contents/ui/config/ConfigButtons.qml:247
msgid "Bottom right"
msgstr "Долу вдясно"

#: package/contents/ui/config/ConfigButtons.qml:253
msgid "Vertical center"
msgstr "Вертикално центрирано"

#: package/contents/ui/config/ConfigButtons.qml:263
msgid "Button size:"
msgstr "Размер на бутоните:"

#: package/contents/ui/config/ConfigButtons.qml:275
msgid "Buttons spacing:"
msgstr "Разстояние между бутоните:"

#: package/contents/ui/config/ConfigButtons.qml:294
msgid "Theme"
msgstr "Тема"

#: package/contents/ui/config/ConfigButtons.qml:300
msgid "Automatic"
msgstr "Автоматично"

#: package/contents/ui/config/ConfigButtons.qml:304
msgid "Absolute path to aurorae button theme folder"
msgstr "Абсолютен път до папката на тема за бутони aurorae"

#: package/contents/ui/config/ConfigMouseControl.qml:84
msgid "Mouse Buttons:"
msgstr "Бутони на мишката:"

#: package/contents/ui/config/ConfigMouseControl.qml:89
msgid "Doubleclick to toggle maximizing"
msgstr "Двойно кликване за превключване на максимизиране"

#: package/contents/ui/config/ConfigMouseControl.qml:101
msgid "Left click disabled"
msgstr "Кликване с ляв бутон е деактивирано"

#: package/contents/ui/config/ConfigMouseControl.qml:108
msgid "Left click to present windows (Current Desktop)"
msgstr ""
"Кликване с левия бутон на мишката за представяне на прозорци (Текущ работен "
"плот)"

#: package/contents/ui/config/ConfigMouseControl.qml:115
msgid "Left click to present windows (All Desktops)"
msgstr ""
"Кликване с левия бутон на мишката за представяне на прозорци (Всички работни "
"плотове)"

#: package/contents/ui/config/ConfigMouseControl.qml:122
msgid "Left click to present windows (Window Class)"
msgstr ""
"Кликване с левия бутон на мишката за представяне на прозорци (клас Windows)"

#: package/contents/ui/config/ConfigMouseControl.qml:140
msgid "Middle click disabled"
msgstr "Кликване със среден бутон е деактивирано"

#: package/contents/ui/config/ConfigMouseControl.qml:146
msgid "Middle click to close active window"
msgstr "Кликване със среден бутон за затваряне на активния прозорец"

#: package/contents/ui/config/ConfigMouseControl.qml:152
msgid "Middle click to toggle fullscreen"
msgstr "Кликване със среден бутон за превключване на цял екран"

#: package/contents/ui/config/ConfigMouseControl.qml:163
msgid "Mouse Wheel:"
msgstr "Колелце на мишката:"

#: package/contents/ui/config/ConfigMouseControl.qml:168
msgid "Mouse wheel up to maximize"
msgstr "Превъртане колелцето на мишката нагоре за максимизиране"

#: package/contents/ui/config/ConfigMouseControl.qml:178
msgid "Mouse wheel down disabled"
msgstr "Превъртане колелцето на мишката надолу е деактивирано"

#: package/contents/ui/config/ConfigMouseControl.qml:184
msgid "Mouse wheel down to minimize"
msgstr "Превъртане колелцето на мишката надолу за минимизиране"

#: package/contents/ui/config/ConfigMouseControl.qml:190
msgid "Mouse wheel down to unmaximize"
msgstr "Превъртане колелцето на мишката надолу за възстановяване"

#: package/contents/ui/config/IconPicker.qml:73
msgctxt "@item:inmenu Open icon chooser dialog"
msgid "Choose..."
msgstr "Избиране..."

#: package/contents/ui/config/IconPicker.qml:78
msgctxt "@item:inmenu Reset icon to default"
msgid "Clear Icon"
msgstr "Изчистване на икона"

#: package/contents/ui/main.qml:583
msgid "Switch to activity: %1"
msgstr "Превключване към дейност: %1"

#: package/contents/ui/main.qml:591
msgid "Close"
msgstr "Затваряне"

#: package/contents/ui/main.qml:592
msgid "Toggle Maximise"
msgstr "Превключване на максимизиране"

#: package/contents/ui/main.qml:593
msgid "Minimise"
msgstr "Минимизиране"

#: package/contents/ui/main.qml:594
msgid "Toggle Pin To All Desktops"
msgstr "Превключване закачане на всички работни плотове"

#: package/contents/ui/main.qml:596
msgid "Reload Theme"
msgstr "Презареждане на темата"
07070100000053000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000002F00000000plasma-active-window-control-116.7736a87/po/ca07070100000054000081A40000000000000000000000016626CF9D00002EB3000000000000000000000000000000000000005C00000000plasma-active-window-control-116.7736a87/po/ca/plasma_applet_org.kde.activeWindowControl.po# Translation of plasma_applet_org.kde.activeWindowControl.po to Catalan
# Copyright (C) 2017-2022 This_file_is_part_of_KDE
# This file is distributed under the license LGPL version 2.1 or
# version 3 or later versions approved by the membership of KDE e.V.
#
# Antoni Bella Pérez <antonibella5@yahoo.com>, 2017, 2020, 2022.
# Josep M. Ferrer <txemaq@gmail.com>, 2017, 2018, 2021.
msgid ""
msgstr ""
"Project-Id-Version: plasma-active-window-control\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2021-05-23 00:18+0000\n"
"PO-Revision-Date: 2022-08-28 13:26+0200\n"
"Last-Translator: Antoni Bella Pérez <antonibella5@yahoo.com>\n"
"Language-Team: Catalan <kde-i18n-ca@kde.org>\n"
"Language: ca\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 22.08.0\n"

#: package/contents/config/config.qml:6
msgid "Appearance"
msgstr "Aparença"

#: package/contents/config/config.qml:11
msgid "Behaviour"
msgstr "Comportament"

#: package/contents/config/config.qml:16
msgid "Buttons"
msgstr "Botons"

#: package/contents/config/config.qml:21
msgid "Mouse Control"
msgstr "Control amb el ratolí"

#: package/contents/config/config.qml:26
msgid "Application Menu"
msgstr "Menú d'aplicacions"

#: package/contents/ui/config/ConfigAppearance.qml:73
msgctxt "Use default font"
msgid "Default"
msgstr "Omissió"

#: package/contents/ui/config/ConfigAppearance.qml:90
msgid "Plasmoid version: "
msgstr "Versió del plasmoide: "

#: package/contents/ui/config/ConfigAppearance.qml:96
msgid "Width in horizontal panel:"
msgstr "Amplada al plafó horitzontal:"

#: package/contents/ui/config/ConfigAppearance.qml:103
msgid "Fill width"
msgstr "Omple l'amplada"

#: package/contents/ui/config/ConfigAppearance.qml:122
msgid "Fine tuning:"
msgstr "Ajusta amb més detall:"

#: package/contents/ui/config/ConfigAppearance.qml:142
msgid "Hide titlebar for maximized windows (takes effect immediately)"
msgstr ""
"Oculta la barra de títol per a les finestres maximitzades (té efecte "
"immediat)"

#: package/contents/ui/config/ConfigAppearance.qml:158
msgid "Show window title"
msgstr "Mostra el títol de la finestra"

#: package/contents/ui/config/ConfigAppearance.qml:173
msgid "Text type:"
msgstr "Tipus de text:"

#: package/contents/ui/config/ConfigAppearance.qml:178
#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "Application name"
msgstr "Nom de l'aplicació"

#: package/contents/ui/config/ConfigAppearance.qml:182
msgid "Fit text:"
msgstr "Ajusta el text:"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Just elide"
msgstr "Només elidit"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Fit on hover"
msgstr "Ajusta en passar-hi per sobre"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Always fit"
msgstr "Ajusta sempre"

#: package/contents/ui/config/ConfigAppearance.qml:191
msgid "Tooltip text:"
msgstr "Text del consell:"

#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "No tooltip"
msgstr "Sense consell"

#: package/contents/ui/config/ConfigAppearance.qml:233
msgid "No window text:"
msgstr "Sense text de la finestra:"

#: package/contents/ui/config/ConfigAppearance.qml:247
msgid "Use %activity% placeholder to show current activity name."
msgstr ""
"Usa el marcador de posició %activity% per a mostrar el nom de l'activitat "
"actual."

#: package/contents/ui/config/ConfigAppearance.qml:254
msgid "No window icon:"
msgstr "Sense icona de la finestra:"

#: package/contents/ui/config/ConfigAppearance.qml:265
msgid "Limit text width"
msgstr "Limita l'amplada del text"

#: package/contents/ui/config/ConfigAppearance.qml:275
#: package/contents/ui/config/ConfigAppMenu.qml:95
msgctxt "Abbreviation for pixels"
msgid "px"
msgstr "px"

#: package/contents/ui/config/ConfigAppearance.qml:288
msgid "Show window icon"
msgstr "Mostra la icona de la finestra"

#: package/contents/ui/config/ConfigAppearance.qml:294
msgid "Window icon on the right"
msgstr "Mostra la icona a la dreta"

#: package/contents/ui/config/ConfigAppearance.qml:315
msgid "Bold text"
msgstr "Text en negreta"

#: package/contents/ui/config/ConfigAppearance.qml:319
msgid "Text font:"
msgstr "Tipus de lletra del text:"

#: package/contents/ui/config/ConfigAppearance.qml:340
msgid "Icon and text spacing:"
msgstr "Espaiat de la icona i el text:"

#: package/contents/ui/config/ConfigAppearance.qml:352
msgid "Font size scale:"
msgstr "Escala la mida del tipus de lletra:"

#: package/contents/ui/config/ConfigAppMenu.qml:23
msgid "Enable application menu"
msgstr "Activa el menú de l'aplicació"

#: package/contents/ui/config/ConfigAppMenu.qml:38
msgid "Fill height"
msgstr "Omple l'alçada"

#: package/contents/ui/config/ConfigAppMenu.qml:44
msgid "Bold font"
msgstr "Tipus de lletra en negreta"

#: package/contents/ui/config/ConfigAppMenu.qml:50
#: package/contents/ui/config/ConfigButtons.qml:173
msgid "Do not hide on mouse out"
msgstr "No ocultis la sortida del ratolí"

#: package/contents/ui/config/ConfigAppMenu.qml:55
msgid "Show next to buttons"
msgstr "Mostra al costat dels botons"

#: package/contents/ui/config/ConfigAppMenu.qml:61
msgid "Show next to icon and text"
msgstr "Mostra al costat de la icona i el text"

#: package/contents/ui/config/ConfigAppMenu.qml:67
msgid "Switch sides with icon and text"
msgstr "Canvia els costats amb la icona i el text"

#: package/contents/ui/config/ConfigAppMenu.qml:74
msgid "Show separator"
msgstr "Mostra el separador"

#: package/contents/ui/config/ConfigAppMenu.qml:81
msgid "Make window title bold when menu is displayed"
msgstr ""
"Fes que el títol de la finestra sigui en negreta quan es mostri el menú"

#: package/contents/ui/config/ConfigAppMenu.qml:86
msgid "Side margin:"
msgstr "Marge lateral:"

#: package/contents/ui/config/ConfigAppMenu.qml:99
msgid "Icon and text opacity:"
msgstr "Opacitat de la icona i el text:"

#: package/contents/ui/config/ConfigAppMenu.qml:111
msgid "Menu button text size scale:"
msgstr "Escala de mida el text en el botó del menú:"

#: package/contents/ui/config/ConfigBehaviour.qml:14
msgid "Show active window only for plasmoid's screen"
msgstr "Mostra la finestra activa només per a la pantalla del plasmoide"

#: package/contents/ui/config/ConfigButtons.qml:90
msgid "Enable Control Buttons"
msgstr "Activa els botons de control"

#: package/contents/ui/config/ConfigButtons.qml:111
msgid "Show minimize button"
msgstr "Mostra el botó minimitza"

#: package/contents/ui/config/ConfigButtons.qml:116
msgid "Show maximize button"
msgstr "Mostra el botó maximitza"

#: package/contents/ui/config/ConfigButtons.qml:121
msgid "Show pin to all desktops"
msgstr "Mostra el pin a tots els escriptoris"

#: package/contents/ui/config/ConfigButtons.qml:131
msgid "Button order:"
msgstr "Ordre del botó:"

#: package/contents/ui/config/ConfigButtons.qml:167
msgid "Behaviour:"
msgstr "Comportament:"

#: package/contents/ui/config/ConfigButtons.qml:184
msgid "Show only when maximized"
msgstr "Mostra'l només quan estigui maximitzat"

#: package/contents/ui/config/ConfigButtons.qml:189
msgid "Buttons next to icon and text"
msgstr "Botons al costat de la icona i el text"

#: package/contents/ui/config/ConfigButtons.qml:194
msgid "Buttons between icon and text"
msgstr "Botons entre la icona i el text"

#: package/contents/ui/config/ConfigButtons.qml:200
msgid "Dynamic width"
msgstr "Amplada dinàmica"

#: package/contents/ui/config/ConfigButtons.qml:206
msgid "Sliding icon and text"
msgstr "Icona i text lliscant"

#: package/contents/ui/config/ConfigButtons.qml:218
msgid "Position:"
msgstr "Posició:"

#: package/contents/ui/config/ConfigButtons.qml:224
msgid "Upper left"
msgstr "Superior esquerra"

#: package/contents/ui/config/ConfigButtons.qml:235
msgid "Upper right"
msgstr "Superior dreta"

#: package/contents/ui/config/ConfigButtons.qml:241
msgid "Bottom left"
msgstr "Inferior esquerra"

#: package/contents/ui/config/ConfigButtons.qml:247
msgid "Bottom right"
msgstr "Inferior dreta"

#: package/contents/ui/config/ConfigButtons.qml:253
msgid "Vertical center"
msgstr "Centre vertical"

#: package/contents/ui/config/ConfigButtons.qml:263
msgid "Button size:"
msgstr "Mida dels botons:"

#: package/contents/ui/config/ConfigButtons.qml:275
msgid "Buttons spacing:"
msgstr "Espaiat entre els botons:"

#: package/contents/ui/config/ConfigButtons.qml:294
msgid "Theme"
msgstr "Tema"

#: package/contents/ui/config/ConfigButtons.qml:300
msgid "Automatic"
msgstr "Automàtic"

#: package/contents/ui/config/ConfigButtons.qml:304
msgid "Absolute path to aurorae button theme folder"
msgstr "Camí absolut a la carpeta de tema de botons «aurorae»"

#: package/contents/ui/config/ConfigMouseControl.qml:84
msgid "Mouse Buttons:"
msgstr "Botons del ratolí:"

#: package/contents/ui/config/ConfigMouseControl.qml:89
msgid "Doubleclick to toggle maximizing"
msgstr "Cal fer doble clic per a alternar la maximització"

#: package/contents/ui/config/ConfigMouseControl.qml:101
msgid "Left click disabled"
msgstr "S'ha desactivat el clic esquerre"

#: package/contents/ui/config/ConfigMouseControl.qml:108
msgid "Left click to present windows (Current Desktop)"
msgstr ""
"Cal fer clic esquerre per a presentar les finestres (escriptori actual)"

#: package/contents/ui/config/ConfigMouseControl.qml:115
msgid "Left click to present windows (All Desktops)"
msgstr ""
"Cal fer clic esquerre per a presentar les finestres (tots els escriptoris)"

#: package/contents/ui/config/ConfigMouseControl.qml:122
msgid "Left click to present windows (Window Class)"
msgstr ""
"Cal fer clic esquerre per a presentar les finestres (classe de finestra)"

#: package/contents/ui/config/ConfigMouseControl.qml:140
msgid "Middle click disabled"
msgstr "Desactiva el clic del mig"

#: package/contents/ui/config/ConfigMouseControl.qml:146
msgid "Middle click to close active window"
msgstr "Cal fer clic del mig per a tancar la finestra activa"

#: package/contents/ui/config/ConfigMouseControl.qml:152
msgid "Middle click to toggle fullscreen"
msgstr "Cal fer clic del mig per a alternar a pantalla completa"

#: package/contents/ui/config/ConfigMouseControl.qml:163
msgid "Mouse Wheel:"
msgstr "Roda del ratolí:"

#: package/contents/ui/config/ConfigMouseControl.qml:168
msgid "Mouse wheel up to maximize"
msgstr "Moure amunt la roda del ratolí per a maximitzar"

#: package/contents/ui/config/ConfigMouseControl.qml:178
msgid "Mouse wheel down disabled"
msgstr "Desactiva moure avall la roda del ratolí"

#: package/contents/ui/config/ConfigMouseControl.qml:184
msgid "Mouse wheel down to minimize"
msgstr "Moure avall la roda del ratolí per a minimitzar"

#: package/contents/ui/config/ConfigMouseControl.qml:190
msgid "Mouse wheel down to unmaximize"
msgstr "Moure avall la roda del ratolí per a sortir de la maximització"

#: package/contents/ui/config/IconPicker.qml:73
msgctxt "@item:inmenu Open icon chooser dialog"
msgid "Choose..."
msgstr "Tria..."

#: package/contents/ui/config/IconPicker.qml:78
msgctxt "@item:inmenu Reset icon to default"
msgid "Clear Icon"
msgstr "Neteja la icona"

#: package/contents/ui/main.qml:583
msgid "Switch to activity: %1"
msgstr "Canvia a l'activitat: %1"

#: package/contents/ui/main.qml:591
msgid "Close"
msgstr "Tanca"

#: package/contents/ui/main.qml:592
msgid "Toggle Maximise"
msgstr "Alterna la maximització"

#: package/contents/ui/main.qml:593
msgid "Minimise"
msgstr "Minimitza"

#: package/contents/ui/main.qml:594
msgid "Toggle Pin To All Desktops"
msgstr "Commuta el pin a tots els escriptoris"

#: package/contents/ui/main.qml:596
msgid "Reload Theme"
msgstr "Recarrega el tema"
07070100000055000041ED0000000000000000000000026626CF9D00000000000000000000000000000000000000000000003800000000plasma-active-window-control-116.7736a87/po/ca@valencia07070100000056000081A40000000000000000000000016626CF9D00002EE8000000000000000000000000000000000000006500000000plasma-active-window-control-116.7736a87/po/ca@valencia/plasma_applet_org.kde.activeWindowControl.po# Translation of plasma_applet_org.kde.activeWindowControl.po to Catalan (Valencian)
# Copyright (C) 2017-2022 This_file_is_part_of_KDE
# This file is distributed under the license LGPL version 2.1 or
# version 3 or later versions approved by the membership of KDE e.V.
#
# Antoni Bella Pérez <antonibella5@yahoo.com>, 2017, 2020, 2022.
# Josep M. Ferrer <txemaq@gmail.com>, 2017, 2018, 2021.
msgid ""
msgstr ""
"Project-Id-Version: plasma-active-window-control\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2021-05-23 00:18+0000\n"
"PO-Revision-Date: 2022-08-28 13:26+0200\n"
"Last-Translator: Antoni Bella Pérez <antonibella5@yahoo.com>\n"
"Language-Team: Catalan <kde-i18n-ca@kde.org>\n"
"Language: ca@valencia\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 22.08.0\n"

#: package/contents/config/config.qml:6
msgid "Appearance"
msgstr "Aparença"

#: package/contents/config/config.qml:11
msgid "Behaviour"
msgstr "Comportament"

#: package/contents/config/config.qml:16
msgid "Buttons"
msgstr "Botons"

#: package/contents/config/config.qml:21
msgid "Mouse Control"
msgstr "Control amb el ratolí"

#: package/contents/config/config.qml:26
msgid "Application Menu"
msgstr "Menú d'aplicacions"

#: package/contents/ui/config/ConfigAppearance.qml:73
msgctxt "Use default font"
msgid "Default"
msgstr "Predeterminat"

#: package/contents/ui/config/ConfigAppearance.qml:90
msgid "Plasmoid version: "
msgstr "Versió del plasmoide: "

#: package/contents/ui/config/ConfigAppearance.qml:96
msgid "Width in horizontal panel:"
msgstr "Amplària en el quadro horitzontal:"

#: package/contents/ui/config/ConfigAppearance.qml:103
msgid "Fill width"
msgstr "Òmpliga l'amplària"

#: package/contents/ui/config/ConfigAppearance.qml:122
msgid "Fine tuning:"
msgstr "Ajusta amb més detall:"

#: package/contents/ui/config/ConfigAppearance.qml:158
msgid "Show window title"
msgstr "Mostra el títol de la finestra"

#: package/contents/ui/config/ConfigAppearance.qml:173
msgid "Text type:"
msgstr "Tipus de text:"

#: package/contents/ui/config/ConfigAppearance.qml:178
#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "Application name"
msgstr "Nom de l'aplicació"

#: package/contents/ui/config/ConfigAppearance.qml:182
msgid "Fit text:"
msgstr "Ajusta el text:"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Just elide"
msgstr "Només elidit"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Fit on hover"
msgstr "Ajusta en passar-hi per damunt"

#: package/contents/ui/config/ConfigAppearance.qml:187
msgid "Always fit"
msgstr "Ajusta sempre"

#: package/contents/ui/config/ConfigAppearance.qml:191
msgid "Tooltip text:"
msgstr "Text del consell:"

#: package/contents/ui/config/ConfigAppearance.qml:196
msgid "No tooltip"
msgstr "Sense consell"

#: package/contents/ui/config/ConfigAppearance.qml:233
msgid "No window text:"
msgstr "Sense text de la finestra:"

#: package/contents/ui/config/ConfigAppearance.qml:247
msgid "Use %activity% placeholder to show current activity name."
msgstr ""
"Utilitza el marcador de posició %activity% per a mostrar el nom de "
"l'activitat actual."

#: package/contents/ui/config/ConfigAppearance.qml:254
msgid "No window icon:"
msgstr "Sense icona de la finestra:"

#: package/contents/ui/config/ConfigAppearance.qml:265
msgid "Limit text width"
msgstr "Limita l'amplària del text"