├── .gitignore
├── LICENSE.md
├── README.md
├── libinput-gestures-qt
├── libinput_gestures_qt
├── __init__.py
├── edit_window.py
├── edit_window.ui
├── logo
│ ├── libinput-gestures-qt.desktop
│ ├── libinput-gestures-qt.kra
│ └── libinput-gestures-qt.png
├── main.py
├── main_window.py
└── main_window.ui
├── setup.py
├── tests
└── test_main.py
└── tox.ini
/.gitignore:
--------------------------------------------------------------------------------
1 | .pytest_cache
2 | .tox
3 | libinput_gestures_qt.egg-info
4 | */__pycache__
5 |
6 |
--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | ### GNU GENERAL PUBLIC LICENSE
2 |
3 | Version 3, 29 June 2007
4 |
5 | Copyright (C) 2007 Free Software Foundation, Inc.
6 |
7 |
8 | Everyone is permitted to copy and distribute verbatim copies of this
9 | license document, but changing it is not allowed.
10 |
11 | ### Preamble
12 |
13 | The GNU General Public License is a free, copyleft license for
14 | software and other kinds of works.
15 |
16 | The licenses for most software and other practical works are designed
17 | to take away your freedom to share and change the works. By contrast,
18 | the GNU General Public License is intended to guarantee your freedom
19 | to share and change all versions of a program--to make sure it remains
20 | free software for all its users. We, the Free Software Foundation, use
21 | the GNU General Public License for most of our software; it applies
22 | also to any other work released this way by its authors. You can apply
23 | it to your programs, too.
24 |
25 | When we speak of free software, we are referring to freedom, not
26 | price. Our General Public Licenses are designed to make sure that you
27 | have the freedom to distribute copies of free software (and charge for
28 | them if you wish), that you receive source code or can get it if you
29 | want it, that you can change the software or use pieces of it in new
30 | free programs, and that you know you can do these things.
31 |
32 | To protect your rights, we need to prevent others from denying you
33 | these rights or asking you to surrender the rights. Therefore, you
34 | have certain responsibilities if you distribute copies of the
35 | software, or if you modify it: responsibilities to respect the freedom
36 | of others.
37 |
38 | For example, if you distribute copies of such a program, whether
39 | gratis or for a fee, you must pass on to the recipients the same
40 | freedoms that you received. You must make sure that they, too, receive
41 | or can get the source code. And you must show them these terms so they
42 | know their rights.
43 |
44 | Developers that use the GNU GPL protect your rights with two steps:
45 | (1) assert copyright on the software, and (2) offer you this License
46 | giving you legal permission to copy, distribute and/or modify it.
47 |
48 | For the developers' and authors' protection, the GPL clearly explains
49 | that there is no warranty for this free software. For both users' and
50 | authors' sake, the GPL requires that modified versions be marked as
51 | changed, so that their problems will not be attributed erroneously to
52 | authors of previous versions.
53 |
54 | Some devices are designed to deny users access to install or run
55 | modified versions of the software inside them, although the
56 | manufacturer can do so. This is fundamentally incompatible with the
57 | aim of protecting users' freedom to change the software. The
58 | systematic pattern of such abuse occurs in the area of products for
59 | individuals to use, which is precisely where it is most unacceptable.
60 | Therefore, we have designed this version of the GPL to prohibit the
61 | practice for those products. If such problems arise substantially in
62 | other domains, we stand ready to extend this provision to those
63 | domains in future versions of the GPL, as needed to protect the
64 | freedom of users.
65 |
66 | Finally, every program is threatened constantly by software patents.
67 | States should not allow patents to restrict development and use of
68 | software on general-purpose computers, but in those that do, we wish
69 | to avoid the special danger that patents applied to a free program
70 | could make it effectively proprietary. To prevent this, the GPL
71 | assures that patents cannot be used to render the program non-free.
72 |
73 | The precise terms and conditions for copying, distribution and
74 | modification follow.
75 |
76 | ### TERMS AND CONDITIONS
77 |
78 | #### 0. Definitions.
79 |
80 | "This License" refers to version 3 of the GNU General Public License.
81 |
82 | "Copyright" also means copyright-like laws that apply to other kinds
83 | of works, such as semiconductor masks.
84 |
85 | "The Program" refers to any copyrightable work licensed under this
86 | License. Each licensee is addressed as "you". "Licensees" and
87 | "recipients" may be individuals or organizations.
88 |
89 | To "modify" a work means to copy from or adapt all or part of the work
90 | in a fashion requiring copyright permission, other than the making of
91 | an exact copy. The resulting work is called a "modified version" of
92 | the earlier work or a work "based on" the earlier work.
93 |
94 | A "covered work" means either the unmodified Program or a work based
95 | on the Program.
96 |
97 | To "propagate" a work means to do anything with it that, without
98 | permission, would make you directly or secondarily liable for
99 | infringement under applicable copyright law, except executing it on a
100 | computer or modifying a private copy. Propagation includes copying,
101 | distribution (with or without modification), making available to the
102 | public, and in some countries other activities as well.
103 |
104 | To "convey" a work means any kind of propagation that enables other
105 | parties to make or receive copies. Mere interaction with a user
106 | through a computer network, with no transfer of a copy, is not
107 | conveying.
108 |
109 | An interactive user interface displays "Appropriate Legal Notices" to
110 | the extent that it includes a convenient and prominently visible
111 | feature that (1) displays an appropriate copyright notice, and (2)
112 | tells the user that there is no warranty for the work (except to the
113 | extent that warranties are provided), that licensees may convey the
114 | work under this License, and how to view a copy of this License. If
115 | the interface presents a list of user commands or options, such as a
116 | menu, a prominent item in the list meets this criterion.
117 |
118 | #### 1. Source Code.
119 |
120 | The "source code" for a work means the preferred form of the work for
121 | making modifications to it. "Object code" means any non-source form of
122 | a work.
123 |
124 | A "Standard Interface" means an interface that either is an official
125 | standard defined by a recognized standards body, or, in the case of
126 | interfaces specified for a particular programming language, one that
127 | is widely used among developers working in that language.
128 |
129 | The "System Libraries" of an executable work include anything, other
130 | than the work as a whole, that (a) is included in the normal form of
131 | packaging a Major Component, but which is not part of that Major
132 | Component, and (b) serves only to enable use of the work with that
133 | Major Component, or to implement a Standard Interface for which an
134 | implementation is available to the public in source code form. A
135 | "Major Component", in this context, means a major essential component
136 | (kernel, window system, and so on) of the specific operating system
137 | (if any) on which the executable work runs, or a compiler used to
138 | produce the work, or an object code interpreter used to run it.
139 |
140 | The "Corresponding Source" for a work in object code form means all
141 | the source code needed to generate, install, and (for an executable
142 | work) run the object code and to modify the work, including scripts to
143 | control those activities. However, it does not include the work's
144 | System Libraries, or general-purpose tools or generally available free
145 | programs which are used unmodified in performing those activities but
146 | which are not part of the work. For example, Corresponding Source
147 | includes interface definition files associated with source files for
148 | the work, and the source code for shared libraries and dynamically
149 | linked subprograms that the work is specifically designed to require,
150 | such as by intimate data communication or control flow between those
151 | subprograms and other parts of the work.
152 |
153 | The Corresponding Source need not include anything that users can
154 | regenerate automatically from other parts of the Corresponding Source.
155 |
156 | The Corresponding Source for a work in source code form is that same
157 | work.
158 |
159 | #### 2. Basic Permissions.
160 |
161 | All rights granted under this License are granted for the term of
162 | copyright on the Program, and are irrevocable provided the stated
163 | conditions are met. This License explicitly affirms your unlimited
164 | permission to run the unmodified Program. The output from running a
165 | covered work is covered by this License only if the output, given its
166 | content, constitutes a covered work. This License acknowledges your
167 | rights of fair use or other equivalent, as provided by copyright law.
168 |
169 | You may make, run and propagate covered works that you do not convey,
170 | without conditions so long as your license otherwise remains in force.
171 | You may convey covered works to others for the sole purpose of having
172 | them make modifications exclusively for you, or provide you with
173 | facilities for running those works, provided that you comply with the
174 | terms of this License in conveying all material for which you do not
175 | control copyright. Those thus making or running the covered works for
176 | you must do so exclusively on your behalf, under your direction and
177 | control, on terms that prohibit them from making any copies of your
178 | copyrighted material outside their relationship with you.
179 |
180 | Conveying under any other circumstances is permitted solely under the
181 | conditions stated below. Sublicensing is not allowed; section 10 makes
182 | it unnecessary.
183 |
184 | #### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
185 |
186 | No covered work shall be deemed part of an effective technological
187 | measure under any applicable law fulfilling obligations under article
188 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
189 | similar laws prohibiting or restricting circumvention of such
190 | measures.
191 |
192 | When you convey a covered work, you waive any legal power to forbid
193 | circumvention of technological measures to the extent such
194 | circumvention is effected by exercising rights under this License with
195 | respect to the covered work, and you disclaim any intention to limit
196 | operation or modification of the work as a means of enforcing, against
197 | the work's users, your or third parties' legal rights to forbid
198 | circumvention of technological measures.
199 |
200 | #### 4. Conveying Verbatim Copies.
201 |
202 | You may convey verbatim copies of the Program's source code as you
203 | receive it, in any medium, provided that you conspicuously and
204 | appropriately publish on each copy an appropriate copyright notice;
205 | keep intact all notices stating that this License and any
206 | non-permissive terms added in accord with section 7 apply to the code;
207 | keep intact all notices of the absence of any warranty; and give all
208 | recipients a copy of this License along with the Program.
209 |
210 | You may charge any price or no price for each copy that you convey,
211 | and you may offer support or warranty protection for a fee.
212 |
213 | #### 5. Conveying Modified Source Versions.
214 |
215 | You may convey a work based on the Program, or the modifications to
216 | produce it from the Program, in the form of source code under the
217 | terms of section 4, provided that you also meet all of these
218 | conditions:
219 |
220 | - a) The work must carry prominent notices stating that you modified
221 | it, and giving a relevant date.
222 | - b) The work must carry prominent notices stating that it is
223 | released under this License and any conditions added under
224 | section 7. This requirement modifies the requirement in section 4
225 | to "keep intact all notices".
226 | - c) You must license the entire work, as a whole, under this
227 | License to anyone who comes into possession of a copy. This
228 | License will therefore apply, along with any applicable section 7
229 | additional terms, to the whole of the work, and all its parts,
230 | regardless of how they are packaged. This License gives no
231 | permission to license the work in any other way, but it does not
232 | invalidate such permission if you have separately received it.
233 | - d) If the work has interactive user interfaces, each must display
234 | Appropriate Legal Notices; however, if the Program has interactive
235 | interfaces that do not display Appropriate Legal Notices, your
236 | work need not make them do so.
237 |
238 | A compilation of a covered work with other separate and independent
239 | works, which are not by their nature extensions of the covered work,
240 | and which are not combined with it such as to form a larger program,
241 | in or on a volume of a storage or distribution medium, is called an
242 | "aggregate" if the compilation and its resulting copyright are not
243 | used to limit the access or legal rights of the compilation's users
244 | beyond what the individual works permit. Inclusion of a covered work
245 | in an aggregate does not cause this License to apply to the other
246 | parts of the aggregate.
247 |
248 | #### 6. Conveying Non-Source Forms.
249 |
250 | You may convey a covered work in object code form under the terms of
251 | sections 4 and 5, provided that you also convey the machine-readable
252 | Corresponding Source under the terms of this License, in one of these
253 | ways:
254 |
255 | - a) Convey the object code in, or embodied in, a physical product
256 | (including a physical distribution medium), accompanied by the
257 | Corresponding Source fixed on a durable physical medium
258 | customarily used for software interchange.
259 | - b) Convey the object code in, or embodied in, a physical product
260 | (including a physical distribution medium), accompanied by a
261 | written offer, valid for at least three years and valid for as
262 | long as you offer spare parts or customer support for that product
263 | model, to give anyone who possesses the object code either (1) a
264 | copy of the Corresponding Source for all the software in the
265 | product that is covered by this License, on a durable physical
266 | medium customarily used for software interchange, for a price no
267 | more than your reasonable cost of physically performing this
268 | conveying of source, or (2) access to copy the Corresponding
269 | Source from a network server at no charge.
270 | - c) Convey individual copies of the object code with a copy of the
271 | written offer to provide the Corresponding Source. This
272 | alternative is allowed only occasionally and noncommercially, and
273 | only if you received the object code with such an offer, in accord
274 | with subsection 6b.
275 | - d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 | - e) Convey the object code using peer-to-peer transmission,
288 | provided you inform other peers where the object code and
289 | Corresponding Source of the work are being offered to the general
290 | public at no charge under subsection 6d.
291 |
292 | A separable portion of the object code, whose source code is excluded
293 | from the Corresponding Source as a System Library, need not be
294 | included in conveying the object code work.
295 |
296 | A "User Product" is either (1) a "consumer product", which means any
297 | tangible personal property which is normally used for personal,
298 | family, or household purposes, or (2) anything designed or sold for
299 | incorporation into a dwelling. In determining whether a product is a
300 | consumer product, doubtful cases shall be resolved in favor of
301 | coverage. For a particular product received by a particular user,
302 | "normally used" refers to a typical or common use of that class of
303 | product, regardless of the status of the particular user or of the way
304 | in which the particular user actually uses, or expects or is expected
305 | to use, the product. A product is a consumer product regardless of
306 | whether the product has substantial commercial, industrial or
307 | non-consumer uses, unless such uses represent the only significant
308 | mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to
312 | install and execute modified versions of a covered work in that User
313 | Product from a modified version of its Corresponding Source. The
314 | information must suffice to ensure that the continued functioning of
315 | the modified object code is in no case prevented or interfered with
316 | solely because modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or
331 | updates for a work that has been modified or installed by the
332 | recipient, or for the User Product in which it has been modified or
333 | installed. Access to a network may be denied when the modification
334 | itself materially and adversely affects the operation of the network
335 | or violates the rules and protocols for communication across the
336 | network.
337 |
338 | Corresponding Source conveyed, and Installation Information provided,
339 | in accord with this section must be in a format that is publicly
340 | documented (and with an implementation available to the public in
341 | source code form), and must require no special password or key for
342 | unpacking, reading or copying.
343 |
344 | #### 7. Additional Terms.
345 |
346 | "Additional permissions" are terms that supplement the terms of this
347 | License by making exceptions from one or more of its conditions.
348 | Additional permissions that are applicable to the entire Program shall
349 | be treated as though they were included in this License, to the extent
350 | that they are valid under applicable law. If additional permissions
351 | apply only to part of the Program, that part may be used separately
352 | under those permissions, but the entire Program remains governed by
353 | this License without regard to the additional permissions.
354 |
355 | When you convey a copy of a covered work, you may at your option
356 | remove any additional permissions from that copy, or from any part of
357 | it. (Additional permissions may be written to require their own
358 | removal in certain cases when you modify the work.) You may place
359 | additional permissions on material, added by you to a covered work,
360 | for which you have or can give appropriate copyright permission.
361 |
362 | Notwithstanding any other provision of this License, for material you
363 | add to a covered work, you may (if authorized by the copyright holders
364 | of that material) supplement the terms of this License with terms:
365 |
366 | - a) Disclaiming warranty or limiting liability differently from the
367 | terms of sections 15 and 16 of this License; or
368 | - b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 | - c) Prohibiting misrepresentation of the origin of that material,
372 | or requiring that modified versions of such material be marked in
373 | reasonable ways as different from the original version; or
374 | - d) Limiting the use for publicity purposes of names of licensors
375 | or authors of the material; or
376 | - e) Declining to grant rights under trademark law for use of some
377 | trade names, trademarks, or service marks; or
378 | - f) Requiring indemnification of licensors and authors of that
379 | material by anyone who conveys the material (or modified versions
380 | of it) with contractual assumptions of liability to the recipient,
381 | for any liability that these contractual assumptions directly
382 | impose on those licensors and authors.
383 |
384 | All other non-permissive additional terms are considered "further
385 | restrictions" within the meaning of section 10. If the Program as you
386 | received it, or any part of it, contains a notice stating that it is
387 | governed by this License along with a term that is a further
388 | restriction, you may remove that term. If a license document contains
389 | a further restriction but permits relicensing or conveying under this
390 | License, you may add to a covered work material governed by the terms
391 | of that license document, provided that the further restriction does
392 | not survive such relicensing or conveying.
393 |
394 | If you add terms to a covered work in accord with this section, you
395 | must place, in the relevant source files, a statement of the
396 | additional terms that apply to those files, or a notice indicating
397 | where to find the applicable terms.
398 |
399 | Additional terms, permissive or non-permissive, may be stated in the
400 | form of a separately written license, or stated as exceptions; the
401 | above requirements apply either way.
402 |
403 | #### 8. Termination.
404 |
405 | You may not propagate or modify a covered work except as expressly
406 | provided under this License. Any attempt otherwise to propagate or
407 | modify it is void, and will automatically terminate your rights under
408 | this License (including any patent licenses granted under the third
409 | paragraph of section 11).
410 |
411 | However, if you cease all violation of this License, then your license
412 | from a particular copyright holder is reinstated (a) provisionally,
413 | unless and until the copyright holder explicitly and finally
414 | terminates your license, and (b) permanently, if the copyright holder
415 | fails to notify you of the violation by some reasonable means prior to
416 | 60 days after the cessation.
417 |
418 | Moreover, your license from a particular copyright holder is
419 | reinstated permanently if the copyright holder notifies you of the
420 | violation by some reasonable means, this is the first time you have
421 | received notice of violation of this License (for any work) from that
422 | copyright holder, and you cure the violation prior to 30 days after
423 | your receipt of the notice.
424 |
425 | Termination of your rights under this section does not terminate the
426 | licenses of parties who have received copies or rights from you under
427 | this License. If your rights have been terminated and not permanently
428 | reinstated, you do not qualify to receive new licenses for the same
429 | material under section 10.
430 |
431 | #### 9. Acceptance Not Required for Having Copies.
432 |
433 | You are not required to accept this License in order to receive or run
434 | a copy of the Program. Ancillary propagation of a covered work
435 | occurring solely as a consequence of using peer-to-peer transmission
436 | to receive a copy likewise does not require acceptance. However,
437 | nothing other than this License grants you permission to propagate or
438 | modify any covered work. These actions infringe copyright if you do
439 | not accept this License. Therefore, by modifying or propagating a
440 | covered work, you indicate your acceptance of this License to do so.
441 |
442 | #### 10. Automatic Licensing of Downstream Recipients.
443 |
444 | Each time you convey a covered work, the recipient automatically
445 | receives a license from the original licensors, to run, modify and
446 | propagate that work, subject to this License. You are not responsible
447 | for enforcing compliance by third parties with this License.
448 |
449 | An "entity transaction" is a transaction transferring control of an
450 | organization, or substantially all assets of one, or subdividing an
451 | organization, or merging organizations. If propagation of a covered
452 | work results from an entity transaction, each party to that
453 | transaction who receives a copy of the work also receives whatever
454 | licenses to the work the party's predecessor in interest had or could
455 | give under the previous paragraph, plus a right to possession of the
456 | Corresponding Source of the work from the predecessor in interest, if
457 | the predecessor has it or can get it with reasonable efforts.
458 |
459 | You may not impose any further restrictions on the exercise of the
460 | rights granted or affirmed under this License. For example, you may
461 | not impose a license fee, royalty, or other charge for exercise of
462 | rights granted under this License, and you may not initiate litigation
463 | (including a cross-claim or counterclaim in a lawsuit) alleging that
464 | any patent claim is infringed by making, using, selling, offering for
465 | sale, or importing the Program or any portion of it.
466 |
467 | #### 11. Patents.
468 |
469 | A "contributor" is a copyright holder who authorizes use under this
470 | License of the Program or a work on which the Program is based. The
471 | work thus licensed is called the contributor's "contributor version".
472 |
473 | A contributor's "essential patent claims" are all patent claims owned
474 | or controlled by the contributor, whether already acquired or
475 | hereafter acquired, that would be infringed by some manner, permitted
476 | by this License, of making, using, or selling its contributor version,
477 | but do not include claims that would be infringed only as a
478 | consequence of further modification of the contributor version. For
479 | purposes of this definition, "control" includes the right to grant
480 | patent sublicenses in a manner consistent with the requirements of
481 | this License.
482 |
483 | Each contributor grants you a non-exclusive, worldwide, royalty-free
484 | patent license under the contributor's essential patent claims, to
485 | make, use, sell, offer for sale, import and otherwise run, modify and
486 | propagate the contents of its contributor version.
487 |
488 | In the following three paragraphs, a "patent license" is any express
489 | agreement or commitment, however denominated, not to enforce a patent
490 | (such as an express permission to practice a patent or covenant not to
491 | sue for patent infringement). To "grant" such a patent license to a
492 | party means to make such an agreement or commitment not to enforce a
493 | patent against the party.
494 |
495 | If you convey a covered work, knowingly relying on a patent license,
496 | and the Corresponding Source of the work is not available for anyone
497 | to copy, free of charge and under the terms of this License, through a
498 | publicly available network server or other readily accessible means,
499 | then you must either (1) cause the Corresponding Source to be so
500 | available, or (2) arrange to deprive yourself of the benefit of the
501 | patent license for this particular work, or (3) arrange, in a manner
502 | consistent with the requirements of this License, to extend the patent
503 | license to downstream recipients. "Knowingly relying" means you have
504 | actual knowledge that, but for the patent license, your conveying the
505 | covered work in a country, or your recipient's use of the covered work
506 | in a country, would infringe one or more identifiable patents in that
507 | country that you have reason to believe are valid.
508 |
509 | If, pursuant to or in connection with a single transaction or
510 | arrangement, you convey, or propagate by procuring conveyance of, a
511 | covered work, and grant a patent license to some of the parties
512 | receiving the covered work authorizing them to use, propagate, modify
513 | or convey a specific copy of the covered work, then the patent license
514 | you grant is automatically extended to all recipients of the covered
515 | work and works based on it.
516 |
517 | A patent license is "discriminatory" if it does not include within the
518 | scope of its coverage, prohibits the exercise of, or is conditioned on
519 | the non-exercise of one or more of the rights that are specifically
520 | granted under this License. You may not convey a covered work if you
521 | are a party to an arrangement with a third party that is in the
522 | business of distributing software, under which you make payment to the
523 | third party based on the extent of your activity of conveying the
524 | work, and under which the third party grants, to any of the parties
525 | who would receive the covered work from you, a discriminatory patent
526 | license (a) in connection with copies of the covered work conveyed by
527 | you (or copies made from those copies), or (b) primarily for and in
528 | connection with specific products or compilations that contain the
529 | covered work, unless you entered into that arrangement, or that patent
530 | license was granted, prior to 28 March 2007.
531 |
532 | Nothing in this License shall be construed as excluding or limiting
533 | any implied license or other defenses to infringement that may
534 | otherwise be available to you under applicable patent law.
535 |
536 | #### 12. No Surrender of Others' Freedom.
537 |
538 | If conditions are imposed on you (whether by court order, agreement or
539 | otherwise) that contradict the conditions of this License, they do not
540 | excuse you from the conditions of this License. If you cannot convey a
541 | covered work so as to satisfy simultaneously your obligations under
542 | this License and any other pertinent obligations, then as a
543 | consequence you may not convey it at all. For example, if you agree to
544 | terms that obligate you to collect a royalty for further conveying
545 | from those to whom you convey the Program, the only way you could
546 | satisfy both those terms and this License would be to refrain entirely
547 | from conveying the Program.
548 |
549 | #### 13. Use with the GNU Affero General Public License.
550 |
551 | Notwithstanding any other provision of this License, you have
552 | permission to link or combine any covered work with a work licensed
553 | under version 3 of the GNU Affero General Public License into a single
554 | combined work, and to convey the resulting work. The terms of this
555 | License will continue to apply to the part which is the covered work,
556 | but the special requirements of the GNU Affero General Public License,
557 | section 13, concerning interaction through a network will apply to the
558 | combination as such.
559 |
560 | #### 14. Revised Versions of this License.
561 |
562 | The Free Software Foundation may publish revised and/or new versions
563 | of the GNU General Public License from time to time. Such new versions
564 | will be similar in spirit to the present version, but may differ in
565 | detail to address new problems or concerns.
566 |
567 | Each version is given a distinguishing version number. If the Program
568 | specifies that a certain numbered version of the GNU General Public
569 | License "or any later version" applies to it, you have the option of
570 | following the terms and conditions either of that numbered version or
571 | of any later version published by the Free Software Foundation. If the
572 | Program does not specify a version number of the GNU General Public
573 | License, you may choose any version ever published by the Free
574 | Software Foundation.
575 |
576 | If the Program specifies that a proxy can decide which future versions
577 | of the GNU General Public License can be used, that proxy's public
578 | statement of acceptance of a version permanently authorizes you to
579 | choose that version for the Program.
580 |
581 | Later license versions may give you additional or different
582 | permissions. However, no additional obligations are imposed on any
583 | author or copyright holder as a result of your choosing to follow a
584 | later version.
585 |
586 | #### 15. Disclaimer of Warranty.
587 |
588 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
589 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
590 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
591 | WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
592 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
593 | A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
594 | PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
595 | DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
596 | CORRECTION.
597 |
598 | #### 16. Limitation of Liability.
599 |
600 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
601 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
602 | CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
603 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
604 | ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
605 | NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
606 | LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
607 | TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
608 | PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
609 |
610 | #### 17. Interpretation of Sections 15 and 16.
611 |
612 | If the disclaimer of warranty and limitation of liability provided
613 | above cannot be given local legal effect according to their terms,
614 | reviewing courts shall apply local law that most closely approximates
615 | an absolute waiver of all civil liability in connection with the
616 | Program, unless a warranty or assumption of liability accompanies a
617 | copy of the Program in return for a fee.
618 |
619 | END OF TERMS AND CONDITIONS
620 |
621 | ### How to Apply These Terms to Your New Programs
622 |
623 | If you develop a new program, and you want it to be of the greatest
624 | possible use to the public, the best way to achieve this is to make it
625 | free software which everyone can redistribute and change under these
626 | terms.
627 |
628 | To do so, attach the following notices to the program. It is safest to
629 | attach them to the start of each source file to most effectively state
630 | the exclusion of warranty; and each file should have at least the
631 | "copyright" line and a pointer to where the full notice is found.
632 |
633 |
634 | Copyright (C)
635 |
636 | This program is free software: you can redistribute it and/or modify
637 | it under the terms of the GNU General Public License as published by
638 | the Free Software Foundation, either version 3 of the License, or
639 | (at your option) any later version.
640 |
641 | This program is distributed in the hope that it will be useful,
642 | but WITHOUT ANY WARRANTY; without even the implied warranty of
643 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
644 | GNU General Public License for more details.
645 |
646 | You should have received a copy of the GNU General Public License
647 | along with this program. If not, see .
648 |
649 | Also add information on how to contact you by electronic and paper
650 | mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands \`show w' and \`show c' should show the
661 | appropriate parts of the General Public License. Of course, your
662 | program's commands might be different; for a GUI interface, you would
663 | use an "about box".
664 |
665 | You should also get your employer (if you work as a programmer) or
666 | school, if any, to sign a "copyright disclaimer" for the program, if
667 | necessary. For more information on this, and how to apply and follow
668 | the GNU GPL, see .
669 |
670 | The GNU General Public License does not permit incorporating your
671 | program into proprietary programs. If your program is a subroutine
672 | library, you may consider it more useful to permit linking proprietary
673 | applications with the library. If this is what you want to do, use the
674 | GNU Lesser General Public License instead of this License. But first,
675 | please read .
676 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # libinput-gestures-qt
2 |
3 | ## Intro
4 | This app is a setup tool for [libinput-gestures](https://github.com/bulletmark/libinput-gestures), a utility that allows
5 | to map touchpad gestures to shell commands.
6 | The problem is that libinput-gestures does not provide a graphical interface and suggests interacting with
7 | `libinput-gestures` and `libinput-gestures-setup` binaries and `libinput-gestures.conf` configuration file.
8 | I find it too difficult and that is why I decided to make a qt-based app for libinput-gestures.
9 |
10 | ## Dependencies
11 | This package requires python version 3.5 or newer, PyQt5 and libinput-gestures.
12 |
13 | ## Install from PyPI
14 | You can install the latest release version from PyPI by running:
15 | `$ sudo pip3 install libinput-gestures-qt`
16 |
17 | This will install the app and make a desktop entry so that you could run it by clicking in
18 | your app menu.
19 |
20 | This app was tested for Debian and OpenSUSE and seems to work stably. However,
21 | it's not final and one cannot yet be sure that it will work well. Nevertheless, I
22 | already use it myself.
23 |
24 | ## Install from git checkout
25 | You can also install this app by following these steps:
26 | 1. `$ git clone https://github.com/OneAdder/libinput_gestures_qt`
27 | 2. `$ cd libinput_gestures_qt`
28 | 3. `$ mkvirtualenv -p libinput-gestures-qt` # virtualenvwrapper must be installed
29 | 4. `$ pip install -e .`
30 |
31 | This will install the app to a virtualenv that does not affect the rest of the system.
32 |
33 | ## Install testing packages
34 | To also install packages for testing, do:
35 | `$ pip install -e .[dev]`
36 |
37 | ## Features
38 | 1) Handsome main window with current configuration displayed in human-readable form:
39 | 
40 | 2) Adding new gestures.
41 | It's possible to map a gesture to a kwin shortcut (via `qdbus`), keyboard shortcut or command:
42 | 
43 | 
44 | 
45 | 3) Set gestures to some defaults:
46 | 
47 | 4) Control libinput-gestures-setup.
48 | 
49 |
--------------------------------------------------------------------------------
/libinput-gestures-qt:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python3
2 | from libinput_gestures_qt import main
3 | if __name__ == '__main__':
4 | main()
5 |
--------------------------------------------------------------------------------
/libinput_gestures_qt/__init__.py:
--------------------------------------------------------------------------------
1 | from libinput_gestures_qt.main import main
2 |
--------------------------------------------------------------------------------
/libinput_gestures_qt/edit_window.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | # Form implementation generated from reading ui file 'edit_window.ui'
4 | #
5 | # Created by: PyQt5 UI code generator 5.11.3
6 | #
7 | # WARNING! All changes made in this file will be lost!
8 |
9 | from PyQt5 import QtCore, QtGui, QtWidgets
10 |
11 | class Ui_Form(object):
12 | def setupUi(self, Form):
13 | Form.setObjectName("Form")
14 | Form.resize(468, 196)
15 | self.verticalLayout = QtWidgets.QVBoxLayout(Form)
16 | self.verticalLayout.setObjectName("verticalLayout")
17 | self.gridLayout = QtWidgets.QGridLayout()
18 | self.gridLayout.setObjectName("gridLayout")
19 | self.fingersLabel = QtWidgets.QLabel(Form)
20 | self.fingersLabel.setObjectName("fingersLabel")
21 | self.gridLayout.addWidget(self.fingersLabel, 2, 1, 1, 1)
22 | self.actionLabel = QtWidgets.QLabel(Form)
23 | self.actionLabel.setObjectName("actionLabel")
24 | self.gridLayout.addWidget(self.actionLabel, 1, 1, 1, 1)
25 | self.actionMenu = QtWidgets.QComboBox(Form)
26 | self.actionMenu.setObjectName("actionMenu")
27 | self.actionMenu.addItem("")
28 | self.actionMenu.addItem("")
29 | self.actionMenu.addItem("")
30 | self.actionMenu.addItem("")
31 | self.actionMenu.addItem("")
32 | self.actionMenu.addItem("")
33 | self.actionMenu.addItem("")
34 | self.actionMenu.addItem("")
35 | self.actionMenu.addItem("")
36 | self.actionMenu.addItem("")
37 | self.actionMenu.addItem("")
38 | self.actionMenu.addItem("")
39 | self.gridLayout.addWidget(self.actionMenu, 1, 2, 1, 1)
40 | self.fingersLine = QtWidgets.QSpinBox(Form)
41 | self.fingersLine.setObjectName("fingersLine")
42 | self.gridLayout.addWidget(self.fingersLine, 2, 2, 1, 1)
43 | self.saveButton = QtWidgets.QPushButton(Form)
44 | self.saveButton.setObjectName("saveButton")
45 | self.gridLayout.addWidget(self.saveButton, 5, 2, 1, 1)
46 | self.shortcut_command = QtWidgets.QComboBox(Form)
47 | self.shortcut_command.setObjectName("shortcut_command")
48 | self.shortcut_command.addItem("")
49 | self.shortcut_command.addItem("")
50 | self.shortcut_command.addItem("")
51 | self.gridLayout.addWidget(self.shortcut_command, 3, 2, 1, 1)
52 | self.label = QtWidgets.QLabel(Form)
53 | self.label.setObjectName("label")
54 | self.gridLayout.addWidget(self.label, 3, 1, 1, 1)
55 | self.actionType = QtWidgets.QLabel(Form)
56 | self.actionType.setObjectName("actionType")
57 | self.gridLayout.addWidget(self.actionType, 4, 1, 1, 1)
58 | self.verticalLayout.addLayout(self.gridLayout)
59 |
60 | self.retranslateUi(Form)
61 | QtCore.QMetaObject.connectSlotsByName(Form)
62 |
63 | def retranslateUi(self, Form):
64 | _translate = QtCore.QCoreApplication.translate
65 | Form.setWindowTitle(_translate("Form", "Form"))
66 | self.fingersLabel.setText(_translate("Form", "Fingers"))
67 | self.actionLabel.setText(_translate("Form", "Gesture"))
68 | self.actionMenu.setItemText(0, _translate("Form", "Swipe Up"))
69 | self.actionMenu.setItemText(1, _translate("Form", "Swipe Down"))
70 | self.actionMenu.setItemText(2, _translate("Form", "Swipe Left"))
71 | self.actionMenu.setItemText(3, _translate("Form", "Swipe LeftUp"))
72 | self.actionMenu.setItemText(4, _translate("Form", "Swipe LeftDown"))
73 | self.actionMenu.setItemText(5, _translate("Form", "Swipe Right"))
74 | self.actionMenu.setItemText(6, _translate("Form", "Swipe RightUp"))
75 | self.actionMenu.setItemText(7, _translate("Form", "Swipe RightDown"))
76 | self.actionMenu.setItemText(8, _translate("Form", "Pinch In"))
77 | self.actionMenu.setItemText(9, _translate("Form", "Pinch Out"))
78 | self.actionMenu.setItemText(10, _translate("Form", "Pinch Clockwise"))
79 | self.actionMenu.setItemText(11, _translate("Form", "Pinch Anticlockwise"))
80 | self.saveButton.setText(_translate("Form", "Save changes"))
81 | self.shortcut_command.setItemText(0, _translate("Form", "Keyboard Shortcut"))
82 | self.shortcut_command.setItemText(1, _translate("Form", "Plasma action"))
83 | self.shortcut_command.setItemText(2, _translate("Form", "Command"))
84 | self.label.setText(_translate("Form", "Action"))
85 | self.actionType.setText(_translate("Form", "Keyboard Shortcut"))
86 |
87 |
--------------------------------------------------------------------------------
/libinput_gestures_qt/edit_window.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | Form
4 |
5 |
6 |
7 | 0
8 | 0
9 | 468
10 | 196
11 |
12 |
13 |
14 | Form
15 |
16 |
17 | -
18 |
19 |
-
20 |
21 |
22 | Fingers
23 |
24 |
25 |
26 | -
27 |
28 |
29 | Gesture
30 |
31 |
32 |
33 | -
34 |
35 |
-
36 |
37 | Swipe Up
38 |
39 |
40 | -
41 |
42 | Swipe Down
43 |
44 |
45 | -
46 |
47 | Swipe Left
48 |
49 |
50 | -
51 |
52 | Swipe LeftUp
53 |
54 |
55 | -
56 |
57 | Swipe LeftDown
58 |
59 |
60 | -
61 |
62 | Swipe Right
63 |
64 |
65 | -
66 |
67 | Swipe RightUp
68 |
69 |
70 | -
71 |
72 | Swipe RightDown
73 |
74 |
75 | -
76 |
77 | Pinch In
78 |
79 |
80 | -
81 |
82 | Pinch Out
83 |
84 |
85 | -
86 |
87 | Pinch Clockwise
88 |
89 |
90 | -
91 |
92 | Pinch Anticlockwise
93 |
94 |
95 |
96 |
97 | -
98 |
99 |
100 | -
101 |
102 |
103 | Save changes
104 |
105 |
106 |
107 | -
108 |
109 |
-
110 |
111 | Keyboard Shortcut
112 |
113 |
114 | -
115 |
116 | Plasma action
117 |
118 |
119 | -
120 |
121 | Command
122 |
123 |
124 |
125 |
126 | -
127 |
128 |
129 | Action
130 |
131 |
132 |
133 | -
134 |
135 |
136 | Keyboard Shortcut
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
--------------------------------------------------------------------------------
/libinput_gestures_qt/logo/libinput-gestures-qt.desktop:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env xdg-open
2 | [Desktop Entry]
3 | Name=libinput-gestures-qt
4 | Comment=Setup utility for libinput-gestures
5 | Exec=libinput-gestures-qt
6 | Icon=/usr/local/share/pixmaps/libinput-gestures-qt.png
7 | Terminal=false
8 | Type=Application
9 | Categories=Application;System;
10 |
11 |
--------------------------------------------------------------------------------
/libinput_gestures_qt/logo/libinput-gestures-qt.kra:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OneAdder/libinput_gestures_qt/0868859f62e9050c33cfd55df0ffe3ac024cc45d/libinput_gestures_qt/logo/libinput-gestures-qt.kra
--------------------------------------------------------------------------------
/libinput_gestures_qt/logo/libinput-gestures-qt.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OneAdder/libinput_gestures_qt/0868859f62e9050c33cfd55df0ffe3ac024cc45d/libinput_gestures_qt/logo/libinput-gestures-qt.png
--------------------------------------------------------------------------------
/libinput_gestures_qt/main.py:
--------------------------------------------------------------------------------
1 | '''libinput-gestures-qt. User interface for the libinput-gestures utility.
2 | Copyright (C) 2019 Michael Voronov
3 |
4 | This program is free software: you can redistribute it and/or modify
5 | it under the terms of the GNU General Public License as published by
6 | the Free Software Foundation, either version 3 of the License, or
7 | (at your option) any later version.
8 |
9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | GNU General Public License for more details.
13 |
14 | You should have received a copy of the GNU General Public License
15 | along with this program. If not, see .
16 | '''
17 | """
18 | This is a GUI for libinout-gestures-utility. Allows to set up touchpad gestures:
19 | allows to edit the configuration file and control utility status.
20 |
21 | Variables:
22 | --------------
23 | Paths:
24 | -----
25 | HOME: str
26 | path to user's home directory
27 | CONFIG_LOCATION: str
28 | path to the location of the configuration file
29 | LOGO_LOCATION: str
30 | path to logo
31 | Mappings:
32 | --------
33 | actions_mapping: dict
34 | finger actions in human-readable form >> finger actions in config-readable form
35 | reversed_mapping: dict
36 | finger actions in config-readable form >> finger actions in human-readable form
37 | keys_mapping: dict
38 | qt keys (lowered) >> xdotool keys
39 | Other:
40 | -----
41 | kde_defaults: str
42 | Default settings for KDE Plasma
43 | kde_defaults_description: str
44 | Descriptin for KDE defaults.
45 | copyleft: str
46 | Copyleft note.
47 | --------------
48 | Classes:
49 | GesturesApp(QtWidgets.QMainWindow, main_window.Ui_MainWindow)
50 | Main window.
51 | EditGestures(QtWidgets.QWidget, edit_window.Ui_Form)
52 | Secondary window for adding/editing gestures.
53 | --------------
54 | Functions: read_config, write_config, find_key_combo, getqdbus_name, main
55 | --------------
56 | """
57 |
58 | import os
59 | import re
60 | import sys
61 | import subprocess
62 | import functools
63 | from pathlib import Path
64 | from PyQt5 import QtWidgets, QtCore, QtGui
65 | from libinput_gestures_qt import main_window
66 | from libinput_gestures_qt import edit_window
67 |
68 | # NOTE `capture_output` was introduced in 3.7
69 | if sys.version_info.minor < 7:
70 | run = functools.partial(subprocess.run, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
71 | else:
72 | run = functools.partial(subprocess.run, capture_output=True)
73 |
74 | HOME = str(Path.home())
75 | CONFIG_LOCATION = HOME + '/.config/libinput-gestures.conf'
76 | LOGO_LOCATION = os.path.dirname(os.path.abspath(__file__)) + os.path.sep + 'logo' + os.path.sep + 'libinput-gestures-qt.png'
77 |
78 | actions_mapping = {
79 | 'Swipe Up': 'gesture swipe up',
80 | 'Swipe Down': 'gesture swipe down',
81 | 'Swipe Left': 'gesture swipe left',
82 | 'Swipe LeftUp': 'gesture swipe left_up',
83 | 'Swipe LeftDown': 'gesture swipe left_down',
84 | 'Swipe Right': 'gesture swipe right',
85 | 'Swipe RightUp': 'gesture swipe right_up',
86 | 'Swipe RightDown': 'gesture swipe right_down',
87 | 'Pinch In': 'gesture pinch in',
88 | 'Pinch Out': 'gesture pinch out',
89 | 'Pinch Clockwise': 'gesture pinch clockwise',
90 | 'Pinch Anticlockwise': 'gesture pinch anticlockwise',
91 | }
92 |
93 | reversed_mapping = {
94 | 'gesture swipe up': 'Swipe Up',
95 | 'gesture swipe down': 'Swipe Down',
96 | 'gesture swipe left': 'Swipe Left',
97 | 'gesture swipe left_up': 'Swipe LeftUp',
98 | 'gesture swipe left_down': 'Swipe LeftDown',
99 | 'gesture swipe right': 'Swipe Right',
100 | 'gesture swipe right_up': 'Swipe RightUp',
101 | 'gesture swipe right_down': 'Swipe RightDown',
102 | 'gesture pinch in': 'Pinch In',
103 | 'gesture pinch out': 'Pinch Out',
104 | 'gesture pinch clockwise': 'Pinch Clockwise',
105 | 'gesture pinch anticlockwise': 'Pinch Anticlockwise'
106 | }
107 |
108 | keys_mapping = {
109 | 'meta': 'super',
110 | 'pgdown': 'Page_Down',
111 | 'pgup': 'Page_Up',
112 | 'right': 'Right',
113 | 'left': 'Left',
114 | 'up': 'Up',
115 | 'down': 'Down',
116 | 'f1': 'F1',
117 | 'f2': 'F2',
118 | 'f3': 'F3',
119 | 'f4': 'F4',
120 | 'f5': 'F5',
121 | 'f6': 'F6',
122 | 'f7': 'F7',
123 | 'f8': 'F8',
124 | 'f9': 'F9',
125 | 'f10': 'F10',
126 | 'f11': 'F11',
127 | 'f12': 'F12',
128 | }
129 |
130 | kde_defaults = '''
131 | #This default settings for KDE Plasma generated by libinput-gestures-qt
132 | #
133 | #Browser actions Back and Forward
134 | gesture swipe left 3 xdotool key alt+Right
135 | gesture swipe right 3 xdotool key alt+Left
136 | #
137 | #Present Windows
138 | gesture swipe down 3 {qdbus} org.kde.kglobalaccel /component/kwin invokeShortcut "Expose"
139 | #
140 | #Desktop Grid
141 | gesture swipe up 3 {qdbus} org.kde.kglobalaccel /component/kwin invokeShortcut "ShowDesktopGrid"
142 | #
143 | #Minimize
144 | gesture swipe down 4 {qdbus} org.kde.kglobalaccel /component/kwin invokeShortcut "Window Minimize"
145 | #
146 | #Maximize
147 | gesture swipe up 4 {qdbus} org.kde.kglobalaccel /component/kwin invokeShortcut "Window Maximize"
148 | #
149 | #Next virtual desktop
150 | gesture swipe left 4 {qdbus} org.kde.kglobalaccel /component/kwin invokeShortcut "Switch to Next Desktop"
151 | #Previous virtual desktop
152 | gesture swipe right 4 {qdbus} org.kde.kglobalaccel /component/kwin invokeShortcut "Switch to Previous Desktop"
153 | '''
154 |
155 | kde_defaults_description = '''
156 | Present windows: Swipe Down (3 fingers)
157 | Desktop Grid: Swipe Up (3 fingers)
158 | Maximize: Swipe Up (4 fingers)
159 | Minimize: Swipe Down (4 fingers)
160 | Next virtual desktop: Swipe Left (4 fingers)
161 | Previous virtual desktop: Swipe Right (4 fingers)
162 | Browser 'Back': Swipe Right (3 fingers)
163 | Browser 'Forward': Swipe Left (3 fingers)
164 | '''
165 |
166 | copyleft = '''
167 | libinput-gestures-qt
168 | Copyright (C) 2019 Michael Voronov
169 | This program comes with ABSOLUTELY NO WARRANTY.
170 | This is free software, and you are welcome to redistribute it
171 | under certain conditions.
172 | '''
173 |
174 | def read_config():
175 | """Reads config file by lines
176 |
177 | Config under CONFIG_LOCATION = ~/.config/libinput-gestures.conf
178 | Returns '' if there is no config file.
179 | """
180 | try:
181 | with open(CONFIG_LOCATION, 'r') as config:
182 | conf = config.readlines()
183 | return conf
184 | except FileNotFoundError:
185 | return ''
186 |
187 |
188 | def write_config(new_conf):
189 | """Writes config under CONFIG_LOCATION
190 |
191 | Parameter: new_conf, list of strings
192 | """
193 | with open(CONFIG_LOCATION, 'w') as config:
194 | config.write(''.join(new_conf))
195 |
196 |
197 | def write_defaults(defaults):
198 | """Write default settings and backs old config up
199 |
200 | Returns defaults
201 | """
202 | old_conf = read_config()
203 | with open(CONFIG_LOCATION + '.old', 'w') as config:
204 | config.write(''.join(old_conf))
205 | with open(CONFIG_LOCATION, 'w') as config:
206 | config.write(defaults)
207 | return defaults
208 |
209 |
210 | def fix_config():
211 | """Fixes config
212 |
213 | Reads config, goes by lines.
214 | If lise starts with '#', it is preserved.
215 | If line starts with 'gesture', 'device' or 'swipe_threshold'
216 | and this line is ok, it is preserved.
217 | Other lines are deleted.
218 | """
219 | conf = read_config()
220 | fixed_conf = []
221 | for line in conf:
222 | if line.startswith('#') or line == '\n':
223 | fixed_conf.append(line)
224 | else:
225 | splitted = line.replace('\t', ' ').split()
226 | if splitted[0] in ['gesture', 'device', 'swipe_threshold']:
227 | if splitted[0] == 'gesture':
228 | if splitted[4] == 'xdotool':
229 | if splitted[5] == 'key' and len(splitted) == 7:
230 | fixed_conf.append(line)
231 | elif 'qdbus' in splitted[4]:
232 | if splitted[-1].endswith('"'):
233 | fixed_conf.append(line)
234 | else:
235 | fixed_conf.append(line)
236 | else:
237 | if len(splitted) == 2:
238 | fixed_conf.append(line)
239 | write_config(''.join(fixed_conf))
240 |
241 |
242 | def resub_config():
243 | """Delete multiple tabs and spaces"""
244 | conf = ''.join(read_config())
245 | conf = re.sub('(\t)+', ' ', conf)
246 | conf = re.sub('\t', ' ', conf)
247 | conf = re.sub('( )+', ' ', conf)
248 | write_config(conf)
249 |
250 |
251 | def find_key_combo(qt_key_combo):
252 | """Key combo translator
253 |
254 | Takes string with QT-like key combo (generated by PyQt5.QtWidgets.QKeySequenceEdit)
255 | mapes into a string consumable by xdotool
256 | """
257 | xdotool_key_combo = []
258 | for qt_key in qt_key_combo.split('+'):
259 | lowered_key = qt_key.lower()
260 | if lowered_key in keys_mapping:
261 | xdotool_key_combo.append(keys_mapping[lowered_key])
262 | else:
263 | xdotool_key_combo.append(lowered_key)
264 | return '+'.join(xdotool_key_combo)
265 |
266 |
267 | def get_qdbus_name():
268 | """It's either 'qdbus' or 'qdbus-qt5'"""
269 | try:
270 | run(['qdbus'])
271 | return 'qdbus'
272 | except FileNotFoundError:
273 | run(['qdbus-qt5'])
274 | return 'qdbus-qt5'
275 |
276 |
277 | class GesturesApp(QtWidgets.QMainWindow, main_window.Ui_MainWindow):
278 | """Main window.
279 |
280 | Display current configuration, menubar and the 'Add' button.
281 | """
282 | def __init__(self, parent=None):
283 | """init
284 |
285 | Calls for self.display_config() and adds triggers to all the events.
286 | Resubs config (multiple tabs and spaces)
287 | Tries to launch libinput-gestures-setup:
288 | if it works, sets self.installed to True
289 | if not sets self.installed to False
290 | """
291 | super().__init__()
292 | self.setupUi(self)
293 | self.setWindowTitle('Libinput Gestures Qt')
294 |
295 | self.setWindowIcon(QtGui.QIcon(LOGO_LOCATION))
296 | self.QDBUS_NAME = get_qdbus_name()
297 | if not self.QDBUS_NAME:
298 | reply = QtWidgets.QMessageBox.question(self, "Cannot find qdbus",
299 | 'Unable to find qdbus binary.\n'
300 | 'It is a utility included into KDE Plasma used by this app.\n'
301 | 'If you have qdbus but it is called somewhat else, alias it to "qdbus" and restart the app.\n'
302 | 'If not, you will not be able to use KDE defaults and map Plasma actions.'
303 | 'Continue?',
304 | QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
305 | QtWidgets.QMessageBox.No)
306 | if reply == QtWidgets.QMessageBox.No:
307 | sys.exit()
308 |
309 | self.kde_defaults = kde_defaults.format(qdbus=self.QDBUS_NAME)
310 |
311 | resub_config()
312 | self.display_config()
313 |
314 | self.pushButton.clicked.connect(self.start_adding)
315 |
316 | #Menubar actions <--
317 | #File
318 | self.actionRefresh.triggered.connect(self.refresh)
319 | self.actionSet_to_default_KDE.triggered.connect(self.set_KDE_default)
320 | self.actionImport_config_file.triggered.connect(self.import_config)
321 |
322 | #Utility
323 | self.libinput_gestures_pid = None
324 | self.actionRun.triggered.connect(self.run_libinput_gestures)
325 | self.actionKill.triggered.connect(self.kill_libinput_gestures)
326 | self.actionSet_to_autostart.triggered.connect(self.set_to_autostart)
327 | self.actionDisable_autostart.triggered.connect(self.disable_autostart)
328 |
329 | #Service
330 | self.actionStatus.triggered.connect(self.display_status)
331 | self.actionRestart.triggered.connect(self.restart_utility)
332 | self.actionStop.triggered.connect(self.stop_utility)
333 | self.actionStart.triggered.connect(self.start_utility)
334 |
335 | #About
336 | self.actionDefaults_KDE_Plasma.triggered.connect(self.show_kde_defaults)
337 | self.actionLicense.triggered.connect(self.show_copyleft)
338 | #-->
339 | try:
340 | run(['libinput-gestures-setup', 'status'])
341 | self.installed = True
342 | except FileNotFoundError:
343 | QtWidgets.QMessageBox.about(self, "Problem", "Cannot find libinput-gestures. Are you sure it is installed correctly?")
344 | self.installed = False
345 |
346 | def start_adding(self):
347 | """Shows EditGestures window"""
348 | self.adding = EditGestures(self)
349 | self.adding.setWindowModality(QtCore.Qt.WindowModal)
350 | self.adding.show()
351 |
352 | '''
353 | File Menu
354 | _____________________________________________________________________________________________
355 | '''
356 | def refresh(self):
357 | """Refresh content of the main window"""
358 | self.display_config(refresh=True)
359 |
360 | def set_KDE_default(self):
361 | """Set default settings for KDE Plasma"""
362 | reply = QtWidgets.QMessageBox.question(
363 | self, 'Message',
364 | 'Set to defaults?\n'
365 | 'Configuration file will be backed up.\n'
366 | 'You will be able to import it from ~/.cofig/libinput-gestures.conf.old',
367 | QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
368 | QtWidgets.QMessageBox.No
369 | )
370 | if reply == QtWidgets.QMessageBox.Yes:
371 | if self.QDBUS_NAME:
372 | write_defaults(self.kde_defaults)
373 | self.display_config(refresh=True)
374 | else:
375 | QtWidgets.QMessageBox.about(self, 'No qdbus', 'You cannot do it without qdbus:(')
376 |
377 | def import_config(self):
378 | """Import some config file"""
379 | fname = QtWidgets.QFileDialog.getOpenFileName(self, 'Import', HOME)
380 | #Without this try-except the app krashes when I close the Import window
381 | try:
382 | with open(fname[0]) as f:
383 | imported_config = f.readlines()
384 | write_config(imported_config)
385 | resub_config()
386 | fix_config()
387 | self.display_config(refresh=True)
388 | except FileNotFoundError:
389 | pass
390 |
391 | '''
392 | Utility Menu
393 | _____________________________________________________________________________________________
394 | '''
395 | def run_libinput_gestures(self):
396 | """Start libinput-gestures in background"""
397 | if self.installed:
398 | subprocess.Popen(['libinput-gestures'])
399 | self.display_status()
400 |
401 | def kill_libinput_gestures(self):
402 | """Fing libinput-gestures and kill it"""
403 | if self.installed:
404 | p = run(['ps', 'axu'])
405 | s = p.stdout.decode('utf-8').split('\n')
406 | for proc in s:
407 | if 'python3' in proc and 'libinput-gestures' in proc and 'libinput-gestures-qt' not in proc:
408 | try:
409 | run(['kill', proc.split()[1]])
410 | except Exception:
411 | pass
412 | self.display_status()
413 |
414 | def set_to_autostart(self):
415 | """Sets libinput-gestures to autostart"""
416 | if self.installed:
417 | run(['libinput-gestures-setup', 'autostart'])
418 | self.display_status()
419 |
420 | def disable_autostart(self):
421 | """Set libinput-gestures to autostop"""
422 | if self.installed:
423 | run(['libinput-gestures-setup', 'autostop'])
424 | self.display_status()
425 |
426 | '''
427 | Service Menu
428 | _____________________________________________________________________________________________
429 | '''
430 | def display_status(self):
431 | """Check status of libinput-gestures and shows it in message box"""
432 | if self.installed:
433 | status = run(['libinput-gestures-setup', 'status'])
434 | status = status.stdout.decode('utf-8')
435 | installed = 'no'
436 | if 'is installed' in status:
437 | installed = 'yes'
438 | running = 'no'
439 | if 'is running' in status:
440 | running = 'yes'
441 | set_to_autostart = 'no'
442 | if 'is set to autostart' in status:
443 | set_to_autostart = 'yes'
444 | status = 'Installed: {}\nRunning: {}\nAutostart: {}\n'.format(installed, running, set_to_autostart)
445 | QtWidgets.QMessageBox.about(self, "Status", status)
446 |
447 | def restart_utility(self):
448 | """Runs 'libinput-gestures-setup restart', displays output in message box"""
449 | if self.installed:
450 | status = run(['libinput-gestures-setup', 'restart'])
451 | status = status.stdout.decode('utf-8')
452 | QtWidgets.QMessageBox.about(self, "Status", status)
453 |
454 | def stop_utility(self):
455 | """Runs 'libinput-gestures-setup stop', displays output in message box"""
456 | if self.installed:
457 | status = run(['libinput-gestures-setup', 'stop'])
458 | status = status.stdout.decode('utf-8')
459 | QtWidgets.QMessageBox.about(self, "Status", status)
460 |
461 | def start_utility(self):
462 | """Runs 'libinput-gestures-setup start', displays output in message box"""
463 | if self.installed:
464 | status = run(['libinput-gestures-setup', 'start'])
465 | status = status.stdout.decode('utf-8')
466 | QtWidgets.QMessageBox.about(self, "Status", status)
467 |
468 | '''
469 | About Menu
470 | _____________________________________________________________________________________________
471 | '''
472 | def show_kde_defaults(self):
473 | """Show info about KDE defaults"""
474 | QtWidgets.QMessageBox.about(self, "KDE Plasma Defaults", kde_defaults_description)
475 |
476 | def show_copyleft(self):
477 | """Show copyleft note"""
478 | QtWidgets.QMessageBox.about(self, "KDE Plasma Defaults", copyleft)
479 |
480 | '''
481 | Getting config to display handsomely
482 | _____________________________________________________________________________________________
483 | '''
484 | def sort_config(self):
485 | """Sorts config contents alphabetically.
486 |
487 | Assigns new values for:
488 | self.gestures: list of str
489 | finger actions in human-readable form
490 | e.g. ['Swipe Up']
491 | self.fingers: list of int
492 | amount of fingers
493 | e.g. [3]
494 | self.shortcuts: list of str
495 | keyboard shortcuts (in the xdotool form)
496 | OR commands
497 | e.g. ['ctrl+super+Page_Down']
498 | e.g. ['echo "Hello"']
499 | self.buttons: list of str
500 | e.g. ['gesture swipe up 3']
501 | self.actions: list of str
502 | either 'shortcut' (stands for a keyboard shortcut)
503 | or 'command'
504 | """
505 | for_sorting = []
506 | for i, el in enumerate(self.gestures):
507 | for_sorting.append([el, (self.fingers[i], self.shortcuts[i], self.buttons[i], self.actions[i])])
508 | sorted_conf = sorted(for_sorting)
509 |
510 | self.gestures = []
511 | self.fingers = []
512 | self.shortcuts = []
513 | self.buttons = []
514 | self.actions = []
515 | for line in sorted_conf:
516 | self.gestures.append(line[0])
517 | self.fingers.append(line[1][0])
518 | self.shortcuts.append(line[1][1])
519 | self.buttons.append(line[1][2])
520 | self.actions.append(line[1][3])
521 |
522 | def prepare_config_for_displaying(self):
523 | """Creates widgets for all stuff read from config
524 |
525 | Assigns new values for: V-----------------------------------V
526 | self.gestures: list of str <============ Translated from 'gesture ...'
527 | finger actions in human-readable form
528 | e.g. ['Swipe Up'] V-------V
529 | self.fingers: list of int <============ Exact values of '... ...'
530 | amount of fingers
531 | e.g. [3] V-------V
532 | self.shortcuts: list of str <======------ Exact values of '... '
533 | keyboard shortcuts (in the xdotool form) \ <> V-----------------V
534 | OR commands ----- Exact values of '... xdotool key
535 | e.g. ['ctrl+super+Page_Down'] \ <> V--------V
536 | e.g. ['echo "Hello"'] --- Exact values of '... '
537 |
538 | V------------------------------------V
539 | self.buttons: list of str <============ Exact values of 'gesture ...'
540 | e.g. ['gesture swipe up 3']
541 | self.actions: list of str <============ Depend on whether xdotool or qdbus is used in config line
542 | either 'Keyboard shortcut'
543 | or 'Plasma action'
544 | or 'Command'
545 | """
546 | conf = read_config()
547 | self.gestures = []
548 | self.fingers = []
549 | self.shortcuts = []
550 | self.buttons = []
551 | self.actions = []
552 | for line in conf:
553 | if line.startswith('gesture'):
554 | splitted = line.split()
555 | self.gestures.append(reversed_mapping['{} {} {}'.format(splitted[0], splitted[1], splitted[2])])
556 | self.fingers.append(splitted[3])
557 | if splitted[4] == 'xdotool' and splitted[5] == 'key':
558 | self.actions.append('Keyboard shortcut')
559 | self.shortcuts.append(splitted[6])
560 | elif 'qdbus' in splitted[4]:
561 | self.actions.append('Plasma action')
562 | plasma_action = re.findall('"(.*?)"', line)[0]
563 | if plasma_action:
564 | self.shortcuts.append(plasma_action)
565 | else:
566 | self.shortcuts.append(splitted[-1].replace('"', ''))
567 | else:
568 | self.actions.append('Command')
569 | self.shortcuts.append(' '.join(splitted[4:]))
570 | self.buttons.append('{} {} {} {}'.format(splitted[0], splitted[1], splitted[2], splitted[3]))
571 |
572 | def display_config(self, refresh=False):
573 | """Displays current configuration in main window
574 |
575 | Finally gathers all widgets (creates a couple new) and puts them into nice layouts.
576 | """
577 | if refresh:
578 | self.area.deleteLater()
579 |
580 | try:
581 | self.prepare_config_for_displaying()
582 | except Exception:
583 | reply = QtWidgets.QMessageBox.question(
584 | self, 'Problem',
585 | "Something is wrong with the configuration file...\nFix it?",
586 | QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
587 | QtWidgets.QMessageBox.No
588 | )
589 | if reply == QtWidgets.QMessageBox.Yes:
590 | fix_config()
591 | self.prepare_config_for_displaying()
592 | else:
593 | sys.exit()
594 |
595 | self.sort_config()
596 |
597 | self.layout = self.verticalLayout
598 | self.area = QtWidgets.QScrollArea()
599 | content_widget = QtWidgets.QWidget()
600 | self.area.setWidget(content_widget)
601 | flay = QtWidgets.QGridLayout(content_widget)
602 | self.area.setWidgetResizable(True)
603 |
604 | for i, label in enumerate(self.gestures):
605 | flay.addWidget(QtWidgets.QLabel(label), i, 0)
606 |
607 | for i, label in enumerate(self.fingers):
608 | flay.addWidget(QtWidgets.QLabel(label), i, 1)
609 |
610 | for i, label in enumerate(self.actions):
611 | flay.addWidget(QtWidgets.QLabel(label), i, 2)
612 |
613 | for i, label in enumerate(self.shortcuts):
614 | flay.addWidget(QtWidgets.QLabel(label), i, 3)
615 |
616 | for i, button in enumerate(self.buttons):
617 | deleteButton = QtWidgets.QPushButton("Delete")
618 | deleteButton.setAccessibleName(button)
619 | deleteButton.clicked.connect(self.delete_entry)
620 | flay.addWidget(deleteButton, i, 4)
621 |
622 | editButton = QtWidgets.QPushButton("Edit")
623 | editButton.setAccessibleName(button)
624 | editButton.clicked.connect(self.edit_entry)
625 | flay.addWidget(editButton, i, 5)
626 |
627 | self.layout.addWidget(self.area)
628 |
629 | '''
630 | Delete Buttons
631 | _____________________________________________________________________________________________
632 |
633 | '''
634 | def delete_entry(self):
635 | """Delete line from config
636 |
637 | Triggered by 'Delete' buttons.
638 | """
639 | button = self.sender()
640 | if isinstance(button, QtWidgets.QPushButton):
641 | reply = QtWidgets.QMessageBox.question(
642 | self, 'Message',
643 | "Are you sure to delete?",
644 | QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
645 | QtWidgets.QMessageBox.No
646 | )
647 | if reply == QtWidgets.QMessageBox.Yes:
648 | conf = read_config()
649 | new_conf = []
650 | for line in conf:
651 | if not line.startswith(button.accessibleName()):
652 | new_conf.append(line)
653 | write_config(new_conf)
654 | self.display_config(refresh=True)
655 |
656 | '''
657 | Edit Buttons
658 | _____________________________________________________________________________________________
659 |
660 | '''
661 | def edit_entry(self):
662 | button = self.sender()
663 | if isinstance(button, QtWidgets.QPushButton):
664 | lineToEdit = ''
665 | conf = read_config()
666 | for line in conf:
667 | if line.startswith(button.accessibleName()):
668 | lineToEdit = line
669 | print(lineToEdit)
670 | self.editing = EditGestures(self, lineToEdit)
671 | self.editing.setWindowModality(QtCore.Qt.WindowModal)
672 | self.editing.show()
673 |
674 |
675 |
676 | class EditGestures(QtWidgets.QWidget, edit_window.Ui_Form):
677 | """Secondary window for adding/editing gestures
678 |
679 | Child to main window (GesturesApp).
680 | """
681 | def __init__(self, parent, default=None):
682 | """init
683 |
684 | Sets widgets and their attributes that I could not set in QT Designer.
685 | Adds events to buttons. Checks for qdbus.
686 | """
687 | super().__init__()
688 | self.setupUi(self)
689 | self.parent = parent
690 | self.setWindowTitle('Add Gestures')
691 | self.setWindowIcon(QtGui.QIcon(LOGO_LOCATION))
692 |
693 | self.QDBUS_NAME = get_qdbus_name()
694 |
695 | self.shortcut_command.activated[str].connect(self.shortcut_command_or_qdbus)
696 | self.actionMenu.activated[str].connect(self.action_chosen)
697 | self.fingersLine.valueChanged[int].connect(self.fingers_chosen)
698 | self.saveButton.clicked.connect(self.save_changes)
699 |
700 | self.default_line = default
701 |
702 | if not default:
703 | print("Default is none")
704 | self.action = 'gesture swipe up'
705 | self.fingers = 3
706 | self.shortcut = ''
707 | self.fingersLine.setMinimum(3)
708 | self.draw_shortcut()
709 | else:
710 | print("Default is not none")
711 | splitConf = default.split()
712 |
713 | """ Set gesture value """
714 | gesture_syntax = ' '.join(splitConf[:3])
715 | gesture_key = ''
716 | for gesture, syntax in actions_mapping.items():
717 | if syntax == gesture_syntax:
718 | gesture_key = gesture
719 | self.action = gesture_syntax
720 | self.actionMenu.setCurrentIndex(list(actions_mapping.keys()).index(gesture_key))
721 | self.action_chosen(self.actionMenu.currentText())
722 |
723 | """ Set finger value """
724 | self.fingers_chosen(splitConf[3])
725 | self.fingersLine.setValue(int(self.fingers))
726 |
727 | action = splitConf[4]
728 | if action == 'xdotool':
729 | self.shortcut_command.setCurrentIndex(0)
730 | self.draw_shortcut()
731 | self.keyboardLine.setKeySequence(splitConf[6])
732 | elif action == 'qdbus':
733 | self.shortcut_command.setCurrentIndex(1)
734 | if self.QDBUS_NAME:
735 | self.draw_plasma_actions(re.findall('"(.*?)"', default)[0])
736 | self.plasma_action_chosen(self.plasmaActions.currentText())
737 | else:
738 | self.shortcut_command.setCurrentIndex(2)
739 | self.draw_command()
740 | self.commandLine.setText(splitConf[4])
741 | self.command_chosen(self.commandLine.text())
742 |
743 | # self.shortcut_command_or_qdbus(self.shortcut_command.currentText)
744 |
745 | def shortcut_command_or_qdbus(self, text):
746 | """Chose whether you want to add plain command, xdotool command using QKeySequenceEdit or qdbus command
747 |
748 | Does not delete previous widgets: they are stored one upon another.
749 | HELP NEEDED -- it works but it's stupid :(
750 | """
751 |
752 | print("here: " + text)
753 | if text == 'Keyboard Shortcut':
754 | self.draw_shortcut()
755 | elif text == 'Plasma action':
756 | if self.QDBUS_NAME:
757 | self.draw_plasma_actions()
758 | else:
759 | self.draw_command()
760 |
761 | def draw_shortcut(self):
762 | """Draws keyboard shortcut input
763 |
764 | ... so that user could just press buttons (sh|h)e wants
765 | istead of manually typing 'xdotool key ' and remember differences between xdotool/Gnome/KDE/etc.
766 | """
767 | self.shortcut = ''
768 | self.actionType.setText('Keyboard Shortcut')
769 | self.keyboardLine = QtWidgets.QKeySequenceEdit()
770 | self.gridLayout.addWidget(self.keyboardLine, 4, 2)
771 | self.keyboardLine.keySequenceChanged.connect(self.shortcut_chosen)
772 |
773 | def draw_plasma_actions(self, default=None):
774 | """Draws Plasma actions combobox input
775 |
776 | ... so that user could just choose action for Plasma
777 | """
778 | self.shortcut = self.QDBUS_NAME + ' org.kde.kglobalaccel /component/kwin invokeShortcut "Expose"'
779 |
780 | self.actionType.setText('Plasma action')
781 | self.plasmaActions = QtWidgets.QComboBox()
782 | kwin_shortcuts = run(
783 | [
784 | self.QDBUS_NAME, 'org.kde.kglobalaccel', '/component/kwin',
785 | 'org.kde.kglobalaccel.Component.shortcutNames'
786 | ]
787 | )
788 | kwin_shortcuts = kwin_shortcuts.stdout.decode('utf-8').split('\n')[:-2]
789 | kwin_shortcuts.sort()
790 | for kwin_shortcut in kwin_shortcuts:
791 | self.plasmaActions.addItem(kwin_shortcut)
792 | self.gridLayout.addWidget(self.plasmaActions, 4, 2)
793 |
794 | if default:
795 | print(default)
796 | self.plasmaActions.setCurrentIndex(kwin_shortcuts.index(default))
797 |
798 | self.plasmaActions.activated[str].connect(self.plasma_action_chosen)
799 |
800 | def draw_command(self):
801 | """Draws command input
802 |
803 | ... because I don't want users to be stuck with xdotool and qdbus
804 | """
805 | self.shortcut = ''
806 | self.actionType.setText('Command')
807 | self.commandLine = QtWidgets.QLineEdit()
808 | self.gridLayout.addWidget(self.commandLine, 4, 2)
809 | self.commandLine.textChanged[str].connect(self.command_chosen)
810 |
811 | def action_chosen(self, text):
812 | """Event when fingers action is chosen"""
813 | if 'Pinch' in text:
814 | self.fingersLine.setMinimum(2)
815 | self.fingersLine.setValue(2)
816 | else:
817 | self.fingersLine.setMinimum(3)
818 | self.fingersLine.setValue(3)
819 | self.action = actions_mapping[text]
820 |
821 | def fingers_chosen(self, value):
822 | """Event when amount of fingers is chosen"""
823 | self.fingers = value
824 |
825 | def shortcut_chosen(self, text):
826 | """Event when keyboard shortcut is chosen"""
827 | shortcut = text.toString().split(',')[0]
828 | self.shortcut = 'xdotool key ' + find_key_combo(shortcut)
829 |
830 | def command_chosen(self, text):
831 | """Event when command is typed in"""
832 | print(text)
833 | self.shortcut = text
834 |
835 | def plasma_action_chosen(self, text):
836 | self.shortcut = '{qdbus} org.kde.kglobalaccel /component/kwin invokeShortcut "{sh}"'.format(qdbus=self.QDBUS_NAME, sh=text)
837 |
838 | def save_changes(self):
839 | """Writes input data into config file"""
840 | if self.action and self.fingers and self.shortcut:
841 | conf = read_config()
842 | new_conf = []
843 | for line in conf:
844 | if not self.default_line:
845 | new_conf.append(line)
846 | else:
847 | if line == self.default_line:
848 | new_conf.append('{} {} {}\n'.format(self.action, str(self.fingers), self.shortcut))
849 | else:
850 | new_conf.append(line)
851 | if not self.default_line:
852 | new_conf.append('{} {} {}\n'.format(self.action, str(self.fingers), self.shortcut))
853 | write_config(new_conf)
854 | self.actionMenu.setCurrentIndex(0)
855 | self.fingersLine.setValue(0)
856 | QtWidgets.QMessageBox.about(self, "Success", "Cofiguration successfully edited.")
857 | self.parent.display_config(refresh=True)
858 | self.close()
859 | else:
860 | QtWidgets.QMessageBox.about(self, "Fail", "Please, fill all the forms.")
861 |
862 |
863 | def main():
864 | app = QtWidgets.QApplication(sys.argv)
865 | window = GesturesApp()
866 | window.show()
867 | app.exec_()
868 |
869 |
870 | if __name__ == '__main__':
871 | main()
872 |
--------------------------------------------------------------------------------
/libinput_gestures_qt/main_window.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | # Form implementation generated from reading ui file 'main_window.ui'
4 | #
5 | # Created by: PyQt5 UI code generator 5.12.1
6 | #
7 | # WARNING! All changes made in this file will be lost!
8 |
9 | from PyQt5 import QtCore, QtGui, QtWidgets
10 |
11 |
12 | class Ui_MainWindow(object):
13 | def setupUi(self, MainWindow):
14 | MainWindow.setObjectName("MainWindow")
15 | MainWindow.resize(791, 598)
16 | self.centralwidget = QtWidgets.QWidget(MainWindow)
17 | self.centralwidget.setObjectName("centralwidget")
18 | self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.centralwidget)
19 | self.verticalLayout_3.setObjectName("verticalLayout_3")
20 | self.gridLayout = QtWidgets.QGridLayout()
21 | self.gridLayout.setObjectName("gridLayout")
22 | self.label_2 = QtWidgets.QLabel(self.centralwidget)
23 | self.label_2.setObjectName("label_2")
24 | self.gridLayout.addWidget(self.label_2, 0, 1, 1, 1)
25 | self.label = QtWidgets.QLabel(self.centralwidget)
26 | self.label.setObjectName("label")
27 | self.gridLayout.addWidget(self.label, 0, 2, 1, 1)
28 | self.label_3 = QtWidgets.QLabel(self.centralwidget)
29 | self.label_3.setObjectName("label_3")
30 | self.gridLayout.addWidget(self.label_3, 0, 4, 1, 1)
31 | self.label_4 = QtWidgets.QLabel(self.centralwidget)
32 | self.label_4.setText("")
33 | self.label_4.setObjectName("label_4")
34 | self.gridLayout.addWidget(self.label_4, 0, 5, 1, 1)
35 | self.label_5 = QtWidgets.QLabel(self.centralwidget)
36 | self.label_5.setObjectName("label_5")
37 | self.gridLayout.addWidget(self.label_5, 0, 3, 1, 1)
38 | self.verticalLayout_3.addLayout(self.gridLayout)
39 | self.verticalLayout = QtWidgets.QVBoxLayout()
40 | self.verticalLayout.setObjectName("verticalLayout")
41 | self.verticalLayout_3.addLayout(self.verticalLayout)
42 | self.verticalLayout_2 = QtWidgets.QVBoxLayout()
43 | self.verticalLayout_2.setObjectName("verticalLayout_2")
44 | self.pushButton = QtWidgets.QPushButton(self.centralwidget)
45 | self.pushButton.setObjectName("pushButton")
46 | self.verticalLayout_2.addWidget(self.pushButton)
47 | self.verticalLayout_3.addLayout(self.verticalLayout_2)
48 | MainWindow.setCentralWidget(self.centralwidget)
49 | self.menubar = QtWidgets.QMenuBar(MainWindow)
50 | self.menubar.setGeometry(QtCore.QRect(0, 0, 791, 38))
51 | self.menubar.setObjectName("menubar")
52 | self.menuFile = QtWidgets.QMenu(self.menubar)
53 | self.menuFile.setObjectName("menuFile")
54 | self.menuService = QtWidgets.QMenu(self.menubar)
55 | self.menuService.setObjectName("menuService")
56 | self.menuAbout = QtWidgets.QMenu(self.menubar)
57 | self.menuAbout.setObjectName("menuAbout")
58 | self.menuUtility = QtWidgets.QMenu(self.menubar)
59 | self.menuUtility.setObjectName("menuUtility")
60 | MainWindow.setMenuBar(self.menubar)
61 | self.statusbar = QtWidgets.QStatusBar(MainWindow)
62 | self.statusbar.setObjectName("statusbar")
63 | MainWindow.setStatusBar(self.statusbar)
64 | self.actionAdd = QtWidgets.QAction(MainWindow)
65 | self.actionAdd.setObjectName("actionAdd")
66 | self.actionStatus = QtWidgets.QAction(MainWindow)
67 | self.actionStatus.setObjectName("actionStatus")
68 | self.actionRestart = QtWidgets.QAction(MainWindow)
69 | self.actionRestart.setObjectName("actionRestart")
70 | self.actionStart = QtWidgets.QAction(MainWindow)
71 | self.actionStart.setObjectName("actionStart")
72 | self.actionStop = QtWidgets.QAction(MainWindow)
73 | self.actionStop.setObjectName("actionStop")
74 | self.actionRefresh = QtWidgets.QAction(MainWindow)
75 | self.actionRefresh.setObjectName("actionRefresh")
76 | self.actionSet_to_default_KDE = QtWidgets.QAction(MainWindow)
77 | self.actionSet_to_default_KDE.setObjectName("actionSet_to_default_KDE")
78 | self.actionDefaults_KDE_Plasma = QtWidgets.QAction(MainWindow)
79 | self.actionDefaults_KDE_Plasma.setObjectName("actionDefaults_KDE_Plasma")
80 | self.actionLicense = QtWidgets.QAction(MainWindow)
81 | self.actionLicense.setObjectName("actionLicense")
82 | self.actionImport_config_file = QtWidgets.QAction(MainWindow)
83 | self.actionImport_config_file.setObjectName("actionImport_config_file")
84 | self.actionRun = QtWidgets.QAction(MainWindow)
85 | self.actionRun.setObjectName("actionRun")
86 | self.actionKill = QtWidgets.QAction(MainWindow)
87 | self.actionKill.setObjectName("actionKill")
88 | self.actionSet_to_autostart = QtWidgets.QAction(MainWindow)
89 | self.actionSet_to_autostart.setObjectName("actionSet_to_autostart")
90 | self.actionDisable_autostart = QtWidgets.QAction(MainWindow)
91 | self.actionDisable_autostart.setObjectName("actionDisable_autostart")
92 | self.menuFile.addAction(self.actionRefresh)
93 | self.menuFile.addAction(self.actionSet_to_default_KDE)
94 | self.menuFile.addAction(self.actionImport_config_file)
95 | self.menuService.addAction(self.actionStatus)
96 | self.menuService.addAction(self.actionRestart)
97 | self.menuService.addAction(self.actionStart)
98 | self.menuService.addAction(self.actionStop)
99 | self.menuAbout.addAction(self.actionDefaults_KDE_Plasma)
100 | self.menuAbout.addAction(self.actionLicense)
101 | self.menuUtility.addAction(self.actionRun)
102 | self.menuUtility.addAction(self.actionKill)
103 | self.menuUtility.addAction(self.actionSet_to_autostart)
104 | self.menuUtility.addAction(self.actionDisable_autostart)
105 | self.menubar.addAction(self.menuFile.menuAction())
106 | self.menubar.addAction(self.menuUtility.menuAction())
107 | self.menubar.addAction(self.menuService.menuAction())
108 | self.menubar.addAction(self.menuAbout.menuAction())
109 |
110 | self.retranslateUi(MainWindow)
111 | QtCore.QMetaObject.connectSlotsByName(MainWindow)
112 |
113 | def retranslateUi(self, MainWindow):
114 | _translate = QtCore.QCoreApplication.translate
115 | MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
116 | self.label_2.setText(_translate("MainWindow", "Gesture"))
117 | self.label.setText(_translate("MainWindow", "Fingers"))
118 | self.label_3.setText(_translate("MainWindow", "Action"))
119 | self.label_5.setText(_translate("MainWindow", "Type"))
120 | self.pushButton.setText(_translate("MainWindow", "Add"))
121 | self.menuFile.setTitle(_translate("MainWindow", "&File"))
122 | self.menuService.setTitle(_translate("MainWindow", "&Service"))
123 | self.menuAbout.setTitle(_translate("MainWindow", "&About"))
124 | self.menuUtility.setTitle(_translate("MainWindow", "&Utility"))
125 | self.actionAdd.setText(_translate("MainWindow", "&Add"))
126 | self.actionStatus.setText(_translate("MainWindow", "&Status"))
127 | self.actionRestart.setText(_translate("MainWindow", "&Restart"))
128 | self.actionStart.setText(_translate("MainWindow", "S&tart"))
129 | self.actionStop.setText(_translate("MainWindow", "St&op"))
130 | self.actionRefresh.setText(_translate("MainWindow", "&Refresh"))
131 | self.actionSet_to_default_KDE.setText(_translate("MainWindow", "&Set to default (KDE)"))
132 | self.actionDefaults_KDE_Plasma.setText(_translate("MainWindow", "&Defaults (KDE Plasma)"))
133 | self.actionLicense.setText(_translate("MainWindow", "&License"))
134 | self.actionImport_config_file.setText(_translate("MainWindow", "&Import config file"))
135 | self.actionRun.setText(_translate("MainWindow", "Run"))
136 | self.actionKill.setText(_translate("MainWindow", "Kill"))
137 | self.actionSet_to_autostart.setText(_translate("MainWindow", "Set to autostart"))
138 | self.actionDisable_autostart.setText(_translate("MainWindow", "Disable autostart"))
139 |
140 |
141 |
--------------------------------------------------------------------------------
/libinput_gestures_qt/main_window.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | MainWindow
4 |
5 |
6 |
7 | 0
8 | 0
9 | 791
10 | 598
11 |
12 |
13 |
14 | MainWindow
15 |
16 |
17 |
18 | -
19 |
20 |
-
21 |
22 |
23 | Gesture
24 |
25 |
26 |
27 | -
28 |
29 |
30 | Fingers
31 |
32 |
33 |
34 | -
35 |
36 |
37 | Action
38 |
39 |
40 |
41 | -
42 |
43 |
44 |
45 |
46 |
47 |
48 | -
49 |
50 |
51 | Type
52 |
53 |
54 |
55 |
56 |
57 | -
58 |
59 |
60 | -
61 |
62 |
-
63 |
64 |
65 | Add
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
120 |
121 |
122 |
123 | &Add
124 |
125 |
126 |
127 |
128 | &Status
129 |
130 |
131 |
132 |
133 | &Restart
134 |
135 |
136 |
137 |
138 | S&tart
139 |
140 |
141 |
142 |
143 | St&op
144 |
145 |
146 |
147 |
148 | &Refresh
149 |
150 |
151 |
152 |
153 | &Set to default (KDE)
154 |
155 |
156 |
157 |
158 | &Defaults (KDE Plasma)
159 |
160 |
161 |
162 |
163 | &License
164 |
165 |
166 |
167 |
168 | &Import config file
169 |
170 |
171 |
172 |
173 | Run
174 |
175 |
176 |
177 |
178 | Kill
179 |
180 |
181 |
182 |
183 | Set to autostart
184 |
185 |
186 |
187 |
188 | Disable autostart
189 |
190 |
191 |
192 |
193 |
194 |
195 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | from setuptools import setup
2 |
3 | setup(
4 | name='libinput_gestures_qt',
5 | version='0.4',
6 | description='Qt interface for libinput-gestures (works best with Plasma)',
7 | url='https://github.com/OneAdder/libinput_gestures_qt',
8 | author='Michael Voronov',
9 | author_email='mikivo@list.ru',
10 | license='GPLv3',
11 | packages=['libinput_gestures_qt'],
12 | extras_require={
13 | 'dev': ['pytest']
14 | },
15 | zip_safe=False,
16 | scripts=['libinput-gestures-qt'],
17 | data_files=[
18 | ('share/applications', ['libinput_gestures_qt/logo/libinput-gestures-qt.desktop']),
19 | ('share/pixmaps/', ['libinput_gestures_qt/logo/libinput-gestures-qt.png']),
20 | ('local/share/applications', ['libinput_gestures_qt/logo/libinput-gestures-qt.desktop']),
21 | ('local/share/pixmaps/', ['libinput_gestures_qt/logo/libinput-gestures-qt.png']),
22 | ],
23 | include_package_data=True
24 | )
25 |
--------------------------------------------------------------------------------
/tests/test_main.py:
--------------------------------------------------------------------------------
1 | from libinput_gestures_qt.main import run
2 |
3 |
4 | def test_run():
5 | run('ls')
6 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | # tox (https://tox.readthedocs.io/) is a tool for running tests
2 | # in multiple virtualenvs. This configuration file will run the
3 | # test suite on all supported python versions. To use it, "pip install tox"
4 | # and then run "tox" from this directory.
5 |
6 | [tox]
7 | envlist = py35, py36, py37
8 |
9 | [testenv]
10 | commands = pytest
11 | deps =
12 | pytest
13 |
--------------------------------------------------------------------------------