ukui-panel/ 0000775 0001750 0001750 00000000000 15167645111 011561 5 ustar feng feng ukui-panel/LICENSE 0000664 0001750 0001750 00000104515 15167645100 012572 0 ustar feng feng GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
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
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
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.
Copyright (C)
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.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
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:
Copyright (C)
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
.
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
.
ukui-panel/README.md 0000664 0001750 0001750 00000002373 15167645100 013043 0 ustar feng feng # ukui-panel
## 简介
ukui-panel是ukui桌面环境中的"任务栏"组件，它是一个在屏幕边缘的dock窗口，
提供了的功能包括应用程序启动器，系统托盘，任务管理，系统时间等。
ukui-panel基于ukui-quick-framework提供的插件机制开发。
## 项目结构
### **panel**
#### 任务栏（经典模式）
* org.ukui.panel
* 屏幕边缘的dock窗口
* 可置于屏幕4个边缘
* 可拖动改变位置
#### 任务栏（三岛模式）
* org.ukui.panelNext
* 屏幕下边缘的dock窗口
* 不可改变位置
* 分为数据岛，应用岛，配置岛三部分
* 不会占用屏幕可用区域
* 智能隐藏
#### 顶栏
* org.ukui.panelTopBar
* 屏幕上边缘的dock窗口
* 不可改变位置
* 可以将三岛任务栏上的数据岛或配置岛放到顶栏，当没有放置任何岛时，顶栏隐藏
* 会占用屏幕可用区域
### **widgets**
* org.ukui.panel.starter(开始菜单按钮插件)
* org.ukui.panel.calendar(日历插件)
* org.ukui.panel.search(搜索按钮插件)
* org.ukui.panel.separator(分割线插件)
* org.ukui.panel.showDesktop(显示桌面按钮插件)
* org.ukui.panel.taskView(多任务视图插件)
* org.ukui.taskManager(任务管理器插件)
ukui-panel/man/ 0000775 0001750 0001750 00000000000 15167645100 012332 5 ustar feng feng ukui-panel/man/ukui-panel.1 0000664 0001750 0001750 00000002747 15167645100 014500 0 ustar feng feng .TH ukui-panel 1 "15 October 2025" "UKUI Desktop Environment Panel Module"
.SH "NAME"
ukui-panel - panel application for UKUI desktop environment
.SH "SYNOPSIS"
.B ukui-panel
.SH "DESCRIPTION"
ukui-panel is the main panel application for the UKUI desktop environment, providing quick access to applications, system status indicators, and other essential desktop features.
.SH "OPTIONS"
.TP
\fB -h, --help\fR
Displays help on commandline options.
.TP
\fB --help-all\fR
Displays help including Qt specific options.
.TP
\fB -v, --version\fR
Displays version information.
.TP
\fB --panelLocation\fR
Show current panel location.
.TP
\fB --panelSizePolicy\fR
Show current panel size policy.
.TP
\fB --panelAutoHide\fR
Show current panel auto hide status.
.TP
\fB --panelLock\fR
Show current panel lock status.
.TP
\fB --disabledWidgets\fR
Show current panel disabled widgets.
.TP
\fB --trayIconsInhibited\fR
Show current inhibited tray icons.
.TP
\fB --taskBarIconsShowedOn\fR
Show where taskbar icons are displayed.
.TP
\fB --showPanelOnAllScreens\fR
Whether the panel is shown on all screens.
.TP
\fB --showSystemTrayOnAllPanels\fR
Whether the system tray is shown on all panels.
.TP
\fB --panelType\fR
Show current panel type.
.SH "LOG FILE"
Current log file path: "~/.log/ukui-panel/"
.SH "BUGS"
.SS Should you encounter any bugs, they may be reported at:
https://gitee.com/openkylin/ukui-panel/issues
.SH "AUTHORS"
.SS This Manual Page has been written for the UKUI Desktop Environment by:
UKUI Development Team
ukui-panel/CMakeLists.txt 0000664 0001750 0001750 00000000447 15167645100 014324 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
project(ukui-panel VERSION 4.1)
if (BUILD_TEST)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
endif ()
add_subdirectory(panel)
add_subdirectory(widgets)
ukui-panel/widgets/ 0000775 0001750 0001750 00000000000 15167645100 013225 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/ 0000775 0001750 0001750 00000000000 15167645111 016554 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/dbus/ 0000775 0001750 0001750 00000000000 15167645100 017507 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/dbus/org.ukui.TaskManager.xml 0000664 0001750 0001750 00000001615 15167645100 024173 0 ustar feng feng
ukui-panel/widgets/ukui-task-manager/qmldir 0000664 0001750 0001750 00000000533 15167645100 017766 0 ustar feng feng module org.ukui.panel.taskManager
plugin ukui-task-manager
AppIcon 1.0 AppIcon.qml
AppList 1.0 AppList.qml
TaskManagerBase 1.0 TaskManagerBase.qml
TaskItemData 1.0 TaskItemData.qml
ThumbnailWindow 1.0 ThumbnailWindow.qml
TaskManagerView 1.0 TaskManagerView.qml
ThumbnailContainer 1.0 ThumbnailContainer.qml
WidgetContainer 1.0 WidgetContainer.qml
ukui-panel/widgets/ukui-task-manager/translations/ 0000775 0001750 0001750 00000000000 15167645100 021273 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_vi.ts 0000664 0001750 0001750 00000003206 15167645100 026356 0 ustar feng feng
TaskManager::TaskManagerItemAdd launcher to panelThêm trình khởi chạy vào bảng điều khiểnRemove launcher from panelXóa trình khởi chạy khỏi bảng điều khiểnCloseThoátTaskManager::UkuiTaskManagerCloseThoátRestoreMởMaximizePhóng lớnMinimizeTối thiểu hóaKeep aboveGhimUnset keep aboveBỏ ghimThumbnailContainerCloseThoátThumbnailWindowCloseThoát
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_fr.ts 0000664 0001750 0001750 00000003164 15167645100 026352 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelAdd launcher to panelCloseTaskManager::UkuiTaskManagerCloseRestoreMaximizeMinimizeKeep aboveUnset keep aboveThumbnailContainerCloseThumbnailWindowClose
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_mn.ts 0000664 0001750 0001750 00000004036 15167645100 026354 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelᠡᠬᠦᠷᠭᠡ ᠵᠢᠨ ᠪᠠᠭᠠᠷ ᠡᠴᠡ ᠳᠤᠭᠳᠠᠪᠤᠷᠢᠵᠢᠭᠤᠯᠤᠭᠰᠠᠨ ᠢ᠋ ᠦᠬᠡᠢᠰᠬᠡᠬᠦAdd launcher to panelᠡᠬᠦᠷᠬᠡ ᠵᠢᠨ ᠪ ᠪᠠᠭᠠᠷ ᠲᠤ᠌ ᠳᠤᠭᠳᠠᠪᠤᠷᠢᠵᠢᠭᠤᠯᠬᠤCloseᠬᠠᠭᠠᠬᠤTaskManager::UkuiTaskManagerCloseᠬᠠᠭᠠᠬᠤRestoreᠰᠡᠷᠭᠦᠭᠡᠬᠦMaximizeᠬᠠᠮᠤᠭ ᠤ᠋ᠨ ᠶᠡᠬᠡᠴᠢᠯᠡᠯMinimizeᠬᠠᠮᠤᠭ ᠤ᠋ᠨ ᠪᠠᠭᠠᠴᠢᠯᠠᠯKeep aboveᠤᠷᠤᠢ ᠳ᠋ᠤ᠌ ᠳᠠᠯᠪᠢᠬᠤUnset keep aboveᠤᠷᠤᠢ ᠳ᠋ᠤ᠌ ᠳᠠᠯᠪᠢᠬᠤ ᠵᠢ ᠦᠬᠡᠢᠰᠬᠡᠬᠦThumbnailContainerCloseᠬᠠᠭᠠᠬᠤThumbnailWindowCloseᠬᠠᠭᠠᠬᠤ
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_es.ts 0000664 0001750 0001750 00000003164 15167645100 026352 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelAdd launcher to panelCloseTaskManager::UkuiTaskManagerCloseRestoreMaximizeMinimizeKeep aboveUnset keep aboveThumbnailContainerCloseThumbnailWindowClose
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_ky.ts 0000664 0001750 0001750 00000003366 15167645100 026372 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelقوزعوتقۇچتۇ باشقارمادان. چىعارۇۇAdd launcher to panelتاقتادا قوزعوتقۇچ قوشۇۇCloseجابۇۇTaskManager::UkuiTaskManagerCloseجابۇۇRestoreالعاچىنا كەتىرىشMaximizeچوڭدۇعۇMinimizeتۅمۅنگۅ جۉكتۅۅKeep aboveجوعورۇدا. ساقتووUnset keep aboveUnset نى جوعۇرۇدا ساقتووThumbnailContainerCloseجابۇۇThumbnailWindowCloseجابۇۇ
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_de.ts 0000664 0001750 0001750 00000003164 15167645100 026333 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelAdd launcher to panelCloseTaskManager::UkuiTaskManagerCloseRestoreMaximizeMinimizeKeep aboveUnset keep aboveThumbnailContainerCloseThumbnailWindowClose
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_zh_HK.ts 0000664 0001750 0001750 00000003125 15167645100 026743 0 ustar feng feng
TaskManager::TaskManagerItemAdd launcher to panel將啟動器添加到面板Remove launcher from panel從面板中刪除啟動器Close關閉TaskManager::UkuiTaskManagerClose關閉Restore恢復Maximize最大化Minimize最小化Keep above保持高於Unset keep above取消設置ThumbnailContainerClose關閉ThumbnailWindowClose關閉
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_bo_CN.ts 0000664 0001750 0001750 00000003665 15167645100 026731 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelལས་ཀའི་སྡེ་ནས་གཏན་འཇོག་འདོར་བ།Add launcher to panelལས་ཀའི་སྡེ་རུ་གཏན་བཞག་བྱེད་པ།Closeཁ་རྒྱགTaskManager::UkuiTaskManagerCloseཁ་རྒྱགRestoreསླར་གསོ་བྱེད་པ།Maximizeཆེ་ཤོས་སུ་སྒྱུར་བ།Minimizeཉུང་དུ་གཏོང་གང་ཐུབ་བྱ་དགོས།Keep aboveརྩེར་འཇོགUnset keep aboveགཙང་སེལ།ThumbnailContainerCloseཁ་རྒྱགThumbnailWindowCloseཁ་རྒྱག
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_kk.ts 0000664 0001750 0001750 00000003377 15167645100 026356 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelقوزعالتۋ اسبابىن تاقتايدا شىعارىپ وتۋAdd launcher to panelتاقتاعا قوزعالتۋ اسبابى قوسۋCloseتاقاۋTaskManager::UkuiTaskManagerCloseتاقاۋRestoreقالپىنا كەلتىرىلگەنMaximizeۇلكەيتۋMinimizeكىشرەيتۋKeep aboveيۇقارقىنى ساقتاۋUnset keep aboveUnset نى جوعارىدا ساقتاۋThumbnailContainerCloseتاقاۋThumbnailWindowCloseتاقاۋ
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_ug.ts 0000664 0001750 0001750 00000003336 15167645100 026357 0 ustar feng feng
TaskManager::TaskManagerItemRemove launcher from panelقوزغاتقۇچنى تاختىدىن چىقىرىۋېتىشAdd launcher to panelتاختىغا قوزغاتقۇچ قوشۇشCloseياپTaskManager::UkuiTaskManagerCloseياپRestoreئەسلىگە كەلتۈرۈشMaximizeچوڭايتىشMinimizeكىچىكلىتىشKeep aboveيۇقارقىنى ساقلاشUnset keep aboveUnset نى يۇقىرىدا ساقلاشThumbnailContainerCloseياپThumbnailWindowCloseياپ
ukui-panel/widgets/ukui-task-manager/translations/libukui-task-manager_zh_CN.ts 0000664 0001750 0001750 00000003101 15167645100 026733 0 ustar feng feng
TaskManager::TaskManagerItemAdd launcher to panel固定到任务栏Remove launcher from panel从任务栏取消固定Close关闭TaskManager::UkuiTaskManagerClose关闭Restore还原Maximize最大化Minimize最小化Keep above置顶Unset keep above取消置顶ThumbnailContainerClose关闭ThumbnailWindowClose关闭
ukui-panel/widgets/ukui-task-manager/widget-delegate.cpp 0000664 0001750 0001750 00000011234 15167645100 022312 0 ustar feng feng /*
*
* * Copyright (C) 2024, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#include "widget-delegate.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace TaskManager;
static std::once_flag flag;
static WidgetInfo *widgetInfo = nullptr;
int WidgetUpdateEvent::m_eventType = QEvent::registerEventType();
int WidgetUpdateEvent::eventType()
{
return m_eventType;
}
WidgetInfo::WidgetInfo(QObject* parent)
{
m_widgetLoader = new UkuiQuick::WidgetLoader(this);
m_widgetLoader->addWidgetSearchPath(QStringLiteral(":/task-manager"));
m_widgetLoader->setShowInFilter( UkuiQuick::WidgetMetadata::Host::TaskManager);
}
WidgetInfo* WidgetInfo::self()
{
std::call_once(flag, [ & ] {
widgetInfo = new WidgetInfo();
});
return widgetInfo;
}
bool WidgetInfo::hasWidgetFor(const QString& appId)
{
QMutexLocker locker(&m_mutex);
return !m_widgetLoader->widgets(appId).isEmpty();
}
QString WidgetInfo::widgetFor(const QString& appId)
{
if (appId.isEmpty()) {
return {};
}
if(m_quickWidgets.contains(appId)) {
return m_quickWidgets.value(appId);
}
QtConcurrent::run([this, appId]() {
QMutexLocker locker(&m_mutex);
QStringList widgets = m_widgetLoader->widgets(appId);
if(!widgets.isEmpty()) {
QGuiApplication::postEvent(this, new WidgetUpdateEvent(appId, widgets.first()));
}
});
return {};
}
UkuiQuick::Widget* WidgetInfo::loadWidget(const QString& id)
{
QMutexLocker locker(&m_mutex);
return m_widgetLoader->loadWidget(id);
}
void WidgetInfo::customEvent(QEvent* event)
{
if(event->type() == WidgetUpdateEvent::eventType()) {
auto e = dynamic_cast(event);
m_quickWidgets.insert(e->appId(), e->widgetId());
Q_EMIT widgetInfoUpdate(e->appId(), e->widgetId());
}
QObject::customEvent(event);
}
WidgetDelegate::WidgetDelegate(QQuickItem* parent) : QQuickItem(parent)
{
loadContainer();
connect(this, &QQuickItem::childrenRectChanged, this, [this]() {
Q_EMIT preferredWidthChanged();
});
}
WidgetDelegate::~WidgetDelegate()
{
if(m_container) {
Q_EMIT m_container->aboutToDeleted();
m_container->deleteLater();
m_container = nullptr;
}
}
QString WidgetDelegate::quickWidgetId() const
{
return m_quickWidgetId;
}
void WidgetDelegate::setQuickWidgetId(const QString& id)
{
if(m_quickWidgetId != id) {
m_quickWidgetId = id;
Q_EMIT quickWidgetIdChanged();
}
loadWidget();
}
int WidgetDelegate::preferredWidth()
{
return m_preferredWidth;
}
void WidgetDelegate::loadContainer()
{
auto widget = WidgetInfo::self()->loadWidget(QStringLiteral("org.ukui.taskManagerContainer"));
auto container = qobject_cast(widget);
if (!container) {
qWarning() << "Load taskManagerContainer failed!";
delete widget;
return;
}
m_container = container;
auto contItem = qobject_cast(UkuiQuick::WidgetQuickItem::loadWidgetItem(m_container, new QQmlContext(UkuiQuick::SharedEngineComponent::sharedEngine(), this)));
if (!contItem) {
qWarning() << "Load taskManagerContainerItem failed!";
return;
}
contItem->setParentItem(this);
m_preferredWidth = contItem->childrenRect().width();
connect(contItem, &QQuickItem::childrenRectChanged, this, [&, contItem]() {
m_preferredWidth = contItem->childrenRect().width();
Q_EMIT preferredWidthChanged();
});
}
void WidgetDelegate::loadWidget()
{
if(m_widget) {
m_container->removeWidget(m_widget);
}
m_widget = WidgetInfo::self()->loadWidget(m_quickWidgetId);
m_container->addWidget(m_widget);
}
ukui-panel/widgets/ukui-task-manager/org.ukui.taskManagerContainer/ 0000775 0001750 0001750 00000000000 15167645100 024414 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/org.ukui.taskManagerContainer/WidgetContainer.qml 0000664 0001750 0001750 00000004301 15167645100 030213 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
import QtQuick 2.15
import QtQuick.Layouts 1.15
import QtQml 2.15
import org.ukui.quick.widgets 1.0
import org.ukui.quick.container 1.0
import org.ukui.quick.items 1.0
WidgetContainerItem {
id: containerItem
anchors.fill: parent
GridLayout {
id: mainLayout
z: 10
height: parent.height
width: childrenRect.width
rows: 1
columns: repeater.count
Repeater {
id: repeater
model: containerItem.widgetItemModel
delegate: widgetLoaderComponent
}
}
Component {
id: widgetLoaderComponent
Item {
id: widgetParent
clip: true
property Item widgetItem: model.widgetItem
Layout.fillWidth: widgetItem.Layout.fillWidth
Layout.fillHeight: widgetItem.Layout.fillHeight
Layout.minimumHeight: widgetItem.Layout.minimumHeight;
Layout.maximumHeight: mainLayout.height;
Layout.minimumWidth : widgetItem.Layout.minimumWidth
Layout.maximumWidth : widgetItem.Layout.maximumWidth
Layout.preferredHeight: mainLayout.height
Layout.preferredWidth: widgetItem.Layout.preferredWidth
onWidgetItemChanged: {
if (widgetItem) {
widgetItem.parent = widgetParent
widgetItem.anchors.fill = Qt.binding(function () {return widgetParent})
}
}
}
}
}
ukui-panel/widgets/ukui-task-manager/org.ukui.taskManagerContainer/metadata.json 0000664 0001750 0001750 00000000557 15167645100 027076 0 ustar feng feng {
"Authors": [
{
"Name": "iaom",
"Email": "zhangpengfei@kylinos.cn"
}
],
"Id": "org.ukui.taskManagerContainer",
"Version": "1.0",
"Website": "https://ukui.org",
"BugReport": "https://gitee.com/openkylin/ukui-panel/issues",
"ShowIn": "TaskManager",
"WidgetType": "Container",
"Contents": {
"Main": "WidgetContainer.qml"
}
}
ukui-panel/widgets/ukui-task-manager/actions.h 0000664 0001750 0001750 00000005331 15167645100 020365 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#ifndef UKUI_TASK_MANAGER_ACTIONS_H
#define UKUI_TASK_MANAGER_ACTIONS_H
#include
#include
#include
#include
namespace TaskManager {
class ActionPrivate;
class ActionsPrivate;
class Action : public QObject
{
Q_OBJECT
public:
enum Type {
Invalid,
//任务栏图标action
NewInstance, //启动新实例
DesktopAction, //desktop文件中的action
RemoveQuickLauncher, //移除快速启动按钮
AddQuickLauncher, //增加快速启动按钮
Exit, //关闭所有窗口
//单窗口action
Close, //关闭窗口
Minimize, //最小化
Maximize, //最大化
Restore, //恢复
KeepAbove, //置顶
UnsetKeepAbove //取消置顶
};
Q_ENUM(Type)
explicit Action(QObject *parent = nullptr);
Action(const QString &name, const QString &displayName, const QIcon &icon, Type type, const QVariant ¶m = {}, QObject *parent = nullptr);
Action(const Action &other);
Action &operator=(const Action &other) = delete;
Action &operator=(Action &&other) = delete;
bool operator==(const Action &other) const;
~Action();
QString name() const;
void setName(const QString &name);
QString text() const;
void setText(const QString &name);
QIcon icon() const;
void setIcon(const QIcon &icon);
Type type() const;
void setType(const Type &type);
QVariant param();
void setParam(const QVariant ¶m);
bool enabled() const;
void setEnabled(bool enabled);
QAction* internalAction() const;
Q_SIGNALS:
void actionTriggered(const QVariant& param);
private:
void initConnection();
QSharedPointer d;
};
typedef QVector Actions;
}
Q_DECLARE_METATYPE(TaskManager::Actions);
#endif //UKUI_TASK_MANAGER_ACTIONS_H
ukui-panel/widgets/ukui-task-manager/task-manager-filter-model.cpp 0000664 0001750 0001750 00000026005 15167645111 024216 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#include "task-manager-filter-model.h"
#include
#include
#include "ukui-task-manager.h"
#include
#include
namespace TaskManager {
TaskManagerFilterModel::TaskManagerFilterModel(QObject *parent) : QSortFilterProxyModel(parent)
{
setFilterRole(UkuiTaskManager::CurrentWinIdList);
//读取taskmanager配置文件中的任务栏图标显示在哪个任务栏taskBarIconsShowedOn项并保存
if (!m_config) {
m_config = UkuiQuick::ConfigLoader::getConfig("org.ukui.panel.taskManager");
if(m_config->data().contains("taskBarIconsShowedOn")) {
m_iconsShowedonScreen = m_config->getValue("taskBarIconsShowedOn").value();
} else {
m_iconsShowedonScreen = TaskBarIconsShowedOn::AllPanels;
m_config->setValue(QStringLiteral("taskBarIconsShowedOn"), TaskBarIconsShowedOn::AllPanels);
}
//当taskBarIconsShowedOn变化时，更新筛选条件,并发送事件，更新数据
connect(m_config, &UkuiQuick::Config::configChanged, this, [&](QString key) {
if(key == "taskBarIconsShowedOn") {
m_iconsShowedonScreen = m_config->getValue(key).value();
invalidateFilter();
if (m_sourceModel) {
m_sourceModel->requestDataChange();
}
}
});
}
//主屏改变时，发送事件，更新数据
connect(qApp, &QGuiApplication::primaryScreenChanged, this, [&]() {
if (m_sourceModel) {
m_sourceModel->requestDataChange();
}
});
setSourceModel(&UkuiTaskManager::self());
}
void TaskManagerFilterModel::setSourceModel(QAbstractItemModel *sourceModel)
{
m_sourceModel = qobject_cast(sourceModel);
QSortFilterProxyModel::setSourceModel(sourceModel);
connect(sourceModel, &QAbstractItemModel::dataChanged, this, &TaskManagerFilterModel::onDataChanged);
connect(m_sourceModel, &UkuiTaskManager::appWhiteListChanged, this, &TaskManagerFilterModel::invalidateFilter);
connect(m_sourceModel, &UkuiTaskManager::appBlackListChanged, this, &TaskManagerFilterModel::invalidateFilter);
}
QVariant TaskManagerFilterModel::data(const QModelIndex &index, int role) const
{
if(role == UkuiTaskManager::CurrentWinIdList && m_screen) {
return currentWinIdList(index);
} else if(role == UkuiTaskManager::HasActiveWindow) {
if(m_screen && mapToSource(index).data(role).toBool()) {
return currentWinIdList(index).contains(UkuiQuick::WindowManager::currentActiveWindow());
}
return false;
} else if (role == UkuiTaskManager::Actions) {
Actions actions = mapToSource(index).data(role).value();
for(auto action : actions) {
if(action->type() == Action::Type::Exit) {
QStringList wids = currentWinIdList(index);
action->setEnabled(!wids.isEmpty());
action->setParam(wids);
break;
}
}
return QVariant::fromValue(actions);
} else if (role == UkuiTaskManager::CurrentScreenWinIdList) {
QStringList wins;
auto windowGeometries = mapToSource(index).data(UkuiTaskManager::WindowGeometries).value>();
for (const QString&wid: mapToSource(index).data(UkuiTaskManager::CurrentDesktopWinIdList).toStringList()) {
if (windowOnCurrentScreen(windowGeometries.value(wid))) {
wins.append(wid);
}
}
return wins;
}
return sourceModel()->data(mapToSource(index), role);
}
void TaskManagerFilterModel::setOrder(const QModelIndex &index, int order)
{
if(order >= rowCount()) {
order = rowCount() - 1;
}
if(order < 0) {
order = 0;
}
// 将setOrder操作放到下一次消息循环，避免wlcom上事件double free崩溃问题
QTimer::singleShot(0, this, [this, index, order] {
m_sourceModel->setOrder(mapToSource(index), mapToSource(this->index(order, 0)).row());
});
}
void TaskManagerFilterModel::addQuickLauncher(const QString &desktopFile, int order)
{
auto orderIndex = mapToSource(this->index(order, 0));
if (!orderIndex.isValid() && order > 0 && order <= m_sourceModel->rowCount(QModelIndex())) {
// 添加到最后一位
m_sourceModel->setQuickLauncher(desktopFile, m_sourceModel->rowCount(QModelIndex()));
} else {
m_sourceModel->setQuickLauncher(desktopFile, orderIndex.row());
}
}
QScreen *TaskManagerFilterModel::screen() const
{
return m_screen;
}
void TaskManagerFilterModel::setScreen(QScreen *screen)
{
m_screen = screen;
invalidateFilter();
m_sourceModel->requestDataChange();
}
bool TaskManagerFilterModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
QModelIndex sourceIndex = sourceModel()->index(source_row, 0, source_parent);
//黑白名单管控
if (!m_sourceModel->appWhiteList().isEmpty()) {
auto whiteList = m_sourceModel->appWhiteList();
if (!std::any_of(whiteList.constBegin(), whiteList.constEnd(), [&](const QString& app) {
return sourceIndex.data(UkuiTaskManager::Id).toString().endsWith(app);
})) {
return false;
}
}
if (!m_sourceModel->appBlackList().isEmpty()) {
auto blackList = m_sourceModel->appBlackList();
if (std::any_of(blackList.constBegin(), blackList.constEnd(), [&](const QString& app) {
return sourceIndex.data(UkuiTaskManager::Id).toString().endsWith(app);
})) {
return false;
}
}
if (!sourceIndex.data(UkuiTaskManager::HasLauncher).toBool()) {
if (sourceIndex.data(UkuiTaskManager::CurrentDesktopWinIdList).toStringList().isEmpty()) {
return false;
}
if (!sourceIndex.data(UkuiTaskManager::HasLauncher).toBool()) {
switch (m_iconsShowedonScreen) {
case AllPanels:
return true;
case PrimaryScreenPanelAndPanelWhereWindowIsOpen:
if (m_screen == qApp->primaryScreen() || onCurrentScreen(sourceIndex)) {
return true;
}
break;
case PanelWhereWindowIsOpen:
if (onCurrentScreen(sourceIndex)) {
return true;
}
break;
default:
return false;
}
return false;
}
}
return true;
}
bool TaskManagerFilterModel::openMenu(const bool &showDisabledActions, const TaskManager::Actions &actions, QQuickItem *item)
{
if (actions.isEmpty()) {
return false;
}
if (m_contextMenu) {
m_contextMenu->close();
}
auto *menu = new QMenu;
menu->setAttribute(Qt::WA_DeleteOnClose);
for(const TaskManager::Action* action : actions) {
if(action->enabled() || showDisabledActions) {
menu->addAction(action->internalAction());
}
if (action->type() == TaskManager::Action::NewInstance) {
menu->insertSeparator(action->internalAction());
}
}
connect(menu, &QMenu::aboutToHide, this, [this] {
Q_EMIT menuAboutToHide();
});
m_contextMenu = menu;
m_contextMenu->winId();
if(m_contextMenu->windowHandle()) {
m_contextMenu->windowHandle()->setTransientParent(item->window());
}
m_contextMenu->popup(QCursor::pos());
return true;
}
QStringList TaskManagerFilterModel::currentWinIdList(const QModelIndex &index) const
{
if (m_iconsShowedonScreen == AllPanels) {
return mapToSource(index).data(UkuiTaskManager::CurrentDesktopWinIdList).toStringList();
}
QStringList wins;
auto windowGeometries = mapToSource(index).data(UkuiTaskManager::WindowGeometries).value>();
for (const QString&wid: mapToSource(index).data(UkuiTaskManager::CurrentDesktopWinIdList).toStringList()) {
switch (m_iconsShowedonScreen) {
case PrimaryScreenPanelAndPanelWhereWindowIsOpen:
if (windowOnCurrentScreen(windowGeometries.value(wid)) || m_screen == qApp->primaryScreen()) {
wins.append(wid);
}
break;
case PanelWhereWindowIsOpen:
if (windowOnCurrentScreen(windowGeometries.value(wid))) {
wins.append(wid);
}
break;
default:;
}
}
return wins;
}
void TaskManagerFilterModel::onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight,
const QVector &roles)
{
Q_EMIT dataChanged(mapFromSource(topLeft), mapFromSource(bottomRight), roles);
if(roles.contains(UkuiTaskManager::CurrentDesktopWinIdList) || roles.contains(UkuiTaskManager::WindowGeometries)) {
Q_EMIT dataChanged(mapFromSource(topLeft), mapFromSource(bottomRight), QVector{UkuiTaskManager::HasActiveWindow, UkuiTaskManager::CurrentScreenWinIdList});
}
}
bool TaskManagerFilterModel::onCurrentScreen(const QModelIndex& index) const
{
//item在当前desktop上的窗口中是否包含一个在当前屏幕上的窗口
auto windowGeometries = index.data(UkuiTaskManager::WindowGeometries).value>();
for(const QString &wid : index.data(UkuiTaskManager::CurrentDesktopWinIdList).toStringList()) {
if(windowOnCurrentScreen(windowGeometries.value(wid))) {
return true;
}
}
return false;
}
bool TaskManagerFilterModel::windowOnCurrentScreen(const QRect &rect) const
{
if(!QGuiApplication::screens().contains(m_screen)) {
return false;
}
auto intersectedRect = m_screen->geometry().intersected(rect);
if(intersectedRect.isEmpty()) {
return false;
}
for(const auto &screen : qGuiApp->screens()) {
QRect r = screen->geometry().intersected(rect);
if(r.isEmpty()) {
continue;
}
if(r.width() * r.height() > intersectedRect.width() * intersectedRect.height() && screen != m_screen) {
return false;
}
}
return true;
}
void TaskManagerFilterModel::launch(const QModelIndex &index, QQuickItem *item)
{
m_sourceModel->launch(mapToSource(index), item);
}
}
ukui-panel/widgets/ukui-task-manager/widget-delegate.h 0000664 0001750 0001750 00000005333 15167645100 021762 0 ustar feng feng /*
*
* * Copyright (C) 2024, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#ifndef WIDGET_SHELL_H
#define WIDGET_SHELL_H
#include
#include
#include
namespace UkuiQuick {
class WidgetContainer;
class Widget;
class WidgetLoader;
}
namespace TaskManager {
class WidgetUpdateEvent : public QEvent
{
public:
WidgetUpdateEvent(const QString &appId, const QString &widgetId) : QEvent(static_cast(eventType())), m_appId(appId), m_widgetId(widgetId) {}
QString appId() const {return m_appId;};
QString widgetId() const {return m_widgetId;};
static int eventType();
private:
QString m_appId;
QString m_widgetId;
static int m_eventType;
};
class WidgetInfo : public QObject
{
Q_OBJECT
public:
static WidgetInfo *self();
bool hasWidgetFor(const QString &appId);
QString widgetFor(const QString &appId);
UkuiQuick::Widget *loadWidget(const QString &id);
Q_SIGNALS:
void widgetInfoUpdate(const QString &appid, const QString &widgetId);
protected:
void customEvent(QEvent* event) override;
private:
explicit WidgetInfo(QObject *parent = nullptr);
UkuiQuick::WidgetLoader *m_widgetLoader = nullptr;
QMap m_quickWidgets;
QMutex m_mutex;
};
class WidgetDelegate : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QString quickWidgetId READ quickWidgetId WRITE setQuickWidgetId NOTIFY quickWidgetIdChanged)
Q_PROPERTY(int preferredWidth READ preferredWidth NOTIFY preferredWidthChanged)
public:
explicit WidgetDelegate(QQuickItem *parent = nullptr);
~WidgetDelegate();
QString quickWidgetId() const;
void setQuickWidgetId(const QString &id);
int preferredWidth();
private:
void loadContainer();
void loadWidget();
Q_SIGNALS:
void quickWidgetIdChanged();
void preferredWidthChanged();
private:
QString m_quickWidgetId;
UkuiQuick::Widget *m_widget = nullptr;
UkuiQuick::WidgetContainer *m_container = nullptr;
int m_preferredWidth = 0;
};
}
#endif //WIDGET_SHELL_H
ukui-panel/widgets/ukui-task-manager/CMakeLists.txt 0000664 0001750 0001750 00000011314 15167645111 021314 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
#project(ukui-task-manager LANGUAGES CXX)
set(VERSION_MAJOR 1)
set(VERSION_MINOR 0)
set(VERSION_MICRO 0)
set(UKUI_TASK_MANAGER_VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_MICRO})
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
find_package(QT NAMES Qt6 Qt5 COMPONENTS Core LinguistTools DBus Widgets Quick Qml Concurrent REQUIRED)
find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core LinguistTools DBus Widgets Quick Qml Concurrent REQUIRED)
if (QT_VERSION_MAJOR EQUAL "5")
set(KF_VERSION_MAJOR "5")
find_package(Qt${QT_VERSION_MAJOR} COMPONENTS X11Extras REQUIRED)
find_package(KF5WindowSystem REQUIRED)
find_package(KF5Wayland)
find_package(Qt5Xdg REQUIRED)
elseif (QT_VERSION_MAJOR EQUAL "6")
set(KF_VERSION_MAJOR "6")
find_package(KF6WindowSystem REQUIRED)
find_package(KWayland)
find_package(Qt6Xdg REQUIRED)
endif()
find_package(ukui-quick COMPONENTS core framework platform)
find_package(PkgConfig REQUIRED)
set(UKUI_TASK_MANAGER_PC_PKGS kysdk-waylandhelper ukui-search)
foreach(external_lib IN ITEMS ${UKUI_TASK_MANAGER_PC_PKGS})
pkg_check_modules(${external_lib} REQUIRED IMPORTED_TARGET ${external_lib})
if(${${external_lib}_FOUND})
include_directories(${${external_lib}_INCLUDE_DIRS})
link_directories(${${external_lib}_LIBRARY_DIRS})
list(APPEND UKUI_TASK_MANAGER_EXTERNAL_LIBS PkgConfig::${external_lib})
endif()
endforeach()
file(GLOB TS_FILES translations/*.ts)
set(TRANSLATION_FILE_DIR "/usr/share/ukui-task-manager/translations")
add_compile_definitions(TRANSLATION_FILE_DIR="${TRANSLATION_FILE_DIR}"
UKUI_TASK_MANAGER_VERSION="${UKUI_TASK_MANAGER_VERSION}")
set(ukuiTaskManager_SRC
ukui-task-manager.cpp ukui-task-manager.h
task-manager-item.cpp task-manager-item.h
utils.cpp utils.h
actions.cpp actions.h
task-manager-plugin.cpp task-manager-plugin.h
task-manager-filter-model.cpp
task-manager-filter-model.h
widget-delegate.h widget-delegate.cpp
)
if(COMMAND qt_add_dbus_adaptor)
qt_add_dbus_adaptor(ukuiTaskManager_SRC dbus/org.ukui.TaskManager.xml ukui-task-manager.h TaskManager::UkuiTaskManager)
else()
qt5_add_dbus_adaptor(ukuiTaskManager_SRC dbus/org.ukui.TaskManager.xml ukui-task-manager.h TaskManager::UkuiTaskManager)
endif()
if(COMMAND qt_create_translation)
qt_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES} OPTIONS -no-obsolete -no-ui-lines)
else()
qt5_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES} OPTIONS -no-obsolete -no-ui-lines)
endif()
set(QRC_FILES container.qrc qml/qml.qrc)
add_library(ukui-task-manager SHARED
${ukuiTaskManager_SRC}
${QRC_FILES}
${QM_FILES}
)
target_include_directories(ukui-task-manager PUBLIC
$
)
target_link_libraries(ukui-task-manager PRIVATE
Qt${QT_VERSION_MAJOR}::Core
Qt${QT_VERSION_MAJOR}::DBus
Qt${QT_VERSION_MAJOR}::Widgets
Qt${QT_VERSION_MAJOR}::Quick
Qt${QT_VERSION_MAJOR}::Qml
Qt${QT_VERSION_MAJOR}::Concurrent
${UKUI_TASK_MANAGER_EXTERNAL_LIBS}
KF${QT_VERSION_MAJOR}::WindowSystem
ukui-quick::core
ukui-quick::framework
ukui-quick::platform
)
if (QT_VERSION_MAJOR EQUAL "5")
target_link_libraries(ukui-task-manager PRIVATE Qt::X11Extras Qt5Xdg KF5::WaylandClient)
else()
target_link_libraries(ukui-task-manager PRIVATE Qt6Xdg Plasma::KWaylandClient)
endif()
set_target_properties(ukui-task-manager PROPERTIES
VERSION ${UKUI_TASK_MANAGER_VERSION}
SOVERSION ${VERSION_MAJOR}
OUTPUT_NAME ukui-task-manager
)
install(FILES ${QM_FILES} DESTINATION "${TRANSLATION_FILE_DIR}")
set(PLUGIN_INSTALL_PATH "/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/qt${QT_VERSION_MAJOR}/qml/org/ukui/panel/taskManager")
install(DIRECTORY "plugin/" DESTINATION "/usr/share/ukui/widgets/org.ukui.panel.taskManager")
install(FILES "qmldir" DESTINATION ${PLUGIN_INSTALL_PATH})
install(FILES "qml/AppIcon.qml" DESTINATION ${PLUGIN_INSTALL_PATH})
install(FILES "qml/AppList.qml" DESTINATION ${PLUGIN_INSTALL_PATH})
install(FILES "qml/TaskManagerBase.qml" DESTINATION ${PLUGIN_INSTALL_PATH})
install(FILES "qml/TaskItemData.qml" DESTINATION ${PLUGIN_INSTALL_PATH})
install(FILES "qml/TaskManagerView.qml" DESTINATION ${PLUGIN_INSTALL_PATH})
install(FILES "qml/ThumbnailWindow.qml" DESTINATION ${PLUGIN_INSTALL_PATH})
install(FILES "qml/ThumbnailContainer.qml" DESTINATION ${PLUGIN_INSTALL_PATH})
install(TARGETS "ukui-task-manager" LIBRARY DESTINATION ${PLUGIN_INSTALL_PATH})
ukui-panel/widgets/ukui-task-manager/qml/ 0000775 0001750 0001750 00000000000 15167645111 017345 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/TaskItemData.qml 0000664 0001750 0001750 00000001717 15167645100 022377 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
import QtQml 2.15
import QtQuick 2.15
QtObject {
property var windowIdList: []
property var windowIcons: {}
property var windowIconsName: {}
property var windowTitles: {}
property Item currentTaskItem: null
}
ukui-panel/widgets/ukui-task-manager/qml/AppList.qml 0000664 0001750 0001750 00000024015 15167645100 021434 0 ustar feng feng /*
*
* Copyright (C) 2023, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: qiqi49
*
*/
import QtQuick 2.12
import QtQml.Models 2.15
import QtQuick.Layouts 1.12
import org.ukui.quick.widgets 1.0
import org.ukui.quick.items 1.0 as UkuiItems
import org.ukui.quick.platform 1.0 as Platform
import org.ukui.panel.taskManager 1.0 as UkuiTaskManager
Item {
id: root
property int iconIndexAboutToBeScaled: -1
property alias model: visualModel.model
property bool isHorizontal: orientation === ListView.Horizontal
property alias spacing: normalView.spacing
property int itemSize: 48
property int itemMargin: 4 * ratio
property real ratio: 1
signal toNormalFinished()
signal toDraggingFinished()
signal requestThumbnailView(bool show, TaskItemData data, Item item)
function indexAt(x, y) {
let idx = normalView.normalViewItemIdx(x, y, normalView.spacing/2, true);
if (idx === -1) {
idx = normalView.normalViewItemIdx(x, y, normalView.spacing/2, false);
}
return idx;
}
function updateIconGeometry() {
for (var i = 0; i < visualModel.count; i++) {
let item = repeater.itemAt(i);
if (item) {
Platform.WindowManager.setMinimizedGeometry(model[i], item);
}
}
}
DelegateModel {
id: visualModel
delegate: Item {
width: isHorizontal ? visualDelegate.width : root.itemSize
height: root.itemSize
Timer {
id: listDragTimer
interval: 100
onTriggered: {
if (listDropArea.containsDrag) {
root.updateIconGeometry();
if (modelData !== "") {
UkuiTaskManager.TaskManager.activateWindow(modelData)
}
}
}
}
DropArea {
id: listDropArea
anchors.fill: parent
enabled: UkuiTaskManager.TaskManager.enableDragToApp
onEntered: (dragEvent) => {
if (taskItemListRoot.dragEventSource(dragEvent) !== "DropToAppIcon") {
dragEvent.accepted = false;
return;
}
listDragTimer.restart();
}
onExited: {
listDragTimer.stop();
tooltip.hideTooltip();
}
}
UkuiItems.Tooltip {
id: tooltip
anchors.fill: parent
mainText: taskItemData.Name
posFollowCursor: false
active: listDropArea.containsDrag
// TODO: 优化
// 先有entered信号，再触发containsDragChanged信号，之后才有tooltip.active变为true
// 只有当tooltip.active为true时，调用tooltip.showTooltip()才可以生效
onActiveChanged: {
if (active) {
tooltip.showTooltip();
}
}
location: {
switch(Widget.container.position) {
case UkuiItems.Types.Bottom:
return UkuiItems.Dialog.BottomEdge;
case UkuiItems.Types.Left:
return UkuiItems.Dialog.LeftEdge;
case UkuiItems.Types.Top:
return UkuiItems.Dialog.TopEdge;
case UkuiItems.Types.Right:
return UkuiItems.Dialog.RightEdge;
}
}
margin: 8
}
UkuiItems.DtThemeBackground {
id: visualDelegate
width: viewLayout.width
height: root.itemSize - itemMargin*2
anchors.verticalCenter: parent.verticalCenter
anchors.horizontalCenter: parent.horizontalCenter
useStyleTransparency: false
backgroundColor: listDropArea.containsDrag ? Platform.GlobalTheme.kComponentAlphaHover :
normalLayout.containsPress ? Platform.GlobalTheme.kComponentAlphaClick :
normalLayout.containsMouse ? Platform.GlobalTheme.kComponentAlphaHover :
Platform.GlobalTheme.kContainGeneralAlphaNormal
radius: Platform.GlobalTheme.kRadiusNormal
RowLayout {
id: viewLayout
height: parent.height
spacing: 0
onChildrenRectChanged: width = childrenRect.width
z: 1
UkuiItems.Icon {
id: themeicon
Layout.margins: itemMargin
Layout.preferredWidth: height
Layout.maximumWidth: height
Layout.fillHeight: true
source: taskItemData.WindowIconsName[modelData] === "" ? taskItemData.WindowIcons[modelData] : taskItemData.WindowIconsName[modelData]
addUnifiedIconBox: true
scale: (iconIndexAboutToBeScaled === index) ? 0.8 : 1.0
Behavior on scale {
NumberAnimation { duration: 100 }
}
}
UkuiItems.DtThemeText {
id: text
Layout.preferredWidth: text.implicitWidth
Layout.maximumWidth: 192
Layout.fillHeight: true
Layout.rightMargin: 8
visible: isHorizontal
text: (taskItemData.WindowTitles[modelData] === undefined) ? "" : taskItemData.WindowTitles[modelData]
textColor: Platform.GlobalTheme.kFontPrimary
verticalAlignment: Text.AlignVCenter
horizontalAlignment: Text.AlignLeft
elide: Text.ElideRight
fontSizeMode: Text.VerticalFit
}
}
// 仅用于获取鼠标悬浮事件，requestThumbnailView
MouseArea {
id: normalLayout
Accessible.role: Accessible.Button
Accessible.description: "This is task manager button on list mode of ukui-panel"
Accessible.name: taskItemData.Id + index
anchors.fill: parent
acceptedButtons: Qt.NoButton
hoverEnabled: true
TaskItemData {
id: singleItemData
windowIdList: [modelData]
windowIcons: taskItemData.WindowIcons
windowIconsName: taskItemData.WindowIconsName
windowTitles: taskItemData.WindowTitles
}
onContainsMouseChanged: {
mouseArea.aboutToShowThumbnailView(containsMouse, singleItemData, this);
}
}
Rectangle {
id: demandsAttention
anchors.fill: parent
color: "#FF9100"
radius: 8
visible: taskItemData.DemandsAttentionWinIdList.includes(modelData)
NumberAnimation on opacity {
running: demandsAttention.visible
loops: 4
from: 0.25
to: 0.6
duration: 450
}
}
}
UkuiItems.DtThemeBackground {
height: 4 * ratio
width: 8 * ratio
radius: 2 * ratio
anchors.verticalCenter: visualDelegate.bottom
anchors.left: visualDelegate.left
anchors.leftMargin: 16 * ratio
useStyleTransparency: false
backgroundColor: (modelData === UkuiTaskManager.TaskManager.currentActiveWinId)
? Platform.GlobalTheme.kBrandNormal : Platform.GlobalTheme.kGrayAlpha9
}
}
}
Grid {
id: normalView
width: childrenRect.width
height: childrenRect.height
rows: isHorizontal ? 1 : visualModel.count
columns: isHorizontal ? visualModel.count : 1
Repeater {
id: repeater
model: visualModel
}
function indexAtPosition(x, y) {
for (let i = 0; i < visualModel.count; ++i) {
let item = repeater.itemAt(i);
let point = item.mapFromItem(root, Qt.point(x, y));
if (item.contains(point)) {
return i;
}
}
return -1;
}
function normalViewItemIdx(x, y, offset, forward) {
if (isHorizontal) {
return normalView.indexAtPosition(forward ? x - offset : x + offset, y);
} else {
return normalView.indexAtPosition(x, forward ? y - offset : y + offset);
}
}
}
}
ukui-panel/widgets/ukui-task-manager/qml/icons/ 0000775 0001750 0001750 00000000000 15167645100 020456 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/icons/to.svg 0000664 0001750 0001750 00000004553 15167645100 021630 0 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/icons/back.svg 0000664 0001750 0001750 00000004616 15167645100 022106 0 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/ThumbnailContainer.qml 0000664 0001750 0001750 00000022146 15167645100 023651 0 ustar feng feng /*
*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: qiqi49
*
*/
import QtQuick 2.15
import QtQuick.Layouts 1.15
import QtQuick.Controls 2.15
import org.ukui.quick.items 1.0
import org.ukui.windowThumbnail 1.0
import org.ukui.quick.platform 1.0
import org.ukui.panel.taskManager 1.0 as UkuiTaskManager
DtThemeBackground {
id: container
property int spacing: 8
property var containerIcon
property bool isList: false
property bool containsMouse: false
property bool containsPress: false
property bool viewIsHorizontal: false
property string containerTitle: ""
signal closeButtonClicked()
backgroundColor: GlobalTheme.baseActive
//预览图非列表模式跟随主题透明度
alpha: 0
useStyleTransparency: !isList
radius: GlobalTheme.kRadiusWindow
borderColor: GlobalTheme.kLineNormal
border.width: !isList ? 1 : 0
Loader {
id: layoutLoader
DtThemeBackground {
anchors.fill: parent
backgroundColor: containsPress ? GlobalTheme.kGrayAlpha3 :
containsMouse ? GlobalTheme.kGrayAlpha1 :
GlobalTheme.kGrayAlpha0
useStyleTransparency: false
radius: isList ? 4 : GlobalTheme.kRadiusWindow
}
sourceComponent: isList ? listLayout : thumbnailLayout
}
Component {
id: thumbnailLayout
ColumnLayout {
id: baseLayout
spacing: 0
height: {
if (viewIsHorizontal) {
return viewLoader.preChildrenSize;
} else {
var preHeight = windowThumbnail.height + container.spacing * 3 + 24;
return Math.max(preHeight, minimumHeight);
}
}
width: {
if (viewIsHorizontal) {
var preWidth = windowThumbnail.width + container.spacing * 2;
return Math.max(preWidth, minimumWidth);
} else {
return viewLoader.preChildrenSize;
}
}
RowLayout {
Layout.fillWidth: true
Layout.preferredHeight: 24
Layout.maximumHeight: 24
Layout.margins: container.spacing
Layout.bottomMargin: 0
spacing: 0
Icon {
Layout.preferredHeight: 24
Layout.preferredWidth: 24
// 最小宽度下，保证图标和关闭按钮完全显示（24*2），左右margin也要对称显示
Layout.rightMargin: Math.min(baseLayout.width - 24*2 - container.spacing*2, container.spacing)
source: containerIcon
}
DtThemeText {
Layout.fillHeight: true
Layout.fillWidth: true
text: containerTitle
textColor: GlobalTheme.kFontPrimary
elide: Text.ElideRight
verticalAlignment: Text.AlignVCenter
Tooltip {
anchors.fill: parent
mainText: parent.text
posFollowCursor: true
visible: parent.truncated
}
}
MouseArea {
id: closeButtonArea
Layout.preferredHeight: 24
Layout.preferredWidth: 24
Layout.alignment: Qt.AlignVCenter | Qt.AlignRight
hoverEnabled: true
visible: container.containsMouse
DtThemeBackground {
backgroundColor: closeButtonArea.containsPress ? GlobalTheme.kErrorClick :
GlobalTheme.kErrorNormal
radius: GlobalTheme.kRadiusNormal
anchors.fill: parent
visible: parent.containsMouse
Tooltip {
anchors.fill: parent
mainText: qsTr("Close")
posFollowCursor: true
}
}
Icon {
anchors.centerIn: parent
width: 16
height: width
mode: parent.containsMouse ? Icon.Highlight : Icon.AutoHighlight
source: "window-close-symbolic"
}
onClicked: {
closeButtonClicked();
}
}
}
WindowThumbnail {
id: windowThumbnail
Layout.alignment: Qt.AlignHCenter
Layout.margins: container.spacing
Layout.preferredWidth: viewIsHorizontal ? itemWidth : viewLoader.preChildrenSize - container.spacing * 2
Layout.preferredHeight: viewIsHorizontal ? viewLoader.preChildrenSize - 48 : itemHeight
Layout.maximumHeight: maximumHeight - container.spacing * 3 - 24
Layout.maximumWidth: maximumWidth - container.spacing * 2
property real itemHeight
property real itemWidth
// 窗口visible改变
winId: windowVisible ? modelData : ""
function updateSize() {
if (winId === "") {
return;
}
var itemGeometry = WindowManager.geometry(winId);
if (viewIsHorizontal) {
itemWidth = itemGeometry.width * ((viewLoader.preChildrenSize - 48 ) / itemGeometry.height);
} else {
itemHeight = itemGeometry.height * ((viewLoader.preChildrenSize - container.spacing * 2) / itemGeometry.width);
}
}
onWinIdChanged: updateSize()
onWidthChanged: updateSize()
onHeightChanged: updateSize()
}
}
}
Component {
id: listLayout
Item {
width: viewLoader.item.isIntervactive ? 220 : 232
height: 36
RowLayout {
anchors.fill: parent
anchors.margins: container.spacing
Icon {
Layout.preferredHeight: 16
Layout.preferredWidth: 16
source: containerIcon
}
DtThemeText {
Layout.fillHeight: true
Layout.fillWidth: true
text: containerTitle
textColor: GlobalTheme.kFontPrimary
elide: Text.ElideRight
verticalAlignment: Text.AlignVCenter
Tooltip {
anchors.fill: parent
mainText: parent.text
posFollowCursor: true
visible: parent.truncated
}
}
MouseArea {
id: listCloseButtonArea
Layout.preferredHeight: 16
Layout.preferredWidth: 16
Layout.alignment: Qt.AlignVCenter | Qt.AlignRight
hoverEnabled: true
visible: container.containsMouse
DtThemeBackground {
backgroundColor: listCloseButtonArea.containsPress ? GlobalTheme.kErrorClick :
GlobalTheme.kErrorNormal
radius: GlobalTheme.kRadiusMin
anchors.fill: parent
visible: parent.containsMouse
Tooltip {
anchors.fill: parent
mainText: qsTr("Close")
posFollowCursor: true
}
}
Icon {
anchors.fill: parent
mode: parent.containsMouse ? Icon.Highlight : Icon.AutoHighlight
source: "window-close-symbolic"
}
onClicked: {
closeButtonClicked();
}
}
}
}
}
}
ukui-panel/widgets/ukui-task-manager/qml/TaskManagerView.qml 0000664 0001750 0001750 00000037406 15167645111 023122 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: qiqi49
* hxf
*
*/
import QtQml 2.15
import QtQuick 2.12
import QtQml.Models 2.12
import QtQuick.Layouts 1.12
import org.ukui.quick.widgets 1.0
import org.ukui.panel.taskManager 1.0 as UkuiTaskManager
import org.ukui.quick.items 1.0 as Items
import org.ukui.quick.platform 1.0 as Platform
// taskManager全部界面显示（包括预览图）
TaskManagerBase {
id: taskManager
// 任务栏是否激活： 预览图是否显示、是否有高亮显示、是否有拖拽事件、是否打开右键菜单
Widget.active: taskManagerActived || thumbnailView.visible || isDragging
property var widgetScreenGeo: Widget.container.screen.availableGeometry
function menuAboutToHide() {
viewContent.menuVisible = false;
taskManagerActived = false;
isTaskMenuShow = false;
}
function hidethumbnail() {
UkuiTaskManager.TaskManager.activateWindowView([]);
thumbnailView.hide();
viewContent.clearThumbnailModel();
}
function showthumbnail() {
if (!viewContent.currentWinIdList) {
return;
}
if (viewContent.currentWinIdList.length !== 0) {
thumbnailView.show();
}
}
Component.onCompleted: {
taskManager.viewModel.menuAboutToHide.connect(menuAboutToHide)
}
Component.onDestruction: {
taskManager.viewModel.menuAboutToHide.disconnect(menuAboutToHide)
}
state: ""
states: [
State {
name: "aboutToShowThumbnail"
},
State {
name: "aboutToHideThumbanil"
}
]
transitions: [
Transition {
to: "aboutToShowThumbnail"
SequentialAnimation {
PauseAnimation { duration: 400 }
ScriptAction {
script: {
if (!thumbnailView.visible && !isTaskMenuShow) {
viewContent.updateThumbnailView();
thumbnailView.updatePosition();
thumbnailView.updateThumbnailOffset();
showthumbnail();
updateBlurRegionTimer.restart();
}
}
}
}
},
Transition {
to: "aboutToHideThumbanil"
SequentialAnimation {
PauseAnimation { duration: 400 }
ScriptAction {
script: {
if (thumbnailView.visible && (!taskItemData.mouse.containsMouse || isTaskMenuShow)) {
hidethumbnail();
}
}
}
}
}
]
Timer {
id: changedThumbnailData
interval: 400
onTriggered: {
if (taskItemData.mouse.containsMouse) {
viewContent.thumbnailData = taskItemData.dataToBeChanged;
}
}
}
onRequestThumbnailView: (show, data, mouse) => {
taskItemData.mouse = mouse;
if (show) {
state = "aboutToShowThumbnail";
if (thumbnailView.visible) {
// timer
taskItemData.dataToBeChanged = data;
changedThumbnailData.restart();
} else {
viewContent.thumbnailData = data;
}
} else {
if (taskItemData.mouse) {
state = "aboutToHideThumbanil";
} else {
hidethumbnail();
}
}
}
QtObject {
id: taskItemData
// 当前预览图对应的taskItem，通过containsMouse判断是否数据更新 / 解决X下预览图尺寸变化会触发隐藏的bug
property Item mouse
property var dataToBeChanged
}
Items.Dialog {
id: thumbnailView
mainItem: viewContent
type: Platform.Settings.platformName === "wayland" ? Platform.WindowType.Switcher : Platform.WindowType.PopupMenu
flags: Qt.WindowDoesNotAcceptFocus | Qt.FramelessWindowHint
/**
* [注]: 以Items.Types.Bottom（任务栏在下）为例，关于horizontalCenterOffset的计算：
* 由于Dialog窗口需要加上阴影大小，所以窗口大小比内部预览图要大，默认情况下，预览图是居中显示的（horizontalCenterOffset = 0）
* 在满屏时，此时Dialog已经比Screen.width要大，再居中就不对了，所以需要调整horizontalCenterOffset
* 在缩放情况下有时不会完美铺满屏幕，所以预览图需要在屏幕上居中显示(horizontalCenterOffset = thumbnailView.width - Screen.width)/2 * -1
* 并且设计稿标注，预览图与窗口间距为8(horizontalCenterOffset = (viewContent.cachedOffset - viewContent.screenMargin) * -1)
*/
onWidthChanged: updateThumbnailOffset();
onHeightChanged: updateThumbnailOffset();
function updateThumbnailOffset() {
var actualHorizontalOffset = 0;
var actualVerticalOffset = 0;
if (viewContent.isHorizontal) {
actualHorizontalOffset = (thumbnailView.width > taskManager.widgetScreenGeo.width) ?
Math.max((viewContent.cachedOffset - viewContent.screenMargin) * -1, (thumbnailView.width - taskManager.widgetScreenGeo.width)/2 * -1) : 0;
viewContent.anchors.horizontalCenterOffset = actualHorizontalOffset;
} else {
actualVerticalOffset = (thumbnailView.height > taskManager.widgetScreenGeo.height) ?
Math.max((viewContent.cachedOffset - viewContent.screenMargin) * -1, (thumbnailView.height - taskManager.widgetScreenGeo.height)/2 * -1) : 0;
viewContent.anchors.verticalCenterOffset = actualVerticalOffset;
}
}
function updatePosition() {
switch (Widget.container.position) {
case Items.Types.Left:
thumbnailView.location = Items.Types.LeftEdge;
viewContent.anchors.horizontalCenterOffset = -(viewContent.offset-viewContent.viewMargin) / 2;
viewContent.anchors.verticalCenterOffset = 0;
break;
case Items.Types.Top:
thumbnailView.location = Items.Types.TopEdge;
viewContent.anchors.horizontalCenterOffset = 0;
viewContent.anchors.verticalCenterOffset = -(viewContent.offset-viewContent.viewMargin)/2;
break;
case Items.Types.Right:
thumbnailView.location = Items.Types.RightEdge;
viewContent.anchors.horizontalCenterOffset = (viewContent.offset-viewContent.viewMargin) / 2;
viewContent.anchors.verticalCenterOffset = 0;
break;
case Items.Types.Bottom:
thumbnailView.location = Items.Types.BottomEdge;
viewContent.anchors.horizontalCenterOffset = 0;
viewContent.anchors.verticalCenterOffset = (viewContent.offset-viewContent.viewMargin) / 2;
break;
default:
break;
}
thumbnailView.margin = 0;
}
Items.WindowBlurBehind {
id: blurRegions
window: thumbnailView
enable: true
// 整个窗口的毛玻璃区域（为list模式时）
Items.RectRegion {
id: windowRegion
x: 0
y: 0
width: viewContent.width
height: viewContent.height
radius: Platform.GlobalTheme.kRadiusWindow
}
}
Item {
id: viewBase
height: viewContent.isHorizontal ? (viewContent.height + viewContent.offset + viewContent.viewMargin) : (viewContent.height + viewContent.offset*2)
width: viewContent.isHorizontal ? (viewContent.width + viewContent.offset*2) : (viewContent.width + viewContent.offset + viewContent.viewMargin)
/**
* DropArea实现功能： 拖拽文件到多窗口下，预览图有悬浮显示，并600ms后激活对应窗口
* 悬浮三态 ---- (ThumbnailWindow.qml处实现)mouseAreaContainsMouse与(viewDropArea.targetThumbnailIndex === index)绑定
* 激活对应窗口 ---- 通过indexAt取到对应index并开始计时
*/
DropArea {
id: viewDropArea
property int targetThumbnailIndex: -1
enabled: UkuiTaskManager.TaskManager.enableDragToApp
anchors.fill: viewContent
anchors.centerIn: viewContent
onPositionChanged: (drag) => {
if (taskManager.dragEventSource(drag) !== "DropToAppIcon") {
return;
}
var targetIndex = viewContent.thumbnailLayout.indexAt(drag.x, drag.y);
if (viewDropArea.targetThumbnailIndex !== targetIndex && targetIndex !== -1) {
viewDropArea.targetThumbnailIndex = targetIndex;
viewDragTimer.restart();
}
}
onExited: {
viewDropArea.targetThumbnailIndex = -1;
viewDragTimer.stop();
}
Timer {
id: viewDragTimer
interval: 600
onTriggered: {
if (viewDropArea.targetThumbnailIndex > -1 && viewDropArea.targetThumbnailIndex < thumbnailModel.count) {
UkuiTaskManager.TaskManager.activateWindow(thumbnailModel.get(viewDropArea.targetThumbnailIndex).winId);
taskManager.hidethumbnail();
viewDropArea.targetThumbnailIndex = -1;
}
}
}
}
ThumbnailWindow {
id: viewContent
Accessible.role: Accessible.Button
Accessible.description: "This is a thumbnail window of ukui-panel"
Accessible.name: "ukui-panel thumbnail window"
anchors.horizontalCenter: parent.horizontalCenter
anchors.verticalCenter: parent.verticalCenter
property UkuiTaskManager.TaskItemData thumbnailData: null
property var currentWinIdList: thumbnailData ? thumbnailData.windowIdList : []
property var windowTitles: thumbnailData ? thumbnailData.windowTitles : []
property var windowIcons: thumbnailData ? thumbnailData.windowIcons : []
property var windowIconsName: thumbnailData ? thumbnailData.windowIconsName : []
property bool isHorizontal: taskManager.view.orientation === ListView.Horizontal
property bool hasFocus: viewContent.containsMouse || viewContent.menuVisible || viewDropArea.containsDrag
property bool windowVisible: thumbnailView.visible
property var widgetScreenGeo: taskManager.widgetScreenGeo
onHasFocusChanged: {
if (hasFocus) {
taskManager.state = "aboutToShowThumbnail";
} else {
taskManager.state = "aboutToHideThumbanil";
}
}
Timer {
id: updateBlurRegionTimer
interval: 50
onTriggered: {
if (!viewContent.isList) {
blurRegions.clearRectRegion();
for (var i = 0; i < thumbnailModel.count; i++) {
let item = viewContent.thumbnailLayout.itemAt(i);
let point = item.mapToItem(viewBase, 0, 0);
item.itemRegion.x = point.x;
item.itemRegion.y = point.y;
if (item) {
blurRegions.addRectRegion(item.itemRegion);
}
}
} else {
blurRegions.clearRectRegion();
let point = viewContent.mapToItem(viewBase, 0, 0);
windowRegion.x = point.x;
windowRegion.y = point.y;
blurRegions.addRectRegion(windowRegion);
}
}
}
onCurrentWinIdListChanged: updateThumbnailView()
// 更新预览图model数据 && 更新毛玻璃区域
function updateThumbnailView() {
updateBlurRegionTimer.stop();
updateThumbnailModel();
updateBlurRegionTimer.restart();
viewContent.determineListViewSize();
// 先设置mainItem的宽高 再切换visualParent,解决预览图闪烁问题
if (viewContent.thumbnailData) {
if (viewContent.thumbnailData.currentTaskItem !== null) {
thumbnailView.visualParent = viewContent.thumbnailData.currentTaskItem;
}
} else {
thumbnailView.visualParent = null;
}
}
property var modelList: []
ListModel {
id: thumbnailModel
}
function clearThumbnailModel() {
modelList = [];
thumbnailModel.clear();
}
function updateThumbnailModel() {
// 这里不能直接用=（js中表示引用），需要浅拷贝
if (!currentWinIdList || currentWinIdList.length == 0) {
hidethumbnail();
return;
}
var listFromModel = modelList.slice(0);
var listFromCurrent = currentWinIdList.slice(0);
var indexOfRemoveList = [];
for (var i = 0; i < listFromModel.length; i++) {
if (listFromCurrent.includes(listFromModel[i])) {
listFromCurrent.splice(listFromCurrent.indexOf(listFromModel[i]), 1);
} else {
indexOfRemoveList.push(i);
}
}
for (var i = indexOfRemoveList.length - 1; i > -1; i--) {
listFromModel.splice(indexOfRemoveList[i], 1);
thumbnailModel.remove(indexOfRemoveList[i]);
}
for (var i = 0; i < listFromCurrent.length; i++) {
listFromModel.push(listFromCurrent[i]);
thumbnailModel.append({"winId": listFromCurrent[i]});
}
modelList = listFromModel;
}
}
}
}
}
ukui-panel/widgets/ukui-task-manager/qml/qml.qrc 0000664 0001750 0001750 00000000561 15167645100 020645 0 ustar feng feng icons/back.svgicons/to.svgicon/ukui-start-symbolic.svgicon/ukui-start-symbolic-disable.svgicon/ukui-end-symbolic.svgicon/ukui-end-symbolic-disable.svg
ukui-panel/widgets/ukui-task-manager/qml/ThumbnailWindow.qml 0000664 0001750 0001750 00000055324 15167645111 023204 0 ustar feng feng /*
*
* Copyright (C) 2023, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: qiqi49
*
*/
import QtQuick 2.15
import QtQuick.Layouts 1.15
import QtQuick.Controls 2.15
import org.ukui.quick.items 1.0
import org.ukui.windowThumbnail 1.0
import org.ukui.quick.platform 1.0 as Platform
import org.ukui.panel.taskManager 1.0 as UkuiTaskManager
MouseArea {
id: baseMouseArea
property bool isList
property var thumbnailLayout: viewLoader.item.viewRepeater
hoverEnabled: true
property bool menuVisible: false
property int thumbnailImplicitHeight: 192
// 设置初始高度，规避初次显示时出现鼠标悬浮退出事件，影响预览图显示
width: 272
height: 192
// 判断相对于默认宽高来说，是否进行缩放(为true时，预览图在不达到最小宽高时进行等比缩放)
property real thumbnailScale: 1.0
// 阴影的宽度(采用GlobalTheme.kShadowMenu)
property int cachedOffset: 14
property int offset: {
if (isList) {
cachedOffset = Math.max(baseShadow.shadowSize, 14);
return cachedOffset;
} else {
if (thumbnailLayout.count > 0) {
cachedOffset = Math.max(thumbnailLayout.itemAt(0).shadowSize, 14);
return cachedOffset;
}
return cachedOffset;
}
}
// 预览图窗口布局和*默认*大小相关参数
property int viewMargin: 8 // 预览图显示内容与任务栏的间距
property int screenMargin: 8 // 预览图满屏时，与屏幕边缘的间距
property int viewSpacing: 8 // 预览图模式下窗口间距
property int layoutSpacing: 8 // 内部预览图组件与窗口的左右margin
property var maximumSize : Qt.size(344, 344)
property var minimumSize : Qt.size(120, 120)
property var initSize: Qt.size(192, 192)
function determineListViewSize() {
if (!currentWinIdList) {
return;
}
if (isHorizontal) {
var listPreHeight = listViewBase.determineHeight(currentWinIdList).height;
if (listPreHeight < 124) {
baseMouseArea.isList = true;
return;
} else {
viewLoader.preChildrenSize = listPreHeight;
baseMouseArea.isList = false;
}
} else {
var listPreWidth = listViewBase.determineWidth(currentWinIdList).width;
if (listPreWidth < 124) {
baseMouseArea.isList = true;
return;
} else {
viewLoader.preChildrenSize = listPreWidth;
baseMouseArea.isList = false;
}
}
}
DtThemeBackground {
id: listViewBase
backgroundColor: Platform.GlobalTheme.baseActive
//预览图列表模式跟随主题透明度
alpha: 0
useStyleTransparency: isList
width: viewLoader.width
height: viewLoader.height
borderColor: Platform.GlobalTheme.kLineNormal
border.width: isList ? 1 : 0
radius: Platform.GlobalTheme.kRadiusWindow
DtDropShadow {
id: baseShadow
anchors.fill: listViewBase
shadowData: isList ? Platform.GlobalTheme.kShadowMenu : undefined
shadowRadius: listViewBase.radius
}
// 窗口尺寸不能为0
onWidthChanged: {
baseMouseArea.width = Math.max(Math.ceil(listViewBase.width), 1);
baseMouseArea.height = Math.max(Math.ceil(listViewBase.height), 1);
}
onHeightChanged: {
baseMouseArea.width = Math.max(Math.ceil(listViewBase.width), 1);
baseMouseArea.height = Math.max(Math.ceil(listViewBase.height), 1);
}
function determineHeight(winIdList) {
var totalWidth = 0;
var thumbnailHeight = 144; // 这是预览图内部组件默认高度（192-24-layoutSpacing*3）
if (!winIdList) {
return;
}
for (var i = 0; i < winIdList.length; i++) {
var itemGeometry = Platform.WindowManager.geometry(winIdList[i]);
var thumbWidth = itemGeometry.width * (thumbnailHeight / itemGeometry.height);
// 预览图在计算宽高时，也要考虑大小限制
totalWidth = totalWidth + Math.min(Math.max(thumbWidth, minimumSize.width - layoutSpacing*2), maximumSize.width - layoutSpacing*2);
}
var otherAreaSize;
// 其余区域的大小，包括间距和预览图的margin
otherAreaSize = (layoutSpacing * 2 * winIdList.length) + (viewSpacing * (winIdList.length - 1));
if ((baseMouseArea.widgetScreenGeo.width - (screenMargin * 2) - otherAreaSize) < totalWidth) {
thumbnailScale = (baseMouseArea.widgetScreenGeo.width - screenMargin * 2 - otherAreaSize) / totalWidth;
thumbnailHeight = thumbnailHeight * thumbnailScale;
} else {
thumbnailScale = 1.0;
}
var listPreHeight = thumbnailHeight + 48;
var listPreWidth = otherAreaSize + totalWidth;
return Qt.rect(0, 0, listPreWidth, listPreHeight);
}
function determineWidth(winIdList) {
var totalHeight = 0;
var thumbnailWidth = 176; // 这是预览图内部组件默认宽度（192-layoutSpacing*2）
var thumbnailOtherHeight = 48; //这是单个预览图内部，除预览图外的其他高度（48）
if (!winIdList) {
return;
}
for (var i = 0; i < winIdList.length; i++) {
var itemGeometry = Platform.WindowManager.geometry(winIdList[i]);
var thumbHeight = (itemGeometry.height * (thumbnailWidth / itemGeometry.width));
// 预览图在计算宽高试，也要考虑大小限制
totalHeight = totalHeight + Math.min(Math.max(thumbHeight, minimumSize.height - thumbnailOtherHeight), maximumSize.height - thumbnailOtherHeight);
}
var otherAreaSize;
// 其余区域的大小，包括间距和预览图的margin,以及纵向布局时的title高度（24）
otherAreaSize = (layoutSpacing * 3 + 24) * winIdList.length + viewSpacing * (winIdList.length - 1);
if ((baseMouseArea.widgetScreenGeo.height - screenMargin * 2 - otherAreaSize) < totalHeight) {
thumbnailScale = (baseMouseArea.widgetScreenGeo.height - screenMargin * 2 - otherAreaSize) / totalHeight;
thumbnailWidth = thumbnailWidth * thumbnailScale;
} else {
thumbnailScale = 1.0;
}
var listPreWidth = thumbnailWidth + layoutSpacing*2;
var listPreHeight = totalHeight + otherAreaSize;
return Qt.rect(0, 0, listPreWidth, listPreHeight);
}
Loader {
id: viewLoader
property real preChildrenSize
sourceComponent: baseMouseArea.isList ? listMode : thumbnailMode
}
/**
* 预览图显示View： 列表模式、预览图模式
*/
Component {
id: thumbnailMode
Item {
width: childrenRect.width
height: childrenRect.height
property var viewRepeater: repeater
Column {
id: columnLayout
spacing: viewSpacing
}
Row {
id: rowLayout
spacing: viewSpacing
}
Repeater {
id: repeater
parent: isHorizontal ? rowLayout : columnLayout
model: thumbnailModel
delegate: thumbnailDelegate
function indexAt(x, y) {
for (let i = 0; i < thumbnailModel.count; ++i) {
let item = repeater.itemAt(i);
let point = item.mapFromItem(baseMouseArea, Qt.point(x, y));
if (item.contains(point)) {
return i;
}
}
return -1;
}
}
}
}
}
Component {
id: listMode
RowLayout {
property bool isIntervactive: listModelView.contentItem.childrenRect.height > listModelView.height
property var viewRepeater: listModelView
width: 240
height: listModelView.height + listModelView.Layout.margins * 2
spacing: 0
ListView {
id: listModelView
Layout.fillWidth: true
Layout.preferredHeight: Math.min(contentItem.childrenRect.height, 360)
Layout.margins: 4
Layout.rightMargin: 0
clip: true
spacing: 0
interactive: parent.isIntervactive
orientation: ListView.Vertical
boundsBehavior: Flickable.StopAtBounds
ScrollBar.vertical: scrollBarControl
model: thumbnailModel
delegate: thumbnailDelegate
}
ScrollBar {
id: scrollBarControl
Layout.fillHeight: true
Layout.preferredWidth: 12
Layout.margins: 4
Layout.leftMargin: 0
visible: (size < 1 && size > 0)
padding: 4
contentItem: DtThemeBackground {
radius: width / 2
useStyleTransparency: false
backgroundColor: Platform.GlobalTheme.kGrayAlpha3
}
}
}
}
/**
* 预览图delegate
*/
Component {
id: thumbnailDelegate
MouseArea {
id: itemMouseArea
width: thumbnailLoader.width
height: thumbnailLoader.height
hoverEnabled: true
acceptedButtons: Qt.LeftButton | Qt.RightButton
property alias itemRegion: blurRegion
property alias shadowSize: itemShadow.shadowSize
RectRegion {
id: blurRegion
x: itemMouseArea.x
y: itemMouseArea.y
width: itemMouseArea.width
height: itemMouseArea.height
radius: thumbnailLoader.item.radius
}
DtDropShadow {
id: itemShadow
anchors.fill: thumbnailLoader
shadowData: isList ? undefined : Platform.GlobalTheme.kShadowMenu
shadowRadius: thumbnailLoader.item.radius
}
Timer {
id: activeTimer
property var activeWinIds: []
onTriggered: {
UkuiTaskManager.TaskManager.activateWindowView(activeTimer.activeWinIds)
}
}
function activateWindowView() {
var winIds = [model.winId];
if (baseMouseArea.menuVisible || containsMouse) {
activeTimer.interval = 500;
activeTimer.activeWinIds = winIds;
activeTimer.start();
} else {
activeTimer.stop();
UkuiTaskManager.TaskManager.activateWindowView([]);
}
}
onContainsMouseChanged: activateWindowView()
onClicked: {
if (mouse.button === Qt.RightButton) {
var actions = UkuiTaskManager.TaskManager.windowActions(model.winId);
baseMouseArea.menuVisible = taskManager.viewModel.openMenu(true, actions, viewLoader);
} else {
// 需要先激活窗口再隐藏预览图
// 如果先隐藏预览图再激活窗口，会因为先取消highlight窗口，导致屏幕闪一下其他窗口的问题
UkuiTaskManager.TaskManager.activateWindow(model.winId);
taskManager.hidethumbnail();
}
}
Loader {
id: thumbnailLoader
WindowThumbnailMprisModel {
id: mprisModel
winID: model.winId
pid: Platform.WindowManager.pid(model.winId)
}
property string modelData: model.winId
property var title: windowTitles ? windowTitles[model.winId] : ""
property var icon: windowIcons ? windowIcons[model.winId] : ""
property var iconName: windowIconsName ? windowIconsName[model.winId] : ""
property var windowThumbnailMprisModel: mprisModel
property bool mouseAreaContainsMouse: itemMouseArea.containsMouse || viewDropArea.targetThumbnailIndex === index
property bool mouseAreaContainsPress: itemMouseArea.containsPress
// 预览图限制宽高(最大最小宽高限制，要随满屏*等比例缩放* ）
property real maximumHeight: isHorizontal ? maximumSize.height : maximumSize.height * baseMouseArea.thumbnailScale
property real minimumHeight: isHorizontal ? minimumSize.height : minimumSize.height * baseMouseArea.thumbnailScale
property real maximumWidth: isHorizontal ? maximumSize.width * baseMouseArea.thumbnailScale : maximumSize.width
property real minimumWidth: isHorizontal ? minimumSize.width * baseMouseArea.thumbnailScale : minimumSize.width
// mprisModel.count > 0为mpris音视频预览图
sourceComponent: {
if (mprisModel.count > 0) {
if (mprisModel.isCurrentMediaAudio) {
return musicThumbanilComponent;
} else {
return videoThumbnailComponent;
}
} else {
return thumbnailComponent;
}
}
}
}
}
/**
* 预览图组件显示: 普通预览图（预览图界面、列表界面）、mpris音频预览图、mpris视频预览图
*/
Component {
id: thumbnailComponent
ThumbnailContainer {
width: baseMouseArea.isList ? 220 : (isHorizontal ? contentWidth : viewLoader.preChildrenSize)
height: baseMouseArea.isList ? 36 : (isHorizontal ? viewLoader.preChildrenSize : contentHeight)
property real contentHeight: childrenRect.height
property real contentWidth: childrenRect.width
isList: baseMouseArea.isList
spacing: layoutSpacing
containerIcon: (iconName === undefined || iconName === "") ? icon : iconName
containerTitle: title === undefined ? "" : title
containsMouse: mouseAreaContainsMouse
containsPress: mouseAreaContainsPress
viewIsHorizontal: isHorizontal
onCloseButtonClicked: {
UkuiTaskManager.TaskManager.activateWindowView([]);
UkuiTaskManager.TaskManager.execSpecifiedAction(UkuiTaskManager.Action.Close, modelData);
}
}
}
Component {
id: musicThumbanilComponent
DtThemeBackground {
backgroundColor: Platform.GlobalTheme.baseActive
radius: Platform.GlobalTheme.kRadiusWindow
useStyleTransparency: true
width: childrenRect.width
height: childrenRect.height
borderColor: Platform.GlobalTheme.kLineNormal
border.width: 1
AudioPalyerThumbnail {
playerData: windowThumbnailMprisModel
containsMouse: mouseAreaContainsMouse
windowRadius: parent.radius
onCloseButtonClicked: {
UkuiTaskManager.TaskManager.activateWindowView([]);
UkuiTaskManager.TaskManager.execSpecifiedAction(UkuiTaskManager.Action.Close, modelData);
}
}
}
}
Component {
id: videoThumbnailComponent
DtThemeBackground {
backgroundColor: Platform.GlobalTheme.baseActive
radius: Platform.GlobalTheme.kRadiusWindow
useStyleTransparency: true
width: childrenRect.width
height: childrenRect.height
property int thumbnailMargin: 8
borderColor: Platform.GlobalTheme.kLineNormal
border.width: 1
Repeater {
id: view
model: windowThumbnailMprisModel
ColumnLayout {
id: baseLayout
spacing: 0
height: {
if (isHorizontal) {
return viewLoader.preChildrenSize;
} else {
var preHeight = windowThumbnail.height + layoutSpacing * 3 + 24;
return Math.max(preHeight, minimumHeight);
}
}
width: {
if (isHorizontal) {
var preWidth = windowThumbnail.width + layoutSpacing * 2;
return Math.max(preWidth, minimumWidth);
} else {
return viewLoader.preChildrenSize;
}
}
RowLayout {
Layout.fillWidth: true
Layout.preferredHeight: 24
Layout.maximumHeight: 24
Layout.margins: thumbnailMargin
Layout.bottomMargin: 0
Icon {
Layout.preferredHeight: 24
Layout.preferredWidth: 24
Layout.rightMargin: thumbnailMargin
source: (iconName === undefined || iconName === "") ? icon : iconName
}
DtThemeText {
Layout.fillHeight: true
Layout.fillWidth: true
text: title === undefined ? "" : title
textColor: Platform.GlobalTheme.kFontPrimary
elide: Text.ElideRight
verticalAlignment: Text.AlignVCenter
Tooltip {
anchors.fill: parent
mainText: parent.text
posFollowCursor: true
visible: parent.truncated
}
}
MouseArea {
id: closeButtonArea
Layout.preferredHeight: 24
Layout.preferredWidth: 24
Layout.alignment: Qt.AlignVCenter | Qt.AlignRight
hoverEnabled: true
visible: mouseAreaContainsMouse
DtThemeBackground {
backgroundColor: closeButtonArea.containsPress ? Platform.GlobalTheme.kErrorClick :
Platform.GlobalTheme.kErrorNormal
radius: Platform.GlobalTheme.kRadiusMin
anchors.fill: parent
visible: parent.containsMouse
Tooltip {
anchors.fill: parent
mainText: qsTr("Close")
posFollowCursor: true
}
}
Icon {
anchors.centerIn: parent
width: 16
height: width
mode: parent.containsMouse ? Icon.Highlight : Icon.AutoHighlight
source: "window-close-symbolic"
}
onClicked: {
UkuiTaskManager.TaskManager.activateWindowView([]);
UkuiTaskManager.TaskManager.execSpecifiedAction(UkuiTaskManager.Action.Close, modelData);
}
}
}
VideoPlayerThumbnail {
id: windowThumbnail
Layout.alignment: Qt.AlignHCenter
Layout.margins: thumbnailMargin
Layout.preferredWidth: isHorizontal ? itemWidth : viewLoader.preChildrenSize - layoutSpacing*2
Layout.preferredHeight: isHorizontal ? viewLoader.preChildrenSize - 48 : itemHeight
Layout.maximumHeight: maximumHeight - layoutSpacing * 3 - 24
Layout.maximumWidth: maximumWidth - layoutSpacing * 2
property real itemHeight
property real itemWidth
winId: windowVisible ? modelData : ""
playerData: windowThumbnailMprisModel
viewModel: view.model
// 视频预览图需要保证按钮显示完全
clip: false
onWinIdChanged: {
if (winId === "") {
return;
}
var itemGeometry = Platform.WindowManager.geometry(modelData);
if (isHorizontal) {
itemWidth = itemGeometry.width * ((viewLoader.preChildrenSize - 48) / itemGeometry.height);
} else {
itemHeight = itemGeometry.height * ((viewLoader.preChildrenSize - layoutSpacing*2) / itemGeometry.width);
}
}
}
}
}
}
}
}
ukui-panel/widgets/ukui-task-manager/qml/icon/ 0000775 0001750 0001750 00000000000 15167645100 020273 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/icon/ukui-start-symbolic.svg 0000775 0001750 0001750 00000001634 15167645100 024752 0 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/icon/ukui-end-symbolic-disable.svg 0000775 0001750 0001750 00000001667 15167645100 025772 0 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/icon/ukui-start-symbolic-disable.svg 0000775 0001750 0001750 00000001634 15167645100 026353 0 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/icon/ukui-end-symbolic.svg 0000775 0001750 0001750 00000001667 15167645100 024371 0 ustar feng feng ukui-panel/widgets/ukui-task-manager/qml/AppIcon.qml 0000664 0001750 0001750 00000020411 15167645111 021407 0 ustar feng feng /*
*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: qiqi49
*
*/
import QtQuick 2.12
import QtQuick.Layouts 1.12
import Qt5Compat.GraphicalEffects
import org.ukui.quick.items 1.0 as UkuiItems
import org.ukui.quick.platform 1.0 as Platform
import org.ukui.panel.taskManager 1.0 as UkuiTaskManager
Item {
property alias appIcon: icon
property alias appBackgroud: backgroud
property bool isOpenGL: true
property real ratio: 1
property int inset: 4 * ratio // background与控件的边距
function updateIconGeometry(winIdList) {
Platform.WindowManager.setMinimizedGeometry(winIdList, backgroud);
}
Timer {
id: iconDragTimer
interval: 100
onTriggered: {
if (iconDropArea.containsDrag) {
updateIconGeometry(taskItemData.CurrentWinIdList);
if (taskItemData.CurrentWinIdList[0] !== "") {
UkuiTaskManager.TaskManager.activateWindow(taskItemData.CurrentWinIdList[0])
taskManager.hidethumbnail();
}
}
}
}
DropArea {
id: iconDropArea
anchors.fill: parent
enabled: UkuiTaskManager.TaskManager.enableDragToApp
function showTooltipIfNeeded() {
if (tooltip.active && iconDropArea.containsDrag && taskItemData.CurrentWinIdList.length < 2) {
tooltip.showTooltip();
}
}
onContainsDragChanged: showTooltipIfNeeded() //实现拖拽到未打开的固定图标上，显示tooltip
onEntered: (dragEvent) => {
// 表示图标内部是否接收到了拖拽事件（功能: 拖拽文件到已打开的应用图标上，有三态显示并进行激活窗口操作）
if (taskItemListRoot.dragEventSource(dragEvent) !== "DropToAppIcon") {
dragEvent.accepted = false;
return;
}
if (taskItemData.CurrentWinIdList.length === 1) {
iconDragTimer.restart();
} else {
mouseArea.aboutToShowThumbnailView(true, thumbnailData, mouseArea)
}
}
onPositionChanged: {
// 拖拽到固定未打开的图标上，鼠标标识为禁用状态
if (taskItemData.CurrentWinIdList.length < 1) {
drag.accepted = false;
}
}
onExited: {
iconDragTimer.stop();
tooltip.hideTooltip();
taskItemListRoot.requestThumbnailView(false, thumbnailData, mouseArea)
}
}
UkuiItems.Tooltip {
id: tooltip
anchors.fill: parent
mainText: taskItemData.Name
posFollowCursor: false
// 固定在任务栏的应用显示tooltip (taskItemData.CurrentWinIdList.length < 1)
// 接收拖拽文件的图标显示tooltip (iconDropArea.containsDrag)
active: iconDropArea.containsDrag ? true : taskItemData.CurrentWinIdList ? taskItemData.CurrentWinIdList.length < 1 : false
onActiveChanged: iconDropArea.showTooltipIfNeeded() // 用于在有拖拽事件，并且只有一个打开窗口时的情况
location: {
switch(Widget.container.position) {
case UkuiItems.Types.Bottom:
return UkuiItems.Dialog.BottomEdge;
case UkuiItems.Types.Left:
return UkuiItems.Dialog.LeftEdge;
case UkuiItems.Types.Top:
return UkuiItems.Dialog.TopEdge;
case UkuiItems.Types.Right:
return UkuiItems.Dialog.RightEdge;
}
}
margin: 8
}
UkuiItems.DtThemeBackground {
id: backgroud
Accessible.role: Accessible.Button
Accessible.description: "This is task manager button of ukui-panel"
Accessible.name: taskItemData.Id
anchors.fill: parent
anchors {
leftMargin: isHorizontal? 0 : inset
topMargin: isHorizontal? inset : 0
rightMargin: isHorizontal? 0 : inset
bottomMargin: isHorizontal? inset : 0
}
useStyleTransparency: false
// id: mouseArea --> TaskManager.qml
backgroundColor: iconDropArea.containsDrag ? Platform.GlobalTheme.kComponentAlphaHover :
mouseArea.containsPress ? Platform.GlobalTheme.kComponentAlphaClick :
mouseArea.containsMouse ? Platform.GlobalTheme.kComponentAlphaHover : Platform.GlobalTheme.kContainGeneralAlphaNormal
radius: Platform.GlobalTheme.kRadiusNormal
Rectangle {
id: demandsAttention
anchors.fill: parent
color: "#FF9100"
z: -1
radius: backgroud.radius
visible: taskItemData.DemandsAttentionWinIdList ? (taskItemData.DemandsAttentionWinIdList.length > 0) : false
NumberAnimation on opacity {
running: demandsAttention.visible
loops: 4
from: 0.25
to: 0.6
duration: 450
}
}
UkuiItems.Icon {
id: icon
anchors.margins: inset
anchors.fill: parent
Behavior on scale {
NumberAnimation { duration: 100 }
}
}
Loader {
anchors.right: icon.right
anchors.rightMargin: -3
anchors.top: icon.top
anchors.topMargin: -3
active: taskItemData.UnreadMessagesNum > 0
sourceComponent: Rectangle {
id: unreadMessagesBase
height: icon.height / 2
width: height + additionalWidth
radius: height / 2
property int additionalWidth: {
if (taskItemData.UnreadMessagesNum < 10) {
return 0;
} else if (taskItemData.UnreadMessagesNum < 100){
return 6;
} else {
return 12;
}
}
color: Platform.GlobalTheme.kErrorNormal.pureColor
layer.enabled: isOpenCV
layer.effect: DropShadow {
radius: 2
samples: 5
color: Platform.GlobalTheme.kGrayAlpha10.pureColor
}
UkuiItems.DtThemeText {
id: unreadMessagesNum
anchors.fill: parent
horizontalAlignment: Text.AlignHCenter
verticalAlignment: Text.AlignVCenter
textColor: Platform.GlobalTheme.kFontWhite
pointSizeOffset: -2
font.pixelSize: unreadMessagesBase.height * 5 / 8 //按设计稿比例设置固定字体大小
text: {
if (taskItemData.UnreadMessagesNum < 100) {
return taskItemData.UnreadMessagesNum;
} else {
return "99+"
}
}
}
}
}
}
UkuiItems.DtThemeBackground {
height: 4 * ratio
width: taskItemData.CurrentWinIdList ? Math.min(taskItemData.CurrentWinIdList.length * 8 * ratio, 16 * ratio) : 16
radius: 2 * ratio
anchors.verticalCenter: backgroud.bottom
anchors.horizontalCenter: parent.horizontalCenter
useStyleTransparency: false
backgroundColor: taskItemData.HasActiveWindow? Platform.GlobalTheme.kBrandNormal : Platform.GlobalTheme.kGrayAlpha9
Behavior on width {
NumberAnimation { duration: 200 }
}
}
}
ukui-panel/widgets/ukui-task-manager/qml/TaskManagerBase.qml 0000664 0001750 0001750 00000105631 15167645111 023056 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: qiqi49
* hxf
*
*/
import QtQml 2.15
import QtQuick 2.15
import QtQml.Models 2.15
import org.ukui.quick.widgets 1.0
import org.ukui.panel.taskManager 1.0 as UkuiTaskManager
import org.ukui.quick.items 1.0 as Items
import org.ukui.quick.platform 1.0 as Platform
DropArea {
id: taskItemListRoot
property real ratio: 1
property var dragedObj: null
property alias view: taskItemView
property alias viewModel: taskItemProxyModel
property bool taskManagerActived: false
property bool isTaskMenuShow: false
property bool isDragging: false
property int resetItemsIndex: -1
// 请求显示预览图
signal requestThumbnailView(bool show, TaskItemData data, Item mouseArea)
UkuiTaskManager.TaskManagerFilterModel {
id: taskItemProxyModel
screen: Widget.container.screen
}
Component {
id: taskIconComponent
Items.Icon {}
}
DelegateModel {
id: taskItemDelegateModel
property var dragedObject: null
/**
* 删除临时Item
*/
function removeTempItems() {
for (let i = tempItems.count - 1; i >= 0; --i) {
const obj = tempItems.get(i);
obj.groups = [tempItems.name];
tempItems.remove(i);
}
}
/**
* 将对应itemsIndex的项，存在persistedItems组中，并从界面移除
* @param itemsIndex
*/
function removeVisualItem(itemsIndex) {
if (itemsIndex < 0 || itemsIndex >= taskItemView.count) {
return;
}
// 将被拖拽的项添加到持久化组中, 如果在items组中, 那么从可见列表移除
items.get(itemsIndex).groups = [persistedItems.name];
}
/**
* 将存起来的Item全部归位，并从persistedItems组中移除
*/
function resetPersistedItems() {
if (persistedItems.count > 0) {
let i = persistedItems.count - 1;
for (; i >= 0; --i) {
const persistedItemObj = persistedItems.get(i);
if (!persistedItemObj.inItems) {
// TODO: listview中的数据往前挪可以同步缓存位置，往后挪则位置不会变，需要把临时Item最后出现的位置记下来
let tmpItemsIndex = tempItems.get(0).itemsIndex;
persistedItems.addGroups(i, 1, [items.name]);
items.move(persistedItemObj.itemsIndex, tmpItemsIndex, 1);
}
persistedItems.remove(i, 1);
}
}
dragedObject = null;
removeTempItems();
}
// 临时生成的用于定位拖拽落点的Items组
groups: [
DelegateModelGroup { id: tempItems; name: "tempItems" }
]
model: taskItemProxyModel
delegate: Item {
id: taskItemRoot
property int dragStartIndex: -1
property var icon: model.Icon
property bool isDragStatus: false
property bool useSingleItem: taskItemView.isMergeStatus || (CurrentWinIdList ? CurrentWinIdList.length < 1 : true)
//非合并状态下激活预览图时 对应的winId
property var singleWinId: []
property bool iconNeedsUpdate: true
// 三岛状态下，是否已切换为小插件样式
property bool quickWidgetLoaded: false
property bool isItemActived: model.DemandsAttentionWinIdList ? (model.DemandsAttentionWinIdList.length !== 0) : false
width: taskItemLoader.width
height: taskItemLoader.height
visible: !DelegateModel.inPersistedItems
onIsItemActivedChanged: {
taskItemView.updateActivedItem(isItemActived);
}
onIconChanged: {
iconNeedsUpdate = true;
}
function generateDragImage() {
let icon = taskIconComponent.createObject(this, {width: taskItemView.taskItemSize, height: taskItemView.taskItemSize});
if (icon !== null) {
icon.addUnifiedIconBox = true
icon.source = model.Icon
icon.grabToImage(function (result) {
taskItemRoot.Drag.imageSource = result.url;
icon.destroy();
});
icon.visible = false
}
}
// 拖拽设置, 手动开启拖拽
Drag.dragType: Drag.None
Drag.hotSpot: Qt.point(taskItemView.taskItemSize/2, taskItemView.taskItemSize/2)
// 处理拖拽完成信号
Drag.onDragFinished: function (dropAction) {
taskItemListRoot.isDragging = false;
// 拖拽被取消，仅处理内部拖拽
if (taskItemDelegateModel.persistedItems.count > 0) {
let i = taskItemDelegateModel.persistedItems.count - 1;
for (; i >= 0; --i) {
const persistedItemObj = taskItemDelegateModel.persistedItems.get(i);
if (!persistedItemObj.inItems) {
// TODO: listview中的数据往前挪可以同步缓存位置，往后挪则位置不会变，需要把临时Item最后出现的位置记下来
persistedItemObj.groups = [taskItemDelegateModel.items.name];
}
}
}
taskItemRoot.isDragStatus = false;
}
function startDrag() {
// 存起来的被拖拽项目和临时生成的项目都不允许被拖动
if (!DelegateModel.inItems || DelegateModel.inPersistedItems || DelegateModel.inTempItems) {
return;
}
const delegateModel = DelegateModel.model;
const itemsIndex = DelegateModel.itemsIndex;
dragStartIndex = itemsIndex;
// 当前拖拽对象
delegateModel.dragedObject = delegateModel.items.get(itemsIndex);
taskItemDelegateModel.removeVisualItem(itemsIndex);
taskItemRoot.isDragStatus = true;
const modelIndex = delegateModel.dragedObject.model.index;
Drag.mimeData = {
"text/plain": '{"dragStartIndex":' + dragStartIndex + ',"modelIndex":' + modelIndex + '}'
};
Drag.active = true;
// 不同的Action鼠标光标不同
Drag.startDrag(Qt.MoveAction);
}
MouseArea {
id: mouseArea
x: 0; y: 0
width: parent.width; height: parent.height
hoverEnabled: !UkuiTaskManager.TaskManager.disableMouseHover
acceptedButtons: {
let button = Qt.NoButton;
if (!UkuiTaskManager.TaskManager.disableMouseLeftButton) {
button |= Qt.LeftButton
}
if (!UkuiTaskManager.TaskManager.disableMouseRightButton) {
button |= Qt.RightButton
}
return button;
}
property int lastIndex: -1
property string currentWid: ""
function activeWinId(winId) {
if (UkuiTaskManager.TaskManager.windowIsActivated(winId)) {
UkuiTaskManager.TaskManager.execSpecifiedAction(UkuiTaskManager.Action.Minimize, winId);
} else {
UkuiTaskManager.TaskManager.activateWindow(winId);
}
}
function aboutToShowThumbnailView(isShow, data, item) {
// 设置预览图窗口信息
// 在非合并状态下，由loader里的item触发request信号和参数
data.currentTaskItem = item;
taskItemListRoot.requestThumbnailView(isShow, data, item);
}
// 为拖拽截图
onPressed: {
if (iconNeedsUpdate) {
parent.generateDragImage();
iconNeedsUpdate = false;
}
}
drag.target: mouseArea
drag.onActiveChanged: {
taskItemListRoot.requestThumbnailView(false, null, mouseArea);
if (drag.active) {
taskItemListRoot.isDragging = true;
taskItemRoot.startDrag();
} else {
mouseArea.x = 0;
mouseArea.y = 0;
}
}
onClicked: (mouse) => {
if (mouse.button === Qt.RightButton) {
taskItemProxyModel.openMenu(false, model.Actions, taskItemView);
taskManagerActived = true;
isTaskMenuShow = true;
} else {
if (CurrentWinIdList.length === 0) {
taskItemDelegateModel.model.launch(taskItemDelegateModel.model.index(model.index, 0), taskItemRoot);
return;
}
let index = -1;
if (taskItemView.isMergeStatus) {
// 轮转
if (currentWid !== "") {
index = CurrentWinIdList.indexOf(currentWid);
if (index < (CurrentWinIdList.length - 1)) {
++index;
} else {
index = 0;
}
}
} else {
// 由taskList实现
index = taskItemLoader.item.indexAt(mouseX, mouseY);
}
if (index < 0) {
index = 0;
} else if (index >= CurrentWinIdList.length) {
index = CurrentWinIdList.length - 1;
}
currentWid = CurrentWinIdList[index];
/**
* 鼠标点击，更新窗口最小化和激活动画。
*/
updateIconGeometry(currentWid);
activeWinId(currentWid);
}
taskManager.hidethumbnail();
}
onEntered: {
if (CurrentWinIdList !== undefined && CurrentWinIdList.length > 0 && !taskItemRoot.quickWidgetLoaded) {
if (taskItemView.isMergeStatus) {
mouseArea.aboutToShowThumbnailView(true, thumbnailData, mouseArea);
}
}
}
onExited: {
taskItemListRoot.requestThumbnailView(false, thumbnailData, mouseArea);
pluginButtonLoader.active = false;
}
TaskItemData {
id: thumbnailData
windowIdList: model.CurrentWinIdList
windowIcons: model.WindowIcons
windowIconsName: model.WindowIconsName
windowTitles: model.WindowTitles
}
Loader {
id: taskItemLoader
property var taskItemData: model
property var thumbnailData: thumbnailData
sourceComponent: {
if (taskItemRoot.DelegateModel.inTempItems) {
return tempTaskitem;
}
if (taskItemRoot.useSingleItem) {
if (taskItemRoot.quickWidgetLoaded) {
return quickWidgetItem;
} else {
return singleTaskItem;
}
} else {
return listTaskItem;
}
}
}
Component {
id: tempTaskitem
Item {
width: taskItemView.taskItemSize
height: taskItemView.taskItemSize
}
}
// 非合并状态 图标+名称
Component {
id: listTaskItem
AppList {
height: childrenRect.height
width: childrenRect.width
itemSize: taskItemView.taskItemSize
isHorizontal: taskItemView.orientation === ListView.Horizontal
spacing: taskItemView.spacing
model: taskItemData.CurrentWinIdList
ratio: taskItemListRoot.ratio
iconIndexAboutToBeScaled: {
if (mouseArea.containsPress) {
return indexAt(mouseArea.mouseX, mouseArea.mouseY);
}
return -1;
}
}
}
Component {
id: singleTaskItem
AppIcon {
// 在任务栏横向的时候，单个图标的三态区域上下边距为4，左右边距为8。两方不一致，需要特殊处理。
// 并且在设计稿最新改动中（2025.9.19），各个插件的间距也为8，所以作为首项item不能留有左右的两边的间距。
// 任务栏竖向的时候，同理。
width: isHorizontal ? (taskItemView.taskItemSize - inset * 2) : taskItemView.taskItemSize
height: isHorizontal ? taskItemView.taskItemSize : (taskItemView.taskItemSize - inset * 2)
appIcon.source: taskItemData.IconName === "" ? taskItemData.Icon : taskItemData.IconName
appIcon.addUnifiedIconBox: true
appIcon.scale: mouseArea.containsPress ? 0.8 : 1.0
ratio: taskItemListRoot.ratio
}
}
Component {
id: quickWidgetItem
Item {
height: taskItemView.taskItemSize
width: quickWidget.preferredWidth + margins * 2
property int margins: 4 * taskItemListRoot.ratio
UkuiTaskManager.WidgetDelegate {
id: quickWidget
anchors.fill: parent
anchors.margins: parent.margins
quickWidgetId: taskItemData.QuickWidgetId
}
function updateIconGeometry(winIdList) {
Platform.WindowManager.setMinimizedGeometry(winIdList, this);
}
}
}
/**
* 三岛任务栏小插件切换按钮,相关属性：taskItemRoot.quickWidgetLoaded
*/
property bool hasQuickWidgetId: model.QuickWidgetId !== "" && model.QuickWidgetId !== undefined && root.isIslandMode
onHasQuickWidgetIdChanged: {
if (hasQuickWidgetId) {
quickWidgetTimer.createObject(mouseArea);
}
}
Component {
id: quickWidgetTimer
Timer {
interval: 1000
running: mouseArea.containsMouse
onTriggered: {
pluginButtonLoader.active = true;
}
}
}
Loader {
id: pluginButtonLoader
anchors.top: mouseArea.top
anchors.topMargin: 1
anchors.right: mouseArea.right
anchors.rightMargin: 1
active: false
sourceComponent: pluginButton
}
Component {
id: pluginButton
Items.DtThemeBackground {
width: 20; height: width
radius: width / 2
useStyleTransparency: false
backgroundColor: mousearea.containsPress ? Platform.GlobalTheme.kGray7 :
mousearea.containsMouse ? Platform.GlobalTheme.kGray6 :
Platform.GlobalTheme.kContainSecondaryNormal
MouseArea {
id:mousearea
anchors.fill: parent
hoverEnabled: true
onClicked: {
taskItemRoot.quickWidgetLoaded = !taskItemRoot.quickWidgetLoaded;
taskManager.hidethumbnail();
}
}
Items.Icon {
anchors.fill: parent
anchors.margins: 2
source: taskItemRoot.quickWidgetLoaded ?
"://org.ukui.panel.taskManager/qml/icons/back.svg" : "://org.ukui.panel.taskManager/qml/icons/to.svg"
}
}
}
}
/**
* iconGeometry功能
*/
property var currentWinIdList: model.CurrentWinIdList
property var hasActiveWindow: model.HasActiveWindow
property int itemIndex: DelegateModel.itemsIndex
property bool invisibleOfFront: (x < taskItemView.contentX) || (y < taskItemView.contentY)
property bool invisibleOfBack: (x > taskItemView.width + taskItemView.contentX) || (y > taskItemView.height + taskItemView.contentY)
// 调用setMinimizedGeometry接口，默认参数为CurrentScreenWinIdList
function updateIconGeometry(winIdList = CurrentScreenWinIdList) {
if (taskItemLoader.item && !taskItemRoot.DelegateModel.inTempItems) {
if (invisibleOfFront) {
Platform.WindowManager.setMinimizedGeometry(winIdList, virtualFrontItem);
} else if (invisibleOfBack) {
Platform.WindowManager.setMinimizedGeometry(winIdList, virtualBackItem);
} else {
taskItemLoader.item.updateIconGeometry(winIdList);
}
}
}
function addIndexToGeometryList() {
if (model.CurrentScreenWinIdList) {
// 在 *所在屏幕* 的位置，添加最小化动画
// Note: 图标Click后，会在点击所对应的位置，进行最小化动画
if (model.CurrentScreenWinIdList.length > 0 && !taskItemView.pendingUpdatesList.includes(itemIndex)) {
taskItemView.pendingUpdatesList.push(itemIndex);
updateGeometryList.restart();
}
}
}
Component.onCompleted: {
//初始化、拖拽后更新model、切换任务栏方向，都会触发
addIndexToGeometryList();
}
Component.onDestruction: {
if (isItemActived) {
taskItemView.updateActivedItem(false);
}
}
onCurrentWinIdListChanged: {
addIndexToGeometryList();
}
// 激活窗口后，在窗口 *对应屏幕* 上进行最小化动画
onHasActiveWindowChanged: {
if (HasActiveWindow && model.CurrentScreenWinIdList.length > 0) {
updateIconGeometry();
}
}
Behavior on width {
// 主要提供三岛小插件切换的动画
enabled: root.isIslandMode
NumberAnimation {
duration: 150
easing.type: Easing.OutQuad
}
}
}
}
ListView {
id: taskItemView
// view的宽高 在main的view.width view.height中定义
property bool windowVisible: false
property bool isMergeStatus: {
var status = Widget.globalConfig.mergeIcons;
return (status === undefined) || (status === 0) ;
}
property bool isHorizontal: Widget.orientation === Items.Types.Horizontal
property real taskItemSize: 48
property int activedItem: 0
interactive: false
// flickDeceleration： filck减速速率，默认为1500。
// 调整减速速率，达到在翻页时，以较快速度进行滑动。
// boundsMovement: Flickable.StopAtBounds 设置此属性会偶现切换方向后，contentX和ContentY出现异常导致内部不显示的问题
flickDeceleration: 10000
spacing: 0
model: taskItemDelegateModel
cacheBuffer: taskItemView.isHorizontal ? Math.max(0, contentWidth) : Math.max(0, contentHeight)
// 使用delayed属性，避免方向切换时，taskItemSize立即更新，导致过程中数值错误
Binding {
target: taskItemView
property: "taskItemSize"
value: isHorizontal ? taskItemListRoot.parent.height : taskItemListRoot.parent.width
delayed: true
}
onTaskItemSizeChanged: {
if (contentX !== 0 || contentY !== 0) {
positionViewAtBeginning();
}
pushAllIndex();
}
onIsMergeStatusChanged: {
pushAllIndex();
}
onWindowVisibleChanged: {
if(Platform.WindowManager.isWaylandSession) {
pushAllIndex();
}
}
onContentXChanged: {
pushAllIndex();
}
onContentYChanged: {
pushAllIndex();
}
onIsHorizontalChanged: {
// 重置滚动位置
positionViewAtBeginning();
orientation = isHorizontal ? ListView.Horizontal : ListView.Vertical;
}
function updateActivedItem(isActived) {
taskItemView.activedItem = isActived ? taskItemView.activedItem + 1 : Math.max(taskItemView.activedItem - 1, 0);
taskManagerActived = taskItemView.activedItem > 0;
}
function updateIconState() {
for (let i = 0; i < taskItemDelegateModel.count; ++i) {
taskItemView.itemAtIndex(i).iconNeedsUpdate = true;
}
}
Component.onCompleted: {
orientation = isHorizontal ? ListView.Horizontal : ListView.Vertical;
Platform.Theme.iconThemeChanged.connect(updateIconState);
if (Widget.globalConfig.mergeIcons === undefined) {
Widget.globalConfig.mergeIcons = 0;
}
}
/**
* iconGeometry
*/
property var pendingUpdatesList: []
Connections {
target: Widget.container
function onPositionChanged() {
taskItemView.pushAllIndex();
}
}
function pushAllIndex() {
pendingUpdatesList.length = 0;
for (var i = 0; i < taskItemView.count; ++i) {
pendingUpdatesList.push(i);
}
if (pendingUpdatesList.length > 0) {
updateGeometryList.restart();
}
}
Timer {
id: updateGeometryList
interval: 500
onTriggered: {
for (let i = 0; i < taskItemView.pendingUpdatesList.length; ++i) {
let index = taskItemView.pendingUpdatesList[i];
let item = taskItemView.itemAtIndex(index);
if (item) {
item.updateIconGeometry();
}
}
taskItemView.pendingUpdatesList.length = 0;
}
}
Item {
id: virtualFrontItem
x: 0; y: 0
width: 10
height: 10
}
Item {
id: virtualBackItem
x: taskItemView.width - width; y: taskItemView.height - height
width: 10
height: 10
}
displaced: Transition {
NumberAnimation {
properties: "x,y"
easing.type: Easing.OutQuad
duration: 300
}
}
move: Transition {
NumberAnimation { properties: "x,y"; duration: 300 }
}
add: Transition {
NumberAnimation {
id: addAnimation
property: taskItemView.isHorizontal ? "y" : "x"
from: (Widget.container.position === Items.Types.Left) || (Widget.container.position === Items.Types.Top) ? -taskItemView.taskItemSize : taskItemView.taskItemSize
to: 0
easing.type: Easing.OutCubic
duration: 300
}
}
remove: Transition {
NumberAnimation {
id: removeAnimation
property: addAnimation.property
easing.type: Easing.OutCubic
from: 0; to: addAnimation.from
duration: 300
}
}
}
// 获取ListView的坐标对应的ContentItem内部坐标
// listview与dropArea的大小需要重合
function getContentPoint(localX, localY) {
return Qt.point(localX + taskItemView.contentX, localY + taskItemView.contentY);
}
/**
* 事件来源判断
* 内部事件: 任务栏内部拖拽换位--"InternalEvent"
* 外部事件: 从开始菜单或桌面，固定到任务栏--"PinToTaskbar"
* 从桌面、文件管理器，拖到任务栏可打开应用图标上 --"DropToAppIcon" (enableDragToApp需为true)
* 无效事件: "InvalidEvent"
*/
property string panelDragEvent: "InvalidEvent"
function dragEventSource(event) {
if (taskItemDelegateModel.dragedObject !== null) {
return "InternalEvent";
}
let source = event.getDataAsString("source");
if (source === "ukui-menu") {
let url = event.getDataAsString("url");
return url.startsWith("app://") ? "PinToTaskbar" : "InvalidEvent";
}
if (UkuiTaskManager.TaskManager.enableDragToApp) {
if (event.urls && event.urls.length > 0) {
return "DropToAppIcon";
}
}
return "InvalidEvent";
}
// 获取一个Item的中点坐标
function getItemMidPoint(item) {
return Qt.point(item.x + item.width/2, item.y + item.height/2);
}
// point 是否在item的中点前
function beforeMidpoint(item, point) {
let midPoint = getItemMidPoint(item);
if (taskItemView.orientation === ListView.Horizontal) {
return point.x < midPoint.x;
} else {
return point.y < midPoint.y
}
}
// 1.拖拽进入事件
// 拖拽进入，需要生成临时Item
onEntered: (dragEvent) => {
// 1.处理进入拖拽区域时的边缘点情况，避免丢失拖拽事件
let enterX = dragEvent.x === width ? dragEvent.x - 1 : dragEvent.x;
let enterY = dragEvent.y === height ? dragEvent.y - 1 : dragEvent.y;
const contentPoint = getContentPoint(enterX, enterY);
// 2.删除上次未删除的临时Item,保证只有一个临时Item
if (tempItems.count > 0) {
taskItemDelegateModel.removeTempItems();
}
// 3.获取进入点下方的Item, 如果为null，则说明拖拽到了空白位置
let insertIndex = -1;
let pointItem = taskItemView.itemAt(contentPoint.x, contentPoint.y);
if (pointItem !== null) {
// 4.通过进入点的对象的itemsIndex获取各种数据。
insertIndex = pointItem.DelegateModel.itemsIndex;
// 判断中点位置，确定在插入在前还是后，insertIndex or insertIndex+1
const maxIdx = taskItemDelegateModel.items.count - 1;
if ((insertIndex > 0) && (insertIndex < maxIdx) && beforeMidpoint(pointItem, contentPoint)) {
++insertIndex;
}
} else {
// 5.拖拽进入点是空白区域
insertIndex = taskItemDelegateModel.items.count;
}
/**
* 4.判断事件来源
* 区分拖拽事件的来源，一般有两个来源：
* 1.内部拖拽事件，拖拽listview的Item进行位置的调整。
* 2.外部事件，将桌面图标拖拽到任务栏上。
*/
const eventType = dragEventSource(dragEvent);
panelDragEvent = eventType;
if (eventType === "InvalidEvent") {
dragEvent.accepted = false;
return;
} else if (eventType === "PinToTaskbar") {
let id = dragEvent.getDataAsString("url").slice(6);
let itemsIndex = -1;
// 判断任务栏是否已经有同id图标
for (var i = 0; i < taskItemView.count; ++i) {
if (taskItemDelegateModel.items.get(i).model.Id === id) {
itemsIndex = taskItemDelegateModel.items.get(i).itemsIndex;
resetItemsIndex = itemsIndex;
}
}
taskItemDelegateModel.removeVisualItem(itemsIndex);
} else if (eventType === "DropToAppIcon" && UkuiTaskManager.TaskManager.enableDragToApp) {
dragEvent.accepted = false;
return;
}
// 5.创建临时Item，并将他放到tempItems组中，后续可通过该组删除它
if (insertIndex < 0) {
insertIndex = 0;
} else if (insertIndex > taskItemDelegateModel.items.count) {
insertIndex = taskItemDelegateModel.items.count;
}
taskItemDelegateModel.items.insert(
insertIndex,
{
Name: ""
},
[taskItemDelegateModel.items.name, "tempItems"]
);
}
// 2.拖拽移出事件
onExited: {
taskItemDelegateModel.removeTempItems();
if (panelDragEvent === "PinToTaskbar") {
// 外部拖拽退出后，任务栏已有图标返回原来位置
let i = taskItemDelegateModel.persistedItems.count - 1;
for (; i >= 0; --i) {
const persistedItemObj = taskItemDelegateModel.persistedItems.get(i);
if (!persistedItemObj.inItems) {
persistedItemObj.groups = [taskItemDelegateModel.items.name];
if (resetItemsIndex !== -1) {
taskItemDelegateModel.items.move(persistedItemObj.itemsIndex, resetItemsIndex, 1);
}
}
}
resetItemsIndex = -1;
}
}
// 3.拖拽移动事件
onPositionChanged: (dragEvent) => {
if (tempItems.count === 1) {
// 落点
let currentPoint = getContentPoint(dragEvent.x, dragEvent.y);
let targetItem = taskItemView.itemAt(currentPoint.x, currentPoint.y);
if (targetItem !== null && !targetItem.DelegateModel.inTempItems) {
let sourceIndex = tempItems.get(0).itemsIndex;
let targetIndex = targetItem.DelegateModel.itemsIndex;
const bmp = beforeMidpoint(targetItem, currentPoint);
if ((sourceIndex < targetIndex) && bmp) {
--targetIndex;
} else if ((sourceIndex > targetIndex) && !bmp) {
++targetIndex;
}
let moveCount = Math.abs(targetIndex - sourceIndex);
if (moveCount === 0) {
return;
}
if (sourceIndex < targetIndex) {
taskItemDelegateModel.items.move(sourceIndex + 1, sourceIndex, moveCount);
} else {
taskItemDelegateModel.items.move(targetIndex, targetIndex + 1, moveCount);
}
}
}
}
// 4.拖拽放下事件
onDropped: (dragEvent) => {
// 1.获取丢下点的Index
let droppedIndex = -1;
if (tempItems.count > 0) {
// 默认情况下临时Item对应的位置就是丢下的位置
let tempObj = tempItems.get(0);
droppedIndex = tempObj.inItems ? tempObj.itemsIndex : taskItemDelegateModel.items.count;
} else {
// 修正边缘落点情况
let enterX = dragEvent.x === width ? dragEvent.x - 1 : dragEvent.x;
let enterY = dragEvent.y === height ? dragEvent.y - 1 : dragEvent.y;
let contentPoint = getContentPoint(enterX, enterY);
let dropTargetItem = taskItemView.itemAt(contentPoint.x, contentPoint.y);
droppedIndex = (dropTargetItem === null) ? taskItemDelegateModel.items.count : dropTargetItem.DelegateModel.itemsIndex;
}
// 2.将存起来的Item全部归位，并清空临时对象
let eventType = dragEventSource(dragEvent);
taskItemDelegateModel.resetPersistedItems();
// 3.事件类型
if (eventType === "InternalEvent") {
const obj = JSON.parse(dragEvent.text);
if (obj !== null) {
taskItemProxyModel.setOrder(taskItemDelegateModel.model.index(obj.modelIndex, 0), droppedIndex);
}
} else if (eventType === "PinToTaskbar") {
// 外部事件，执行外部操作
let id = dragEvent.getDataAsString("url").slice(6);
taskItemProxyModel.addQuickLauncher(id, droppedIndex);
}
taskItemListRoot.isDragging = false;
panelDragEvent = "InvalidEvent";
}
}
ukui-panel/widgets/ukui-task-manager/utils.cpp 0000664 0001750 0001750 00000003460 15167645100 020421 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#include "utils.h"
#include
#include "window-manager.h"
static UkuiSearch::ApplicationInfo *applicationInfo = nullptr;
static std::once_flag flag;
UkuiSearch::ApplicationInfo *Utils::getApplicationInfo()
{
std::call_once(flag, [ & ] {
applicationInfo = new UkuiSearch::ApplicationInfo();
});
return applicationInfo;
}
QString Utils::desktopFileFromPid(uint pid)
{
QString desktopFile;
getApplicationInfo()->tranPidToDesktopFp(pid, desktopFile);
return desktopFile;
}
QString Utils::desktopFileFromWid(const QString &wid)
{
QString desktopFile;
getApplicationInfo()->desktopFilePathFromName(UkuiQuick::WindowManager::appId(wid), desktopFile);
if(desktopFile.isEmpty()) {
getApplicationInfo()->tranPidToDesktopFp(UkuiQuick::WindowManager::pid(wid),desktopFile);
}
return desktopFile;
}
QString Utils::desktopFilePathFromName(const QString&name)
{
QString desktopFile;
getApplicationInfo()->desktopFilePathFromName(name, desktopFile);
return desktopFile;
}
ukui-panel/widgets/ukui-task-manager/plugin/ 0000775 0001750 0001750 00000000000 15167645100 020050 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/plugin/qml/ 0000775 0001750 0001750 00000000000 15167645111 020643 5 ustar feng feng ukui-panel/widgets/ukui-task-manager/plugin/qml/main.qml 0000664 0001750 0001750 00000025156 15167645111 022313 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: qiqi49
* hxf
*
*/
import QtQuick 2.12
import QtQuick.Layouts 1.12
import org.ukui.quick.widgets 1.0
import org.ukui.quick.items 1.0
import org.ukui.quick.platform 1.0
import org.ukui.panel.taskManager 1.0 as UkuiTaskManager
WidgetItem {
id: root
Layout.objectName: "layout"
property bool isHorizontal: Widget.orientation === Types.Horizontal
property int maxLength: {
if (isHorizontal) {
if (parent.Layout.maximumWidth > 0) {
return parent.Layout.maximumWidth;
} else {
if (parent.width > 0) {
return parent.width;
} else {
return height + buttonBase.width;
}
}
} else {
return parent.Layout.maximumHeight ? parent.Layout.maximumHeight : parent.height;
}
}
property bool isIntervactive: {
if (isHorizontal) {
return taskManagerView.view.contentWidth > maxLength;
} else {
return taskManagerView.view.contentHeight > maxLength;
}
}
property real ratio: parent.ratio ? parent.ratio : 1
property int spacing: parent ? (parent.ratio ? 8 * parent.ratio : 8) : 8
property bool isIslandMode: parent.isIslandMode ? parent.isIslandMode : false
Layout.fillWidth: !isHorizontal
Layout.fillHeight: isHorizontal
Layout.preferredWidth: isHorizontal ? childrenRect.width : width
Layout.preferredHeight: isHorizontal ? height : childrenRect.height
// 最小宽高：保证taskManager在滚动状态时，能够至少显示一个图标和翻页按钮
Layout.minimumWidth: isHorizontal ? Math.min((taskManagerView.view.contentWidth + taskManagerView.view.taskItemSize + spacing), (height + buttonBase.width)) : 0
onWidgetWindowChanged: {
if (widgetWindow) {
widgetWindow.onVisibleChanged.connect(updateWindowVisible);
}
}
function updateWindowVisible() {
taskManagerView.view.windowVisible = widgetWindow.visible;
}
function flickView(distance) {
// 计算轻弹速度
let velocity = Math.round(Math.sqrt(2 * Math.abs(distance) * taskManagerView.view.flickDeceleration));
// 确定轻弹方向
let direction = (distance > 0) ? 1 : -1
taskManagerView.view.maximumFlickVelocity = velocity;
if (isHorizontal) {
taskManagerView.view.flick(velocity * direction, 0);
} else {
taskManagerView.view.flick(0, velocity * direction);
}
}
// 向前滚动view，进行Overshoot时的处理
function flickViewForward(distance) {
// 想要滚动的距离，采取向上取整，避免剩余0.XX时还需要再进行翻页
let preDistance = Math.ceil(distance);
// 剩余的距离
let remainDistance = isHorizontal ? taskManagerView.view.contentX : taskManagerView.view.contentY;
if (preDistance < remainDistance) {
flickView(preDistance);
} else {
flickView(remainDistance + taskManagerView.viewOvershoot);
}
}
// 向后滚动view，进行Overshoot时的处理
function flickViewBackward(distance) {
// 想要滚动的距离，采取向上取整，避免剩余0.XX时还需要再进行翻页
let preDistance = Math.ceil(distance);
// 剩余的距离，采取向下取整，原因同上
let remainDistance = isHorizontal ? Math.max(0, taskManagerView.view.contentItem.childrenRect.width - taskManagerView.view.contentX - taskManagerView.view.width)
: Math.max(0, taskManagerView.view.contentItem.childrenRect.height - taskManagerView.view.contentY - taskManagerView.view.height);
remainDistance = Math.floor(remainDistance);
if (preDistance < remainDistance) {
flickView(preDistance * -1);
} else {
flickView((remainDistance + taskManagerView.viewOvershoot) * -1);
}
}
GridLayout {
id: gridLayout
width: isHorizontal ? (isIntervactive ? maxLength : taskManagerView.width) : parent.width
height: isHorizontal ? parent.height : (isIntervactive ? maxLength : taskManagerView.height)
columnSpacing: root.spacing
rowSpacing: root.spacing
columns: taskManagerView.view.isHorizontal ? 2 : 1
rows: taskManagerView.view.isHorizontal ? 1 : 2
// taskManager
MouseArea {
id: wheelArea
Layout.preferredWidth: isHorizontal ? taskManagerView.width : parent.width
Layout.preferredHeight: isHorizontal ? parent.height : taskManagerView.height
enabled: isIntervactive
onWheel: (wheel) => {
flickView(wheel.angleDelta.y);
}
UkuiTaskManager.TaskManagerView {
id: taskManagerView
// 三岛、经典模式下，taskManager.width都留出一个item的空白宽度，并且可以接受drop事件
property int visualWidth: isIntervactive ? childrenRect.width : childrenRect.width + view.taskItemSize + spacing
// 超长滚动时，内容可超过边界的距离
property int viewOvershoot: 120
width: isHorizontal ? visualWidth : parent.width
height: isHorizontal ? parent.height : childrenRect.height
ratio: root.ratio
view.clip: isIntervactive
view.spacing: root.spacing
view.width: {
if (isHorizontal) {
if (maxLength < view.contentItem.childrenRect.width) {
return maxLength - buttonBase.width - root.spacing;
} else {
return isIslandMode ? view.contentItem.childrenRect.width : maxLength;
}
} else {
return parent.width
}
}
view.height: {
if (isHorizontal) {
return parent.height
} else {
if (maxLength < view.contentItem.childrenRect.height) {
return maxLength - buttonBase.height - root.spacing
} else {
return isIslandMode ? view.contentItem.childrenRect.height : maxLength;
}
}
}
}
}
// 超长滚动按钮 按钮宽高比为 0.8
StyleBackground {
id: buttonBase
Layout.preferredHeight: isHorizontal ? (parent.height - spacing*2) : (buttonBase.width*0.8*2 + 1)
Layout.preferredWidth: isHorizontal ? (buttonBase.height*0.8*2 + 1) : (parent.width - spacing*2)
Layout.alignment: isHorizontal ? Qt.AlignVCenter : Qt.AlignHCenter
Layout.margins: 2
property int iconSize: isHorizontal ? (buttonBase.height / 2) : (buttonBase.width / 2)
paletteRole: Theme.Text
useStyleTransparency: false
alpha: 0.1
radius: 12
GridLayout {
anchors.fill: parent
rows: isHorizontal ? 1 : children.length
columns: isHorizontal ? children.length : 1
rowSpacing: 0
columnSpacing: 0
// 上一页
MouseArea {
Layout.fillHeight: true
Layout.fillWidth: true
property string iconEnabled: "://org.ukui.panel.taskManager/qml/icon/ukui-start-symbolic.svg"
property string iconDisabled: "://org.ukui.panel.taskManager/qml/icon/ukui-start-symbolic-disable.svg"
property bool isAtBeginning: isHorizontal ? taskManagerView.view.atXBeginning : taskManagerView.view.atYBeginning
onClicked: {
if (!isAtBeginning) {
flickViewForward(isHorizontal ? taskManagerView.view.width : taskManagerView.view.height);
}
}
Icon {
width: buttonBase.iconSize; height: width
anchors.centerIn: parent
mode: Icon.AutoHighlight
rotation: isHorizontal ? 0 : 90
source: parent.isAtBeginning ? parent.iconDisabled : parent.iconEnabled
}
}
StyleBackground {
Layout.fillHeight: isHorizontal
Layout.fillWidth: !isHorizontal
Layout.preferredHeight: 1
Layout.preferredWidth: 1
paletteRole: Theme.Text
useStyleTransparency: false
alpha: 0.15
}
// 下一页
MouseArea {
Layout.fillHeight: true
Layout.fillWidth: true
property string iconEnabled: "://org.ukui.panel.taskManager/qml/icon/ukui-end-symbolic.svg"
property string iconDisabled: "://org.ukui.panel.taskManager/qml/icon/ukui-end-symbolic-disable.svg"
property bool isAtEnd: isHorizontal ? taskManagerView.view.atXEnd : taskManagerView.view.atYEnd
onClicked: {
if (!isAtEnd) {
flickViewBackward(isHorizontal ? taskManagerView.view.width : taskManagerView.view.height);
}
}
Icon {
width: buttonBase.iconSize; height: width
anchors.centerIn: parent
mode: Icon.AutoHighlight
rotation: isHorizontal ? 0 : 90
source: parent.isAtEnd ? parent.iconDisabled : parent.iconEnabled
}
}
}
}
}
}
ukui-panel/widgets/ukui-task-manager/plugin/metadata.json 0000775 0001750 0001750 00000001167 15167645100 022533 0 ustar feng feng {
"Authors": [
{
"Name": "iaom",
"Email": "zhangpengfei@kylinos.cn"
}
],
"Id": "org.ukui.panel.taskManager",
"Icon": "taskManager",
"Name": "taskManager",
"Name[zh_CN]": "任务管理器",
"Name[bo_CN]": "ལས་འགན་དོ་དམ་ཆས།",
"Description": "taskManager",
"Description[zh_CN]": "任务管理器",
"Description[bo_CN]": "ལས་འགན་དོ་དམ་ཆས།",
"Version": "1.0.0",
"Website": "https://ukui.org",
"BugReport": "https://gitee.com/openkylin/ukui-panel/issues",
"ShowIn": "Panel",
"Contents": {
"Main": "qml/main.qml"
}
}
ukui-panel/widgets/ukui-task-manager/task-manager-plugin.cpp 0000664 0001750 0001750 00000004523 15167645100 023130 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: qiqi49
*
*/
#include "task-manager-plugin.h"
#include
#include
#include
#include "ukui-task-manager.h"
#include "actions.h"
#include "task-manager-filter-model.h"
#include "widget-delegate.h"
void TaskManagerPlugin::registerTypes(const char *uri)
{
Q_ASSERT(QLatin1String(uri) == QLatin1String("org.ukui.panel.taskManager"));
qmlRegisterSingletonType(uri, 1, 0, "TaskManager", [] (QQmlEngine *, QJSEngine *) -> QObject* {
return &TaskManager::UkuiTaskManager::self();
});
qmlRegisterType(uri, 1, 0, "TaskManagerFilterModel");
qmlRegisterType(uri, 1, 0, "WidgetDelegate");
qmlRegisterUncreatableType(uri, 1, 0, "Action", "Only enumeration variables are required");
qRegisterMetaType("TaskManager::Action::Type");
qRegisterMetaType("TaskManager::Actions");
}
void TaskManagerPlugin::initializeEngine(QQmlEngine* engine, const char* uri)
{
Q_UNUSED(engine);
Q_ASSERT(QLatin1String(uri) == QLatin1String("org.ukui.panel.taskManager"));
//workaround bug#470839 这个构造中有roundTrip，可能会触发屏幕改变信号，导致触发任务栏新增或删除，如果上面的qmlRegisterSingletonType中初始化可能会导致循环调用
//这里确保UkuiQuick::WindowManager和TaskManager::UkuiTaskManager提前初始化好并且在主线程
UkuiQuick::WindowManager::self();
TaskManager::UkuiTaskManager::self();
}
ukui-panel/widgets/ukui-task-manager/actions.cpp 0000664 0001750 0001750 00000005532 15167645100 020723 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#include "actions.h"
namespace TaskManager {
class ActionPrivate
{
public:
ActionPrivate();
~ActionPrivate();
QString m_name;
Action::Type m_type = Action::Type::Invalid;
QVariant m_param;
QAction *m_action = nullptr;
};
ActionPrivate::ActionPrivate()
{
m_action = new QAction;
}
ActionPrivate::~ActionPrivate()
{
if(m_action) {
delete m_action;
m_action = nullptr;
}
}
Action::Action(QObject *parent) : QObject(parent), d(new ActionPrivate())
{
initConnection();
}
Action::Action(const QString &name, const QString &displayName, const QIcon &icon, Type type, const QVariant ¶m, QObject *parent)
: QObject(parent), d(new ActionPrivate())
{
d->m_name = name;
d->m_type = type;
d->m_param = param;
d->m_action->setText(displayName);
d->m_action->setIcon(icon);
initConnection();
}
Action::Action(const Action &other)
{
d = other.d;
initConnection();
}
Action::~Action() = default;
QString Action::name() const
{
return d->m_name;
}
Action::Type Action::type() const
{
return d->m_type;
}
void Action::setName(const QString &name)
{
d->m_name = name;
}
QString Action::text() const
{
return d->m_action->text();
}
void Action::setText(const QString &name)
{
d->m_action->setText(name);
}
QIcon Action::icon() const
{
return d->m_action->icon();
}
void Action::setIcon(const QIcon &icon)
{
d->m_action->setIcon(icon);
}
void Action::setType(const Action::Type &type)
{
d->m_type = type;
}
bool Action::operator==(const Action &other) const
{
return(d->m_name == other.name()
&& d->m_type == other.type());
}
QVariant Action::param()
{
return d->m_param;
}
void Action::setParam(const QVariant ¶m)
{
d->m_param = param;
}
void Action::initConnection()
{
connect(d->m_action, &QAction::triggered, this, [&](){
Q_EMIT actionTriggered(d->m_param);
});
}
QAction *Action::internalAction() const
{
return d->m_action;
}
bool Action::enabled() const
{
return d->m_action->isEnabled();
}
void Action::setEnabled(bool enabled)
{
d->m_action->setEnabled(enabled);
}
}
ukui-panel/widgets/ukui-task-manager/utils.h 0000664 0001750 0001750 00000002320 15167645100 020060 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#ifndef UKUI_TASK_MANAGER_UTILS_H
#define UKUI_TASK_MANAGER_UTILS_H
#include
#include
#include
class Utils
{
public:
static UkuiSearch::ApplicationInfo *getApplicationInfo();
static QString desktopFileFromPid(uint pid);
static QString desktopFileFromWid(const QString &wid);
static QString desktopFilePathFromName(const QString &name);
};
#endif //UKUI_TASK_MANAGER_UTILS_H
ukui-panel/widgets/ukui-task-manager/task-manager-plugin.h 0000664 0001750 0001750 00000002271 15167645100 022573 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: qiqi49
*
*/
#ifndef UKUI_PANEL_TASK_MANAGER_PLUGIN_H
#define UKUI_PANEL_TASK_MANAGER_PLUGIN_H
#include
class TaskManagerPlugin : public QQmlExtensionPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
public:
void registerTypes(const char *uri) override;
void initializeEngine(QQmlEngine *engine, const char *uri) override;
};
#endif //UKUI_PANEL_TASK_MANAGER_PLUGIN_H
ukui-panel/widgets/ukui-task-manager/ukui-task-manager.h 0000664 0001750 0001750 00000014524 15167645111 022260 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#ifndef UKUITASKMANAGER_H
#define UKUITASKMANAGER_H
#include
#include
#include
#include
#include "actions.h"
namespace TaskManager {
class UkuiTaskManager : public QAbstractListModel
{
Q_OBJECT
Q_PROPERTY(QString currentActiveWinId READ currentActiveWinId NOTIFY currentActiveWinIdChanged)
Q_PROPERTY(bool disableMouseLeftButton READ disableMouseLeftButton NOTIFY disableMouseLeftButtonChanged)
Q_PROPERTY(bool disableMouseRightButton READ disableMouseRightButton NOTIFY disableMouseRightButtonChanged)
Q_PROPERTY(bool disableMouseHover READ disableMouseHover NOTIFY disableMouseHoverChanged)
Q_PROPERTY(bool enableDragToApp READ enableDragToApp WRITE setEnableDragToApp NOTIFY enableDragToAppChanged)
public:
enum AdditionalRoles {
Id = Qt::UserRole + 1, //desktop文件全路径
DesktopFile,
Name, //名称
GenericName, //应用GenericName
IconName, //图标名称
Icon, //图标
WinIdList, //winID列表
CurrentDesktopWinIdList, //当前工作区的窗口
WindowGeometries,
WindowTitles,
WindowIcons,
WindowIconsName,
CurrentWinIdList,
CurrentScreenWinIdList, //当前屏幕上的窗口列表
DemandsAttentionWinIdList, //处于demandsAttention状态的窗口列表
HasLauncher, //快速启动按钮位置（从0开始），-1表示无快速启动按钮
Actions, //可执行的action，目前只包含desktop action
UnreadMessagesNum, //未读消息数量
HasActiveWindow,
ApplicationMenuServiceName,
ApplicationMenuObjectPath,
QuickWidgetId
};
Q_ENUM(AdditionalRoles)
static UkuiTaskManager &self();
~UkuiTaskManager() override;
QHash roleNames() const override;
QVariant data(const QModelIndex &index, int role) const override;
QModelIndex index(int row, int column, const QModelIndex &parent) const override;
int rowCount(const QModelIndex &parent) const override;
/**
* 快速启动按钮 增加/交换位置
* @param desktopFile 目标desktop文件
* @param order 增加或交换位置
*/
void setQuickLauncher(const QString &desktopFile, int order);
void setOrder(const QModelIndex &index, int order);
QModelIndex indexOf(const QString &appId);
QString currentActiveWinId() const;
Q_INVOKABLE static void activateWindowView(const QStringList &winIds);
/**
* 激活窗口
* @param winId
*/
Q_INVOKABLE void activateWindow(const QString &winId);
/**
* 窗口标题
* @param winId
* @return
*/
Q_INVOKABLE QString windowTitle(const QString &winId);
/**
* 窗口图标
* @param winId
* @return
*/
Q_INVOKABLE QIcon windowIcon(const QString &winId);
/**
* 窗口action
* @param winId
* @return
*/
Q_INVOKABLE TaskManager::Actions windowActions(const QString &winId);
/**
* 窗口是否被激活
* @param winId
* @return bool
*/
Q_INVOKABLE static bool windowIsActivated(const QString &winId);
/**
* 窗口执行指定动作
* @param Action::Type
* @param winId
*/
Q_INVOKABLE static void execSpecifiedAction(const TaskManager::Action::Type &type, const QString &wid);
void launch(const QModelIndex &index, const QQuickItem *item = nullptr);
bool event(QEvent* ev) override;
void requestDataChange();
bool disableMouseLeftButton() const;
bool disableMouseRightButton() const;
bool disableMouseHover() const;
QStringList appWhiteList() const;
QStringList appBlackList() const;
bool enableDragToApp() const;
void setEnableDragToApp(bool enable);
Q_SIGNALS:
void unReadMessagesNumberUpdate(const QString &desktopFile, uint num);
void currentActiveWinIdChanged();
void disableMouseLeftButtonChanged();
void disableMouseRightButtonChanged();
void disableMouseHoverChanged();
void appWhiteListChanged();
void appBlackListChanged();
void enableDragToAppChanged();
public Q_SLOTS:
/*
* 这四个接口是对外的接口，用于添加/删除/检查/获取快速启动按钮
*/
bool addQuickLauncher(const QString &desktopFile);
bool checkQuickLauncher(const QString &desktopFile);
bool removeQuickLauncher(const QString &desktopFile);
QStringList quickLaunchers() const;
static QString standardizePath(const QString &path);
void closeWindow(const QVariant& wid);
void minimizeWindow(const QVariant& wid);
void maximizeWindow(const QVariant& wid);
void restoreWindow(const QVariant& wid);
void keepAbove(const QVariant& wid);
void unsetKeepAbove(const QVariant& wid);
private:
explicit UkuiTaskManager(QObject *parent = nullptr);
/**
* 添加快捷按钮到指定位置（新增、交换位置）
* @param desktopFile
* @param order 图标在m_items对应的位置
*/
void addQuickLauncher(const QString &desktopFile, int order);
int quickLauncherCountBeforeRow(int row) const;
void onAppUninstalled(const QStringList &desktopFiles);
/**
* 固定到任务栏/取消固定操作上传埋点数据
* @param applicationName 目标desktop文件
*/
void addQuickLauncherEvent(const QString &applicationName, const QString &operate);
void onFunctionControlChanged(const QString& name, bool exit = false);
class Private;
Private *d = nullptr;
};
}
#endif // UKUITASKMANAGER_H
ukui-panel/widgets/ukui-task-manager/container.qrc 0000664 0001750 0001750 00000000315 15167645100 021242 0 ustar feng feng org.ukui.taskManagerContainer/WidgetContainer.qmlorg.ukui.taskManagerContainer/metadata.json
ukui-panel/widgets/ukui-task-manager/ukui-task-manager.cpp 0000664 0001750 0001750 00000107507 15167645111 022617 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#include "ukui-task-manager.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "task-manager-item.h"
#include "taskmanageradaptor.h"
#include "utils.h"
#include
#include
#include
#include "actions.h"
#include "config.h"
#include "taskmanageradaptor.h"
#include
static const QString QUICK_LAUNCHERS_KEY("quickLaunchers");
static const QString NOTIFICATION_SERVICE = QStringLiteral("org.freedesktop.Notifications");
static const QString NOTIFICATION_PATH = QStringLiteral("/org/freedesktop/Notifications");
static const QString NOTIFICATION_INTERFACE = QStringLiteral("org.ukui.NotificationServer");
static const QStringList DEFAULT_QUICK_LAUNCHERS = {"peony",
"firefox",
"kylin-software-center",
"kylin-screenshot",
"ukui-control-center",
};
/**
* 1.0 QUICK_LAUNCHERS_KEY 值从desktop文件全路径改为desktop文件名列表（不包含后缀）
*/
static const QString CONFIG_VERSION = QStringLiteral("1.0");
namespace TaskManager
{
using WindowManager = UkuiQuick::WindowManager;
bool compareListBySort(QStringList &list1, QStringList &list2) {
if (list1.size() != list2.size())
return false;
list1.sort();
list2.sort();
return list1 == list2;
}
QString appIdFromDesktopFile(const QString &desktopFile)
{
QFileInfo fileInfo(desktopFile);
auto fileName = fileInfo.fileName();
if (fileName.endsWith(QStringLiteral(".desktop"))) {
return fileName.left(fileName.length() - 8);
}
return {};
}
class Q_DECL_HIDDEN UkuiTaskManager::Private
{
public:
explicit Private(UkuiTaskManager *q = nullptr);
~Private();
void windowAdded(const QString &windowId);
void windowRemoved(const QString &windowId);
void skipTaskbarChanged(const QString& windowId);
void activeWindowChanged(const QString& windowId);
void loadSettings();
void addQuickLauncherItem(const QString &desktopFile);
void save() const;
void loadWindows();
void newItem(const QString &wid, const QString &desktopFile);
void onNotificationServiceChanged(const QString &service, const QString &oldOwner, const QString &newOwner);
void connectToNotificationServer();
QVector m_items;
UkuiQuick::Config *m_config {nullptr};
QStringList m_quickLaunchersOrder;
uint m_groupID = 0; //当窗口的group为空时使用
QTranslator *m_translator = nullptr;
QDBusServiceWatcher *m_watcher = nullptr;
bool m_connectedToNotificationServer = false;
QString m_activeWindow;
TaskManager::Actions m_windowActions;
bool m_requestDataChange {false};
//管控配置
bool m_disableMouseLeftButton {false};
bool m_disableMouseRightButton {false};
bool m_disableMouseHover {false};
QStringList m_appWhiteList;
QStringList m_appBlackList;
// 控制是否允许拖拽到应用图标，激活应用窗口功能（default: true）
bool m_enableDragToApp {true};
private:
UkuiTaskManager *q = nullptr;
};
UkuiTaskManager::Private::Private(UkuiTaskManager *q) : q(q)
{
}
UkuiTaskManager::Private::~Private()
{
qDeleteAll(m_items);
qDeleteAll(m_windowActions);
}
void UkuiTaskManager::Private::loadSettings()
{
if (!m_config) {
m_config = UkuiQuick::ConfigLoader::getConfig("org.ukui.panel.taskManager");
}
//版本升级处理
if (m_config->getValue(QStringLiteral("version")).toString() != CONFIG_VERSION) {
auto oldVersion = m_config->getValue(QStringLiteral("version")).toString();
if (oldVersion.isEmpty() && m_config->contains(QUICK_LAUNCHERS_KEY)) {
auto list = m_config->getValue(QUICK_LAUNCHERS_KEY).toStringList();
QStringList newList;
QFileInfo info;
for (const auto&desktop: list) {
info.setFile(desktop);
QString filName = info.fileName();
if (filName.endsWith(QStringLiteral(".desktop"))) {
newList.append(filName.left(filName.length() - 8));
}
}
m_config->setValue(QUICK_LAUNCHERS_KEY, newList);
}
m_config->setValue(QStringLiteral("version"), CONFIG_VERSION);
}
QStringList quickLaunchers;
if (m_config->contains(QUICK_LAUNCHERS_KEY)) {
quickLaunchers = m_config->getValue(QUICK_LAUNCHERS_KEY).toStringList();
} else {
quickLaunchers = DEFAULT_QUICK_LAUNCHERS;
}
for (auto id : quickLaunchers) {
auto fullPath = Utils::desktopFilePathFromName(id);
if (!fullPath.isEmpty()) {
m_quickLaunchersOrder.append(id);
addQuickLauncherItem(fullPath);
}
}
if (quickLaunchers != m_quickLaunchersOrder) {
m_config->setValue(QUICK_LAUNCHERS_KEY, m_quickLaunchersOrder);
}
}
void UkuiTaskManager::Private::addQuickLauncherItem(const QString &desktopFile)
{
qDebug() << "Init quickLauncher button from desktop:" << desktopFile;
auto item = new TaskManagerItem(desktopFile);
connect(item, &TaskManagerItem::dataUpdated, q, [&, item](const QVector &roles){
QModelIndex changeIndex = q->index(m_items.indexOf(item), 0, QModelIndex());
q->dataChanged(changeIndex, changeIndex, roles);
});
connect(q, &UkuiTaskManager::unReadMessagesNumberUpdate, item, &TaskManagerItem::updateUnreadMessagesNum);
item->setHasLauncher(true);
item->init();
q->beginInsertRows(QModelIndex(), m_items.size(), m_items.size());
m_items.append(item);
q->endInsertRows();
}
void UkuiTaskManager::Private::windowAdded(const QString &windowId)
{
//过滤不需要显示的窗口
if(WindowManager::skipTaskBar(windowId)) {
return;
}
QString windowGroup = WindowManager::windowGroup(windowId);
if (windowGroup.isEmpty()) {
windowGroup = QString::number(++m_groupID);
}
QString desktopFile = Utils::desktopFileFromWid(windowId);
for (auto item : m_items) {
//避免重复添加
if(item->winIDs().contains(windowId)) {
return;
}
//组已经存在，增加一个窗口（windowGroup就是appid）
if (item->group() == windowGroup) {
item->addWinID(windowId);
return;
}
//desktop匹配，增加一个窗口
auto appid = appIdFromDesktopFile(desktopFile);
if (!item->ID().isEmpty() && !appid.isEmpty() && item->ID() == appid) {
item->addWinID(windowId);
return;
}
}
newItem(windowId, desktopFile);
}
void UkuiTaskManager::Private::windowRemoved(const QString &windowId)
{
for (int index = 0; index < m_items.size(); ++index) {
auto item = m_items.at(index);
if (item->winIDs().contains(windowId)) {
item->removeWinID(windowId);
if (item->winIDs().isEmpty() && !item->hasLauncher()) {
q->beginRemoveRows(QModelIndex(), index, index);
delete m_items.takeAt(index);
q->endRemoveRows();
}
break;
}
}
}
void UkuiTaskManager::Private::skipTaskbarChanged(const QString &windowId)
{
bool skipTaskBar = WindowManager::skipTaskBar(windowId);
QString windowGroup = WindowManager::windowGroup(windowId);
bool handled = false;
for (int index = 0; index < m_items.size(); ++index) {
auto item = m_items.at(index);
if (item->winIDs().contains(windowId)) {
if(skipTaskBar) {
item->removeWinID(windowId);
if (item->winIDs().isEmpty() && !item->hasLauncher()) {
q->beginRemoveRows(QModelIndex(), index, index);
delete m_items.takeAt(index);
q->endRemoveRows();
}
}
handled = true;
break;
} else if(item->group() == windowGroup && !windowGroup.isEmpty() && !skipTaskBar) {
item->addWinID(windowId);
handled = true;
break;
}
}
if(!handled) {
if(!skipTaskBar) {
newItem(windowId, Utils::desktopFileFromWid(windowId));
}
}
}
void UkuiTaskManager::Private::activeWindowChanged(const QString &windowId)
{
if(windowId == m_activeWindow) {
return;
}
for(auto item : m_items) {
if(item->currentDesktopWinIDs().contains(m_activeWindow)) {
item->setHasActiveWindow(false);
}
if(item->currentDesktopWinIDs().contains(windowId)) {
item->setHasActiveWindow(true);
}
}
m_activeWindow = windowId;
Q_EMIT q->currentActiveWinIdChanged();
}
void UkuiTaskManager::Private::loadWindows()
{
for (const QString &winID: WindowManager::windows()) {
windowAdded(winID);
}
}
void UkuiTaskManager::Private::newItem(const QString &wid, const QString &desktopFile)
{
auto appid = appIdFromDesktopFile(desktopFile);
//查看是否存在快速启动按钮
if (m_quickLaunchersOrder.contains(appid)) {
m_items.at(q->indexOf(appid).row())->addWinID(wid);
return;
}
//新增一个item
auto newItem = new TaskManagerItem(QStringList{wid});
newItem->setID(appid);
newItem->setDesktopFile(desktopFile);
newItem->init();
connect(q, &UkuiTaskManager::unReadMessagesNumberUpdate, newItem, &TaskManagerItem::updateUnreadMessagesNum);
QObject::connect(newItem, &TaskManagerItem::dataUpdated, q, [&, newItem](const QVector &roles){
QModelIndex changeIndex = q->index(m_items.indexOf(newItem), 0, QModelIndex());
q->dataChanged(changeIndex, changeIndex, roles);
});
q->beginInsertRows(QModelIndex(), m_items.size(), m_items.size());
m_items.append(newItem);
q->endInsertRows();
}
void UkuiTaskManager::Private::save() const
{
m_config->setValue(QUICK_LAUNCHERS_KEY, m_quickLaunchersOrder);
m_config->forceSync();
}
void UkuiTaskManager::Private::onNotificationServiceChanged(const QString &service, const QString &oldOwner,
const QString &newOwner)
{
if(!oldOwner.isEmpty()) {
QDBusConnection::sessionBus().disconnect(NOTIFICATION_SERVICE,
NOTIFICATION_PATH,
NOTIFICATION_INTERFACE,
QStringLiteral("UnreadMessagesNumberUpdated"),
q,
SLOT(unReadMessagesNumberUpdate));
m_connectedToNotificationServer = false;
if(!newOwner.isEmpty()) {
connectToNotificationServer();
}
} else if(!newOwner.isEmpty()) {
if(!m_connectedToNotificationServer) {
return;
}
connectToNotificationServer();
}
}
void UkuiTaskManager::Private::connectToNotificationServer()
{
m_connectedToNotificationServer = QDBusConnection::sessionBus().connect(NOTIFICATION_SERVICE,
NOTIFICATION_PATH,
NOTIFICATION_INTERFACE,
QStringLiteral("UnreadMessagesNumberUpdated"),
q,
SLOT(unReadMessagesNumberUpdate(const QString &, uint)));
}
QModelIndex UkuiTaskManager::indexOf(const QString &appId)
{
for(int row = 0; row < d->m_items.size(); ++row) {
if(d->m_items.at(row)->ID() == appId) {
return index(row, 0, {});
}
}
return {};
}
QString UkuiTaskManager::currentActiveWinId() const
{
return d->m_activeWindow;
}
UkuiTaskManager::UkuiTaskManager(QObject *parent) : QAbstractListModel(parent), d(new Private(this))
{
d->m_translator = new QTranslator(this);
if (!d->m_translator->load(QString(TRANSLATION_FILE_DIR) + "/libukui-task-manager_" + QLocale::system().name() + ".qm")) {
qWarning() << "Load translations file" << QLocale::system().name() << "failed!";;
}
qApp->installTranslator(d->m_translator);
//加载配置文件，初始化快速启动按钮
d->loadSettings();
//加载当前打开的窗口
d->loadWindows();
connect(Utils::getApplicationInfo(), &UkuiSearch::ApplicationInfo::appDBItems2BDelete, this, &UkuiTaskManager::onAppUninstalled);
connect(WindowManager::self(), &WindowManager::windowAdded, this, [&](const QString &winId) {
d->windowAdded(winId);
});
connect(WindowManager::self(), &WindowManager::windowRemoved, this, [&](const QString &winId) {
d->windowRemoved(winId);
});
connect(WindowManager::self(), &WindowManager::skipTaskbarChanged, this, [&](const QString &winId) {
d->skipTaskbarChanged(winId);
});
connect(WindowManager::self(), &WindowManager::activeWindowChanged, this, [&](const QString &winId){
d->activeWindowChanged(winId);
});
//为了避免UI阻塞 bug#464235
QTimer::singleShot(0, [this](){
d->m_activeWindow = WindowManager::currentActiveWindow();
Q_EMIT currentActiveWinIdChanged();
});
auto conn = QDBusConnection::sessionBus();
d->m_watcher = new QDBusServiceWatcher(QStringLiteral("org.freedesktop.Notifications"),
conn,
QDBusServiceWatcher::WatchForOwnerChange,
this);
connect(d->m_watcher, &QDBusServiceWatcher::serviceOwnerChanged,this,[&](const QString &service, const QString &oldOwner, const QString &newOwner){
d->onNotificationServiceChanged(service, oldOwner, newOwner);
});
d->connectToNotificationServer();
new TaskManagerAdaptor(this);
QDBusConnection dbus = QDBusConnection::sessionBus();
dbus.registerObject(QStringLiteral("/taskManager"), this);
dbus.registerService(QStringLiteral("org.ukui.taskManager"));
UkuiQuick::FunctionControl::instance()->addWatch(QStringLiteral("ukui-panel-taskManager-v11"));
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlChanged, this, [&](const QString &name) {
onFunctionControlChanged(name);
});
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlExit, this, [&]() {
onFunctionControlChanged(QStringLiteral("ukui-panel-taskManager-v11"), true);
});
onFunctionControlChanged(QStringLiteral("ukui-panel-taskManager-v11"));
}
UkuiTaskManager::~UkuiTaskManager()
{
UkuiQuick::FunctionControl::instance()->removeWatch(QStringLiteral("ukui-panel-taskManager-v11"));
if (d) {
delete d;
d = nullptr;
}
}
QHash UkuiTaskManager::roleNames() const
{
QHash roles = QAbstractItemModel::roleNames();
QMetaEnum e = metaObject()->enumerator(metaObject()->indexOfEnumerator("AdditionalRoles"));
for (int i = 0; i < e.keyCount(); ++i) {
roles.insert(e.value(i), e.key(i));
}
return roles;
}
QVariant UkuiTaskManager::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || index.row() >= d->m_items.count()) {
return {};
}
TaskManagerItem *item = d->m_items.at(index.row());
if (!item) {
return {};
}
switch (role) {
case Qt::DisplayRole:
return item->name();
case Icon: {
if (item->icon().isNull()) {
return "application-x-desktop";
}
return item->icon();
}
case IconName:
return item->iconName();
case Id:
return item->ID();
case DesktopFile:
return item->desktopFile();
case Name:
return item->name();
case GenericName:
return item->genericName();
case WinIdList:
return item->winIDs();
case CurrentDesktopWinIdList:
return item->currentDesktopWinIDs();
case WindowGeometries:
return QVariant::fromValue(item->WindowGeometries());
case WindowTitles:
return QVariant::fromValue(item->windowTitles());
case WindowIcons:
return QVariant::fromValue(item->windowIcons());
case WindowIconsName:
return QVariant::fromValue(item->windowIconsName());
case DemandsAttentionWinIdList:
return item->demandsAttentionWinIDs();
case ApplicationMenuServiceName:
case ApplicationMenuObjectPath:
return QString();
case HasLauncher:
return item->hasLauncher();
case Actions: {
auto actions = item->actions();
for(auto action : actions) {
if(action->type() == Action::Type::AddQuickLauncher) {
action->setParam(index.row());
break;
}
}
return QVariant::fromValue(actions);
}
case UnreadMessagesNum:
return item->unReadMessagesNum();
case HasActiveWindow:
return item->hasActiveWindow();
case QuickWidgetId:
return item->quickWidget();
default:
return {};
}
Q_UNREACHABLE();
}
QModelIndex UkuiTaskManager::index(int row, int column, const QModelIndex &parent) const
{
if (row < 0 || column != 0) {
return {};
}
return createIndex(row, column, nullptr);
}
int UkuiTaskManager::rowCount(const QModelIndex &parent) const
{
return parent.isValid() ? 0 : d->m_items.count();
}
bool UkuiTaskManager::addQuickLauncher(const QString &desktopFile)
{
//支持传入全路径，appId后带desktop后缀的appId
QString fullpath = standardizePath(desktopFile);
if (fullpath.isEmpty()) {
return false;
}
const auto appId = appIdFromDesktopFile(fullpath);
if (appId.isEmpty() || d->m_quickLaunchersOrder.contains(appId)) {
return false;
}
QModelIndex index = indexOf(fullpath);
if (index.isValid()) {
addQuickLauncher(fullpath, index.row());
} else {
addQuickLauncher(fullpath, d->m_items.size());
}
return true;
}
bool UkuiTaskManager::checkQuickLauncher(const QString &desktopFile)
{
if (std::any_of(d->m_quickLaunchersOrder.begin(), d->m_quickLaunchersOrder.end(), [&](const QString& id) {
if (desktopFile.endsWith("/" + id + ".desktop")) {
return true;
}
return false;
})) {
return true;
}
return false;
}
bool UkuiTaskManager::removeQuickLauncher(const QString &desktopFile)
{
QString appId;
if (desktopFile.endsWith(QStringLiteral("desktop"))) {
appId = appIdFromDesktopFile(desktopFile);
} else {
appId = desktopFile;
}
if (appId.isEmpty()) {
return false;
}
if (d->m_quickLaunchersOrder.contains(appId)) {
int modelIndex = indexOf(appId).row();
auto targetItem = d->m_items.at(modelIndex);
int oldOrder = d->m_quickLaunchersOrder.indexOf(appId);
//取消固定
targetItem->setHasLauncher(false);
//上传埋点数据
addQuickLauncherEvent(appId, "unpin from taskbar");
if (targetItem->winIDs().isEmpty()) {
beginRemoveRows(QModelIndex(), modelIndex, modelIndex);
delete d->m_items.takeAt(modelIndex);
endRemoveRows();
}
d->m_quickLaunchersOrder.removeAt(oldOrder);
d->save();
} else {
return false;
}
return true;
}
QStringList UkuiTaskManager::quickLaunchers() const
{
return d->m_quickLaunchersOrder;
}
QString UkuiTaskManager::standardizePath(const QString &path)
{
QString fullpath = path;
if (!QFile::exists(path)) {
if (path.endsWith(QStringLiteral("desktop"))) {
fullpath = Utils::desktopFilePathFromName(path.left(path.length() - 8));
} else {
fullpath = Utils::desktopFilePathFromName(path);
}
if (!QFile::exists(fullpath)) {
return {};
}
} else if (!path.endsWith(QStringLiteral("desktop"))) {
return {};
}
return fullpath;
}
void UkuiTaskManager::addQuickLauncher(const QString &desktopFile, int order)
{
if(order < 0 || !QFile::exists(desktopFile)) {
return;
}
auto appId = appIdFromDesktopFile(desktopFile);
// 1. 任务栏已存在图标
// 1.1 改变HasLauncher属性,并同步配置文件
for (int i = 0; i < d->m_items.size(); ++i) {
if (d->m_items.at(i)->ID() == appId) {
if (!d->m_items.at(i)->hasLauncher()) {
d->m_items.at(i)->setHasLauncher(true);
auto launcherOrder = qMin(quickLauncherCountBeforeRow(i), d->m_quickLaunchersOrder.size());
d->m_quickLaunchersOrder.insert(launcherOrder, appId);
d->save();
}
// 1.2 移动到指定位置
setOrder(indexOf(appId), order);
addQuickLauncherEvent(appId, "pin to taskbar");
return;
}
}
// 2. 任务栏不存在图标
// 2.1. 新增图标
auto item = new TaskManagerItem(desktopFile);
item->setHasLauncher(true);
connect(this, &UkuiTaskManager::unReadMessagesNumberUpdate, item, &TaskManagerItem::updateUnreadMessagesNum);
QObject::connect(item, &TaskManagerItem::dataUpdated, this, [&, item](const QVector&roles) {
QModelIndex changeIndex = index(d->m_items.indexOf(item), 0, QModelIndex());
Q_EMIT dataChanged(changeIndex, changeIndex, roles);
});
item->init();
order = qMin(order, d->m_items.size());
beginInsertRows(QModelIndex(), order, order);
d->m_items.insert(order, item);
endInsertRows();
// 2.2 记录快捷启动按钮顺序，并同步配置文件
auto launcherOrder = quickLauncherCountBeforeRow(order);
launcherOrder = qMin(launcherOrder, d->m_quickLaunchersOrder.size());
d->m_quickLaunchersOrder.insert(launcherOrder, appId);
d->save();
// 2.3 上传埋点数据
addQuickLauncherEvent(appId, "pin to taskbar");
}
void UkuiTaskManager::setOrder(const QModelIndex &index, int order)
{
int oldOrder = index.row();
order = qMin(order, d->m_items.size() -1);
if(order == oldOrder || !index.isValid() || oldOrder >= d->m_items.size()) {
return;
}
auto item = d->m_items.at(oldOrder);
if(item->hasLauncher()) {
int launcherOrder = d->m_quickLaunchersOrder.indexOf(item->ID());
if(oldOrder < order) {
for(int row = oldOrder + 1; row <= order; ++row) {
if(d->m_items.at(row)->hasLauncher()) {
++launcherOrder;
}
}
} else {
for(int row = oldOrder - 1; row >= order; --row) {
if(d->m_items.at(row)->hasLauncher()) {
--launcherOrder;
}
}
if (launcherOrder < 0) {
launcherOrder = 0;
}
}
launcherOrder = qMin(d->m_quickLaunchersOrder.size() - 1, launcherOrder);
d->m_quickLaunchersOrder.move(d->m_quickLaunchersOrder.indexOf(item->ID()), launcherOrder);
d->save();
}
if (oldOrder < order) {
beginMoveRows(index.parent(), oldOrder, oldOrder, index.parent(), order + 1);
} else {
beginMoveRows(index.parent(), oldOrder, oldOrder, index.parent(), order);
}
d->m_items.insert(order, d->m_items.takeAt(oldOrder));
endMoveRows();
}
void UkuiTaskManager::activateWindowView(const QStringList &winIds)
{
WindowManager::self()->activateWindowView(winIds);
}
void UkuiTaskManager::activateWindow(const QString &winId)
{
WindowManager::activateWindow(winId);
}
QString UkuiTaskManager::windowTitle(const QString &winId)
{
return WindowManager::windowTitle(winId);
}
QIcon UkuiTaskManager::windowIcon(const QString &winId)
{
return WindowManager::windowIcon(winId);
}
UkuiTaskManager &UkuiTaskManager::self()
{
static UkuiTaskManager s_self;
return s_self;
}
TaskManager::Actions UkuiTaskManager::windowActions(const QString &winId)
{
if(d->m_windowActions.isEmpty()) {
//关闭
auto action = new Action("Close", tr("Close"), QIcon::fromTheme("window-close-symbolic"), Action::Type::Close, winId);
connect(action, &Action::actionTriggered, this, &UkuiTaskManager::closeWindow);
d->m_windowActions.append(action);
//还原
action = new Action("Restore", tr("Restore"), QIcon::fromTheme("window-restore-symbolic"), Action::Type::Restore, winId);
connect(action, &Action::actionTriggered, this, &UkuiTaskManager::restoreWindow);
d->m_windowActions.append(action);
//最大化
action = new Action("Maximize", tr("Maximize"), QIcon::fromTheme("window-maximize-symbolic"), Action::Type::Maximize, winId);
connect(action, &Action::actionTriggered, this, &UkuiTaskManager::maximizeWindow);
d->m_windowActions.append(action);
//最小化
action = new Action("Minimize", tr("Minimize"), QIcon::fromTheme("window-minimize-symbolic"), Action::Type::Minimize, winId);
connect(action, &Action::actionTriggered, this, &UkuiTaskManager::minimizeWindow);
d->m_windowActions.append(action);
//置顶
action = new Action("Keep above", tr("Keep above"), QIcon::fromTheme("ukui-fixed-symbolic"), Action::Type::KeepAbove, winId);
connect(action, &Action::actionTriggered, this, &UkuiTaskManager::keepAbove);
d->m_windowActions.append(action);
//取消置顶
action = new Action("Unset keep above", tr("Unset keep above"), QIcon::fromTheme("ukui-unfixed-symbolic"), Action::Type::UnsetKeepAbove, winId);
connect(action, &Action::actionTriggered, this, &UkuiTaskManager::unsetKeepAbove);
d->m_windowActions.append(action);
}
for (auto action : d->m_windowActions) {
if (action->param() != winId) {
action->setParam(winId);
}
switch (action->type()) {
case Action::Close:
break;
case Action::Minimize:
action->setEnabled(WindowManager::isMinimizable(winId) && !WindowManager::isMinimized(winId));
break;
case Action::Maximize:
action->setEnabled(WindowManager::isMaximizable(winId) && (!WindowManager::isMaximized(winId) || WindowManager::isMinimized(winId)));
break;
case Action::Restore:
action->setEnabled(WindowManager::isMaximized(winId) || WindowManager::isMinimized(winId));
break;
case Action::KeepAbove:
action->setEnabled(!WindowManager::isKeepAbove(winId));
break;
case Action::UnsetKeepAbove:
action->setEnabled(WindowManager::isKeepAbove(winId));
break;
default:
break;
}
}
return d->m_windowActions;
}
bool UkuiTaskManager::windowIsActivated(const QString &winId)
{
return winId == WindowManager::currentActiveWindow();
}
void UkuiTaskManager::execSpecifiedAction(const TaskManager::Action::Type &type, const QString &wid)
{
switch (type) {
case Action::Close:
WindowManager::closeWindow(wid);
break;
case Action::Minimize:
WindowManager::minimizeWindow(wid);
break;
case Action::Maximize:
WindowManager::maximizeWindow(wid);
break;
case Action::Restore:
WindowManager::restoreWindow(wid);
break;
case Action::KeepAbove:
case Action::UnsetKeepAbove:
WindowManager::keepAboveWindow(wid);
break;
default:
break;
}
}
void UkuiTaskManager::launch(const QModelIndex& index, const QQuickItem* item)
{
if (!index.isValid() || index.row() >= d->m_items.count()) {
return;
}
d->m_items.at(index.row())->launch(item);
}
void UkuiTaskManager::closeWindow(const QVariant &wid)
{
WindowManager::closeWindow(wid.toString());
}
void UkuiTaskManager::minimizeWindow(const QVariant &wid)
{
WindowManager::minimizeWindow(wid.toString());
}
void UkuiTaskManager::maximizeWindow(const QVariant &wid)
{
if (!WindowManager::isMaximized(wid.toString())) {
WindowManager::maximizeWindow(wid.toString());
}
WindowManager::activateWindow(wid.toString());
}
void UkuiTaskManager::restoreWindow(const QVariant &wid)
{
WindowManager::restoreWindow(wid.toString());
WindowManager::activateWindow(wid.toString());
}
void UkuiTaskManager::keepAbove(const QVariant &wid)
{
WindowManager::keepAboveWindow(wid.toString());
}
void UkuiTaskManager::unsetKeepAbove(const QVariant &wid)
{
WindowManager::keepAboveWindow(wid.toString());
}
int UkuiTaskManager::quickLauncherCountBeforeRow(int row) const
{
int launcherCount = 0;
row = qMin(row, d->m_items.size());
for(int i = 0; i < row; ++i) {
if(d->m_items.at(i)->hasLauncher()) {
launcherCount++;
}
}
return launcherCount;
}
void UkuiTaskManager::setQuickLauncher(const QString &desktopFile, int order)
{
if(order >= d->m_items.size()) {
order = d->m_items.size();
}
addQuickLauncher(desktopFile, order);
}
void UkuiTaskManager::onAppUninstalled(const QStringList &desktopFiles)
{
for(const QString &desktopFile : desktopFiles) {
removeQuickLauncher(desktopFile);
}
}
void UkuiTaskManager::addQuickLauncherEvent(const QString &applicationName, const QString &operate )
{
KCustomProperty *property = new KCustomProperty[2];
property[0].key = strdup(QStringLiteral("AppliciationName").toLocal8Bit().data());
property[0].value = strdup(applicationName.toLocal8Bit().data());
property[1].key = strdup(QStringLiteral("EventType").toLocal8Bit().data());
property[1].value = strdup(operate.toLocal8Bit().data());
KTrackData *node = kdk_dia_data_init(KEVENTSOURCE_DESKTOP, KEVENT_CLICK);
kdk_dia_append_custom_property(node, property, 2);
kdk_dia_upload_default(node, strdup(QStringLiteral("pin_to_taskbar_event").toLocal8Bit().data()),strdup(QStringLiteral("ukui-panel").toLocal8Bit().data()));
kdk_dia_data_free(node);
free(property[0].key);
free(property[0].value);
free(property[1].key);
free(property[1].value);
delete []property;
}
void UkuiTaskManager::onFunctionControlChanged(const QString &name, bool exit)
{
if (name != QStringLiteral("ukui-panel-taskManager-v11")) {
return;
}
//管控中有值时，设置为管控值，否则设置为配置文件中的值
auto config = exit? QJsonObject() : UkuiQuick::FunctionControl::instance()->functionControlObject(name).value(name).toObject();
qDebug() << "TaskManager" << "function control config:" << config;
//应用白名单
if (config.contains(QStringLiteral("appWhiteList"))) {
QStringList appWhiteList;
for (QVariant &app : config.value(QStringLiteral("appWhiteList")).toArray().toVariantList()) {
auto id = app.toString();
if (id.endsWith(".desktop")) {
id = id.left(id.size() - 8);
}
appWhiteList.append(id);
}
if (!compareListBySort(d->m_appWhiteList, appWhiteList)) {
d->m_appWhiteList = appWhiteList;
Q_EMIT appWhiteListChanged();
}
} else if (!d->m_appWhiteList.isEmpty()) {
d->m_appWhiteList.clear();
Q_EMIT appWhiteListChanged();
}
//应用黑名单
if (config.contains(QStringLiteral("appBlackList"))) {
QStringList appBlackList;
for (QVariant &app : config.value(QStringLiteral("appBlackList")).toArray().toVariantList()) {
auto id = app.toString();
if (id.endsWith(".desktop")) {
id = id.left(id.size() - 8);
}
appBlackList.append(id);
}
if (!compareListBySort(d->m_appBlackList, appBlackList)) {
d->m_appBlackList= appBlackList;
Q_EMIT appBlackListChanged();
}
} else if (!d->m_appBlackList.isEmpty()) {
d->m_appBlackList.clear();
Q_EMIT appBlackListChanged();
}
//是否禁用左键点击（任务栏整体禁用）
if (config.contains(QStringLiteral("disableMouseLeftButton"))) {
bool disable = config.value(QStringLiteral("disableMouseLeftButton")).toBool();
if (disable != d->m_disableMouseLeftButton) {
d->m_disableMouseLeftButton = disable;
Q_EMIT disableMouseLeftButtonChanged();
}
} else {
d->m_disableMouseLeftButton = false;
Q_EMIT disableMouseLeftButtonChanged();
}
//是否禁用右键点击（任务栏整体禁用）
if (config.contains(QStringLiteral("disableMouseRightButton"))) {
bool disable = config.value(QStringLiteral("disableMouseRightButton")).toBool();
if (disable != d->m_disableMouseRightButton) {
d->m_disableMouseRightButton = disable;
Q_EMIT disableMouseRightButtonChanged();
}
} else {
d->m_disableMouseRightButton = false;
Q_EMIT disableMouseRightButtonChanged();
}
//是否禁用任务栏鼠标悬浮效果（任务栏整体）
if (config.contains(QStringLiteral("disableMouseHover"))) {
bool disable = config.value(QStringLiteral("disableMouseHover")).toBool();
if (disable != d->m_disableMouseHover) {
d->m_disableMouseHover = disable;
Q_EMIT disableMouseHoverChanged();
}
} else {
d->m_disableMouseHover = false;
Q_EMIT disableMouseHoverChanged();
}
}
bool UkuiTaskManager::event(QEvent *event)
{
if (event->type() == QEvent::UpdateRequest) {
for(auto item : d->m_items) {
item->updateIconStatus();
}
d->m_requestDataChange = false;
}
return QObject::event(event);
}
void UkuiTaskManager::requestDataChange()
{
if (!d->m_requestDataChange) {
d->m_requestDataChange = true;
auto ev = new QEvent(QEvent::UpdateRequest);
QCoreApplication::postEvent(this, ev);
}
}
bool UkuiTaskManager::disableMouseLeftButton() const
{
return d->m_disableMouseLeftButton;
}
bool UkuiTaskManager::disableMouseRightButton() const
{
return d->m_disableMouseRightButton;
}
bool UkuiTaskManager::disableMouseHover() const
{
return d->m_disableMouseHover;
}
QStringList UkuiTaskManager::appWhiteList() const
{
return d->m_appWhiteList;
}
QStringList UkuiTaskManager::appBlackList() const
{
return d->m_appBlackList;
}
bool UkuiTaskManager::enableDragToApp() const
{
return d->m_enableDragToApp;
}
void UkuiTaskManager::setEnableDragToApp(bool enable)
{
if (enable != d->m_enableDragToApp) {
d->m_enableDragToApp = enable;
Q_EMIT enableDragToAppChanged();
}
}
}
#include "moc_ukui-task-manager.cpp"
ukui-panel/widgets/ukui-task-manager/task-manager-item.h 0000664 0001750 0001750 00000006675 15167645100 022247 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#ifndef UKUI_TASK_MANAGER_TASK_MANAGER_ITEM_H
#define UKUI_TASK_MANAGER_TASK_MANAGER_ITEM_H
#include
#include
#include
#include "actions.h"
class QQuickItem;
namespace TaskManager {
class TaskManagerItemPrivate;
class TaskManagerItem : public QObject
{
Q_OBJECT
public:
explicit TaskManagerItem(QObject *parent = nullptr);
explicit TaskManagerItem(const QString &desktoFile, QObject *parent = nullptr);
explicit TaskManagerItem(const QStringList &winIDs, QObject *parent = nullptr);
~TaskManagerItem();
const QString &ID() const;
void setID(const QString &appID);
const QString &desktopFile() const;
void setDesktopFile(const QString &desktopFile);
const QString &name() const;
const QString &genericName() const;
const QString &iconName() const;
const QIcon &icon() const;
const QStringList &winIDs() const;
const QStringList ¤tDesktopWinIDs();
const QMap &WindowGeometries() const;
const QMap &windowTitles() const;
const QMap &windowIcons() const;
const QMap &windowIconsName() const;
void addWinID(const QString &winId);
void removeWinID(const QString &winID);
void iconChanged(const QString& windowId);
void titleChanged(const QString& windowId);
void desktopChanged(const QString& windowId);
void demandsAttentionChanged(const QString& windowId);
void geometryChanged(const QString& windowId);
void setHasActiveWindow(bool has);
bool hasActiveWindow();
const QString &group() const;
void setGroup(const QString &group);
bool hasLauncher() const;
void setHasLauncher(bool hasLauncher);
Actions actions() const;
QStringList demandsAttentionWinIDs() const;
const QString &display() const;
QString quickWidget() const;
uint unReadMessagesNum();
void init();
void updateIconStatus();
public Q_SLOTS:
void updateUnreadMessagesNum(const QString &desktopFile, uint num);
void newInstanceActionActive(const QVariant& param);
void launch(const QQuickItem *item = nullptr);
private Q_SLOTS:
void refreshWinIdsOnCurrentDesktop();
void refreshWinIdsOnScreens();
void refreshWindowTitlesAndIcons();
void desktopActionActive(const QString &name);
void removeQuickLauncherActionActive();
void addQuickLauncherActionActive(int index);
void exitActionActive(const QStringList &winIds);
void onWidgetInfoUpdate(const QString &appid, const QString &widgetId);
Q_SIGNALS:
void dataUpdated(QVector roles);
private:
TaskManagerItemPrivate *d = nullptr;
};
}
#endif //UKUI_TASK_MANAGER_TASK_MANAGER_ITEM_H
ukui-panel/widgets/ukui-task-manager/task-manager-filter-model.h 0000664 0001750 0001750 00000006201 15167645111 023657 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#ifndef UKUI_PANEL_TASK_MANAGER_FILTER_MODEL_H
#define UKUI_PANEL_TASK_MANAGER_FILTER_MODEL_H
#include
#include
#include
#include
#include
#include "actions.h"
#include "ukui-task-manager.h"
#include "config-loader.h"
namespace TaskManager {
class TaskManagerFilterModel : public QSortFilterProxyModel
{
Q_OBJECT
Q_PROPERTY(QScreen *screen READ screen WRITE setScreen)
public:
explicit TaskManagerFilterModel(QObject *parent = nullptr);
Q_INVOKABLE void setSourceModel(QAbstractItemModel *sourceModel) override;
QVariant data(const QModelIndex &index, int role) const override;
Q_INVOKABLE void setOrder(const QModelIndex &index, int order);
/**
* 右键菜单
* @param showDisabledActions
* @param actions
*/
Q_INVOKABLE bool openMenu(const bool &showDisabledActions, const TaskManager::Actions &actions, QQuickItem *item);
/**
* 添加快捷按钮到指定位置（先添加快捷按钮，再换位）
* @param desktopFile
* @param order
*/
Q_INVOKABLE void addQuickLauncher(const QString &desktopFile, int order);
Q_INVOKABLE void launch(const QModelIndex &index, QQuickItem *item = nullptr);
QScreen *screen() const;
void setScreen(QScreen *screen);
/**
* 多屏时，任务栏图标显示在哪个任务栏 枚举值
* 0-所有屏幕，1-主屏和打开了窗口的任务栏 2-只显示在打开了窗口的任务栏
*/
enum TaskBarIconsShowedOn {
AllPanels = 0,
PrimaryScreenPanelAndPanelWhereWindowIsOpen,
PanelWhereWindowIsOpen
};
Q_ENUM(TaskBarIconsShowedOn)
protected:
bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
private:
QStringList currentWinIdList(const QModelIndex &index) const;
void onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector &roles = QVector());
bool onCurrentScreen(const QModelIndex &index) const;
bool windowOnCurrentScreen(const QRect &rect) const;
UkuiTaskManager *m_sourceModel = nullptr;
QScreen *m_screen = nullptr;
QPointer m_contextMenu;
//任务栏图标显示在哪个任务栏
TaskBarIconsShowedOn m_iconsShowedonScreen;
UkuiQuick::Config *m_config {nullptr};
Q_SIGNALS:
void menuAboutToHide();
};
}
#endif //UKUI_PANEL_TASK_MANAGER_FILTER_MODEL_H
ukui-panel/widgets/ukui-task-manager/task-manager-item.cpp 0000664 0001750 0001750 00000047246 15167645100 022601 0 ustar feng feng /*
*
* * Copyright (C) 2023, KylinSoft Co., Ltd.
* *
* * 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.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see .
* *
* * Authors: iaom
*
*/
#include "task-manager-item.h"
#include
#include
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
#include
#include
#else
#include
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include "window-manager.h"
#include "ukui-task-manager.h"
#include "utils.h"
#include "widget-delegate.h"
using namespace TaskManager;
using namespace UkuiQuick;
class TaskManager::TaskManagerItemPrivate
{
public:
~TaskManagerItemPrivate();
QString m_ID;
QString m_desktopFile;
QString m_name;
QString m_genericName;
QString m_iconName;
QIcon m_icon;
QStringList m_winIDs;
QStringList m_winIDsOnCurrentDesktop;
QString m_groupLeader;
QString m_group;
bool m_hasLauncher = false;
QString m_display;
Actions m_actions;
XdgDesktopFile m_xdf;
uint m_unreadMessagesNum = 0;
QStringList m_demandsAttentionWinIDs;
QMap m_widToGeometry;
QMap m_widToTitle;
QMap m_widToIcon;
QMap m_widToIconName;
bool m_hasActiveWindow = false;
QString m_quickWidget;
};
TaskManagerItemPrivate::~TaskManagerItemPrivate()
{
qDeleteAll(m_actions);
}
TaskManagerItem::TaskManagerItem(QObject *parent) : QObject(parent), d(new TaskManagerItemPrivate)
{
}
TaskManagerItem::TaskManagerItem(const QString &desktoFile, QObject *parent): QObject(parent), d(new TaskManagerItemPrivate)
{
d->m_desktopFile = desktoFile;
QFileInfo info(d->m_desktopFile);
auto fileName = info.fileName();
if (fileName.endsWith(QStringLiteral(".desktop"))) {
d->m_ID = fileName.left(fileName.size() - 8);
}
d->m_xdf.load(d->m_desktopFile);
}
TaskManagerItem::TaskManagerItem(const QStringList &winIDs, QObject *parent) : QObject(parent), d(new TaskManagerItemPrivate)
{
d->m_winIDs = winIDs;
}
TaskManagerItem::~TaskManagerItem()
{
if(d) {
delete d;
d = nullptr;
}
}
const QString &TaskManagerItem::ID() const
{
return d->m_ID;
}
void TaskManagerItem::setID(const QString &appID)
{
d->m_ID = appID;
}
const QString& TaskManagerItem::desktopFile() const
{
return d->m_desktopFile;
}
void TaskManagerItem::setDesktopFile(const QString&desktopFile)
{
d->m_desktopFile = desktopFile;
d->m_xdf.load(desktopFile);
}
bool TaskManagerItem::hasLauncher() const
{
return d->m_hasLauncher;
}
void TaskManagerItem::setHasLauncher(bool hasLauncher)
{
if(d->m_hasLauncher && hasLauncher) {
return;
}
if(!hasLauncher && d->m_hasLauncher) {
for(Action *action : d->m_actions) {
if(action->type() == Action::Type::RemoveQuickLauncher) {
action->setEnabled(false);
}
if(action->type() == Action::Type::AddQuickLauncher) {
action->setEnabled(true);
}
}
} else if(hasLauncher && !d->m_hasLauncher) {
for(Action *action : d->m_actions) {
if(action->type() == Action::Type::RemoveQuickLauncher) {
action->setEnabled(true);
}
if(action->type() == Action::Type::AddQuickLauncher) {
action->setEnabled(false);
}
}
}
d->m_hasLauncher = hasLauncher;
Q_EMIT dataUpdated(QVector{UkuiTaskManager::HasLauncher, UkuiTaskManager::Actions});
}
const QString &TaskManagerItem::display() const
{
return d->m_display;
}
QString TaskManagerItem::quickWidget() const
{
return d->m_quickWidget;
}
const QString &TaskManagerItem::name() const
{
return d->m_name;
}
const QIcon &TaskManagerItem::icon() const
{
return d->m_icon;
}
const QString &TaskManagerItem::genericName() const
{
return d->m_genericName;
}
const QString &TaskManagerItem::iconName() const
{
return d->m_iconName;
}
const QStringList &TaskManagerItem::winIDs() const
{
return d->m_winIDs;
}
void TaskManagerItem::addWinID(const QString &winId)
{
if(d->m_winIDs.contains(winId)) {
return;
}
d->m_winIDs.append(winId);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WinIdList});
if(WindowManager::isOnCurrentDesktop(winId) || WindowManager::isOnAllDesktops(winId)) {
d->m_winIDsOnCurrentDesktop.append(winId);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::CurrentDesktopWinIdList, UkuiTaskManager::CurrentWinIdList});
}
geometryChanged(winId);
QString title = WindowManager::windowTitle(winId);
if(title.isEmpty()) {
title = d->m_name;
}
d->m_widToTitle.insert(winId, title);
QIcon icon = WindowManager::windowIcon(winId);
if(icon.isNull()) {
icon = d->m_icon;
}
d->m_widToIcon.insert(winId, icon.isNull() ? QVariant("application-x-desktop") : icon);
d->m_widToIconName.insert(winId, icon.name());
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WindowTitles, UkuiTaskManager::WindowIcons, UkuiTaskManager::WindowIconsName});
}
void TaskManagerItem::removeWinID(const QString &winID)
{
bool updateIconName = d->m_winIDs.isEmpty()? false : d->m_winIDs.first() == winID;
if(!d->m_winIDs.isEmpty()) {
d->m_winIDs.removeAll(winID);
d->m_widToTitle.remove(winID);
d->m_widToIcon.remove(winID);
d->m_widToIconName.remove(winID);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WinIdList, UkuiTaskManager::WindowTitles, UkuiTaskManager::WindowIcons, UkuiTaskManager::WindowIconsName});
if(!hasLauncher() && d->m_xdf.name().isEmpty() && !d->m_winIDs.isEmpty() && updateIconName) {
d->m_name = WindowManager::windowTitle(d->m_winIDs.first());
d->m_icon = WindowManager::windowIcon(d->m_winIDs.first());
Q_EMIT dataUpdated(QVector{UkuiTaskManager::Name, UkuiTaskManager::Icon});
}
}
if(d->m_winIDsOnCurrentDesktop.removeAll(winID)) {
Q_EMIT dataUpdated(QVector{UkuiTaskManager::CurrentDesktopWinIdList, UkuiTaskManager::CurrentWinIdList});
}
if(d->m_widToGeometry.remove(winID)) {
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WindowGeometries, UkuiTaskManager::CurrentWinIdList});
}
if(d->m_demandsAttentionWinIDs.removeAll(winID)) {
Q_EMIT dataUpdated(QVector{UkuiTaskManager::DemandsAttentionWinIdList});
}
}
void TaskManagerItem::setHasActiveWindow(bool has)
{
if(d->m_hasActiveWindow != has) {
d->m_hasActiveWindow = has;
Q_EMIT dataUpdated(QVector{UkuiTaskManager::HasActiveWindow});
}
}
bool TaskManagerItem::hasActiveWindow()
{
return d->m_hasActiveWindow;
}
const QString &TaskManagerItem::group() const
{
return d->m_group;
}
void TaskManagerItem::setGroup(const QString &group)
{
d->m_group = group;
}
void TaskManagerItem::init()
{
connect(WindowManager::self(), &WindowManager::currentDesktopChanged, this, &TaskManagerItem::refreshWinIdsOnCurrentDesktop);
connect(WindowManager::self(), &WindowManager::onAllDesktopsChanged, this, &TaskManagerItem::desktopChanged);
connect(WindowManager::self(), &WindowManager::windowDesktopChanged, this, &TaskManagerItem::desktopChanged);
connect(WindowManager::self(), &WindowManager::titleChanged, this, &TaskManagerItem::titleChanged);
connect(WindowManager::self(), &WindowManager::iconChanged, this, &TaskManagerItem::iconChanged);
connect(WindowManager::self(), &WindowManager::demandsAttentionChanged, this, &TaskManagerItem::demandsAttentionChanged);
connect(WindowManager::self(), &WindowManager::geometryChanged, this, &TaskManagerItem::geometryChanged);
connect(WidgetInfo::self(), &WidgetInfo::widgetInfoUpdate, this, &TaskManagerItem::onWidgetInfoUpdate);
d->m_quickWidget = WidgetInfo::self()->widgetFor(d->m_ID);
d->m_name = d->m_xdf.localizedValue("Name").toString();
d->m_iconName = d->m_xdf.iconName();
if(d->m_iconName.startsWith("/")) {
if(QFile::exists(d->m_iconName)) {
d->m_icon = QIcon(d->m_iconName);
}
} else {
d->m_icon = QIcon::fromTheme(d->m_iconName);
if (d->m_icon.isNull()) {
d->m_icon = XdgIcon::fromTheme(d->m_iconName);
}
}
if(!winIDs().isEmpty()) {
//TODO： 获取groupLeader窗口的图标？
if (winIDs().contains(WindowManager::currentActiveWindow())) {
this->setHasActiveWindow(true);
}
if(d->m_icon.isNull()) {
d->m_icon = WindowManager::windowIcon(winIDs().at(0));
}
if(d->m_name.isEmpty()) {
d->m_name = WindowManager::windowTitle(winIDs().at(0));
}
d->m_group = WindowManager::windowGroup(winIDs().at(0));
refreshWinIdsOnCurrentDesktop();
refreshWinIdsOnScreens();
refreshWindowTitlesAndIcons();
}
//添加Action
//desktop中的action
for(const QString &action : d->m_xdf.actions()) {
auto a = new Action(action, d->m_xdf.actionName(action), d->m_xdf.actionIcon(action), Action::Type::DesktopAction, action);
connect(a, &Action::actionTriggered, this, [&](const QVariant& param){
desktopActionActive(param.toString());
});
d->m_actions.append(a);
}
//打开应用
if(d->m_xdf.isValid()) {
d->m_actions.append(new Action(d->m_xdf.name(), d->m_xdf.name(), d->m_icon, Action::Type::NewInstance));
connect(d->m_actions.last(), &Action::actionTriggered, this, &TaskManagerItem::newInstanceActionActive);
}
//添加到任务栏和从任务栏移除
auto removeLauncher = new Action("Remove launcher", tr("Remove launcher from panel"),
QIcon::fromTheme("ukui-unfixed-symbolic"), Action::Type::RemoveQuickLauncher);
connect(removeLauncher, &Action::actionTriggered, this, &TaskManagerItem::removeQuickLauncherActionActive);
removeLauncher->setEnabled(hasLauncher());
d->m_actions.append(removeLauncher);
//NoDisplay为true时无添加到任务栏选项
if (!d->m_xdf.value("NoDisplay").toBool()) {
auto addLauncher = new Action("Add launcher", tr("Add launcher to panel"),
QIcon::fromTheme("ukui-fixed-symbolic"), Action::Type::AddQuickLauncher);
connect(addLauncher, &Action::actionTriggered, this, [&](const QVariant ¶m) {
addQuickLauncherActionActive(param.toInt());
});
addLauncher->setEnabled(!hasLauncher() && !d->m_ID.isEmpty());
d->m_actions.append(addLauncher);
}
//关闭
auto exit = new Action("Close", tr("Close"), QIcon::fromTheme("application-exit-symbolic"), Action::Type::Exit);
connect(exit, &Action::actionTriggered, this, [&](const QVariant& param){
exitActionActive(param.toStringList());
});
d->m_actions.append(exit);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::Actions,
UkuiTaskManager::Id,
UkuiTaskManager::Icon,
UkuiTaskManager::Name});
}
Actions TaskManagerItem::actions() const
{
return d->m_actions;
}
QStringList TaskManagerItem::demandsAttentionWinIDs() const
{
return d->m_demandsAttentionWinIDs;
}
void TaskManagerItem::iconChanged(const QString &windowId)
{
if(d->m_winIDs.contains(windowId)) {
QIcon icon = WindowManager::windowIcon(windowId);
if(icon.isNull()) {
return;
}
d->m_widToIcon.insert(windowId, icon);
d->m_widToIconName.insert(windowId, icon.name());
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WindowIcons, UkuiTaskManager::WindowIconsName});
if(d->m_icon.isNull() && windowId == winIDs().first()) {
d->m_icon = WindowManager::windowIcon(winIDs().at(0));
Q_EMIT dataUpdated(QVector{UkuiTaskManager::Icon});
}
}
}
void TaskManagerItem::titleChanged(const QString &windowId)
{
if(d->m_winIDs.contains(windowId)) {
d->m_widToTitle.insert(windowId, WindowManager::windowTitle(windowId));
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WindowTitles});
if (d->m_name.isEmpty() && windowId == winIDs().first()) {
d->m_name = WindowManager::windowTitle(winIDs().at(0));
Q_EMIT dataUpdated(QVector{UkuiTaskManager::Name});
}
}
}
void TaskManagerItem::desktopChanged(const QString &windowId)
{
if(currentDesktopWinIDs().contains(windowId)) {
if(!WindowManager::isOnAllDesktops(windowId) && !WindowManager::isOnCurrentDesktop(windowId)) {
d->m_winIDsOnCurrentDesktop.removeAll(windowId);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::CurrentDesktopWinIdList, UkuiTaskManager::CurrentWinIdList});
}
} else if (d->m_winIDs.contains(windowId)){
if(WindowManager::isOnAllDesktops(windowId) || WindowManager::isOnCurrentDesktop(windowId)) {
d->m_winIDsOnCurrentDesktop.append(windowId);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::CurrentDesktopWinIdList, UkuiTaskManager::CurrentWinIdList});
}
}
}
void TaskManagerItem::demandsAttentionChanged(const QString &windowId)
{
if(d->m_winIDs.contains(windowId)) {
if(WindowManager::isDemandsAttention(windowId)) {
if(!d->m_demandsAttentionWinIDs.contains(windowId)) {
d->m_demandsAttentionWinIDs.append(windowId);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::DemandsAttentionWinIdList});
}
} else {
if(d->m_demandsAttentionWinIDs.contains(windowId)) {
d->m_demandsAttentionWinIDs.removeAll(windowId);
Q_EMIT dataUpdated(QVector{UkuiTaskManager::DemandsAttentionWinIdList});
}
}
}
}
void TaskManagerItem::geometryChanged(const QString &windowId)
{
if(!d->m_winIDs.contains(windowId)) {
return;
}
d->m_widToGeometry.insert(windowId, WindowManager::geometry(windowId));
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WindowGeometries, UkuiTaskManager::CurrentWinIdList});
}
void TaskManagerItem::refreshWinIdsOnCurrentDesktop()
{
d->m_winIDsOnCurrentDesktop.clear();
for(const QString &wid : d->m_winIDs) {
if(WindowManager::isOnCurrentDesktop(wid) || WindowManager::isOnAllDesktops(wid)) {
d->m_winIDsOnCurrentDesktop.append(wid);
}
}
Q_EMIT dataUpdated(QVector{UkuiTaskManager::CurrentDesktopWinIdList, UkuiTaskManager::CurrentWinIdList});
}
void TaskManagerItem::refreshWinIdsOnScreens()
{
d->m_widToGeometry.clear();
for (const QString &wid: d->m_winIDs) {
d->m_widToGeometry.insert(wid, WindowManager::geometry(wid));
}
Q_EMIT dataUpdated(QVector{UkuiTaskManager::WindowGeometries, UkuiTaskManager::CurrentWinIdList});
}
void TaskManagerItem::refreshWindowTitlesAndIcons()
{
d->m_widToTitle.clear();
for(const QString &wid : d->m_winIDs) {
QString title = WindowManager::windowTitle(wid);
if(title.isEmpty()) {
title = d->m_name;
}
d->m_widToTitle.insert(wid, title);
QIcon icon = WindowManager::windowIcon(wid);
if(icon.isNull()) {
icon = d->m_icon;
}
d->m_widToIcon.insert(wid, icon.isNull() ? QVariant("application-x-desktop") : icon);
d->m_widToIconName.insert(wid, icon.name());
}
}
const QStringList &TaskManagerItem::currentDesktopWinIDs()
{
return d->m_winIDsOnCurrentDesktop;
}
void TaskManagerItem::updateUnreadMessagesNum(const QString &desktopFile, uint num)
{
QFileInfo fileInfo(desktopFile);
QString desktopName;
if (fileInfo.fileName().endsWith(QStringLiteral(".desktop"))) {
desktopName = fileInfo.completeBaseName();
} else {
desktopName = fileInfo.fileName();
}
if(desktopName == d->m_ID) {
qDebug() << "Update unread messagesNum" << desktopFile << num;
d->m_unreadMessagesNum = num;
Q_EMIT dataUpdated(QVector{UkuiTaskManager::UnreadMessagesNum});
}
}
uint TaskManagerItem::unReadMessagesNum()
{
return d->m_unreadMessagesNum;
}
void TaskManagerItem::newInstanceActionActive(const QVariant& param)
{
launch(param.value());
}
void TaskManagerItem::launch(const QQuickItem* item)
{
if(d->m_desktopFile.isEmpty()) {
return;
}
QString method = QStringLiteral("LaunchApp");
if(item) {
method = QStringLiteral("LaunchAppWithGeometry");
}
QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("com.kylin.ProcessManager"),
QStringLiteral("/com/kylin/ProcessManager/AppLauncher"),
QStringLiteral("com.kylin.ProcessManager.AppLauncher"),
method);
message << d->m_desktopFile;
if(item) {
auto point = item->mapToGlobal(QPoint(0, 0));
message << static_cast(point.x()) << static_cast(point.y()) << static_cast(item->width()) << static_cast(item->height());
}
qDebug() << "Taskmanager Calling:" << method << message;
auto watcher = new QDBusPendingCallWatcher(QDBusPendingCall(QDBusConnection::sessionBus().asyncCall(message)));
QObject::connect(watcher, &QDBusPendingCallWatcher::finished, this, [&] (QDBusPendingCallWatcher *self) {
qDebug() << "Taskmanager Calling finished:" << self->isError();
if (self->isError()) {
qDebug() << "launch" << d->m_desktopFile << self->error();
d->m_xdf.startDetached();
}
self->deleteLater();
});
}
void TaskManagerItem::desktopActionActive(const QString &name)
{
d->m_xdf.actionActivate(name, {});
}
void TaskManagerItem::removeQuickLauncherActionActive()
{
UkuiTaskManager::self().removeQuickLauncher(d->m_desktopFile);
}
void TaskManagerItem::addQuickLauncherActionActive(int index)
{
UkuiTaskManager::self().setQuickLauncher(d->m_desktopFile, index);
}
void TaskManagerItem::exitActionActive(const QStringList &winIds)
{
for(const QString &wid : winIds) {
WindowManager::closeWindow(wid);
}
}
void TaskManagerItem::onWidgetInfoUpdate(const QString& appid, const QString& widgetId)
{
if(d->m_ID == appid) {
d->m_quickWidget = widgetId;
Q_EMIT dataUpdated(QVector{UkuiTaskManager::QuickWidgetId});
}
}
const QMap &TaskManagerItem::WindowGeometries() const
{
return d->m_widToGeometry;
}
const QMap &TaskManagerItem::windowTitles() const
{
return d->m_widToTitle;
}
const QMap &TaskManagerItem::windowIcons() const
{
return d->m_widToIcon;
}
const QMap &TaskManagerItem::windowIconsName() const
{
return d->m_widToIconName;
}
void TaskManagerItem::updateIconStatus()
{
Q_EMIT dataUpdated(QVector{UkuiTaskManager::HasActiveWindow, UkuiTaskManager::WindowGeometries, UkuiTaskManager::CurrentWinIdList});
}
ukui-panel/widgets/ukui-panel-widget-test/ 0000775 0001750 0001750 00000000000 15167645100 017535 5 ustar feng feng ukui-panel/widgets/ukui-panel-widget-test/widget/ 0000775 0001750 0001750 00000000000 15167645100 021020 5 ustar feng feng ukui-panel/widgets/ukui-panel-widget-test/widget/ui/ 0000775 0001750 0001750 00000000000 15167645100 021435 5 ustar feng feng ukui-panel/widgets/ukui-panel-widget-test/widget/ui/BlurImageTest.qml 0000664 0001750 0001750 00000002420 15167645100 024655 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
import QtQuick 2.15
import org.ukui.quick.items 1.0
Rectangle {
color: "transparent"
Image {
id: image
width: 1600
height: 900
source: "file:///usr/share/backgrounds/2-openkylin.jpg"
}
BlurItem {
x: 100
y: 100
width: 500
height: 500
radius: 40
samples: 81
source: image
Drag.active: dragArea.drag.active
MouseArea {
id: dragArea
anchors.fill: parent
drag.target: parent
}
}
}
ukui-panel/widgets/ukui-panel-widget-test/widget/ui/main.qml 0000664 0001750 0001750 00000003234 15167645100 023076 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
import QtQuick 2.15
import QtQuick.Layouts 1.15
import org.ukui.quick.widgets 1.0
import org.ukui.menu.starter 1.0
import org.ukui.quick.items 1.0
WidgetItem {
id: root
property bool isHorizontal: Widget.orientation == Types.Horizontal
Layout.preferredWidth: isHorizontal ? 200 : 50
Layout.preferredHeight: !isHorizontal ? 200 : 50
// BlurImageTest {
// anchors.fill: parent
// }
ToolTip.text: Widget.tooltip
MouseArea {
anchors.fill: parent
hoverEnabled: true
onEntered: {
root.ToolTip.show(root.mapToGlobal(root.x, root.y));
}
onExited: {
root.ToolTip.hide();
}
}
Rectangle {
anchors.fill: parent
color: "#407D52BF"
DropArea {
anchors.fill: parent
onDropped: (drop) => {
console.log("drop:", drop.urls, drop.text);
}
}
}
}
ukui-panel/widgets/ukui-panel-widget-test/widget/metadata.json 0000664 0001750 0001750 00000001036 15167645100 023473 0 ustar feng feng {
"Authors": [
{
"Name": "zpf",
"Email": "zpf@kylinos.cn"
}
],
"Id": "org.ukui.panel.widget.test",
"Icon": "ukui-panel",
"Name": "Widget test tool",
"Name[zh_CN]": "组件测试工具",
"Tooltip": "Widget test tool",
"Tooltip[zh_CN]": "组件测试工具",
"Description": "Widget test tool",
"Description[zh_CN]": "组件测试工具",
"Version": "1.0",
"Website": "https://ukui.org",
"BugReport": "https://gitee.com/openkylin/ukui-panel/issues",
"Contents": {
"Main": "ui/main.qml"
}
}
ukui-panel/widgets/ukui-panel-widget-test/CMakeLists.txt 0000664 0001750 0001750 00000000204 15167645100 022271 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
install(DIRECTORY "widget/" DESTINATION "/usr/share/ukui/widgets/org.ukui.panel.widget.test")
ukui-panel/widgets/CMakeLists.txt 0000664 0001750 0001750 00000000671 15167645100 015771 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
project(widgets VERSION 4.1)
add_subdirectory(ukui-task-manager)
add_subdirectory(ukui-menu-starter)
add_subdirectory(ukui-panel-showDesktop)
add_subdirectory(ukui-panel-widget-test)
add_subdirectory(ukui-panel-calendar)
add_subdirectory(ukui-panel-separator)
add_subdirectory(ukui-panel-search)
add_subdirectory(ukui-panel-taskView)
add_subdirectory(ukui-panel-idm)
add_subdirectory(ukui-ai-assistant)
ukui-panel/widgets/ukui-panel-showDesktop/ 0000775 0001750 0001750 00000000000 15167645111 017611 5 ustar feng feng ukui-panel/widgets/ukui-panel-showDesktop/widget/ 0000775 0001750 0001750 00000000000 15167645100 021072 5 ustar feng feng ukui-panel/widgets/ukui-panel-showDesktop/widget/ui/ 0000775 0001750 0001750 00000000000 15167645100 021507 5 ustar feng feng ukui-panel/widgets/ukui-panel-showDesktop/widget/ui/main.qml 0000664 0001750 0001750 00000006460 15167645100 023154 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
import QtQuick 2.12
import QtQuick.Layouts 1.12
import org.ukui.quick.widgets 1.0
import org.ukui.panel.showDesktop 1.0
import org.ukui.quick.items 1.0
import org.ukui.quick.platform 1.0
WidgetItem {
id: root
property bool isHorizontal: Widget.orientation == Types.Horizontal
property real ratio: parent.ratio ? parent.ratio : 1
property real inset: 2 * ratio
Layout.fillWidth: !isHorizontal
Layout.fillHeight: isHorizontal
Layout.preferredHeight: isHorizontal ? height : (15 * ratio + inset)
Layout.preferredWidth: isHorizontal ? (15 * ratio + inset) : width
//使其右键不显示父窗口的菜单
MouseArea {
anchors.fill: root
acceptedButtons: Qt.LeftButton | Qt.RightButton
onClicked: {
if (mouse.button === Qt.RightButton) {
return;
}
}
}
MouseArea {
Accessible.role: Accessible.Button
Accessible.description: "This is a showDesktop button of ukui-panel"
Accessible.name: "show desktop"
anchors.fill: parent
anchors.leftMargin: isHorizontal ? inset : 0
anchors.topMargin: isHorizontal ? 0 : inset
hoverEnabled: true
DtThemeBackground {
anchors.fill: parent
useStyleTransparency: false
backgroundColor: parent.containsPress ? GlobalTheme.kComponentAlphaClick
: parent.containsMouse ? GlobalTheme.kComponentAlphaHover
: GlobalTheme.kComponentAlphaNormal
}
ShowDesktop {
id: showDesktop
}
onClicked: {
//使其右键不显示父窗口的菜单
if (mouse.button === Qt.RightButton) {
return;
} else if (mouse.button === Qt.LeftButton && !showDesktop.disableMouseLeftButton) {
showDesktop.showDesktop();
}
}
Tooltip {
id: tooltip
anchors.fill: parent
mainText: Widget.tooltip
posFollowCursor: false
location: {
switch(Widget.container.position) {
case Types.Bottom:
return Dialog.BottomEdge;
case Types.Left:
return Dialog.LeftEdge;
case Types.Top:
return Dialog.TopEdge;
case Types.Right:
return Dialog.RightEdge;
}
}
margin: 8
}
}
}
ukui-panel/widgets/ukui-panel-showDesktop/widget/metadata.json 0000775 0001750 0001750 00000003345 15167645100 023555 0 ustar feng feng {
"Authors": [
{
"Name": "hxf",
"Email": "hewenfei@kylinos.cn"
}
],
"Id": "org.ukui.panel.showDesktop",
"Icon": "ukui-panel",
"Name": "show desktop",
"Name[zh_CN]": "显示桌面",
"Name[zh_HK]": "顯示桌面",
"Name[bo_CN]": "ཅོག་ངོས་འཆར་བ།",
"Name[ug_CN]": "ئۈستەل يۈزىنى كۆرسىتىش",
"Name[kk_KZ]": "ۇستەل بەتىن كورسەتۋ",
"Name[ky_KG]": "شىرە بەتىن كۅرسۅتۉۉ",
"Name[mn_MN]": "ᠰᠢᠷᠡᠭᠡᠨ ᠭᠠᠳᠠᠷᠭᠤ ᠶᠢ ᠢᠯᠡᠷᠡᠭᠦᠯᠦᠨᠡ",
"Tooltip": "Show desktop",
"Tooltip[zh_CN]": "显示桌面",
"Tooltip[zh_HK]": "顯示桌面",
"Tooltip[bo_CN]": "ཅོག་ངོས་འཆར་བ།",
"Tooltip[ug_CN]": "ئۈستەل يۈزىنى كۆرسىتىش",
"Tooltip[kk_KZ]": "ۇستەل بەتىن كورسەتۋ",
"Tooltip[ky_KG]": "شىرە بەتىن كۅرسۅتۉۉ",
"Tooltip[mn_MN]": "ᠰᠢᠷᠡᠭᠡᠨ ᠭᠠᠳᠠᠷᠭᠤ ᠶᠢ ᠢᠯᠡᠷᠡᠭᠦᠯᠦᠨᠡ",
"Description": "Show desktop",
"Description[zh_CN]": "显示桌面",
"Description[zh_HK]": "顯示桌面",
"Description[bo_CN]": "ཅོག་ངོས་འཆར་བ།",
"Description[ug_CN]": "ئۈستەل يۈزىنى كۆرسىتىش",
"Description[kk_KZ]": "ۇستەل بەتىن كورسەتۋ",
"Description[ky_KG]": "شىرە بەتىن كۅرسۅتۉۉ",
"Description[mn_MN]": "ᠰᠢᠷᠡᠭᠡᠨ ᠭᠠᠳᠠᠷᠭᠤ ᠶᠢ ᠢᠯᠡᠷᠡᠭᠦᠯᠦᠨᠡ",
"Version": "1.0",
"Website": "https://ukui.org",
"BugReport": "https://gitee.com/openkylin/ukui-panel/issues",
"ShowIn": "Panel",
"Contents": {
"Main": "ui/main.qml"
}
}
ukui-panel/widgets/ukui-panel-showDesktop/CMakeLists.txt 0000664 0001750 0001750 00000002565 15167645111 022361 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
project(ukui-panel-showDesktop VERSION 4.1)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
find_package(QT NAMES Qt6 Qt5 COMPONENTS Core Quick REQUIRED)
find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Quick REQUIRED)
find_package(ukui-quick REQUIRED platform)
set(PROJECT_SOURCES
plugin/show-desktop-plugin.h plugin/show-desktop-plugin.cpp
plugin/show-desktop.h plugin/show-desktop.cpp
)
if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES})
else()
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES})
endif()
target_compile_definitions(${PROJECT_NAME}
PRIVATE $<$,$>:QT_QML_DEBUG>
)
target_link_libraries(${PROJECT_NAME}
PRIVATE
Qt${QT_VERSION_MAJOR}::Core
Qt${QT_VERSION_MAJOR}::Quick
ukui-quick::platform
)
set(PLUGIN_INSTALL_ROOT_PATH "/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/qt${QT_VERSION_MAJOR}/qml/org/ukui/panel/showDesktop")
install(DIRECTORY "widget/" DESTINATION "/usr/share/ukui/widgets/org.ukui.panel.showDesktop")
install(FILES "plugin/qmldir" DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
ukui-panel/widgets/ukui-panel-showDesktop/plugin/ 0000775 0001750 0001750 00000000000 15167645100 021105 5 ustar feng feng ukui-panel/widgets/ukui-panel-showDesktop/plugin/qmldir 0000664 0001750 0001750 00000000100 15167645100 022307 0 ustar feng feng module org.ukui.panel.showDesktop
plugin ukui-panel-showDesktop
ukui-panel/widgets/ukui-panel-showDesktop/plugin/show-desktop.h 0000664 0001750 0001750 00000002700 15167645100 023704 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
#ifndef UKUI_PANEL_SHOW_DESKTOP_H
#define UKUI_PANEL_SHOW_DESKTOP_H
#include
namespace UkuiPanel {
class ShowDesktop : public QObject
{
Q_OBJECT
Q_PROPERTY(bool disableMouseLeftButton READ disableMouseLeftButton NOTIFY disableMouseLeftButtonChanged)
public:
explicit ShowDesktop(QObject *parent = nullptr);
~ShowDesktop() override;
Q_INVOKABLE void showDesktop();
bool disableMouseLeftButton() const;
Q_SIGNALS:
void disableMouseLeftButtonChanged();
public Q_SLOTS:
void onFunctionControlChanged(const QString& name, bool exit = false);
private:
void initFunctionControl();
bool m_disableMouseLeftButton = false;
};
} // UkuiPanel
#endif //UKUI_PANEL_SHOW_DESKTOP_H
ukui-panel/widgets/ukui-panel-showDesktop/plugin/show-desktop-plugin.h 0000664 0001750 0001750 00000002076 15167645100 025206 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
#ifndef UKUI_PANEL_SHOW_DESKTOP_PLUGIN_H
#define UKUI_PANEL_SHOW_DESKTOP_PLUGIN_H
#include
class ShowDesktopPlugin : public QQmlExtensionPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
public:
void registerTypes(const char *uri) override;
};
#endif //UKUI_PANEL_SHOW_DESKTOP_PLUGIN_H
ukui-panel/widgets/ukui-panel-showDesktop/plugin/show-desktop.cpp 0000664 0001750 0001750 00000005442 15167645100 024245 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
#include "show-desktop.h"
#include
#include
#include
namespace UkuiPanel {
ShowDesktop::ShowDesktop(QObject *parent) : QObject(parent)
{
initFunctionControl();
}
ShowDesktop::~ShowDesktop()
{
UkuiQuick::FunctionControl::instance()->removeWatch(QStringLiteral("ukui-panel-showDesktop-v11"));
}
void ShowDesktop::showDesktop()
{
UkuiQuick::WindowManager::setShowingDesktop(!UkuiQuick::WindowManager::showingDesktop());
}
bool ShowDesktop::disableMouseLeftButton() const
{
return m_disableMouseLeftButton;
}
void ShowDesktop::onFunctionControlChanged(const QString &name, bool exit)
{
if (name != QStringLiteral("ukui-panel-showDesktop-v11")) {
return;
}
auto controlConfig = exit ? QJsonObject(): UkuiQuick::FunctionControl::instance()->functionControlObject(name).value(name).toObject();
qDebug() << "ShowDesktop function control config:" << controlConfig;
//是否禁用左键点击
if (controlConfig.contains(QStringLiteral("disableMouseLeftButton"))) {
bool disable = controlConfig.value(QStringLiteral("disableMouseLeftButton")).toBool();
if (disable != m_disableMouseLeftButton) {
m_disableMouseLeftButton = disable;
Q_EMIT disableMouseLeftButtonChanged();
}
} else {
m_disableMouseLeftButton = false;
Q_EMIT disableMouseLeftButtonChanged();
}
}
void ShowDesktop::initFunctionControl()
{
//管控配置
UkuiQuick::FunctionControl::instance()->addWatch(QStringLiteral("ukui-panel-showDesktop-v11"));
onFunctionControlChanged(QStringLiteral("ukui-panel-showDesktop-v11"), false);
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlChanged, this, [this](const QString &name) {
onFunctionControlChanged(name, false);
});
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlExit, this, [this]() {
onFunctionControlChanged(QStringLiteral("ukui-panel-showDesktop-v11"), true);
});
}
} // UkuiPanel
ukui-panel/widgets/ukui-panel-showDesktop/plugin/show-desktop-plugin.cpp 0000664 0001750 0001750 00000002013 15167645100 025530 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
#include "show-desktop-plugin.h"
#include "show-desktop.h"
#include
void ShowDesktopPlugin::registerTypes(const char *uri)
{
Q_ASSERT(QLatin1String(uri) == QLatin1String("org.ukui.panel.showDesktop"));
qmlRegisterType(uri, 1, 0, "ShowDesktop");
}
ukui-panel/widgets/ukui-panel-search/ 0000775 0001750 0001750 00000000000 15167645111 016544 5 ustar feng feng ukui-panel/widgets/ukui-panel-search/translations/ 0000775 0001750 0001750 00000000000 15167645100 021263 5 ustar feng feng ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_ky.ts 0000664 0001750 0001750 00000000563 15167645100 026447 0 ustar feng feng
mainSearchٴتىنتۋSearch settingsٴتىنتۋ سالۋ
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_zh_CN.ts 0000664 0001750 0001750 00000000552 15167645100 027023 0 ustar feng feng
mainSearch搜索Search settings设置搜索项
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_es.ts 0000664 0001750 0001750 00000000566 15167645100 026436 0 ustar feng feng
mainSearchSearch settings
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_fr.ts 0000664 0001750 0001750 00000000566 15167645100 026436 0 ustar feng feng
mainSearchSearch settings
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_ug.ts 0000664 0001750 0001750 00000000575 15167645100 026442 0 ustar feng feng
mainSearchئىزدەSearch settingsئىزدەش تەڭشەكلىرى
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_mn.ts 0000664 0001750 0001750 00000000630 15167645100 026431 0 ustar feng feng
mainSearchᠡᠷᠢᠬᠦSearch settingsᠡᠷᠢᠵᠦ ᠪᠠᠶᠢᠷᠢᠯᠠᠭᠤᠯᠬᠤ
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_kk.ts 0000664 0001750 0001750 00000000563 15167645100 026431 0 ustar feng feng
mainSearchٴتىنتۋSearch settingsٴتىنتۋ سالۋ
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_zh_HK.ts 0000664 0001750 0001750 00000000552 15167645100 027025 0 ustar feng feng
mainSearch搜索Search settings設置搜索項
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_bo_CN.ts 0000664 0001750 0001750 00000000742 15167645100 027003 0 ustar feng feng
mainSearchའཚོལ་ཞིབ་བྱེད་པ།Search settingsའཚོལ་ཞིབ་ཀྱི་རྣམ་གྲངས་བཟོ་དགོས།
ukui-panel/widgets/ukui-panel-search/translations/org.ukui.panel.search_de.ts 0000664 0001750 0001750 00000000566 15167645100 026417 0 ustar feng feng
mainSearchSearch settings
ukui-panel/widgets/ukui-panel-search/widget/ 0000775 0001750 0001750 00000000000 15167645100 020025 5 ustar feng feng ukui-panel/widgets/ukui-panel-search/widget/ui/ 0000775 0001750 0001750 00000000000 15167645100 020442 5 ustar feng feng ukui-panel/widgets/ukui-panel-search/widget/ui/main.qml 0000664 0001750 0001750 00000007624 15167645100 022112 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
import QtQuick 2.15
import QtQuick.Layouts 1.15
import org.ukui.quick.widgets 1.0
import org.ukui.panel.search 1.0
import org.ukui.quick.items 1.0
import org.ukui.quick.platform 1.0
WidgetItem {
id: root
property bool isHorizontal: Widget.orientation == Types.Horizontal
property real ratio: parent.ratio ? parent.ratio : 1
Layout.fillWidth: !isHorizontal
Layout.fillHeight: isHorizontal
Layout.preferredWidth: isHorizontal ? height - mouseArea.anchors.topMargin - mouseArea.anchors.bottomMargin : width
Layout.preferredHeight: isHorizontal ? height : width - mouseArea.anchors.leftMargin - mouseArea.anchors.rightMargin
MouseArea {
id: mouseArea
Accessible.role: Accessible.Button
Accessible.description: "This is a global search button of ukui-panel"
Accessible.name: "ukui-panel-search"
anchors.fill: parent
hoverEnabled: true
anchors {
leftMargin: root.isHorizontal? 0 : 4 * root.ratio
topMargin: root.isHorizontal? 4 * root.ratio : 0
rightMargin: root.isHorizontal? 0 : 4 * root.ratio
bottomMargin: root.isHorizontal? 4 * root.ratio : 0
}
DtThemeBackground {
anchors.fill: parent
radius: GlobalTheme.kRadiusNormal
useStyleTransparency: false
backgroundColor: mouseArea.containsPress ? GlobalTheme.kComponentAlphaClick
: mouseArea.containsMouse ? GlobalTheme.kComponentAlphaHover
: GlobalTheme.kContainGeneralAlphaNormal
Icon {
anchors.fill: parent
anchors.margins: 4 * root.ratio
source: "kylin-search"
scale: mouseArea.containsPress ? 0.8 : 1.0
Behavior on scale {
NumberAnimation { duration: 100 }
}
}
}
SearchButton {
id: searchButton
}
acceptedButtons: Qt.LeftButton | Qt.RightButton
onClicked: (mouse) => {
if (mouse.button === Qt.LeftButton && !searchButton.disableMouseLeftButton) {
let globalPos = mapToGlobal(Qt.point(mouseArea.x, mouseArea.y))
searchButton.openUkuiSearch(globalPos.x, globalPos.y, mouseArea.width, mouseArea.height);
}
if (mouse.button === Qt.RightButton && !searchButton.disableMouseRightButton) {
searchButton.openContextMenu(root);
}
}
Tooltip {
id: tooltip
anchors.fill: parent
mainText: Widget.tooltip
posFollowCursor: false
location: {
switch(Widget.container.position) {
case Types.Bottom:
return Dialog.BottomEdge;
case Types.Left:
return Dialog.LeftEdge;
case Types.Top:
return Dialog.TopEdge;
case Types.Right:
return Dialog.RightEdge;
}
}
margin: root.isHorizontal ? 8 + mouseArea.anchors.topMargin : 8 + mouseArea.anchors.leftMargin
}
}
}
ukui-panel/widgets/ukui-panel-search/widget/metadata.json 0000775 0001750 0001750 00000003233 15167645100 022504 0 ustar feng feng {
"Authors": [
{
"Name": "iaom",
"Email": "zhangpengfei@kylinos.cn"
}
],
"Id": "org.ukui.panel.search",
"Icon": "kylin-search",
"Name": "ukui-panel-search",
"Name[zh_CN]": "搜索",
"Name[zh_HK]": "搜索",
"Name[bo_CN]": "བཤེར་འཚོལ།",
"Name[ug_CN]": "ھەممە يەردىن ئىزدەش",
"Name[kk_KZ]": "بارلٸق جەردەن ٸزدەۋ",
"Name[ky_KG]": "باردىق جەردەن ىزدۅۅ",
"Name[mn_MN]": "ᠬᠠᠢᠯᠳᠠ",
"Tooltip": "Global Search",
"Tooltip[zh_CN]": "搜索",
"Tooltip[zh_HK]": "搜索",
"Tooltip[bo_CN]": "བཤེར་འཚོལ་འགོ་སློང་།",
"Tooltip[ug_CN]": "ھەممە يەرنى ئىزدەشنى قوزغىتىش",
"Tooltip[kk_KZ]": "بارلٸق جەردى ىزدەۋدى قوزعالتۋ",
"Tooltip[ky_KG]": "باردىق جەردى ىزدەشتى قوزعوتۇۇ",
"Tooltip[mn_MN]": "ᠬᠠᠢᠯᠳᠠ",
"Description": "Global Search",
"Description[zh_CN]": "启动搜索",
"Description[zh_HK]": "啟動搜索",
"Description[bo_CN]": "བཤེར་འཚོལ་འགོ་སློང་།",
"Description[ug_CN]": "ھەممە يەرنى ئىزدەشنى قوزغىتىش",
"Description[kk_KZ]": "بارلٸق جەردى ىزدەۋدى قوزعالتۋ",
"Description[ky_KG]": "باردىق جەردى ىزدەشتى قوزعوتۇۇ",
"Description[mn_MN]": "ᠬᠠᠢᠯᠳᠠ",
"Version": "1.0",
"Website": "https://ukui.org",
"BugReport": "https://gitee.com/openkylin/ukui-panel/issues",
"ShowIn": "All",
"Contents": {
"Main": "ui/main.qml",
"I18n": "translations/org.ukui.panel.search"
}
}
ukui-panel/widgets/ukui-panel-search/CMakeLists.txt 0000664 0001750 0001750 00000004054 15167645111 021307 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
project(ukui-panel-search VERSION 4.1)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
find_package(QT NAMES Qt6 Qt5 COMPONENTS Core Quick Widgets DBus LinguistTools REQUIRED)
find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Quick Widgets DBus LinguistTools REQUIRED)
find_package(ukui-quick COMPONENTS platform)
set(PROJECT_SOURCES
plugin/search-button.h
plugin/search-plugin.h
plugin/search-plugin.cpp
plugin/search-button.cpp
)
file(GLOB TS_FILES translations/*.ts)
set(SEARCH_WIDGET_DIR "/usr/share/ukui/widgets/org.ukui.panel.search")
set(TRANSLATION_FILE_DIR "${SEARCH_WIDGET_DIR}/translations")
add_compile_definitions(TRANSLATION_FILE_DIR="${TRANSLATION_FILE_DIR}"
UKUI_TASK_MANAGER_VERSION="${UKUI_TASK_MANAGER_VERSION}")
if(COMMAND qt_create_translation)
qt_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES})
else()
qt5_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES})
endif()
if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES} ${QM_FILES})
else()
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES} ${QM_FILES})
endif()
target_compile_definitions(${PROJECT_NAME}
PRIVATE $<$,$>:QT_QML_DEBUG>
)
target_link_libraries(${PROJECT_NAME}
PRIVATE
Qt${QT_VERSION_MAJOR}::Core
Qt${QT_VERSION_MAJOR}::Quick
Qt${QT_VERSION_MAJOR}::DBus
Qt${QT_VERSION_MAJOR}::Widgets
ukui-quick::platform
)
set(PLUGIN_INSTALL_ROOT_PATH "/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/qt${QT_VERSION_MAJOR}/qml/org/ukui/panel/search")
install(DIRECTORY "widget/" DESTINATION ${SEARCH_WIDGET_DIR})
install(FILES ${QM_FILES} DESTINATION "${TRANSLATION_FILE_DIR}")
install(FILES "plugin/qmldir" DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
ukui-panel/widgets/ukui-panel-search/plugin/ 0000775 0001750 0001750 00000000000 15167645100 020040 5 ustar feng feng ukui-panel/widgets/ukui-panel-search/plugin/search-plugin.cpp 0000664 0001750 0001750 00000001773 15167645100 023315 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#include "search-plugin.h"
#include "search-button.h"
#include "qqml.h"
void StartMenuPlugin::registerTypes(const char *uri)
{
Q_ASSERT(QLatin1String(uri) == QLatin1String("org.ukui.panel.search"));
qmlRegisterType(uri, 1, 0, "SearchButton");
}
ukui-panel/widgets/ukui-panel-search/plugin/qmldir 0000664 0001750 0001750 00000000066 15167645100 021255 0 ustar feng feng module org.ukui.panel.search
plugin ukui-panel-search
ukui-panel/widgets/ukui-panel-search/plugin/search-button.h 0000664 0001750 0001750 00000003475 15167645100 023000 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#ifndef UKUI_PANEL_START_MENU_BUTTON_H
#define UKUI_PANEL_START_MENU_BUTTON_H
#include
#include
class SearchButton : public QObject
{
Q_OBJECT
Q_PROPERTY(bool disableMouseLeftButton READ disableMouseLeftButton NOTIFY disableMouseLeftButtonChanged)
Q_PROPERTY(bool disableMouseRightButton READ disableMouseRightButton NOTIFY disableMouseRightButtonChanged)
public:
explicit SearchButton(QObject *parent=nullptr);
~SearchButton() override;
Q_INVOKABLE void openUkuiSearch(int x, int y, int width, int height);
Q_INVOKABLE void openSearchSetting();
Q_INVOKABLE void openContextMenu(QQuickItem *item);
bool disableMouseLeftButton() const;
bool disableMouseRightButton() const;
Q_SIGNALS:
void disableMouseLeftButtonChanged();
void disableMouseRightButtonChanged();
public Q_SLOTS:
void onFunctionControlChanged(const QString& name, bool exit = false);
private:
void initFunctionControl();
bool m_disableMouseLeftButton = false;
bool m_disableMouseRightButton = false;
};
#endif //UKUI_PANEL_START_MENU_BUTTON_H
ukui-panel/widgets/ukui-panel-search/plugin/search-button.cpp 0000664 0001750 0001750 00000012770 15167645100 023331 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#include "search-button.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
SearchButton::SearchButton(QObject *parent) : QObject(parent)
{
initFunctionControl();
}
SearchButton::~SearchButton()
{
UkuiQuick::FunctionControl::instance()->removeWatch(QStringLiteral("ukui-panel-search-v11"));
}
void SearchButton::openUkuiSearch(int x, int y, int width, int height)
{
uint searchPid = QDBusConnection::sessionBus().interface()->servicePid(QStringLiteral("com.ukui.search.service"));
UkuiQuick::StartupManagement::self()->setStartupGeometry(searchPid, x, y, width, height);
QDBusInterface interface(QStringLiteral("com.ukui.search.service"), QStringLiteral("/"), QStringLiteral("org.ukui.search.service"), QDBusConnection::sessionBus());
interface.asyncCall(QStringLiteral("mainWindowSwitch"));
}
void SearchButton::openSearchSetting()
{
bool res(false);
QDBusInterface appLaunchInterface(QStringLiteral("com.kylin.ProcessManager"),
QStringLiteral("/com/kylin/ProcessManager/AppLauncher"),
QStringLiteral("com.kylin.ProcessManager.AppLauncher"),
QDBusConnection::sessionBus());
if(!appLaunchInterface.isValid()) {
qWarning() << qPrintable(QDBusConnection::sessionBus().lastError().message());
res = false;
} else {
appLaunchInterface.setTimeout(10000);
QDBusReply reply = appLaunchInterface.call("LaunchAppWithArguments", "/usr/share/applications/ukui-control-center.desktop", QStringList{"-m", "search"});
if(reply.isValid()) {
res = true;
} else {
qWarning() << "ProcessManager dbus called failed!" << reply.error();
res = false;
}
}
if (!res) {
//打开控制面板对应页面
QProcess::startDetached("ukui-control-center", {"-m", "search"});
}
}
void SearchButton::openContextMenu(QQuickItem *item)
{
QMenu *menu = new QMenu;
menu->setAttribute(Qt::WA_DeleteOnClose);
QAction *searchSettings = new QAction(QIcon::fromTheme("system-settings-symbolic"), tr("Search settings"), menu);
connect(searchSettings, &QAction::triggered, this, &SearchButton::openSearchSetting);
menu->addAction(searchSettings);
//设置父窗口
menu->winId();
if(menu->windowHandle()) {
menu->windowHandle()->setTransientParent(item->window());
}
menu->popup(QCursor::pos());
}
bool SearchButton::disableMouseLeftButton() const
{
return m_disableMouseLeftButton;
}
bool SearchButton::disableMouseRightButton() const
{
return m_disableMouseRightButton;
}
void SearchButton::initFunctionControl()
{
//管控配置
UkuiQuick::FunctionControl::instance()->addWatch(QStringLiteral("ukui-panel-search-v11"));
onFunctionControlChanged(QStringLiteral("ukui-panel-search-v11"), false);
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlChanged, this, [this](const QString &name) {
onFunctionControlChanged(name, false);
});
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlExit, this, [this]() {
onFunctionControlChanged(QStringLiteral("ukui-panel-search-v11"), true);
});
}
void SearchButton::onFunctionControlChanged(const QString &name, bool exit)
{
if (name != QStringLiteral("ukui-panel-search-v11")) {
return;
}
auto controlConfig = exit ? QJsonObject(): UkuiQuick::FunctionControl::instance()->functionControlObject(name).value(name).toObject();
qDebug() << "SearchButton function control config:" << controlConfig;
//是否禁用左键点击
if (controlConfig.contains(QStringLiteral("disableMouseLeftButton"))) {
bool disable = controlConfig.value(QStringLiteral("disableMouseLeftButton")).toBool();
if (disable != m_disableMouseLeftButton) {
m_disableMouseLeftButton = disable;
Q_EMIT disableMouseLeftButtonChanged();
}
} else {
m_disableMouseLeftButton = false;
Q_EMIT disableMouseLeftButtonChanged();
}
//是否禁用右键点击
if (controlConfig.contains(QStringLiteral("disableMouseRightButton"))) {
bool disable = controlConfig.value(QStringLiteral("disableMouseRightButton")).toBool();
if (disable != m_disableMouseRightButton) {
m_disableMouseRightButton = disable;
Q_EMIT disableMouseRightButtonChanged();
}
} else {
m_disableMouseRightButton = false;
Q_EMIT disableMouseRightButtonChanged();
}
}
ukui-panel/widgets/ukui-panel-search/plugin/search-plugin.h 0000664 0001750 0001750 00000002074 15167645100 022755 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#ifndef UKUI_PANEL_START_MENU_PLUGIN_H
#define UKUI_PANEL_START_MENU_PLUGIN_H
#include
class StartMenuPlugin : public QQmlExtensionPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
public:
void registerTypes(const char *uri) override;
};
#endif //UKUI_PANEL_START_MENU_PLUGIN_H
ukui-panel/widgets/ukui-ai-assistant/ 0000775 0001750 0001750 00000000000 15167645111 016602 5 ustar feng feng ukui-panel/widgets/ukui-ai-assistant/i18n/ 0000775 0001750 0001750 00000000000 15167645100 017357 5 ustar feng feng ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_ky.ts 0000664 0001750 0001750 00000000134 15167645100 024573 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_ug.ts 0000664 0001750 0001750 00000000134 15167645100 024563 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_bo_CN.ts 0000664 0001750 0001750 00000000137 15167645100 025133 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_mn.ts 0000664 0001750 0001750 00000000134 15167645100 024562 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_kk.ts 0000664 0001750 0001750 00000000134 15167645100 024555 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_es.ts 0000664 0001750 0001750 00000000134 15167645100 024557 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_zh_CN.ts 0000664 0001750 0001750 00000000137 15167645100 025154 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_zh_HK.ts 0000664 0001750 0001750 00000000137 15167645100 025156 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_de.ts 0000664 0001750 0001750 00000000134 15167645100 024540 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_fr.ts 0000664 0001750 0001750 00000000134 15167645100 024557 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/i18n/org.ukui.ai.assistant_tr.ts 0000664 0001750 0001750 00000000134 15167645100 024575 0 ustar feng feng
ukui-panel/widgets/ukui-ai-assistant/widget/ 0000775 0001750 0001750 00000000000 15167645100 020063 5 ustar feng feng ukui-panel/widgets/ukui-ai-assistant/widget/ui/ 0000775 0001750 0001750 00000000000 15167645100 020500 5 ustar feng feng ukui-panel/widgets/ukui-ai-assistant/widget/ui/main.qml 0000664 0001750 0001750 00000010415 15167645100 022140 0 ustar feng feng /*
* Copyright (C) 2025, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
import QtQuick 2.15
import QtQuick.Layouts 1.15
import org.ukui.quick.widgets 1.0
import org.ukui.ai.assistant 1.0
import org.ukui.quick.items 1.0
import org.ukui.quick.platform 1.0
WidgetItem {
id: root
property bool isHorizontal: Widget.orientation == Types.Horizontal
property real ratio: parent.ratio ? parent.ratio : 1
visible: assistantButton.available
Layout.fillWidth: !isHorizontal
Layout.fillHeight: isHorizontal
Layout.preferredWidth: assistantButton.available ? (isHorizontal ? height - mouseArea.anchors.topMargin - mouseArea.anchors.bottomMargin : width) : 0
Layout.preferredHeight: assistantButton.available ? (isHorizontal ? height : width - mouseArea.anchors.leftMargin - mouseArea.anchors.rightMargin) : 0
property bool isMiniLayout: isHorizontal && (height <= 36)
// 更新tooltip
Widget.tooltip: Widget.tooltip
//使其右键不显示父窗口的菜单
MouseArea {
anchors.fill: root
acceptedButtons: Qt.LeftButton | Qt.RightButton
onClicked: {
if (mouse.button === Qt.RightButton) {
return;
}
}
}
MouseArea {
id: mouseArea
Accessible.role: Accessible.Button
Accessible.description: "This is an ai-assistant button of ukui-panel"
Accessible.name: "kylin-ai-assistant"
anchors.fill: parent
hoverEnabled: true
anchors {
leftMargin: root.isHorizontal? 0 : 4 * root.ratio
topMargin: isMiniLayout ? 2 * root.ratio : root.isHorizontal? 4 * root.ratio : 0
rightMargin: root.isHorizontal? 0 : 4 * root.ratio
bottomMargin: isMiniLayout ? 2 * root.ratio : root.isHorizontal? 4 * root.ratio : 0
}
DtThemeBackground {
anchors.fill: parent
radius: GlobalTheme.kRadiusNormal
useStyleTransparency: false
backgroundColor: mouseArea.containsPress ? GlobalTheme.kComponentAlphaClick
: mouseArea.containsMouse ? GlobalTheme.kComponentAlphaHover
: GlobalTheme.kContainGeneralAlphaNormal
Tooltip {
id: tooltip
anchors.fill: parent
mainText: Widget.tooltip
posFollowCursor: false
location: {
switch(Widget.container.position) {
case Types.Bottom:
return Dialog.BottomEdge;
case Types.Left:
return Dialog.LeftEdge;
case Types.Top:
return Dialog.TopEdge;
case Types.Right:
return Dialog.RightEdge;
}
}
margin: root.isHorizontal ? 8 + mouseArea.anchors.topMargin : 8 + mouseArea.anchors.leftMargin
}
}
Icon {
anchors.fill: parent
anchors.margins: isMiniLayout ? 2 * root.ratio : 4 * root.ratio
source: assistantButton.icon
scale: parent.containsPress ? 0.8 : 1.0
Behavior on scale {
NumberAnimation { duration: 100 }
}
}
onClicked: (mouse) => {
if (mouse.button === Qt.LeftButton && !assistantButton.disableMouseLeftButton) {
assistantButton.pressed();
}
}
}
AiAssistantButton {
id: assistantButton
}
}
ukui-panel/widgets/ukui-ai-assistant/widget/metadata.json 0000775 0001750 0001750 00000002113 15167645100 022536 0 ustar feng feng {
"Authors": [
{
"Name": "iaom",
"Email": "zhangpengfei@kylinos.cn"
}
],
"Id": "org.ukui.ai.assistant",
"Icon": "kylin-ai-assistant",
"Name": "kylin-ai-assistant",
"Name[zh_CN]": "AI 助手",
"Name[zh_HK]": "AI 助手",
"Name[mn_MN]": "AI ᠬᠠᠪᠰᠤᠷᠤᠭᠴᠢ ",
"Name[bo_CN]": "ཨའི་ཨར་རྩིས་རྩོམ་པ",
"Tooltip": "AI Assistant",
"Tooltip[zh_CN]": "AI 助手",
"Tooltip[zh_HK]": "AI 助手",
"Tooltip[mn_MN]": "AI ᠬᠠᠪᠰᠤᠷᠤᠭᠴᠢ ",
"Tooltip[bo_CN]": "ཨའི་ཨར་རྩིས་རྩོམ་པ",
"Description": "Kylin AI Assistant",
"Description[zh_CN]": "AI 助手",
"Description[zh_HK]": "AI 助手",
"Description[mn_MN]": "AI ᠬᠠᠪᠰᠤᠷᠤᠭᠴᠢ ",
"Description[bo_CN]": "ཨའི་ཨར་རྩིས་རྩོམ་པ",
"Version": "1.0",
"Website": "https://ukui.org",
"BugReport": "https://gitee.com/openkylin/ukui-panel/issues",
"ShowIn": "All",
"Contents": {
"Main": "ui/main.qml",
"I18n": "i18n/org.ukui.ai.assistant"
}
}
ukui-panel/widgets/ukui-ai-assistant/CMakeLists.txt 0000664 0001750 0001750 00000003642 15167645111 021347 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
project(ukui-ai-assistant VERSION 4.20)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# TODO: 将依赖倒入的操作放到顶级CMakeList文件中
find_package(QT NAMES Qt6 Qt5 COMPONENTS Core Quick LinguistTools REQUIRED)
find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Quick LinguistTools REQUIRED)
find_package(ukui-quick COMPONENTS platform REQUIRED)
find_package(ukui-search)
set(PROJECT_SOURCES
plugin/ai-assistant-button.cpp
plugin/ai-assistant-button.h
plugin/ai-assistant-plugin.cpp
plugin/ai-assistant-plugin.h
)
file(GLOB TS_FILES i18n/*.ts)
if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
qt_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES} OPTIONS -no-obsolete -no-ui-lines)
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES} ${QM_FILES})
else()
qt5_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES} OPTIONS -no-obsolete -no-ui-lines)
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES} ${QM_FILES})
endif()
target_compile_definitions(${PROJECT_NAME}
PRIVATE $<$,$>:QT_QML_DEBUG>
)
target_link_libraries(${PROJECT_NAME}
PRIVATE
Qt${QT_VERSION_MAJOR}::Core
Qt${QT_VERSION_MAJOR}::Quick
Qt${QT_VERSION_MAJOR}::Widgets
Qt${QT_VERSION_MAJOR}::DBus
ukui-quick::platform
ukui-search
)
set(PLUGIN_INSTALL_ROOT_PATH "/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/qt${QT_VERSION_MAJOR}/qml/org/ukui/ai/assistant")
install(DIRECTORY "widget/" DESTINATION "/usr/share/ukui/widgets/org.ukui.ai.assistant")
install(FILES ${QM_FILES} DESTINATION "/usr/share/ukui/widgets/org.ukui.ai.assistant/i18n")
install(FILES "plugin/qmldir" DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
ukui-panel/widgets/ukui-ai-assistant/plugin/ 0000775 0001750 0001750 00000000000 15167645100 020076 5 ustar feng feng ukui-panel/widgets/ukui-ai-assistant/plugin/qmldir 0000664 0001750 0001750 00000000066 15167645100 021313 0 ustar feng feng module org.ukui.ai.assistant
plugin ukui-ai-assistant
ukui-panel/widgets/ukui-ai-assistant/plugin/ai-assistant-plugin.h 0000664 0001750 0001750 00000002076 15167645100 024150 0 ustar feng feng /*
* Copyright (C) 2025, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#ifndef UKUI_PANEL_START_MENU_PLUGIN_H
#define UKUI_PANEL_START_MENU_PLUGIN_H
#include
class AIAssistantPlugin : public QQmlExtensionPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
public:
void registerTypes(const char *uri) override;
};
#endif //UKUI_PANEL_START_MENU_PLUGIN_H
ukui-panel/widgets/ukui-ai-assistant/plugin/ai-assistant-button.h 0000664 0001750 0001750 00000003523 15167645100 024163 0 ustar feng feng /*
* Copyright (C) 2025, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#ifndef UKUI_PANEL_START_MENU_BUTTON_H
#define UKUI_PANEL_START_MENU_BUTTON_H
#include
namespace UkuiSearch {
class ApplicationInfo;
}
class AiAssistantButton : public QObject
{
Q_OBJECT
Q_PROPERTY(bool available READ available NOTIFY availableChanged)
Q_PROPERTY(QString icon READ icon NOTIFY iconChanged)
Q_PROPERTY(bool disableMouseLeftButton READ disableMouseLeftButton NOTIFY disableMouseLeftButtonChanged)
public:
explicit AiAssistantButton(QObject *parent=nullptr);
~AiAssistantButton() override;
Q_INVOKABLE void pressed();
bool available() const;
QString icon() const;
bool disableMouseLeftButton() const;
Q_SIGNALS:
void availableChanged();
void iconChanged();
void disableMouseLeftButtonChanged();
public Q_SLOTS:
void onFunctionControlChanged(const QString& name, bool exit = false);
private:
void fetchIcon();
void initFunctionControl();
bool m_disableMouseLeftButton = false;
UkuiSearch::ApplicationInfo *m_appInfo = nullptr;
QString m_desktopFile;
QString m_icon;
};
#endif //UKUI_PANEL_START_MENU_BUTTON_H
ukui-panel/widgets/ukui-ai-assistant/plugin/ai-assistant-plugin.cpp 0000664 0001750 0001750 00000002022 15167645100 024472 0 ustar feng feng /*
* Copyright (C) 2025, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#include "ai-assistant-plugin.h"
#include "ai-assistant-button.h"
#include "qqml.h"
void AIAssistantPlugin::registerTypes(const char *uri)
{
Q_ASSERT(QLatin1String(uri) == QLatin1String("org.ukui.ai.assistant"));
qmlRegisterType(uri, 1, 0, "AiAssistantButton");
}
ukui-panel/widgets/ukui-ai-assistant/plugin/ai-assistant-button.cpp 0000664 0001750 0001750 00000014004 15167645100 024512 0 ustar feng feng /*
* Copyright (C) 2025, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: iaom
*
*/
#include "ai-assistant-button.h"
#include
#include
#include
#include
#include
#include
#include
#include
AiAssistantButton::AiAssistantButton(QObject *parent) : QObject(parent)
{
m_appInfo = new UkuiSearch::ApplicationInfo(this);
m_appInfo->desktopFilePathFromName(QStringLiteral("kylin-aiassistant"), m_desktopFile);
if (m_desktopFile.isEmpty()) {
qWarning() << "AiAssistantButton: kylin-aiassistant desktop file not found";
} else {
fetchIcon();
}
connect(m_appInfo, &UkuiSearch::ApplicationInfo::appDBItems2BAdd, this, [this](const QStringList &desktopFiles) {
for (const QString &desktopFile : desktopFiles) {
if (desktopFile.endsWith(QStringLiteral("kylin-aiassistant.desktop"))) {
m_appInfo->desktopFilePathFromName(QStringLiteral("kylin-aiassistant"), m_desktopFile);
fetchIcon();
Q_EMIT availableChanged();
}
}
});
connect(m_appInfo, &UkuiSearch::ApplicationInfo::appDBItems2BDelete, this, [this](const QStringList &desktopFiles) {
for (const QString &desktopFile: desktopFiles) {
if (desktopFile.endsWith(QStringLiteral("kylin-aiassistant.desktop"))) {
m_desktopFile.clear();
m_appInfo->desktopFilePathFromName(QStringLiteral("kylin-aiassistant"), m_desktopFile);
if (!m_desktopFile.isEmpty()) {
fetchIcon();
}
Q_EMIT availableChanged();
}
}
});
connect(m_appInfo, &UkuiSearch::ApplicationInfo::appDBItems2BUpdate, this, [this](UkuiSearch::ApplicationInfoMap infoMap) {
for (const QString &desktopFile : infoMap.keys()) {
if (desktopFile == m_desktopFile) {
auto props = infoMap[desktopFile];
if (props.contains(UkuiSearch::ApplicationProperty::Property::Icon)) {
auto newicon = props[UkuiSearch::ApplicationProperty::Property::Icon].toString();
if (newicon != m_icon) {
m_icon = newicon;
Q_EMIT iconChanged();
}
}
break;
}
}
});
initFunctionControl();
}
AiAssistantButton::~AiAssistantButton()
{
UkuiQuick::FunctionControl::instance()->removeWatch(QStringLiteral("ukui-ai-assistant-v11"));
}
void AiAssistantButton::pressed()
{
qDebug() << "AiAssistantButton::pressed";
QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.ukui.kylin_aiassistant"),
QStringLiteral("/org/ukui/kylin_aiassistant"),
QStringLiteral("org.ukui.kylin_aiassistant"),
QStringLiteral("showOrHideView"));
auto watcher = new QDBusPendingCallWatcher(QDBusPendingCall(QDBusConnection::sessionBus().asyncCall(msg)));
connect(watcher, &QDBusPendingCallWatcher::finished, this, [&] (QDBusPendingCallWatcher *self) {
if (self->isError()) {
qWarning() << "AiAssistantButton::pressed: failed to call showOrHideView" << self->error();
}
self->deleteLater();
});
}
bool AiAssistantButton::available() const
{
return !m_desktopFile.isEmpty();
}
QString AiAssistantButton::icon() const
{
return m_icon;
}
bool AiAssistantButton::disableMouseLeftButton() const
{
return m_disableMouseLeftButton;
}
void AiAssistantButton::fetchIcon()
{
auto icon = m_appInfo->getInfo(m_desktopFile, UkuiSearch::ApplicationProperty::Property::Icon).toString();
if (icon != m_icon) {
m_icon = icon;
Q_EMIT iconChanged();
}
}
void AiAssistantButton::initFunctionControl()
{
//管控配置
UkuiQuick::FunctionControl::instance()->addWatch(QStringLiteral("ukui-ai-assistant-v11"));
onFunctionControlChanged(QStringLiteral("ukui-ai-assistant-v11"), false);
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlChanged, this, [this](const QString &name) {
onFunctionControlChanged(name, false);
});
connect(UkuiQuick::FunctionControl::instance(), &UkuiQuick::FunctionControl::functionControlExit, this, [this]() {
onFunctionControlChanged(QStringLiteral("ukui-ai-assistant-v11"), true);
});
}
void AiAssistantButton::onFunctionControlChanged(const QString &name, bool exit)
{
if (name != QStringLiteral("ukui-ai-assistant-v11")) {
return;
}
auto controlConfig = exit ? QJsonObject(): UkuiQuick::FunctionControl::instance()->functionControlObject(name).value(name).toObject();
qDebug() << "AiAssistantButton function control config:" << controlConfig;
//是否禁用左键点击
if (controlConfig.contains(QStringLiteral("disableMouseLeftButton"))) {
bool disable = controlConfig.value(QStringLiteral("disableMouseLeftButton")).toBool();
if (disable != m_disableMouseLeftButton) {
m_disableMouseLeftButton = disable;
Q_EMIT disableMouseLeftButtonChanged();
}
} else {
m_disableMouseLeftButton = false;
Q_EMIT disableMouseLeftButtonChanged();
}
}
ukui-panel/widgets/ukui-menu-starter/ 0000775 0001750 0001750 00000000000 15167645111 016630 5 ustar feng feng ukui-panel/widgets/ukui-menu-starter/i18n/ 0000775 0001750 0001750 00000000000 15167645111 017407 5 ustar feng feng ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_bo_CN.ts 0000664 0001750 0001750 00000010271 15167645100 025207 0 ustar feng feng
StartMenuButtonLock Screenབརྙན་ཡོལ་དམིགས་འཛིནSwitch Userགློག་སྒོ་འབྱེད་པའི་སྤྱོད་མཁནLog Outདོར་བSuspendལས་མཚམས་བཞག་པ།Hibernateམངལ་གནས་སུ་སྦས་པ།Restartཡང་བསྐྱར་འགོ་འཛུགས་Time Shutdownདུས་གཏན་གནམ་གྲུ་སྒོ་རྒྱག་དགོས།Shut Downལས་མཚམས་འཇོགUpgrade and Restartགསར་སྒྱུར་གལ་ཆེ་མཉམ་དུ་འཛིན་པ།Upgrade and Shut Downགསར་སྒྱུར་བྱས་པར་མ་ཟད་།ཁ་བརྒྱབ་།Estimated %1 hour %2 minutesསྔོན་དཔགས་བྱས་ན། ཆུ་ཚོད %1 དང་སྐར་མ %2Estimated %1 minutesསྔོན་དཔགས་བྱས་ན། སྐར་མ %1mainPower Managerགློག་ཁུངས་དོ་དམ་ཆས་About This Computerའཕྲུལ་ཆས་འདིའི་སྐོར།Network Settingsདྲ་རྒྱའི་སྒྲིག་འགོད།System Monitorརྒྱུད་ཁོངས་སོ་ལྟ་ཆས།Control Centerརྒྱུད་རིམ་ལྡན་པའི་སྒོ་ནས་སྒྲིག་File Managerཡིག་ཆའི་དོ་དམ་ཆས།Searchསྤྱིའི་་བཤེར་འཚོལ།Open Terminal打开终端Switch User or Log Outཐོ་ཁོངས་བརྗེ་བའམ་ཡང་ན་ཐོ་ཁོངས་ནས་བསུབ་དགོས།Powerགློག་ཁུངས་བཅས་ཀྱི་རྣམ་གྲངས་འདེམས་དགོས།Show Desktopཅོག་ཙེའི་ངོས་སུ་མངོནAll Applicationsཉེར་སྤྱོད་ཆ་ཚང་།
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_fr.ts 0000664 0001750 0001750 00000005055 15167645100 024642 0 ustar feng feng
StartMenuButtonLock ScreenSwitch UserLog OutSuspendHibernateRestartTime ShutdownShut DownmainPower ManagerAbout This ComputerNetwork SettingsSystem MonitorControl CenterFile ManagerSearchOpen TerminalSwitch User or Log OutPowerShow DesktopAll Applications
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_ky.ts 0000664 0001750 0001750 00000006300 15167645100 024650 0 ustar feng feng
StartMenuButtonLog Outبەكەر قىلىۋەتمەكHibernateۇيقۇSuspendتوقتوتۇۇRestartقايرا قوزعوتۇۇShut Downجااپ جىبەرۉۉTime ShutdownLock Screenەكىران قۇلۇپتووSwitch Userىشتەتۉۉچۉنۉ الماشتىرۇۇUpgrade and RestartUpgrade and Shut DownEstimated %1 hour %2 minutesEstimated %1 minutesmainSearchىزدۅۅFile Managerۅجۅت ادمئنىستراتورControl CenterPowerSystem Monitorساامالىق كۉزۅتكۉچShow Desktopشىرە بەتىن كۅرسۅتۉۉAll Applicationsباردىق پراگراممالارPower Managerتۅك باشقارعىچAbout This ComputerNetwork Settingsتور تەڭشەكتەرىOpen TerminalSwitch User or Log Out
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_tr.ts 0000664 0001750 0001750 00000004776 15167645100 024671 0 ustar feng feng
StartMenuButtonLog OutLog OutHibernateDerinUykuSuspendAskıya AlRestartYeniden BaşlatShut DownBilgisayarı KapatLock ScreenSwitch UserTime ShutdownmainSearchAraFile ManagerDosya YöneticisiControl CenterPowerSystem MonitorPower ManagerAbout This ComputerNetwork SettingsOpen TerminalSwitch User or Log OutShow DesktopAll Applications
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_kk.ts 0000664 0001750 0001750 00000006360 15167645100 024640 0 ustar feng feng
StartMenuButtonLog Outبوس قىلىۋەتمەكHibernateۇيقىSuspendتوقتاتۋRestartقاتە قوزعالتۋShut DownوشىرۋTime Shutdownۋاقىتتى تاقاۋLock Screenەكٸران قۇلپىلاۋSwitch Userتۇتٸنۋشٸنٸ سايكەستىرۋUpgrade and RestartUpgrade and Shut DownEstimated %1 hour %2 minutesEstimated %1 minutesmainSearchٸزدەۋFile Managerحۇجات اكىمشىControl CenterPowerۇقىق تالدانبالارٸSystem Monitorسەستيما كۇزەتۋشىShow Desktopۇستەل بەتىن كورسەتۋAll Applicationsبارلٸق پٸروگٸراممالارPower Managerتوك باسقارۋشىAbout This Computerنۇ كومپيۋتەر جايىنداNetwork Settingsتور تەڭشەۋلەرىOpen Terminalٸشٸۋ اقىرىSwitch User or Log Outتۇتٸنۋشٸنٸ سايكەستىرۋ ياكي شەگىنۋ
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_mn.ts 0000664 0001750 0001750 00000010337 15167645100 024644 0 ustar feng feng
StartMenuButtonLock Screenᠳᠡᠯᠭᠡᠴᠡ ᠣᠨᠢᠰᠤᠯᠠᠬᠤSwitch Userᠬᠡᠷᠡᠭᠯᠡᠭᠴᠢᠶᠢ ᠰᠤᠯᠢᠬᠤLog Outᠬᠦᠴᠦᠨ ᠦᠭᠡᠶ ᠪᠣᠯᠭᠠᠬᠤSuspendᠵᠤᠭ᠍ᠰᠤᠭᠠᠬᠤHibernateᠢᠴᠡᠬᠡᠯᠡᠬᠦ᠌Restartᠳᠠᠬᠢᠨ ᠡᠬᠢᠯᠡᠬᠦᠯᠬᠦTime Shutdownᠳᠤᠭᠳᠠᠭᠰᠠᠨ ᠴᠠᠭ ᠲᠤ᠌ ᠬᠠᠭᠠᠬᠤShut Downᠮᠠᠰᠢᠨ ᠤᠨᠳᠠᠷᠠᠭᠠᠬᠤUpgrade and Restartᠰᠢᠨᠡᠳᠬᠡᠬᠦ ᠶᠢ ᠵᠡᠷᠭᠡᠪᠡᠷ ᠳᠠᠬᠢᠨ ᠡᠭᠢᠯᠡᠭᠦᠯᠦᠨᠡ ᠃Upgrade and Shut Downᠰᠢᠨᠡᠳᠬᠡᠬᠦ ᠶᠢᠨ ᠬᠠᠮᠲᠤ ᠪᠠᠶᠢᠭᠤᠯᠤᠯᠭᠠ ᠶᠢ ᠰᠢᠨᠡᠳᠬᠡᠨᠡ ᠃Estimated %1 hour %2 minutesᠵᠢᠱᠢᠯᠲᠡ ᠪᠡᠷ ᠨᠢᠭᠡ ᠴᠠᠭ ᠢᠶᠠᠷ 2 ᠮᠢᠨᠦᠢᠲ᠋ ᠃Estimated %1 minutesᠵᠢᠱᠢᠯᠲᠡ ᠪᠡᠷ ᠨᠢᠭᠡ ᠮᠢᠨᠦᠢᠲ᠋ ᠃mainPower Managerᠴᠠᠬᠢᠯᠭᠠᠨ ᠡᠭᠦᠰᠭᠡᠭᠴᠢ ᠵᠢᠨ ᠬᠠᠮᠢᠶᠠᠷᠤᠯᠲᠠ ᠵᠢᠨ ᠪᠠᠭᠠᠵᠢAbout This Computerᠲᠤᠰ ᠮᠠᠰᠢᠨ ᠤ᠋ ᠲᠤᠬᠠᠢNetwork Settingsᠰᠦᠯᠵᠢᠶᠡᠨ ᠤ᠋ ᠳᠤᠬᠢᠷᠠᠭᠤᠯᠭᠠSystem Monitorᠰᠢᠰᠲ᠋ᠧᠮᠦ᠋ᠨ ᠬᠢᠨᠠᠭᠤᠷControl Centerᠡᠵᠡᠮᠳᠡᠯ ᠦᠨ ᠲᠥᠪFile Managerᠹᠠᠢᠯ ᠤ᠋ᠨ ᠬᠠᠮᠢᠶᠠᠷᠤᠭᠤᠷSearchᠪᠦᠬᠦ ᠳᠠᠯᠠ ᠪᠡᠷ ᠬᠠᠢᠬᠤOpen Terminalᠦᠵᠦᠬᠦᠷᠯᠢᠭ ᠢ᠋ ᠨᠡᠬᠡᠬᠡᠬᠦSwitch User or Log Outᠬᠡᠷᠡᠭᠯᠡᠭᠴᠢ ᠵᠢ ᠰᠣᠯᠢᠬᠤ ᠪᠤᠶᠤ ᠳᠠᠩᠰᠠᠨ ᠡᠴᠡ ᠬᠠᠰᠤᠬᠤPowerᠴᠠᠬᠢᠯᠭᠠᠨ ᠡᠬᠦᠰᠬᠡᠭᠴᠢ ᠵᠢᠨ ᠰᠤᠩᠭᠤᠭᠳᠠᠬᠤᠨShow Desktopᠱᠢᠷᠡᠭᠡᠨ ᠨᠢᠭᠤᠷ ᠢ ᠢᠯᠡᠷᠡᠬᠦᠯᠬᠦ᠌All Applicationsᠪᠦᠬᠦ ᠬᠡᠷᠡᠭᠯᠡᠭᠡ
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_de.ts 0000664 0001750 0001750 00000005055 15167645100 024623 0 ustar feng feng
StartMenuButtonLock ScreenSwitch UserLog OutSuspendHibernateRestartTime ShutdownShut DownmainPower ManagerAbout This ComputerNetwork SettingsSystem MonitorControl CenterFile ManagerSearchOpen TerminalSwitch User or Log OutPowerShow DesktopAll Applications
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_es.ts 0000664 0001750 0001750 00000005055 15167645100 024642 0 ustar feng feng
StartMenuButtonLock ScreenSwitch UserLog OutSuspendHibernateRestartTime ShutdownShut DownmainPower ManagerAbout This ComputerNetwork SettingsSystem MonitorControl CenterFile ManagerSearchOpen TerminalSwitch User or Log OutPowerShow DesktopAll Applications
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_ug.ts 0000664 0001750 0001750 00000006270 15167645100 024646 0 ustar feng feng
StartMenuButtonLog Outبىكار قىلىۋەتمەكHibernateئۇيقۇداSuspendئېسىشRestartقايتا قوزغىتىشShut DownتاقىۋېتىشTime ShutdownLock Screenئېكران قۇلۇپلاشSwitch Userئىشلەتكۈچىنى ئالماشتۇرۇشUpgrade and RestartUpgrade and Shut DownEstimated %1 hour %2 minutesEstimated %1 minutesmainSearchئىزدەشFile Managerھۆججەت باشقۇرغۇControl CenterPowerSystem Monitorسىستېما كۆزەتكۈچShow Desktopئۈستەل يۈزىنى كۆرسىتىشAll Applicationsبارلىق پروگراممىلارPower Managerتوك باشقۇرغۇچAbout This ComputerNetwork Settingsتور تەڭشەكلىرىOpen TerminalSwitch User or Log Out
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_zh_HK.ts 0000664 0001750 0001750 00000005665 15167645100 025245 0 ustar feng feng
StartMenuButtonLock Screen鎖定荧幕Switch User切換使用者Log Out註銷Suspend睡眠Hibernate休眠Restart重新啟動Time Shutdown定時關機Shut Down關閉電源Upgrade and Restart更新並重啟Upgrade and Shut Down更新並關機Estimated %1 hour %2 minutes預計 %1 小時 %2 分鐘Estimated %1 minutes預計 %1 分鐘mainPower Manager電源管理About This Computer關於本機Network Settings網絡設置System Monitor系統監視器Control Center控制面板File Manager檔管理員Search搜索Open Terminal打開終端Switch User or Log Out切換用戶或註銷Power電源Show Desktop顯示桌面All Applications所有應用
ukui-panel/widgets/ukui-menu-starter/i18n/org.ukui.menu.starter_zh_CN.ts 0000664 0001750 0001750 00000005651 15167645111 025240 0 ustar feng feng
StartMenuButtonLog Out注销Hibernate休眠Suspend睡眠Restart重启Shut Down关机Time Shutdown定时关机Lock Screen锁定屏幕Switch User切换用户Upgrade and Restart更新并重启Upgrade and Shut Down更新并关机Estimated %1 hour %2 minutes预计 %1 小时 %2 分钟Estimated %1 minutes预计 %1 分钟mainSearch搜索File Manager文件管理器Control Center系统设置Power电源System Monitor系统监视器Show Desktop显示桌面All Applications全部应用Power Manager电源管理About This Computer关于本机Network Settings网络设置Open Terminal打开终端Switch User or Log Out切换用户或注销
ukui-panel/widgets/ukui-menu-starter/widget/ 0000775 0001750 0001750 00000000000 15167645100 020111 5 ustar feng feng ukui-panel/widgets/ukui-menu-starter/widget/ui/ 0000775 0001750 0001750 00000000000 15167645100 020526 5 ustar feng feng ukui-panel/widgets/ukui-menu-starter/widget/ui/main.qml 0000664 0001750 0001750 00000010246 15167645100 022170 0 ustar feng feng /*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
import QtQuick 2.15
import QtQuick.Layouts 1.15
import org.ukui.quick.widgets 1.0
import org.ukui.menu.starter 1.0
import org.ukui.quick.items 1.0
import org.ukui.quick.platform 1.0
WidgetItem {
id: root
property bool isHorizontal: Widget.orientation == Types.Horizontal
property real ratio: parent.ratio ? parent.ratio : 1
Layout.fillWidth: !isHorizontal
Layout.fillHeight: isHorizontal
Layout.preferredWidth: isHorizontal ? height - mouseArea.anchors.topMargin - mouseArea.anchors.bottomMargin : width
Layout.preferredHeight: isHorizontal ? height : width - mouseArea.anchors.leftMargin - mouseArea.anchors.rightMargin
property bool isMiniLayout: isHorizontal && (height <= 36)
Widget.active: StartMenuButton.currentScreen === Widget.container.screen ? StartMenuButton.menuWindowVisible : false
// 更新tooltip
Widget.tooltip: Widget.tooltip
MouseArea {
id: mouseArea
anchors.fill: parent
hoverEnabled: true
Accessible.role: Accessible.Button
Accessible.description: "This is a start menu button of ukui-panel"
Accessible.name: "ukui-menu-starter"
anchors {
leftMargin: root.isHorizontal? 0 : 4 * root.ratio
topMargin: isMiniLayout ? 2 * root.ratio : root.isHorizontal? 4 * root.ratio : 0
rightMargin: root.isHorizontal? 0 : 4 * root.ratio
bottomMargin: isMiniLayout ? 2 * root.ratio : root.isHorizontal? 4 * root.ratio : 0
}
DtThemeBackground {
anchors.fill: parent
radius: GlobalTheme.kRadiusNormal
useStyleTransparency: false
backgroundColor: mouseArea.containsPress ? GlobalTheme.kComponentAlphaClick
: mouseArea.containsMouse ? GlobalTheme.kComponentAlphaHover
: GlobalTheme.kContainGeneralAlphaNormal
Tooltip {
id: tooltip
anchors.fill: parent
mainText: Widget.tooltip
posFollowCursor: false
location: {
switch(Widget.container.position) {
case Types.Bottom:
return Dialog.BottomEdge;
case Types.Left:
return Dialog.LeftEdge;
case Types.Top:
return Dialog.TopEdge;
case Types.Right:
return Dialog.RightEdge;
}
}
margin: root.isHorizontal ? 8 + mouseArea.anchors.topMargin : 8 + mouseArea.anchors.leftMargin
}
}
Icon {
anchors.fill: parent
anchors.margins: isMiniLayout ? 2 * root.ratio : 4 * root.ratio
source: "kylin-startmenu"
scale: parent.containsPress ? 0.8 : 1.0
Behavior on scale {
NumberAnimation { duration: 100 }
}
}
acceptedButtons: Qt.LeftButton | Qt.RightButton
onClicked: (mouse) => {
if (mouse.button === Qt.LeftButton && !StartMenuButton.disableMouseLeftButton) {
StartMenuButton.openStartMenu()
}
if (mouse.button === Qt.RightButton && !StartMenuButton.disableMouseRightButton) {
StartMenuButton.openContextMenu(root)
}
}
}
}
ukui-panel/widgets/ukui-menu-starter/widget/metadata.json 0000775 0001750 0001750 00000003743 15167645100 022576 0 ustar feng feng {
"Authors": [
{
"Name": "iaom",
"Email": "zhangpengfei@kylinos.cn"
}
],
"Id": "org.ukui.menu.starter",
"Icon": "ukui-menu",
"Name": "ukui-menu-starter",
"Name[zh_CN]": "开始菜单启动器",
"Name[zh_HK]": "開始菜單啟動器",
"Name[bo_CN]": "འགོ་འཛུགས་འདེམས་བྱང་འགོ་སློང་ཆས།",
"Name[ug_CN]": "باشلاش تىزىملىكى قوزغاتقۇچى",
"Name[kk_KZ]": "بباستاۋ تٸزٸمدٸگٸ قوزعالتۋ اسپابى",
"Name[ky_KG]": "باشتوو تىزىمدىگى قوزعوتۇۇچۇ",
"Name[mn_MN]": "ᠡᠬᠢᠯᠡᠯᠲᠡ ᠶᠢᠨ ᠲᠣᠪᠶᠣᠭ ᠤᠨ ᠬᠥᠳᠡᠯᠭᠡᠭᠦᠷ",
"Tooltip": "UKUI Menu",
"Tooltip[zh_CN]": "开始菜单",
"Tooltip[zh_HK]": "開始菜單",
"Tooltip[bo_CN]": "འགོ་འཛུགས་འདེམས་བྱང་།",
"Tooltip[ug_CN]": "باشلاش تىزىملىكىنى قوزغىتىش",
"Tooltip[kk_KZ]": "باستاۋ تٸزٸمدٸكدٸ قوزعالتۋ",
"Tooltip[ky_KG]": "باشتوو تىزىمدىگىن قوزعوتۇۇ",
"Tooltip[mn_MN]": "ᠡᠬᠢᠯᠡᠯᠲᠡ ᠶᠢᠨ ᠲᠣᠪᠶᠣᠭ",
"Description": "Start ukui-menu",
"Description[zh_CN]": "启动开始菜单",
"Description[zh_HK]": "啟動開始菜單",
"Description[bo_CN]": "འགོ་འཛུགས་འདེམས་བྱང་འགོ་སློང་།",
"Description[ug_CN]": "باشلاش تىزىملىكىنى قوزغىتىش",
"Description[kk_KZ]": "باستاۋ تٸزٸمدٸكدٸ قوزعالتۋ",
"Description[ky_KG]": "باشتوو تىزىمدىگىن قوزعوتۇۇ",
"Description[mn_MN]": "ᠡᠬᠢᠯᠡᠯᠲᠡ ᠶᠢᠨ ᠲᠣᠪᠶᠣᠭ",
"Version": "1.0",
"Website": "https://ukui.org",
"BugReport": "https://gitee.com/openkylin/ukui-panel/issues",
"ShowIn": "All",
"Contents": {
"Main": "ui/main.qml",
"I18n": "i18n/org.ukui.menu.starter"
}
}
ukui-panel/widgets/ukui-menu-starter/CMakeLists.txt 0000664 0001750 0001750 00000005033 15167645111 021371 0 ustar feng feng cmake_minimum_required(VERSION 3.16)
project(ukui-menu-starter VERSION 4.1)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# TODO: 将依赖倒入的操作放到顶级CMakeList文件中
find_package(QT NAMES Qt6 Qt5 COMPONENTS Core Quick Widgets DBus LinguistTools REQUIRED)
find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Quick Widgets DBus LinguistTools REQUIRED)
find_package(PkgConfig REQUIRED)
find_package(ukui-quick COMPONENTS platform REQUIRED)
find_package(ukui-search)
set(EXTERNAL_LIBS "")
if (QT_VERSION_MAJOR EQUAL "5")
set(PC_PKGS gsettings-qt kysdk-systime)
elseif (QT_VERSION_MAJOR EQUAL "6")
set(PC_PKGS gsettings-qt6 kysdk-systime)
endif()
foreach(external_lib IN ITEMS ${PC_PKGS})
pkg_check_modules(${external_lib} REQUIRED IMPORTED_TARGET ${external_lib})
if(${${external_lib}_FOUND})
include_directories(${${external_lib}_INCLUDE_DIRS})
link_directories(${${external_lib}_LIBRARY_DIRS})
list(APPEND EXTERNAL_LIBS PkgConfig::${external_lib})
endif()
endforeach()
set(PROJECT_SOURCES
plugin/start-menu-plugin.h plugin/start-menu-plugin.cpp
plugin/start-menu-button.h plugin/start-menu-button.cpp
)
file(GLOB TS_FILES i18n/*.ts)
if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
qt_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES} OPTIONS -no-obsolete -no-ui-lines)
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES} ${QM_FILES})
else()
qt5_create_translation(QM_FILES ${CMAKE_CURRENT_SOURCE_DIR} ${TS_FILES} OPTIONS -no-obsolete -no-ui-lines)
add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES} ${QM_FILES})
endif()
target_compile_definitions(${PROJECT_NAME}
PRIVATE $<$,$>:QT_QML_DEBUG>
)
target_link_libraries(${PROJECT_NAME}
PRIVATE
Qt${QT_VERSION_MAJOR}::Core
Qt${QT_VERSION_MAJOR}::Quick
Qt${QT_VERSION_MAJOR}::Widgets
Qt${QT_VERSION_MAJOR}::DBus
ukui-quick::platform
ukui-search
)
set(PLUGIN_INSTALL_ROOT_PATH "/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/qt${QT_VERSION_MAJOR}/qml/org/ukui/menu/starter")
install(DIRECTORY "widget/" DESTINATION "/usr/share/ukui/widgets/org.ukui.menu.starter")
install(FILES ${QM_FILES} DESTINATION "/usr/share/ukui/widgets/org.ukui.menu.starter/i18n")
install(FILES "plugin/qmldir" DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${PLUGIN_INSTALL_ROOT_PATH})
ukui-panel/widgets/ukui-menu-starter/plugin/ 0000775 0001750 0001750 00000000000 15167645111 020126 5 ustar feng feng ukui-panel/widgets/ukui-menu-starter/plugin/qmldir 0000664 0001750 0001750 00000000066 15167645100 021341 0 ustar feng feng module org.ukui.menu.starter
plugin ukui-menu-starter
ukui-panel/widgets/ukui-menu-starter/plugin/start-menu-button.cpp 0000664 0001750 0001750 00000055225 15167645111 024253 0 ustar feng feng
/*
* Copyright (C) 2024, KylinSoft Co., Ltd.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
* Authors: hxf
*
*/
#include "start-menu-button.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
StartMenuButton &StartMenuButton::self()
{
static StartMenuButton s_self;
return s_self;
}
StartMenuButton::StartMenuButton(QObject *parent) : QObject(parent)
{
qRegisterMetaType