Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Kenny Levinsen
|
a3d89aadd5 |
@@ -2,10 +2,6 @@ image: archlinux
|
||||
packages:
|
||||
- rust
|
||||
- libpulse
|
||||
- alsa-lib
|
||||
- fontconfig
|
||||
sources:
|
||||
- https://git.sr.ht/~kennylevinsen/wldash
|
||||
tasks:
|
||||
- rustfmt-check: |
|
||||
cd wldash
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
# These are supported funding model platforms
|
||||
|
||||
liberapay: kennylevinsen
|
||||
Generated
+977
-718
File diff suppressed because it is too large
Load Diff
+18
-24
@@ -1,13 +1,11 @@
|
||||
[package]
|
||||
name = "wldash"
|
||||
version = "0.3.0"
|
||||
version = "0.2.0"
|
||||
authors = ["Kenny Levinsen <kl@kl.wtf>"]
|
||||
edition = "2021"
|
||||
edition = "2018"
|
||||
|
||||
[profile.release]
|
||||
lto = "fat"
|
||||
panic = "abort"
|
||||
opt-level = "z"
|
||||
|
||||
[features]
|
||||
default = ["alsa-widget", "pulseaudio-widget", "yaml-cfg", "json-cfg"]
|
||||
@@ -20,31 +18,27 @@ alsa-widget = ["alsa"]
|
||||
pulseaudio-widget = ["libpulse-binding"]
|
||||
|
||||
[dependencies]
|
||||
byteorder = "1.4"
|
||||
bitflags = "1.3"
|
||||
dlib = "0.5"
|
||||
rusttype = "^0.9"
|
||||
smithay-client-toolkit = "0.6.4"
|
||||
byteorder = "1.3"
|
||||
rusttype = "0.7"
|
||||
failure = "0.1.5"
|
||||
chrono = "0.4"
|
||||
nix = "0.26"
|
||||
nix = "0.15"
|
||||
memmap = "0.7"
|
||||
os_pipe = "1.1"
|
||||
wayland-client = { version = "0.29"}
|
||||
wayland-protocols = { version = "0.29", features = ["client", "unstable_protocols"] }
|
||||
os_pipe = "0.8"
|
||||
wayland-client = { version = "0.23", features = ["dlopen"] }
|
||||
wayland-protocols = { version = "0.23", features = ["client", "unstable_protocols"] }
|
||||
wl-clipboard-rs = { version = "0.3" }
|
||||
dbus = "0.6"
|
||||
fuzzy-matcher = "0.3"
|
||||
fuzzy-matcher = "0.2"
|
||||
lazy_static = "1.4"
|
||||
rcalc_lib = "1.0"
|
||||
rust-ini = "0.18"
|
||||
shlex = "1.1"
|
||||
timerfd = "1.4.0"
|
||||
walkdir = "2.3"
|
||||
itertools = "0.10"
|
||||
rcalc_lib = { version = "0.9" }
|
||||
rust-ini = "0.13"
|
||||
shlex = "0.1"
|
||||
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
serde_json = { version = "1.0", optional = true }
|
||||
serde_yaml = { version = "0.9", optional = true }
|
||||
serde_yaml = { version = "0.8", optional = true }
|
||||
|
||||
libpulse-binding = { version = "2.26", optional = true }
|
||||
alsa = { version = "0.7.0", optional = true }
|
||||
fontconfig = "0.6.0"
|
||||
unicode-segmentation = "1.10.0"
|
||||
libpulse-binding = { version = "2.11", optional = true }
|
||||
alsa = { version = "0.3.0", optional = true }
|
||||
|
||||
@@ -1,7 +1,5 @@
|
||||
# wldash
|
||||
|
||||
|
||||
|
||||
A dashboard/launcher/control-panel thing for Wayland. Requires wlr-layer-shell-unstable-v1.
|
||||
|
||||
Consider this alpha-quality: While it works, *everything* is subject to change with a moments notice. You may end up pulling in the latest changes, and *poof*, wldash suddenly turns into an artisan espresso machine.
|
||||
@@ -56,7 +54,6 @@ Using backlight sys file, only visible of backlight is detected. Scroll to adjus
|
||||
Loads desktop files from the usual locations.
|
||||
|
||||
The launcher also accepts prefix operators to change its mode:
|
||||
|
||||
- `!`: Arbitrary command
|
||||
- `=`: Calculator based on rcalc_lib. See https://docs.rs/rcalc_lib/0.9.3/rcalc_lib/
|
||||
|
||||
@@ -66,7 +63,3 @@ The launcher also accepts prefix operators to change its mode:
|
||||
- Configurability
|
||||
- Cleanup and reorganization
|
||||
- Proper line editor for the launcher
|
||||
|
||||
## How to discuss
|
||||
|
||||
Go to #kennylevinsen @ irc.libera.chat to discuss, or use [~kennylevinsen/public-inbox@lists.sr.ht](https://lists.sr.ht/~kennylevinsen/public-inbox).
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 130 KiB |
+4
-4
@@ -23,7 +23,7 @@
|
||||
},{
|
||||
"margin": {
|
||||
"margins": [0,0,0,8],
|
||||
"widget": {"backlight": {"device": "intel_backlight", "font_size": 24.0,"length": 600}}
|
||||
"widget": {"backlight": {"font_size": 24.0,"length": 600}}
|
||||
}
|
||||
},{
|
||||
"margin": {
|
||||
@@ -37,8 +37,8 @@
|
||||
{"launcher": {
|
||||
"font_size": 32.0,
|
||||
"length": 1200,
|
||||
"app_opener": "swaymsg exec -- ",
|
||||
"term_opener": "foot --",
|
||||
"app_opener": "swaymsg exec ",
|
||||
"term_opener": "alacritty -e ",
|
||||
"url_opener": "xdg-open "
|
||||
}}
|
||||
]}
|
||||
@@ -52,4 +52,4 @@
|
||||
"blue": 0,
|
||||
"opacity": 0.9
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-3
@@ -30,7 +30,6 @@ widget:
|
||||
margins: [0, 0, 0, 8]
|
||||
widget:
|
||||
backlight:
|
||||
device: "intel_backlight"
|
||||
font_size: 24.0
|
||||
length: 600
|
||||
- margin:
|
||||
@@ -45,6 +44,6 @@ widget:
|
||||
- launcher:
|
||||
font_size: 32.0
|
||||
length: 1200
|
||||
app_opener: "swaymsg exec --"
|
||||
term_opener: "foot --"
|
||||
app_opener: "swaymsg exec "
|
||||
term_opener: "alacritty -e "
|
||||
url_opener: "xdg-open "
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,38 @@
|
||||
|
||||
==========================================================
|
||||
|
||||
Wen Quan Yi Micro Hei
|
||||
|
||||
ChangeLog
|
||||
|
||||
----------------------------------------------------------
|
||||
|
||||
WenQuanYi Micro Hei ChangeLog:
|
||||
|
||||
== WenQuanYi Micro Hei 0.2 (BigBang), FangQ <fangq nmr mgh harvard edu> ==
|
||||
|
||||
2009/05/25 Updated contributor list in the NB and announced beta release
|
||||
2009/05/18 fixed hinting instr for M/N in MicroHeiMono by copying cvt table (F
|
||||
angQ)
|
||||
2009/05/16 added Micro Hei Mono by merging with Droid Sans Mono (FangQ)
|
||||
2009/05/15 rename uni00B9 to onesuperior to match the it in DroidSans (FangQ)
|
||||
2009/05/10 updated documentations (FangQ)
|
||||
2009/05/09 scale MicroHei to EM=2048 before merging to Droid Sans, keep
|
||||
all hinting and kerning info. (FangQ)
|
||||
2009/04/12 imported Chinese punctuations from UmeGothic (FangQ)
|
||||
2009/02/08 all characters in U4E00~U9FC3 were complete (review panel, wanghong
|
||||
)
|
||||
2009/01/16 Micro Hei nightly-build became active (FangQ)
|
||||
2009/01/15 GBK glyph review process started (FangQ)
|
||||
2009/01/03 Fontopia supported sub-contour editing (FangQ)
|
||||
2008/12/31 GBK char-set completed 90%, CJK Ext. A became online
|
||||
2008/12/29 project publicly announcement (FangQ)
|
||||
2008/12/09 Droid Font license confirmed (Apache2 as committed in git)
|
||||
2008/12/03 add theme and rename as Fontopia (FangQ)
|
||||
2008/11/23 Droid extension GUI milestone reached (mozbug, FangQ)
|
||||
2008/11/07 initial upload of BezierGlyph/Bezier_lib.js script (mozbug)
|
||||
2008/11/06 code point and script preparation (mozbug)
|
||||
2008/10/21 project conceptualized (FangQ)
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,122 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this
|
||||
document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code,
|
||||
documentation source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not
|
||||
limited to compiled object code, generated documentation, and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which
|
||||
the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship.
|
||||
For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by
|
||||
name) to the interfaces of, the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to
|
||||
that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition,
|
||||
"submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including
|
||||
but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are
|
||||
managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is
|
||||
conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor
|
||||
and subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a
|
||||
perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works
|
||||
of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with
|
||||
the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim
|
||||
or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or
|
||||
contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the
|
||||
date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You meet the following conditions:
|
||||
|
||||
1. You must give any other recipients of the Work or Derivative Works a copy of this License; and
|
||||
|
||||
2. You must cause any modified files to carry prominent notices stating that You changed the files; and
|
||||
|
||||
3. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative
|
||||
Works; and
|
||||
|
||||
4. If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to
|
||||
any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the
|
||||
Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display
|
||||
generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for
|
||||
informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You
|
||||
distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot
|
||||
be construed as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the
|
||||
Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have
|
||||
executed with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the
|
||||
Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of
|
||||
the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume
|
||||
any risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as
|
||||
a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has
|
||||
been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred
|
||||
by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
APPENDIX: How to apply the Apache License to your work
|
||||
|
||||
To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment
|
||||
syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed
|
||||
page" as the copyright notice for easier identification within third-party archives.
|
||||
Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
|
||||
except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless
|
||||
required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing
|
||||
permissions and limitations under the License.
|
||||
@@ -0,0 +1,674 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
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.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<http://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
|
||||
@@ -0,0 +1,378 @@
|
||||
|
||||
==========================================================
|
||||
|
||||
Wen Quan Yi Micro Hei
|
||||
|
||||
Release Notes
|
||||
|
||||
----------------------------------------------------------
|
||||
|
||||
Summary:
|
||||
|
||||
Author : WenQuanYi Project Contributors
|
||||
Webpage : http://wenq.org/en/ or http://wqy.sourceforge.net/en/
|
||||
Font Name: WenQuanYi Micro Hei
|
||||
Version : 0.2.0-beta (Big-Bang)
|
||||
Release : 0
|
||||
Copyright Digitized data copyright © 2007, Google Corporation.
|
||||
Copyright © 2008-2009, WenQuanYi Project Board of
|
||||
Trustees, All rights reserved.
|
||||
|
||||
Droid Sans Fallback extension interface
|
||||
( http://wenq.org/index.cgi?Fontopia(cn) ),
|
||||
copyright © 2008-2009 mozbug and Qianqian Fang
|
||||
License : This font is licensed under Apache2.0 or GPLv3
|
||||
with font embedding exceptions (see Appendix B).
|
||||
Read LICENSE_Apache2.txt and LICENSE_GPLv3.txt for details
|
||||
|
||||
----------------------------------------------------------
|
||||
|
||||
Table of Content
|
||||
|
||||
I. About this font
|
||||
II. Development History
|
||||
III. Credits
|
||||
IV. Language Coverage
|
||||
V. About "WenQuanYi Project"
|
||||
VI. Links
|
||||
VII. Appendix
|
||||
|
||||
----------------------------------------------------------
|
||||
|
||||
|
||||
I. About this font
|
||||
|
||||
WenQuanYi Micro Hei font family is a Sans-Serif style (also known as Hei,
|
||||
Gothic or Dotum among the Chinese/Japanese/Korean users) high quality
|
||||
CJK outline font. It was derived from "Droid Sans Fallback", "Droid
|
||||
Sans" and "Droid Sans Mono" released by Google Corp. This font package
|
||||
contains two faces, "Micro Hei" and "Micro Hei Mono", in form of a
|
||||
True-Type Collection (ttc) file. All the unified CJK Han glyphs, i.e.
|
||||
GBK Hanzi, in the range of U+4E00-U+9FC3 defined in Unicode Standard 5.1
|
||||
are covered, with additional support to many other international
|
||||
languages such as Latin, Extended Latin, Hanguls and Kanas. The font
|
||||
file is extremely compact (~5M) compared with most known CJK fonts.
|
||||
As a result, it can be used for hand-held devices or embedded systems, or
|
||||
used on PC with a significantly small memory footprint. Because both
|
||||
font faces carry hinting and kerning instructions for Latin glyphs,
|
||||
they are the excellent choices for desktop fonts.
|
||||
|
||||
|
||||
II. Development History
|
||||
|
||||
The original Droid Sans Fallback font contain 16,000 Unified Han glyphs,
|
||||
and was officially released by Google under Apache2 license on Dec. 9,
|
||||
2008 [2]. With a Javascript-based web interface, Fontopia(TM) [1], developed
|
||||
by mozbug and Qianqian Fang, the WenQuanYi contributors had completed
|
||||
over 10,000 new glyphs by combining the spline contours from the existing
|
||||
Droid Han glyphs. By the end of 2008, project phase-1 had almost
|
||||
completed, and phase-2 for CJK Extension A (U+3400-U+4DB5) was brought
|
||||
online on Dec. 29, 2009. A review panel was formed to reinforce the
|
||||
quality of all submitted glyphs [3]. In Jan. 2009, the reviewers
|
||||
had redone over 2000 Hanzi and completed all the missing characters.
|
||||
The nightly-build font has become online since Jan. 16. As of Feb. 2009, there
|
||||
has been over 5500 CJK Extension A Han glyphs completed, which led this
|
||||
font toward a complete GB18030 coverage.
|
||||
|
||||
In this font, we incorporated the high quality Latin glyphs from "Droid Sans"
|
||||
and "Droid Sans Mono", which contain not only a better coverage but also
|
||||
the additional hinting and kerning information. The EM of MicroHei
|
||||
and MicroHeiMono fonts were unified to 2048 to retain all the advanced
|
||||
typesetting features.
|
||||
|
||||
|
||||
III. Credits
|
||||
|
||||
We cordially thank Google(TM) for generously releasing Droid fonts to
|
||||
public under an open-source license. Google purchased the font from
|
||||
Ascenders Corp. (which was originally designed by a Chinese company).
|
||||
|
||||
The project for extending the Droid fonts is based on the web-based
|
||||
glyph-composing applet [1], created by mozbug and Qianqian Fang
|
||||
jointly. They are constantly improving this application targeting at
|
||||
a web-based collaborative font development environment.
|
||||
|
||||
Over a thousand anonymous contributors have participated the project;
|
||||
they submitted over 10,000 new Hanzi glyphs and many modifications.
|
||||
The full update history of the glyphs can be found at [4].
|
||||
|
||||
The key members of the review panel, i.e. lsz, FangQ, kmc, Xhacker,
|
||||
philacorns, and an "anonymous" (as requested) contributor, had
|
||||
spent significant amount of efforts to redesign nearly half of the
|
||||
submitted glyphs. We appreciate the incredible effort from this team
|
||||
to make this font available. The detailed review credit can be found
|
||||
at [3]
|
||||
|
||||
|
||||
IV. Language Coverage
|
||||
|
||||
The following table is based on the locale data provided by fontconfig
|
||||
(generated by langcover.pl from Dejavu Project
|
||||
http://dejavu.sourceforge.net/wiki/index.php/Font_utilities).
|
||||
----------------------------------------------------------------
|
||||
Locale MicroHei
|
||||
----------------------------------------------------------------
|
||||
aa Afar 100% (62/62)
|
||||
ab Abkhazia 100% (90/90)
|
||||
af Afrikaans 100% (69/69)
|
||||
am Amharic (0/264)
|
||||
ar Arabic (0/125)
|
||||
as (0/89)
|
||||
ast Asturian 100% (72/72)
|
||||
ava Avaric 100% (67/67)
|
||||
ay Aymara 100% (60/60)
|
||||
az Azerbaijani 98% (146/148)
|
||||
az-ir Azerbaijani in Iran (0/130)
|
||||
ba Bashkir 100% (82/82)
|
||||
bam Bambara 90% (54/60)
|
||||
be Byelorussian 100% (68/68)
|
||||
bg Bulgarian 100% (60/60)
|
||||
bh Bihari (Devanagari script) (0/68)
|
||||
bho Bhojpuri (Devanagari script) (0/68)
|
||||
bi Bislama 100% (58/58)
|
||||
bin Edo or Bini 100% (78/78)
|
||||
bn Bengali (0/89)
|
||||
bo Tibetan (0/95)
|
||||
br Breton 100% (64/64)
|
||||
bs Bosnian 100% (62/62)
|
||||
bua Buriat (Buryat) 100% (70/70)
|
||||
ca Catalan 100% (74/74)
|
||||
ce Chechen 100% (67/67)
|
||||
ch Chamorro 100% (58/58)
|
||||
chm Mari (Lower Cheremis / Upper Cheremis) 100% (76/76)
|
||||
chr Cherokee (0/85)
|
||||
co Corsican 100% (85/85)
|
||||
cs Czech 100% (82/82)
|
||||
cu Old Church Slavonic 100% (103/103)
|
||||
cv Chuvash 100% (74/74)
|
||||
cy Welsh 100% (78/78)
|
||||
da Danish 100% (70/70)
|
||||
de German 100% (60/60)
|
||||
dz Dzongkha (0/95)
|
||||
el Greek 100% (70/70)
|
||||
en English 100% (73/73)
|
||||
eo Esperanto 100% (64/64)
|
||||
es Spanish 100% (67/67)
|
||||
et Estonian 100% (64/64)
|
||||
eu Basque 100% (56/56)
|
||||
fa Persian (0/129)
|
||||
fi Finnish 100% (63/63)
|
||||
fj Fijian 100% (52/52)
|
||||
fo Faroese 100% (68/68)
|
||||
fr French 100% (85/85)
|
||||
ful Fulah (Fula) 87% (54/62)
|
||||
fur Friulian 100% (66/66)
|
||||
fy Frisian 100% (75/75)
|
||||
ga Irish 82% (66/80)
|
||||
gd Scots Gaelic 100% (70/70)
|
||||
gez Ethiopic (Geez) (0/218)
|
||||
gl Galician 100% (66/66)
|
||||
gn Guarani 100% (70/70)
|
||||
gu Gujarati (0/78)
|
||||
gv Manx Gaelic 100% (54/54)
|
||||
ha Hausa 86% (52/60)
|
||||
haw Hawaiian 98% (62/63)
|
||||
he Hebrew (0/27)
|
||||
hi Hindi (Devanagari script) (0/68)
|
||||
ho Hiri Motu 100% (52/52)
|
||||
hr Croatian 100% (62/62)
|
||||
hu Hungarian 100% (70/70)
|
||||
hy Armenian (0/77)
|
||||
ia Interlingua 100% (52/52)
|
||||
ibo Igbo 100% (58/58)
|
||||
id Indonesian 100% (54/54)
|
||||
ie Interlingue 100% (52/52)
|
||||
ik Inupiaq (Inupiak, Eskimo) 100% (68/68)
|
||||
io Ido 100% (52/52)
|
||||
is Icelandic 100% (70/70)
|
||||
it Italian 100% (73/73)
|
||||
iu Inuktitut (0/161)
|
||||
ja Japanese 99% (6526/6538)
|
||||
ka Georgian (0/33)
|
||||
kaa Kara-Kalpak (Karakalpak) 100% (78/78)
|
||||
ki Kikuyu 100% (56/56)
|
||||
kk Kazakh 100% (77/77)
|
||||
kl Greenlandic 100% (81/81)
|
||||
km Khmer (0/70)
|
||||
kn Kannada (0/80)
|
||||
ko Korean 100% (2443/2443)
|
||||
kok Kokani (Devanagari script) (0/68)
|
||||
ks Kashmiri (Devanagari script) (0/68)
|
||||
ku Kurdish 100% (64/64)
|
||||
ku-ir Kurdish in Iran (0/32)
|
||||
kum Kumyk 100% (66/66)
|
||||
kv Komi (Komi-Permyak/Komi-Siryan) 100% (70/70)
|
||||
kw Cornish 96% (62/64)
|
||||
ky Kirgiz 100% (70/70)
|
||||
la Latin 100% (68/68)
|
||||
lb Luxembourgish (Letzeburgesch) 100% (75/75)
|
||||
lez Lezghian (Lezgian) 100% (67/67)
|
||||
ln Lingala 92% (75/81)
|
||||
lo Lao (0/65)
|
||||
lt Lithuanian 100% (70/70)
|
||||
lv Latvian 100% (78/78)
|
||||
mg Malagasy 100% (56/56)
|
||||
mh Marshallese 100% (62/62)
|
||||
mi Maori 96% (62/64)
|
||||
mk Macedonian 100% (42/42)
|
||||
ml Malayalam (0/78)
|
||||
mn Mongolian (0/130)
|
||||
mo Moldavian 98% (126/128)
|
||||
mr Marathi (Devanagari script) (0/68)
|
||||
mt Maltese 100% (72/72)
|
||||
my Burmese (Myanmar) (0/48)
|
||||
nb Norwegian Bokmal 100% (70/70)
|
||||
nds Low Saxon 100% (59/59)
|
||||
ne Nepali (Devanagari script) (0/68)
|
||||
nl Dutch 100% (83/83)
|
||||
nn Norwegian Nynorsk 100% (76/76)
|
||||
no Norwegian (Bokmal) 100% (70/70)
|
||||
ny Chichewa 100% (54/54)
|
||||
oc Occitan 100% (70/70)
|
||||
om Oromo or Galla 100% (52/52)
|
||||
or Oriya (0/79)
|
||||
os Ossetic 100% (66/66)
|
||||
pa Punjabi (Gurumukhi script) (0/63)
|
||||
pl Polish 100% (70/70)
|
||||
ps-af Pashto in Afghanistan (0/49)
|
||||
ps-pk Pashto in Pakistan (0/49)
|
||||
pt Portuguese 100% (83/83)
|
||||
rm Rhaeto-Romance (Romansch) 100% (66/66)
|
||||
ro Romanian 96% (60/62)
|
||||
ru Russian 100% (66/66)
|
||||
sa Sanskrit (Devanagari script) (0/68)
|
||||
sah Yakut 100% (76/76)
|
||||
sco Scots 92% (52/56)
|
||||
se North Sami 100% (66/66)
|
||||
sel Selkup (Ostyak-Samoyed) 100% (66/66)
|
||||
sh Serbo-Croatian 100% (76/76)
|
||||
si Sinhala (Sinhalese) (0/77)
|
||||
sk Slovak 100% (86/86)
|
||||
sl Slovenian 100% (62/62)
|
||||
sm Samoan 98% (52/53)
|
||||
sma South Sami 100% (60/60)
|
||||
smj Lule Sami 100% (60/60)
|
||||
smn Inari Sami 100% (68/68)
|
||||
sms Skolt Sami 87% (70/80)
|
||||
so Somali 100% (52/52)
|
||||
sq Albanian 100% (56/56)
|
||||
sr Serbian 100% (76/76)
|
||||
sv Swedish 100% (68/68)
|
||||
sw Swahili 100% (52/52)
|
||||
syr Syriac (0/45)
|
||||
ta Tamil (0/48)
|
||||
te Telugu (0/80)
|
||||
tg Tajik 100% (78/78)
|
||||
th Thai 1% (1/87)
|
||||
ti-er Eritrean Tigrinya (0/256)
|
||||
ti-et Ethiopian Tigrinya (0/282)
|
||||
tig Tigre (0/221)
|
||||
tk Turkmen 100% (74/74)
|
||||
tl Tagalog (0/19)
|
||||
tn Tswana 100% (56/56)
|
||||
to Tonga 98% (52/53)
|
||||
tr Turkish 100% (70/70)
|
||||
ts Tsonga 100% (52/52)
|
||||
tt Tatar 100% (76/76)
|
||||
tw Twi 91% (67/73)
|
||||
tyv Tuvinian 100% (70/70)
|
||||
ug Uighur (0/125)
|
||||
uk Ukrainian 100% (72/72)
|
||||
ur Urdu (0/145)
|
||||
uz Uzbek 100% (68/68)
|
||||
ven Venda 83% (52/62)
|
||||
vi Vietnamese 98% (191/194)
|
||||
vo Volapuk 100% (54/54)
|
||||
vot Votic 100% (62/62)
|
||||
wa Walloon 100% (70/70)
|
||||
wen Sorbian languages (lower and upper) 100% (76/76)
|
||||
wo Wolof 100% (66/66)
|
||||
xh Xhosa 100% (52/52)
|
||||
yap Yapese 100% (58/58)
|
||||
yi Yiddish (0/27)
|
||||
yo Yoruba 91% (109/119)
|
||||
zh-936 99% (21873/21920)
|
||||
zh-cn Chinese (simplified) 99% (6754/6765)
|
||||
zh-hk Chinese Hong Kong Supplementary Character Set 99% (2212/2213)
|
||||
zh-mo Chinese in Macau 99% (2212/2213)
|
||||
zh-sg Chinese in Singapore 99% (6754/6765)
|
||||
zh-tw Chinese (traditional) 99% (13051/13063)
|
||||
zu Zulu 100% (52/52)
|
||||
----------------------------------------------------------------
|
||||
|
||||
V. About "WenQuanYi Project"
|
||||
|
||||
The "Wen Quan Yi" Project [5] was founded by Qianqian Fang [6] in
|
||||
Oct. 2004. The goal of this project is to create a web-based
|
||||
collaborative environment for open-source type-face development.
|
||||
The initial focus of the project is to create high quality bitmap
|
||||
character glyphs and outline fonts for all 70,000+ CJK characters
|
||||
currently encoded by the Unicode Consortium. Some of the fonts
|
||||
released by this project have been widely used as the default
|
||||
Chinese desktop fonts by main-stream GNU/Linux distributions.
|
||||
|
||||
The Wen Quan Yi Project uses wiki [5] as the primary development
|
||||
tool for glyph creation, documentation and coordinations. Wen Quan Yi
|
||||
wiki also supports glyph version control and nightly build.
|
||||
|
||||
|
||||
VI. Links
|
||||
|
||||
[1] http://wenq.org/index.cgi?Fontopia(cn)
|
||||
[2] http://android.git.kernel.org/?p=platform/frameworks/base.git;a=commit;h=1a2
|
||||
d9dbe9c6f54c5e0dc26386dc01df1d18073ad
|
||||
[3] http://wenq.org/dev/index.cgi?BigBang_TASK
|
||||
[4] http://wenq.org/WQYHistory.html.gz
|
||||
[5] http://wenq.org/en/
|
||||
[6] http://nmr.mgh.harvard.edu/~fangq/
|
||||
|
||||
|
||||
VII. Appendix
|
||||
|
||||
Appendix A.
|
||||
|
||||
Copyright disclaimer for UmeFont
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
3. Neither the name of the Wada Laboratory, the University of Tokyo nor
|
||||
the names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY WADA LABORATORY, THE UNIVERSITY OF TOKYO AND
|
||||
CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
|
||||
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
|
||||
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LABORATORY OR
|
||||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
|
||||
Appendix B.
|
||||
|
||||
GPL with font embedding exception:
|
||||
|
||||
http://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.html#FontException
|
||||
|
||||
As a special exception, if you create a document which uses this
|
||||
font, and embed this font or unaltered portions of this font into
|
||||
the document, this font does not by itself cause the resulting
|
||||
document to be covered by the GNU General Public License. This
|
||||
exception does not however invalidate any other reasons why the
|
||||
document might be covered by the GNU General Public License. If you
|
||||
modify this font, you may extend this exception to your version of
|
||||
the font, but you are not obligated to do so. If you do not wish to
|
||||
do so, delete this exception statement from your version.
|
||||
|
||||
|
||||
|
||||
Binary file not shown.
+189
-219
@@ -1,21 +1,22 @@
|
||||
use std::collections::VecDeque;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::Sender;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use chrono::{Duration, Local, NaiveDateTime};
|
||||
use chrono::Local;
|
||||
|
||||
use crate::keyboard::{keysyms, map_keyboard, Event as KbEvent, KeyState, ModifiersState};
|
||||
use smithay_client_toolkit::keyboard::{
|
||||
keysyms, map_keyboard_auto, Event as KbEvent, KeyState, ModifiersState,
|
||||
};
|
||||
|
||||
use wayland_client::protocol::{wl_compositor, wl_output, wl_pointer, wl_seat, wl_shm, wl_surface};
|
||||
use wayland_client::{Display, EventQueue, GlobalEvent, GlobalManager, Main};
|
||||
use wayland_client::protocol::{wl_compositor, wl_output, wl_pointer, wl_shm, wl_surface};
|
||||
use wayland_client::{Display, EventQueue, GlobalEvent, GlobalManager, NewProxy};
|
||||
use wayland_protocols::wlr::unstable::layer_shell::v1::client::{
|
||||
zwlr_layer_shell_v1, zwlr_layer_surface_v1,
|
||||
};
|
||||
|
||||
use crate::buffer::Buffer;
|
||||
use crate::color::Color;
|
||||
use crate::widget::{DrawContext, WaitContext, Widget};
|
||||
use crate::widget::{DrawContext, Widget};
|
||||
|
||||
use crate::cmd::Cmd;
|
||||
use crate::doublemempool::DoubleMemPool;
|
||||
@@ -27,12 +28,12 @@ pub enum OutputMode {
|
||||
}
|
||||
|
||||
struct AppInner {
|
||||
compositor: Option<Main<wl_compositor::WlCompositor>>,
|
||||
surfaces: Vec<Main<wl_surface::WlSurface>>,
|
||||
shell_surfaces: Vec<Main<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1>>,
|
||||
compositor: Option<wl_compositor::WlCompositor>,
|
||||
surfaces: Vec<wl_surface::WlSurface>,
|
||||
shell_surfaces: Vec<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1>,
|
||||
configured_surfaces: Arc<Mutex<usize>>,
|
||||
outputs: Vec<(u32, Main<wl_output::WlOutput>)>,
|
||||
shell: Option<Main<zwlr_layer_shell_v1::ZwlrLayerShellV1>>,
|
||||
outputs: Vec<(u32, wl_output::WlOutput)>,
|
||||
shell: Option<zwlr_layer_shell_v1::ZwlrLayerShellV1>,
|
||||
draw_tx: Sender<Cmd>,
|
||||
output_mode: OutputMode,
|
||||
visible: bool,
|
||||
@@ -49,9 +50,9 @@ impl AppInner {
|
||||
outputs: Vec::new(),
|
||||
shell: None,
|
||||
draw_tx: tx,
|
||||
output_mode,
|
||||
output_mode: output_mode,
|
||||
visible: true,
|
||||
scale,
|
||||
scale: scale,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -63,35 +64,42 @@ impl AppInner {
|
||||
tx: Sender<Cmd>,
|
||||
output: Option<&wl_output::WlOutput>,
|
||||
) -> (
|
||||
Main<wl_surface::WlSurface>,
|
||||
Main<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1>,
|
||||
wl_surface::WlSurface,
|
||||
zwlr_layer_surface_v1::ZwlrLayerSurfaceV1,
|
||||
) {
|
||||
let surface = compositor.create_surface();
|
||||
let surface = compositor
|
||||
.create_surface(NewProxy::implement_dummy)
|
||||
.unwrap();
|
||||
|
||||
let this_is_stupid = AtomicBool::new(false);
|
||||
let this_is_stupid = Arc::new(Mutex::new(false));
|
||||
|
||||
let shell_surface = shell.get_layer_surface(
|
||||
&surface,
|
||||
output,
|
||||
zwlr_layer_shell_v1::Layer::Overlay,
|
||||
"".to_string(),
|
||||
);
|
||||
shell_surface.quick_assign(move |layer, event, _| match event {
|
||||
zwlr_layer_surface_v1::Event::Configure { serial, .. } => {
|
||||
if this_is_stupid
|
||||
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
|
||||
.is_ok()
|
||||
{
|
||||
*(configured_surfaces.lock().unwrap()) += 1;
|
||||
layer.ack_configure(serial);
|
||||
tx.send(Cmd::ForceDraw).unwrap();
|
||||
}
|
||||
}
|
||||
_ => unreachable!(),
|
||||
});
|
||||
let shell_surface = shell
|
||||
.get_layer_surface(
|
||||
&surface,
|
||||
output,
|
||||
zwlr_layer_shell_v1::Layer::Overlay,
|
||||
"".to_string(),
|
||||
move |layer| {
|
||||
layer.implement_closure(
|
||||
move |evt, layer| match evt {
|
||||
zwlr_layer_surface_v1::Event::Configure { serial, .. } => {
|
||||
let mut x = this_is_stupid.lock().unwrap();
|
||||
if !*x {
|
||||
*x = true;
|
||||
*(configured_surfaces.lock().unwrap()) += 1;
|
||||
layer.ack_configure(serial);
|
||||
tx.send(Cmd::ForceDraw).unwrap();
|
||||
}
|
||||
}
|
||||
_ => unreachable!(),
|
||||
},
|
||||
(),
|
||||
)
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
shell_surface.set_keyboard_interactivity(zwlr_layer_surface_v1::KeyboardInteractivity::Exclusive);
|
||||
shell_surface.set_size(1, 1);
|
||||
shell_surface.set_keyboard_interactivity(1);
|
||||
surface.set_buffer_scale(scale as i32);
|
||||
surface.commit();
|
||||
(surface, shell_surface)
|
||||
@@ -124,7 +132,7 @@ impl AppInner {
|
||||
|
||||
match self.output_mode {
|
||||
OutputMode::Active => {
|
||||
if !self.shell_surfaces.is_empty() {
|
||||
if self.shell_surfaces.len() > 0 {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -161,7 +169,7 @@ impl AppInner {
|
||||
self.draw_tx.send(Cmd::ForceDraw).unwrap();
|
||||
}
|
||||
|
||||
fn add_output(&mut self, id: u32, output: Main<wl_output::WlOutput>) {
|
||||
fn add_output(&mut self, id: u32, output: wl_output::WlOutput) {
|
||||
self.outputs.push((id, output));
|
||||
self.outputs_changed();
|
||||
}
|
||||
@@ -173,7 +181,7 @@ impl AppInner {
|
||||
.outputs
|
||||
.iter()
|
||||
.filter(|(output_id, _)| *output_id != id)
|
||||
.map(|(x, y)| (*x, y.clone()))
|
||||
.map(|(x, y)| (x.clone(), y.clone()))
|
||||
.collect();
|
||||
if output.1.as_ref().version() >= 3 {
|
||||
output.1.release()
|
||||
@@ -183,36 +191,28 @@ impl AppInner {
|
||||
}
|
||||
}
|
||||
|
||||
fn set_compositor(&mut self, compositor: Option<Main<wl_compositor::WlCompositor>>) {
|
||||
fn set_compositor(&mut self, compositor: Option<wl_compositor::WlCompositor>) {
|
||||
self.compositor = compositor
|
||||
}
|
||||
|
||||
fn set_shell(&mut self, shell: Option<Main<zwlr_layer_shell_v1::ZwlrLayerShellV1>>) {
|
||||
fn set_shell(&mut self, shell: Option<zwlr_layer_shell_v1::ZwlrLayerShellV1>) {
|
||||
self.shell = shell
|
||||
}
|
||||
}
|
||||
|
||||
struct AppKeyboard {
|
||||
current: Option<Cmd>,
|
||||
delay: i32,
|
||||
rate: i32,
|
||||
next: Option<NaiveDateTime>,
|
||||
}
|
||||
|
||||
pub struct App<'a> {
|
||||
pub struct App {
|
||||
pools: DoubleMemPool,
|
||||
display: Display,
|
||||
event_queue: EventQueue,
|
||||
cmd_queue: Arc<Mutex<VecDeque<Cmd>>>,
|
||||
widget: Option<Box<dyn Widget + Send + 'a>>,
|
||||
widget: Option<Box<dyn Widget + Send>>,
|
||||
bg: Color,
|
||||
inner: Arc<Mutex<AppInner>>,
|
||||
last_damage: Option<Vec<(i32, i32, i32, i32)>>,
|
||||
last_dim: (u32, u32),
|
||||
keyboard: Arc<Mutex<AppKeyboard>>,
|
||||
}
|
||||
|
||||
impl<'a> App<'a> {
|
||||
impl App {
|
||||
pub fn redraw(&mut self, force: bool) -> Result<(), ::std::io::Error> {
|
||||
let widget = match self.widget {
|
||||
Some(ref mut widget) => widget,
|
||||
@@ -220,11 +220,11 @@ impl<'a> App<'a> {
|
||||
};
|
||||
|
||||
let inner = self.inner.lock().unwrap();
|
||||
let time = Local::now().naive_local();
|
||||
let time = Local::now();
|
||||
|
||||
if !inner.visible
|
||||
|| inner.shell_surfaces.len() != *inner.configured_surfaces.lock().unwrap()
|
||||
|| inner.surfaces.is_empty()
|
||||
|| inner.surfaces.len() == 0
|
||||
{
|
||||
// Not ready yet
|
||||
return Ok(());
|
||||
@@ -232,10 +232,7 @@ impl<'a> App<'a> {
|
||||
|
||||
let (last, pool) = match self.pools.pool() {
|
||||
Some((last, pool)) => (last, pool),
|
||||
None => {
|
||||
self.pools.never_mind();
|
||||
return Ok(());
|
||||
}
|
||||
None => return Ok(()),
|
||||
};
|
||||
|
||||
let size = widget.size();
|
||||
@@ -272,16 +269,15 @@ impl<'a> App<'a> {
|
||||
&mut DrawContext {
|
||||
buf: &mut buf,
|
||||
bg: &self.bg,
|
||||
time,
|
||||
time: &time,
|
||||
force,
|
||||
},
|
||||
(0, 0),
|
||||
size,
|
||||
)?;
|
||||
|
||||
mmap.flush().unwrap();
|
||||
|
||||
if !force && !report.full_damage && report.damage.is_empty() {
|
||||
if !force && !report.full_damage && report.damage.len() == 0 {
|
||||
// Nothing to do
|
||||
self.pools.never_mind();
|
||||
return Ok(());
|
||||
@@ -346,37 +342,17 @@ impl<'a> App<'a> {
|
||||
&mut self.event_queue
|
||||
}
|
||||
|
||||
pub fn get_widget(&mut self) -> &mut Box<dyn Widget + Send + 'a> {
|
||||
pub fn get_widget(&mut self) -> &mut Box<dyn Widget + Send> {
|
||||
self.widget.as_mut().unwrap()
|
||||
}
|
||||
|
||||
pub fn set_widget(&mut self, w: Box<dyn Widget + Send + 'a>) -> Result<(), ::std::io::Error> {
|
||||
pub fn set_widget(&mut self, w: Box<dyn Widget + Send>) -> Result<(), ::std::io::Error> {
|
||||
self.widget = Some(w);
|
||||
self.redraw(true)
|
||||
}
|
||||
|
||||
pub fn set_keyboard_repeat(&mut self, ctx: &mut WaitContext) {
|
||||
let kbd = self.keyboard.lock().unwrap();
|
||||
if let Some(t) = kbd.next {
|
||||
ctx.set_time(t);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn key_repeat(&mut self) -> Option<Cmd> {
|
||||
let time = Local::now().naive_local();
|
||||
let mut kbd = self.keyboard.lock().unwrap();
|
||||
if let Some(target) = kbd.next {
|
||||
if time >= target {
|
||||
let cmd = kbd.current.as_ref().unwrap().clone();
|
||||
kbd.next = Some(time + Duration::milliseconds(kbd.rate.into()));
|
||||
return Some(cmd);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn new(tx: Sender<Cmd>, output_mode: OutputMode, bg: Color, scale: u32) -> App<'a> {
|
||||
let inner = Arc::new(Mutex::new(AppInner::new(tx, output_mode, scale)));
|
||||
pub fn new(tx: Sender<Cmd>, output_mode: OutputMode, bg: Color, scale: u32) -> App {
|
||||
let inner = Arc::new(Mutex::new(AppInner::new(tx.clone(), output_mode, scale)));
|
||||
|
||||
//
|
||||
// Set up modules
|
||||
@@ -384,23 +360,31 @@ impl<'a> App<'a> {
|
||||
|
||||
let cmd_queue = Arc::new(Mutex::new(VecDeque::new()));
|
||||
|
||||
let display = Display::connect_to_env().unwrap();
|
||||
let mut event_queue = display.create_event_queue();
|
||||
let display_wrapper = (*display).clone().attach(event_queue.token());
|
||||
let (display, mut event_queue) = Display::connect_to_env().unwrap();
|
||||
|
||||
let display_wrapper = display
|
||||
.as_ref()
|
||||
.make_wrapper(&event_queue.get_token())
|
||||
.unwrap()
|
||||
.into();
|
||||
|
||||
//
|
||||
// Set up global manager
|
||||
//
|
||||
let inner_global = inner.clone();
|
||||
let manager =
|
||||
GlobalManager::new_with_cb(&display_wrapper, move |event, registry, _| match event {
|
||||
GlobalManager::new_with_cb(&display_wrapper, move |event, registry| match event {
|
||||
GlobalEvent::New {
|
||||
id,
|
||||
ref interface,
|
||||
version,
|
||||
} => {
|
||||
if let "wl_output" = &interface[..] {
|
||||
let output = registry.bind(std::cmp::min(version, 3), id);
|
||||
let output = registry
|
||||
.bind(version, id, move |output| {
|
||||
output.implement_closure(move |_, _| {}, ())
|
||||
})
|
||||
.unwrap();
|
||||
inner_global.lock().unwrap().add_output(id, output);
|
||||
}
|
||||
}
|
||||
@@ -413,28 +397,40 @@ impl<'a> App<'a> {
|
||||
|
||||
// double sync to retrieve the global list
|
||||
// and the globals metadata
|
||||
event_queue.sync_roundtrip(&mut (), |_, _, _| {}).unwrap();
|
||||
event_queue.sync_roundtrip(&mut (), |_, _, _| {}).unwrap();
|
||||
event_queue.sync_roundtrip().unwrap();
|
||||
event_queue.sync_roundtrip().unwrap();
|
||||
|
||||
// wl_compositor
|
||||
let compositor = manager
|
||||
.instantiate_range(1, 4)
|
||||
let compositor: wl_compositor::WlCompositor = manager
|
||||
.instantiate_range(1, 4, NewProxy::implement_dummy)
|
||||
.expect("server didn't advertise `wl_compositor`");
|
||||
|
||||
inner.lock().unwrap().set_compositor(Some(compositor));
|
||||
|
||||
// wl_shm
|
||||
let shm: Main<wl_shm::WlShm> = manager
|
||||
.instantiate_range(1, 1)
|
||||
let shm_formats = Arc::new(Mutex::new(Vec::new()));
|
||||
let shm_formats2 = shm_formats.clone();
|
||||
let shm = manager
|
||||
.instantiate_range(1, 1, |shm| {
|
||||
shm.implement_closure(
|
||||
move |evt, _| {
|
||||
if let wl_shm::Event::Format { format } = evt {
|
||||
shm_formats2.lock().unwrap().push(format);
|
||||
}
|
||||
},
|
||||
(),
|
||||
)
|
||||
})
|
||||
.expect("server didn't advertise `wl_shm`");
|
||||
|
||||
let pools = DoubleMemPool::new(shm).expect("Failed to create a memory pool !");
|
||||
let pools = DoubleMemPool::new(&shm).expect("Failed to create a memory pool !");
|
||||
|
||||
//
|
||||
// Get our seat
|
||||
//
|
||||
let seat: Main<wl_seat::WlSeat> = manager.instantiate_range(1, 6).unwrap();
|
||||
event_queue.sync_roundtrip(&mut (), |_, _, _| {}).unwrap();
|
||||
let seat = manager
|
||||
.instantiate_range(1, 6, NewProxy::implement_dummy)
|
||||
.unwrap();
|
||||
|
||||
//
|
||||
// Keyboard processing
|
||||
@@ -448,153 +444,127 @@ impl<'a> App<'a> {
|
||||
logo: false,
|
||||
num_lock: false,
|
||||
}));
|
||||
|
||||
let keyboard = Arc::new(Mutex::new(AppKeyboard {
|
||||
current: None,
|
||||
delay: 0,
|
||||
rate: 0,
|
||||
next: None,
|
||||
}));
|
||||
|
||||
let kb2 = keyboard.clone();
|
||||
|
||||
map_keyboard(&seat, None, move |event: KbEvent, _, _| match event {
|
||||
map_keyboard_auto(&seat, move |event: KbEvent, _| match event {
|
||||
KbEvent::Key {
|
||||
keysym,
|
||||
utf8,
|
||||
state,
|
||||
..
|
||||
} => {
|
||||
if let KeyState::Pressed = state {
|
||||
match keysym {
|
||||
keysyms::XKB_KEY_Escape => kbd_clone.lock().unwrap().push_back(Cmd::Exit),
|
||||
keysyms::XKB_KEY_c if modifiers_state.lock().unwrap().ctrl => {
|
||||
kbd_clone.lock().unwrap().push_back(Cmd::Exit)
|
||||
}
|
||||
v => {
|
||||
let ev = Cmd::Keyboard {
|
||||
key: v,
|
||||
key_state: state,
|
||||
modifiers_state: *modifiers_state.lock().unwrap(),
|
||||
interpreted: utf8,
|
||||
};
|
||||
let mut kbd = kb2.lock().unwrap();
|
||||
kbd.current = Some(ev.clone());
|
||||
kbd.next = if kbd.delay > 0 {
|
||||
Some(
|
||||
Local::now().naive_local()
|
||||
+ Duration::milliseconds(kbd.delay.into()),
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
drop(kbd);
|
||||
kbd_clone.lock().unwrap().push_back(ev);
|
||||
}
|
||||
} => match state {
|
||||
KeyState::Pressed => match keysym {
|
||||
keysyms::XKB_KEY_Escape => kbd_clone.lock().unwrap().push_back(Cmd::Exit),
|
||||
keysyms::XKB_KEY_c if modifiers_state.lock().unwrap().ctrl => {
|
||||
kbd_clone.lock().unwrap().push_back(Cmd::Exit)
|
||||
}
|
||||
} else {
|
||||
kb2.lock().unwrap().next = None;
|
||||
}
|
||||
}
|
||||
KbEvent::Leave { .. } => {
|
||||
kb2.lock().unwrap().next = None;
|
||||
}
|
||||
KbEvent::RepeatInfo { delay, rate } => {
|
||||
let mut kbd = kb2.lock().unwrap();
|
||||
kbd.delay = delay;
|
||||
kbd.rate = rate;
|
||||
}
|
||||
v => kbd_clone.lock().unwrap().push_back(Cmd::Keyboard {
|
||||
key: v,
|
||||
key_state: state,
|
||||
modifiers_state: modifiers_state.lock().unwrap().clone(),
|
||||
interpreted: utf8,
|
||||
}),
|
||||
},
|
||||
_ => (),
|
||||
},
|
||||
KbEvent::Modifiers { modifiers } => *modifiers_state.lock().unwrap() = modifiers,
|
||||
_ => (),
|
||||
})
|
||||
.expect("could not map keyboard");
|
||||
.expect("Failed to map keyboard");
|
||||
|
||||
//
|
||||
// Prepare shell so that we can create our shell surface
|
||||
//
|
||||
inner
|
||||
.lock()
|
||||
.unwrap()
|
||||
.set_shell(Some(if let Ok(layer) = manager.instantiate_exact(1) {
|
||||
inner.lock().unwrap().set_shell(Some(
|
||||
if let Ok(layer) = manager.instantiate_exact(
|
||||
1,
|
||||
|layer: NewProxy<zwlr_layer_shell_v1::ZwlrLayerShellV1>| {
|
||||
layer.implement_closure(|_, _| {}, ())
|
||||
},
|
||||
) {
|
||||
layer
|
||||
} else {
|
||||
panic!("server didn't advertise `zwlr_layer_shell_v1`");
|
||||
}));
|
||||
},
|
||||
));
|
||||
|
||||
event_queue.sync_roundtrip(&mut (), |_, _, _| {}).unwrap();
|
||||
event_queue.sync_roundtrip().unwrap();
|
||||
|
||||
//
|
||||
// Cursor processing
|
||||
//
|
||||
let pointer_clone = cmd_queue.clone();
|
||||
let pointer = seat.get_pointer();
|
||||
let mut pos: (u32, u32) = (0, 0);
|
||||
let mut vert_scroll: f64 = 0.0;
|
||||
let mut horiz_scroll: f64 = 0.0;
|
||||
let mut btn: u32 = 0;
|
||||
let mut btn_clicked = false;
|
||||
pointer.quick_assign(move |_, event, _| match event {
|
||||
wl_pointer::Event::Enter {
|
||||
surface_x,
|
||||
surface_y,
|
||||
..
|
||||
} => {
|
||||
pos = (surface_x as u32, surface_y as u32);
|
||||
}
|
||||
wl_pointer::Event::Leave { .. } => {
|
||||
pos = (0, 0);
|
||||
}
|
||||
wl_pointer::Event::Motion {
|
||||
surface_x,
|
||||
surface_y,
|
||||
..
|
||||
} => {
|
||||
pos = (surface_x as u32 * scale, surface_y as u32 * scale);
|
||||
}
|
||||
wl_pointer::Event::Axis { axis, value, .. } => {
|
||||
if axis == wl_pointer::Axis::VerticalScroll {
|
||||
vert_scroll += value;
|
||||
}
|
||||
}
|
||||
wl_pointer::Event::Button { button, state, .. } => {
|
||||
if let wl_pointer::ButtonState::Released = state {
|
||||
btn = button;
|
||||
btn_clicked = true;
|
||||
}
|
||||
}
|
||||
wl_pointer::Event::Frame => {
|
||||
if vert_scroll != 0.0 || horiz_scroll != 0.0 {
|
||||
pointer_clone.lock().unwrap().push_back(Cmd::MouseScroll {
|
||||
scroll: (horiz_scroll, vert_scroll),
|
||||
pos,
|
||||
});
|
||||
vert_scroll = 0.0;
|
||||
horiz_scroll = 0.0;
|
||||
}
|
||||
if btn_clicked {
|
||||
pointer_clone
|
||||
.lock()
|
||||
.unwrap()
|
||||
.push_back(Cmd::MouseClick { btn, pos });
|
||||
btn_clicked = false;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
});
|
||||
seat.get_pointer(move |ptr| {
|
||||
let mut pos: (u32, u32) = (0, 0);
|
||||
let mut vert_scroll: f64 = 0.0;
|
||||
let mut horiz_scroll: f64 = 0.0;
|
||||
let mut btn: u32 = 0;
|
||||
let mut btn_clicked = false;
|
||||
ptr.implement_closure(
|
||||
move |evt, _| match evt {
|
||||
wl_pointer::Event::Enter {
|
||||
surface_x,
|
||||
surface_y,
|
||||
..
|
||||
} => {
|
||||
pos = (surface_x as u32, surface_y as u32);
|
||||
}
|
||||
wl_pointer::Event::Leave { .. } => {
|
||||
pos = (0, 0);
|
||||
}
|
||||
wl_pointer::Event::Motion {
|
||||
surface_x,
|
||||
surface_y,
|
||||
..
|
||||
} => {
|
||||
pos = (surface_x as u32 * scale, surface_y as u32 * scale);
|
||||
}
|
||||
wl_pointer::Event::Axis { axis, value, .. } => {
|
||||
if axis == wl_pointer::Axis::VerticalScroll {
|
||||
vert_scroll += value;
|
||||
}
|
||||
}
|
||||
wl_pointer::Event::Button { button, state, .. } => match state {
|
||||
wl_pointer::ButtonState::Released => {
|
||||
btn = button;
|
||||
btn_clicked = true;
|
||||
}
|
||||
_ => {}
|
||||
},
|
||||
wl_pointer::Event::Frame => {
|
||||
if vert_scroll != 0.0 || horiz_scroll != 0.0 {
|
||||
pointer_clone.lock().unwrap().push_back(Cmd::MouseScroll {
|
||||
scroll: (horiz_scroll, vert_scroll),
|
||||
pos: pos,
|
||||
});
|
||||
vert_scroll = 0.0;
|
||||
horiz_scroll = 0.0;
|
||||
}
|
||||
if btn_clicked {
|
||||
pointer_clone
|
||||
.lock()
|
||||
.unwrap()
|
||||
.push_back(Cmd::MouseClick { btn: btn, pos: pos });
|
||||
btn_clicked = false;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
},
|
||||
(),
|
||||
)
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
display.flush().unwrap();
|
||||
|
||||
App {
|
||||
display,
|
||||
event_queue,
|
||||
cmd_queue,
|
||||
pools,
|
||||
display: display,
|
||||
event_queue: event_queue,
|
||||
cmd_queue: cmd_queue,
|
||||
pools: pools,
|
||||
widget: None,
|
||||
bg,
|
||||
inner,
|
||||
bg: bg,
|
||||
inner: inner,
|
||||
last_damage: None,
|
||||
last_dim: (0, 0),
|
||||
keyboard,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+2
-2
@@ -11,8 +11,8 @@ pub struct Buffer<'a> {
|
||||
impl<'a> Buffer<'a> {
|
||||
pub fn new(buf: &'a mut MmapMut, dimensions: (u32, u32)) -> Buffer {
|
||||
Buffer {
|
||||
buf,
|
||||
dimensions,
|
||||
buf: buf,
|
||||
dimensions: dimensions,
|
||||
subdimensions: None,
|
||||
}
|
||||
}
|
||||
|
||||
+1
-3
@@ -1,6 +1,5 @@
|
||||
use crate::keyboard::{KeyState, ModifiersState};
|
||||
use smithay_client_toolkit::keyboard::{KeyState, ModifiersState};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub enum Cmd {
|
||||
Exit,
|
||||
Draw,
|
||||
@@ -14,7 +13,6 @@ pub enum Cmd {
|
||||
scroll: (f64, f64),
|
||||
pos: (u32, u32),
|
||||
},
|
||||
KeyboardTest,
|
||||
Keyboard {
|
||||
key: u32,
|
||||
key_state: KeyState,
|
||||
|
||||
+45
-168
@@ -1,16 +1,12 @@
|
||||
use crate::cmd::Cmd;
|
||||
use crate::color::Color;
|
||||
use crate::widget;
|
||||
use crate::{
|
||||
fonts::{FontMap, FontRef},
|
||||
widgets,
|
||||
};
|
||||
use chrono::NaiveDateTime;
|
||||
use crate::widgets;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::default::Default;
|
||||
use std::{collections::HashMap, sync::mpsc::Sender};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone, Debug)]
|
||||
#[derive(Serialize, Deserialize, Debug)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum Widget {
|
||||
Margin {
|
||||
@@ -22,24 +18,19 @@ pub enum Widget {
|
||||
height: u32,
|
||||
widget: Box<Widget>,
|
||||
},
|
||||
HorizontalLayout(Vec<Widget>),
|
||||
VerticalLayout(Vec<Widget>),
|
||||
HorizontalLayout(Vec<Box<Widget>>),
|
||||
VerticalLayout(Vec<Box<Widget>>),
|
||||
Clock {
|
||||
font: Option<String>,
|
||||
font_size: f32,
|
||||
},
|
||||
Date {
|
||||
font: Option<String>,
|
||||
font_size: f32,
|
||||
},
|
||||
Calendar {
|
||||
font_primary: Option<String>,
|
||||
font_secondary: Option<String>,
|
||||
font_size: f32,
|
||||
sections: u32,
|
||||
},
|
||||
Launcher {
|
||||
font: Option<String>,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
#[serde(default)]
|
||||
@@ -50,40 +41,29 @@ pub enum Widget {
|
||||
url_opener: String,
|
||||
},
|
||||
Battery {
|
||||
font: Option<String>,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
},
|
||||
Backlight {
|
||||
#[serde(default)]
|
||||
device: String,
|
||||
font: Option<String>,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
},
|
||||
#[cfg(feature = "pulseaudio-widget")]
|
||||
PulseAudio {
|
||||
font: Option<String>,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
},
|
||||
#[cfg(feature = "alsa-widget")]
|
||||
AlsaSound {
|
||||
font: Option<String>,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
},
|
||||
}
|
||||
|
||||
impl Widget {
|
||||
pub fn construct<'a>(
|
||||
self,
|
||||
time: NaiveDateTime,
|
||||
tx: Sender<Cmd>,
|
||||
fonts: &'a FontMap,
|
||||
) -> Option<Box<dyn widget::Widget + Send + 'a>> {
|
||||
pub fn construct(self, tx: Sender<Cmd>) -> Option<Box<dyn widget::Widget + Send>> {
|
||||
match self {
|
||||
Widget::Margin { margins, widget } => match widget.construct(time, tx, fonts) {
|
||||
Widget::Margin { margins, widget } => match widget.construct(tx.clone()) {
|
||||
Some(w) => Some(widget::Margin::new(margins, w)),
|
||||
None => None,
|
||||
},
|
||||
@@ -91,14 +71,14 @@ impl Widget {
|
||||
width,
|
||||
height,
|
||||
widget,
|
||||
} => match widget.construct(time, tx, fonts) {
|
||||
} => match widget.construct(tx.clone()) {
|
||||
Some(w) => Some(widget::Fixed::new((width, height), w)),
|
||||
None => None,
|
||||
},
|
||||
Widget::HorizontalLayout(widgets) => Some(widget::HorizontalLayout::new(
|
||||
widgets
|
||||
.into_iter()
|
||||
.map(|x| x.construct(time, tx.clone(), fonts))
|
||||
.map(|x| x.construct(tx.clone()))
|
||||
.filter(|x| x.is_some())
|
||||
.map(|x| x.unwrap())
|
||||
.collect(),
|
||||
@@ -106,128 +86,57 @@ impl Widget {
|
||||
Widget::VerticalLayout(widgets) => Some(widget::VerticalLayout::new(
|
||||
widgets
|
||||
.into_iter()
|
||||
.map(|x| x.construct(time, tx.clone(), fonts))
|
||||
.map(|x| x.construct(tx.clone()))
|
||||
.filter(|x| x.is_some())
|
||||
.map(|x| x.unwrap())
|
||||
.collect(),
|
||||
)),
|
||||
Widget::Clock { font, font_size } => match widgets::clock::Clock::new(
|
||||
time,
|
||||
get_font(&font.or_else(|| Some("sans".to_string())).unwrap(), &fonts),
|
||||
font_size,
|
||||
) {
|
||||
Ok(w) => Some(w),
|
||||
Err(_) => None,
|
||||
},
|
||||
Widget::Date { font, font_size } => match widgets::date::Date::new(
|
||||
time,
|
||||
get_font(&font.or_else(|| Some("sans".to_string())).unwrap(), &fonts),
|
||||
font_size,
|
||||
) {
|
||||
Ok(w) => Some(w),
|
||||
Err(_) => None,
|
||||
},
|
||||
Widget::Clock { font_size } => Some(widgets::clock::Clock::new(font_size, tx.clone())),
|
||||
Widget::Date { font_size } => Some(widgets::date::Date::new(font_size)),
|
||||
Widget::Calendar {
|
||||
font_primary,
|
||||
font_secondary,
|
||||
font_size,
|
||||
sections,
|
||||
} => Some(widgets::calendar::Calendar::new(
|
||||
time,
|
||||
get_font(
|
||||
&font_primary.or_else(|| Some("sans".to_string())).unwrap(),
|
||||
&fonts,
|
||||
),
|
||||
get_font(
|
||||
&font_secondary.or_else(|| Some("mono".to_string())).unwrap(),
|
||||
&fonts,
|
||||
),
|
||||
font_size,
|
||||
sections,
|
||||
)),
|
||||
} => Some(widgets::calendar::Calendar::new(font_size, sections)),
|
||||
Widget::Launcher {
|
||||
font,
|
||||
font_size,
|
||||
length,
|
||||
app_opener,
|
||||
term_opener,
|
||||
url_opener,
|
||||
} => Some(widgets::launcher::Launcher::new(
|
||||
get_font(&font.or_else(|| Some("sans".to_string())).unwrap(), &fonts),
|
||||
font_size,
|
||||
length,
|
||||
tx,
|
||||
tx.clone(),
|
||||
app_opener,
|
||||
term_opener,
|
||||
if url_opener.is_empty() {
|
||||
if url_opener.len() == 0 {
|
||||
"xdg_open ".to_string()
|
||||
} else {
|
||||
url_opener
|
||||
},
|
||||
)),
|
||||
Widget::Battery {
|
||||
font,
|
||||
font_size,
|
||||
length,
|
||||
} => {
|
||||
match widgets::battery::UpowerBattery::new(
|
||||
get_font(&font.or_else(|| Some("sans".to_string())).unwrap(), &fonts),
|
||||
font_size,
|
||||
length,
|
||||
tx,
|
||||
) {
|
||||
Widget::Battery { font_size, length } => {
|
||||
match widgets::battery::UpowerBattery::new(font_size, length, tx.clone()) {
|
||||
Ok(w) => Some(w),
|
||||
Err(_) => None,
|
||||
}
|
||||
}
|
||||
Widget::Backlight {
|
||||
device,
|
||||
font,
|
||||
font_size,
|
||||
length,
|
||||
} => {
|
||||
let d = if device == "" {
|
||||
"intel_backlight"
|
||||
} else {
|
||||
&device
|
||||
};
|
||||
match widgets::backlight::Backlight::new(
|
||||
d,
|
||||
get_font(&font.or_else(|| Some("sans".to_string())).unwrap(), &fonts),
|
||||
font_size,
|
||||
length,
|
||||
) {
|
||||
Widget::Backlight { font_size, length } => {
|
||||
match widgets::backlight::Backlight::new(font_size, length) {
|
||||
Ok(w) => Some(w),
|
||||
Err(_) => None,
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "pulseaudio-widget")]
|
||||
Widget::PulseAudio {
|
||||
font,
|
||||
font_size,
|
||||
length,
|
||||
} => {
|
||||
match widgets::audio::PulseAudio::new(
|
||||
get_font(&font.or_else(|| Some("sans".to_string())).unwrap(), &fonts),
|
||||
font_size,
|
||||
length,
|
||||
tx,
|
||||
) {
|
||||
Widget::PulseAudio { font_size, length } => {
|
||||
match widgets::audio::PulseAudio::new(font_size, length, tx.clone()) {
|
||||
Ok(w) => Some(w),
|
||||
Err(_) => None,
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "alsa-widget")]
|
||||
Widget::AlsaSound {
|
||||
font,
|
||||
font_size,
|
||||
length,
|
||||
} => {
|
||||
match widgets::audio::Alsa::new(
|
||||
get_font(&font.or_else(|| Some("sans".to_string())).unwrap(), &fonts),
|
||||
font_size,
|
||||
length,
|
||||
) {
|
||||
Widget::AlsaSound { font_size, length } => {
|
||||
match widgets::audio::Alsa::new(font_size, length) {
|
||||
Ok(w) => Some(w),
|
||||
Err(_) => None,
|
||||
}
|
||||
@@ -249,13 +158,6 @@ impl Default for OutputMode {
|
||||
}
|
||||
}
|
||||
|
||||
fn default_fonts() -> HashMap<String, String> {
|
||||
let mut map = HashMap::with_capacity(2);
|
||||
map.insert("mono".to_string(), "mono".to_string());
|
||||
map.insert("sans".to_string(), "sans".to_string());
|
||||
map
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct Config {
|
||||
@@ -263,9 +165,6 @@ pub struct Config {
|
||||
pub scale: u32,
|
||||
pub background: Color,
|
||||
pub widget: Widget,
|
||||
|
||||
#[serde(default = "default_fonts")]
|
||||
pub fonts: HashMap<String, String>,
|
||||
}
|
||||
|
||||
impl Default for Config {
|
||||
@@ -274,77 +173,55 @@ impl Default for Config {
|
||||
widget: Widget::Margin {
|
||||
margins: (20, 20, 20, 20),
|
||||
widget: Box::new(Widget::VerticalLayout(vec![
|
||||
Widget::HorizontalLayout(vec![
|
||||
Widget::Margin {
|
||||
Box::new(Widget::HorizontalLayout(vec![
|
||||
Box::new(Widget::Margin {
|
||||
margins: (0, 88, 0, 32),
|
||||
widget: Box::new(Widget::VerticalLayout(vec![
|
||||
Widget::Date {
|
||||
font: None,
|
||||
font_size: 64.0,
|
||||
},
|
||||
Widget::Clock {
|
||||
font: None,
|
||||
font_size: 256.0,
|
||||
},
|
||||
Box::new(Widget::Date { font_size: 64.0 }),
|
||||
Box::new(Widget::Clock { font_size: 256.0 }),
|
||||
])),
|
||||
},
|
||||
Widget::VerticalLayout(vec![
|
||||
Widget::Margin {
|
||||
}),
|
||||
Box::new(Widget::VerticalLayout(vec![
|
||||
Box::new(Widget::Margin {
|
||||
margins: (0, 0, 0, 8),
|
||||
widget: Box::new(Widget::Battery {
|
||||
font: None,
|
||||
font_size: 24.0,
|
||||
length: 0,
|
||||
length: 600,
|
||||
}),
|
||||
},
|
||||
Widget::Margin {
|
||||
}),
|
||||
Box::new(Widget::Margin {
|
||||
margins: (0, 0, 0, 8),
|
||||
widget: Box::new(Widget::Backlight {
|
||||
device: "intel_backlight".to_string(),
|
||||
font: None,
|
||||
font_size: 24.0,
|
||||
length: 0,
|
||||
length: 600,
|
||||
}),
|
||||
},
|
||||
}),
|
||||
#[cfg(feature = "pulseaudio-widget")]
|
||||
Widget::Margin {
|
||||
Box::new(Widget::Margin {
|
||||
margins: (0, 0, 0, 8),
|
||||
widget: Box::new(Widget::PulseAudio {
|
||||
font: None,
|
||||
font_size: 24.0,
|
||||
length: 0,
|
||||
length: 600,
|
||||
}),
|
||||
},
|
||||
]),
|
||||
]),
|
||||
Widget::Calendar {
|
||||
font_primary: None,
|
||||
font_secondary: None,
|
||||
}),
|
||||
])),
|
||||
])),
|
||||
Box::new(Widget::Calendar {
|
||||
font_size: 16.0,
|
||||
sections: 3,
|
||||
},
|
||||
Widget::Launcher {
|
||||
font: None,
|
||||
}),
|
||||
Box::new(Widget::Launcher {
|
||||
font_size: 32.0,
|
||||
length: 0,
|
||||
length: 1200,
|
||||
app_opener: "".to_string(),
|
||||
term_opener: "".to_string(),
|
||||
url_opener: "".to_string(),
|
||||
},
|
||||
}),
|
||||
])),
|
||||
},
|
||||
output_mode: Default::default(),
|
||||
scale: 1,
|
||||
background: Color::new(0.0, 0.0, 0.0, 0.9),
|
||||
fonts: default_fonts(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_font<'a>(name: &str, map: &'a FontMap) -> FontRef<'a> {
|
||||
match map.get(name) {
|
||||
Some(f) => f,
|
||||
None => panic!("Font {} is missing from the config", name),
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -8,7 +8,7 @@ pub enum ConfigFmt {
|
||||
Json,
|
||||
}
|
||||
|
||||
pub const CONFIG_NAMES: &[&str] = &[
|
||||
pub const CONFIG_NAMES: &'static [&'static str] = &[
|
||||
#[cfg(feature = "yaml-cfg")]
|
||||
"config.yaml",
|
||||
#[cfg(feature = "json-cfg")]
|
||||
|
||||
-57
@@ -1,57 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::HashMap;
|
||||
use std::env;
|
||||
use std::error::Error;
|
||||
use std::fs::{create_dir_all, File, OpenOptions};
|
||||
use std::path::PathBuf;
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize, Clone, Default)]
|
||||
pub struct Data {
|
||||
pub entries: HashMap<String, i64>,
|
||||
}
|
||||
|
||||
impl Data {
|
||||
pub fn load() -> Result<Data, Box<dyn Error>> {
|
||||
Ok(serde_yaml::from_reader(Self::read_file()?)?)
|
||||
}
|
||||
|
||||
pub fn save(&self) -> Result<(), Box<dyn Error>> {
|
||||
Ok(serde_yaml::to_writer(Self::write_file()?, self)?)
|
||||
}
|
||||
|
||||
fn read_file() -> Result<File, Box<dyn Error>> {
|
||||
Ok(OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.read(true)
|
||||
.open(Self::path()?)?)
|
||||
}
|
||||
|
||||
fn write_file() -> Result<File, Box<dyn Error>> {
|
||||
Ok(OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.truncate(true)
|
||||
.open(Self::path()?)?)
|
||||
}
|
||||
|
||||
fn path() -> Result<PathBuf, Box<dyn Error>> {
|
||||
let xdg_cache = match env::var_os("XDG_CACHE_HOME") {
|
||||
Some(s) => s
|
||||
.into_string()
|
||||
.map_err(|_| "Unable to resolve $XDG_CACHE_HOME")?,
|
||||
None => format!(
|
||||
"{}/.cache",
|
||||
env::var_os("HOME")
|
||||
.ok_or("Unable to resolve $HOME")?
|
||||
.into_string()
|
||||
.map_err(|_| "Unable to resolve $HOME")?
|
||||
),
|
||||
};
|
||||
|
||||
let cache_dir = PathBuf::from(xdg_cache).join("wldash");
|
||||
create_dir_all(&cache_dir)?;
|
||||
|
||||
Ok(cache_dir.join("data.yaml"))
|
||||
}
|
||||
}
|
||||
+5
-17
@@ -1,14 +1,13 @@
|
||||
extern crate ini;
|
||||
use ini::{Ini, ParseOption};
|
||||
use itertools::Itertools;
|
||||
use std::cmp::Ordering;
|
||||
use std::env;
|
||||
use std::error::Error;
|
||||
use std::fs;
|
||||
use std::io::Error as io_error;
|
||||
use std::io::ErrorKind;
|
||||
use walkdir::WalkDir;
|
||||
|
||||
#[derive(Clone, Debug, Eq, Hash)]
|
||||
#[derive(Clone, Debug, Eq)]
|
||||
pub struct Desktop {
|
||||
pub entry_type: String,
|
||||
pub name: String,
|
||||
@@ -17,7 +16,6 @@ pub struct Desktop {
|
||||
pub exec: Option<String>,
|
||||
pub url: Option<String>,
|
||||
pub term: bool,
|
||||
pub keywords: Vec<String>,
|
||||
}
|
||||
|
||||
impl Desktop {
|
||||
@@ -38,15 +36,6 @@ impl Desktop {
|
||||
hidden: desktop.get("Hidden").unwrap_or(&"".to_string()) == "true",
|
||||
exec: desktop.get("Exec").map(|x| x.to_string()),
|
||||
url: desktop.get("URL").map(|x| x.to_string()),
|
||||
keywords: desktop
|
||||
.get("Keywords")
|
||||
.map(|x| {
|
||||
x.split(';')
|
||||
.map(|y| y.trim().to_string())
|
||||
.filter(|z| z != "")
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_else(|| vec![]),
|
||||
}),
|
||||
None => Err(Box::new(io_error::new(
|
||||
ErrorKind::NotFound,
|
||||
@@ -57,7 +46,7 @@ impl Desktop {
|
||||
|
||||
fn parse_dir(d: &str) -> Result<Vec<Desktop>, Box<dyn Error>> {
|
||||
let mut files: Vec<Desktop> = Vec::with_capacity(16);
|
||||
for entry in WalkDir::new(d) {
|
||||
for entry in fs::read_dir(d)? {
|
||||
let entry = entry?;
|
||||
let path = entry.path();
|
||||
|
||||
@@ -93,7 +82,7 @@ pub fn load_desktop_files() -> Vec<Desktop> {
|
||||
|
||||
let xdg_data_home = match env::var_os("XDG_DATA_HOME") {
|
||||
Some(s) => s.into_string().unwrap(),
|
||||
None => format!("{}/.local/share", home),
|
||||
None => format!("{}/.local/share", home).to_string(),
|
||||
};
|
||||
let xdg_data_dirs = match env::var_os("XDG_DATA_DIRS") {
|
||||
Some(s) => s.into_string().unwrap(),
|
||||
@@ -101,13 +90,12 @@ pub fn load_desktop_files() -> Vec<Desktop> {
|
||||
};
|
||||
|
||||
std::iter::once(xdg_data_home.as_str())
|
||||
.chain(xdg_data_dirs.split(':'))
|
||||
.chain(xdg_data_dirs.split(":"))
|
||||
.map(|p| Desktop::parse_dir(&format!("{}/applications", p)))
|
||||
.filter_map(Result::ok)
|
||||
.flatten()
|
||||
.filter(|d| {
|
||||
!d.hidden && !d.no_display && (d.entry_type == "Application" || d.entry_type == "Link")
|
||||
})
|
||||
.unique_by(|x| x.name.clone())
|
||||
.collect()
|
||||
}
|
||||
|
||||
+5
-228
@@ -1,228 +1,5 @@
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
ffi::CStr,
|
||||
fs::File,
|
||||
io,
|
||||
os::unix::io::{FromRawFd, RawFd},
|
||||
rc::Rc,
|
||||
time::SystemTime,
|
||||
time::UNIX_EPOCH,
|
||||
};
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
use nix::sys::memfd;
|
||||
use nix::{
|
||||
errno::Errno,
|
||||
fcntl,
|
||||
sys::{mman, stat},
|
||||
unistd,
|
||||
};
|
||||
|
||||
use memmap::MmapMut;
|
||||
|
||||
use wayland_client::{
|
||||
protocol::{wl_buffer, wl_shm, wl_shm_pool},
|
||||
Main,
|
||||
};
|
||||
|
||||
/// A wrapper handling an SHM memory pool backed by a shared memory file
|
||||
///
|
||||
/// This wrapper handles for you the creation of the shared memory file and its synchronization
|
||||
/// with the protocol.
|
||||
///
|
||||
/// Mempool internally tracks the release of the buffers by the compositor. As such, creating a buffer
|
||||
/// that is not commited to a surface (and then never released by the server) would cause the Mempool
|
||||
/// to be stuck believing it is still in use.
|
||||
///
|
||||
/// Mempool will also handle the destruction of buffers and as such the `destroy()` method should not
|
||||
/// be used on buffers created from Mempool.
|
||||
///
|
||||
/// Overwriting the contents of the memory pool before it is completely freed may cause graphical
|
||||
/// glitches due to the possible corruption of data while the compositor is reading it.
|
||||
///
|
||||
/// Mempool requires a callback that will be called when the pool becomes free, this
|
||||
/// happens when all the pools buffers are released by the server.
|
||||
pub struct MemPool {
|
||||
file: File,
|
||||
len: usize,
|
||||
pool: Main<wl_shm_pool::WlShmPool>,
|
||||
buffer_count: Rc<RefCell<u32>>,
|
||||
mmap: MmapMut,
|
||||
callback: Rc<RefCell<dyn FnMut(wayland_client::DispatchData)>>,
|
||||
}
|
||||
|
||||
impl MemPool {
|
||||
/// Create a new memory pool associated with given shm
|
||||
pub fn new<F>(shm: Main<wl_shm::WlShm>, callback: F) -> io::Result<MemPool>
|
||||
where
|
||||
F: FnMut(wayland_client::DispatchData) + 'static,
|
||||
{
|
||||
let mem_fd = create_shm_fd()?;
|
||||
let mem_file = unsafe { File::from_raw_fd(mem_fd) };
|
||||
mem_file.set_len(128)?;
|
||||
|
||||
let pool = shm.create_pool(mem_fd, 128);
|
||||
|
||||
let mmap = unsafe { MmapMut::map_mut(&mem_file).unwrap() };
|
||||
|
||||
Ok(MemPool {
|
||||
file: mem_file,
|
||||
len: 128,
|
||||
pool,
|
||||
buffer_count: Rc::new(RefCell::new(0)),
|
||||
mmap,
|
||||
callback: Rc::new(RefCell::new(callback)),
|
||||
})
|
||||
}
|
||||
|
||||
/// Resize the memory pool
|
||||
///
|
||||
/// This affect the size as it is seen by the wayland server. Even
|
||||
/// if you extend the temporary file size by writing to it, you need to
|
||||
/// call this method otherwise the server won't see the new size.
|
||||
///
|
||||
/// Memory pools can only be extented, as such this method will do nothing
|
||||
/// if the requested new size is smaller than the current size.
|
||||
///
|
||||
/// This method allows you to ensure the underlying pool is large enough to
|
||||
/// hold what you want to write to it.
|
||||
pub fn resize(&mut self, newsize: usize) -> io::Result<()> {
|
||||
if newsize > self.len {
|
||||
self.file.set_len(newsize as u64)?;
|
||||
self.pool.resize(newsize as i32);
|
||||
self.len = newsize;
|
||||
self.mmap = unsafe { MmapMut::map_mut(&self.file).unwrap() };
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Create a new buffer to this pool
|
||||
///
|
||||
/// The parameters are:
|
||||
///
|
||||
/// - `offset`: the offset (in bytes) from the beginning of the pool at which this
|
||||
/// buffer starts
|
||||
/// - `width`: the width of this buffer (in pixels)
|
||||
/// - `height`: the height of this buffer (in pixels)
|
||||
/// - `stride`: distance (in bytes) between the beginning of a row and the next one
|
||||
/// - `format`: the encoding format of the pixels. Using a format that was not
|
||||
/// advertised to the `wl_shm` global by the server is a protocol error and will
|
||||
/// terminate your connection
|
||||
pub fn buffer(
|
||||
&self,
|
||||
offset: i32,
|
||||
width: i32,
|
||||
height: i32,
|
||||
stride: i32,
|
||||
format: wl_shm::Format,
|
||||
) -> wl_buffer::WlBuffer {
|
||||
*self.buffer_count.borrow_mut() += 1;
|
||||
let my_buffer_count = self.buffer_count.clone();
|
||||
let my_callback = self.callback.clone();
|
||||
let buffer = self
|
||||
.pool
|
||||
.create_buffer(offset, width, height, stride, format);
|
||||
buffer.quick_assign(move |buffer, event, dispatch_data| match event {
|
||||
wl_buffer::Event::Release => {
|
||||
buffer.destroy();
|
||||
let new_count = {
|
||||
// borrow the buffer_count for as short as possible, in case
|
||||
// the user wants to create a new buffer from the callback
|
||||
let mut my_buffer_count = my_buffer_count.borrow_mut();
|
||||
*my_buffer_count -= 1;
|
||||
*my_buffer_count
|
||||
};
|
||||
if new_count == 0 {
|
||||
(&mut *my_callback.borrow_mut())(dispatch_data);
|
||||
}
|
||||
}
|
||||
_ => unreachable!(),
|
||||
});
|
||||
(*buffer).clone().detach()
|
||||
}
|
||||
|
||||
/// Uses the memmap crate to map the underlying shared memory file
|
||||
pub fn mmap(&mut self) -> &mut MmapMut {
|
||||
&mut self.mmap
|
||||
}
|
||||
|
||||
/// Returns true if the pool contains buffers that are currently in use by the server
|
||||
pub fn is_used(&self) -> bool {
|
||||
*self.buffer_count.borrow() != 0
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for MemPool {
|
||||
fn drop(&mut self) {
|
||||
self.pool.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
impl io::Write for MemPool {
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
io::Write::write(&mut self.file, buf)
|
||||
}
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
io::Write::flush(&mut self.file)
|
||||
}
|
||||
}
|
||||
|
||||
impl io::Seek for MemPool {
|
||||
fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
|
||||
io::Seek::seek(&mut self.file, pos)
|
||||
}
|
||||
}
|
||||
|
||||
fn create_shm_fd() -> io::Result<RawFd> {
|
||||
// Only try memfd on linux
|
||||
#[cfg(target_os = "linux")]
|
||||
loop {
|
||||
match memfd::memfd_create(
|
||||
CStr::from_bytes_with_nul(b"smithay-client-toolkit\0").unwrap(),
|
||||
memfd::MemFdCreateFlag::MFD_CLOEXEC,
|
||||
) {
|
||||
Ok(fd) => return Ok(fd),
|
||||
Err(Errno::EINTR) => continue,
|
||||
Err(Errno::ENOSYS) => break,
|
||||
Err(errno) => return Err(io::Error::from(errno)),
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback to using shm_open
|
||||
let sys_time = SystemTime::now();
|
||||
let mut mem_file_handle = format!(
|
||||
"/smithay-client-toolkit-{}",
|
||||
sys_time.duration_since(UNIX_EPOCH).unwrap().subsec_nanos()
|
||||
);
|
||||
loop {
|
||||
match mman::shm_open(
|
||||
mem_file_handle.as_str(),
|
||||
fcntl::OFlag::O_CREAT
|
||||
| fcntl::OFlag::O_EXCL
|
||||
| fcntl::OFlag::O_RDWR
|
||||
| fcntl::OFlag::O_CLOEXEC,
|
||||
stat::Mode::S_IRUSR | stat::Mode::S_IWUSR,
|
||||
) {
|
||||
Ok(fd) => match mman::shm_unlink(mem_file_handle.as_str()) {
|
||||
Ok(_) => return Ok(fd),
|
||||
Err(errno) => match unistd::close(fd) {
|
||||
Ok(_) => return Err(io::Error::from(errno)),
|
||||
Err(errno) => return Err(io::Error::from(errno)),
|
||||
},
|
||||
},
|
||||
Err(Errno::EEXIST) => {
|
||||
// If a file with that handle exists then change the handle
|
||||
mem_file_handle = format!(
|
||||
"/smithay-client-toolkit-{}",
|
||||
sys_time.duration_since(UNIX_EPOCH).unwrap().subsec_nanos()
|
||||
);
|
||||
continue;
|
||||
}
|
||||
Err(Errno::EINTR) => continue,
|
||||
Err(errno) => return Err(io::Error::from(errno)),
|
||||
}
|
||||
}
|
||||
}
|
||||
use smithay_client_toolkit::utils::MemPool;
|
||||
use wayland_client::protocol::wl_shm;
|
||||
|
||||
pub struct DoubleMemPool {
|
||||
pool1: MemPool,
|
||||
@@ -231,10 +8,10 @@ pub struct DoubleMemPool {
|
||||
}
|
||||
|
||||
impl DoubleMemPool {
|
||||
pub fn new(shm: Main<wl_shm::WlShm>) -> ::std::io::Result<DoubleMemPool> {
|
||||
pub fn new(shm: &wl_shm::WlShm) -> ::std::io::Result<DoubleMemPool> {
|
||||
Ok(DoubleMemPool {
|
||||
pool1: MemPool::new(shm.clone(), move |_| {})?,
|
||||
pool2: MemPool::new(shm.clone(), move |_| {})?,
|
||||
pool1: MemPool::new(shm, move || {})?,
|
||||
pool2: MemPool::new(shm, move || {})?,
|
||||
switch: false,
|
||||
})
|
||||
}
|
||||
|
||||
+34
-110
@@ -1,23 +1,38 @@
|
||||
use crate::buffer::Buffer;
|
||||
use crate::{color::Color, fonts::FontRef};
|
||||
use crate::color::Color;
|
||||
|
||||
use rusttype::{point, Scale};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use lazy_static::lazy_static;
|
||||
use rusttype::{point, Font as RustFont, Scale};
|
||||
|
||||
pub static DEJAVUSANS_MONO_FONT_DATA: &'static [u8] =
|
||||
include_bytes!("../fonts/dejavu/DejaVuSansMono.ttf");
|
||||
pub static ROBOTO_REGULAR_FONT_DATA: &'static [u8] = include_bytes!("../fonts/Roboto-Regular.ttf");
|
||||
|
||||
lazy_static! {
|
||||
pub static ref DEJAVUSANS_MONO: RustFont<'static> =
|
||||
RustFont::from_bytes(DEJAVUSANS_MONO_FONT_DATA as &[u8])
|
||||
.expect("error constructing DejaVuSansMono");
|
||||
pub static ref ROBOTO_REGULAR: RustFont<'static> =
|
||||
RustFont::from_bytes(ROBOTO_REGULAR_FONT_DATA as &[u8])
|
||||
.expect("error constructing Roboto-Regular");
|
||||
}
|
||||
|
||||
struct CachedGlyph {
|
||||
dimensions: (u32, u32),
|
||||
origin: (i32, i32),
|
||||
render: Vec<f32>,
|
||||
advance: i32,
|
||||
}
|
||||
|
||||
impl CachedGlyph {
|
||||
fn new(font: FontRef, size: f32, ch: char) -> CachedGlyph {
|
||||
fn new(font: &RustFont, size: f32, ch: char) -> CachedGlyph {
|
||||
let scale = Scale::uniform(size);
|
||||
let v_metrics = font.v_metrics(scale);
|
||||
let glyph = font.glyph(ch).scaled(scale);
|
||||
let advance = glyph.h_metrics().advance_width as i32;
|
||||
let glyph = glyph.positioned(point(0.0, v_metrics.ascent));
|
||||
let glyph = font
|
||||
.glyph(ch)
|
||||
.scaled(scale)
|
||||
.positioned(point(0.0, v_metrics.ascent));
|
||||
|
||||
if let Some(bounding_box) = glyph.pixel_bounding_box() {
|
||||
let origin = (bounding_box.min.x, bounding_box.min.y);
|
||||
@@ -32,17 +47,15 @@ impl CachedGlyph {
|
||||
render[pos as usize] = o;
|
||||
});
|
||||
CachedGlyph {
|
||||
origin,
|
||||
dimensions,
|
||||
render,
|
||||
advance,
|
||||
origin: origin,
|
||||
dimensions: dimensions,
|
||||
render: render,
|
||||
}
|
||||
} else {
|
||||
CachedGlyph {
|
||||
origin: (0, 0),
|
||||
dimensions: (0, 0),
|
||||
dimensions: ((size / 4.0) as u32, 0),
|
||||
render: Vec::new(),
|
||||
advance: (size / 4.0) as i32,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -69,18 +82,18 @@ impl CachedGlyph {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Font<'a> {
|
||||
pub struct Font {
|
||||
glyphs: HashMap<char, CachedGlyph>,
|
||||
font: FontRef<'a>,
|
||||
font: &'static RustFont<'static>,
|
||||
size: f32,
|
||||
}
|
||||
|
||||
impl<'a> Font<'a> {
|
||||
pub fn new(font: FontRef<'a>, size: f32) -> Font {
|
||||
impl Font {
|
||||
pub fn new(font: &'static RustFont, size: f32) -> Font {
|
||||
Font {
|
||||
glyphs: HashMap::new(),
|
||||
font,
|
||||
size,
|
||||
font: font,
|
||||
size: size,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -120,89 +133,12 @@ impl<'a> Font<'a> {
|
||||
}
|
||||
for glyph in glyphs {
|
||||
glyph.draw(buf, (x_off, -off), bg, c);
|
||||
x_off += glyph.advance;
|
||||
x_off += glyph.dimensions.0 as i32 + glyph.origin.0;
|
||||
}
|
||||
|
||||
Ok((x_off as u32, self.size as u32))
|
||||
}
|
||||
|
||||
pub fn draw_text_with_cursor(
|
||||
&self,
|
||||
buf: &mut Buffer,
|
||||
bg: &Color,
|
||||
c: &Color,
|
||||
s: &str,
|
||||
cursor: usize,
|
||||
) -> Result<(u32, u32), ::std::io::Error> {
|
||||
let mut x_off: i32 = 0;
|
||||
let mut off: i32 = 0;
|
||||
let mut glyphs = Vec::with_capacity(s.len());
|
||||
for ch in s.chars() {
|
||||
let glyph = match self.glyphs.get(&ch) {
|
||||
Some(glyph) => glyph,
|
||||
None => {
|
||||
return Err(::std::io::Error::new(
|
||||
::std::io::ErrorKind::Other,
|
||||
format!("glyph for {:} not in cache", ch),
|
||||
))
|
||||
}
|
||||
};
|
||||
glyphs.push(glyph);
|
||||
if glyph.origin.1 < off {
|
||||
off = glyph.origin.1
|
||||
}
|
||||
}
|
||||
|
||||
let height = buf.get_bounds().3;
|
||||
for (i, glyph) in glyphs.iter().enumerate() {
|
||||
if i == cursor {
|
||||
self.draw_cursor(buf, c, x_off as u32, height)?;
|
||||
}
|
||||
glyph.draw(buf, (x_off, -off), bg, c);
|
||||
x_off += glyph.advance;
|
||||
}
|
||||
if cursor == glyphs.len() {
|
||||
self.draw_cursor(buf, c, x_off as u32, height)?;
|
||||
}
|
||||
|
||||
Ok((x_off as u32, self.size as u32))
|
||||
}
|
||||
|
||||
pub fn draw_cursor(
|
||||
&self,
|
||||
buf: &mut Buffer,
|
||||
c: &Color,
|
||||
offset: u32,
|
||||
height: u32,
|
||||
) -> Result<(), ::std::io::Error> {
|
||||
// draw cursor
|
||||
for i in 1..height {
|
||||
buf.put((offset, i), c)?
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn auto_widest(&mut self, s: &str) -> Result<u32, ::std::io::Error> {
|
||||
self.add_str_to_cache(s);
|
||||
let mut max = 0;
|
||||
for ch in s.chars() {
|
||||
let glyph = match self.glyphs.get(&ch) {
|
||||
Some(glyph) => glyph,
|
||||
None => {
|
||||
return Err(::std::io::Error::new(
|
||||
::std::io::ErrorKind::Other,
|
||||
format!("glyph for {:} not in cache", ch),
|
||||
))
|
||||
}
|
||||
};
|
||||
let width = glyph.advance;
|
||||
if width > max {
|
||||
max = width
|
||||
}
|
||||
}
|
||||
Ok(max as u32)
|
||||
}
|
||||
|
||||
pub fn auto_draw_text(
|
||||
&mut self,
|
||||
buf: &mut Buffer,
|
||||
@@ -214,18 +150,6 @@ impl<'a> Font<'a> {
|
||||
self.draw_text(buf, bg, c, s)
|
||||
}
|
||||
|
||||
pub fn auto_draw_text_with_cursor(
|
||||
&mut self,
|
||||
buf: &mut Buffer,
|
||||
bg: &Color,
|
||||
c: &Color,
|
||||
s: &str,
|
||||
cursor: usize,
|
||||
) -> Result<(u32, u32), ::std::io::Error> {
|
||||
self.add_str_to_cache(s);
|
||||
self.draw_text_with_cursor(buf, bg, c, s, cursor)
|
||||
}
|
||||
|
||||
pub fn draw_text_fixed_width(
|
||||
&self,
|
||||
buf: &mut Buffer,
|
||||
@@ -287,7 +211,7 @@ impl<'a> Font<'a> {
|
||||
}
|
||||
for (idx, glyph) in glyphs.into_iter().enumerate() {
|
||||
glyph.draw(buf, (x_off, -off), bg, &color[idx]);
|
||||
x_off += glyph.advance;
|
||||
x_off += glyph.dimensions.0 as i32 + glyph.origin.0;
|
||||
}
|
||||
|
||||
Ok((x_off as u32, self.size as u32))
|
||||
|
||||
@@ -1,47 +0,0 @@
|
||||
//! Utility module for fonts
|
||||
|
||||
use fontconfig::Fontconfig as FontConfig;
|
||||
use rusttype::Font;
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fs::File,
|
||||
io::Read,
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
|
||||
/// FontMap is used to store different font configurations
|
||||
pub type FontMap<'a> = HashMap<String, rusttype::Font<'a>>;
|
||||
|
||||
/// FontRef is used to store Fonts on widgets.
|
||||
pub type FontRef<'a> = &'a rusttype::Font<'a>;
|
||||
|
||||
/// FontSeeker is a marker struct that is used to look up fonts
|
||||
pub(crate) struct FontSeeker;
|
||||
|
||||
impl FontSeeker {
|
||||
/// Acts like fc-match.
|
||||
/// Given a string, it matches it to a font file and returns its path.
|
||||
pub(crate) fn from_string(name: &str) -> PathBuf {
|
||||
let fc = FontConfig::new().unwrap();
|
||||
fc.find(name, None).unwrap().path
|
||||
}
|
||||
}
|
||||
|
||||
/// FontLoader is a marker struct that is used to load files
|
||||
pub(crate) struct FontLoader;
|
||||
|
||||
impl FontLoader {
|
||||
/// Given a path, loads it as a Font, which can be rendered to the screen.
|
||||
pub(crate) fn from_path<'a, P>(path: P) -> Option<Font<'a>>
|
||||
where
|
||||
P: AsRef<Path>,
|
||||
{
|
||||
let mut file = File::open(path).expect("Font file not found");
|
||||
let mut data = match file.metadata() {
|
||||
Ok(metadata) => Vec::with_capacity(metadata.len() as usize),
|
||||
Err(_) => vec![],
|
||||
};
|
||||
file.read_to_end(&mut data).unwrap();
|
||||
Font::try_from_vec(data)
|
||||
}
|
||||
}
|
||||
@@ -1,269 +0,0 @@
|
||||
#![allow(dead_code, non_camel_case_types, clippy::identity_op)]
|
||||
#![cfg_attr(rustfmt, rustfmt_skip)]
|
||||
|
||||
use std::os::raw::{c_char, c_int, c_void, c_uint};
|
||||
|
||||
pub const XKB_MOD_NAME_SHIFT : &[u8] = b"Shift\0";
|
||||
pub const XKB_MOD_NAME_CAPS : &[u8] = b"Lock\0";
|
||||
pub const XKB_MOD_NAME_CTRL : &[u8] = b"Control\0";
|
||||
pub const XKB_MOD_NAME_ALT : &[u8] = b"Mod1\0";
|
||||
pub const XKB_MOD_NAME_NUM : &[u8] = b"Mod2\0";
|
||||
pub const XKB_MOD_NAME_LOGO : &[u8] = b"Mod4\0";
|
||||
|
||||
pub const XKB_LED_NAME_CAPS : &[u8] = b"Caps Lock\0";
|
||||
pub const XKB_LED_NAME_NUM : &[u8] = b"Num Lock\0";
|
||||
pub const XKB_LED_NAME_SCROLL : &[u8] = b"Scroll Lock\0";
|
||||
|
||||
pub struct xkb_context;
|
||||
pub struct xkb_keymap;
|
||||
pub struct xkb_state;
|
||||
pub struct xkb_compose_table;
|
||||
pub struct xkb_compose_state;
|
||||
|
||||
pub type xkb_keycode_t = u32;
|
||||
pub type xkb_keysym_t = u32;
|
||||
pub type xkb_layout_index_t = u32;
|
||||
pub type xkb_layout_mask_t = u32;
|
||||
pub type xkb_level_index_t = u32;
|
||||
pub type xkb_mod_index_t = u32;
|
||||
pub type xkb_mod_mask_t = u32;
|
||||
pub type xkb_led_index_t = u32;
|
||||
pub type xkb_led_mask_t = u32;
|
||||
|
||||
pub const XKB_KEYCODE_INVALID :u32 = 0xffff_ffff;
|
||||
pub const XKB_LAYOUT_INVALID :u32 = 0xffff_ffff;
|
||||
pub const XKB_LEVEL_INVALID :u32 = 0xffff_ffff;
|
||||
pub const XKB_MOD_INVALID :u32 = 0xffff_ffff;
|
||||
pub const XKB_LED_INVALID :u32 = 0xffff_ffff;
|
||||
pub const XKB_KEYCODE_MAX :u32 = 0xffff_fffe;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct xkb_rule_names {
|
||||
pub rules: *const c_char,
|
||||
pub model: *const c_char ,
|
||||
pub layout: *const c_char,
|
||||
pub variant: *const c_char,
|
||||
pub options: *const c_char,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_keysym_flags {
|
||||
/** Do not apply any flags. */
|
||||
XKB_KEYSYM_NO_FLAGS = 0,
|
||||
/** Find keysym by case-insensitive search. */
|
||||
XKB_KEYSYM_CASE_INSENSITIVE = (1 << 0)
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_context_flags {
|
||||
/** Do not apply any context flags. */
|
||||
XKB_CONTEXT_NO_FLAGS = 0,
|
||||
/** Create this context with an empty include path. */
|
||||
XKB_CONTEXT_NO_DEFAULT_INCLUDES = (1 << 0),
|
||||
/**
|
||||
* Don't take RMLVO names from the environment.
|
||||
* @since 0.3.0
|
||||
*/
|
||||
XKB_CONTEXT_NO_ENVIRONMENT_NAMES = (1 << 1)
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_log_level {
|
||||
/** Log critical internal errors only. */
|
||||
XKB_LOG_LEVEL_CRITICAL = 10,
|
||||
/** Log all errors. */
|
||||
XKB_LOG_LEVEL_ERROR = 20,
|
||||
/** Log warnings and errors. */
|
||||
XKB_LOG_LEVEL_WARNING = 30,
|
||||
/** Log information, warnings, and errors. */
|
||||
XKB_LOG_LEVEL_INFO = 40,
|
||||
/** Log everything. */
|
||||
XKB_LOG_LEVEL_DEBUG = 50
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_keymap_compile_flags {
|
||||
/** Do not apply any flags. */
|
||||
XKB_KEYMAP_COMPILE_NO_FLAGS = 0,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_keymap_format {
|
||||
/** Cannot be used for creation */
|
||||
XKB_KEYMAP_USE_ORIGINAL_FORMAT = 0,
|
||||
/** The current/classic XKB text format, as generated by xkbcomp -xkb. */
|
||||
XKB_KEYMAP_FORMAT_TEXT_V1 = 1,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_key_direction {
|
||||
/** The key was released. */
|
||||
XKB_KEY_UP,
|
||||
/** The key was pressed. */
|
||||
XKB_KEY_DOWN
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_compose_compile_flags {
|
||||
XKB_COMPOSE_COMPILE_NO_FLAGS = 0
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_compose_format {
|
||||
XKB_COMPOSE_FORMAT_TEXT_V1 = 1
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_compose_state_flags {
|
||||
XKB_COMPOSE_STATE_NO_FLAGS = 0
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_compose_status {
|
||||
XKB_COMPOSE_NOTHING,
|
||||
XKB_COMPOSE_COMPOSING,
|
||||
XKB_COMPOSE_COMPOSED,
|
||||
XKB_COMPOSE_CANCELLED
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum xkb_compose_feed_result {
|
||||
XKB_COMPOSE_FEED_IGNORED,
|
||||
XKB_COMPOSE_FEED_ACCEPTED
|
||||
}
|
||||
|
||||
bitflags::bitflags!(
|
||||
pub struct xkb_state_component: u32 {
|
||||
/** Depressed modifiers, i.e. a key is physically holding them. */
|
||||
const XKB_STATE_MODS_DEPRESSED = (1 << 0);
|
||||
/** Latched modifiers, i.e. will be unset after the next non-modifier
|
||||
* key press. */
|
||||
const XKB_STATE_MODS_LATCHED = (1 << 1);
|
||||
/** Locked modifiers, i.e. will be unset after the key provoking the
|
||||
* lock has been pressed again. */
|
||||
const XKB_STATE_MODS_LOCKED = (1 << 2);
|
||||
/** Effective modifiers, i.e. currently active and affect key
|
||||
* processing (derived from the other state components).
|
||||
* Use this unless you explictly care how the state came about. */
|
||||
const XKB_STATE_MODS_EFFECTIVE = (1 << 3);
|
||||
/** Depressed layout, i.e. a key is physically holding it. */
|
||||
const XKB_STATE_LAYOUT_DEPRESSED = (1 << 4);
|
||||
/** Latched layout, i.e. will be unset after the next non-modifier
|
||||
* key press. */
|
||||
const XKB_STATE_LAYOUT_LATCHED = (1 << 5);
|
||||
/** Locked layout, i.e. will be unset after the key provoking the lock
|
||||
* has been pressed again. */
|
||||
const XKB_STATE_LAYOUT_LOCKED = (1 << 6);
|
||||
/** Effective layout, i.e. currently active and affects key processing
|
||||
* (derived from the other state components).
|
||||
* Use this unless you explictly care how the state came about. */
|
||||
const XKB_STATE_LAYOUT_EFFECTIVE = (1 << 7);
|
||||
/** LEDs (derived from the other state components). */
|
||||
const XKB_STATE_LEDS = (1 << 8);
|
||||
}
|
||||
);
|
||||
|
||||
dlopen_external_library!(XkbCommon,
|
||||
functions:
|
||||
fn xkb_keysym_get_name(xkb_keysym_t, *mut c_char, usize) -> c_int,
|
||||
fn xkb_keysym_from_name(*const c_char, xkb_keysym_flags) -> xkb_keysym_t,
|
||||
fn xkb_keysym_to_utf8(xkb_keysym_t, *mut c_char, usize) -> c_int,
|
||||
fn xkb_keysym_to_utf32(xkb_keysym_t) -> u32,
|
||||
fn xkb_context_new(xkb_context_flags) -> *mut xkb_context,
|
||||
fn xkb_context_ref(*mut xkb_context) -> *mut xkb_context,
|
||||
fn xkb_context_unref(*mut xkb_context) -> (),
|
||||
fn xkb_context_set_user_data(*mut xkb_context, *mut c_void) -> (),
|
||||
fn xkb_context_get_user_data(*mut xkb_context) -> *mut c_void,
|
||||
fn xkb_context_include_path_append(*mut xkb_context, *const c_char) -> c_int,
|
||||
fn xkb_context_include_path_append_default(*mut xkb_context) -> c_int,
|
||||
fn xkb_context_include_path_reset_defaults(*mut xkb_context) -> c_int,
|
||||
fn xkb_context_include_path_clear(*mut xkb_context) -> (),
|
||||
fn xkb_context_num_include_paths(*mut xkb_context) -> c_uint,
|
||||
fn xkb_context_include_path_get(*mut xkb_context, c_uint) -> *const c_char,
|
||||
fn xkb_context_set_log_level(*mut xkb_context, xkb_log_level) -> (),
|
||||
fn xkb_context_get_log_level(*mut xkb_context) -> xkb_log_level,
|
||||
fn xkb_context_set_log_verbosity(*mut xkb_context, c_int) -> (),
|
||||
fn xkb_context_get_log_verbosity(*mut xkb_context) -> c_int,
|
||||
fn xkb_keymap_new_from_names(*mut xkb_context,
|
||||
*const xkb_rule_names,
|
||||
xkb_keymap_compile_flags
|
||||
) -> *mut xkb_keymap,
|
||||
fn xkb_keymap_new_from_string(*mut xkb_context,
|
||||
*const c_char,
|
||||
xkb_keymap_format,
|
||||
xkb_keymap_compile_flags
|
||||
) -> *mut xkb_keymap,
|
||||
fn xkb_keymap_new_from_buffer(*mut xkb_context,
|
||||
*const c_char,
|
||||
usize,
|
||||
xkb_keymap_format,
|
||||
xkb_keymap_compile_flags
|
||||
) -> *mut xkb_keymap,
|
||||
fn xkb_keymap_ref(*mut xkb_keymap) -> *mut xkb_keymap,
|
||||
fn xkb_keymap_unref(*mut xkb_keymap) -> (),
|
||||
fn xkb_keymap_get_as_string(*mut xkb_keymap, xkb_keymap_format) -> *const c_char,
|
||||
fn xkb_keymap_key_repeats(*mut xkb_keymap, xkb_keycode_t) -> c_int,
|
||||
|
||||
fn xkb_state_new(*mut xkb_keymap) -> *mut xkb_state,
|
||||
fn xkb_state_ref(*mut xkb_state) -> *mut xkb_state,
|
||||
fn xkb_state_unref(*mut xkb_state) -> (),
|
||||
fn xkb_state_update_mask(*mut xkb_state,
|
||||
xkb_mod_mask_t,
|
||||
xkb_mod_mask_t,
|
||||
xkb_mod_mask_t,
|
||||
xkb_layout_index_t,
|
||||
xkb_layout_index_t,
|
||||
xkb_layout_index_t
|
||||
) -> xkb_state_component,
|
||||
fn xkb_state_update_key(*mut xkb_state,
|
||||
xkb_keycode_t,
|
||||
xkb_key_direction
|
||||
) -> xkb_state_component,
|
||||
fn xkb_state_key_get_syms(*mut xkb_state,
|
||||
xkb_keycode_t,
|
||||
*const *mut xkb_keysym_t
|
||||
) -> c_int,
|
||||
fn xkb_state_key_get_utf8(*mut xkb_state,
|
||||
xkb_keycode_t,
|
||||
*mut c_char,
|
||||
usize
|
||||
) -> c_int,
|
||||
fn xkb_state_key_get_utf32(*mut xkb_state, xkb_keycode_t) -> u32,
|
||||
fn xkb_state_key_get_one_sym(*mut xkb_state, xkb_keycode_t) -> xkb_keysym_t,
|
||||
fn xkb_state_mod_name_is_active(*mut xkb_state, *const c_char, xkb_state_component) -> c_int,
|
||||
fn xkb_compose_table_new_from_locale(*mut xkb_context, *const c_char, xkb_compose_compile_flags) -> *mut xkb_compose_table,
|
||||
fn xkb_compose_table_unref(*mut xkb_compose_table) -> (),
|
||||
fn xkb_compose_state_new(*mut xkb_compose_table, xkb_compose_state_flags) -> *mut xkb_compose_state,
|
||||
fn xkb_compose_state_unref(*mut xkb_compose_state) -> (),
|
||||
fn xkb_compose_state_feed(*mut xkb_compose_state, xkb_keysym_t) -> xkb_compose_feed_result,
|
||||
fn xkb_compose_state_reset(*mut xkb_compose_state) -> (),
|
||||
fn xkb_compose_state_get_status(*mut xkb_compose_state) -> xkb_compose_status,
|
||||
fn xkb_compose_state_get_utf8(*mut xkb_compose_state, *mut c_char, usize) -> c_int,
|
||||
fn xkb_compose_state_get_one_sym(*mut xkb_compose_state) -> xkb_keysym_t,
|
||||
);
|
||||
|
||||
lazy_static::lazy_static!(
|
||||
pub static ref XKBCOMMON_OPTION: Option<XkbCommon> = {
|
||||
unsafe {
|
||||
XkbCommon::open("libxkbcommon.so.0")
|
||||
.or_else(|_| XkbCommon::open("libxkbcommon.so"))
|
||||
.ok()
|
||||
}
|
||||
};
|
||||
pub static ref XKBCOMMON_HANDLE: &'static XkbCommon = {
|
||||
XKBCOMMON_OPTION.as_ref().expect("Library libxkbcommon.so could not be loaded.")
|
||||
};
|
||||
);
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
#![allow(missing_docs, non_upper_case_globals, unused_parens, clippy::all)]
|
||||
|
||||
pub const XKB_KEY_BackSpace: u32 = 0xff08; /* Back space, back char */
|
||||
pub const XKB_KEY_Tab: u32 = 0xff09;
|
||||
pub const XKB_KEY_Return: u32 = 0xff0d; /* Return, enter */
|
||||
pub const XKB_KEY_Escape: u32 = 0xff1b;
|
||||
pub const XKB_KEY_Delete: u32 = 0xffff; /* Delete, rubout */
|
||||
pub const XKB_KEY_Home: u32 = 0xff50;
|
||||
pub const XKB_KEY_Left: u32 = 0xff51; /* Move left, left arrow */
|
||||
pub const XKB_KEY_Right: u32 = 0xff53; /* Move right, right arrow */
|
||||
pub const XKB_KEY_End: u32 = 0xff57; /* EOL */
|
||||
|
||||
pub const XKB_KEY_ISO_Left_Tab: u32 = 0xfe20;
|
||||
pub const XKB_KEY_e: u32 = 0x0065; /* U+0065 LATIN SMALL LETTER E */
|
||||
pub const XKB_KEY_a: u32 = 0x0061; /* U+0061 LATIN SMALL LETTER A */
|
||||
pub const XKB_KEY_c: u32 = 0x0063; /* U+0063 LATIN SMALL LETTER C */
|
||||
pub const XKB_KEY_u: u32 = 0x0075; /* U+0075 LATIN SMALL LETTER U */
|
||||
@@ -1,344 +0,0 @@
|
||||
//! Utilities for keymap interpretation of keyboard input
|
||||
//!
|
||||
//! This module provides an implementation for `wl_keyboard`
|
||||
//! objects using `libxkbcommon` to interpret the keyboard input
|
||||
//! given the user keymap.
|
||||
//!
|
||||
//! The entry point of this module is the [`map_keyboard`](fn.map_keyboard.html)
|
||||
//! function which, given a `wl_seat` and a callback, setup keymap interpretation
|
||||
//! and key repetition for the `wl_keyboard` of this seat.
|
||||
//!
|
||||
//! Key repetition relies on an event source, that needs to be inserted in your
|
||||
//! calloop event loop. Not doing so will prevent key repetition to work
|
||||
//! (but the rest of the functionnality will not be affected).
|
||||
|
||||
use std::{cell::RefCell, os::unix::io::RawFd, rc::Rc};
|
||||
|
||||
use byteorder::{ByteOrder, NativeEndian};
|
||||
|
||||
pub use wayland_client::protocol::wl_keyboard::KeyState;
|
||||
use wayland_client::{
|
||||
protocol::{wl_keyboard, wl_seat, wl_surface},
|
||||
Attached,
|
||||
};
|
||||
|
||||
mod ffi;
|
||||
pub mod keysyms;
|
||||
mod state;
|
||||
|
||||
use self::state::KbState;
|
||||
pub use self::state::{ModifiersState, RMLVO};
|
||||
|
||||
#[derive(Debug)]
|
||||
/// An error that occurred while trying to initialize a mapped keyboard
|
||||
pub enum Error {
|
||||
/// libxkbcommon is not available
|
||||
XKBNotFound,
|
||||
/// Provided RMLVO specified a keymap that would not be loaded
|
||||
BadNames,
|
||||
}
|
||||
|
||||
/// Events received from a mapped keyboard
|
||||
pub enum Event<'a> {
|
||||
/// The keyboard focus has entered a surface
|
||||
Enter {
|
||||
/// serial number of the event
|
||||
serial: u32,
|
||||
/// surface that was entered
|
||||
surface: wl_surface::WlSurface,
|
||||
/// raw values of the currently pressed keys
|
||||
rawkeys: &'a [u32],
|
||||
/// interpreted symbols of the currently pressed keys
|
||||
keysyms: &'a [u32],
|
||||
},
|
||||
/// The keyboard focus has left a surface
|
||||
Leave {
|
||||
/// serial number of the event
|
||||
serial: u32,
|
||||
/// surface that was left
|
||||
surface: wl_surface::WlSurface,
|
||||
},
|
||||
/// The key modifiers have changed state
|
||||
Modifiers {
|
||||
/// current state of the modifiers
|
||||
modifiers: ModifiersState,
|
||||
},
|
||||
/// A key event occurred
|
||||
Key {
|
||||
/// serial number of the event
|
||||
serial: u32,
|
||||
/// time at which the keypress occurred
|
||||
time: u32,
|
||||
/// raw value of the key
|
||||
rawkey: u32,
|
||||
/// interpreted symbol of the key
|
||||
keysym: u32,
|
||||
/// new state of the key
|
||||
state: KeyState,
|
||||
/// utf8 interpretation of the entered text
|
||||
///
|
||||
/// will always be `None` on key release events
|
||||
utf8: Option<String>,
|
||||
repeats: bool,
|
||||
},
|
||||
RepeatInfo {
|
||||
rate: i32,
|
||||
delay: i32,
|
||||
},
|
||||
}
|
||||
|
||||
/// Implement a keyboard for keymap translation with key repetition
|
||||
///
|
||||
/// This requires you to provide a callback to receive the events after they
|
||||
/// have been interpreted with the keymap.
|
||||
///
|
||||
/// The keymap will be loaded from the provided RMLVO rules, or from the compositor
|
||||
/// provided keymap if `None`.
|
||||
///
|
||||
/// Returns an error if xkbcommon could not be initialized, the RMLVO specification
|
||||
/// contained invalid values, or if the provided seat does not have keyboard capability.
|
||||
///
|
||||
/// **Note:** This adapter does not handle key repetition. See `map_keyboard_repeat` for that.
|
||||
pub fn map_keyboard<F>(
|
||||
seat: &Attached<wl_seat::WlSeat>,
|
||||
rmlvo: Option<RMLVO>,
|
||||
callback: F,
|
||||
) -> Result<wl_keyboard::WlKeyboard, Error>
|
||||
where
|
||||
F: FnMut(Event<'_>, wl_keyboard::WlKeyboard, wayland_client::DispatchData<'_>) + 'static,
|
||||
{
|
||||
let keyboard = seat.get_keyboard();
|
||||
|
||||
let state = Rc::new(RefCell::new(
|
||||
rmlvo
|
||||
.map(KbState::from_rmlvo)
|
||||
.unwrap_or_else(KbState::new)?,
|
||||
));
|
||||
|
||||
let callback = Rc::new(RefCell::new(callback));
|
||||
|
||||
// prepare the handler
|
||||
let mut kbd_handler = KbdHandler { callback, state };
|
||||
|
||||
keyboard.quick_assign(move |keyboard, event, data| {
|
||||
kbd_handler.event(keyboard.detach(), event, data)
|
||||
});
|
||||
|
||||
Ok(keyboard.detach())
|
||||
}
|
||||
|
||||
/*
|
||||
* Classic handling
|
||||
*/
|
||||
|
||||
type KbdCallback = dyn FnMut(Event<'_>, wl_keyboard::WlKeyboard, wayland_client::DispatchData<'_>);
|
||||
|
||||
struct KbdHandler {
|
||||
state: Rc<RefCell<KbState>>,
|
||||
callback: Rc<RefCell<KbdCallback>>,
|
||||
}
|
||||
|
||||
impl KbdHandler {
|
||||
fn event(
|
||||
&mut self,
|
||||
kbd: wl_keyboard::WlKeyboard,
|
||||
event: wl_keyboard::Event,
|
||||
dispatch_data: wayland_client::DispatchData,
|
||||
) {
|
||||
use wl_keyboard::Event;
|
||||
|
||||
match event {
|
||||
Event::Keymap { format, fd, size } => self.keymap(kbd, format, fd, size),
|
||||
Event::Enter {
|
||||
serial,
|
||||
surface,
|
||||
keys,
|
||||
} => self.enter(kbd, serial, surface, keys, dispatch_data),
|
||||
Event::Leave { serial, surface } => self.leave(kbd, serial, surface, dispatch_data),
|
||||
Event::Key {
|
||||
serial,
|
||||
time,
|
||||
key,
|
||||
state,
|
||||
} => self.key(kbd, serial, time, key, state, dispatch_data),
|
||||
Event::Modifiers {
|
||||
mods_depressed,
|
||||
mods_latched,
|
||||
mods_locked,
|
||||
group,
|
||||
..
|
||||
} => self.modifiers(
|
||||
kbd,
|
||||
mods_depressed,
|
||||
mods_latched,
|
||||
mods_locked,
|
||||
group,
|
||||
dispatch_data,
|
||||
),
|
||||
Event::RepeatInfo { rate, delay } => self.repeat_info(kbd, rate, delay, dispatch_data),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn keymap(
|
||||
&mut self,
|
||||
_: wl_keyboard::WlKeyboard,
|
||||
format: wl_keyboard::KeymapFormat,
|
||||
fd: RawFd,
|
||||
size: u32,
|
||||
) {
|
||||
let mut state = self.state.borrow_mut();
|
||||
if state.locked() {
|
||||
// state is locked, ignore keymap updates
|
||||
return;
|
||||
}
|
||||
if state.ready() {
|
||||
// new keymap, we first deinit to free resources
|
||||
unsafe {
|
||||
state.de_init();
|
||||
}
|
||||
}
|
||||
match format {
|
||||
wl_keyboard::KeymapFormat::XkbV1 => unsafe {
|
||||
state.init_with_fd(fd, size as usize);
|
||||
},
|
||||
wl_keyboard::KeymapFormat::NoKeymap => {
|
||||
// TODO: how to handle this (hopefully never occuring) case?
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
fn enter(
|
||||
&mut self,
|
||||
object: wl_keyboard::WlKeyboard,
|
||||
serial: u32,
|
||||
surface: wl_surface::WlSurface,
|
||||
keys: Vec<u8>,
|
||||
dispatch_data: wayland_client::DispatchData,
|
||||
) {
|
||||
let mut state = self.state.borrow_mut();
|
||||
let rawkeys = keys
|
||||
.chunks_exact(4)
|
||||
.map(NativeEndian::read_u32)
|
||||
.collect::<Vec<_>>();
|
||||
let keys: Vec<u32> = rawkeys.iter().map(|k| state.get_one_sym_raw(*k)).collect();
|
||||
(&mut *self.callback.borrow_mut())(
|
||||
Event::Enter {
|
||||
serial,
|
||||
surface,
|
||||
rawkeys: &rawkeys,
|
||||
keysyms: &keys,
|
||||
},
|
||||
object,
|
||||
dispatch_data,
|
||||
);
|
||||
}
|
||||
|
||||
fn leave(
|
||||
&mut self,
|
||||
object: wl_keyboard::WlKeyboard,
|
||||
serial: u32,
|
||||
surface: wl_surface::WlSurface,
|
||||
dispatch_data: wayland_client::DispatchData,
|
||||
) {
|
||||
(&mut *self.callback.borrow_mut())(Event::Leave { serial, surface }, object, dispatch_data);
|
||||
}
|
||||
|
||||
fn key(
|
||||
&mut self,
|
||||
object: wl_keyboard::WlKeyboard,
|
||||
serial: u32,
|
||||
time: u32,
|
||||
key: u32,
|
||||
key_state: wl_keyboard::KeyState,
|
||||
dispatch_data: wayland_client::DispatchData,
|
||||
) {
|
||||
let (sym, utf8, repeats) = {
|
||||
let mut state = self.state.borrow_mut();
|
||||
// Get the values to generate a key event
|
||||
let sym = state.get_one_sym_raw(key);
|
||||
let utf8 = if key_state == wl_keyboard::KeyState::Pressed {
|
||||
match state.compose_feed(sym) {
|
||||
Some(ffi::xkb_compose_feed_result::XKB_COMPOSE_FEED_ACCEPTED) => {
|
||||
if let Some(status) = state.compose_status() {
|
||||
match status {
|
||||
ffi::xkb_compose_status::XKB_COMPOSE_COMPOSED => {
|
||||
state.compose_get_utf8()
|
||||
}
|
||||
ffi::xkb_compose_status::XKB_COMPOSE_NOTHING => {
|
||||
state.get_utf8_raw(key)
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
} else {
|
||||
state.get_utf8_raw(key)
|
||||
}
|
||||
}
|
||||
Some(_) => {
|
||||
// XKB_COMPOSE_FEED_IGNORED
|
||||
None
|
||||
}
|
||||
None => {
|
||||
// XKB COMPOSE is not initialized
|
||||
state.get_utf8_raw(key)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let repeats = unsafe { state.key_repeats(key + 8) };
|
||||
(sym, utf8, repeats)
|
||||
};
|
||||
|
||||
(&mut *self.callback.borrow_mut())(
|
||||
Event::Key {
|
||||
serial,
|
||||
time,
|
||||
rawkey: key,
|
||||
keysym: sym,
|
||||
state: key_state,
|
||||
utf8,
|
||||
repeats,
|
||||
},
|
||||
object,
|
||||
dispatch_data,
|
||||
);
|
||||
}
|
||||
|
||||
fn modifiers(
|
||||
&mut self,
|
||||
object: wl_keyboard::WlKeyboard,
|
||||
mods_depressed: u32,
|
||||
mods_latched: u32,
|
||||
mods_locked: u32,
|
||||
group: u32,
|
||||
dispatch_data: wayland_client::DispatchData,
|
||||
) {
|
||||
{
|
||||
let mut state = self.state.borrow_mut();
|
||||
state.update_modifiers(mods_depressed, mods_latched, mods_locked, group);
|
||||
(&mut *self.callback.borrow_mut())(
|
||||
Event::Modifiers {
|
||||
modifiers: state.mods_state(),
|
||||
},
|
||||
object,
|
||||
dispatch_data,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn repeat_info(
|
||||
&mut self,
|
||||
object: wl_keyboard::WlKeyboard,
|
||||
rate: i32,
|
||||
delay: i32,
|
||||
dispatch_data: wayland_client::DispatchData,
|
||||
) {
|
||||
(&mut *self.callback.borrow_mut())(
|
||||
Event::RepeatInfo { rate, delay },
|
||||
object,
|
||||
dispatch_data,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,400 +0,0 @@
|
||||
use std::{
|
||||
env,
|
||||
ffi::CString,
|
||||
fs::File,
|
||||
os::raw::c_char,
|
||||
os::unix::{
|
||||
ffi::OsStringExt,
|
||||
io::{FromRawFd, RawFd},
|
||||
},
|
||||
ptr,
|
||||
};
|
||||
|
||||
use memmap::MmapOptions;
|
||||
|
||||
use super::ffi::{self, xkb_state_component, XKBCOMMON_HANDLE as XKBH};
|
||||
use super::Error;
|
||||
|
||||
pub struct KbState {
|
||||
xkb_context: *mut ffi::xkb_context,
|
||||
xkb_keymap: *mut ffi::xkb_keymap,
|
||||
xkb_state: *mut ffi::xkb_state,
|
||||
xkb_compose_table: *mut ffi::xkb_compose_table,
|
||||
xkb_compose_state: *mut ffi::xkb_compose_state,
|
||||
mods_state: ModifiersState,
|
||||
locked: bool,
|
||||
}
|
||||
|
||||
/// The RMLVO description of a keymap
|
||||
///
|
||||
/// All fields are optional, and the system default
|
||||
/// will be used if set to `None`.
|
||||
pub struct RMLVO {
|
||||
/// The rules file to use
|
||||
pub rules: Option<String>,
|
||||
/// The keyboard model by which to interpret keycodes and LEDs
|
||||
pub model: Option<String>,
|
||||
/// A comma separated list of layouts (languages) to include in the keymap
|
||||
pub layout: Option<String>,
|
||||
/// A comma separated list of variants, one per layout, which may modify or
|
||||
/// augment the respective layout in various ways
|
||||
pub variant: Option<String>,
|
||||
/// A comma separated list of options, through which the user specifies
|
||||
/// non-layout related preferences, like which key combinations are
|
||||
/// used for switching layouts, or which key is the Compose key.
|
||||
pub options: Option<String>,
|
||||
}
|
||||
|
||||
/// Represents the current state of the keyboard modifiers
|
||||
///
|
||||
/// Each field of this struct represents a modifier and is `true` if this modifier is active.
|
||||
///
|
||||
/// For some modifiers, this means that the key is currently pressed, others are toggled
|
||||
/// (like caps lock).
|
||||
#[derive(Copy, Clone, Debug, Default)]
|
||||
pub struct ModifiersState {
|
||||
/// The "control" key
|
||||
pub ctrl: bool,
|
||||
/// The "alt" key
|
||||
pub alt: bool,
|
||||
/// The "shift" key
|
||||
pub shift: bool,
|
||||
/// The "Caps lock" key
|
||||
pub caps_lock: bool,
|
||||
/// The "logo" key
|
||||
///
|
||||
/// Also known as the "windows" key on most keyboards
|
||||
pub logo: bool,
|
||||
/// The "Num lock" key
|
||||
pub num_lock: bool,
|
||||
}
|
||||
|
||||
impl ModifiersState {
|
||||
fn new() -> ModifiersState {
|
||||
ModifiersState::default()
|
||||
}
|
||||
|
||||
fn update_with(&mut self, state: *mut ffi::xkb_state) {
|
||||
self.ctrl = unsafe {
|
||||
(XKBH.xkb_state_mod_name_is_active)(
|
||||
state,
|
||||
ffi::XKB_MOD_NAME_CTRL.as_ptr() as *const c_char,
|
||||
xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
|
||||
) > 0
|
||||
};
|
||||
self.alt = unsafe {
|
||||
(XKBH.xkb_state_mod_name_is_active)(
|
||||
state,
|
||||
ffi::XKB_MOD_NAME_ALT.as_ptr() as *const c_char,
|
||||
xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
|
||||
) > 0
|
||||
};
|
||||
self.shift = unsafe {
|
||||
(XKBH.xkb_state_mod_name_is_active)(
|
||||
state,
|
||||
ffi::XKB_MOD_NAME_SHIFT.as_ptr() as *const c_char,
|
||||
xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
|
||||
) > 0
|
||||
};
|
||||
self.caps_lock = unsafe {
|
||||
(XKBH.xkb_state_mod_name_is_active)(
|
||||
state,
|
||||
ffi::XKB_MOD_NAME_CAPS.as_ptr() as *const c_char,
|
||||
xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
|
||||
) > 0
|
||||
};
|
||||
self.logo = unsafe {
|
||||
(XKBH.xkb_state_mod_name_is_active)(
|
||||
state,
|
||||
ffi::XKB_MOD_NAME_LOGO.as_ptr() as *const c_char,
|
||||
xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
|
||||
) > 0
|
||||
};
|
||||
self.num_lock = unsafe {
|
||||
(XKBH.xkb_state_mod_name_is_active)(
|
||||
state,
|
||||
ffi::XKB_MOD_NAME_NUM.as_ptr() as *const c_char,
|
||||
xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
|
||||
) > 0
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
impl KbState {
|
||||
pub(crate) fn update_modifiers(
|
||||
&mut self,
|
||||
mods_depressed: u32,
|
||||
mods_latched: u32,
|
||||
mods_locked: u32,
|
||||
group: u32,
|
||||
) {
|
||||
if !self.ready() {
|
||||
return;
|
||||
}
|
||||
let mask = unsafe {
|
||||
(XKBH.xkb_state_update_mask)(
|
||||
self.xkb_state,
|
||||
mods_depressed,
|
||||
mods_latched,
|
||||
mods_locked,
|
||||
0,
|
||||
0,
|
||||
group,
|
||||
)
|
||||
};
|
||||
if mask.contains(xkb_state_component::XKB_STATE_MODS_EFFECTIVE) {
|
||||
// effective value of mods have changed, we need to update our state
|
||||
self.mods_state.update_with(self.xkb_state);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn get_one_sym_raw(&mut self, keycode: u32) -> u32 {
|
||||
if !self.ready() {
|
||||
return 0;
|
||||
}
|
||||
unsafe { (XKBH.xkb_state_key_get_one_sym)(self.xkb_state, keycode + 8) }
|
||||
}
|
||||
|
||||
pub(crate) fn get_utf8_raw(&mut self, keycode: u32) -> Option<String> {
|
||||
if !self.ready() {
|
||||
return None;
|
||||
}
|
||||
let size = unsafe {
|
||||
(XKBH.xkb_state_key_get_utf8)(self.xkb_state, keycode + 8, ptr::null_mut(), 0)
|
||||
} + 1;
|
||||
if size <= 1 {
|
||||
return None;
|
||||
};
|
||||
let mut buffer = Vec::with_capacity(size as usize);
|
||||
unsafe {
|
||||
buffer.set_len(size as usize);
|
||||
(XKBH.xkb_state_key_get_utf8)(
|
||||
self.xkb_state,
|
||||
keycode + 8,
|
||||
buffer.as_mut_ptr() as *mut _,
|
||||
size as usize,
|
||||
);
|
||||
};
|
||||
// remove the final `\0`
|
||||
buffer.pop();
|
||||
// libxkbcommon will always provide valid UTF8
|
||||
Some(unsafe { String::from_utf8_unchecked(buffer) })
|
||||
}
|
||||
|
||||
pub(crate) fn compose_feed(&mut self, keysym: u32) -> Option<ffi::xkb_compose_feed_result> {
|
||||
if !self.ready() || self.xkb_compose_state.is_null() {
|
||||
return None;
|
||||
}
|
||||
Some(unsafe { (XKBH.xkb_compose_state_feed)(self.xkb_compose_state, keysym) })
|
||||
}
|
||||
|
||||
pub(crate) fn compose_status(&mut self) -> Option<ffi::xkb_compose_status> {
|
||||
if !self.ready() || self.xkb_compose_state.is_null() {
|
||||
return None;
|
||||
}
|
||||
Some(unsafe { (XKBH.xkb_compose_state_get_status)(self.xkb_compose_state) })
|
||||
}
|
||||
|
||||
pub(crate) fn compose_get_utf8(&mut self) -> Option<String> {
|
||||
if !self.ready() || self.xkb_compose_state.is_null() {
|
||||
return None;
|
||||
}
|
||||
let size = unsafe {
|
||||
(XKBH.xkb_compose_state_get_utf8)(self.xkb_compose_state, ptr::null_mut(), 0)
|
||||
} + 1;
|
||||
if size <= 1 {
|
||||
return None;
|
||||
};
|
||||
let mut buffer = Vec::with_capacity(size as usize);
|
||||
unsafe {
|
||||
buffer.set_len(size as usize);
|
||||
(XKBH.xkb_compose_state_get_utf8)(
|
||||
self.xkb_compose_state,
|
||||
buffer.as_mut_ptr() as *mut _,
|
||||
size as usize,
|
||||
);
|
||||
};
|
||||
// remove the final `\0`
|
||||
buffer.pop();
|
||||
// libxkbcommon will always provide valid UTF8
|
||||
Some(unsafe { String::from_utf8_unchecked(buffer) })
|
||||
}
|
||||
|
||||
pub(crate) fn new() -> Result<KbState, Error> {
|
||||
let xkbh = match ffi::XKBCOMMON_OPTION.as_ref() {
|
||||
Some(h) => h,
|
||||
None => return Err(Error::XKBNotFound),
|
||||
};
|
||||
let xkb_context =
|
||||
unsafe { (xkbh.xkb_context_new)(ffi::xkb_context_flags::XKB_CONTEXT_NO_FLAGS) };
|
||||
if xkb_context.is_null() {
|
||||
return Err(Error::XKBNotFound);
|
||||
}
|
||||
|
||||
let mut me = KbState {
|
||||
xkb_context,
|
||||
xkb_keymap: ptr::null_mut(),
|
||||
xkb_state: ptr::null_mut(),
|
||||
xkb_compose_table: ptr::null_mut(),
|
||||
xkb_compose_state: ptr::null_mut(),
|
||||
mods_state: ModifiersState::new(),
|
||||
locked: false,
|
||||
};
|
||||
|
||||
unsafe {
|
||||
me.init_compose();
|
||||
}
|
||||
|
||||
Ok(me)
|
||||
}
|
||||
|
||||
pub(crate) fn from_rmlvo(rmlvo: RMLVO) -> Result<KbState, Error> {
|
||||
fn to_cstring(s: Option<String>) -> Result<Option<CString>, Error> {
|
||||
s.map_or(Ok(None), |s| CString::new(s).map(Option::Some))
|
||||
.map_err(|_| Error::BadNames)
|
||||
}
|
||||
|
||||
let mut state = KbState::new()?;
|
||||
|
||||
let rules = to_cstring(rmlvo.rules)?;
|
||||
let model = to_cstring(rmlvo.model)?;
|
||||
let layout = to_cstring(rmlvo.layout)?;
|
||||
let variant = to_cstring(rmlvo.variant)?;
|
||||
let options = to_cstring(rmlvo.options)?;
|
||||
|
||||
let xkb_names = ffi::xkb_rule_names {
|
||||
rules: rules.map_or(ptr::null(), |s| s.as_ptr()),
|
||||
model: model.map_or(ptr::null(), |s| s.as_ptr()),
|
||||
layout: layout.map_or(ptr::null(), |s| s.as_ptr()),
|
||||
variant: variant.map_or(ptr::null(), |s| s.as_ptr()),
|
||||
options: options.map_or(ptr::null(), |s| s.as_ptr()),
|
||||
};
|
||||
|
||||
unsafe {
|
||||
state.init_with_rmlvo(xkb_names)?;
|
||||
}
|
||||
|
||||
state.locked = true;
|
||||
Ok(state)
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn init_compose(&mut self) {
|
||||
let locale = env::var_os("LC_ALL")
|
||||
.and_then(|v| if v.is_empty() { None } else { Some(v) })
|
||||
.or_else(|| env::var_os("LC_CTYPE"))
|
||||
.and_then(|v| if v.is_empty() { None } else { Some(v) })
|
||||
.or_else(|| env::var_os("LANG"))
|
||||
.and_then(|v| if v.is_empty() { None } else { Some(v) })
|
||||
.unwrap_or_else(|| "C".into());
|
||||
let locale = CString::new(locale.into_vec()).unwrap();
|
||||
|
||||
let compose_table = (XKBH.xkb_compose_table_new_from_locale)(
|
||||
self.xkb_context,
|
||||
locale.as_ptr(),
|
||||
ffi::xkb_compose_compile_flags::XKB_COMPOSE_COMPILE_NO_FLAGS,
|
||||
);
|
||||
|
||||
if compose_table.is_null() {
|
||||
// init of compose table failed, continue without compose
|
||||
return;
|
||||
}
|
||||
|
||||
let compose_state = (XKBH.xkb_compose_state_new)(
|
||||
compose_table,
|
||||
ffi::xkb_compose_state_flags::XKB_COMPOSE_STATE_NO_FLAGS,
|
||||
);
|
||||
|
||||
if compose_state.is_null() {
|
||||
// init of compose state failed, continue without compose
|
||||
(XKBH.xkb_compose_table_unref)(compose_table);
|
||||
return;
|
||||
}
|
||||
|
||||
self.xkb_compose_table = compose_table;
|
||||
self.xkb_compose_state = compose_state;
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn post_init(&mut self, xkb_keymap: *mut ffi::xkb_keymap) {
|
||||
let xkb_state = (XKBH.xkb_state_new)(xkb_keymap);
|
||||
self.xkb_keymap = xkb_keymap;
|
||||
self.xkb_state = xkb_state;
|
||||
self.mods_state.update_with(xkb_state);
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn de_init(&mut self) {
|
||||
(XKBH.xkb_state_unref)(self.xkb_state);
|
||||
self.xkb_state = ptr::null_mut();
|
||||
(XKBH.xkb_keymap_unref)(self.xkb_keymap);
|
||||
self.xkb_keymap = ptr::null_mut();
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn init_with_fd(&mut self, fd: RawFd, size: usize) {
|
||||
let map = MmapOptions::new()
|
||||
.len(size)
|
||||
.map(&File::from_raw_fd(fd))
|
||||
.unwrap();
|
||||
|
||||
let xkb_keymap = (XKBH.xkb_keymap_new_from_string)(
|
||||
self.xkb_context,
|
||||
map.as_ptr() as *const _,
|
||||
ffi::xkb_keymap_format::XKB_KEYMAP_FORMAT_TEXT_V1,
|
||||
ffi::xkb_keymap_compile_flags::XKB_KEYMAP_COMPILE_NO_FLAGS,
|
||||
);
|
||||
|
||||
if xkb_keymap.is_null() {
|
||||
panic!("Received invalid keymap from compositor.");
|
||||
}
|
||||
|
||||
self.post_init(xkb_keymap);
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn init_with_rmlvo(
|
||||
&mut self,
|
||||
names: ffi::xkb_rule_names,
|
||||
) -> Result<(), Error> {
|
||||
let xkb_keymap = (XKBH.xkb_keymap_new_from_names)(
|
||||
self.xkb_context,
|
||||
&names,
|
||||
ffi::xkb_keymap_compile_flags::XKB_KEYMAP_COMPILE_NO_FLAGS,
|
||||
);
|
||||
|
||||
if xkb_keymap.is_null() {
|
||||
return Err(Error::BadNames);
|
||||
}
|
||||
|
||||
self.post_init(xkb_keymap);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn key_repeats(&mut self, xkb_keycode_t: ffi::xkb_keycode_t) -> bool {
|
||||
(XKBH.xkb_keymap_key_repeats)(self.xkb_keymap, xkb_keycode_t) == 1
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub(crate) fn ready(&self) -> bool {
|
||||
!self.xkb_state.is_null()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub(crate) fn locked(&self) -> bool {
|
||||
self.locked
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub(crate) fn mods_state(&self) -> ModifiersState {
|
||||
self.mods_state
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for KbState {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
(XKBH.xkb_compose_state_unref)(self.xkb_compose_state);
|
||||
(XKBH.xkb_compose_table_unref)(self.xkb_compose_table);
|
||||
(XKBH.xkb_state_unref)(self.xkb_state);
|
||||
(XKBH.xkb_keymap_unref)(self.xkb_keymap);
|
||||
(XKBH.xkb_context_unref)(self.xkb_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
+59
-132
@@ -3,12 +3,10 @@ use std::fs::File;
|
||||
use std::io::{BufRead, BufReader, Read, Write};
|
||||
use std::os::unix::io::AsRawFd;
|
||||
use std::os::unix::net::{UnixListener, UnixStream};
|
||||
use std::{collections::HashMap, sync::mpsc::channel};
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
use chrono::{Duration, Local};
|
||||
use nix::poll::{poll, PollFd, PollFlags};
|
||||
use os_pipe::pipe;
|
||||
use timerfd::{SetTimeFlags, TimerFd, TimerState};
|
||||
|
||||
mod app;
|
||||
mod buffer;
|
||||
@@ -16,24 +14,16 @@ mod cmd;
|
||||
mod color;
|
||||
mod config;
|
||||
mod configfmt;
|
||||
mod data;
|
||||
mod desktop;
|
||||
mod doublemempool;
|
||||
mod draw;
|
||||
mod fonts;
|
||||
mod keyboard;
|
||||
mod widget;
|
||||
mod widgets;
|
||||
|
||||
#[macro_use]
|
||||
extern crate dlib;
|
||||
|
||||
use app::{App, OutputMode};
|
||||
use cmd::Cmd;
|
||||
use config::Config;
|
||||
use configfmt::ConfigFmt;
|
||||
use fonts::{FontLoader, FontMap, FontSeeker};
|
||||
use widget::WaitContext;
|
||||
|
||||
enum Mode {
|
||||
Start,
|
||||
@@ -52,7 +42,7 @@ fn main() {
|
||||
Ok(dir) => dir + "/wldash",
|
||||
Err(_) => match env::var("HOME") {
|
||||
Ok(home) => home + "/.config/wldash",
|
||||
_ => panic!("unable to find user folder"),
|
||||
Err(_) => panic!("unable to find user folder"),
|
||||
},
|
||||
};
|
||||
|
||||
@@ -86,19 +76,6 @@ fn main() {
|
||||
|
||||
let scale = config.scale;
|
||||
|
||||
let fonts: FontMap = {
|
||||
let load_font = |font_name| {
|
||||
let path = FontSeeker::from_string(font_name);
|
||||
FontLoader::from_path(&path).expect(&format!("Loading {} failed", path.display()))
|
||||
};
|
||||
|
||||
config
|
||||
.fonts
|
||||
.iter()
|
||||
.map(|(key, val)| (key.clone(), load_font(val)))
|
||||
.collect::<HashMap<_, _>>()
|
||||
};
|
||||
|
||||
let mut args = env::args();
|
||||
let _ = args.next();
|
||||
let mode = match args.next() {
|
||||
@@ -125,7 +102,7 @@ fn main() {
|
||||
},
|
||||
None => Mode::Start,
|
||||
};
|
||||
if args.next().is_some() {
|
||||
if let Some(_) = args.next() {
|
||||
// total = args.count + 2 (the two we skipped + the rest)
|
||||
eprintln!("expected 0 or 1 arguments, got {}", args.count() + 2);
|
||||
std::process::exit(1);
|
||||
@@ -135,7 +112,7 @@ fn main() {
|
||||
|
||||
match mode {
|
||||
Mode::ToggleVisible => {
|
||||
if let Ok(mut socket) = UnixStream::connect(socket_path) {
|
||||
if let Ok(mut socket) = UnixStream::connect(socket_path.clone()) {
|
||||
socket.write_all(b"toggle_visible\n").unwrap();
|
||||
return;
|
||||
};
|
||||
@@ -149,13 +126,13 @@ fn main() {
|
||||
};
|
||||
}
|
||||
Mode::Start => {
|
||||
if UnixStream::connect(socket_path.clone()).is_ok() {
|
||||
if let Ok(_) = UnixStream::connect(socket_path.clone()) {
|
||||
eprintln!("wldash is already running");
|
||||
std::process::exit(1);
|
||||
};
|
||||
}
|
||||
Mode::Daemonize => {
|
||||
if UnixStream::connect(socket_path.clone()).is_ok() {
|
||||
if let Ok(_) = UnixStream::connect(socket_path.clone()) {
|
||||
eprintln!("wldash is already running");
|
||||
std::process::exit(1);
|
||||
};
|
||||
@@ -179,12 +156,14 @@ fn main() {
|
||||
|
||||
let (tx_draw, rx_draw) = channel();
|
||||
let tx_draw_mod = tx_draw.clone();
|
||||
|
||||
// Print, write to a file, or send to an HTTP server.
|
||||
let widget = config
|
||||
.widget
|
||||
.construct(Local::now().naive_local(), tx_draw_mod, &fonts)
|
||||
.expect("no widget configured");
|
||||
let (mod_tx, mod_rx) = channel();
|
||||
std::thread::spawn(move || {
|
||||
// Print, write to a file, or send to an HTTP server.
|
||||
match config.widget.construct(tx_draw_mod) {
|
||||
Some(w) => mod_tx.send(w).unwrap(),
|
||||
None => panic!("no widget configured"),
|
||||
}
|
||||
});
|
||||
|
||||
let mut app = App::new(tx_draw, output_mode, background, scale);
|
||||
if daemon {
|
||||
@@ -192,6 +171,7 @@ fn main() {
|
||||
} else {
|
||||
app.show();
|
||||
}
|
||||
let widget = mod_rx.recv().unwrap();
|
||||
app.set_widget(widget).unwrap();
|
||||
|
||||
let (mut rx_pipe, mut tx_pipe) = pipe().unwrap();
|
||||
@@ -206,23 +186,50 @@ fn main() {
|
||||
tx_pipe.write_all(&[0x1]).unwrap();
|
||||
});
|
||||
|
||||
let mut timer = TimerFd::new().unwrap();
|
||||
let ev_fd = PollFd::new(
|
||||
app.event_queue().display().get_connection_fd(),
|
||||
PollFlags::POLLIN,
|
||||
);
|
||||
let rx_fd = PollFd::new(rx_pipe.as_raw_fd(), PollFlags::POLLIN);
|
||||
let tm_fd = PollFd::new(timer.as_raw_fd(), PollFlags::POLLIN);
|
||||
let ipc_fd = PollFd::new(listener.as_raw_fd(), PollFlags::POLLIN);
|
||||
let ipc_queue = app.cmd_queue();
|
||||
let _ = std::thread::Builder::new()
|
||||
.name("ipc_server".to_string())
|
||||
.spawn(move || loop {
|
||||
for stream in listener.incoming() {
|
||||
match stream {
|
||||
Ok(stream) => {
|
||||
let client_queue = ipc_queue.clone();
|
||||
let mut client_pipe = ipc_pipe.try_clone().unwrap();
|
||||
let _ = std::thread::Builder::new()
|
||||
.name("ipc_client".to_string())
|
||||
.spawn(move || {
|
||||
let r = BufReader::new(stream);
|
||||
for line in r.lines() {
|
||||
match line {
|
||||
Ok(v) => match v.as_str() {
|
||||
"kill" => {
|
||||
client_queue.lock().unwrap().push_back(Cmd::Exit)
|
||||
}
|
||||
"toggle_visible" => client_queue
|
||||
.lock()
|
||||
.unwrap()
|
||||
.push_back(Cmd::ToggleVisible),
|
||||
v => eprintln!("unknown command: {}", v),
|
||||
},
|
||||
Err(_) => return,
|
||||
}
|
||||
client_pipe.write_all(&[0x1]).unwrap();
|
||||
}
|
||||
});
|
||||
}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let mut fds = [
|
||||
PollFd::new(app.event_queue().get_connection_fd(), PollFlags::POLLIN),
|
||||
PollFd::new(rx_pipe.as_raw_fd(), PollFlags::POLLIN),
|
||||
];
|
||||
|
||||
app.cmd_queue().lock().unwrap().push_back(Cmd::Draw);
|
||||
|
||||
let mut visible = !daemon;
|
||||
let mut wait_ctx = WaitContext {
|
||||
fds: Vec::new(),
|
||||
target_time: None,
|
||||
};
|
||||
|
||||
let q = app.cmd_queue();
|
||||
loop {
|
||||
let cmd = q.lock().unwrap().pop_front();
|
||||
@@ -232,11 +239,6 @@ fn main() {
|
||||
app.redraw(false).expect("Failed to draw");
|
||||
app.flush_display();
|
||||
}
|
||||
Cmd::KeyboardTest => {
|
||||
if let Some(cmd) = app.key_repeat() {
|
||||
q.lock().unwrap().push_back(cmd);
|
||||
}
|
||||
}
|
||||
Cmd::ForceDraw => {
|
||||
app.redraw(true).expect("Failed to draw");
|
||||
app.flush_display();
|
||||
@@ -285,36 +287,9 @@ fn main() {
|
||||
None => {
|
||||
app.flush_display();
|
||||
|
||||
wait_ctx.fds.clear();
|
||||
wait_ctx.fds.push(ev_fd);
|
||||
wait_ctx.fds.push(rx_fd);
|
||||
wait_ctx.fds.push(ipc_fd);
|
||||
wait_ctx.target_time = None;
|
||||
poll(&mut fds, -1).unwrap();
|
||||
|
||||
app.get_widget().wait(&mut wait_ctx);
|
||||
app.set_keyboard_repeat(&mut wait_ctx);
|
||||
|
||||
if let Some(target_time) = wait_ctx.target_time {
|
||||
let n = Local::now().naive_local();
|
||||
let sleep = if target_time > n {
|
||||
target_time - n
|
||||
} else {
|
||||
Duration::seconds(0)
|
||||
};
|
||||
timer.set_state(
|
||||
TimerState::Oneshot(sleep.to_std().unwrap()),
|
||||
SetTimeFlags::Default,
|
||||
);
|
||||
wait_ctx.fds.push(tm_fd);
|
||||
}
|
||||
|
||||
poll(&mut wait_ctx.fds, -1).unwrap();
|
||||
|
||||
if wait_ctx.fds[0]
|
||||
.revents()
|
||||
.unwrap()
|
||||
.contains(PollFlags::POLLIN)
|
||||
{
|
||||
if fds[0].revents().unwrap().contains(PollFlags::POLLIN) {
|
||||
if let Some(guard) = app.event_queue().prepare_read() {
|
||||
if let Err(e) = guard.read_events() {
|
||||
if e.kind() != ::std::io::ErrorKind::WouldBlock {
|
||||
@@ -327,62 +302,14 @@ fn main() {
|
||||
}
|
||||
|
||||
app.event_queue()
|
||||
.dispatch_pending(&mut (), |_, _, _| {})
|
||||
.dispatch_pending()
|
||||
.expect("Failed to dispatch all messages.");
|
||||
}
|
||||
|
||||
if wait_ctx.fds[1]
|
||||
.revents()
|
||||
.unwrap()
|
||||
.contains(PollFlags::POLLIN)
|
||||
{
|
||||
if fds[1].revents().unwrap().contains(PollFlags::POLLIN) {
|
||||
let mut v = [0x00];
|
||||
rx_pipe.read_exact(&mut v).unwrap();
|
||||
}
|
||||
|
||||
if wait_ctx.fds[2]
|
||||
.revents()
|
||||
.unwrap()
|
||||
.contains(PollFlags::POLLIN)
|
||||
{
|
||||
if let Ok((stream, _)) = listener.accept() {
|
||||
let client_queue = q.clone();
|
||||
let mut client_pipe = ipc_pipe.try_clone().unwrap();
|
||||
let _ = std::thread::Builder::new()
|
||||
.name("ipc_client".to_string())
|
||||
.spawn(move || {
|
||||
let r = BufReader::new(stream);
|
||||
for line in r.lines() {
|
||||
match line {
|
||||
Ok(v) => match v.as_str() {
|
||||
"kill" => {
|
||||
client_queue.lock().unwrap().push_back(Cmd::Exit)
|
||||
}
|
||||
"toggle_visible" => client_queue
|
||||
.lock()
|
||||
.unwrap()
|
||||
.push_back(Cmd::ToggleVisible),
|
||||
v => eprintln!("unknown command: {}", v),
|
||||
},
|
||||
Err(_) => return,
|
||||
}
|
||||
client_pipe.write_all(&[0x1]).unwrap();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if wait_ctx.target_time.is_some()
|
||||
&& wait_ctx.fds[wait_ctx.fds.len() - 1]
|
||||
.revents()
|
||||
.unwrap()
|
||||
.contains(PollFlags::POLLIN)
|
||||
{
|
||||
timer.read();
|
||||
let mut qq = q.lock().unwrap();
|
||||
qq.push_back(Cmd::KeyboardTest);
|
||||
qq.push_back(Cmd::Draw);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+47
-106
@@ -1,13 +1,12 @@
|
||||
use crate::buffer::Buffer;
|
||||
use crate::color::Color;
|
||||
pub use crate::keyboard::{KeyState, ModifiersState};
|
||||
use chrono::NaiveDateTime;
|
||||
use nix::poll::PollFd;
|
||||
use chrono::{DateTime, Local};
|
||||
pub use smithay_client_toolkit::keyboard::{KeyState, ModifiersState};
|
||||
|
||||
pub struct DrawContext<'a> {
|
||||
pub buf: &'a mut Buffer<'a>,
|
||||
pub bg: &'a Color,
|
||||
pub time: NaiveDateTime,
|
||||
pub time: &'a DateTime<Local>,
|
||||
pub force: bool,
|
||||
}
|
||||
|
||||
@@ -30,25 +29,7 @@ impl DrawReport {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct WaitContext {
|
||||
pub fds: Vec<PollFd>,
|
||||
pub target_time: Option<NaiveDateTime>,
|
||||
}
|
||||
|
||||
impl WaitContext {
|
||||
pub fn set_time(&mut self, new_time: NaiveDateTime) {
|
||||
if let Some(ot) = self.target_time {
|
||||
if new_time < ot {
|
||||
self.target_time = Some(new_time);
|
||||
}
|
||||
} else {
|
||||
self.target_time = Some(new_time);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait Widget {
|
||||
fn wait(&mut self, ctx: &mut WaitContext);
|
||||
fn enter(&mut self);
|
||||
fn leave(&mut self);
|
||||
fn size(&self) -> (u32, u32);
|
||||
@@ -56,7 +37,6 @@ pub trait Widget {
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error>;
|
||||
|
||||
fn keyboard_input(
|
||||
@@ -70,23 +50,18 @@ pub trait Widget {
|
||||
fn mouse_scroll(&mut self, scroll: (f64, f64), pos: (u32, u32));
|
||||
}
|
||||
|
||||
pub struct VerticalLayout<'a> {
|
||||
pub children: Vec<Box<dyn Widget + Send + 'a>>,
|
||||
pub struct VerticalLayout {
|
||||
pub children: Vec<Box<dyn Widget + Send>>,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl<'a> VerticalLayout<'a> {
|
||||
pub fn new(children: Vec<Box<dyn Widget + Send + 'a>>) -> Box<VerticalLayout> {
|
||||
Box::new(VerticalLayout { children })
|
||||
impl VerticalLayout {
|
||||
pub fn new(children: Vec<Box<dyn Widget + Send>>) -> Box<VerticalLayout> {
|
||||
Box::new(VerticalLayout { children: children })
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for VerticalLayout<'a> {
|
||||
fn wait(&mut self, ctx: &mut WaitContext) {
|
||||
for child in &mut self.children {
|
||||
child.wait(ctx);
|
||||
}
|
||||
}
|
||||
impl Widget for VerticalLayout {
|
||||
fn enter(&mut self) {
|
||||
for child in &mut self.children {
|
||||
child.enter();
|
||||
@@ -116,20 +91,16 @@ impl<'a> Widget for VerticalLayout<'a> {
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
let mut offset = 0;
|
||||
let mut offset = pos.1;
|
||||
let mut width = 0;
|
||||
let mut damage = Vec::new();
|
||||
let mut full_damage = false;
|
||||
|
||||
for child in &mut self.children {
|
||||
let mut report = child.draw(
|
||||
ctx,
|
||||
(pos.0, offset + pos.1),
|
||||
(expansion.0, expansion.1 - offset),
|
||||
)?;
|
||||
let mut report = child.draw(ctx, (pos.0, offset))?;
|
||||
if report.width > width {
|
||||
width = report.width
|
||||
width = report.width;
|
||||
}
|
||||
offset += report.height;
|
||||
full_damage |= report.full_damage;
|
||||
@@ -138,7 +109,7 @@ impl<'a> Widget for VerticalLayout<'a> {
|
||||
|
||||
Ok(DrawReport {
|
||||
width,
|
||||
height: offset,
|
||||
height: offset - pos.1,
|
||||
damage,
|
||||
full_damage,
|
||||
})
|
||||
@@ -185,36 +156,18 @@ impl<'a> Widget for VerticalLayout<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct HorizontalLayout<'a> {
|
||||
pub children: Vec<Box<dyn Widget + Send + 'a>>,
|
||||
pub struct HorizontalLayout {
|
||||
pub children: Vec<Box<dyn Widget + Send>>,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl<'a> HorizontalLayout<'a> {
|
||||
pub fn new(children: Vec<Box<dyn Widget + Send + 'a>>) -> Box<HorizontalLayout> {
|
||||
Box::new(HorizontalLayout { children })
|
||||
}
|
||||
|
||||
fn height(&self) -> u32 {
|
||||
let mut height = 0;
|
||||
|
||||
for child in &self.children {
|
||||
let size = child.size();
|
||||
if size.1 > height {
|
||||
height = size.1;
|
||||
}
|
||||
}
|
||||
|
||||
height
|
||||
impl HorizontalLayout {
|
||||
pub fn new(children: Vec<Box<dyn Widget + Send>>) -> Box<HorizontalLayout> {
|
||||
Box::new(HorizontalLayout { children: children })
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for HorizontalLayout<'a> {
|
||||
fn wait(&mut self, ctx: &mut WaitContext) {
|
||||
for child in &mut self.children {
|
||||
child.wait(ctx);
|
||||
}
|
||||
}
|
||||
impl Widget for HorizontalLayout {
|
||||
fn enter(&mut self) {
|
||||
for child in &mut self.children {
|
||||
child.enter();
|
||||
@@ -244,20 +197,16 @@ impl<'a> Widget for HorizontalLayout<'a> {
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
let mut offset = 0;
|
||||
let mut offset = pos.0;
|
||||
let mut height = 0;
|
||||
let mut damage = Vec::new();
|
||||
let mut full_damage = false;
|
||||
|
||||
for child in &mut self.children {
|
||||
let mut report = child.draw(
|
||||
ctx,
|
||||
(offset + pos.0, pos.1),
|
||||
(expansion.0 - offset, expansion.1),
|
||||
)?;
|
||||
let mut report = child.draw(ctx, (offset, pos.1))?;
|
||||
if report.height > height {
|
||||
height = report.height
|
||||
height = report.height;
|
||||
}
|
||||
offset += report.width;
|
||||
full_damage |= report.full_damage;
|
||||
@@ -265,7 +214,7 @@ impl<'a> Widget for HorizontalLayout<'a> {
|
||||
}
|
||||
|
||||
Ok(DrawReport {
|
||||
width: offset,
|
||||
width: offset - pos.0,
|
||||
height,
|
||||
damage,
|
||||
full_damage,
|
||||
@@ -315,22 +264,22 @@ impl<'a> Widget for HorizontalLayout<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Margin<'a> {
|
||||
pub child: Box<dyn Widget + Send + 'a>,
|
||||
pub struct Margin {
|
||||
pub child: Box<dyn Widget + Send>,
|
||||
pub margins: (u32, u32, u32, u32), // left, right, top, bottom
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl<'a> Margin<'a> {
|
||||
pub fn new(margins: (u32, u32, u32, u32), child: Box<dyn Widget + Send + 'a>) -> Box<Margin> {
|
||||
Box::new(Margin { child, margins })
|
||||
impl Margin {
|
||||
pub fn new(margins: (u32, u32, u32, u32), child: Box<dyn Widget + Send>) -> Box<Margin> {
|
||||
Box::new(Margin {
|
||||
child: child,
|
||||
margins: margins,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for Margin<'a> {
|
||||
fn wait(&mut self, ctx: &mut WaitContext) {
|
||||
self.child.wait(ctx)
|
||||
}
|
||||
impl Widget for Margin {
|
||||
fn enter(&mut self) {
|
||||
self.child.enter()
|
||||
}
|
||||
@@ -349,17 +298,10 @@ impl<'a> Widget for Margin<'a> {
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
let expansion = (
|
||||
expansion.0 - self.margins.0 - self.margins.1,
|
||||
expansion.1 - self.margins.2 - self.margins.3,
|
||||
);
|
||||
let report = self.child.draw(
|
||||
ctx,
|
||||
(pos.0 + self.margins.0, pos.1 + self.margins.2),
|
||||
expansion,
|
||||
)?;
|
||||
let report = self
|
||||
.child
|
||||
.draw(ctx, (pos.0 + self.margins.0, pos.1 + self.margins.2))?;
|
||||
Ok(DrawReport {
|
||||
width: report.width + self.margins.0 + self.margins.1,
|
||||
height: report.height + self.margins.2 + self.margins.3,
|
||||
@@ -396,22 +338,22 @@ impl<'a> Widget for Margin<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Fixed<'a> {
|
||||
pub child: Box<dyn Widget + Send + 'a>,
|
||||
pub struct Fixed {
|
||||
pub child: Box<dyn Widget + Send>,
|
||||
pub size: (u32, u32),
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl<'a> Fixed<'a> {
|
||||
pub fn new(size: (u32, u32), child: Box<dyn Widget + Send + 'a>) -> Box<Fixed> {
|
||||
Box::new(Fixed { child, size })
|
||||
impl Fixed {
|
||||
pub fn new(size: (u32, u32), child: Box<dyn Widget + Send>) -> Box<Fixed> {
|
||||
Box::new(Fixed {
|
||||
child: child,
|
||||
size: size,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for Fixed<'a> {
|
||||
fn wait(&mut self, ctx: &mut WaitContext) {
|
||||
self.child.wait(ctx)
|
||||
}
|
||||
impl Widget for Fixed {
|
||||
fn enter(&mut self) {
|
||||
self.child.enter()
|
||||
}
|
||||
@@ -426,9 +368,8 @@ impl<'a> Widget for Fixed<'a> {
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
let report = self.child.draw(ctx, pos, expansion)?;
|
||||
let report = self.child.draw(ctx, pos)?;
|
||||
Ok(DrawReport {
|
||||
width: self.size.0,
|
||||
height: self.size.1,
|
||||
|
||||
@@ -1,21 +1,21 @@
|
||||
use crate::color::Color;
|
||||
use crate::widget::WaitContext;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widgets::bar_widget::{BarWidget, BarWidgetImpl},
|
||||
};
|
||||
use crate::widgets::bar_widget::{BarWidget, BarWidgetImpl};
|
||||
|
||||
use alsa::mixer::{Mixer, Selem, SelemChannelId, SelemId};
|
||||
|
||||
const CARD_NAME: &str = "default";
|
||||
const SELEM_NAME: &str = "Master";
|
||||
const CARD_NAME: &'static str = "default";
|
||||
const SELEM_NAME: &'static str = "Master";
|
||||
const SELEM_ID: u32 = 0u32;
|
||||
|
||||
#[inline]
|
||||
fn alsa_error_to_io_error(fail: &'static str, err: &alsa::Error) -> ::std::io::Error {
|
||||
let kind = ::std::io::ErrorKind::Other;
|
||||
let func = err.func();
|
||||
::std::io::Error::new(kind, format!("{}: {}{}", fail, func, err.errno()))
|
||||
let errno = err
|
||||
.errno()
|
||||
.map(|errno| format!("; errno = {}", errno))
|
||||
.unwrap_or(String::new());
|
||||
return ::std::io::Error::new(kind, format!("{}: {}{}", fail, func, errno));
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@@ -33,20 +33,15 @@ pub struct Alsa {
|
||||
}
|
||||
|
||||
impl Alsa {
|
||||
pub fn new(font: FontRef, font_size: f32, length: u32) -> ::std::io::Result<Box<BarWidget>> {
|
||||
pub fn new(font_size: f32, length: u32) -> ::std::io::Result<Box<BarWidget>> {
|
||||
let mixer = Mixer::new(CARD_NAME, true)
|
||||
.map_err(|err| alsa_error_to_io_error("Failed to create ALSA mixer", &err))?;
|
||||
let mixer = Self { mixer };
|
||||
mixer.get_master_volume()?; // probing
|
||||
Ok(BarWidget::new_simple(
|
||||
font,
|
||||
font_size,
|
||||
length,
|
||||
Box::new(mixer),
|
||||
))
|
||||
Ok(BarWidget::new_simple(font_size, length, Box::new(mixer)))
|
||||
}
|
||||
#[inline]
|
||||
pub fn get_master(&self) -> ::std::io::Result<Selem> {
|
||||
pub fn get_master<'a>(&'a self) -> ::std::io::Result<Selem<'a>> {
|
||||
let master_id = SelemId::new(SELEM_NAME, SELEM_ID);
|
||||
match self.mixer.find_selem(&master_id) {
|
||||
Some(master) => Ok(master),
|
||||
@@ -88,14 +83,13 @@ impl Alsa {
|
||||
}
|
||||
|
||||
impl BarWidgetImpl for Alsa {
|
||||
fn wait(&mut self, _: &mut WaitContext) {}
|
||||
fn name(&self) -> &str {
|
||||
"volume"
|
||||
}
|
||||
fn value(&self) -> f32 {
|
||||
match self.get_master_volume() {
|
||||
Ok(v) => v,
|
||||
Err(e) => panic!("{}", e),
|
||||
Err(e) => panic!(e),
|
||||
}
|
||||
}
|
||||
fn color(&self) -> Color {
|
||||
@@ -103,12 +97,12 @@ impl BarWidgetImpl for Alsa {
|
||||
}
|
||||
fn inc(&mut self, diff: f32) {
|
||||
if let Err(e) = self.inc_master_volume(diff) {
|
||||
panic!("{}", e)
|
||||
panic!(e)
|
||||
}
|
||||
}
|
||||
fn set(&mut self, abs: f32) {
|
||||
if let Err(e) = self.set_master_volume(abs) {
|
||||
panic!("{}", e)
|
||||
panic!(e)
|
||||
}
|
||||
}
|
||||
fn toggle(&mut self) {}
|
||||
|
||||
@@ -1,10 +1,6 @@
|
||||
use crate::cmd::Cmd;
|
||||
use crate::color::Color;
|
||||
use crate::widget::WaitContext;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widgets::bar_widget::{BarWidget, BarWidgetImpl},
|
||||
};
|
||||
use crate::widgets::bar_widget::{BarWidget, BarWidgetImpl};
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::collections::HashMap;
|
||||
@@ -16,13 +12,13 @@ use std::thread;
|
||||
|
||||
use libpulse_binding::callbacks::ListResult;
|
||||
use libpulse_binding::context::{
|
||||
introspect::ServerInfo, introspect::SinkInfo, subscribe::Facility, subscribe::InterestMaskSet,
|
||||
subscribe::Operation as SubscribeOperation, Context, FlagSet, State as PulseState,
|
||||
flags, introspect::ServerInfo, introspect::SinkInfo, subscribe::subscription_masks,
|
||||
subscribe::Facility, subscribe::Operation as SubscribeOperation, Context, State as PulseState,
|
||||
};
|
||||
use libpulse_binding::mainloop::standard::IterateResult;
|
||||
use libpulse_binding::mainloop::standard::Mainloop;
|
||||
use libpulse_binding::proplist::{properties, Proplist};
|
||||
use libpulse_binding::volume::{ChannelVolumes, Volume};
|
||||
use libpulse_binding::volume::{ChannelVolumes, Volume, VOLUME_MAX, VOLUME_NORM};
|
||||
|
||||
struct PulseAudioConnection {
|
||||
mainloop: Rc<RefCell<Mainloop>>,
|
||||
@@ -79,7 +75,7 @@ impl PulseAudioConnection {
|
||||
|
||||
context
|
||||
.borrow_mut()
|
||||
.connect(None, FlagSet::NOFLAGS, None)
|
||||
.connect(None, flags::NOFLAGS, None)
|
||||
.map_err(|_e| {
|
||||
::std::io::Error::new(
|
||||
::std::io::ErrorKind::Other,
|
||||
@@ -158,75 +154,60 @@ impl PulseAudioClient {
|
||||
Ok(req) => {
|
||||
let mut introspector = conn.context.borrow_mut().introspect();
|
||||
|
||||
let done = Arc::new(Mutex::new(false));
|
||||
let done_reader = done.clone();
|
||||
let s = match req {
|
||||
match req {
|
||||
PulseAudioClientRequest::GetDefaultDevice(s) => {
|
||||
introspector.get_server_info(move |info| {
|
||||
*done.lock().unwrap() = true;
|
||||
PulseAudioClient::server_info_callback(
|
||||
let _res = PulseAudioClient::server_info_callback(
|
||||
cl.clone(),
|
||||
l.clone(),
|
||||
info,
|
||||
);
|
||||
if let Some(s) = &s {
|
||||
let _ = s.send(true);
|
||||
}
|
||||
});
|
||||
s
|
||||
}
|
||||
PulseAudioClientRequest::GetSinkInfoByIndex(s, index) => {
|
||||
introspector.get_sink_info_by_index(index, move |res| {
|
||||
*done.lock().unwrap() = true;
|
||||
PulseAudioClient::sink_info_callback(
|
||||
cl.clone(),
|
||||
l.clone(),
|
||||
res,
|
||||
);
|
||||
if let Some(s) = &s {
|
||||
let _ = s.send(true);
|
||||
}
|
||||
});
|
||||
s
|
||||
}
|
||||
PulseAudioClientRequest::GetSinkInfoByName(s, name) => {
|
||||
introspector.get_sink_info_by_name(&name, move |res| {
|
||||
*done.lock().unwrap() = true;
|
||||
PulseAudioClient::sink_info_callback(
|
||||
cl.clone(),
|
||||
l.clone(),
|
||||
res,
|
||||
);
|
||||
if let Some(s) = &s {
|
||||
let _ = s.send(true);
|
||||
}
|
||||
});
|
||||
s
|
||||
}
|
||||
PulseAudioClientRequest::SetSinkVolumeByName(s, name, volumes) => {
|
||||
introspector.set_sink_volume_by_name(
|
||||
&name,
|
||||
&volumes,
|
||||
Some(Box::new(move |_| {
|
||||
*done.lock().unwrap() = true;
|
||||
})),
|
||||
);
|
||||
s
|
||||
introspector.set_sink_volume_by_name(&name, &volumes, None);
|
||||
if let Some(s) = &s {
|
||||
let _ = s.send(true);
|
||||
}
|
||||
}
|
||||
PulseAudioClientRequest::SetSinkMuteByName(s, name, mute) => {
|
||||
introspector.set_sink_mute_by_name(
|
||||
&name,
|
||||
mute,
|
||||
Some(Box::new(move |_| {
|
||||
*done.lock().unwrap() = true;
|
||||
})),
|
||||
);
|
||||
s
|
||||
introspector.set_sink_mute_by_name(&name, mute, None);
|
||||
if let Some(s) = &s {
|
||||
let _ = s.send(true);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// send request and receive response
|
||||
loop {
|
||||
if *done_reader.lock().unwrap() {
|
||||
break;
|
||||
}
|
||||
conn.iterate(true).unwrap();
|
||||
}
|
||||
|
||||
if let Some(s) = s {
|
||||
let _ = s.send(true);
|
||||
}
|
||||
conn.iterate(true).unwrap();
|
||||
conn.iterate(true).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -256,9 +237,10 @@ impl PulseAudioClient {
|
||||
.unwrap()
|
||||
.subscribe_callback(facility, operation, index)
|
||||
})));
|
||||
conn.context
|
||||
.borrow_mut()
|
||||
.subscribe(InterestMaskSet::SERVER | InterestMaskSet::SINK, |_| {});
|
||||
conn.context.borrow_mut().subscribe(
|
||||
subscription_masks::SERVER | subscription_masks::SINK,
|
||||
|_| {},
|
||||
);
|
||||
|
||||
conn.mainloop.borrow_mut().run().unwrap();
|
||||
});
|
||||
@@ -277,12 +259,13 @@ impl PulseAudioClient {
|
||||
}
|
||||
|
||||
fn send(&self, request: PulseAudioClientRequest) -> Result<(), ::std::io::Error> {
|
||||
self.sender.send(request).map_err(|_e| {
|
||||
let res = self.sender.send(request).map_err(|_e| {
|
||||
::std::io::Error::new(
|
||||
::std::io::ErrorKind::Other,
|
||||
"unable to send pulseaudio request",
|
||||
)
|
||||
})
|
||||
});
|
||||
res
|
||||
}
|
||||
|
||||
fn server_info_callback<F>(s: Arc<Mutex<Self>>, listener: F, server_info: &ServerInfo)
|
||||
@@ -369,7 +352,7 @@ impl PulseAudioSoundDevice {
|
||||
};
|
||||
|
||||
inner.volume = Some(sink_info.volume);
|
||||
inner.volume_avg = sink_info.volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
|
||||
inner.volume_avg = sink_info.volume.avg().0 as f32 / VOLUME_NORM.0 as f32;
|
||||
inner.muted = sink_info.mute;
|
||||
|
||||
listener();
|
||||
@@ -387,7 +370,10 @@ impl PulseAudioSoundDevice {
|
||||
cl.default_sink.to_string()
|
||||
};
|
||||
(*inner.lock().unwrap()).name = Some(name.clone());
|
||||
let device = PulseAudioSoundDevice { client: cl, inner };
|
||||
let device = PulseAudioSoundDevice {
|
||||
client: cl,
|
||||
inner: inner,
|
||||
};
|
||||
let (tx, rx) = channel();
|
||||
{
|
||||
let cl = client.lock().unwrap();
|
||||
@@ -421,9 +407,9 @@ impl PulseAudioSoundDevice {
|
||||
};
|
||||
|
||||
// apply step to volumes
|
||||
let step = (step * Volume::NORMAL.0 as f32).round() as i32;
|
||||
let step = (step * VOLUME_NORM.0 as f32).round() as i32;
|
||||
if step > 0 {
|
||||
volume.inc_clamp(Volume(step as u32), Volume::MAX);
|
||||
volume.inc_clamp(Volume(step as u32), VOLUME_MAX);
|
||||
} else {
|
||||
volume.decrease(Volume(-step as u32));
|
||||
}
|
||||
@@ -435,7 +421,7 @@ impl PulseAudioSoundDevice {
|
||||
|
||||
// update volumes
|
||||
inner.volume = Some(volume);
|
||||
inner.volume_avg = volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
|
||||
inner.volume_avg = volume.avg().0 as f32 / VOLUME_NORM.0 as f32;
|
||||
self.client
|
||||
.lock()
|
||||
.unwrap()
|
||||
@@ -458,7 +444,7 @@ impl PulseAudioSoundDevice {
|
||||
};
|
||||
|
||||
// apply step to volumes
|
||||
volume.scale(Volume((val * Volume::NORMAL.0 as f32).round() as u32));
|
||||
volume.scale(Volume((val * VOLUME_NORM.0 as f32).round() as u32));
|
||||
|
||||
let name = inner
|
||||
.name
|
||||
@@ -467,7 +453,7 @@ impl PulseAudioSoundDevice {
|
||||
|
||||
// update volumes
|
||||
inner.volume = Some(volume);
|
||||
inner.volume_avg = volume.avg().0 as f32 / Volume::NORMAL.0 as f32;
|
||||
inner.volume_avg = volume.avg().0 as f32 / VOLUME_NORM.0 as f32;
|
||||
self.client
|
||||
.lock()
|
||||
.unwrap()
|
||||
@@ -501,23 +487,21 @@ pub struct PulseAudio {
|
||||
|
||||
impl PulseAudio {
|
||||
pub fn new(
|
||||
font: FontRef,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
sender: Sender<Cmd>,
|
||||
) -> Result<Box<BarWidget>, ::std::io::Error> {
|
||||
BarWidget::new(font, font_size, length, move |dirty| {
|
||||
BarWidget::new(font_size, length, move |dirty| {
|
||||
let device = PulseAudioSoundDevice::new(move || {
|
||||
*dirty.lock().unwrap() = true;
|
||||
sender.send(Cmd::Draw).unwrap();
|
||||
})?;
|
||||
Ok(Box::new(PulseAudio { device }))
|
||||
Ok(Box::new(PulseAudio { device: device }))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl BarWidgetImpl for PulseAudio {
|
||||
fn wait(&mut self, _: &mut WaitContext) {}
|
||||
fn name(&self) -> &str {
|
||||
"volume"
|
||||
}
|
||||
|
||||
+23
-25
@@ -1,14 +1,9 @@
|
||||
use crate::color::Color;
|
||||
use crate::widget::WaitContext;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widgets::bar_widget::{BarWidget, BarWidgetImpl},
|
||||
};
|
||||
use crate::widgets::bar_widget::{BarWidget, BarWidgetImpl};
|
||||
|
||||
use std::fs;
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::Write;
|
||||
use std::io::{Error, ErrorKind};
|
||||
use std::io::{Read, Write};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub struct Backlight {
|
||||
@@ -18,9 +13,11 @@ pub struct Backlight {
|
||||
}
|
||||
|
||||
fn read_file_as_u64(path: &Path) -> Result<u64, Error> {
|
||||
let mut s = fs::read_to_string(path)?;
|
||||
s.pop();
|
||||
s.parse::<u64>()
|
||||
let mut file = OpenOptions::new().read(true).open(path)?;
|
||||
let mut str = String::new();
|
||||
file.read_to_string(&mut str)?;
|
||||
str.pop();
|
||||
str.parse::<u64>()
|
||||
.map_err(|_e| Error::new(ErrorKind::Other, "unable to parse value"))
|
||||
}
|
||||
|
||||
@@ -51,7 +48,7 @@ impl Backlight {
|
||||
return 1.0;
|
||||
}
|
||||
|
||||
self.cur_brightness as f32 / self.max_brightness as f32
|
||||
(self.cur_brightness as f32 / self.max_brightness as f32)
|
||||
}
|
||||
|
||||
pub fn set(&mut self, val: f32) -> Result<(), Error> {
|
||||
@@ -73,31 +70,29 @@ impl Backlight {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn new<'a>(
|
||||
path: &str,
|
||||
font: FontRef<'a>,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
) -> Result<Box<BarWidget<'a>>, Error> {
|
||||
pub fn new(font_size: f32, length: u32) -> Result<Box<BarWidget>, Error> {
|
||||
let devices = Path::new("/sys/class/backlight").read_dir()?;
|
||||
|
||||
let first_device = match devices.take(1).next() {
|
||||
Some(v) => match v {
|
||||
Ok(v) => v,
|
||||
Err(_) => return Err(Error::new(ErrorKind::Other, "no backlight device")),
|
||||
},
|
||||
None => return Err(Error::new(ErrorKind::Other, "no backlight device")),
|
||||
};
|
||||
let mut dev = Backlight {
|
||||
device_path: Path::new("/sys/class/backlight").to_path_buf().join(path),
|
||||
device_path: first_device.path(),
|
||||
cur_brightness: 0,
|
||||
max_brightness: 0,
|
||||
};
|
||||
|
||||
dev.update()?;
|
||||
|
||||
Ok(BarWidget::new_simple(
|
||||
font,
|
||||
font_size,
|
||||
length,
|
||||
Box::new(dev),
|
||||
))
|
||||
Ok(BarWidget::new_simple(font_size, length, Box::new(dev)))
|
||||
}
|
||||
}
|
||||
|
||||
impl BarWidgetImpl for Backlight {
|
||||
fn wait(&mut self, _: &mut WaitContext) {}
|
||||
fn name(&self) -> &str {
|
||||
"backlight"
|
||||
}
|
||||
@@ -113,6 +108,7 @@ impl BarWidgetImpl for Backlight {
|
||||
Ok(val) => val,
|
||||
Err(err) => {
|
||||
eprintln!("Error while trying to change brightness: {}", err);
|
||||
()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -122,6 +118,7 @@ impl BarWidgetImpl for Backlight {
|
||||
Ok(val) => val,
|
||||
Err(err) => {
|
||||
eprintln!("Error while trying to change brightness: {}", err);
|
||||
()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -135,6 +132,7 @@ impl BarWidgetImpl for Backlight {
|
||||
Ok(val) => val,
|
||||
Err(err) => {
|
||||
eprintln!("Error while trying to change brightness: {}", err);
|
||||
()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+22
-38
@@ -1,14 +1,10 @@
|
||||
use crate::color::Color;
|
||||
use crate::draw::{draw_bar, draw_box, Font};
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widget::{DrawContext, DrawReport, KeyState, ModifiersState, WaitContext, Widget},
|
||||
};
|
||||
use crate::draw::{draw_bar, draw_box, Font, ROBOTO_REGULAR};
|
||||
use crate::widget::{DrawContext, DrawReport, KeyState, ModifiersState, Widget};
|
||||
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
pub trait BarWidgetImpl {
|
||||
fn wait(&mut self, ctx: &mut WaitContext);
|
||||
fn name(&self) -> &str;
|
||||
fn value(&self) -> f32;
|
||||
fn color(&self) -> Color;
|
||||
@@ -17,78 +13,66 @@ pub trait BarWidgetImpl {
|
||||
fn toggle(&mut self);
|
||||
}
|
||||
|
||||
pub struct BarWidget<'a> {
|
||||
pub struct BarWidget {
|
||||
bar_impl: Box<dyn BarWidgetImpl + Send>,
|
||||
font: Font<'a>,
|
||||
font: Font,
|
||||
font_size: u32,
|
||||
length: u32,
|
||||
dirty: Arc<Mutex<bool>>,
|
||||
}
|
||||
|
||||
impl<'a> BarWidget<'a> {
|
||||
impl BarWidget {
|
||||
pub fn new_simple(
|
||||
font: FontRef,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
w: Box<dyn BarWidgetImpl + Send>,
|
||||
) -> Box<BarWidget> {
|
||||
let mut font = Font::new(font, font_size);
|
||||
let mut font = Font::new(&ROBOTO_REGULAR, font_size);
|
||||
font.add_str_to_cache(w.name());
|
||||
|
||||
Box::new(BarWidget {
|
||||
bar_impl: w,
|
||||
dirty: Arc::new(Mutex::new(true)),
|
||||
font,
|
||||
font: font,
|
||||
font_size: font_size as u32,
|
||||
length,
|
||||
length: length,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn new<F>(
|
||||
font: FontRef<'a>,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
f: F,
|
||||
) -> Result<Box<BarWidget>, ::std::io::Error>
|
||||
pub fn new<F>(font_size: f32, length: u32, f: F) -> Result<Box<BarWidget>, ::std::io::Error>
|
||||
where
|
||||
F: FnOnce(Arc<Mutex<bool>>) -> Result<Box<dyn BarWidgetImpl + Send>, ::std::io::Error>,
|
||||
F: Send + 'a + Clone,
|
||||
F: Send + 'static + Clone,
|
||||
{
|
||||
let dirty = Arc::new(Mutex::new(true));
|
||||
let im = f(dirty.clone())?;
|
||||
|
||||
let mut font = Font::new(font, font_size);
|
||||
let mut font = Font::new(&ROBOTO_REGULAR, font_size);
|
||||
font.add_str_to_cache(im.name());
|
||||
|
||||
Ok(Box::new(BarWidget {
|
||||
bar_impl: im,
|
||||
dirty,
|
||||
font,
|
||||
dirty: dirty,
|
||||
font: font,
|
||||
font_size: font_size as u32,
|
||||
length,
|
||||
length: length,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for BarWidget<'a> {
|
||||
fn wait(&mut self, ctx: &mut WaitContext) {
|
||||
self.bar_impl.wait(ctx);
|
||||
}
|
||||
impl Widget for BarWidget {
|
||||
fn enter(&mut self) {}
|
||||
fn leave(&mut self) {}
|
||||
fn size(&self) -> (u32, u32) {
|
||||
(self.length, self.font_size)
|
||||
}
|
||||
|
||||
fn draw(
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
if self.length == 0 {
|
||||
self.length = expansion.0;
|
||||
}
|
||||
let (width, height) = (self.length, self.font_size);
|
||||
let (width, height) = self.size();
|
||||
{
|
||||
let mut d = self.dirty.lock().unwrap();
|
||||
if !*d && !ctx.force {
|
||||
@@ -109,7 +93,7 @@ impl<'a> Widget for BarWidget<'a> {
|
||||
draw_bar(
|
||||
&mut buf.offset((bar_off, 0))?,
|
||||
&c,
|
||||
width - bar_off,
|
||||
self.length - bar_off,
|
||||
self.font_size,
|
||||
val,
|
||||
)?;
|
||||
@@ -121,7 +105,7 @@ impl<'a> Widget for BarWidget<'a> {
|
||||
draw_bar(
|
||||
&mut buf.offset((bar_off, 0))?,
|
||||
&c,
|
||||
width - bar_off,
|
||||
self.length - bar_off,
|
||||
self.font_size,
|
||||
val,
|
||||
)?;
|
||||
@@ -129,11 +113,11 @@ impl<'a> Widget for BarWidget<'a> {
|
||||
draw_box(
|
||||
&mut buf.offset((bar_off, 0))?,
|
||||
&c,
|
||||
(width - bar_off, self.font_size),
|
||||
(self.length - bar_off, self.font_size),
|
||||
)?;
|
||||
Ok(DrawReport {
|
||||
width,
|
||||
height,
|
||||
width: width,
|
||||
height: height,
|
||||
damage: vec![buf.get_signed_bounds()],
|
||||
full_damage: false,
|
||||
})
|
||||
|
||||
+73
-98
@@ -1,15 +1,12 @@
|
||||
use crate::cmd::Cmd;
|
||||
use crate::color::Color;
|
||||
use crate::widget::WaitContext;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widgets::bar_widget::{BarWidget, BarWidgetImpl},
|
||||
};
|
||||
use crate::widgets::bar_widget::{BarWidget, BarWidgetImpl};
|
||||
|
||||
use std::sync::mpsc::Sender;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::thread;
|
||||
|
||||
use nix::poll::{PollFd, PollFlags};
|
||||
use dbus;
|
||||
|
||||
fn get_upower_property(
|
||||
con: &dbus::Connection,
|
||||
@@ -31,34 +28,21 @@ fn get_upower_property(
|
||||
.append2(
|
||||
dbus::MessageItem::Str("org.freedesktop.UPower.Device".to_string()),
|
||||
dbus::MessageItem::Str(property.to_string()),
|
||||
);
|
||||
);;
|
||||
|
||||
con.send_with_reply_and_block(msg, 1000).map_err(|_| {
|
||||
::std::io::Error::new(::std::io::ErrorKind::Other, "could not send dbus message")
|
||||
})
|
||||
}
|
||||
|
||||
// The widget is created on a different thread than where it will be used, so
|
||||
// we need it to be Send. However, dbus::Connection has a void*, so it's not
|
||||
// auto-derived. So, we make a small wrapper where we make it Send.
|
||||
struct DbusConnection(dbus::Connection);
|
||||
|
||||
impl std::convert::AsRef<dbus::Connection> for DbusConnection {
|
||||
fn as_ref(&self) -> &dbus::Connection {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Send for DbusConnection {}
|
||||
|
||||
pub struct UpowerBattery {
|
||||
device_path: String,
|
||||
sender: Sender<Cmd>,
|
||||
dirty: Arc<Mutex<bool>>,
|
||||
inner: Arc<Mutex<UpowerBatteryInner>>,
|
||||
}
|
||||
|
||||
pub struct UpowerBatteryInner {
|
||||
state: UpowerBatteryState,
|
||||
capacity: f64,
|
||||
con: DbusConnection,
|
||||
watch: dbus::Watch,
|
||||
}
|
||||
|
||||
enum UpowerBatteryState {
|
||||
@@ -71,29 +55,12 @@ enum UpowerBatteryState {
|
||||
}
|
||||
|
||||
impl UpowerBattery {
|
||||
pub fn from_device(
|
||||
dirty: Arc<Mutex<bool>>,
|
||||
sender: Sender<Cmd>,
|
||||
device: &str,
|
||||
) -> Result<Self, ::std::io::Error> {
|
||||
pub fn from_device(device: &str) -> Result<Self, ::std::io::Error> {
|
||||
let device_path = format!("/org/freedesktop/UPower/devices/battery_{}", device);
|
||||
let con = dbus::Connection::get_private(dbus::BusType::System).map_err(|_| {
|
||||
::std::io::Error::new(::std::io::ErrorKind::Other, "unable to open dbus")
|
||||
::std::io::Error::new(::std::io::ErrorKind::Other, "could not get dbus connection")
|
||||
})?;
|
||||
let device_path = format!("/org/freedesktop/UPower/devices/{}", device);
|
||||
|
||||
let rule = format!(
|
||||
"type='signal',\
|
||||
path='{}',\
|
||||
interface='org.freedesktop.DBus.Properties',\
|
||||
member='PropertiesChanged'",
|
||||
&device_path
|
||||
);
|
||||
con.add_match(&rule).map_err(|_| {
|
||||
::std::io::Error::new(
|
||||
::std::io::ErrorKind::Other,
|
||||
"unable to add match rule to dbus connection",
|
||||
)
|
||||
})?;
|
||||
let upower_type: dbus::arg::Variant<u32> =
|
||||
match get_upower_property(&con, &device_path, "Type")?.get1() {
|
||||
Some(v) => v,
|
||||
@@ -144,83 +111,91 @@ impl UpowerBattery {
|
||||
}
|
||||
};
|
||||
|
||||
let fds = con.watch_fds();
|
||||
if fds.len() != 1 {
|
||||
return Err(::std::io::Error::new(
|
||||
::std::io::ErrorKind::Other,
|
||||
"expected 1 watch fd from dbus",
|
||||
));
|
||||
}
|
||||
|
||||
Ok(UpowerBattery {
|
||||
device_path,
|
||||
con: DbusConnection(con),
|
||||
dirty,
|
||||
sender,
|
||||
capacity,
|
||||
state,
|
||||
watch: fds[0],
|
||||
inner: Arc::new(Mutex::new(UpowerBatteryInner {
|
||||
capacity: capacity,
|
||||
state: state,
|
||||
})),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn new(
|
||||
font: FontRef,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
sender: Sender<Cmd>,
|
||||
) -> Result<Box<BarWidget>, ::std::io::Error> {
|
||||
BarWidget::new(font, font_size, length, move |dirty| {
|
||||
let d = UpowerBattery::from_device(dirty, sender, "DisplayDevice")?;
|
||||
BarWidget::new(font_size, length, move |dirty| {
|
||||
let d = UpowerBattery::from_device("BAT0")?;
|
||||
let path = d.device_path.clone();
|
||||
let inner = d.inner.clone();
|
||||
let _ = thread::Builder::new()
|
||||
.name("battery_monitor".to_string())
|
||||
.spawn(move || {
|
||||
let con = dbus::Connection::get_private(dbus::BusType::System)
|
||||
.expect("Failed to establish D-Bus connection.");
|
||||
let rule = format!(
|
||||
"type='signal',\
|
||||
path='{}',\
|
||||
interface='org.freedesktop.DBus.Properties',\
|
||||
member='PropertiesChanged'",
|
||||
path
|
||||
);
|
||||
|
||||
// First we're going to get an (irrelevant) NameAcquired event.
|
||||
con.incoming(10_000).next();
|
||||
|
||||
con.add_match(&rule)
|
||||
.expect("Failed to add D-Bus match rule.");
|
||||
|
||||
loop {
|
||||
if con.incoming(10_000).next().is_some() {
|
||||
let capacity = get_upower_property(&con, &path, "Percentage")
|
||||
.unwrap()
|
||||
.get1::<dbus::arg::Variant<f64>>()
|
||||
.unwrap()
|
||||
.0;
|
||||
let state = match get_upower_property(&con, &path, "State")
|
||||
.unwrap()
|
||||
.get1::<dbus::arg::Variant<u32>>()
|
||||
.unwrap()
|
||||
.0
|
||||
{
|
||||
1 => UpowerBatteryState::Charging,
|
||||
2 => UpowerBatteryState::Discharging,
|
||||
3 => UpowerBatteryState::Empty,
|
||||
4 => UpowerBatteryState::Full,
|
||||
5 => UpowerBatteryState::NotCharging,
|
||||
6 => UpowerBatteryState::Discharging,
|
||||
_ => UpowerBatteryState::Unknown,
|
||||
};
|
||||
let mut inner = inner.lock().unwrap();
|
||||
inner.state = state;
|
||||
inner.capacity = capacity;
|
||||
*dirty.lock().unwrap() = true;
|
||||
sender.send(Cmd::Draw).unwrap();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
Ok(Box::new(d))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl BarWidgetImpl for UpowerBattery {
|
||||
fn wait(&mut self, ctx: &mut WaitContext) {
|
||||
for _ in self
|
||||
.con
|
||||
.as_ref()
|
||||
.watch_handle(self.watch.fd(), dbus::WatchEvent::Readable as u32)
|
||||
{
|
||||
let capacity = get_upower_property(self.con.as_ref(), &self.device_path, "Percentage")
|
||||
.unwrap()
|
||||
.get1::<dbus::arg::Variant<f64>>()
|
||||
.unwrap()
|
||||
.0;
|
||||
let state = match get_upower_property(self.con.as_ref(), &self.device_path, "State")
|
||||
.unwrap()
|
||||
.get1::<dbus::arg::Variant<u32>>()
|
||||
.unwrap()
|
||||
.0
|
||||
{
|
||||
1 => UpowerBatteryState::Charging,
|
||||
2 => UpowerBatteryState::Discharging,
|
||||
3 => UpowerBatteryState::Empty,
|
||||
4 => UpowerBatteryState::Full,
|
||||
5 => UpowerBatteryState::NotCharging,
|
||||
6 => UpowerBatteryState::Discharging,
|
||||
_ => UpowerBatteryState::Unknown,
|
||||
};
|
||||
self.state = state;
|
||||
self.capacity = capacity;
|
||||
*self.dirty.lock().unwrap() = true;
|
||||
self.sender.send(Cmd::Draw).unwrap();
|
||||
}
|
||||
|
||||
ctx.fds
|
||||
.push(PollFd::new(self.watch.fd(), PollFlags::POLLIN));
|
||||
}
|
||||
fn name(&self) -> &str {
|
||||
"battery"
|
||||
}
|
||||
fn value(&self) -> f32 {
|
||||
(self.capacity as f32) / 100.0
|
||||
let inner = self.inner.lock().unwrap();
|
||||
(inner.capacity as f32) / 100.0
|
||||
}
|
||||
fn color(&self) -> Color {
|
||||
match self.state {
|
||||
let inner = self.inner.lock().unwrap();
|
||||
match inner.state {
|
||||
UpowerBatteryState::Discharging | UpowerBatteryState::Unknown => {
|
||||
if self.capacity > 10.0 {
|
||||
if inner.capacity > 10.0 {
|
||||
Color::new(1.0, 1.0, 1.0, 1.0)
|
||||
} else {
|
||||
Color::new(1.0, 0.5, 0.0, 1.0)
|
||||
|
||||
+30
-41
@@ -1,34 +1,31 @@
|
||||
use crate::buffer::Buffer;
|
||||
use crate::color::Color;
|
||||
use crate::draw::Font;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widget::{DrawContext, DrawReport, KeyState, ModifiersState, WaitContext, Widget},
|
||||
};
|
||||
use crate::draw::{Font, DEJAVUSANS_MONO, ROBOTO_REGULAR};
|
||||
use crate::widget::{DrawContext, DrawReport, KeyState, ModifiersState, Widget};
|
||||
|
||||
use chrono::{Datelike, NaiveDate, NaiveDateTime};
|
||||
use chrono::{Date, Datelike, Local};
|
||||
|
||||
pub struct Calendar<'a> {
|
||||
cur_date: NaiveDate,
|
||||
pub struct Calendar {
|
||||
cur_date: Date<Local>,
|
||||
dirty: bool,
|
||||
offset: f64,
|
||||
sections: u32,
|
||||
font_size: u32,
|
||||
calendar_cache: Font<'a>,
|
||||
month_cache: Font<'a>,
|
||||
year_cache: Font<'a>,
|
||||
day_cache: Font<'a>,
|
||||
calendar_cache: Font,
|
||||
month_cache: Font,
|
||||
year_cache: Font,
|
||||
day_cache: Font,
|
||||
}
|
||||
|
||||
impl<'a> Calendar<'a> {
|
||||
impl Calendar {
|
||||
fn draw_month(
|
||||
&self,
|
||||
buf: &mut Buffer,
|
||||
background_color: &Color,
|
||||
orig: NaiveDate,
|
||||
time: NaiveDate,
|
||||
orig: &Date<Local>,
|
||||
time: &Date<Local>,
|
||||
) -> Result<(i32, i32, i32, i32), ::std::io::Error> {
|
||||
let mut time = time;
|
||||
let mut time = time.clone();
|
||||
let mut y_off = 1;
|
||||
let mut done = false;
|
||||
|
||||
@@ -155,38 +152,31 @@ impl<'a> Calendar<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Calendar<'a> {
|
||||
pub fn new(
|
||||
time: NaiveDateTime,
|
||||
font_primary: FontRef<'a>,
|
||||
font_secondary: FontRef<'a>,
|
||||
font_size: f32,
|
||||
sections: u32,
|
||||
) -> Box<Calendar<'a>> {
|
||||
let mut calendar_cache = Font::new(font_secondary, font_size * 2.0);
|
||||
impl Calendar {
|
||||
pub fn new(font_size: f32, sections: u32) -> Box<Calendar> {
|
||||
let mut calendar_cache = Font::new(&DEJAVUSANS_MONO, font_size * 2.0);
|
||||
calendar_cache.add_str_to_cache("0123456789");
|
||||
let mut month_cache = Font::new(font_primary, font_size * 4.0);
|
||||
let mut month_cache = Font::new(&ROBOTO_REGULAR, font_size * 4.0);
|
||||
month_cache.add_str_to_cache("JanuryFebMchApilJgstSmOoNvD");
|
||||
let mut year_cache = Font::new(font_primary, font_size * 1.5);
|
||||
let mut year_cache = Font::new(&DEJAVUSANS_MONO, font_size * 1.5);
|
||||
year_cache.add_str_to_cache("-0123456789");
|
||||
let mut day_cache = Font::new(font_primary, font_size);
|
||||
let mut day_cache = Font::new(&DEJAVUSANS_MONO, font_size);
|
||||
day_cache.add_str_to_cache("MONTUEWDHFRISA");
|
||||
Box::new(Calendar {
|
||||
cur_date: time.date(),
|
||||
cur_date: Local::now().date(),
|
||||
dirty: true,
|
||||
offset: 0.0,
|
||||
sections,
|
||||
sections: sections,
|
||||
font_size: font_size as u32,
|
||||
calendar_cache,
|
||||
month_cache,
|
||||
year_cache,
|
||||
day_cache,
|
||||
calendar_cache: calendar_cache,
|
||||
month_cache: month_cache,
|
||||
year_cache: year_cache,
|
||||
day_cache: day_cache,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for Calendar<'a> {
|
||||
fn wait(&mut self, _: &mut WaitContext) {}
|
||||
impl Widget for Calendar {
|
||||
fn enter(&mut self) {}
|
||||
fn leave(&mut self) {}
|
||||
|
||||
@@ -203,7 +193,6 @@ impl<'a> Widget for Calendar<'a> {
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
_expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
let (width, height) = self.size();
|
||||
if ctx.time.date() == self.cur_date && !ctx.force && !self.dirty {
|
||||
@@ -221,7 +210,7 @@ impl<'a> Widget for Calendar<'a> {
|
||||
let cals = self.sections - 1;
|
||||
let pre_cals = cals / 2;
|
||||
for _ in 0..pre_cals {
|
||||
t = t.pred_opt().unwrap().with_day(1).unwrap();
|
||||
t = t.pred().with_day(1).unwrap();
|
||||
}
|
||||
|
||||
if o != 0 {
|
||||
@@ -243,7 +232,7 @@ impl<'a> Widget for Calendar<'a> {
|
||||
}
|
||||
let cal_pad = 7 * self.font_size * 3 + self.font_size * 5;
|
||||
for idx in 0..self.sections {
|
||||
self.draw_month(&mut buf.offset((cal_pad * idx, 0))?, ctx.bg, time, t)?;
|
||||
self.draw_month(&mut buf.offset((cal_pad * idx, 0))?, ctx.bg, &time, &t)?;
|
||||
|
||||
t = if t.month() == 12 {
|
||||
t.with_year(t.year() + 1).unwrap().with_month(1).unwrap()
|
||||
@@ -252,8 +241,8 @@ impl<'a> Widget for Calendar<'a> {
|
||||
};
|
||||
}
|
||||
Ok(DrawReport {
|
||||
width,
|
||||
height,
|
||||
width: width,
|
||||
height: height,
|
||||
damage: vec![buf.get_signed_bounds()],
|
||||
full_damage: false,
|
||||
})
|
||||
|
||||
+43
-39
@@ -1,58 +1,62 @@
|
||||
use crate::cmd::Cmd;
|
||||
use crate::color::Color;
|
||||
use crate::draw::Font;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widget::{DrawContext, DrawReport, KeyState, ModifiersState, WaitContext, Widget},
|
||||
};
|
||||
use crate::draw::{Font, ROBOTO_REGULAR};
|
||||
use crate::widget::{DrawContext, DrawReport, KeyState, ModifiersState, Widget};
|
||||
|
||||
use chrono::{Duration, NaiveDateTime, Timelike};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct Clock<'a> {
|
||||
cur_time: NaiveDateTime,
|
||||
clock_cache: Font<'a>,
|
||||
use chrono::{DateTime, Datelike, Duration, Local, Timelike};
|
||||
|
||||
pub struct Clock {
|
||||
cur_time: DateTime<Local>,
|
||||
clock_cache: Font,
|
||||
size: f32,
|
||||
digit: u32,
|
||||
colon: u32,
|
||||
}
|
||||
|
||||
impl<'a> Clock<'a> {
|
||||
pub fn new(time: NaiveDateTime, font: FontRef, size: f32) -> ::std::io::Result<Box<Clock>> {
|
||||
let mut clock_cache = Font::new(font, size);
|
||||
impl Clock {
|
||||
pub fn new(size: f32, ch: Sender<Cmd>) -> Box<Clock> {
|
||||
let _ = std::thread::Builder::new()
|
||||
.name("clock_ticker".to_string())
|
||||
.spawn(move || loop {
|
||||
let n = Local::now();
|
||||
let target = (n + Duration::seconds(60))
|
||||
.with_second(0)
|
||||
.unwrap()
|
||||
.with_nanosecond(0)
|
||||
.unwrap();
|
||||
|
||||
let d = target - n;
|
||||
|
||||
std::thread::sleep(d.to_std().unwrap());
|
||||
ch.send(Cmd::Draw).unwrap();
|
||||
});
|
||||
|
||||
let mut clock_cache = Font::new(&ROBOTO_REGULAR, size);
|
||||
clock_cache.add_str_to_cache("0123456789:");
|
||||
|
||||
let digit = clock_cache.auto_widest("123456789")?;
|
||||
let colon = clock_cache.auto_widest(":")?;
|
||||
let time = Local::now();
|
||||
|
||||
Ok(Box::new(Clock {
|
||||
cur_time: time,
|
||||
clock_cache,
|
||||
size,
|
||||
digit,
|
||||
colon,
|
||||
}))
|
||||
Box::new(Clock {
|
||||
cur_time: time.with_year(time.year().saturating_sub(1)).unwrap(),
|
||||
clock_cache: clock_cache,
|
||||
size: size,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for Clock<'a> {
|
||||
fn wait(&mut self, ctx: &mut WaitContext) {
|
||||
let target = (self.cur_time + Duration::seconds(60))
|
||||
.with_second(0)
|
||||
.unwrap()
|
||||
.with_nanosecond(0)
|
||||
.unwrap();
|
||||
ctx.set_time(target);
|
||||
}
|
||||
impl Widget for Clock {
|
||||
fn enter(&mut self) {}
|
||||
fn leave(&mut self) {}
|
||||
fn size(&self) -> (u32, u32) {
|
||||
(self.digit * 4 + self.colon, self.size.ceil() as u32)
|
||||
let digit = (self.size * 0.45).ceil() as u32;
|
||||
let colon = (self.size * 0.20).ceil() as u32;
|
||||
(digit * 4 + colon, self.size.ceil() as u32)
|
||||
}
|
||||
|
||||
fn draw(
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
_expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
let (width, height) = self.size();
|
||||
if !(ctx.time.date() != self.cur_time.date()
|
||||
@@ -63,13 +67,13 @@ impl<'a> Widget for Clock<'a> {
|
||||
return Ok(DrawReport::empty(width, height));
|
||||
}
|
||||
|
||||
self.cur_time = ctx.time;
|
||||
self.cur_time = ctx.time.clone();
|
||||
|
||||
let buf = &mut ctx.buf.subdimensions((pos.0, pos.1, width, height))?;
|
||||
buf.memset(ctx.bg);
|
||||
|
||||
let digit = self.digit;
|
||||
let colon = self.colon;
|
||||
let digit = (self.size * 0.45).ceil() as u32;
|
||||
let colon = (self.size * 0.20).ceil() as u32;
|
||||
self.clock_cache.draw_text_fixed_width(
|
||||
buf,
|
||||
ctx.bg,
|
||||
@@ -79,8 +83,8 @@ impl<'a> Widget for Clock<'a> {
|
||||
)?;
|
||||
|
||||
Ok(DrawReport {
|
||||
width,
|
||||
height,
|
||||
width: width,
|
||||
height: height,
|
||||
damage: vec![(pos.0 as i32, pos.1 as i32, width as i32, height as i32)],
|
||||
full_damage: false,
|
||||
})
|
||||
|
||||
+22
-42
@@ -1,62 +1,42 @@
|
||||
use crate::color::Color;
|
||||
use crate::draw::Font;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widget::{DrawContext, DrawReport, KeyState, ModifiersState, WaitContext, Widget},
|
||||
};
|
||||
use crate::draw::{Font, ROBOTO_REGULAR};
|
||||
use crate::widget::{DrawContext, DrawReport, KeyState, ModifiersState, Widget};
|
||||
|
||||
use chrono::{Datelike, NaiveDateTime};
|
||||
use chrono::{DateTime, Datelike, Local};
|
||||
|
||||
pub struct Date<'a> {
|
||||
cur_time: NaiveDateTime,
|
||||
date_cache: Font<'a>,
|
||||
pub struct Date {
|
||||
cur_time: DateTime<Local>,
|
||||
date_cache: Font,
|
||||
size: f32,
|
||||
ch_width: u32,
|
||||
digit_width: u32,
|
||||
spacing_width: u32,
|
||||
}
|
||||
|
||||
impl<'a> Date<'a> {
|
||||
pub fn new(time: NaiveDateTime, font: FontRef, size: f32) -> ::std::io::Result<Box<Date>> {
|
||||
let mut date_cache = Font::new(font, size);
|
||||
let chs = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||
let digits = "0123456789,/ ";
|
||||
let spacings = ",/ ";
|
||||
impl Date {
|
||||
pub fn new(size: f32) -> Box<Date> {
|
||||
let mut date_cache = Font::new(&ROBOTO_REGULAR, size);
|
||||
date_cache
|
||||
.add_str_to_cache("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,/ ");
|
||||
|
||||
date_cache.add_str_to_cache(chs);
|
||||
date_cache.add_str_to_cache(digits);
|
||||
date_cache.add_str_to_cache(spacings);
|
||||
let ch_width = date_cache.auto_widest(chs)?;
|
||||
let digit_width = date_cache.auto_widest(digits)?;
|
||||
let spacing_width = date_cache.auto_widest(spacings)?;
|
||||
let time = Local::now();
|
||||
|
||||
Ok(Box::new(Date {
|
||||
cur_time: time,
|
||||
date_cache,
|
||||
size,
|
||||
ch_width,
|
||||
digit_width,
|
||||
spacing_width,
|
||||
}))
|
||||
Box::new(Date {
|
||||
cur_time: time.with_year(time.year().saturating_sub(1)).unwrap(),
|
||||
date_cache: date_cache,
|
||||
size: size,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for Date<'a> {
|
||||
fn wait(&mut self, _: &mut WaitContext) {}
|
||||
impl Widget for Date {
|
||||
fn enter(&mut self) {}
|
||||
fn leave(&mut self) {}
|
||||
fn size(&self) -> (u32, u32) {
|
||||
(
|
||||
(3 * self.ch_width + 8 * self.digit_width + 4 * self.spacing_width) as u32,
|
||||
self.size.ceil() as u32,
|
||||
)
|
||||
((6.5 * self.size).ceil() as u32, self.size.ceil() as u32)
|
||||
}
|
||||
|
||||
fn draw(
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
_expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
let (width, height) = self.size();
|
||||
|
||||
@@ -64,7 +44,7 @@ impl<'a> Widget for Date<'a> {
|
||||
return Ok(DrawReport::empty(width, height));
|
||||
}
|
||||
|
||||
self.cur_time = ctx.time;
|
||||
self.cur_time = ctx.time.clone();
|
||||
|
||||
let buf = &mut ctx.buf.subdimensions((pos.0, pos.1, width, height))?;
|
||||
buf.memset(ctx.bg);
|
||||
@@ -82,8 +62,8 @@ impl<'a> Widget for Date<'a> {
|
||||
)?;
|
||||
|
||||
Ok(DrawReport {
|
||||
width,
|
||||
height,
|
||||
width: width,
|
||||
height: height,
|
||||
damage: vec![(pos.0 as i32, pos.1 as i32, width as i32, height as i32)],
|
||||
full_damage: false,
|
||||
})
|
||||
|
||||
+81
-219
@@ -2,26 +2,18 @@ use crate::buffer::Buffer;
|
||||
use crate::cmd::Cmd;
|
||||
use crate::color::Color;
|
||||
use crate::desktop::{load_desktop_files, Desktop};
|
||||
use crate::draw::Font;
|
||||
use crate::{
|
||||
fonts::FontRef,
|
||||
widget::{DrawContext, DrawReport, KeyState, ModifiersState, WaitContext, Widget},
|
||||
};
|
||||
use crate::draw::{Font, ROBOTO_REGULAR};
|
||||
use crate::widget::{DrawContext, DrawReport, KeyState, ModifiersState, Widget};
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::cmp::Ordering;
|
||||
use std::collections::HashMap;
|
||||
use std::process::Command;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::data::Data;
|
||||
use crate::keyboard::keysyms;
|
||||
use fuzzy_matcher::skim::SkimMatcherV2;
|
||||
use fuzzy_matcher::FuzzyMatcher;
|
||||
use unicode_segmentation::UnicodeSegmentation;
|
||||
use fuzzy_matcher::skim::{fuzzy_indices, fuzzy_match};
|
||||
use smithay_client_toolkit::keyboard::keysyms;
|
||||
|
||||
pub struct Launcher<'a> {
|
||||
cursor: usize,
|
||||
pub struct Launcher {
|
||||
options: Vec<Desktop>,
|
||||
term_opener: String,
|
||||
app_opener: String,
|
||||
@@ -30,17 +22,15 @@ pub struct Launcher<'a> {
|
||||
input: String,
|
||||
result: Option<String>,
|
||||
offset: usize,
|
||||
font: RefCell<Font<'a>>,
|
||||
font: RefCell<Font>,
|
||||
font_size: u32,
|
||||
length: u32,
|
||||
dirty: bool,
|
||||
tx: Sender<Cmd>,
|
||||
counter: Data,
|
||||
}
|
||||
|
||||
impl<'a> Launcher<'a> {
|
||||
impl Launcher {
|
||||
pub fn new(
|
||||
font: FontRef,
|
||||
font_size: f32,
|
||||
length: u32,
|
||||
listener: Sender<Cmd>,
|
||||
@@ -49,7 +39,6 @@ impl<'a> Launcher<'a> {
|
||||
url: String,
|
||||
) -> Box<Launcher> {
|
||||
Box::new(Launcher {
|
||||
cursor: 0,
|
||||
options: load_desktop_files(),
|
||||
term_opener: term,
|
||||
app_opener: app,
|
||||
@@ -58,53 +47,40 @@ impl<'a> Launcher<'a> {
|
||||
input: "".to_string(),
|
||||
result: None,
|
||||
offset: 0,
|
||||
font: RefCell::new(Font::new(font, font_size)),
|
||||
font: RefCell::new(Font::new(&ROBOTO_REGULAR, font_size)),
|
||||
font_size: font_size as u32,
|
||||
length,
|
||||
length: length,
|
||||
dirty: true,
|
||||
tx: listener,
|
||||
counter: Data::load().unwrap_or_default(),
|
||||
})
|
||||
}
|
||||
|
||||
fn draw_launcher(
|
||||
&self,
|
||||
buf: &mut Buffer,
|
||||
bg: &Color,
|
||||
width: u32,
|
||||
) -> Result<(), ::std::io::Error> {
|
||||
let mut x_off = if !self.input.is_empty() {
|
||||
let c = if self.matches.is_empty() {
|
||||
fn draw_launcher(&self, buf: &mut Buffer, bg: &Color) -> Result<(), ::std::io::Error> {
|
||||
let mut x_off = if self.input.len() > 0 {
|
||||
let c = if self.matches.len() == 0 {
|
||||
Color::new(1.0, 0.5, 0.5, 1.0)
|
||||
} else {
|
||||
Color::new(1.0, 1.0, 1.0, 1.0)
|
||||
};
|
||||
|
||||
let dim = self.font.borrow_mut().auto_draw_text_with_cursor(
|
||||
buf,
|
||||
bg,
|
||||
&c,
|
||||
&self.input,
|
||||
self.cursor,
|
||||
)?;
|
||||
let dim = self
|
||||
.font
|
||||
.borrow_mut()
|
||||
.auto_draw_text(buf, bg, &c, &self.input)?;
|
||||
|
||||
dim.0 + self.font_size / 4
|
||||
} else {
|
||||
0
|
||||
};
|
||||
|
||||
let mut width_remaining: i32 = (width - x_off) as i32;
|
||||
let fuzzy_matcher = SkimMatcherV2::default();
|
||||
let mut width_remaining: i32 = (self.length - x_off) as i32;
|
||||
for (idx, m) in self.matches.iter().enumerate() {
|
||||
let mut b = match buf.offset((x_off, 0)) {
|
||||
Ok(b) => b,
|
||||
Err(_) => break,
|
||||
};
|
||||
let size = if idx == self.offset {
|
||||
let (_, indices) = fuzzy_matcher
|
||||
.fuzzy_indices(&m.name.to_lowercase(), &self.input.to_lowercase())
|
||||
.unwrap_or((0, vec![]));
|
||||
|
||||
let size = if idx == self.offset && self.input.len() > 0 {
|
||||
let (_, indices) =
|
||||
fuzzy_indices(&m.name.to_lowercase(), &self.input.to_lowercase()).unwrap();
|
||||
let mut colors = Vec::with_capacity(m.name.len());
|
||||
for pos in 0..m.name.len() {
|
||||
if indices.contains(&pos) {
|
||||
@@ -144,13 +120,12 @@ impl<'a> Launcher<'a> {
|
||||
.0
|
||||
+ self.font_size / 4;
|
||||
|
||||
let x_off = if !self.input.is_empty() {
|
||||
let dim = self.font.borrow_mut().auto_draw_text_with_cursor(
|
||||
let x_off = if self.input.len() > 0 {
|
||||
let dim = self.font.borrow_mut().auto_draw_text(
|
||||
&mut buf.offset((x_off, 0))?,
|
||||
bg,
|
||||
&Color::new(1.0, 1.0, 1.0, 1.0),
|
||||
&self.input[1..],
|
||||
self.cursor - 1,
|
||||
)?;
|
||||
|
||||
x_off + dim.0 + self.font_size / 4
|
||||
@@ -183,13 +158,12 @@ impl<'a> Launcher<'a> {
|
||||
.0
|
||||
+ self.font_size / 4;
|
||||
|
||||
if !self.input.is_empty() {
|
||||
self.font.borrow_mut().auto_draw_text_with_cursor(
|
||||
if self.input.len() > 0 {
|
||||
self.font.borrow_mut().auto_draw_text(
|
||||
&mut buf.offset((x_off, 0))?,
|
||||
bg,
|
||||
&Color::new(1.0, 1.0, 1.0, 1.0),
|
||||
&self.input[1..],
|
||||
self.cursor - 1,
|
||||
)?;
|
||||
};
|
||||
|
||||
@@ -199,87 +173,21 @@ impl<'a> Launcher<'a> {
|
||||
|
||||
fn calc(s: &str) -> Result<String, String> {
|
||||
rcalc_lib::parse::eval(s, &mut rcalc_lib::parse::CalcState::new())
|
||||
.map(|x| format!("{}", x))
|
||||
.map_err(|x| format!("{}", x))
|
||||
.map(|x| format!("{}", x).to_string())
|
||||
.map_err(|x| format!("{}", x).to_string())
|
||||
}
|
||||
|
||||
fn wlcopy(s: &str) -> Result<(), String> {
|
||||
let mut child = std::process::Command::new("wl-copy")
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::null())
|
||||
.stderr(std::process::Stdio::null())
|
||||
.arg(s)
|
||||
.spawn()
|
||||
.map_err(|_| "wl-copy not available".to_string())?;
|
||||
child
|
||||
.wait()
|
||||
.map_err(|_| "unable to run wl-copy".to_string())?;
|
||||
Ok(())
|
||||
use wl_clipboard_rs::copy::{MimeType, Options, Source};
|
||||
use failure::Fail;
|
||||
let opts = Options::new();
|
||||
opts.copy(Source::Bytes(s.as_bytes()), MimeType::Text).map_err(|e|e.name().unwrap_or("unknown error").to_string())
|
||||
}
|
||||
|
||||
struct Matcher {
|
||||
matches: HashMap<Desktop, i64>,
|
||||
counter: Data,
|
||||
}
|
||||
|
||||
impl Matcher {
|
||||
fn new(counter: Data) -> Self {
|
||||
Self {
|
||||
matches: HashMap::new(),
|
||||
counter,
|
||||
}
|
||||
}
|
||||
|
||||
fn try_match(&mut self, dtop: Desktop, val: &str, input: &str, prio: f32) {
|
||||
let fuzzy_matcher = SkimMatcherV2::default();
|
||||
if let Some(ma) = fuzzy_matcher.fuzzy_match(val, input) {
|
||||
let ma = ((ma as f32) * prio) as i64;
|
||||
if let Some(ma_old) = self.matches.get(&dtop) {
|
||||
// Skip over new matches for the same program that are worse
|
||||
// than the one we already have.
|
||||
if ma_old > &ma {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
self.matches.insert(dtop, ma);
|
||||
}
|
||||
}
|
||||
|
||||
fn matches(&self) -> Vec<Desktop> {
|
||||
let mut m = self
|
||||
.matches
|
||||
.iter()
|
||||
.map(|(key, ma)| (*ma, key.clone()))
|
||||
.collect::<Vec<(i64, Desktop)>>();
|
||||
|
||||
m.sort_by(|(ma1, d1), (ma2, d2)| {
|
||||
let count1 = self.counter.entries.get(&d1.name).unwrap_or(&0);
|
||||
let count2 = self.counter.entries.get(&d2.name).unwrap_or(&0);
|
||||
|
||||
if ma1 + count1 > ma2 + count2 {
|
||||
Ordering::Less
|
||||
} else if ma1 + count1 < ma2 + count2 {
|
||||
Ordering::Greater
|
||||
} else if d1.name.len() < d2.name.len() {
|
||||
Ordering::Less
|
||||
} else if d1.name.len() > d2.name.len() {
|
||||
Ordering::Greater
|
||||
} else {
|
||||
d1.cmp(d2)
|
||||
}
|
||||
});
|
||||
|
||||
m.into_iter().map(|(_, x)| x).collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Widget for Launcher<'a> {
|
||||
fn wait(&mut self, _: &mut WaitContext) {}
|
||||
impl Widget for Launcher {
|
||||
fn enter(&mut self) {}
|
||||
fn leave(&mut self) {
|
||||
self.input = "".to_string();
|
||||
self.cursor = 0;
|
||||
self.offset = 0;
|
||||
self.result = None;
|
||||
self.dirty = true;
|
||||
@@ -293,12 +201,8 @@ impl<'a> Widget for Launcher<'a> {
|
||||
&mut self,
|
||||
ctx: &mut DrawContext,
|
||||
pos: (u32, u32),
|
||||
expansion: (u32, u32),
|
||||
) -> Result<DrawReport, ::std::io::Error> {
|
||||
if self.length == 0 {
|
||||
self.length = expansion.0;
|
||||
}
|
||||
let (width, height) = (self.length, self.font_size);
|
||||
let (width, height) = self.size();
|
||||
if !self.dirty && !ctx.force {
|
||||
return Ok(DrawReport::empty(width, height));
|
||||
}
|
||||
@@ -315,26 +219,34 @@ impl<'a> Widget for Launcher<'a> {
|
||||
}
|
||||
Some('!') => (),
|
||||
_ => {
|
||||
let mut matcher = Matcher::new(self.counter.clone());
|
||||
let mut m = self
|
||||
.options
|
||||
.iter()
|
||||
.map(|x| {
|
||||
(
|
||||
fuzzy_match(&x.name.to_lowercase(), &self.input.to_lowercase()),
|
||||
x,
|
||||
)
|
||||
})
|
||||
.filter(|(x, _)| x.is_some())
|
||||
.map(|(x, y)| (x.unwrap(), y.clone()))
|
||||
.collect::<Vec<(i64, Desktop)>>();
|
||||
|
||||
for desktop in self.options.iter() {
|
||||
matcher.try_match(
|
||||
desktop.clone(),
|
||||
&desktop.name.to_lowercase(),
|
||||
&self.input.to_lowercase(),
|
||||
1.0,
|
||||
);
|
||||
for keyword in desktop.keywords.iter() {
|
||||
matcher.try_match(
|
||||
desktop.clone(),
|
||||
&keyword.to_lowercase(),
|
||||
&self.input.to_lowercase(),
|
||||
0.5,
|
||||
);
|
||||
m.sort_by(|(x1, y1), (x2, y2)| {
|
||||
if x1 > x2 {
|
||||
Ordering::Less
|
||||
} else if x1 < x2 {
|
||||
Ordering::Greater
|
||||
} else if y1.name.len() < y2.name.len() {
|
||||
Ordering::Less
|
||||
} else if y1.name.len() > y2.name.len() {
|
||||
Ordering::Greater
|
||||
} else {
|
||||
y1.cmp(y2)
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
self.matches = matcher.matches();
|
||||
self.matches = m.into_iter().map(|(_, x)| x).collect();
|
||||
}
|
||||
};
|
||||
|
||||
@@ -344,12 +256,12 @@ impl<'a> Widget for Launcher<'a> {
|
||||
match self.input.chars().next() {
|
||||
Some('=') => self.draw_calc(buf, ctx.bg),
|
||||
Some('!') => self.draw_shell(buf, ctx.bg),
|
||||
_ => self.draw_launcher(buf, ctx.bg, width),
|
||||
_ => self.draw_launcher(buf, ctx.bg),
|
||||
}?;
|
||||
|
||||
Ok(DrawReport {
|
||||
width,
|
||||
height,
|
||||
width: width,
|
||||
height: height,
|
||||
damage: vec![buf.get_signed_bounds()],
|
||||
full_damage: false,
|
||||
})
|
||||
@@ -364,50 +276,23 @@ impl<'a> Widget for Launcher<'a> {
|
||||
) {
|
||||
match key {
|
||||
keysyms::XKB_KEY_u if modifiers.ctrl => self.leave(),
|
||||
keysyms::XKB_KEY_a if modifiers.ctrl => {
|
||||
self.cursor = 0;
|
||||
self.dirty = true;
|
||||
}
|
||||
keysyms::XKB_KEY_e if modifiers.ctrl => {
|
||||
self.cursor = self.input.len();
|
||||
self.dirty = true;
|
||||
}
|
||||
keysyms::XKB_KEY_Home => {
|
||||
self.cursor = 0;
|
||||
self.dirty = true;
|
||||
}
|
||||
keysyms::XKB_KEY_End => {
|
||||
self.cursor = self.input.len();
|
||||
self.dirty = true;
|
||||
}
|
||||
keysyms::XKB_KEY_BackSpace => {
|
||||
let mut indices: Vec<(usize, &str)> = self.input.grapheme_indices(true).collect();
|
||||
if !indices.is_empty() && self.cursor > 0 {
|
||||
self.cursor -= 1;
|
||||
indices.remove(self.cursor);
|
||||
self.input = indices.iter().fold("".into(), |acc, el| acc + el.1);
|
||||
if self.input.len() > 0 {
|
||||
self.input = self.input[..self.input.len() - 1].to_string();
|
||||
self.offset = 0;
|
||||
self.result = None;
|
||||
self.dirty = true
|
||||
}
|
||||
}
|
||||
keysyms::XKB_KEY_Delete => {
|
||||
let mut indices: Vec<(usize, &str)> = self.input.grapheme_indices(true).collect();
|
||||
if !indices.is_empty() && self.cursor < indices.len() {
|
||||
indices.remove(self.cursor);
|
||||
self.input = indices.iter().fold("".into(), |acc, el| acc + el.1);
|
||||
self.dirty = true;
|
||||
}
|
||||
}
|
||||
keysyms::XKB_KEY_Return => {
|
||||
match self.input.chars().next() {
|
||||
Some('=') => {
|
||||
if let Some(ref v) = self.result {
|
||||
Some('=') => match self.result {
|
||||
Some(ref v) => {
|
||||
let _ = wlcopy(&v);
|
||||
}
|
||||
}
|
||||
None => (),
|
||||
},
|
||||
Some('!') => {
|
||||
self.cursor = 0;
|
||||
let _ = Command::new("sh")
|
||||
.arg("-c")
|
||||
.arg(self.input.chars().skip(1).collect::<String>())
|
||||
@@ -429,29 +314,24 @@ impl<'a> Widget for Launcher<'a> {
|
||||
&self.app_opener
|
||||
};
|
||||
|
||||
let mut lexed = shlex::split(&exec).unwrap();
|
||||
let lexed = if !prefix.is_empty() {
|
||||
let lexed = if prefix.len() > 0 {
|
||||
let mut prefix = shlex::split(prefix).unwrap();
|
||||
prefix.append(&mut lexed);
|
||||
prefix.push(exec);
|
||||
prefix
|
||||
} else {
|
||||
lexed
|
||||
shlex::split(&exec).unwrap()
|
||||
};
|
||||
|
||||
*self.counter.entries.entry(d.name.clone()).or_insert(0) += 1;
|
||||
self.counter.save().expect("Unable to save data");
|
||||
|
||||
if !lexed.is_empty() {
|
||||
if lexed.len() > 0 {
|
||||
let _ =
|
||||
Command::new(lexed[0].clone()).args(&lexed[1..]).spawn();
|
||||
self.tx.send(Cmd::Exit).unwrap();
|
||||
}
|
||||
}
|
||||
if let Some(url) = &d.url {
|
||||
if !self.url_opener.is_empty() {
|
||||
if self.url_opener.len() > 0 {
|
||||
let mut lexed = shlex::split(&self.url_opener).unwrap();
|
||||
lexed.push(url.to_string());
|
||||
if !lexed.is_empty() {
|
||||
if lexed.len() > 0 {
|
||||
let _ = Command::new(lexed[0].clone())
|
||||
.args(&lexed[1..])
|
||||
.spawn();
|
||||
@@ -463,45 +343,27 @@ impl<'a> Widget for Launcher<'a> {
|
||||
}
|
||||
};
|
||||
}
|
||||
keysyms::XKB_KEY_Tab => {
|
||||
if !self.matches.is_empty() && self.offset < self.matches.len() - 1 {
|
||||
keysyms::XKB_KEY_Right => {
|
||||
if self.matches.len() > 0 && self.offset < self.matches.len() - 1 {
|
||||
self.offset += 1;
|
||||
self.dirty = true;
|
||||
}
|
||||
}
|
||||
keysyms::XKB_KEY_ISO_Left_Tab => {
|
||||
if !self.matches.is_empty() && self.offset > 0 {
|
||||
keysyms::XKB_KEY_Left => {
|
||||
if self.matches.len() > 0 && self.offset > 0 {
|
||||
self.offset -= 1;
|
||||
self.dirty = true;
|
||||
}
|
||||
}
|
||||
keysyms::XKB_KEY_Left => {
|
||||
if self.cursor > 0 {
|
||||
self.cursor -= 1;
|
||||
self.dirty = true;
|
||||
}
|
||||
}
|
||||
keysyms::XKB_KEY_Right => {
|
||||
if self.cursor < self.input.len() {
|
||||
self.cursor += 1;
|
||||
self.dirty = true;
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
if let Some(v) = interpreted {
|
||||
let indices: Vec<(usize, &str)> = self.input.grapheme_indices(true).collect();
|
||||
if self.cursor == indices.len() {
|
||||
self.input += &v;
|
||||
} else {
|
||||
let index_at = indices[self.cursor].0;
|
||||
self.input.insert_str(index_at, &v);
|
||||
}
|
||||
self.cursor += 1;
|
||||
_ => match interpreted {
|
||||
Some(v) => {
|
||||
self.input += &v;
|
||||
self.offset = 0;
|
||||
self.result = None;
|
||||
self.dirty = true;
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
},
|
||||
}
|
||||
}
|
||||
fn mouse_click(&mut self, _: u32, _: (u32, u32)) {}
|
||||
|
||||
Reference in New Issue
Block a user