From 64ed01835900d3bb8f602ece3e05b302fc15b6e6 Mon Sep 17 00:00:00 2001 From: pants Date: Thu, 16 Apr 2026 16:57:38 -0700 Subject: [PATCH] init --- CHANGELOG.md | 175 + LICENSE | 692 ++++ LICENSE.dwm | 39 + LICENSE.sway | 19 + LICENSE.tinywl | 127 + Makefile | 78 + README.md | 180 + client.h | 396 +++ config.def.h | 229 ++ config.h | 229 ++ config.mk | 17 + cursor-shape-v1-protocol.h | 507 +++ dwl.1 | 158 + dwl.c | 3159 +++++++++++++++++ dwl.desktop | 5 + dwl.o | Bin 0 -> 275992 bytes install | 3 + pointer-constraints-unstable-v1-protocol.h | 615 ++++ protocols/wlr-layer-shell-unstable-v1.xml | 390 ++ ...lr-output-power-management-unstable-v1.xml | 128 + util.c | 51 + util.h | 5 + util.o | Bin 0 -> 8696 bytes wlr-layer-shell-unstable-v1-protocol.h | 730 ++++ ...ut-power-management-unstable-v1-protocol.h | 285 ++ xdg-shell-protocol.h | 2374 +++++++++++++ 26 files changed, 10591 insertions(+) create mode 100644 CHANGELOG.md create mode 100644 LICENSE create mode 100644 LICENSE.dwm create mode 100644 LICENSE.sway create mode 100644 LICENSE.tinywl create mode 100644 Makefile create mode 100644 README.md create mode 100644 client.h create mode 100644 config.def.h create mode 100644 config.h create mode 100644 config.mk create mode 100644 cursor-shape-v1-protocol.h create mode 100644 dwl.1 create mode 100644 dwl.c create mode 100644 dwl.desktop create mode 100644 dwl.o create mode 100755 install create mode 100644 pointer-constraints-unstable-v1-protocol.h create mode 100644 protocols/wlr-layer-shell-unstable-v1.xml create mode 100644 protocols/wlr-output-power-management-unstable-v1.xml create mode 100644 util.c create mode 100644 util.h create mode 100644 util.o create mode 100644 wlr-layer-shell-unstable-v1-protocol.h create mode 100644 wlr-output-power-management-unstable-v1-protocol.h create mode 100644 xdg-shell-protocol.h diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..6ef3d96 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,175 @@ +# Changelog + +* [0.6](#0.6) +* [0.5](#0.5) + + +## Unreleased + +### Added + +* Add `rootcolor` to change the default background color ([#544][544]). +* Implement the wlr-virtual-pointer-unstable-v1 protocol ([#574][574]). +* Implement the pointer-constraints and relative-pointer protocols ([#317][317]) +* Implement the wlr-output-power-management protocol ([#599][599]) + +[544]: https://codeberg.org/dwl/dwl/pulls/544 +[574]: https://codeberg.org/dwl/dwl/pulls/574 +[317]: https://codeberg.org/dwl/dwl/issues/317 +[599]: https://codeberg.org/dwl/dwl/issues/559 + + +### Changed + +* Keyboards are now managed through keyboard groups ([#549][549]). +* Only the first matched keybinding is executed. +* Allow toggling the layout before selecting a different one ([#570][570]). +* Fullscreen clients are now rendered above wlr_layer_surfaces in the top layer + ([#609][609]). +* The default menu was changed from `bemenu-run` to `wmenu-run` ([#553][553]). +* The option `sloppyfocus` now replicates the dwm behavior ([#599][599]). +* Allow configure position of monitors with negative values. (-1, -1) is + used to auto-configure them ([#635][635]). +* dwl now kills the entire process group of `startup_cmd` +* The O_NONBLOCK flag is set for stdout. + +[549]: https://codeberg.org/dwl/dwl/pulls/549 +[570]: https://codeberg.org/dwl/dwl/pulls/570 +[609]: https://codeberg.org/dwl/dwl/pulls/609 +[553]: https://codeberg.org/dwl/dwl/issues/553 +[599]: https://codeberg.org/dwl/dwl/pulls/599 +[635]: https://codeberg.org/dwl/dwl/pulls/635 + + +### Removed + +* The SLOC limit is now removed ([#497][497]). + +[497]: https://codeberg.org/dwl/dwl/pulls/497 + + +### Fixed + +* Clients not having the correct border color when mapping. +* Compliance with the xdg-decoration-unstable-v1 ([#546][546]). +* dwl no longer sends negative values in xdg_toplevel.configure events. +* Crashes with disabled monitors ([#472][472]). + +[546]: https://codeberg.org/dwl/dwl/pulls/546 +[472]: https://codeberg.org/dwl/dwl/issues/472 + + +### Contributors + +Ben Jargowsky +Benjamin Chausse +David Donahue +Devin J. Pohly +Dima Krasner +Emil Miler +Forrest Bushstone +Guido Cella +Peter Hofmann +Rutherther +Squibid +choc +fictitiousexistence +korei999 +sewn +thanatos + + +## 0.5 + +### Added + +* Allow configure x and y position of outputs ([#301][301]) +* Implement repeatable keybindings ([#368][368]) +* Print app id in printstatus() output ([#381][381]) +* Display client count in monocle symbol ([#387][387]) +* Export XCURSOR_SIZE to fix apps using an older version of Qt ([#425][425]) +* Support for wp-fractional-scale-v1 (through wlr_scene: [wlroots!3511][wlroots!3511]) +* dwl now sends `wl_surface.preferred_buffer_scale` (through wlr_scene: [wlroots!4269][wlroots!4269]) +* Add support for xdg-shell v6 ([#465][465]) +* Add support for wp-cursor-shape-v1 ([#444][444]) +* Add desktop file ([#484][484]) +* Add macro to easily configure colors ([#466][466]) +* Color of urgent clients are now red ([#494][494]) +* New flag `-d` and option `log_level` to change the wlroots debug level +* Add CHANGELOG.md ([#501][501]) + +[301]: https://github.com/djpohly/dwl/pull/301 +[368]: https://github.com/djpohly/dwl/pull/368 +[381]: https://github.com/djpohly/dwl/pull/381 +[387]: https://github.com/djpohly/dwl/issues/387 +[425]: https://github.com/djpohly/dwl/pull/425 +[wlroots!4269]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4269 +[wlroots!3511]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/3511 +[465]: https://github.com/djpohly/dwl/pull/465 +[444]: https://github.com/djpohly/dwl/pull/444 +[484]: https://github.com/djpohly/dwl/pull/484 +[466]: https://github.com/djpohly/dwl/issues/466 +[494]: https://github.com/djpohly/dwl/pull/494 +[501]: https://github.com/djpohly/dwl/pull/501 + + +### Changed + +* Replace `tags` with `TAGCOUNT` in config.def.h ([#403][403]) +* Pop ups are now destroyed when focusing another client ([#408][408]) +* dwl does not longer respect size hints, instead clip windows if they are + larger than they should be ([#455][455]) +* The version of wlr-layer-shell-unstable-v1 was lowered to 3 (from 4) +* Use the same border color as dwm ([#494][494]) + +[403]: https://github.com/djpohly/dwl/pull/403 +[408]: https://github.com/djpohly/dwl/pull/409 +[455]: https://github.com/djpohly/dwl/pull/455 +[494]: https://github.com/djpohly/dwl/pull/494 + + +### Removed + +* Remove unused `rootcolor` option ([#401][401]) +* Remove support for wlr-input-inhibitor-unstable-v1 ([#430][430]) +* Remove support for KDE idle protocol ([#431][431]) + +[401]: https://github.com/djpohly/dwl/pull/401 +[430]: https://github.com/djpohly/dwl/pull/430 +[431]: https://github.com/djpohly/dwl/pull/431 + + +### Fixed + +* Fix crash when creating a layer surface with all outputs disabled + ([#421][421]) +* Fix other clients being shown as focused if the focused client have pop ups + open ([#408][408]) +* Resize fullscreen clients when updating monitor mode +* dwl no longer crash at exit like sometimes did +* Fullscreen background appearing above clients ([#487][487]) +* Fix a segfault when user provides invalid xkb_rules ([#518][518]) + +[421]: https://github.com/djpohly/dwl/pull/421 +[408]: https://github.com/djpohly/dwl/issues/408 +[487]: https://github.com/djpohly/dwl/issues/487 +[518]: https://github.com/djpohly/dwl/pull/518 + + +### Contributors + +* A Frederick Christensen +* Angelo Antony +* Ben Collerson +* Devin J. Pohly +* Forrest Bushstone +* gan-of-culture +* godalming123 +* Job79 +* link2xt +* Micah Gorrell +* Nikita Ivanov +* Palanix +* pino-desktop +* Weiseguy +* Yves Zoundi diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..658085a --- /dev/null +++ b/LICENSE @@ -0,0 +1,692 @@ +dwl - dwm for Wayland + +Copyright © 2020 dwl team + +See also the files LICENSE.tinywl, LICENSE.dwm and LICENSE.sway. + +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. + +---- + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/LICENSE.dwm b/LICENSE.dwm new file mode 100644 index 0000000..507e4dc --- /dev/null +++ b/LICENSE.dwm @@ -0,0 +1,39 @@ +Portions of dwl based on dwm code are used under the following license: + +MIT/X Consortium License + +© 2006-2019 Anselm R Garbe +© 2006-2009 Jukka Salmi +© 2006-2007 Sander van Dijk +© 2007-2011 Peter Hartlich +© 2007-2009 Szabolcs Nagy +© 2007-2009 Christof Musik +© 2007-2009 Premysl Hruby +© 2007-2008 Enno Gottox Boland +© 2008 Martin Hurton +© 2008 Neale Pickett +© 2009 Mate Nagy +© 2010-2016 Hiltjo Posthuma +© 2010-2012 Connor Lane Smith +© 2011 Christoph Lohmann <20h@r-36.net> +© 2015-2016 Quentin Rameau +© 2015-2016 Eric Pruitt +© 2016-2017 Markus Teich + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/LICENSE.sway b/LICENSE.sway new file mode 100644 index 0000000..3e0cacc --- /dev/null +++ b/LICENSE.sway @@ -0,0 +1,19 @@ +Copyright (c) 2016-2017 Drew DeVault + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/LICENSE.tinywl b/LICENSE.tinywl new file mode 100644 index 0000000..7023690 --- /dev/null +++ b/LICENSE.tinywl @@ -0,0 +1,127 @@ +dwl is originally based on TinyWL, which is used under the following license: + +This work is licensed under CC0, which effectively puts it in the public domain. + +--- + +Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0d651e7 --- /dev/null +++ b/Makefile @@ -0,0 +1,78 @@ +.POSIX: +.SUFFIXES: + +include config.mk + +# flags for compiling +DWLCPPFLAGS = -I. -DWLR_USE_UNSTABLE -D_POSIX_C_SOURCE=200809L \ + -DVERSION=\"$(VERSION)\" $(XWAYLAND) +DWLDEVCFLAGS = -g -pedantic -Wall -Wextra -Wdeclaration-after-statement \ + -Wno-unused-parameter -Wshadow -Wunused-macros -Werror=strict-prototypes \ + -Werror=implicit -Werror=return-type -Werror=incompatible-pointer-types \ + -Wfloat-conversion + +# CFLAGS / LDFLAGS +PKGS = wlroots wayland-server xkbcommon libinput $(XLIBS) +DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(DWLCPPFLAGS) $(DWLDEVCFLAGS) $(CFLAGS) +LDLIBS = `$(PKG_CONFIG) --libs $(PKGS)` -lm $(LIBS) + +all: dwl +dwl: dwl.o util.o + $(CC) dwl.o util.o $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@ +dwl.o: dwl.c client.h config.h config.mk cursor-shape-v1-protocol.h \ + pointer-constraints-unstable-v1-protocol.h wlr-layer-shell-unstable-v1-protocol.h \ + wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h +util.o: util.c util.h + +# wayland-scanner is a tool which generates C headers and rigging for Wayland +# protocols, which are specified in XML. wlroots requires you to rig these up +# to your build system yourself and provide them in the include path. +WAYLAND_SCANNER = `$(PKG_CONFIG) --variable=wayland_scanner wayland-scanner` +WAYLAND_PROTOCOLS = `$(PKG_CONFIG) --variable=pkgdatadir wayland-protocols` + +cursor-shape-v1-protocol.h: + $(WAYLAND_SCANNER) server-header \ + $(WAYLAND_PROTOCOLS)/staging/cursor-shape/cursor-shape-v1.xml $@ +pointer-constraints-unstable-v1-protocol.h: + $(WAYLAND_SCANNER) server-header \ + $(WAYLAND_PROTOCOLS)/unstable/pointer-constraints/pointer-constraints-unstable-v1.xml $@ +wlr-layer-shell-unstable-v1-protocol.h: + $(WAYLAND_SCANNER) server-header \ + protocols/wlr-layer-shell-unstable-v1.xml $@ +wlr-output-power-management-unstable-v1-protocol.h: + $(WAYLAND_SCANNER) server-header \ + protocols/wlr-output-power-management-unstable-v1.xml $@ +xdg-shell-protocol.h: + $(WAYLAND_SCANNER) server-header \ + $(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@ + +config.h: + cp config.def.h $@ +clean: + rm -f dwl *.o *-protocol.h + +dist: clean + mkdir -p dwl-$(VERSION) + cp -R LICENSE* Makefile CHANGELOG.md README.md client.h config.def.h \ + config.mk protocols dwl.1 dwl.c util.c util.h dwl.desktop \ + dwl-$(VERSION) + tar -caf dwl-$(VERSION).tar.gz dwl-$(VERSION) + rm -rf dwl-$(VERSION) + +install: dwl + mkdir -p $(DESTDIR)$(PREFIX)/bin + cp -f dwl $(DESTDIR)$(PREFIX)/bin + chmod 755 $(DESTDIR)$(PREFIX)/bin/dwl + mkdir -p $(DESTDIR)$(MANDIR)/man1 + cp -f dwl.1 $(DESTDIR)$(MANDIR)/man1 + chmod 644 $(DESTDIR)$(MANDIR)/man1/dwl.1 + mkdir -p $(DESTDIR)$(DATADIR)/wayland-sessions + cp -f dwl.desktop $(DESTDIR)$(DATADIR)/wayland-sessions/dwl.desktop + chmod 644 $(DESTDIR)$(DATADIR)/wayland-sessions/dwl.desktop +uninstall: + rm -f $(DESTDIR)$(PREFIX)/bin/dwl $(DESTDIR)$(MANDIR)/man1/dwl.1 \ + $(DESTDIR)$(DATADIR)/wayland-sessions/dwl.desktop + +.SUFFIXES: .c .o +.c.o: + $(CC) $(CPPFLAGS) $(DWLCFLAGS) -o $@ -c $< diff --git a/README.md b/README.md new file mode 100644 index 0000000..9d91923 --- /dev/null +++ b/README.md @@ -0,0 +1,180 @@ +# dwl - dwm for Wayland + +Join us on our IRC channel: [#dwl on Libera Chat] +Or on our [Discord server]. + +dwl is a compact, hackable compositor for [Wayland] based on [wlroots]. It is +intended to fill the same space in the Wayland world that dwm does in X11, +primarily in terms of functionality, and secondarily in terms of philosophy. +Like dwm, dwl is: + +- Easy to understand, hack on, and extend with patches +- One C source file (or a very small number) configurable via `config.h` +- Tied to as few external dependencies as possible + +dwl is not meant to provide every feature under the sun. Instead, like dwm, it +sticks to features which are necessary, simple, and straightforward to implement +given the base on which it is built. Implemented default features are: + +- Any features provided by dwm/Xlib: simple window borders, tags, keybindings, + client rules, mouse move/resize. Providing a built-in status bar is an + exception to this goal, to avoid dependencies on font rendering and/or + drawing libraries when an external bar could work well. +- Configurable multi-monitor layout support, including position and rotation +- Configurable HiDPI/multi-DPI support +- Idle-inhibit protocol which lets applications such as mpv disable idle + monitoring +- Provide information to external status bars via stdout/stdin +- Urgency hints via xdg-activate protocol +- Support screen lockers via ext-session-lock-v1 protocol +- Various Wayland protocols +- XWayland support as provided by wlroots (can be enabled in `config.mk`) +- Zero flickering - Wayland users naturally expect that "every frame is perfect" +- Layer shell popups (used by Waybar) +- Damage tracking provided by scenegraph API + +Given the Wayland architecture, dwl has to implement features from dwm **and** +the xorg-server. Because of this, it is impossible to maintain the original +project goal of 2000 SLOC and have a reasonably complete compositor with +features comparable to dwm. However, this does not mean that the code will grow +indiscriminately. We will try to keep the code as small as possible. + +Features under consideration (possibly as patches) are: + +- Protocols made trivial by wlroots +- Implement the text-input and input-method protocols to support IME once ibus + implements input-method v2 (see https://github.com/ibus/ibus/pull/2256 and + https://codeberg.org/dwl/dwl/pulls/235) + +Feature *non-goals* for the main codebase include: + +- Client-side decoration (any more than is necessary to tell the clients not to) +- Client-initiated window management, such as move, resize, and close, which can + be done through the compositor +- Animations and visual effects + +## Building dwl + +dwl has the following dependencies: +``` +libinput +wayland +wlroots (compiled with the libinput backend) +xkbcommon +wayland-protocols (compile-time only) +pkg-config (compile-time only) +``` +If you enable X11 support: +``` +libxcb +libxcb-wm +wlroots (compiled with X11 support) +Xwayland (runtime only) +``` + +Simply install these (and their `-devel` versions if your distro has separate +development packages) and run `make`. If you wish to build against a Git +version of wlroots, check out the [wlroots-next branch]. + +To enable XWayland, you should uncomment its flags in `config.mk`. + +## Configuration + +All configuration is done by editing `config.h` and recompiling, in the same +manner as dwm. There is no way to separately restart the window manager in +Wayland without restarting the entire display server, so any changes will take +effect the next time dwl is executed. + +As in the dwm community, we encourage users to share patches they have created. +Check out the dwl [patches repository]! + +## Running dwl + +dwl can be run on any of the backends supported by wlroots. This means you can +run it as a separate window inside either an X11 or Wayland session, as well +as directly from a VT console. Depending on your distro's setup, you may need +to add your user to the `video` and `input` groups before you can run dwl on +a VT. If you are using `elogind` or `systemd-logind` you need to install +polkit; otherwise you need to add yourself in the `seat` group and +enable/start the seatd daemon. + +When dwl is run with no arguments, it will launch the server and begin handling +any shortcuts configured in `config.h`. There is no status bar or other +decoration initially; these are instead clients that can be run within +the Wayland session. +Do note that the background color is black. + +If you would like to run a script or command automatically at startup, you can +specify the command using the `-s` option. This command will be executed as a +shell command using `/bin/sh -c`. It serves a similar function to `.xinitrc`, +but differs in that the display server will not shut down when this process +terminates. Instead, dwl will send this process a SIGTERM at shutdown and wait +for it to terminate (if it hasn't already). This makes it ideal for execing into +a user service manager like [s6], [anopa], [runit], [dinit], or [`systemd --user`]. + +Note: The `-s` command is run as a *child process* of dwl, which means that it +does not have the ability to affect the environment of dwl or of any processes +that it spawns. If you need to set environment variables that affect the entire +dwl session, these must be set prior to running dwl. For example, Wayland +requires a valid `XDG_RUNTIME_DIR`, which is usually set up by a session manager +such as `elogind` or `systemd-logind`. If your system doesn't do this +automatically, you will need to configure it prior to launching `dwl`, e.g.: + + export XDG_RUNTIME_DIR=/tmp/xdg-runtime-$(id -u) + mkdir -p $XDG_RUNTIME_DIR + dwl + +### Status information + +Information about selected layouts, current window title, app-id, and +selected/occupied/urgent tags is written to the stdin of the `-s` command (see +the `printstatus()` function for details). This information can be used to +populate an external status bar with a script that parses the information. +Failing to read this information will cause dwl to block, so if you do want to +run a startup command that does not consume the status information, you can +close standard input with the `<&-` shell redirection, for example: + + dwl -s 'foot --server <&-' + +If your startup command is a shell script, you can achieve the same inside the +script with the line + + exec <&- + +To get a list of status bars that work with dwl consult our [wiki]. + +## Replacements for X applications + +You can find a [list of useful resources on our wiki]. + +## Acknowledgements + +dwl began by extending the TinyWL example provided (CC0) by the sway/wlroots +developers. This was made possible in many cases by looking at how sway +accomplished something, then trying to do the same in as suckless a way as +possible. + +Many thanks to suckless.org and the dwm developers and community for the +inspiration, and to the various contributors to the project, including: + +- **Devin J. Pohly for creating and nurturing the fledgling project** +- Alexander Courtis for the XWayland implementation +- Guido Cella for the layer-shell protocol implementation, patch maintenance, + and for helping to keep the project running +- Stivvo for output management and fullscreen support, and patch maintenance + + +[Discord server]: https://discord.gg/jJxZnrGPWN +[#dwl on Libera Chat]: https://web.libera.chat/?channels=#dwl +[Wayland]: https://wayland.freedesktop.org/ +[wlroots]: https://gitlab.freedesktop.org/wlroots/wlroots/ +[wlroots-next branch]: https://codeberg.org/dwl/dwl/src/branch/wlroots-next +[patches repository]: https://codeberg.org/dwl/dwl-patches +[s6]: https://skarnet.org/software/s6/ +[anopa]: https://jjacky.com/anopa/ +[runit]: http://smarden.org/runit/faq.html#userservices +[dinit]: https://davmac.org/projects/dinit/ +[`systemd --user`]: https://wiki.archlinux.org/title/Systemd/User +[wiki]: https://codeberg.org/dwl/dwl/wiki/Home#compatible-status-bars +[list of useful resources on our wiki]: + https://codeberg.org/dwl/dwl/wiki/Home#migrating-from-x diff --git a/client.h b/client.h new file mode 100644 index 0000000..f0e5445 --- /dev/null +++ b/client.h @@ -0,0 +1,396 @@ +/* + * Attempt to consolidate unavoidable suck into one file, away from dwl.c. This + * file is not meant to be pretty. We use a .h file with static inline + * functions instead of a separate .c module, or function pointers like sway, so + * that they will simply compile out if the chosen #defines leave them unused. + */ + +/* Leave these functions first; they're used in the others */ +static inline int +client_is_x11(Client *c) +{ +#ifdef XWAYLAND + return c->type == X11; +#endif + return 0; +} + +static inline struct wlr_surface * +client_surface(Client *c) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return c->surface.xwayland->surface; +#endif + return c->surface.xdg->surface; +} + +static inline int +toplevel_from_wlr_surface(struct wlr_surface *s, Client **pc, LayerSurface **pl) +{ + struct wlr_xdg_surface *xdg_surface, *tmp_xdg_surface; + struct wlr_surface *root_surface; + struct wlr_layer_surface_v1 *layer_surface; + Client *c = NULL; + LayerSurface *l = NULL; + int type = -1; +#ifdef XWAYLAND + struct wlr_xwayland_surface *xsurface; +#endif + + if (!s) + return -1; + root_surface = wlr_surface_get_root_surface(s); + +#ifdef XWAYLAND + if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(root_surface))) { + c = xsurface->data; + type = c->type; + goto end; + } +#endif + + if ((layer_surface = wlr_layer_surface_v1_try_from_wlr_surface(root_surface))) { + l = layer_surface->data; + type = LayerShell; + goto end; + } + + xdg_surface = wlr_xdg_surface_try_from_wlr_surface(root_surface); + while (xdg_surface) { + tmp_xdg_surface = NULL; + switch (xdg_surface->role) { + case WLR_XDG_SURFACE_ROLE_POPUP: + if (!xdg_surface->popup || !xdg_surface->popup->parent) + return -1; + + tmp_xdg_surface = wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent); + + if (!tmp_xdg_surface) + return toplevel_from_wlr_surface(xdg_surface->popup->parent, pc, pl); + + xdg_surface = tmp_xdg_surface; + break; + case WLR_XDG_SURFACE_ROLE_TOPLEVEL: + c = xdg_surface->data; + type = c->type; + goto end; + case WLR_XDG_SURFACE_ROLE_NONE: + return -1; + } + } + +end: + if (pl) + *pl = l; + if (pc) + *pc = c; + return type; +} + +/* The others */ +static inline void +client_activate_surface(struct wlr_surface *s, int activated) +{ + struct wlr_xdg_toplevel *toplevel; +#ifdef XWAYLAND + struct wlr_xwayland_surface *xsurface; + if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) { + wlr_xwayland_surface_activate(xsurface, activated); + return; + } +#endif + if ((toplevel = wlr_xdg_toplevel_try_from_wlr_surface(s))) + wlr_xdg_toplevel_set_activated(toplevel, activated); +} + +static inline uint32_t +client_set_bounds(Client *c, int32_t width, int32_t height) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return 0; +#endif + if (wl_resource_get_version(c->surface.xdg->toplevel->resource) >= + XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION && width >= 0 && height >= 0 + && (c->bounds.width != width || c->bounds.height != height)) { + c->bounds.width = width; + c->bounds.height = height; + return wlr_xdg_toplevel_set_bounds(c->surface.xdg->toplevel, width, height); + } + return 0; +} + +static inline const char * +client_get_appid(Client *c) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return c->surface.xwayland->class; +#endif + return c->surface.xdg->toplevel->app_id; +} + +static inline void +client_get_clip(Client *c, struct wlr_box *clip) +{ + struct wlr_box xdg_geom = {0}; + *clip = (struct wlr_box){ + .x = 0, + .y = 0, + .width = c->geom.width - c->bw, + .height = c->geom.height - c->bw, + }; + +#ifdef XWAYLAND + if (client_is_x11(c)) + return; +#endif + + wlr_xdg_surface_get_geometry(c->surface.xdg, &xdg_geom); + clip->x = xdg_geom.x; + clip->y = xdg_geom.y; +} + +static inline void +client_get_geometry(Client *c, struct wlr_box *geom) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) { + geom->x = c->surface.xwayland->x; + geom->y = c->surface.xwayland->y; + geom->width = c->surface.xwayland->width; + geom->height = c->surface.xwayland->height; + return; + } +#endif + wlr_xdg_surface_get_geometry(c->surface.xdg, geom); +} + +static inline Client * +client_get_parent(Client *c) +{ + Client *p = NULL; +#ifdef XWAYLAND + if (client_is_x11(c)) { + if (c->surface.xwayland->parent) + toplevel_from_wlr_surface(c->surface.xwayland->parent->surface, &p, NULL); + return p; + } +#endif + if (c->surface.xdg->toplevel->parent) + toplevel_from_wlr_surface(c->surface.xdg->toplevel->parent->base->surface, &p, NULL); + return p; +} + +static inline const char * +client_get_title(Client *c) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return c->surface.xwayland->title; +#endif + return c->surface.xdg->toplevel->title; +} + +static inline int +client_is_float_type(Client *c) +{ + struct wlr_xdg_toplevel *toplevel; + struct wlr_xdg_toplevel_state state; + +#ifdef XWAYLAND + if (client_is_x11(c)) { + struct wlr_xwayland_surface *surface = c->surface.xwayland; + xcb_size_hints_t *size_hints = surface->size_hints; + size_t i; + if (surface->modal) + return 1; + + for (i = 0; i < surface->window_type_len; i++) + if (surface->window_type[i] == netatom[NetWMWindowTypeDialog] + || surface->window_type[i] == netatom[NetWMWindowTypeSplash] + || surface->window_type[i] == netatom[NetWMWindowTypeToolbar] + || surface->window_type[i] == netatom[NetWMWindowTypeUtility]) + return 1; + + return size_hints && size_hints->min_width > 0 && size_hints->min_height > 0 + && (size_hints->max_width == size_hints->min_width + || size_hints->max_height == size_hints->min_height); + } +#endif + + toplevel = c->surface.xdg->toplevel; + state = toplevel->current; + return toplevel->parent || (state.min_width != 0 && state.min_height != 0 + && (state.min_width == state.max_width + || state.min_height == state.max_height)); +} + +static inline int +client_is_rendered_on_mon(Client *c, Monitor *m) +{ + /* This is needed for when you don't want to check formal assignment, + * but rather actual displaying of the pixels. + * Usually VISIBLEON suffices and is also faster. */ + struct wlr_surface_output *s; + int unused_lx, unused_ly; + if (!wlr_scene_node_coords(&c->scene->node, &unused_lx, &unused_ly)) + return 0; + wl_list_for_each(s, &client_surface(c)->current_outputs, link) + if (s->output == m->wlr_output) + return 1; + return 0; +} + +static inline int +client_is_stopped(Client *c) +{ + int pid; + siginfo_t in = {0}; +#ifdef XWAYLAND + if (client_is_x11(c)) + return 0; +#endif + + wl_client_get_credentials(c->surface.xdg->client->client, &pid, NULL, NULL); + if (waitid(P_PID, pid, &in, WNOHANG|WCONTINUED|WSTOPPED|WNOWAIT) < 0) { + /* This process is not our child process, while is very unluckely that + * it is stopped, in order to do not skip frames assume that it is. */ + if (errno == ECHILD) + return 1; + } else if (in.si_pid) { + if (in.si_code == CLD_STOPPED || in.si_code == CLD_TRAPPED) + return 1; + if (in.si_code == CLD_CONTINUED) + return 0; + } + + return 0; +} + +static inline int +client_is_unmanaged(Client *c) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return c->surface.xwayland->override_redirect; +#endif + return 0; +} + +static inline void +client_notify_enter(struct wlr_surface *s, struct wlr_keyboard *kb) +{ + if (kb) + wlr_seat_keyboard_notify_enter(seat, s, kb->keycodes, + kb->num_keycodes, &kb->modifiers); + else + wlr_seat_keyboard_notify_enter(seat, s, NULL, 0, NULL); +} + +static inline void +client_restack_surface(Client *c) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + wlr_xwayland_surface_restack(c->surface.xwayland, NULL, + XCB_STACK_MODE_ABOVE); +#endif + return; +} + +static inline void +client_send_close(Client *c) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) { + wlr_xwayland_surface_close(c->surface.xwayland); + return; + } +#endif + wlr_xdg_toplevel_send_close(c->surface.xdg->toplevel); +} + +static inline void +client_set_border_color(Client *c, const float color[static 4]) +{ + int i; + for (i = 0; i < 4; i++) + wlr_scene_rect_set_color(c->border[i], color); +} + +static inline void +client_set_fullscreen(Client *c, int fullscreen) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) { + wlr_xwayland_surface_set_fullscreen(c->surface.xwayland, fullscreen); + return; + } +#endif + wlr_xdg_toplevel_set_fullscreen(c->surface.xdg->toplevel, fullscreen); +} + +static inline uint32_t +client_set_size(Client *c, uint32_t width, uint32_t height) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) { + wlr_xwayland_surface_configure(c->surface.xwayland, + c->geom.x + c->bw, c->geom.y + c->bw, width, height); + return 0; + } +#endif + if ((int32_t)width == c->surface.xdg->toplevel->current.width + && (int32_t)height == c->surface.xdg->toplevel->current.height) + return 0; + return wlr_xdg_toplevel_set_size(c->surface.xdg->toplevel, (int32_t)width, (int32_t)height); +} + +static inline void +client_set_tiled(Client *c, uint32_t edges) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return; +#endif + if (wl_resource_get_version(c->surface.xdg->toplevel->resource) + >= XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION) { + wlr_xdg_toplevel_set_tiled(c->surface.xdg->toplevel, edges); + } else { + wlr_xdg_toplevel_set_maximized(c->surface.xdg->toplevel, edges != WLR_EDGE_NONE); + } +} + +static inline void +client_set_suspended(Client *c, int suspended) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return; +#endif + + wlr_xdg_toplevel_set_suspended(c->surface.xdg->toplevel, suspended); +} + +static inline int +client_wants_focus(Client *c) +{ +#ifdef XWAYLAND + return client_is_unmanaged(c) + && wlr_xwayland_or_surface_wants_focus(c->surface.xwayland) + && wlr_xwayland_icccm_input_model(c->surface.xwayland) != WLR_ICCCM_INPUT_MODEL_NONE; +#endif + return 0; +} + +static inline int +client_wants_fullscreen(Client *c) +{ +#ifdef XWAYLAND + if (client_is_x11(c)) + return c->surface.xwayland->fullscreen; +#endif + return c->surface.xdg->toplevel->requested.fullscreen; +} diff --git a/config.def.h b/config.def.h new file mode 100644 index 0000000..c39fda2 --- /dev/null +++ b/config.def.h @@ -0,0 +1,229 @@ +/* Taken from https://github.com/djpohly/dwl/issues/466 */ +#define COLOR(hex) { ((hex >> 24) & 0xFF) / 255.0f, \ + ((hex >> 16) & 0xFF) / 255.0f, \ + ((hex >> 8) & 0xFF) / 255.0f, \ + (hex & 0xFF) / 255.0f } +/* appearance */ +static const int sloppyfocus = 1; /* focus follows mouse */ +static const int bypass_surface_visibility = 0; /* 1 means idle inhibitors will disable idle tracking even if it's surface isn't visible */ +static const unsigned int borderpx = 8; /* border pixel of windows */ +static const float rootcolor[] = COLOR(0x222222ff); +static const float bordercolor[] = COLOR(0x444444ff); +static const float focuscolor[] = COLOR(0x005577ff); +static const float urgentcolor[] = COLOR(0xff0000ff); +/* This conforms to the xdg-protocol. Set the alpha to zero to restore the old behavior */ +static const float fullscreen_bg[] = {0.1f, 0.1f, 0.1f, 1.0f}; /* You can also use glsl colors */ + +/* tagging - TAGCOUNT must be no greater than 31 */ +#define TAGCOUNT (9) + +/* logging */ +static int log_level = WLR_ERROR; + +/* NOTE: ALWAYS keep a rule declared even if you don't use rules (e.g leave at least one example) */ +static const Rule rules[] = { + /* app_id title tags mask isfloating monitor */ + /* examples: */ + { "Gimp_EXAMPLE", NULL, 0, 1, -1 }, /* Start on currently visible tags floating, not tiled */ + { "firefox_EXAMPLE", NULL, 1 << 8, 0, -1 }, /* Start on ONLY tag "9" */ +}; + +/* layout(s) */ +static const Layout layouts[] = { + /* symbol arrange function */ + { "[]=", tile }, + { "><>", NULL }, /* no layout function means floating behavior */ + { "[M]", monocle }, +}; + +/* monitors */ +/* (x=-1, y=-1) is reserved as an "autoconfigure" monitor position indicator + * WARNING: negative values other than (-1, -1) cause problems with Xwayland clients + * https://gitlab.freedesktop.org/xorg/xserver/-/issues/899 +*/ +/* NOTE: ALWAYS add a fallback rule, even if you are completely sure it won't be used */ +static const MonitorRule monrules[] = { + /* name mfact nmaster scale layout rotate/reflect x y */ + /* example of a HiDPI laptop monitor: + { "eDP-1", 0.5f, 1, 2, &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL, -1, -1 }, + */ + { "DP-1", 0.55f, 1, 1, &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL, 0, 0}, + { "DP-2", 0.55f, 1, 1, &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL, 0, 1440}, +}; + +/* keyboard */ +static const struct xkb_rule_names xkb_rules = { + /* can specify fields: rules, model, layout, variant, options */ + /* example: + .options = "ctrl:nocaps", + */ + .options = NULL, +}; + +static const int repeat_rate = 40; +static const int repeat_delay = 200; + +/* Trackpad */ +static const int tap_to_click = 1; +static const int tap_and_drag = 1; +static const int drag_lock = 1; +static const int natural_scrolling = 0; +static const int disable_while_typing = 1; +static const int left_handed = 0; +static const int middle_button_emulation = 0; +/* You can choose between: +LIBINPUT_CONFIG_SCROLL_NO_SCROLL +LIBINPUT_CONFIG_SCROLL_2FG +LIBINPUT_CONFIG_SCROLL_EDGE +LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN +*/ +static const enum libinput_config_scroll_method scroll_method = LIBINPUT_CONFIG_SCROLL_2FG; + +/* You can choose between: +LIBINPUT_CONFIG_CLICK_METHOD_NONE +LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS +LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER +*/ +static const enum libinput_config_click_method click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS; + +/* You can choose between: +LIBINPUT_CONFIG_SEND_EVENTS_ENABLED +LIBINPUT_CONFIG_SEND_EVENTS_DISABLED +LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE +*/ +static const uint32_t send_events_mode = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED; + +/* You can choose between: +LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT +LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE +*/ +static const enum libinput_config_accel_profile accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE; +static const double accel_speed = 0.0; + +/* You can choose between: +LIBINPUT_CONFIG_TAP_MAP_LRM -- 1/2/3 finger tap maps to left/right/middle +LIBINPUT_CONFIG_TAP_MAP_LMR -- 1/2/3 finger tap maps to left/middle/right +*/ +static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TAP_MAP_LRM; + +/* If you want to use the windows key for MODKEY, use WLR_MODIFIER_LOGO */ +//#define MODKEY WLR_MODIFIER_ALT +#define MODKEY WLR_MODIFIER_LOGO + +#define TAGKEYS(KEY,SKEY,TAG) \ + { MODKEY, KEY, view, {.ui = 1 << TAG} }, \ + { MODKEY|WLR_MODIFIER_CTRL, KEY, toggleview, {.ui = 1 << TAG} }, \ + { MODKEY|WLR_MODIFIER_SHIFT, SKEY, tag, {.ui = 1 << TAG} }, \ + { MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT,SKEY,toggletag, {.ui = 1 << TAG} } + +/* helper for spawning shell commands in the pre dwm-5.0 fashion */ +#define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } } + +/* commands */ +static const char *termcmd[] = { "foot", NULL }; +static const char *menucmd[] = { "wmenu-run", NULL }; +static const char *browsercmd[] = { "browser", NULL }; + +// audio controls +static const char *volupcmd[] = { "volumectl", "up", NULL }; +static const char *voldowncmd[] = { "volumectl", "down", NULL }; +static const char *mutecmd[] = { "volumectl", "mute", NULL}; +static const char *audioswitchcmd[] = { "audioswitch", NULL }; + +// playerctl controls +static const char *playpausecmd[] = { "mpc", "toggle", NULL }; +static const char *nextcmd[] = { "mpc", "next", NULL }; +static const char *prevcmd[] = { "mpc", "prev", NULL }; + +// screenshots +static const char *screenshot_fullscreencmd[] = { "screenshot", NULL }; +static const char *screenshot_selectioncmd[] = { "screenshot", "1", NULL }; + +// brightness controls +static const char *brightnessupcmd[] = { "brightnessctl", "set", "5%+", NULL }; +static const char *brightnessdowncmd[] = { "brightnessctl", "set", "5%-", NULL }; + +// recording +static const char *record_cmd[] = { "record", NULL }; +static const char *record_nomiccmd[] = { "record", "1", NULL }; + +// displays (titanium) +//static const char *displayctlcmd[] = { "displayctl", NULL }; + +// misc +static const char *managercmd[] = { "manager", NULL }; +static const char *autoclickcmd[] = { "autoclick", NULL }; +static const char *calculatorcmd[] = { "calculator", NULL }; +static const char *opencmd[] = { "open", NULL }; +static const char *bgselectcmd[] = { "bgselect", NULL }; + +static const Key keys[] = { + + // DWL KEYS + /* Note that Shift changes certain key codes: c -> C, 2 -> at, etc. */ + /* modifier key function argument */ + { MODKEY, XKB_KEY_p, spawn, {.v = menucmd} }, + { MODKEY, XKB_KEY_q, spawn, {.v = termcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_B, spawn, {.v = browsercmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_K, spawn, {.v = volupcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_J, spawn, {.v = voldowncmd } }, + { MODKEY, XKB_KEY_p, spawn, {.v = playpausecmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_H, spawn, {.v = prevcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_L, spawn, {.v = nextcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_M, spawn, {.v = managercmd } }, + { MODKEY, XKB_KEY_c, spawn, {.v = autoclickcmd } }, + { MODKEY, XKB_KEY_equal, spawn, {.v = calculatorcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_O, spawn, {.v = opencmd } }, + { MODKEY|WLR_MODIFIER_CTRL, XKB_KEY_s, spawn, {.v = screenshot_selectioncmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_S, spawn, {.v = screenshot_fullscreencmd } }, + { MODKEY, XKB_KEY_r, spawn, {.v = record_cmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_R, spawn, {.v = record_nomiccmd } }, + { MODKEY|WLR_MODIFIER_CTRL, XKB_KEY_b, spawn, {.v = bgselectcmd } }, + { MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT, XKB_KEY_a, spawn, {.v = audioswitchcmd } }, + { MODKEY, XKB_KEY_j, focusstack, {.i = +1} }, + { MODKEY, XKB_KEY_k, focusstack, {.i = -1} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_I, incnmaster, {.i = +1} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_D, incnmaster, {.i = -1} }, + { MODKEY, XKB_KEY_h, setmfact, {.f = -0.05f} }, + { MODKEY, XKB_KEY_l, setmfact, {.f = +0.05f} }, + { MODKEY, XKB_KEY_Return, zoom, {0} }, + { MODKEY, XKB_KEY_Tab, view, {0} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_C, killclient, {0} }, + { MODKEY, XKB_KEY_t, setlayout, {.v = &layouts[0]} }, + { MODKEY, XKB_KEY_f, setlayout, {.v = &layouts[1]} }, + { MODKEY, XKB_KEY_m, setlayout, {.v = &layouts[2]} }, + { MODKEY, XKB_KEY_space, setlayout, {0} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space, togglefloating, {0} }, + { MODKEY, XKB_KEY_e, togglefullscreen, {0} }, + { MODKEY, XKB_KEY_0, view, {.ui = ~0} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright, tag, {.ui = ~0} }, + { MODKEY, XKB_KEY_comma, focusmon, {.i = WLR_DIRECTION_UP} }, + { MODKEY, XKB_KEY_period, focusmon, {.i = WLR_DIRECTION_DOWN} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_less, tagmon, {.i = WLR_DIRECTION_UP} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_greater, tagmon, {.i = WLR_DIRECTION_DOWN} }, + TAGKEYS( XKB_KEY_1, XKB_KEY_exclam, 0), + TAGKEYS( XKB_KEY_2, XKB_KEY_at, 1), + TAGKEYS( XKB_KEY_3, XKB_KEY_numbersign, 2), + TAGKEYS( XKB_KEY_4, XKB_KEY_dollar, 3), + TAGKEYS( XKB_KEY_5, XKB_KEY_percent, 4), + TAGKEYS( XKB_KEY_6, XKB_KEY_asciicircum, 5), + TAGKEYS( XKB_KEY_7, XKB_KEY_ampersand, 6), + TAGKEYS( XKB_KEY_8, XKB_KEY_asterisk, 7), + TAGKEYS( XKB_KEY_9, XKB_KEY_parenleft, 8), + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Q, quit, {0} }, + + /* Ctrl-Alt-Backspace and Ctrl-Alt-Fx used to be handled by X server */ + { WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_Terminate_Server, quit, {0} }, + /* Ctrl-Alt-Fx is used to switch to another VT, if you don't know what a VT is + * do not remove them. + */ +#define CHVT(n) { WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_XF86Switch_VT_##n, chvt, {.ui = (n)} } + CHVT(1), CHVT(2), CHVT(3), CHVT(4), CHVT(5), CHVT(6), + CHVT(7), CHVT(8), CHVT(9), CHVT(10), CHVT(11), CHVT(12), +}; + +static const Button buttons[] = { + { MODKEY, BTN_LEFT, moveresize, {.ui = CurMove} }, + { MODKEY, BTN_MIDDLE, togglefloating, {0} }, + { MODKEY, BTN_RIGHT, moveresize, {.ui = CurResize} }, +}; diff --git a/config.h b/config.h new file mode 100644 index 0000000..c39fda2 --- /dev/null +++ b/config.h @@ -0,0 +1,229 @@ +/* Taken from https://github.com/djpohly/dwl/issues/466 */ +#define COLOR(hex) { ((hex >> 24) & 0xFF) / 255.0f, \ + ((hex >> 16) & 0xFF) / 255.0f, \ + ((hex >> 8) & 0xFF) / 255.0f, \ + (hex & 0xFF) / 255.0f } +/* appearance */ +static const int sloppyfocus = 1; /* focus follows mouse */ +static const int bypass_surface_visibility = 0; /* 1 means idle inhibitors will disable idle tracking even if it's surface isn't visible */ +static const unsigned int borderpx = 8; /* border pixel of windows */ +static const float rootcolor[] = COLOR(0x222222ff); +static const float bordercolor[] = COLOR(0x444444ff); +static const float focuscolor[] = COLOR(0x005577ff); +static const float urgentcolor[] = COLOR(0xff0000ff); +/* This conforms to the xdg-protocol. Set the alpha to zero to restore the old behavior */ +static const float fullscreen_bg[] = {0.1f, 0.1f, 0.1f, 1.0f}; /* You can also use glsl colors */ + +/* tagging - TAGCOUNT must be no greater than 31 */ +#define TAGCOUNT (9) + +/* logging */ +static int log_level = WLR_ERROR; + +/* NOTE: ALWAYS keep a rule declared even if you don't use rules (e.g leave at least one example) */ +static const Rule rules[] = { + /* app_id title tags mask isfloating monitor */ + /* examples: */ + { "Gimp_EXAMPLE", NULL, 0, 1, -1 }, /* Start on currently visible tags floating, not tiled */ + { "firefox_EXAMPLE", NULL, 1 << 8, 0, -1 }, /* Start on ONLY tag "9" */ +}; + +/* layout(s) */ +static const Layout layouts[] = { + /* symbol arrange function */ + { "[]=", tile }, + { "><>", NULL }, /* no layout function means floating behavior */ + { "[M]", monocle }, +}; + +/* monitors */ +/* (x=-1, y=-1) is reserved as an "autoconfigure" monitor position indicator + * WARNING: negative values other than (-1, -1) cause problems with Xwayland clients + * https://gitlab.freedesktop.org/xorg/xserver/-/issues/899 +*/ +/* NOTE: ALWAYS add a fallback rule, even if you are completely sure it won't be used */ +static const MonitorRule monrules[] = { + /* name mfact nmaster scale layout rotate/reflect x y */ + /* example of a HiDPI laptop monitor: + { "eDP-1", 0.5f, 1, 2, &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL, -1, -1 }, + */ + { "DP-1", 0.55f, 1, 1, &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL, 0, 0}, + { "DP-2", 0.55f, 1, 1, &layouts[0], WL_OUTPUT_TRANSFORM_NORMAL, 0, 1440}, +}; + +/* keyboard */ +static const struct xkb_rule_names xkb_rules = { + /* can specify fields: rules, model, layout, variant, options */ + /* example: + .options = "ctrl:nocaps", + */ + .options = NULL, +}; + +static const int repeat_rate = 40; +static const int repeat_delay = 200; + +/* Trackpad */ +static const int tap_to_click = 1; +static const int tap_and_drag = 1; +static const int drag_lock = 1; +static const int natural_scrolling = 0; +static const int disable_while_typing = 1; +static const int left_handed = 0; +static const int middle_button_emulation = 0; +/* You can choose between: +LIBINPUT_CONFIG_SCROLL_NO_SCROLL +LIBINPUT_CONFIG_SCROLL_2FG +LIBINPUT_CONFIG_SCROLL_EDGE +LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN +*/ +static const enum libinput_config_scroll_method scroll_method = LIBINPUT_CONFIG_SCROLL_2FG; + +/* You can choose between: +LIBINPUT_CONFIG_CLICK_METHOD_NONE +LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS +LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER +*/ +static const enum libinput_config_click_method click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS; + +/* You can choose between: +LIBINPUT_CONFIG_SEND_EVENTS_ENABLED +LIBINPUT_CONFIG_SEND_EVENTS_DISABLED +LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE +*/ +static const uint32_t send_events_mode = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED; + +/* You can choose between: +LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT +LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE +*/ +static const enum libinput_config_accel_profile accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE; +static const double accel_speed = 0.0; + +/* You can choose between: +LIBINPUT_CONFIG_TAP_MAP_LRM -- 1/2/3 finger tap maps to left/right/middle +LIBINPUT_CONFIG_TAP_MAP_LMR -- 1/2/3 finger tap maps to left/middle/right +*/ +static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TAP_MAP_LRM; + +/* If you want to use the windows key for MODKEY, use WLR_MODIFIER_LOGO */ +//#define MODKEY WLR_MODIFIER_ALT +#define MODKEY WLR_MODIFIER_LOGO + +#define TAGKEYS(KEY,SKEY,TAG) \ + { MODKEY, KEY, view, {.ui = 1 << TAG} }, \ + { MODKEY|WLR_MODIFIER_CTRL, KEY, toggleview, {.ui = 1 << TAG} }, \ + { MODKEY|WLR_MODIFIER_SHIFT, SKEY, tag, {.ui = 1 << TAG} }, \ + { MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT,SKEY,toggletag, {.ui = 1 << TAG} } + +/* helper for spawning shell commands in the pre dwm-5.0 fashion */ +#define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } } + +/* commands */ +static const char *termcmd[] = { "foot", NULL }; +static const char *menucmd[] = { "wmenu-run", NULL }; +static const char *browsercmd[] = { "browser", NULL }; + +// audio controls +static const char *volupcmd[] = { "volumectl", "up", NULL }; +static const char *voldowncmd[] = { "volumectl", "down", NULL }; +static const char *mutecmd[] = { "volumectl", "mute", NULL}; +static const char *audioswitchcmd[] = { "audioswitch", NULL }; + +// playerctl controls +static const char *playpausecmd[] = { "mpc", "toggle", NULL }; +static const char *nextcmd[] = { "mpc", "next", NULL }; +static const char *prevcmd[] = { "mpc", "prev", NULL }; + +// screenshots +static const char *screenshot_fullscreencmd[] = { "screenshot", NULL }; +static const char *screenshot_selectioncmd[] = { "screenshot", "1", NULL }; + +// brightness controls +static const char *brightnessupcmd[] = { "brightnessctl", "set", "5%+", NULL }; +static const char *brightnessdowncmd[] = { "brightnessctl", "set", "5%-", NULL }; + +// recording +static const char *record_cmd[] = { "record", NULL }; +static const char *record_nomiccmd[] = { "record", "1", NULL }; + +// displays (titanium) +//static const char *displayctlcmd[] = { "displayctl", NULL }; + +// misc +static const char *managercmd[] = { "manager", NULL }; +static const char *autoclickcmd[] = { "autoclick", NULL }; +static const char *calculatorcmd[] = { "calculator", NULL }; +static const char *opencmd[] = { "open", NULL }; +static const char *bgselectcmd[] = { "bgselect", NULL }; + +static const Key keys[] = { + + // DWL KEYS + /* Note that Shift changes certain key codes: c -> C, 2 -> at, etc. */ + /* modifier key function argument */ + { MODKEY, XKB_KEY_p, spawn, {.v = menucmd} }, + { MODKEY, XKB_KEY_q, spawn, {.v = termcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_B, spawn, {.v = browsercmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_K, spawn, {.v = volupcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_J, spawn, {.v = voldowncmd } }, + { MODKEY, XKB_KEY_p, spawn, {.v = playpausecmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_H, spawn, {.v = prevcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_L, spawn, {.v = nextcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_M, spawn, {.v = managercmd } }, + { MODKEY, XKB_KEY_c, spawn, {.v = autoclickcmd } }, + { MODKEY, XKB_KEY_equal, spawn, {.v = calculatorcmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_O, spawn, {.v = opencmd } }, + { MODKEY|WLR_MODIFIER_CTRL, XKB_KEY_s, spawn, {.v = screenshot_selectioncmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_S, spawn, {.v = screenshot_fullscreencmd } }, + { MODKEY, XKB_KEY_r, spawn, {.v = record_cmd } }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_R, spawn, {.v = record_nomiccmd } }, + { MODKEY|WLR_MODIFIER_CTRL, XKB_KEY_b, spawn, {.v = bgselectcmd } }, + { MODKEY|WLR_MODIFIER_CTRL|WLR_MODIFIER_SHIFT, XKB_KEY_a, spawn, {.v = audioswitchcmd } }, + { MODKEY, XKB_KEY_j, focusstack, {.i = +1} }, + { MODKEY, XKB_KEY_k, focusstack, {.i = -1} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_I, incnmaster, {.i = +1} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_D, incnmaster, {.i = -1} }, + { MODKEY, XKB_KEY_h, setmfact, {.f = -0.05f} }, + { MODKEY, XKB_KEY_l, setmfact, {.f = +0.05f} }, + { MODKEY, XKB_KEY_Return, zoom, {0} }, + { MODKEY, XKB_KEY_Tab, view, {0} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_C, killclient, {0} }, + { MODKEY, XKB_KEY_t, setlayout, {.v = &layouts[0]} }, + { MODKEY, XKB_KEY_f, setlayout, {.v = &layouts[1]} }, + { MODKEY, XKB_KEY_m, setlayout, {.v = &layouts[2]} }, + { MODKEY, XKB_KEY_space, setlayout, {0} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space, togglefloating, {0} }, + { MODKEY, XKB_KEY_e, togglefullscreen, {0} }, + { MODKEY, XKB_KEY_0, view, {.ui = ~0} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright, tag, {.ui = ~0} }, + { MODKEY, XKB_KEY_comma, focusmon, {.i = WLR_DIRECTION_UP} }, + { MODKEY, XKB_KEY_period, focusmon, {.i = WLR_DIRECTION_DOWN} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_less, tagmon, {.i = WLR_DIRECTION_UP} }, + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_greater, tagmon, {.i = WLR_DIRECTION_DOWN} }, + TAGKEYS( XKB_KEY_1, XKB_KEY_exclam, 0), + TAGKEYS( XKB_KEY_2, XKB_KEY_at, 1), + TAGKEYS( XKB_KEY_3, XKB_KEY_numbersign, 2), + TAGKEYS( XKB_KEY_4, XKB_KEY_dollar, 3), + TAGKEYS( XKB_KEY_5, XKB_KEY_percent, 4), + TAGKEYS( XKB_KEY_6, XKB_KEY_asciicircum, 5), + TAGKEYS( XKB_KEY_7, XKB_KEY_ampersand, 6), + TAGKEYS( XKB_KEY_8, XKB_KEY_asterisk, 7), + TAGKEYS( XKB_KEY_9, XKB_KEY_parenleft, 8), + { MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Q, quit, {0} }, + + /* Ctrl-Alt-Backspace and Ctrl-Alt-Fx used to be handled by X server */ + { WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_Terminate_Server, quit, {0} }, + /* Ctrl-Alt-Fx is used to switch to another VT, if you don't know what a VT is + * do not remove them. + */ +#define CHVT(n) { WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_XF86Switch_VT_##n, chvt, {.ui = (n)} } + CHVT(1), CHVT(2), CHVT(3), CHVT(4), CHVT(5), CHVT(6), + CHVT(7), CHVT(8), CHVT(9), CHVT(10), CHVT(11), CHVT(12), +}; + +static const Button buttons[] = { + { MODKEY, BTN_LEFT, moveresize, {.ui = CurMove} }, + { MODKEY, BTN_MIDDLE, togglefloating, {0} }, + { MODKEY, BTN_RIGHT, moveresize, {.ui = CurResize} }, +}; diff --git a/config.mk b/config.mk new file mode 100644 index 0000000..6fb4fb3 --- /dev/null +++ b/config.mk @@ -0,0 +1,17 @@ +_VERSION = 0.6 +VERSION = `git describe --tags --dirty 2>/dev/null || echo $(_VERSION)` + +PKG_CONFIG = pkg-config + +# paths +PREFIX = /usr/local +MANDIR = $(PREFIX)/share/man +DATADIR = $(PREFIX)/share + +XWAYLAND = +XLIBS = +# Uncomment to build XWayland support +#XWAYLAND = -DXWAYLAND +#XLIBS = xcb xcb-icccm + +CC = gcc diff --git a/cursor-shape-v1-protocol.h b/cursor-shape-v1-protocol.h new file mode 100644 index 0000000..08714b3 --- /dev/null +++ b/cursor-shape-v1-protocol.h @@ -0,0 +1,507 @@ +/* Generated by wayland-scanner 1.25.0 */ + +#ifndef CURSOR_SHAPE_V1_SERVER_PROTOCOL_H +#define CURSOR_SHAPE_V1_SERVER_PROTOCOL_H + +#include +#include +#include "wayland-server.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct wl_client; +struct wl_resource; + +/** + * @page page_cursor_shape_v1 The cursor_shape_v1 protocol + * @section page_ifaces_cursor_shape_v1 Interfaces + * - @subpage page_iface_wp_cursor_shape_manager_v1 - cursor shape manager + * - @subpage page_iface_wp_cursor_shape_device_v1 - cursor shape for a device + * @section page_copyright_cursor_shape_v1 Copyright + * 
+ *
+ * Copyright 2018 The Chromium Authors
+ * Copyright 2023 Simon Ser
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */ +struct wl_pointer; +struct wp_cursor_shape_device_v1; +struct wp_cursor_shape_manager_v1; +struct zwp_tablet_tool_v2; + +#ifndef WP_CURSOR_SHAPE_MANAGER_V1_INTERFACE +#define WP_CURSOR_SHAPE_MANAGER_V1_INTERFACE +/** + * @page page_iface_wp_cursor_shape_manager_v1 wp_cursor_shape_manager_v1 + * @section page_iface_wp_cursor_shape_manager_v1_desc Description + * + * This global offers an alternative, optional way to set cursor images. This + * new way uses enumerated cursors instead of a wl_surface like + * wl_pointer.set_cursor does. + * + * Warning! The protocol described in this file is currently in the testing + * phase. Backward compatible changes may be added together with the + * corresponding interface version bump. Backward incompatible changes can + * only be done by creating a new major version of the extension. + * @section page_iface_wp_cursor_shape_manager_v1_api API + * See @ref iface_wp_cursor_shape_manager_v1. + */ +/** + * @defgroup iface_wp_cursor_shape_manager_v1 The wp_cursor_shape_manager_v1 interface + * + * This global offers an alternative, optional way to set cursor images. This + * new way uses enumerated cursors instead of a wl_surface like + * wl_pointer.set_cursor does. + * + * Warning! The protocol described in this file is currently in the testing + * phase. Backward compatible changes may be added together with the + * corresponding interface version bump. Backward incompatible changes can + * only be done by creating a new major version of the extension. + */ +extern const struct wl_interface wp_cursor_shape_manager_v1_interface; +#endif +#ifndef WP_CURSOR_SHAPE_DEVICE_V1_INTERFACE +#define WP_CURSOR_SHAPE_DEVICE_V1_INTERFACE +/** + * @page page_iface_wp_cursor_shape_device_v1 wp_cursor_shape_device_v1 + * @section page_iface_wp_cursor_shape_device_v1_desc Description + * + * This interface allows clients to set the cursor shape. + * @section page_iface_wp_cursor_shape_device_v1_api API + * See @ref iface_wp_cursor_shape_device_v1. + */ +/** + * @defgroup iface_wp_cursor_shape_device_v1 The wp_cursor_shape_device_v1 interface + * + * This interface allows clients to set the cursor shape. + */ +extern const struct wl_interface wp_cursor_shape_device_v1_interface; +#endif + +/** + * @ingroup iface_wp_cursor_shape_manager_v1 + * @struct wp_cursor_shape_manager_v1_interface + */ +struct wp_cursor_shape_manager_v1_interface { + /** + * destroy the manager + * + * Destroy the cursor shape manager. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * manage the cursor shape of a pointer device + * + * Obtain a wp_cursor_shape_device_v1 for a wl_pointer object. + * + * When the pointer capability is removed from the wl_seat, the + * wp_cursor_shape_device_v1 object becomes inert. + */ + void (*get_pointer)(struct wl_client *client, + struct wl_resource *resource, + uint32_t cursor_shape_device, + struct wl_resource *pointer); + /** + * manage the cursor shape of a tablet tool device + * + * Obtain a wp_cursor_shape_device_v1 for a zwp_tablet_tool_v2 + * object. + * + * When the zwp_tablet_tool_v2 is removed, the + * wp_cursor_shape_device_v1 object becomes inert. + */ + void (*get_tablet_tool_v2)(struct wl_client *client, + struct wl_resource *resource, + uint32_t cursor_shape_device, + struct wl_resource *tablet_tool); +}; + + +/** + * @ingroup iface_wp_cursor_shape_manager_v1 + */ +#define WP_CURSOR_SHAPE_MANAGER_V1_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_wp_cursor_shape_manager_v1 + */ +#define WP_CURSOR_SHAPE_MANAGER_V1_GET_POINTER_SINCE_VERSION 1 +/** + * @ingroup iface_wp_cursor_shape_manager_v1 + */ +#define WP_CURSOR_SHAPE_MANAGER_V1_GET_TABLET_TOOL_V2_SINCE_VERSION 1 + +#ifndef WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ENUM +#define WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ENUM +/** + * @ingroup iface_wp_cursor_shape_device_v1 + * cursor shapes + * + * This enum describes cursor shapes. + * + * The names are taken from the CSS W3C specification: + * https://w3c.github.io/csswg-drafts/css-ui/#cursor + * with a few additions. + * + * Note that there are some groups of cursor shapes that are related: + * The first group is drag-and-drop cursors which are used to indicate + * the selected action during dnd operations. The second group is resize + * cursors which are used to indicate resizing and moving possibilities + * on window borders. It is recommended that the shapes in these groups + * should use visually compatible images and metaphors. + */ +enum wp_cursor_shape_device_v1_shape { + /** + * default cursor + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT = 1, + /** + * a context menu is available for the object under the cursor + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CONTEXT_MENU = 2, + /** + * help is available for the object under the cursor + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_HELP = 3, + /** + * pointer that indicates a link or another interactive element + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER = 4, + /** + * progress indicator + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_PROGRESS = 5, + /** + * program is busy, user should wait + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_WAIT = 6, + /** + * a cell or set of cells may be selected + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CELL = 7, + /** + * simple crosshair + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR = 8, + /** + * text may be selected + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT = 9, + /** + * vertical text may be selected + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_VERTICAL_TEXT = 10, + /** + * drag-and-drop: alias of/shortcut to something is to be created + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ALIAS = 11, + /** + * drag-and-drop: something is to be copied + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_COPY = 12, + /** + * drag-and-drop: something is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE = 13, + /** + * drag-and-drop: the dragged item cannot be dropped at the current cursor location + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NO_DROP = 14, + /** + * drag-and-drop: the requested action will not be carried out + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NOT_ALLOWED = 15, + /** + * drag-and-drop: something can be grabbed + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRAB = 16, + /** + * drag-and-drop: something is being grabbed + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRABBING = 17, + /** + * resizing: the east border is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_E_RESIZE = 18, + /** + * resizing: the north border is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_N_RESIZE = 19, + /** + * resizing: the north-east corner is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NE_RESIZE = 20, + /** + * resizing: the north-west corner is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NW_RESIZE = 21, + /** + * resizing: the south border is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_S_RESIZE = 22, + /** + * resizing: the south-east corner is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SE_RESIZE = 23, + /** + * resizing: the south-west corner is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SW_RESIZE = 24, + /** + * resizing: the west border is to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_W_RESIZE = 25, + /** + * resizing: the east and west borders are to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE = 26, + /** + * resizing: the north and south borders are to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE = 27, + /** + * resizing: the north-east and south-west corners are to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NESW_RESIZE = 28, + /** + * resizing: the north-west and south-east corners are to be moved + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NWSE_RESIZE = 29, + /** + * resizing: that the item/column can be resized horizontally + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_COL_RESIZE = 30, + /** + * resizing: that the item/row can be resized vertically + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ROW_RESIZE = 31, + /** + * something can be scrolled in any direction + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ALL_SCROLL = 32, + /** + * something can be zoomed in + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ZOOM_IN = 33, + /** + * something can be zoomed out + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ZOOM_OUT = 34, + /** + * drag-and-drop: the user will select which action will be carried out (non-css value) + * @since 2 + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DND_ASK = 35, + /** + * resizing: something can be moved or resized in any direction (non-css value) + * @since 2 + */ + WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ALL_RESIZE = 36, +}; +/** + * @ingroup iface_wp_cursor_shape_device_v1 + */ +#define WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DND_ASK_SINCE_VERSION 2 +/** + * @ingroup iface_wp_cursor_shape_device_v1 + */ +#define WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ALL_RESIZE_SINCE_VERSION 2 +#endif /* WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ENUM */ + +#ifndef WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ENUM_IS_VALID +#define WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ENUM_IS_VALID +/** + * @ingroup iface_wp_cursor_shape_device_v1 + * Validate a wp_cursor_shape_device_v1 shape value. + * + * @return true on success, false on error. + * @ref wp_cursor_shape_device_v1_shape + */ +static inline bool +wp_cursor_shape_device_v1_shape_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CONTEXT_MENU: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_HELP: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_PROGRESS: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_WAIT: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CELL: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_VERTICAL_TEXT: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ALIAS: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_COPY: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NO_DROP: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NOT_ALLOWED: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRAB: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRABBING: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_E_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_N_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NE_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NW_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_S_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SE_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SW_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_W_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NESW_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NWSE_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_COL_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ROW_RESIZE: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ALL_SCROLL: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ZOOM_IN: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ZOOM_OUT: + return version >= 1; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DND_ASK: + return version >= 2; + case WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ALL_RESIZE: + return version >= 2; + default: + return false; + } +} +#endif /* WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ENUM_IS_VALID */ + +#ifndef WP_CURSOR_SHAPE_DEVICE_V1_ERROR_ENUM +#define WP_CURSOR_SHAPE_DEVICE_V1_ERROR_ENUM +enum wp_cursor_shape_device_v1_error { + /** + * the specified shape value is invalid + */ + WP_CURSOR_SHAPE_DEVICE_V1_ERROR_INVALID_SHAPE = 1, +}; +#endif /* WP_CURSOR_SHAPE_DEVICE_V1_ERROR_ENUM */ + +#ifndef WP_CURSOR_SHAPE_DEVICE_V1_ERROR_ENUM_IS_VALID +#define WP_CURSOR_SHAPE_DEVICE_V1_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_wp_cursor_shape_device_v1 + * Validate a wp_cursor_shape_device_v1 error value. + * + * @return true on success, false on error. + * @ref wp_cursor_shape_device_v1_error + */ +static inline bool +wp_cursor_shape_device_v1_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case WP_CURSOR_SHAPE_DEVICE_V1_ERROR_INVALID_SHAPE: + return version >= 1; + default: + return false; + } +} +#endif /* WP_CURSOR_SHAPE_DEVICE_V1_ERROR_ENUM_IS_VALID */ + +/** + * @ingroup iface_wp_cursor_shape_device_v1 + * @struct wp_cursor_shape_device_v1_interface + */ +struct wp_cursor_shape_device_v1_interface { + /** + * destroy the cursor shape device + * + * Destroy the cursor shape device. + * + * The device cursor shape remains unchanged. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * set device cursor to the shape + * + * Sets the device cursor to the specified shape. The compositor + * will change the cursor image based on the specified shape. + * + * The cursor actually changes only if the input device focus is + * one of the requesting client's surfaces. If any, the previous + * cursor image (surface or shape) is replaced. + * + * The "shape" argument must be a valid enum entry, otherwise the + * invalid_shape protocol error is raised. + * + * This is similar to the wl_pointer.set_cursor and + * zwp_tablet_tool_v2.set_cursor requests, but this request accepts + * a shape instead of contents in the form of a surface. Clients + * can mix set_cursor and set_shape requests. + * + * The serial parameter must match the latest wl_pointer.enter or + * zwp_tablet_tool_v2.proximity_in serial number sent to the + * client. Otherwise the request will be ignored. + * @param serial serial number of the enter event + */ + void (*set_shape)(struct wl_client *client, + struct wl_resource *resource, + uint32_t serial, + uint32_t shape); +}; + + +/** + * @ingroup iface_wp_cursor_shape_device_v1 + */ +#define WP_CURSOR_SHAPE_DEVICE_V1_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_wp_cursor_shape_device_v1 + */ +#define WP_CURSOR_SHAPE_DEVICE_V1_SET_SHAPE_SINCE_VERSION 1 + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/dwl.1 b/dwl.1 new file mode 100644 index 0000000..387bcc9 --- /dev/null +++ b/dwl.1 @@ -0,0 +1,158 @@ +.Dd January 8, 2021 +.Dt DWL 1 +.Os +.Sh NAME +.Nm dwl +.Nd dwm for Wayland +.Sh SYNOPSIS +.Nm +.Op Fl v +.Op Fl d +.Op Fl s Ar startup command +.Sh DESCRIPTION +.Nm +is a Wayland compositor based on wlroots. +It is intended to fill the same space in the Wayland world that +.Nm dwm +does for X11. +.Pp +When given the +.Fl v +option, +.Nm +writes its name and version to standard error and exits unsuccessfully. +.Pp +When given the +.Fl d +option, +.Nm +enables full wlroots logging, including debug information. +.Pp +When given the +.Fl s +option, +.Nm +starts a shell process running +.Ar command +when starting. +When stopping, it sends +.Dv SIGTERM +to the child process and waits for it to exit. +.Pp +Users are encouraged to customize +.Nm +by editing the sources, in particular +.Pa config.h . +The default key bindings are as follows: +.Bl -tag -width 20n -offset indent -compact +.It Mod-[1-9] +Show only all windows with a tag. +.It Mod-Ctrl-[1-9] +Show all windows with a tag. +.It Mod-Shift-[1-9] +Move window to a single tag. +.It Mod-Ctrl-Shift-[1-9] +Toggle tag for window. +.It Mod-p +Spawn +.Nm wmenu-run . +.It Mod-Shift-Return +Spawn +.Nm foot . +.It Mod-[jk] +Move focus down/up the stack. +.It Mod-[id] +Increase/decrease number of windows in master area. +.It Mod-[hl] +Decrease/increase master area. +.It Mod-Return +Move window on top of stack or switch top of stack with second window. +.It Mod-Tab +Show only all windows with previous tag. +.It Mod-Shift-c +Close window. +.It Mod-t +Switch to tabbed layout. +.It Mod-f +Switch to floating layout. +.It Mod-m +Switch to monocle layout. +.It Mod-Space +Switch to previous layout. +.It Mod-Shift-Space +Toggle floating state of window. +.It Mod-e +Toggle fullscreen state of window. +.It Mod-0 +Show all windows. +.It Mod-Shift-0 +Set all tags for window. +.It Mod-, +Move focus to previous monitor. +.It Mod-. +Move focus to next monitor. +.It Mod-Shift-, +Move window to previous monitor. +.It Mod-Shift-. +Move window to next monitor. +.It Mod-Shift-q +Quit +.Nm . +.El +These might differ depending on your keyboard layout. +.Sh ENVIRONMENT +These environment variables are used by +.Nm : +.Bl -tag -width XDG_RUNTIME_DIR +.It Ev XDG_RUNTIME_DIR +A directory where temporary user files, such as the Wayland socket, +are stored. +.It Ev XDG_CONFIG_DIR +A directory containing configuration of various programs and +libraries, including libxkbcommon. +.It Ev DISPLAY , WAYLAND_DISPLAY , WAYLAND_SOCKET +Tell how to connect to an underlying X11 or Wayland server. +.It Ev WLR_* +Various variables specific to wlroots. +.It Ev XKB_* , XLOCALEDIR , XCOMPOSEFILE +Various variables specific to libxkbcommon. +.It Ev XCURSOR_PATH +List of directories to search for XCursor themes in. +.It Ev HOME +A directory where there are always dear files there for you. +Waiting for you to clean them up. +.El +.Pp +These are set by +.Nm : +.Bl -tag -width WAYLAND_DISPLAY +.It Ev WAYLAND_DISPLAY +Tell how to connect to +.Nm . +.It Ev DISPLAY +If using +.Nm Xwayland , +tell how to connect to the +.Nm Xwayland +server. +.El +.Sh EXAMPLES +Start +.Nm +with s6 in the background: +.Dl dwl -s 's6-svscan <&-' +.Sh SEE ALSO +.Xr foot 1 , +.Xr wmenu 1 , +.Xr dwm 1 , +.Xr xkeyboard-config 7 +.Sh CAVEATS +The child process's standard input is connected with a pipe to +.Nm . +If the child process neither reads from the pipe nor closes its +standard input, +.Nm +will freeze after a while due to it blocking when writing to the full +pipe buffer. +.Sh BUGS +All of them. diff --git a/dwl.c b/dwl.c new file mode 100644 index 0000000..145fd01 --- /dev/null +++ b/dwl.c @@ -0,0 +1,3159 @@ +/* + * See LICENSE file for copyright and license details. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef XWAYLAND +#include +#include +#include +#endif + +#include "util.h" + +/* macros */ +#define MAX(A, B) ((A) > (B) ? (A) : (B)) +#define MIN(A, B) ((A) < (B) ? (A) : (B)) +#define CLEANMASK(mask) (mask & ~WLR_MODIFIER_CAPS) +#define VISIBLEON(C, M) ((M) && (C)->mon == (M) && ((C)->tags & (M)->tagset[(M)->seltags])) +#define LENGTH(X) (sizeof X / sizeof X[0]) +#define END(A) ((A) + LENGTH(A)) +#define TAGMASK ((1u << TAGCOUNT) - 1) +#define LISTEN(E, L, H) wl_signal_add((E), ((L)->notify = (H), (L))) +#define LISTEN_STATIC(E, H) do { static struct wl_listener _l = {.notify = (H)}; wl_signal_add((E), &_l); } while (0) + +/* enums */ +enum { CurNormal, CurPressed, CurMove, CurResize }; /* cursor */ +enum { XDGShell, LayerShell, X11 }; /* client types */ +enum { LyrBg, LyrBottom, LyrTile, LyrFloat, LyrTop, LyrFS, LyrOverlay, LyrBlock, NUM_LAYERS }; /* scene layers */ +#ifdef XWAYLAND +enum { NetWMWindowTypeDialog, NetWMWindowTypeSplash, NetWMWindowTypeToolbar, + NetWMWindowTypeUtility, NetLast }; /* EWMH atoms */ +#endif + +typedef union { + int i; + uint32_t ui; + float f; + const void *v; +} Arg; + +typedef struct { + unsigned int mod; + unsigned int button; + void (*func)(const Arg *); + const Arg arg; +} Button; + +typedef struct Monitor Monitor; +typedef struct { + /* Must keep these three elements in this order */ + unsigned int type; /* XDGShell or X11* */ + struct wlr_box geom; /* layout-relative, includes border */ + Monitor *mon; + struct wlr_scene_tree *scene; + struct wlr_scene_rect *border[4]; /* top, bottom, left, right */ + struct wlr_scene_tree *scene_surface; + struct wl_list link; + struct wl_list flink; + union { + struct wlr_xdg_surface *xdg; + struct wlr_xwayland_surface *xwayland; + } surface; + struct wlr_xdg_toplevel_decoration_v1 *decoration; + struct wl_listener commit; + struct wl_listener map; + struct wl_listener maximize; + struct wl_listener unmap; + struct wl_listener destroy; + struct wl_listener set_title; + struct wl_listener fullscreen; + struct wl_listener set_decoration_mode; + struct wl_listener destroy_decoration; + struct wlr_box prev; /* layout-relative, includes border */ + struct wlr_box bounds; +#ifdef XWAYLAND + struct wl_listener activate; + struct wl_listener associate; + struct wl_listener dissociate; + struct wl_listener configure; + struct wl_listener set_hints; +#endif + unsigned int bw; + uint32_t tags; + int isfloating, isurgent, isfullscreen; + uint32_t resize; /* configure serial of a pending resize */ +} Client; + +typedef struct { + uint32_t mod; + xkb_keysym_t keysym; + void (*func)(const Arg *); + const Arg arg; +} Key; + +typedef struct { + struct wl_list link; + struct wlr_keyboard_group *wlr_group; + + int nsyms; + const xkb_keysym_t *keysyms; /* invalid if nsyms == 0 */ + uint32_t mods; /* invalid if nsyms == 0 */ + struct wl_event_source *key_repeat_source; + + struct wl_listener modifiers; + struct wl_listener key; + struct wl_listener destroy; +} KeyboardGroup; + +typedef struct { + /* Must keep these three elements in this order */ + unsigned int type; /* LayerShell */ + struct wlr_box geom; + Monitor *mon; + struct wlr_scene_tree *scene; + struct wlr_scene_tree *popups; + struct wlr_scene_layer_surface_v1 *scene_layer; + struct wl_list link; + int mapped; + struct wlr_layer_surface_v1 *layer_surface; + + struct wl_listener destroy; + struct wl_listener unmap; + struct wl_listener surface_commit; +} LayerSurface; + +typedef struct { + const char *symbol; + void (*arrange)(Monitor *); +} Layout; + +struct Monitor { + struct wl_list link; + struct wlr_output *wlr_output; + struct wlr_scene_output *scene_output; + struct wlr_scene_rect *fullscreen_bg; /* See createmon() for info */ + struct wl_listener frame; + struct wl_listener destroy; + struct wl_listener request_state; + struct wl_listener destroy_lock_surface; + struct wlr_session_lock_surface_v1 *lock_surface; + struct wlr_box m; /* monitor area, layout-relative */ + struct wlr_box w; /* window area, layout-relative */ + struct wl_list layers[4]; /* LayerSurface.link */ + const Layout *lt[2]; + unsigned int seltags; + unsigned int sellt; + uint32_t tagset[2]; + float mfact; + int gamma_lut_changed; + int nmaster; + char ltsymbol[16]; + int asleep; +}; + +typedef struct { + const char *name; + float mfact; + int nmaster; + float scale; + const Layout *lt; + enum wl_output_transform rr; + int x, y; +} MonitorRule; + +typedef struct { + struct wlr_pointer_constraint_v1 *constraint; + struct wl_listener destroy; +} PointerConstraint; + +typedef struct { + const char *id; + const char *title; + uint32_t tags; + int isfloating; + int monitor; +} Rule; + +typedef struct { + struct wlr_scene_tree *scene; + + struct wlr_session_lock_v1 *lock; + struct wl_listener new_surface; + struct wl_listener unlock; + struct wl_listener destroy; +} SessionLock; + +/* function declarations */ +static void applybounds(Client *c, struct wlr_box *bbox); +static void applyrules(Client *c); +static void arrange(Monitor *m); +static void arrangelayer(Monitor *m, struct wl_list *list, + struct wlr_box *usable_area, int exclusive); +static void arrangelayers(Monitor *m); +static void axisnotify(struct wl_listener *listener, void *data); +static void buttonpress(struct wl_listener *listener, void *data); +static void chvt(const Arg *arg); +static void checkidleinhibitor(struct wlr_surface *exclude); +static void cleanup(void); +static void cleanupmon(struct wl_listener *listener, void *data); +static void closemon(Monitor *m); +static void commitlayersurfacenotify(struct wl_listener *listener, void *data); +static void commitnotify(struct wl_listener *listener, void *data); +static void createdecoration(struct wl_listener *listener, void *data); +static void createidleinhibitor(struct wl_listener *listener, void *data); +static void createkeyboard(struct wlr_keyboard *keyboard); +static KeyboardGroup *createkeyboardgroup(void); +static void createlayersurface(struct wl_listener *listener, void *data); +static void createlocksurface(struct wl_listener *listener, void *data); +static void createmon(struct wl_listener *listener, void *data); +static void createnotify(struct wl_listener *listener, void *data); +static void createpointer(struct wlr_pointer *pointer); +static void createpointerconstraint(struct wl_listener *listener, void *data); +static void cursorconstrain(struct wlr_pointer_constraint_v1 *constraint); +static void cursorframe(struct wl_listener *listener, void *data); +static void cursorwarptohint(void); +static void destroydecoration(struct wl_listener *listener, void *data); +static void destroydragicon(struct wl_listener *listener, void *data); +static void destroyidleinhibitor(struct wl_listener *listener, void *data); +static void destroylayersurfacenotify(struct wl_listener *listener, void *data); +static void destroylock(SessionLock *lock, int unlocked); +static void destroylocksurface(struct wl_listener *listener, void *data); +static void destroynotify(struct wl_listener *listener, void *data); +static void destroypointerconstraint(struct wl_listener *listener, void *data); +static void destroysessionlock(struct wl_listener *listener, void *data); +static void destroysessionmgr(struct wl_listener *listener, void *data); +static void destroykeyboardgroup(struct wl_listener *listener, void *data); +static Monitor *dirtomon(enum wlr_direction dir); +static void focusclient(Client *c, int lift); +static void focusmon(const Arg *arg); +static void focusstack(const Arg *arg); +static Client *focustop(Monitor *m); +static void fullscreennotify(struct wl_listener *listener, void *data); +static void handlesig(int signo); +static void incnmaster(const Arg *arg); +static void inputdevice(struct wl_listener *listener, void *data); +static int keybinding(uint32_t mods, xkb_keysym_t sym); +static void keypress(struct wl_listener *listener, void *data); +static void keypressmod(struct wl_listener *listener, void *data); +static int keyrepeat(void *data); +static void killclient(const Arg *arg); +static void locksession(struct wl_listener *listener, void *data); +static void mapnotify(struct wl_listener *listener, void *data); +static void maximizenotify(struct wl_listener *listener, void *data); +static void monocle(Monitor *m); +static void motionabsolute(struct wl_listener *listener, void *data); +static void motionnotify(uint32_t time, struct wlr_input_device *device, double sx, + double sy, double sx_unaccel, double sy_unaccel); +static void motionrelative(struct wl_listener *listener, void *data); +static void moveresize(const Arg *arg); +static void outputmgrapply(struct wl_listener *listener, void *data); +static void outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test); +static void outputmgrtest(struct wl_listener *listener, void *data); +static void pointerfocus(Client *c, struct wlr_surface *surface, + double sx, double sy, uint32_t time); +static void printstatus(void); +static void powermgrsetmode(struct wl_listener *listener, void *data); +static void quit(const Arg *arg); +static void rendermon(struct wl_listener *listener, void *data); +static void requestdecorationmode(struct wl_listener *listener, void *data); +static void requeststartdrag(struct wl_listener *listener, void *data); +static void requestmonstate(struct wl_listener *listener, void *data); +static void resize(Client *c, struct wlr_box geo, int interact); +static void run(char *startup_cmd); +static void setcursor(struct wl_listener *listener, void *data); +static void setcursorshape(struct wl_listener *listener, void *data); +static void setfloating(Client *c, int floating); +static void setfullscreen(Client *c, int fullscreen); +static void setgamma(struct wl_listener *listener, void *data); +static void setlayout(const Arg *arg); +static void setmfact(const Arg *arg); +static void setmon(Client *c, Monitor *m, uint32_t newtags); +static void setpsel(struct wl_listener *listener, void *data); +static void setsel(struct wl_listener *listener, void *data); +static void setup(void); +static void spawn(const Arg *arg); +static void startdrag(struct wl_listener *listener, void *data); +static void tag(const Arg *arg); +static void tagmon(const Arg *arg); +static void tile(Monitor *m); +static void togglefloating(const Arg *arg); +static void togglefullscreen(const Arg *arg); +static void toggletag(const Arg *arg); +static void toggleview(const Arg *arg); +static void unlocksession(struct wl_listener *listener, void *data); +static void unmaplayersurfacenotify(struct wl_listener *listener, void *data); +static void unmapnotify(struct wl_listener *listener, void *data); +static void updatemons(struct wl_listener *listener, void *data); +static void updatetitle(struct wl_listener *listener, void *data); +static void urgent(struct wl_listener *listener, void *data); +static void view(const Arg *arg); +static void virtualkeyboard(struct wl_listener *listener, void *data); +static void virtualpointer(struct wl_listener *listener, void *data); +static Monitor *xytomon(double x, double y); +static void xytonode(double x, double y, struct wlr_surface **psurface, + Client **pc, LayerSurface **pl, double *nx, double *ny); +static void zoom(const Arg *arg); + +/* variables */ +static const char broken[] = "broken"; +static pid_t child_pid = -1; +static int locked; +static void *exclusive_focus; +static struct wl_display *dpy; +static struct wlr_backend *backend; +static struct wlr_scene *scene; +static struct wlr_scene_tree *layers[NUM_LAYERS]; +static struct wlr_scene_tree *drag_icon; +/* Map from ZWLR_LAYER_SHELL_* constants to Lyr* enum */ +static const int layermap[] = { LyrBg, LyrBottom, LyrTop, LyrOverlay }; +static struct wlr_renderer *drw; +static struct wlr_allocator *alloc; +static struct wlr_compositor *compositor; +static struct wlr_session *session; + +static struct wlr_xdg_shell *xdg_shell; +static struct wlr_xdg_activation_v1 *activation; +static struct wlr_xdg_decoration_manager_v1 *xdg_decoration_mgr; +static struct wl_list clients; /* tiling order */ +static struct wl_list fstack; /* focus order */ +static struct wlr_idle_notifier_v1 *idle_notifier; +static struct wlr_idle_inhibit_manager_v1 *idle_inhibit_mgr; +static struct wlr_layer_shell_v1 *layer_shell; +static struct wlr_output_manager_v1 *output_mgr; +static struct wlr_gamma_control_manager_v1 *gamma_control_mgr; +static struct wlr_virtual_keyboard_manager_v1 *virtual_keyboard_mgr; +static struct wlr_virtual_pointer_manager_v1 *virtual_pointer_mgr; +static struct wlr_cursor_shape_manager_v1 *cursor_shape_mgr; +static struct wlr_output_power_manager_v1 *power_mgr; + +static struct wlr_pointer_constraints_v1 *pointer_constraints; +static struct wlr_relative_pointer_manager_v1 *relative_pointer_mgr; +static struct wlr_pointer_constraint_v1 *active_constraint; + +static struct wlr_cursor *cursor; +static struct wlr_xcursor_manager *cursor_mgr; + +static struct wlr_scene_rect *root_bg; +static struct wlr_session_lock_manager_v1 *session_lock_mgr; +static struct wlr_scene_rect *locked_bg; +static struct wlr_session_lock_v1 *cur_lock; +static struct wl_listener lock_listener = {.notify = locksession}; + +static struct wlr_seat *seat; +static KeyboardGroup *kb_group; +static unsigned int cursor_mode; +static Client *grabc; +static int grabcx, grabcy; /* client-relative */ + +static struct wlr_output_layout *output_layout; +static struct wlr_box sgeom; +static struct wl_list mons; +static Monitor *selmon; + +#ifdef XWAYLAND +static void activatex11(struct wl_listener *listener, void *data); +static void associatex11(struct wl_listener *listener, void *data); +static void configurex11(struct wl_listener *listener, void *data); +static void createnotifyx11(struct wl_listener *listener, void *data); +static void dissociatex11(struct wl_listener *listener, void *data); +static xcb_atom_t getatom(xcb_connection_t *xc, const char *name); +static void sethints(struct wl_listener *listener, void *data); +static void xwaylandready(struct wl_listener *listener, void *data); +static struct wlr_xwayland *xwayland; +static xcb_atom_t netatom[NetLast]; +#endif + +/* configuration, allows nested code to access above variables */ +#include "config.h" + +/* attempt to encapsulate suck into one file */ +#include "client.h" + +/* function implementations */ +void +applybounds(Client *c, struct wlr_box *bbox) +{ + /* set minimum possible */ + c->geom.width = MAX(1 + 2 * (int)c->bw, c->geom.width); + c->geom.height = MAX(1 + 2 * (int)c->bw, c->geom.height); + + if (c->geom.x >= bbox->x + bbox->width) + c->geom.x = bbox->x + bbox->width - c->geom.width; + if (c->geom.y >= bbox->y + bbox->height) + c->geom.y = bbox->y + bbox->height - c->geom.height; + if (c->geom.x + c->geom.width <= bbox->x) + c->geom.x = bbox->x; + if (c->geom.y + c->geom.height <= bbox->y) + c->geom.y = bbox->y; +} + +void +applyrules(Client *c) +{ + /* rule matching */ + const char *appid, *title; + uint32_t newtags = 0; + int i; + const Rule *r; + Monitor *mon = selmon, *m; + + c->isfloating = client_is_float_type(c); + if (!(appid = client_get_appid(c))) + appid = broken; + if (!(title = client_get_title(c))) + title = broken; + + for (r = rules; r < END(rules); r++) { + if ((!r->title || strstr(title, r->title)) + && (!r->id || strstr(appid, r->id))) { + c->isfloating = r->isfloating; + newtags |= r->tags; + i = 0; + wl_list_for_each(m, &mons, link) { + if (r->monitor == i++) + mon = m; + } + } + } + setmon(c, mon, newtags); +} + +void +arrange(Monitor *m) +{ + Client *c; + + if (!m->wlr_output->enabled) + return; + + wl_list_for_each(c, &clients, link) { + if (c->mon == m) { + wlr_scene_node_set_enabled(&c->scene->node, VISIBLEON(c, m)); + client_set_suspended(c, !VISIBLEON(c, m)); + } + } + + wlr_scene_node_set_enabled(&m->fullscreen_bg->node, + (c = focustop(m)) && c->isfullscreen); + + strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, LENGTH(m->ltsymbol)); + + /* We move all clients (except fullscreen and unmanaged) to LyrTile while + * in floating layout to avoid "real" floating clients be always on top */ + wl_list_for_each(c, &clients, link) { + if (c->mon != m || c->isfullscreen) + continue; + + wlr_scene_node_reparent(&c->scene->node, + (!m->lt[m->sellt]->arrange && c->isfloating) + ? layers[LyrTile] + : (m->lt[m->sellt]->arrange && c->isfloating) + ? layers[LyrFloat] + : c->scene->node.parent); + } + + if (m->lt[m->sellt]->arrange) + m->lt[m->sellt]->arrange(m); + motionnotify(0, NULL, 0, 0, 0, 0); + checkidleinhibitor(NULL); +} + +void +arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, int exclusive) +{ + LayerSurface *l; + struct wlr_box full_area = m->m; + + wl_list_for_each(l, list, link) { + struct wlr_layer_surface_v1 *layer_surface = l->layer_surface; + + if (exclusive != (layer_surface->current.exclusive_zone > 0)) + continue; + + wlr_scene_layer_surface_v1_configure(l->scene_layer, &full_area, usable_area); + wlr_scene_node_set_position(&l->popups->node, l->scene->node.x, l->scene->node.y); + l->geom.x = l->scene->node.x; + l->geom.y = l->scene->node.y; + } +} + +void +arrangelayers(Monitor *m) +{ + int i; + struct wlr_box usable_area = m->m; + LayerSurface *l; + uint32_t layers_above_shell[] = { + ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, + ZWLR_LAYER_SHELL_V1_LAYER_TOP, + }; + if (!m->wlr_output->enabled) + return; + + /* Arrange exclusive surfaces from top->bottom */ + for (i = 3; i >= 0; i--) + arrangelayer(m, &m->layers[i], &usable_area, 1); + + if (!wlr_box_equal(&usable_area, &m->w)) { + m->w = usable_area; + arrange(m); + } + + /* Arrange non-exlusive surfaces from top->bottom */ + for (i = 3; i >= 0; i--) + arrangelayer(m, &m->layers[i], &usable_area, 0); + + /* Find topmost keyboard interactive layer, if such a layer exists */ + for (i = 0; i < (int)LENGTH(layers_above_shell); i++) { + wl_list_for_each_reverse(l, &m->layers[layers_above_shell[i]], link) { + if (locked || !l->layer_surface->current.keyboard_interactive || !l->mapped) + continue; + /* Deactivate the focused client. */ + focusclient(NULL, 0); + exclusive_focus = l; + client_notify_enter(l->layer_surface->surface, wlr_seat_get_keyboard(seat)); + return; + } + } +} + +void +axisnotify(struct wl_listener *listener, void *data) +{ + /* This event is forwarded by the cursor when a pointer emits an axis event, + * for example when you move the scroll wheel. */ + struct wlr_pointer_axis_event *event = data; + wlr_idle_notifier_v1_notify_activity(idle_notifier, seat); + /* TODO: allow usage of scroll whell for mousebindings, it can be implemented + * checking the event's orientation and the delta of the event */ + /* Notify the client with pointer focus of the axis event. */ + wlr_seat_pointer_notify_axis(seat, + event->time_msec, event->orientation, event->delta, + event->delta_discrete, event->source); +} + +void +buttonpress(struct wl_listener *listener, void *data) +{ + struct wlr_pointer_button_event *event = data; + struct wlr_keyboard *keyboard; + uint32_t mods; + Client *c; + const Button *b; + + wlr_idle_notifier_v1_notify_activity(idle_notifier, seat); + + switch (event->state) { + case WLR_BUTTON_PRESSED: + cursor_mode = CurPressed; + selmon = xytomon(cursor->x, cursor->y); + if (locked) + break; + + /* Change focus if the button was _pressed_ over a client */ + xytonode(cursor->x, cursor->y, NULL, &c, NULL, NULL, NULL); + if (c && (!client_is_unmanaged(c) || client_wants_focus(c))) + focusclient(c, 1); + + keyboard = wlr_seat_get_keyboard(seat); + mods = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0; + for (b = buttons; b < END(buttons); b++) { + if (CLEANMASK(mods) == CLEANMASK(b->mod) && + event->button == b->button && b->func) { + b->func(&b->arg); + return; + } + } + break; + case WLR_BUTTON_RELEASED: + /* If you released any buttons, we exit interactive move/resize mode. */ + /* TODO should reset to the pointer focus's current setcursor */ + if (!locked && cursor_mode != CurNormal && cursor_mode != CurPressed) { + wlr_cursor_set_xcursor(cursor, cursor_mgr, "default"); + cursor_mode = CurNormal; + /* Drop the window off on its new monitor */ + selmon = xytomon(cursor->x, cursor->y); + setmon(grabc, selmon, 0); + return; + } else { + cursor_mode = CurNormal; + } + break; + } + /* If the event wasn't handled by the compositor, notify the client with + * pointer focus that a button press has occurred */ + wlr_seat_pointer_notify_button(seat, + event->time_msec, event->button, event->state); +} + +void +chvt(const Arg *arg) +{ + wlr_session_change_vt(session, arg->ui); +} + +void +checkidleinhibitor(struct wlr_surface *exclude) +{ + int inhibited = 0, unused_lx, unused_ly; + struct wlr_idle_inhibitor_v1 *inhibitor; + wl_list_for_each(inhibitor, &idle_inhibit_mgr->inhibitors, link) { + struct wlr_surface *surface = wlr_surface_get_root_surface(inhibitor->surface); + struct wlr_scene_tree *tree = surface->data; + if (exclude != surface && (bypass_surface_visibility || (!tree + || wlr_scene_node_coords(&tree->node, &unused_lx, &unused_ly)))) { + inhibited = 1; + break; + } + } + + wlr_idle_notifier_v1_set_inhibited(idle_notifier, inhibited); +} + +void +cleanup(void) +{ +#ifdef XWAYLAND + wlr_xwayland_destroy(xwayland); + xwayland = NULL; +#endif + wl_display_destroy_clients(dpy); + if (child_pid > 0) { + kill(-child_pid, SIGTERM); + waitpid(child_pid, NULL, 0); + } + wlr_xcursor_manager_destroy(cursor_mgr); + wlr_output_layout_destroy(output_layout); + + destroykeyboardgroup(&kb_group->destroy, NULL); + + wl_display_destroy(dpy); + /* Destroy after the wayland display (when the monitors are already destroyed) + to avoid destroying them with an invalid scene output. */ + wlr_scene_node_destroy(&scene->tree.node); +} + +void +cleanupmon(struct wl_listener *listener, void *data) +{ + Monitor *m = wl_container_of(listener, m, destroy); + LayerSurface *l, *tmp; + size_t i; + + /* m->layers[i] are intentionally not unlinked */ + for (i = 0; i < LENGTH(m->layers); i++) { + wl_list_for_each_safe(l, tmp, &m->layers[i], link) + wlr_layer_surface_v1_destroy(l->layer_surface); + } + + wl_list_remove(&m->destroy.link); + wl_list_remove(&m->frame.link); + wl_list_remove(&m->link); + wl_list_remove(&m->request_state.link); + m->wlr_output->data = NULL; + wlr_output_layout_remove(output_layout, m->wlr_output); + wlr_scene_output_destroy(m->scene_output); + + closemon(m); + wlr_scene_node_destroy(&m->fullscreen_bg->node); + free(m); +} + +void +closemon(Monitor *m) +{ + /* update selmon if needed and + * move closed monitor's clients to the focused one */ + Client *c; + int i = 0, nmons = wl_list_length(&mons); + if (!nmons) { + selmon = NULL; + } else if (m == selmon) { + do /* don't switch to disabled mons */ + selmon = wl_container_of(mons.next, selmon, link); + while (!selmon->wlr_output->enabled && i++ < nmons); + + if (!selmon->wlr_output->enabled) + selmon = NULL; + } + + wl_list_for_each(c, &clients, link) { + if (c->isfloating && c->geom.x > m->m.width) + resize(c, (struct wlr_box){.x = c->geom.x - m->w.width, .y = c->geom.y, + .width = c->geom.width, .height = c->geom.height}, 0); + if (c->mon == m) + setmon(c, selmon, c->tags); + } + focusclient(focustop(selmon), 1); + printstatus(); +} + +void +commitlayersurfacenotify(struct wl_listener *listener, void *data) +{ + LayerSurface *l = wl_container_of(listener, l, surface_commit); + struct wlr_layer_surface_v1 *layer_surface = l->layer_surface; + struct wlr_scene_tree *scene_layer = layers[layermap[layer_surface->current.layer]]; + + if (layer_surface->current.committed == 0 && l->mapped == layer_surface->surface->mapped) + return; + l->mapped = layer_surface->surface->mapped; + + if (scene_layer != l->scene->node.parent) { + wlr_scene_node_reparent(&l->scene->node, scene_layer); + wl_list_remove(&l->link); + wl_list_insert(&l->mon->layers[layer_surface->current.layer], &l->link); + wlr_scene_node_reparent(&l->popups->node, (layer_surface->current.layer + < ZWLR_LAYER_SHELL_V1_LAYER_TOP ? layers[LyrTop] : scene_layer)); + } + + arrangelayers(l->mon); +} + +void +commitnotify(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, commit); + + if (c->surface.xdg->initial_commit) { + /* + * Get the monitor this client will be rendered on + * Note that if the user set a rule in which the client is placed on + * a different monitor based on its title this will likely select + * a wrong monitor. + */ + applyrules(c); + wlr_surface_set_preferred_buffer_scale(client_surface(c), (int)ceilf(c->mon->wlr_output->scale)); + wlr_fractional_scale_v1_notify_scale(client_surface(c), c->mon->wlr_output->scale); + setmon(c, NULL, 0); /* Make sure to reapply rules in mapnotify() */ + } + + if (client_surface(c)->mapped && c->mon) + resize(c, c->geom, (c->isfloating && !c->isfullscreen)); + + /* mark a pending resize as completed */ + if (c->resize && c->resize <= c->surface.xdg->current.configure_serial) + c->resize = 0; +} + +void +createdecoration(struct wl_listener *listener, void *data) +{ + struct wlr_xdg_toplevel_decoration_v1 *deco = data; + Client *c = deco->toplevel->base->data; + c->decoration = deco; + + LISTEN(&deco->events.request_mode, &c->set_decoration_mode, requestdecorationmode); + LISTEN(&deco->events.destroy, &c->destroy_decoration, destroydecoration); + + requestdecorationmode(&c->set_decoration_mode, deco); +} + +void +createidleinhibitor(struct wl_listener *listener, void *data) +{ + struct wlr_idle_inhibitor_v1 *idle_inhibitor = data; + LISTEN_STATIC(&idle_inhibitor->events.destroy, destroyidleinhibitor); + + checkidleinhibitor(NULL); +} + +void +createkeyboard(struct wlr_keyboard *keyboard) +{ + /* Set the keymap to match the group keymap */ + wlr_keyboard_set_keymap(keyboard, kb_group->wlr_group->keyboard.keymap); + + /* Add the new keyboard to the group */ + wlr_keyboard_group_add_keyboard(kb_group->wlr_group, keyboard); +} + +KeyboardGroup * +createkeyboardgroup(void) +{ + KeyboardGroup *group = ecalloc(1, sizeof(*group)); + struct xkb_context *context; + struct xkb_keymap *keymap; + + group->wlr_group = wlr_keyboard_group_create(); + group->wlr_group->data = group; + + /* Prepare an XKB keymap and assign it to the keyboard group. */ + context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); + if (!(keymap = xkb_keymap_new_from_names(context, &xkb_rules, + XKB_KEYMAP_COMPILE_NO_FLAGS))) + die("failed to compile keymap"); + + wlr_keyboard_set_keymap(&group->wlr_group->keyboard, keymap); + xkb_keymap_unref(keymap); + xkb_context_unref(context); + + wlr_keyboard_set_repeat_info(&group->wlr_group->keyboard, repeat_rate, repeat_delay); + + /* Set up listeners for keyboard events */ + LISTEN(&group->wlr_group->keyboard.events.key, &group->key, keypress); + LISTEN(&group->wlr_group->keyboard.events.modifiers, &group->modifiers, keypressmod); + + group->key_repeat_source = wl_event_loop_add_timer( + wl_display_get_event_loop(dpy), keyrepeat, group); + + /* A seat can only have one keyboard, but this is a limitation of the + * Wayland protocol - not wlroots. We assign all connected keyboards to the + * same wlr_keyboard_group, which provides a single wlr_keyboard interface for + * all of them. Set this combined wlr_keyboard as the seat keyboard. + */ + wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard); + return group; +} + +void +createlayersurface(struct wl_listener *listener, void *data) +{ + struct wlr_layer_surface_v1 *layer_surface = data; + LayerSurface *l; + struct wlr_surface *surface = layer_surface->surface; + struct wlr_scene_tree *scene_layer = layers[layermap[layer_surface->pending.layer]]; + struct wlr_layer_surface_v1_state old_state; + + if (!layer_surface->output + && !(layer_surface->output = selmon ? selmon->wlr_output : NULL)) { + wlr_layer_surface_v1_destroy(layer_surface); + return; + } + + l = layer_surface->data = ecalloc(1, sizeof(*l)); + l->type = LayerShell; + LISTEN(&surface->events.commit, &l->surface_commit, commitlayersurfacenotify); + LISTEN(&surface->events.unmap, &l->unmap, unmaplayersurfacenotify); + LISTEN(&layer_surface->events.destroy, &l->destroy, destroylayersurfacenotify); + + l->layer_surface = layer_surface; + l->mon = layer_surface->output->data; + l->scene_layer = wlr_scene_layer_surface_v1_create(scene_layer, layer_surface); + l->scene = l->scene_layer->tree; + l->popups = surface->data = wlr_scene_tree_create(layer_surface->current.layer + < ZWLR_LAYER_SHELL_V1_LAYER_TOP ? layers[LyrTop] : scene_layer); + l->scene->node.data = l->popups->node.data = l; + + wl_list_insert(&l->mon->layers[layer_surface->pending.layer],&l->link); + wlr_surface_send_enter(surface, layer_surface->output); + wlr_fractional_scale_v1_notify_scale(surface, l->mon->wlr_output->scale); + wlr_surface_set_preferred_buffer_scale(surface, (int32_t)ceilf(l->mon->wlr_output->scale)); + + /* Temporarily set the layer's current state to pending + * so that we can easily arrange it + */ + old_state = layer_surface->current; + layer_surface->current = layer_surface->pending; + l->mapped = 1; + arrangelayers(l->mon); + layer_surface->current = old_state; +} + +void +createlocksurface(struct wl_listener *listener, void *data) +{ + SessionLock *lock = wl_container_of(listener, lock, new_surface); + struct wlr_session_lock_surface_v1 *lock_surface = data; + Monitor *m = lock_surface->output->data; + struct wlr_scene_tree *scene_tree = lock_surface->surface->data + = wlr_scene_subsurface_tree_create(lock->scene, lock_surface->surface); + m->lock_surface = lock_surface; + + wlr_scene_node_set_position(&scene_tree->node, m->m.x, m->m.y); + wlr_session_lock_surface_v1_configure(lock_surface, m->m.width, m->m.height); + + LISTEN(&lock_surface->events.destroy, &m->destroy_lock_surface, destroylocksurface); + + if (m == selmon) + client_notify_enter(lock_surface->surface, wlr_seat_get_keyboard(seat)); +} + +void +createmon(struct wl_listener *listener, void *data) +{ + /* This event is raised by the backend when a new output (aka a display or + * monitor) becomes available. */ + struct wlr_output *wlr_output = data; + const MonitorRule *r; + size_t i; + struct wlr_output_state state; + Monitor *m; + + if (!wlr_output_init_render(wlr_output, alloc, drw)) + return; + + m = wlr_output->data = ecalloc(1, sizeof(*m)); + m->wlr_output = wlr_output; + + for (i = 0; i < LENGTH(m->layers); i++) + wl_list_init(&m->layers[i]); + + wlr_output_state_init(&state); + /* Initialize monitor state using configured rules */ + m->tagset[0] = m->tagset[1] = 1; + for (r = monrules; r < END(monrules); r++) { + if (!r->name || strstr(wlr_output->name, r->name)) { + m->m.x = r->x; + m->m.y = r->y; + m->mfact = r->mfact; + m->nmaster = r->nmaster; + m->lt[0] = r->lt; + m->lt[1] = &layouts[LENGTH(layouts) > 1 && r->lt != &layouts[1]]; + strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, LENGTH(m->ltsymbol)); + wlr_output_state_set_scale(&state, r->scale); + wlr_output_state_set_transform(&state, r->rr); + break; + } + } + + /* The mode is a tuple of (width, height, refresh rate), and each + * monitor supports only a specific set of modes. We just pick the + * monitor's preferred mode; a more sophisticated compositor would let + * the user configure it. */ + wlr_output_state_set_mode(&state, wlr_output_preferred_mode(wlr_output)); + + /* Set up event listeners */ + LISTEN(&wlr_output->events.frame, &m->frame, rendermon); + LISTEN(&wlr_output->events.destroy, &m->destroy, cleanupmon); + LISTEN(&wlr_output->events.request_state, &m->request_state, requestmonstate); + + wlr_output_state_set_enabled(&state, 1); + wlr_output_commit_state(wlr_output, &state); + wlr_output_state_finish(&state); + + wl_list_insert(&mons, &m->link); + printstatus(); + + /* The xdg-protocol specifies: + * + * If the fullscreened surface is not opaque, the compositor must make + * sure that other screen content not part of the same surface tree (made + * up of subsurfaces, popups or similarly coupled surfaces) are not + * visible below the fullscreened surface. + * + */ + /* updatemons() will resize and set correct position */ + m->fullscreen_bg = wlr_scene_rect_create(layers[LyrFS], 0, 0, fullscreen_bg); + wlr_scene_node_set_enabled(&m->fullscreen_bg->node, 0); + + /* Adds this to the output layout in the order it was configured. + * + * The output layout utility automatically adds a wl_output global to the + * display, which Wayland clients can see to find out information about the + * output (such as DPI, scale factor, manufacturer, etc). + */ + m->scene_output = wlr_scene_output_create(scene, wlr_output); + if (m->m.x == -1 && m->m.y == -1) + wlr_output_layout_add_auto(output_layout, wlr_output); + else + wlr_output_layout_add(output_layout, wlr_output, m->m.x, m->m.y); +} + +void +createnotify(struct wl_listener *listener, void *data) +{ + /* This event is raised when wlr_xdg_shell receives a new xdg surface from a + * client, either a toplevel (application window) or popup, + * or when wlr_layer_shell receives a new popup from a layer. + * If you want to do something tricky with popups you should check if + * its parent is wlr_xdg_shell or wlr_layer_shell */ + struct wlr_xdg_surface *xdg_surface = data; + Client *c = NULL; + LayerSurface *l = NULL; + + if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP) { + struct wlr_xdg_popup *popup = xdg_surface->popup; + struct wlr_box box; + if (toplevel_from_wlr_surface(popup->base->surface, &c, &l) < 0) + return; + popup->base->surface->data = wlr_scene_xdg_surface_create( + popup->parent->data, popup->base); + if ((l && !l->mon) || (c && !c->mon)) + return; + box = l ? l->mon->m : c->mon->w; + box.x -= (l ? l->geom.x : c->geom.x); + box.y -= (l ? l->geom.y : c->geom.y); + wlr_xdg_popup_unconstrain_from_box(popup, &box); + return; + } else if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_NONE) + return; + + /* Allocate a Client for this surface */ + c = xdg_surface->data = ecalloc(1, sizeof(*c)); + c->surface.xdg = xdg_surface; + c->bw = borderpx; + + wlr_xdg_toplevel_set_wm_capabilities(xdg_surface->toplevel, + WLR_XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN); + + LISTEN(&xdg_surface->events.destroy, &c->destroy, destroynotify); + LISTEN(&xdg_surface->surface->events.commit, &c->commit, commitnotify); + LISTEN(&xdg_surface->surface->events.map, &c->map, mapnotify); + LISTEN(&xdg_surface->surface->events.unmap, &c->unmap, unmapnotify); + LISTEN(&xdg_surface->toplevel->events.request_fullscreen, &c->fullscreen, + fullscreennotify); + LISTEN(&xdg_surface->toplevel->events.request_maximize, &c->maximize, + maximizenotify); + LISTEN(&xdg_surface->toplevel->events.set_title, &c->set_title, updatetitle); +} + +void +createpointer(struct wlr_pointer *pointer) +{ + struct libinput_device *device; + if (wlr_input_device_is_libinput(&pointer->base) + && (device = wlr_libinput_get_device_handle(&pointer->base))) { + + if (libinput_device_config_tap_get_finger_count(device)) { + libinput_device_config_tap_set_enabled(device, tap_to_click); + libinput_device_config_tap_set_drag_enabled(device, tap_and_drag); + libinput_device_config_tap_set_drag_lock_enabled(device, drag_lock); + libinput_device_config_tap_set_button_map(device, button_map); + } + + if (libinput_device_config_scroll_has_natural_scroll(device)) + libinput_device_config_scroll_set_natural_scroll_enabled(device, natural_scrolling); + + if (libinput_device_config_dwt_is_available(device)) + libinput_device_config_dwt_set_enabled(device, disable_while_typing); + + if (libinput_device_config_left_handed_is_available(device)) + libinput_device_config_left_handed_set(device, left_handed); + + if (libinput_device_config_middle_emulation_is_available(device)) + libinput_device_config_middle_emulation_set_enabled(device, middle_button_emulation); + + if (libinput_device_config_scroll_get_methods(device) != LIBINPUT_CONFIG_SCROLL_NO_SCROLL) + libinput_device_config_scroll_set_method (device, scroll_method); + + if (libinput_device_config_click_get_methods(device) != LIBINPUT_CONFIG_CLICK_METHOD_NONE) + libinput_device_config_click_set_method (device, click_method); + + if (libinput_device_config_send_events_get_modes(device)) + libinput_device_config_send_events_set_mode(device, send_events_mode); + + if (libinput_device_config_accel_is_available(device)) { + libinput_device_config_accel_set_profile(device, accel_profile); + libinput_device_config_accel_set_speed(device, accel_speed); + } + } + + wlr_cursor_attach_input_device(cursor, &pointer->base); +} + +void +createpointerconstraint(struct wl_listener *listener, void *data) +{ + PointerConstraint *pointer_constraint = ecalloc(1, sizeof(*pointer_constraint)); + pointer_constraint->constraint = data; + LISTEN(&pointer_constraint->constraint->events.destroy, + &pointer_constraint->destroy, destroypointerconstraint); +} + +void +cursorconstrain(struct wlr_pointer_constraint_v1 *constraint) +{ + if (active_constraint == constraint) + return; + + if (active_constraint) + wlr_pointer_constraint_v1_send_deactivated(active_constraint); + + active_constraint = constraint; + wlr_pointer_constraint_v1_send_activated(constraint); +} + +void +cursorframe(struct wl_listener *listener, void *data) +{ + /* This event is forwarded by the cursor when a pointer emits an frame + * event. Frame events are sent after regular pointer events to group + * multiple events together. For instance, two axis events may happen at the + * same time, in which case a frame event won't be sent in between. */ + /* Notify the client with pointer focus of the frame event. */ + wlr_seat_pointer_notify_frame(seat); +} + +void +cursorwarptohint(void) +{ + Client *c = NULL; + double sx = active_constraint->current.cursor_hint.x; + double sy = active_constraint->current.cursor_hint.y; + + toplevel_from_wlr_surface(active_constraint->surface, &c, NULL); + /* TODO: wlroots 0.18: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4478 */ + if (c && (active_constraint->current.committed & WLR_POINTER_CONSTRAINT_V1_STATE_CURSOR_HINT )) { + wlr_cursor_warp(cursor, NULL, sx + c->geom.x + c->bw, sy + c->geom.y + c->bw); + wlr_seat_pointer_warp(active_constraint->seat, sx, sy); + } +} + +void +destroydecoration(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, destroy_decoration); + + wl_list_remove(&c->destroy_decoration.link); + wl_list_remove(&c->set_decoration_mode.link); +} + +void +destroydragicon(struct wl_listener *listener, void *data) +{ + /* Focus enter isn't sent during drag, so refocus the focused node. */ + focusclient(focustop(selmon), 1); + motionnotify(0, NULL, 0, 0, 0, 0); +} + +void +destroyidleinhibitor(struct wl_listener *listener, void *data) +{ + /* `data` is the wlr_surface of the idle inhibitor being destroyed, + * at this point the idle inhibitor is still in the list of the manager */ + checkidleinhibitor(wlr_surface_get_root_surface(data)); +} + +void +destroylayersurfacenotify(struct wl_listener *listener, void *data) +{ + LayerSurface *l = wl_container_of(listener, l, destroy); + + wl_list_remove(&l->link); + wl_list_remove(&l->destroy.link); + wl_list_remove(&l->unmap.link); + wl_list_remove(&l->surface_commit.link); + wlr_scene_node_destroy(&l->scene->node); + wlr_scene_node_destroy(&l->popups->node); + free(l); +} + +void +destroylock(SessionLock *lock, int unlock) +{ + wlr_seat_keyboard_notify_clear_focus(seat); + if ((locked = !unlock)) + goto destroy; + + wlr_scene_node_set_enabled(&locked_bg->node, 0); + + focusclient(focustop(selmon), 0); + motionnotify(0, NULL, 0, 0, 0, 0); + +destroy: + wl_list_remove(&lock->new_surface.link); + wl_list_remove(&lock->unlock.link); + wl_list_remove(&lock->destroy.link); + + wlr_scene_node_destroy(&lock->scene->node); + cur_lock = NULL; + free(lock); +} + +void +destroylocksurface(struct wl_listener *listener, void *data) +{ + Monitor *m = wl_container_of(listener, m, destroy_lock_surface); + struct wlr_session_lock_surface_v1 *surface, *lock_surface = m->lock_surface; + + m->lock_surface = NULL; + wl_list_remove(&m->destroy_lock_surface.link); + + if (lock_surface->surface != seat->keyboard_state.focused_surface) + return; + + if (locked && cur_lock && !wl_list_empty(&cur_lock->surfaces)) { + surface = wl_container_of(cur_lock->surfaces.next, surface, link); + client_notify_enter(surface->surface, wlr_seat_get_keyboard(seat)); + } else if (!locked) { + focusclient(focustop(selmon), 1); + } else { + wlr_seat_keyboard_clear_focus(seat); + } +} + +void +destroynotify(struct wl_listener *listener, void *data) +{ + /* Called when the xdg_toplevel is destroyed. */ + Client *c = wl_container_of(listener, c, destroy); + wl_list_remove(&c->destroy.link); + wl_list_remove(&c->set_title.link); + wl_list_remove(&c->fullscreen.link); +#ifdef XWAYLAND + if (c->type != XDGShell) { + wl_list_remove(&c->activate.link); + wl_list_remove(&c->associate.link); + wl_list_remove(&c->configure.link); + wl_list_remove(&c->dissociate.link); + wl_list_remove(&c->set_hints.link); + } else +#endif + { + wl_list_remove(&c->commit.link); + wl_list_remove(&c->map.link); + wl_list_remove(&c->unmap.link); + } + free(c); +} + +void +destroypointerconstraint(struct wl_listener *listener, void *data) +{ + PointerConstraint *pointer_constraint = wl_container_of(listener, pointer_constraint, destroy); + + if (active_constraint == pointer_constraint->constraint) { + cursorwarptohint(); + active_constraint = NULL; + } + + wl_list_remove(&pointer_constraint->destroy.link); + free(pointer_constraint); +} + +void +destroysessionlock(struct wl_listener *listener, void *data) +{ + SessionLock *lock = wl_container_of(listener, lock, destroy); + destroylock(lock, 0); +} + +void +destroysessionmgr(struct wl_listener *listener, void *data) +{ + wl_list_remove(&lock_listener.link); + wl_list_remove(&listener->link); +} + +void +destroykeyboardgroup(struct wl_listener *listener, void *data) +{ + KeyboardGroup *group = wl_container_of(listener, group, destroy); + wl_event_source_remove(group->key_repeat_source); + wlr_keyboard_group_destroy(group->wlr_group); + wl_list_remove(&group->key.link); + wl_list_remove(&group->modifiers.link); + wl_list_remove(&group->destroy.link); + free(group); +} + +Monitor * +dirtomon(enum wlr_direction dir) +{ + struct wlr_output *next; + if (!wlr_output_layout_get(output_layout, selmon->wlr_output)) + return selmon; + if ((next = wlr_output_layout_adjacent_output(output_layout, + dir, selmon->wlr_output, selmon->m.x, selmon->m.y))) + return next->data; + if ((next = wlr_output_layout_farthest_output(output_layout, + dir ^ (WLR_DIRECTION_LEFT|WLR_DIRECTION_RIGHT), + selmon->wlr_output, selmon->m.x, selmon->m.y))) + return next->data; + return selmon; +} + +void +focusclient(Client *c, int lift) +{ + struct wlr_surface *old = seat->keyboard_state.focused_surface; + int unused_lx, unused_ly, old_client_type; + Client *old_c = NULL; + LayerSurface *old_l = NULL; + + if (locked) + return; + + /* Raise client in stacking order if requested */ + if (c && lift) + wlr_scene_node_raise_to_top(&c->scene->node); + + if (c && client_surface(c) == old) + return; + + if ((old_client_type = toplevel_from_wlr_surface(old, &old_c, &old_l)) == XDGShell) { + struct wlr_xdg_popup *popup, *tmp; + wl_list_for_each_safe(popup, tmp, &old_c->surface.xdg->popups, link) + wlr_xdg_popup_destroy(popup); + } + + /* Put the new client atop the focus stack and select its monitor */ + if (c && !client_is_unmanaged(c)) { + wl_list_remove(&c->flink); + wl_list_insert(&fstack, &c->flink); + selmon = c->mon; + c->isurgent = 0; + client_restack_surface(c); + + /* Don't change border color if there is an exclusive focus or we are + * handling a drag operation */ + if (!exclusive_focus && !seat->drag) + client_set_border_color(c, focuscolor); + } + + /* Deactivate old client if focus is changing */ + if (old && (!c || client_surface(c) != old)) { + /* If an overlay is focused, don't focus or activate the client, + * but only update its position in fstack to render its border with focuscolor + * and focus it after the overlay is closed. */ + if (old_client_type == LayerShell && wlr_scene_node_coords( + &old_l->scene->node, &unused_lx, &unused_ly) + && old_l->layer_surface->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP) { + return; + } else if (old_c && old_c == exclusive_focus && client_wants_focus(old_c)) { + return; + /* Don't deactivate old client if the new one wants focus, as this causes issues with winecfg + * and probably other clients */ + } else if (old_c && !client_is_unmanaged(old_c) && (!c || !client_wants_focus(c))) { + client_set_border_color(old_c, bordercolor); + + client_activate_surface(old, 0); + } + } + printstatus(); + + if (!c) { + /* With no client, all we have left is to clear focus */ + wlr_seat_keyboard_notify_clear_focus(seat); + return; + } + + /* Change cursor surface */ + motionnotify(0, NULL, 0, 0, 0, 0); + + /* Have a client, so focus its top-level wlr_surface */ + client_notify_enter(client_surface(c), wlr_seat_get_keyboard(seat)); + + /* Activate the new client */ + client_activate_surface(client_surface(c), 1); +} + +void +focusmon(const Arg *arg) +{ + int i = 0, nmons = wl_list_length(&mons); + if (nmons) { + do /* don't switch to disabled mons */ + selmon = dirtomon(arg->i); + while (!selmon->wlr_output->enabled && i++ < nmons); + } + focusclient(focustop(selmon), 1); +} + +void +focusstack(const Arg *arg) +{ + /* Focus the next or previous client (in tiling order) on selmon */ + Client *c, *sel = focustop(selmon); + if (!sel || sel->isfullscreen) + return; + if (arg->i > 0) { + wl_list_for_each(c, &sel->link, link) { + if (&c->link == &clients) + continue; /* wrap past the sentinel node */ + if (VISIBLEON(c, selmon)) + break; /* found it */ + } + } else { + wl_list_for_each_reverse(c, &sel->link, link) { + if (&c->link == &clients) + continue; /* wrap past the sentinel node */ + if (VISIBLEON(c, selmon)) + break; /* found it */ + } + } + /* If only one client is visible on selmon, then c == sel */ + focusclient(c, 1); +} + +/* We probably should change the name of this, it sounds like + * will focus the topmost client of this mon, when actually will + * only return that client */ +Client * +focustop(Monitor *m) +{ + Client *c; + wl_list_for_each(c, &fstack, flink) { + if (VISIBLEON(c, m)) + return c; + } + return NULL; +} + +void +fullscreennotify(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, fullscreen); + setfullscreen(c, client_wants_fullscreen(c)); +} + +void +handlesig(int signo) +{ + if (signo == SIGCHLD) { +#ifdef XWAYLAND + siginfo_t in; + /* wlroots expects to reap the XWayland process itself, so we + * use WNOWAIT to keep the child waitable until we know it's not + * XWayland. + */ + while (!waitid(P_ALL, 0, &in, WEXITED|WNOHANG|WNOWAIT) && in.si_pid + && (!xwayland || in.si_pid != xwayland->server->pid)) + waitpid(in.si_pid, NULL, 0); +#else + while (waitpid(-1, NULL, WNOHANG) > 0); +#endif + } else if (signo == SIGINT || signo == SIGTERM) { + quit(NULL); + } +} + +void +incnmaster(const Arg *arg) +{ + if (!arg || !selmon) + return; + selmon->nmaster = MAX(selmon->nmaster + arg->i, 0); + arrange(selmon); +} + +void +inputdevice(struct wl_listener *listener, void *data) +{ + /* This event is raised by the backend when a new input device becomes + * available. */ + struct wlr_input_device *device = data; + uint32_t caps; + + switch (device->type) { + case WLR_INPUT_DEVICE_KEYBOARD: + createkeyboard(wlr_keyboard_from_input_device(device)); + break; + case WLR_INPUT_DEVICE_POINTER: + createpointer(wlr_pointer_from_input_device(device)); + break; + default: + /* TODO handle other input device types */ + break; + } + + /* We need to let the wlr_seat know what our capabilities are, which is + * communiciated to the client. In dwl we always have a cursor, even if + * there are no pointer devices, so we always include that capability. */ + /* TODO do we actually require a cursor? */ + caps = WL_SEAT_CAPABILITY_POINTER; + if (!wl_list_empty(&kb_group->wlr_group->devices)) + caps |= WL_SEAT_CAPABILITY_KEYBOARD; + wlr_seat_set_capabilities(seat, caps); +} + +int +keybinding(uint32_t mods, xkb_keysym_t sym) +{ + /* + * Here we handle compositor keybindings. This is when the compositor is + * processing keys, rather than passing them on to the client for its own + * processing. + */ + const Key *k; + for (k = keys; k < END(keys); k++) { + if (CLEANMASK(mods) == CLEANMASK(k->mod) + && sym == k->keysym && k->func) { + k->func(&k->arg); + return 1; + } + } + return 0; +} + +void +keypress(struct wl_listener *listener, void *data) +{ + int i; + /* This event is raised when a key is pressed or released. */ + KeyboardGroup *group = wl_container_of(listener, group, key); + struct wlr_keyboard_key_event *event = data; + + /* Translate libinput keycode -> xkbcommon */ + uint32_t keycode = event->keycode + 8; + /* Get a list of keysyms based on the keymap for this keyboard */ + const xkb_keysym_t *syms; + int nsyms = xkb_state_key_get_syms( + group->wlr_group->keyboard.xkb_state, keycode, &syms); + + int handled = 0; + uint32_t mods = wlr_keyboard_get_modifiers(&group->wlr_group->keyboard); + + wlr_idle_notifier_v1_notify_activity(idle_notifier, seat); + + /* On _press_ if there is no active screen locker, + * attempt to process a compositor keybinding. */ + if (!locked && event->state == WL_KEYBOARD_KEY_STATE_PRESSED) { + for (i = 0; i < nsyms; i++) + handled = keybinding(mods, syms[i]) || handled; + } + + if (handled && group->wlr_group->keyboard.repeat_info.delay > 0) { + group->mods = mods; + group->keysyms = syms; + group->nsyms = nsyms; + wl_event_source_timer_update(group->key_repeat_source, + group->wlr_group->keyboard.repeat_info.delay); + } else { + group->nsyms = 0; + wl_event_source_timer_update(group->key_repeat_source, 0); + } + + if (handled) + return; + + wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard); + /* Pass unhandled keycodes along to the client. */ + wlr_seat_keyboard_notify_key(seat, event->time_msec, + event->keycode, event->state); +} + +void +keypressmod(struct wl_listener *listener, void *data) +{ + /* This event is raised when a modifier key, such as shift or alt, is + * pressed. We simply communicate this to the client. */ + KeyboardGroup *group = wl_container_of(listener, group, modifiers); + + wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard); + /* Send modifiers to the client. */ + wlr_seat_keyboard_notify_modifiers(seat, + &group->wlr_group->keyboard.modifiers); +} + +int +keyrepeat(void *data) +{ + KeyboardGroup *group = data; + int i; + if (!group->nsyms || group->wlr_group->keyboard.repeat_info.rate <= 0) + return 0; + + wl_event_source_timer_update(group->key_repeat_source, + 1000 / group->wlr_group->keyboard.repeat_info.rate); + + for (i = 0; i < group->nsyms; i++) + keybinding(group->mods, group->keysyms[i]); + + return 0; +} + +void +killclient(const Arg *arg) +{ + Client *sel = focustop(selmon); + if (sel) + client_send_close(sel); +} + +void +locksession(struct wl_listener *listener, void *data) +{ + struct wlr_session_lock_v1 *session_lock = data; + SessionLock *lock; + wlr_scene_node_set_enabled(&locked_bg->node, 1); + if (cur_lock) { + wlr_session_lock_v1_destroy(session_lock); + return; + } + lock = session_lock->data = ecalloc(1, sizeof(*lock)); + focusclient(NULL, 0); + + lock->scene = wlr_scene_tree_create(layers[LyrBlock]); + cur_lock = lock->lock = session_lock; + locked = 1; + + LISTEN(&session_lock->events.new_surface, &lock->new_surface, createlocksurface); + LISTEN(&session_lock->events.destroy, &lock->destroy, destroysessionlock); + LISTEN(&session_lock->events.unlock, &lock->unlock, unlocksession); + + wlr_session_lock_v1_send_locked(session_lock); +} + +void +mapnotify(struct wl_listener *listener, void *data) +{ + /* Called when the surface is mapped, or ready to display on-screen. */ + Client *p, *w, *c = wl_container_of(listener, c, map); + Monitor *m; + int i; + + /* Create scene tree for this client and its border */ + c->scene = client_surface(c)->data = wlr_scene_tree_create(layers[LyrTile]); + wlr_scene_node_set_enabled(&c->scene->node, c->type != XDGShell); + c->scene_surface = c->type == XDGShell + ? wlr_scene_xdg_surface_create(c->scene, c->surface.xdg) + : wlr_scene_subsurface_tree_create(c->scene, client_surface(c)); + c->scene->node.data = c->scene_surface->node.data = c; + + client_get_geometry(c, &c->geom); + + /* Handle unmanaged clients first so we can return prior create borders */ + if (client_is_unmanaged(c)) { + /* Unmanaged clients always are floating */ + wlr_scene_node_reparent(&c->scene->node, layers[LyrFloat]); + wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y); + if (client_wants_focus(c)) { + focusclient(c, 1); + exclusive_focus = c; + } + goto unset_fullscreen; + } + + for (i = 0; i < 4; i++) { + c->border[i] = wlr_scene_rect_create(c->scene, 0, 0, + c->isurgent ? urgentcolor : bordercolor); + c->border[i]->node.data = c; + } + + /* Initialize client geometry with room for border */ + client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT); + c->geom.width += 2 * c->bw; + c->geom.height += 2 * c->bw; + + /* Insert this client into client lists. */ + wl_list_insert(&clients, &c->link); + wl_list_insert(&fstack, &c->flink); + + /* Set initial monitor, tags, floating status, and focus: + * we always consider floating, clients that have parent and thus + * we set the same tags and monitor than its parent, if not + * try to apply rules for them */ + if ((p = client_get_parent(c))) { + c->isfloating = 1; + setmon(c, p->mon, p->tags); + } else { + applyrules(c); + } + printstatus(); + +unset_fullscreen: + m = c->mon ? c->mon : xytomon(c->geom.x, c->geom.y); + wl_list_for_each(w, &clients, link) { + if (w != c && w->isfullscreen && m == w->mon && (w->tags & c->tags)) + setfullscreen(w, 0); + } +} + +void +maximizenotify(struct wl_listener *listener, void *data) +{ + /* This event is raised when a client would like to maximize itself, + * typically because the user clicked on the maximize button on + * client-side decorations. dwl doesn't support maximization, but + * to conform to xdg-shell protocol we still must send a configure. + * Since xdg-shell protocol v5 we should ignore request of unsupported + * capabilities, just schedule a empty configure when the client uses <5 + * protocol version + * wlr_xdg_surface_schedule_configure() is used to send an empty reply. */ + Client *c = wl_container_of(listener, c, maximize); + if (wl_resource_get_version(c->surface.xdg->toplevel->resource) + < XDG_TOPLEVEL_WM_CAPABILITIES_SINCE_VERSION) + wlr_xdg_surface_schedule_configure(c->surface.xdg); +} + +void +monocle(Monitor *m) +{ + Client *c; + int n = 0; + + wl_list_for_each(c, &clients, link) { + if (!VISIBLEON(c, m) || c->isfloating || c->isfullscreen) + continue; + resize(c, m->w, 0); + n++; + } + if (n) + snprintf(m->ltsymbol, LENGTH(m->ltsymbol), "[%d]", n); + if ((c = focustop(m))) + wlr_scene_node_raise_to_top(&c->scene->node); +} + +void +motionabsolute(struct wl_listener *listener, void *data) +{ + /* This event is forwarded by the cursor when a pointer emits an _absolute_ + * motion event, from 0..1 on each axis. This happens, for example, when + * wlroots is running under a Wayland window rather than KMS+DRM, and you + * move the mouse over the window. You could enter the window from any edge, + * so we have to warp the mouse there. There is also some hardware which + * emits these events. */ + struct wlr_pointer_motion_absolute_event *event = data; + double lx, ly, dx, dy; + + if (!event->time_msec) /* this is 0 with virtual pointers */ + wlr_cursor_warp_absolute(cursor, &event->pointer->base, event->x, event->y); + + wlr_cursor_absolute_to_layout_coords(cursor, &event->pointer->base, event->x, event->y, &lx, &ly); + dx = lx - cursor->x; + dy = ly - cursor->y; + motionnotify(event->time_msec, &event->pointer->base, dx, dy, dx, dy); +} + +void +motionnotify(uint32_t time, struct wlr_input_device *device, double dx, double dy, + double dx_unaccel, double dy_unaccel) +{ + double sx = 0, sy = 0, sx_confined, sy_confined; + Client *c = NULL, *w = NULL; + LayerSurface *l = NULL; + struct wlr_surface *surface = NULL; + struct wlr_pointer_constraint_v1 *constraint; + + /* Find the client under the pointer and send the event along. */ + xytonode(cursor->x, cursor->y, &surface, &c, NULL, &sx, &sy); + + if (cursor_mode == CurPressed && !seat->drag + && surface != seat->pointer_state.focused_surface + && toplevel_from_wlr_surface(seat->pointer_state.focused_surface, &w, &l) >= 0) { + c = w; + surface = seat->pointer_state.focused_surface; + sx = cursor->x - (l ? l->geom.x : w->geom.x); + sy = cursor->y - (l ? l->geom.y : w->geom.y); + } + + /* time is 0 in internal calls meant to restore pointer focus. */ + if (time) { + wlr_relative_pointer_manager_v1_send_relative_motion( + relative_pointer_mgr, seat, (uint64_t)time * 1000, + dx, dy, dx_unaccel, dy_unaccel); + + wl_list_for_each(constraint, &pointer_constraints->constraints, link) + cursorconstrain(constraint); + + if (active_constraint && cursor_mode != CurResize && cursor_mode != CurMove) { + toplevel_from_wlr_surface(active_constraint->surface, &c, NULL); + if (c && active_constraint->surface == seat->pointer_state.focused_surface) { + sx = cursor->x - c->geom.x - c->bw; + sy = cursor->y - c->geom.y - c->bw; + if (wlr_region_confine(&active_constraint->region, sx, sy, + sx + dx, sy + dy, &sx_confined, &sy_confined)) { + dx = sx_confined - sx; + dy = sy_confined - sy; + } + + if (active_constraint->type == WLR_POINTER_CONSTRAINT_V1_LOCKED) + return; + } + } + + wlr_cursor_move(cursor, device, dx, dy); + wlr_idle_notifier_v1_notify_activity(idle_notifier, seat); + + /* Update selmon (even while dragging a window) */ + if (sloppyfocus) + selmon = xytomon(cursor->x, cursor->y); + } + + /* Update drag icon's position */ + wlr_scene_node_set_position(&drag_icon->node, (int)round(cursor->x), (int)round(cursor->y)); + + /* If we are currently grabbing the mouse, handle and return */ + if (cursor_mode == CurMove) { + /* Move the grabbed client to the new position. */ + resize(grabc, (struct wlr_box){.x = (int)round(cursor->x) - grabcx, .y = (int)round(cursor->y) - grabcy, + .width = grabc->geom.width, .height = grabc->geom.height}, 1); + return; + } else if (cursor_mode == CurResize) { + resize(grabc, (struct wlr_box){.x = grabc->geom.x, .y = grabc->geom.y, + .width = (int)round(cursor->x) - grabc->geom.x, .height = (int)round(cursor->y) - grabc->geom.y}, 1); + return; + } + + /* If there's no client surface under the cursor, set the cursor image to a + * default. This is what makes the cursor image appear when you move it + * off of a client or over its border. */ + if (!surface && !seat->drag) + wlr_cursor_set_xcursor(cursor, cursor_mgr, "default"); + + pointerfocus(c, surface, sx, sy, time); +} + +void +motionrelative(struct wl_listener *listener, void *data) +{ + /* This event is forwarded by the cursor when a pointer emits a _relative_ + * pointer motion event (i.e. a delta) */ + struct wlr_pointer_motion_event *event = data; + /* The cursor doesn't move unless we tell it to. The cursor automatically + * handles constraining the motion to the output layout, as well as any + * special configuration applied for the specific input device which + * generated the event. You can pass NULL for the device if you want to move + * the cursor around without any input. */ + motionnotify(event->time_msec, &event->pointer->base, event->delta_x, event->delta_y, + event->unaccel_dx, event->unaccel_dy); +} + +void +moveresize(const Arg *arg) +{ + if (cursor_mode != CurNormal && cursor_mode != CurPressed) + return; + xytonode(cursor->x, cursor->y, NULL, &grabc, NULL, NULL, NULL); + if (!grabc || client_is_unmanaged(grabc) || grabc->isfullscreen) + return; + + /* Float the window and tell motionnotify to grab it */ + setfloating(grabc, 1); + switch (cursor_mode = arg->ui) { + case CurMove: + grabcx = (int)round(cursor->x) - grabc->geom.x; + grabcy = (int)round(cursor->y) - grabc->geom.y; + wlr_cursor_set_xcursor(cursor, cursor_mgr, "fleur"); + break; + case CurResize: + /* Doesn't work for X11 output - the next absolute motion event + * returns the cursor to where it started */ + wlr_cursor_warp_closest(cursor, NULL, + grabc->geom.x + grabc->geom.width, + grabc->geom.y + grabc->geom.height); + wlr_cursor_set_xcursor(cursor, cursor_mgr, "se-resize"); + break; + } +} + +void +outputmgrapply(struct wl_listener *listener, void *data) +{ + struct wlr_output_configuration_v1 *config = data; + outputmgrapplyortest(config, 0); +} + +void +outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test) +{ + /* + * Called when a client such as wlr-randr requests a change in output + * configuration. This is only one way that the layout can be changed, + * so any Monitor information should be updated by updatemons() after an + * output_layout.change event, not here. + */ + struct wlr_output_configuration_head_v1 *config_head; + int ok = 1; + + wl_list_for_each(config_head, &config->heads, link) { + struct wlr_output *wlr_output = config_head->state.output; + Monitor *m = wlr_output->data; + struct wlr_output_state state; + + /* Ensure displays previously disabled by wlr-output-power-management-v1 + * are properly handled*/ + m->asleep = 0; + + wlr_output_state_init(&state); + wlr_output_state_set_enabled(&state, config_head->state.enabled); + if (!config_head->state.enabled) + goto apply_or_test; + + if (config_head->state.mode) + wlr_output_state_set_mode(&state, config_head->state.mode); + else + wlr_output_state_set_custom_mode(&state, + config_head->state.custom_mode.width, + config_head->state.custom_mode.height, + config_head->state.custom_mode.refresh); + + wlr_output_state_set_transform(&state, config_head->state.transform); + wlr_output_state_set_scale(&state, config_head->state.scale); + wlr_output_state_set_adaptive_sync_enabled(&state, + config_head->state.adaptive_sync_enabled); + +apply_or_test: + ok &= test ? wlr_output_test_state(wlr_output, &state) + : wlr_output_commit_state(wlr_output, &state); + + /* Don't move monitors if position wouldn't change, this to avoid + * wlroots marking the output as manually configured. + * wlr_output_layout_add does not like disabled outputs */ + if (!test && wlr_output->enabled && (m->m.x != config_head->state.x || m->m.y != config_head->state.y)) + wlr_output_layout_add(output_layout, wlr_output, + config_head->state.x, config_head->state.y); + + wlr_output_state_finish(&state); + } + + if (ok) + wlr_output_configuration_v1_send_succeeded(config); + else + wlr_output_configuration_v1_send_failed(config); + wlr_output_configuration_v1_destroy(config); + + /* https://codeberg.org/dwl/dwl/issues/577 */ + updatemons(NULL, NULL); +} + +void +outputmgrtest(struct wl_listener *listener, void *data) +{ + struct wlr_output_configuration_v1 *config = data; + outputmgrapplyortest(config, 1); +} + +void +pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy, + uint32_t time) +{ + struct timespec now; + + if (surface != seat->pointer_state.focused_surface && + sloppyfocus && time && c && !client_is_unmanaged(c)) + focusclient(c, 0); + + /* If surface is NULL, clear pointer focus */ + if (!surface) { + wlr_seat_pointer_notify_clear_focus(seat); + return; + } + + if (!time) { + clock_gettime(CLOCK_MONOTONIC, &now); + time = now.tv_sec * 1000 + now.tv_nsec / 1000000; + } + + /* Let the client know that the mouse cursor has entered one + * of its surfaces, and make keyboard focus follow if desired. + * wlroots makes this a no-op if surface is already focused */ + wlr_seat_pointer_notify_enter(seat, surface, sx, sy); + wlr_seat_pointer_notify_motion(seat, time, sx, sy); +} + +void +printstatus(void) +{ + Monitor *m = NULL; + Client *c; + uint32_t occ, urg, sel; + const char *appid, *title; + + wl_list_for_each(m, &mons, link) { + occ = urg = 0; + wl_list_for_each(c, &clients, link) { + if (c->mon != m) + continue; + occ |= c->tags; + if (c->isurgent) + urg |= c->tags; + } + if ((c = focustop(m))) { + title = client_get_title(c); + appid = client_get_appid(c); + printf("%s title %s\n", m->wlr_output->name, title ? title : broken); + printf("%s appid %s\n", m->wlr_output->name, appid ? appid : broken); + printf("%s fullscreen %d\n", m->wlr_output->name, c->isfullscreen); + printf("%s floating %d\n", m->wlr_output->name, c->isfloating); + sel = c->tags; + } else { + printf("%s title \n", m->wlr_output->name); + printf("%s appid \n", m->wlr_output->name); + printf("%s fullscreen \n", m->wlr_output->name); + printf("%s floating \n", m->wlr_output->name); + sel = 0; + } + + printf("%s selmon %u\n", m->wlr_output->name, m == selmon); + printf("%s tags %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32"\n", + m->wlr_output->name, occ, m->tagset[m->seltags], sel, urg); + printf("%s layout %s\n", m->wlr_output->name, m->ltsymbol); + } + fflush(stdout); +} + +void +powermgrsetmode(struct wl_listener *listener, void *data) +{ + struct wlr_output_power_v1_set_mode_event *event = data; + struct wlr_output_state state = {0}; + Monitor *m = event->output->data; + + if (!m) + return; + + m->gamma_lut_changed = 1; /* Reapply gamma LUT when re-enabling the ouput */ + wlr_output_state_set_enabled(&state, event->mode); + wlr_output_commit_state(m->wlr_output, &state); + + m->asleep = !event->mode; +} + +void +quit(const Arg *arg) +{ + wl_display_terminate(dpy); +} + +void +rendermon(struct wl_listener *listener, void *data) +{ + /* This function is called every time an output is ready to display a frame, + * generally at the output's refresh rate (e.g. 60Hz). */ + Monitor *m = wl_container_of(listener, m, frame); + Client *c; + struct wlr_output_state pending = {0}; + struct wlr_gamma_control_v1 *gamma_control; + struct timespec now; + + /* Render if no XDG clients have an outstanding resize and are visible on + * this monitor. */ + wl_list_for_each(c, &clients, link) { + if (c->resize && !c->isfloating && client_is_rendered_on_mon(c, m) && !client_is_stopped(c)) + goto skip; + } + + /* + * HACK: The "correct" way to set the gamma is to commit it together with + * the rest of the state in one go, but to do that we would need to rewrite + * wlr_scene_output_commit() in order to add the gamma to the pending + * state before committing, instead try to commit the gamma in one frame, + * and commit the rest of the state in the next one (or in the same frame if + * the gamma can not be committed). + */ + if (m->gamma_lut_changed) { + gamma_control + = wlr_gamma_control_manager_v1_get_control(gamma_control_mgr, m->wlr_output); + m->gamma_lut_changed = 0; + + if (!wlr_gamma_control_v1_apply(gamma_control, &pending)) + goto commit; + + if (!wlr_output_test_state(m->wlr_output, &pending)) { + wlr_gamma_control_v1_send_failed_and_destroy(gamma_control); + goto commit; + } + wlr_output_commit_state(m->wlr_output, &pending); + wlr_output_schedule_frame(m->wlr_output); + } else { +commit: + wlr_scene_output_commit(m->scene_output, NULL); + } + +skip: + /* Let clients know a frame has been rendered */ + clock_gettime(CLOCK_MONOTONIC, &now); + wlr_scene_output_send_frame_done(m->scene_output, &now); + wlr_output_state_finish(&pending); +} + +void +requestdecorationmode(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, set_decoration_mode); + wlr_xdg_toplevel_decoration_v1_set_mode(c->decoration, + WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE); +} + +void +requeststartdrag(struct wl_listener *listener, void *data) +{ + struct wlr_seat_request_start_drag_event *event = data; + + if (wlr_seat_validate_pointer_grab_serial(seat, event->origin, + event->serial)) + wlr_seat_start_pointer_drag(seat, event->drag, event->serial); + else + wlr_data_source_destroy(event->drag->source); +} + +void +requestmonstate(struct wl_listener *listener, void *data) +{ + struct wlr_output_event_request_state *event = data; + wlr_output_commit_state(event->output, event->state); + updatemons(NULL, NULL); +} + +void +resize(Client *c, struct wlr_box geo, int interact) +{ + struct wlr_box *bbox; + struct wlr_box clip; + + if (!c->mon || !c->scene) + return; + + bbox = interact ? &sgeom : &c->mon->w; + + client_set_bounds(c, geo.width, geo.height); + c->geom = geo; + applybounds(c, bbox); + + /* Update scene-graph, including borders */ + wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y); + wlr_scene_node_set_position(&c->scene_surface->node, c->bw, c->bw); + wlr_scene_rect_set_size(c->border[0], c->geom.width, c->bw); + wlr_scene_rect_set_size(c->border[1], c->geom.width, c->bw); + wlr_scene_rect_set_size(c->border[2], c->bw, c->geom.height - 2 * c->bw); + wlr_scene_rect_set_size(c->border[3], c->bw, c->geom.height - 2 * c->bw); + wlr_scene_node_set_position(&c->border[1]->node, 0, c->geom.height - c->bw); + wlr_scene_node_set_position(&c->border[2]->node, 0, c->bw); + wlr_scene_node_set_position(&c->border[3]->node, c->geom.width - c->bw, c->bw); + + /* this is a no-op if size hasn't changed */ + c->resize = client_set_size(c, c->geom.width - 2 * c->bw, + c->geom.height - 2 * c->bw); + client_get_clip(c, &clip); + wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip); +} + +void +run(char *startup_cmd) +{ + /* Add a Unix socket to the Wayland display. */ + const char *socket = wl_display_add_socket_auto(dpy); + if (!socket) + die("startup: display_add_socket_auto"); + setenv("WAYLAND_DISPLAY", socket, 1); + + /* Start the backend. This will enumerate outputs and inputs, become the DRM + * master, etc */ + if (!wlr_backend_start(backend)) + die("startup: backend_start"); + + /* Now that the socket exists and the backend is started, run the startup command */ + if (startup_cmd) { + int piperw[2]; + if (pipe(piperw) < 0) + die("startup: pipe:"); + if ((child_pid = fork()) < 0) + die("startup: fork:"); + if (child_pid == 0) { + setsid(); + dup2(piperw[0], STDIN_FILENO); + close(piperw[0]); + close(piperw[1]); + execl("/bin/sh", "/bin/sh", "-c", startup_cmd, NULL); + die("startup: execl:"); + } + dup2(piperw[1], STDOUT_FILENO); + close(piperw[1]); + close(piperw[0]); + } + + /* Mark stdout as non-blocking to avoid people who does not close stdin + * nor consumes it in their startup script getting dwl frozen */ + if (fd_set_nonblock(STDOUT_FILENO) < 0) + close(STDOUT_FILENO); + + printstatus(); + + /* At this point the outputs are initialized, choose initial selmon based on + * cursor position, and set default cursor image */ + selmon = xytomon(cursor->x, cursor->y); + + /* TODO hack to get cursor to display in its initial location (100, 100) + * instead of (0, 0) and then jumping. still may not be fully + * initialized, as the image/coordinates are not transformed for the + * monitor when displayed here */ + wlr_cursor_warp_closest(cursor, NULL, cursor->x, cursor->y); + wlr_cursor_set_xcursor(cursor, cursor_mgr, "default"); + + /* Run the Wayland event loop. This does not return until you exit the + * compositor. Starting the backend rigged up all of the necessary event + * loop configuration to listen to libinput events, DRM events, generate + * frame events at the refresh rate, and so on. */ + wl_display_run(dpy); +} + +void +setcursor(struct wl_listener *listener, void *data) +{ + /* This event is raised by the seat when a client provides a cursor image */ + struct wlr_seat_pointer_request_set_cursor_event *event = data; + /* If we're "grabbing" the cursor, don't use the client's image, we will + * restore it after "grabbing" sending a leave event, followed by a enter + * event, which will result in the client requesting set the cursor surface */ + if (cursor_mode != CurNormal && cursor_mode != CurPressed) + return; + /* This can be sent by any client, so we check to make sure this one is + * actually has pointer focus first. If so, we can tell the cursor to + * use the provided surface as the cursor image. It will set the + * hardware cursor on the output that it's currently on and continue to + * do so as the cursor moves between outputs. */ + if (event->seat_client == seat->pointer_state.focused_client) + wlr_cursor_set_surface(cursor, event->surface, + event->hotspot_x, event->hotspot_y); +} + +void +setcursorshape(struct wl_listener *listener, void *data) +{ + struct wlr_cursor_shape_manager_v1_request_set_shape_event *event = data; + if (cursor_mode != CurNormal && cursor_mode != CurPressed) + return; + /* This can be sent by any client, so we check to make sure this one is + * actually has pointer focus first. If so, we can tell the cursor to + * use the provided cursor shape. */ + if (event->seat_client == seat->pointer_state.focused_client) + wlr_cursor_set_xcursor(cursor, cursor_mgr, + wlr_cursor_shape_v1_name(event->shape)); +} + +void +setfloating(Client *c, int floating) +{ + c->isfloating = floating; + /* If in floating layout do not change the client's layer */ + if (!c->mon || !client_surface(c)->mapped || !c->mon->lt[c->mon->sellt]->arrange) + return; + wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen + ? LyrFS : c->isfloating ? LyrFloat : LyrTile]); + arrange(c->mon); + printstatus(); +} + +void +setfullscreen(Client *c, int fullscreen) +{ + c->isfullscreen = fullscreen; + if (!c->mon || !client_surface(c)->mapped) + return; + c->bw = fullscreen ? 0 : borderpx; + client_set_fullscreen(c, fullscreen); + wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen + ? LyrFS : c->isfloating ? LyrFloat : LyrTile]); + + if (fullscreen) { + c->prev = c->geom; + resize(c, c->mon->m, 0); + } else { + /* restore previous size instead of arrange for floating windows since + * client positions are set by the user and cannot be recalculated */ + resize(c, c->prev, 0); + } + arrange(c->mon); + printstatus(); +} + +void +setgamma(struct wl_listener *listener, void *data) +{ + struct wlr_gamma_control_manager_v1_set_gamma_event *event = data; + Monitor *m = event->output->data; + if (!m) + return; + m->gamma_lut_changed = 1; + wlr_output_schedule_frame(m->wlr_output); +} + +void +setlayout(const Arg *arg) +{ + if (!selmon) + return; + if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt]) + selmon->sellt ^= 1; + if (arg && arg->v) + selmon->lt[selmon->sellt] = (Layout *)arg->v; + strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, LENGTH(selmon->ltsymbol)); + arrange(selmon); + printstatus(); +} + +/* arg > 1.0 will set mfact absolutely */ +void +setmfact(const Arg *arg) +{ + float f; + + if (!arg || !selmon || !selmon->lt[selmon->sellt]->arrange) + return; + f = arg->f < 1.0f ? arg->f + selmon->mfact : arg->f - 1.0f; + if (f < 0.1 || f > 0.9) + return; + selmon->mfact = f; + arrange(selmon); +} + +void +setmon(Client *c, Monitor *m, uint32_t newtags) +{ + Monitor *oldmon = c->mon; + + if (oldmon == m) + return; + c->mon = m; + c->prev = c->geom; + + /* Scene graph sends surface leave/enter events on move and resize */ + if (oldmon) + arrange(oldmon); + if (m) { + /* Make sure window actually overlaps with the monitor */ + resize(c, c->geom, 0); + c->tags = newtags ? newtags : m->tagset[m->seltags]; /* assign tags of target monitor */ + setfullscreen(c, c->isfullscreen); /* This will call arrange(c->mon) */ + setfloating(c, c->isfloating); + } + focusclient(focustop(selmon), 1); +} + +void +setpsel(struct wl_listener *listener, void *data) +{ + /* This event is raised by the seat when a client wants to set the selection, + * usually when the user copies something. wlroots allows compositors to + * ignore such requests if they so choose, but in dwl we always honor + */ + struct wlr_seat_request_set_primary_selection_event *event = data; + wlr_seat_set_primary_selection(seat, event->source, event->serial); +} + +void +setsel(struct wl_listener *listener, void *data) +{ + /* This event is raised by the seat when a client wants to set the selection, + * usually when the user copies something. wlroots allows compositors to + * ignore such requests if they so choose, but in dwl we always honor + */ + struct wlr_seat_request_set_selection_event *event = data; + wlr_seat_set_selection(seat, event->source, event->serial); +} + +void +setup(void) +{ + int i, sig[] = {SIGCHLD, SIGINT, SIGTERM, SIGPIPE}; + struct sigaction sa = {.sa_flags = SA_RESTART, .sa_handler = handlesig}; + sigemptyset(&sa.sa_mask); + + for (i = 0; i < (int)LENGTH(sig); i++) + sigaction(sig[i], &sa, NULL); + + wlr_log_init(log_level, NULL); + + /* The Wayland display is managed by libwayland. It handles accepting + * clients from the Unix socket, manging Wayland globals, and so on. */ + dpy = wl_display_create(); + + /* The backend is a wlroots feature which abstracts the underlying input and + * output hardware. The autocreate option will choose the most suitable + * backend based on the current environment, such as opening an X11 window + * if an X11 server is running. */ + if (!(backend = wlr_backend_autocreate(dpy, &session))) + die("couldn't create backend"); + + /* Initialize the scene graph used to lay out windows */ + scene = wlr_scene_create(); + root_bg = wlr_scene_rect_create(&scene->tree, 0, 0, rootcolor); + for (i = 0; i < NUM_LAYERS; i++) + layers[i] = wlr_scene_tree_create(&scene->tree); + drag_icon = wlr_scene_tree_create(&scene->tree); + wlr_scene_node_place_below(&drag_icon->node, &layers[LyrBlock]->node); + + /* Autocreates a renderer, either Pixman, GLES2 or Vulkan for us. The user + * can also specify a renderer using the WLR_RENDERER env var. + * The renderer is responsible for defining the various pixel formats it + * supports for shared memory, this configures that for clients. */ + if (!(drw = wlr_renderer_autocreate(backend))) + die("couldn't create renderer"); + + /* Create shm, drm and linux_dmabuf interfaces by ourselves. + * The simplest way is call: + * wlr_renderer_init_wl_display(drw); + * but we need to create manually the linux_dmabuf interface to integrate it + * with wlr_scene. */ + wlr_renderer_init_wl_shm(drw, dpy); + + if (wlr_renderer_get_dmabuf_texture_formats(drw)) { + wlr_drm_create(dpy, drw); + wlr_scene_set_linux_dmabuf_v1(scene, + wlr_linux_dmabuf_v1_create_with_renderer(dpy, 4, drw)); + } + + /* Autocreates an allocator for us. + * The allocator is the bridge between the renderer and the backend. It + * handles the buffer creation, allowing wlroots to render onto the + * screen */ + if (!(alloc = wlr_allocator_autocreate(backend, drw))) + die("couldn't create allocator"); + + /* This creates some hands-off wlroots interfaces. The compositor is + * necessary for clients to allocate surfaces and the data device manager + * handles the clipboard. Each of these wlroots interfaces has room for you + * to dig your fingers in and play with their behavior if you want. Note that + * the clients cannot set the selection directly without compositor approval, + * see the setsel() function. */ + compositor = wlr_compositor_create(dpy, 6, drw); + wlr_subcompositor_create(dpy); + wlr_data_device_manager_create(dpy); + wlr_export_dmabuf_manager_v1_create(dpy); + wlr_screencopy_manager_v1_create(dpy); + wlr_data_control_manager_v1_create(dpy); + wlr_primary_selection_v1_device_manager_create(dpy); + wlr_viewporter_create(dpy); + wlr_single_pixel_buffer_manager_v1_create(dpy); + wlr_fractional_scale_manager_v1_create(dpy, 1); + + /* Initializes the interface used to implement urgency hints */ + activation = wlr_xdg_activation_v1_create(dpy); + LISTEN_STATIC(&activation->events.request_activate, urgent); + + gamma_control_mgr = wlr_gamma_control_manager_v1_create(dpy); + LISTEN_STATIC(&gamma_control_mgr->events.set_gamma, setgamma); + + power_mgr = wlr_output_power_manager_v1_create(dpy); + LISTEN_STATIC(&power_mgr->events.set_mode, powermgrsetmode); + + /* Creates an output layout, which a wlroots utility for working with an + * arrangement of screens in a physical layout. */ + output_layout = wlr_output_layout_create(); + LISTEN_STATIC(&output_layout->events.change, updatemons); + wlr_xdg_output_manager_v1_create(dpy, output_layout); + + /* Configure a listener to be notified when new outputs are available on the + * backend. */ + wl_list_init(&mons); + LISTEN_STATIC(&backend->events.new_output, createmon); + + /* Set up our client lists, the xdg-shell and the layer-shell. The xdg-shell is a + * Wayland protocol which is used for application windows. For more + * detail on shells, refer to the article: + * + * https://drewdevault.com/2018/07/29/Wayland-shells.html + */ + wl_list_init(&clients); + wl_list_init(&fstack); + + xdg_shell = wlr_xdg_shell_create(dpy, 6); + LISTEN_STATIC(&xdg_shell->events.new_surface, createnotify); + + layer_shell = wlr_layer_shell_v1_create(dpy, 3); + LISTEN_STATIC(&layer_shell->events.new_surface, createlayersurface); + + idle_notifier = wlr_idle_notifier_v1_create(dpy); + + idle_inhibit_mgr = wlr_idle_inhibit_v1_create(dpy); + LISTEN_STATIC(&idle_inhibit_mgr->events.new_inhibitor, createidleinhibitor); + + session_lock_mgr = wlr_session_lock_manager_v1_create(dpy); + wl_signal_add(&session_lock_mgr->events.new_lock, &lock_listener); + LISTEN_STATIC(&session_lock_mgr->events.destroy, destroysessionmgr); + locked_bg = wlr_scene_rect_create(layers[LyrBlock], sgeom.width, sgeom.height, + (float [4]){0.1f, 0.1f, 0.1f, 1.0f}); + wlr_scene_node_set_enabled(&locked_bg->node, 0); + + /* Use decoration protocols to negotiate server-side decorations */ + wlr_server_decoration_manager_set_default_mode( + wlr_server_decoration_manager_create(dpy), + WLR_SERVER_DECORATION_MANAGER_MODE_SERVER); + xdg_decoration_mgr = wlr_xdg_decoration_manager_v1_create(dpy); + LISTEN_STATIC(&xdg_decoration_mgr->events.new_toplevel_decoration, createdecoration); + + pointer_constraints = wlr_pointer_constraints_v1_create(dpy); + LISTEN_STATIC(&pointer_constraints->events.new_constraint, createpointerconstraint); + + relative_pointer_mgr = wlr_relative_pointer_manager_v1_create(dpy); + + /* + * Creates a cursor, which is a wlroots utility for tracking the cursor + * image shown on screen. + */ + cursor = wlr_cursor_create(); + wlr_cursor_attach_output_layout(cursor, output_layout); + + /* Creates an xcursor manager, another wlroots utility which loads up + * Xcursor themes to source cursor images from and makes sure that cursor + * images are available at all scale factors on the screen (necessary for + * HiDPI support). Scaled cursors will be loaded with each output. */ + cursor_mgr = wlr_xcursor_manager_create(NULL, 24); + setenv("XCURSOR_SIZE", "24", 1); + + /* + * wlr_cursor *only* displays an image on screen. It does not move around + * when the pointer moves. However, we can attach input devices to it, and + * it will generate aggregate events for all of them. In these events, we + * can choose how we want to process them, forwarding them to clients and + * moving the cursor around. More detail on this process is described in + * https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html + * + * And more comments are sprinkled throughout the notify functions above. + */ + LISTEN_STATIC(&cursor->events.motion, motionrelative); + LISTEN_STATIC(&cursor->events.motion_absolute, motionabsolute); + LISTEN_STATIC(&cursor->events.button, buttonpress); + LISTEN_STATIC(&cursor->events.axis, axisnotify); + LISTEN_STATIC(&cursor->events.frame, cursorframe); + + cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1); + LISTEN_STATIC(&cursor_shape_mgr->events.request_set_shape, setcursorshape); + + /* + * Configures a seat, which is a single "seat" at which a user sits and + * operates the computer. This conceptually includes up to one keyboard, + * pointer, touch, and drawing tablet device. We also rig up a listener to + * let us know when new input devices are available on the backend. + */ + LISTEN_STATIC(&backend->events.new_input, inputdevice); + virtual_keyboard_mgr = wlr_virtual_keyboard_manager_v1_create(dpy); + LISTEN_STATIC(&virtual_keyboard_mgr->events.new_virtual_keyboard, virtualkeyboard); + virtual_pointer_mgr = wlr_virtual_pointer_manager_v1_create(dpy); + LISTEN_STATIC(&virtual_pointer_mgr->events.new_virtual_pointer, virtualpointer); + + seat = wlr_seat_create(dpy, "seat0"); + LISTEN_STATIC(&seat->events.request_set_cursor, setcursor); + LISTEN_STATIC(&seat->events.request_set_selection, setsel); + LISTEN_STATIC(&seat->events.request_set_primary_selection, setpsel); + LISTEN_STATIC(&seat->events.request_start_drag, requeststartdrag); + LISTEN_STATIC(&seat->events.start_drag, startdrag); + + kb_group = createkeyboardgroup(); + wl_list_init(&kb_group->destroy.link); + + output_mgr = wlr_output_manager_v1_create(dpy); + LISTEN_STATIC(&output_mgr->events.apply, outputmgrapply); + LISTEN_STATIC(&output_mgr->events.test, outputmgrtest); + + wlr_scene_set_presentation(scene, wlr_presentation_create(dpy, backend)); + + /* Make sure XWayland clients don't connect to the parent X server, + * e.g when running in the x11 backend or the wayland backend and the + * compositor has Xwayland support */ + unsetenv("DISPLAY"); +#ifdef XWAYLAND + /* + * Initialise the XWayland X server. + * It will be started when the first X client is started. + */ + if ((xwayland = wlr_xwayland_create(dpy, compositor, 1))) { + LISTEN_STATIC(&xwayland->events.ready, xwaylandready); + LISTEN_STATIC(&xwayland->events.new_surface, createnotifyx11); + + setenv("DISPLAY", xwayland->display_name, 1); + } else { + fprintf(stderr, "failed to setup XWayland X server, continuing without it\n"); + } +#endif +} + +void +spawn(const Arg *arg) +{ + if (fork() == 0) { + dup2(STDERR_FILENO, STDOUT_FILENO); + setsid(); + execvp(((char **)arg->v)[0], (char **)arg->v); + die("dwl: execvp %s failed:", ((char **)arg->v)[0]); + } +} + +void +startdrag(struct wl_listener *listener, void *data) +{ + struct wlr_drag *drag = data; + if (!drag->icon) + return; + + drag->icon->data = &wlr_scene_drag_icon_create(drag_icon, drag->icon)->node; + LISTEN_STATIC(&drag->icon->events.destroy, destroydragicon); +} + +void +tag(const Arg *arg) +{ + Client *sel = focustop(selmon); + if (!sel || (arg->ui & TAGMASK) == 0) + return; + + sel->tags = arg->ui & TAGMASK; + focusclient(focustop(selmon), 1); + arrange(selmon); + printstatus(); +} + +void +tagmon(const Arg *arg) +{ + Client *sel = focustop(selmon); + if (sel) + setmon(sel, dirtomon(arg->i), 0); +} + +void +tile(Monitor *m) +{ + unsigned int mw, my, ty; + int i, n = 0; + Client *c; + + wl_list_for_each(c, &clients, link) + if (VISIBLEON(c, m) && !c->isfloating && !c->isfullscreen) + n++; + if (n == 0) + return; + + if (n > m->nmaster) + mw = m->nmaster ? (int)roundf(m->w.width * m->mfact) : 0; + else + mw = m->w.width; + i = my = ty = 0; + wl_list_for_each(c, &clients, link) { + if (!VISIBLEON(c, m) || c->isfloating || c->isfullscreen) + continue; + if (i < m->nmaster) { + resize(c, (struct wlr_box){.x = m->w.x, .y = m->w.y + my, .width = mw, + .height = (m->w.height - my) / (MIN(n, m->nmaster) - i)}, 0); + my += c->geom.height; + } else { + resize(c, (struct wlr_box){.x = m->w.x + mw, .y = m->w.y + ty, + .width = m->w.width - mw, .height = (m->w.height - ty) / (n - i)}, 0); + ty += c->geom.height; + } + i++; + } +} + +void +togglefloating(const Arg *arg) +{ + Client *sel = focustop(selmon); + /* return if fullscreen */ + if (sel && !sel->isfullscreen) + setfloating(sel, !sel->isfloating); +} + +void +togglefullscreen(const Arg *arg) +{ + Client *sel = focustop(selmon); + if (sel) + setfullscreen(sel, !sel->isfullscreen); +} + +void +toggletag(const Arg *arg) +{ + uint32_t newtags; + Client *sel = focustop(selmon); + if (!sel || !(newtags = sel->tags ^ (arg->ui & TAGMASK))) + return; + + sel->tags = newtags; + focusclient(focustop(selmon), 1); + arrange(selmon); + printstatus(); +} + +void +toggleview(const Arg *arg) +{ + uint32_t newtagset; + if (!(newtagset = selmon ? selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK) : 0)) + return; + + selmon->tagset[selmon->seltags] = newtagset; + focusclient(focustop(selmon), 1); + arrange(selmon); + printstatus(); +} + +void +unlocksession(struct wl_listener *listener, void *data) +{ + SessionLock *lock = wl_container_of(listener, lock, unlock); + destroylock(lock, 1); +} + +void +unmaplayersurfacenotify(struct wl_listener *listener, void *data) +{ + LayerSurface *l = wl_container_of(listener, l, unmap); + + l->mapped = 0; + wlr_scene_node_set_enabled(&l->scene->node, 0); + if (l == exclusive_focus) + exclusive_focus = NULL; + if (l->layer_surface->output && (l->mon = l->layer_surface->output->data)) + arrangelayers(l->mon); + if (l->layer_surface->surface == seat->keyboard_state.focused_surface) + focusclient(focustop(selmon), 1); + motionnotify(0, NULL, 0, 0, 0, 0); +} + +void +unmapnotify(struct wl_listener *listener, void *data) +{ + /* Called when the surface is unmapped, and should no longer be shown. */ + Client *c = wl_container_of(listener, c, unmap); + if (c == grabc) { + cursor_mode = CurNormal; + grabc = NULL; + } + + if (client_is_unmanaged(c)) { + if (c == exclusive_focus) { + exclusive_focus = NULL; + focusclient(focustop(selmon), 1); + } + } else { + wl_list_remove(&c->link); + setmon(c, NULL, 0); + wl_list_remove(&c->flink); + } + + wlr_scene_node_destroy(&c->scene->node); + printstatus(); + motionnotify(0, NULL, 0, 0, 0, 0); +} + +void +updatemons(struct wl_listener *listener, void *data) +{ + /* + * Called whenever the output layout changes: adding or removing a + * monitor, changing an output's mode or position, etc. This is where + * the change officially happens and we update geometry, window + * positions, focus, and the stored configuration in wlroots' + * output-manager implementation. + */ + struct wlr_output_configuration_v1 *config + = wlr_output_configuration_v1_create(); + Client *c; + struct wlr_output_configuration_head_v1 *config_head; + Monitor *m; + + /* First remove from the layout the disabled monitors */ + wl_list_for_each(m, &mons, link) { + if (m->wlr_output->enabled || m->asleep) + continue; + config_head = wlr_output_configuration_head_v1_create(config, m->wlr_output); + config_head->state.enabled = 0; + /* Remove this output from the layout to avoid cursor enter inside it */ + wlr_output_layout_remove(output_layout, m->wlr_output); + closemon(m); + m->m = m->w = (struct wlr_box){0}; + } + /* Insert outputs that need to */ + wl_list_for_each(m, &mons, link) { + if (m->wlr_output->enabled + && !wlr_output_layout_get(output_layout, m->wlr_output)) + wlr_output_layout_add_auto(output_layout, m->wlr_output); + } + + /* Now that we update the output layout we can get its box */ + wlr_output_layout_get_box(output_layout, NULL, &sgeom); + + wlr_scene_node_set_position(&root_bg->node, sgeom.x, sgeom.y); + wlr_scene_rect_set_size(root_bg, sgeom.width, sgeom.height); + + /* Make sure the clients are hidden when dwl is locked */ + wlr_scene_node_set_position(&locked_bg->node, sgeom.x, sgeom.y); + wlr_scene_rect_set_size(locked_bg, sgeom.width, sgeom.height); + + wl_list_for_each(m, &mons, link) { + if (!m->wlr_output->enabled) + continue; + config_head = wlr_output_configuration_head_v1_create(config, m->wlr_output); + + /* Get the effective monitor geometry to use for surfaces */ + wlr_output_layout_get_box(output_layout, m->wlr_output, &m->m); + m->w = m->m; + wlr_scene_output_set_position(m->scene_output, m->m.x, m->m.y); + + wlr_scene_node_set_position(&m->fullscreen_bg->node, m->m.x, m->m.y); + wlr_scene_rect_set_size(m->fullscreen_bg, m->m.width, m->m.height); + + if (m->lock_surface) { + struct wlr_scene_tree *scene_tree = m->lock_surface->surface->data; + wlr_scene_node_set_position(&scene_tree->node, m->m.x, m->m.y); + wlr_session_lock_surface_v1_configure(m->lock_surface, m->m.width, m->m.height); + } + + /* Calculate the effective monitor geometry to use for clients */ + arrangelayers(m); + /* Don't move clients to the left output when plugging monitors */ + arrange(m); + /* make sure fullscreen clients have the right size */ + if ((c = focustop(m)) && c->isfullscreen) + resize(c, m->m, 0); + + /* Try to re-set the gamma LUT when updating monitors, + * it's only really needed when enabling a disabled output, but meh. */ + m->gamma_lut_changed = 1; + + config_head->state.x = m->m.x; + config_head->state.y = m->m.y; + + if (!selmon) { + selmon = m; + } + } + + if (selmon && selmon->wlr_output->enabled) { + wl_list_for_each(c, &clients, link) { + if (!c->mon && client_surface(c)->mapped) + setmon(c, selmon, c->tags); + } + focusclient(focustop(selmon), 1); + if (selmon->lock_surface) { + client_notify_enter(selmon->lock_surface->surface, + wlr_seat_get_keyboard(seat)); + client_activate_surface(selmon->lock_surface->surface, 1); + } + } + + /* FIXME: figure out why the cursor image is at 0,0 after turning all + * the monitors on. + * Move the cursor image where it used to be. It does not generate a + * wl_pointer.motion event for the clients, it's only the image what it's + * at the wrong position after all. */ + wlr_cursor_move(cursor, NULL, 0, 0); + + wlr_output_manager_v1_set_configuration(output_mgr, config); +} + +void +updatetitle(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, set_title); + if (c == focustop(c->mon)) + printstatus(); +} + +void +urgent(struct wl_listener *listener, void *data) +{ + struct wlr_xdg_activation_v1_request_activate_event *event = data; + Client *c = NULL; + toplevel_from_wlr_surface(event->surface, &c, NULL); + if (!c || c == focustop(selmon)) + return; + + c->isurgent = 1; + printstatus(); + + if (client_surface(c)->mapped) + client_set_border_color(c, urgentcolor); +} + +void +view(const Arg *arg) +{ + if (!selmon || (arg->ui & TAGMASK) == selmon->tagset[selmon->seltags]) + return; + selmon->seltags ^= 1; /* toggle sel tagset */ + if (arg->ui & TAGMASK) + selmon->tagset[selmon->seltags] = arg->ui & TAGMASK; + focusclient(focustop(selmon), 1); + arrange(selmon); + printstatus(); +} + +void +virtualkeyboard(struct wl_listener *listener, void *data) +{ + struct wlr_virtual_keyboard_v1 *kb = data; + /* virtual keyboards shouldn't share keyboard group */ + KeyboardGroup *group = createkeyboardgroup(); + /* Set the keymap to match the group keymap */ + wlr_keyboard_set_keymap(&kb->keyboard, group->wlr_group->keyboard.keymap); + LISTEN(&kb->keyboard.base.events.destroy, &group->destroy, destroykeyboardgroup); + + /* Add the new keyboard to the group */ + wlr_keyboard_group_add_keyboard(group->wlr_group, &kb->keyboard); +} + +void +virtualpointer(struct wl_listener *listener, void *data) +{ + struct wlr_virtual_pointer_v1_new_pointer_event *event = data; + struct wlr_pointer pointer = event->new_pointer->pointer; + + wlr_cursor_attach_input_device(cursor, &pointer.base); + if (event->suggested_output) + wlr_cursor_map_input_to_output(cursor, &pointer.base, event->suggested_output); +} + +Monitor * +xytomon(double x, double y) +{ + struct wlr_output *o = wlr_output_layout_output_at(output_layout, x, y); + return o ? o->data : NULL; +} + +void +xytonode(double x, double y, struct wlr_surface **psurface, + Client **pc, LayerSurface **pl, double *nx, double *ny) +{ + struct wlr_scene_node *node, *pnode; + struct wlr_surface *surface = NULL; + Client *c = NULL; + LayerSurface *l = NULL; + int layer; + + for (layer = NUM_LAYERS - 1; !surface && layer >= 0; layer--) { + if (!(node = wlr_scene_node_at(&layers[layer]->node, x, y, nx, ny))) + continue; + + if (node->type == WLR_SCENE_NODE_BUFFER) + surface = wlr_scene_surface_try_from_buffer( + wlr_scene_buffer_from_node(node))->surface; + /* Walk the tree to find a node that knows the client */ + for (pnode = node; pnode && !c; pnode = &pnode->parent->node) + c = pnode->data; + if (c && c->type == LayerShell) { + c = NULL; + l = pnode->data; + } + } + + if (psurface) *psurface = surface; + if (pc) *pc = c; + if (pl) *pl = l; +} + +void +zoom(const Arg *arg) +{ + Client *c, *sel = focustop(selmon); + + if (!sel || !selmon || !selmon->lt[selmon->sellt]->arrange || sel->isfloating) + return; + + /* Search for the first tiled window that is not sel, marking sel as + * NULL if we pass it along the way */ + wl_list_for_each(c, &clients, link) { + if (VISIBLEON(c, selmon) && !c->isfloating) { + if (c != sel) + break; + sel = NULL; + } + } + + /* Return if no other tiled window was found */ + if (&c->link == &clients) + return; + + /* If we passed sel, move c to the front; otherwise, move sel to the + * front */ + if (!sel) + sel = c; + wl_list_remove(&sel->link); + wl_list_insert(&clients, &sel->link); + + focusclient(sel, 1); + arrange(selmon); +} + +#ifdef XWAYLAND +void +activatex11(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, activate); + + /* Only "managed" windows can be activated */ + if (!client_is_unmanaged(c)) + wlr_xwayland_surface_activate(c->surface.xwayland, 1); +} + +void +associatex11(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, associate); + + LISTEN(&client_surface(c)->events.map, &c->map, mapnotify); + LISTEN(&client_surface(c)->events.unmap, &c->unmap, unmapnotify); +} + +void +configurex11(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, configure); + struct wlr_xwayland_surface_configure_event *event = data; + /* TODO: figure out if there is another way to do this */ + if (!c->mon) { + wlr_xwayland_surface_configure(c->surface.xwayland, + event->x, event->y, event->width, event->height); + return; + } + if (c->isfloating || client_is_unmanaged(c)) + resize(c, (struct wlr_box){.x = event->x, .y = event->y, + .width = event->width + c->bw * 2, .height = event->height + c->bw * 2}, 0); + else + arrange(c->mon); +} + +void +createnotifyx11(struct wl_listener *listener, void *data) +{ + struct wlr_xwayland_surface *xsurface = data; + Client *c; + + /* Allocate a Client for this surface */ + c = xsurface->data = ecalloc(1, sizeof(*c)); + c->surface.xwayland = xsurface; + c->type = X11; + c->bw = client_is_unmanaged(c) ? 0 : borderpx; + + /* Listen to the various events it can emit */ + LISTEN(&xsurface->events.associate, &c->associate, associatex11); + LISTEN(&xsurface->events.destroy, &c->destroy, destroynotify); + LISTEN(&xsurface->events.dissociate, &c->dissociate, dissociatex11); + LISTEN(&xsurface->events.request_activate, &c->activate, activatex11); + LISTEN(&xsurface->events.request_configure, &c->configure, configurex11); + LISTEN(&xsurface->events.request_fullscreen, &c->fullscreen, fullscreennotify); + LISTEN(&xsurface->events.set_hints, &c->set_hints, sethints); + LISTEN(&xsurface->events.set_title, &c->set_title, updatetitle); +} + +void +dissociatex11(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, dissociate); + wl_list_remove(&c->map.link); + wl_list_remove(&c->unmap.link); +} + +xcb_atom_t +getatom(xcb_connection_t *xc, const char *name) +{ + xcb_atom_t atom = 0; + xcb_intern_atom_reply_t *reply; + xcb_intern_atom_cookie_t cookie = xcb_intern_atom(xc, 0, strlen(name), name); + if ((reply = xcb_intern_atom_reply(xc, cookie, NULL))) + atom = reply->atom; + free(reply); + + return atom; +} + +void +sethints(struct wl_listener *listener, void *data) +{ + Client *c = wl_container_of(listener, c, set_hints); + struct wlr_surface *surface = client_surface(c); + if (c == focustop(selmon)) + return; + + c->isurgent = xcb_icccm_wm_hints_get_urgency(c->surface.xwayland->hints); + printstatus(); + + if (c->isurgent && surface && surface->mapped) + client_set_border_color(c, urgentcolor); +} + +void +xwaylandready(struct wl_listener *listener, void *data) +{ + struct wlr_xcursor *xcursor; + xcb_connection_t *xc = xcb_connect(xwayland->display_name, NULL); + int err = xcb_connection_has_error(xc); + if (err) { + fprintf(stderr, "xcb_connect to X server failed with code %d\n. Continuing with degraded functionality.\n", err); + return; + } + + /* Collect atoms we are interested in. If getatom returns 0, we will + * not detect that window type. */ + netatom[NetWMWindowTypeDialog] = getatom(xc, "_NET_WM_WINDOW_TYPE_DIALOG"); + netatom[NetWMWindowTypeSplash] = getatom(xc, "_NET_WM_WINDOW_TYPE_SPLASH"); + netatom[NetWMWindowTypeToolbar] = getatom(xc, "_NET_WM_WINDOW_TYPE_TOOLBAR"); + netatom[NetWMWindowTypeUtility] = getatom(xc, "_NET_WM_WINDOW_TYPE_UTILITY"); + + /* assign the one and only seat */ + wlr_xwayland_set_seat(xwayland, seat); + + /* Set the default XWayland cursor to match the rest of dwl. */ + if ((xcursor = wlr_xcursor_manager_get_xcursor(cursor_mgr, "default", 1))) + wlr_xwayland_set_cursor(xwayland, + xcursor->images[0]->buffer, xcursor->images[0]->width * 4, + xcursor->images[0]->width, xcursor->images[0]->height, + xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y); + + xcb_disconnect(xc); +} +#endif + +int +main(int argc, char *argv[]) +{ + char *startup_cmd = NULL; + int c; + + while ((c = getopt(argc, argv, "s:hdv")) != -1) { + if (c == 's') + startup_cmd = optarg; + else if (c == 'd') + log_level = WLR_DEBUG; + else if (c == 'v') + die("dwl " VERSION); + else + goto usage; + } + if (optind < argc) + goto usage; + + /* Wayland requires XDG_RUNTIME_DIR for creating its communications socket */ + if (!getenv("XDG_RUNTIME_DIR")) + die("XDG_RUNTIME_DIR must be set"); + setup(); + run(startup_cmd); + cleanup(); + return EXIT_SUCCESS; + +usage: + die("Usage: %s [-v] [-d] [-s startup command]", argv[0]); +} diff --git a/dwl.desktop b/dwl.desktop new file mode 100644 index 0000000..e1380f7 --- /dev/null +++ b/dwl.desktop @@ -0,0 +1,5 @@ +[Desktop Entry] +Name=dwl +Comment=dwm for Wayland +Exec=dwl +Type=Application diff --git a/dwl.o b/dwl.o new file mode 100644 index 0000000000000000000000000000000000000000..27f03148f92218d37b43ae457b4d7ccec52be3f4 GIT binary patch literal 275992 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 akH4ILyy}ztW+S{r?98v$7=s literal 0 HcmV?d00001 diff --git a/install b/install new file mode 100755 index 0000000..bcbce19 --- /dev/null +++ b/install @@ -0,0 +1,3 @@ +#!/bin/sh +rm -f config.h +sudo make install diff --git a/pointer-constraints-unstable-v1-protocol.h b/pointer-constraints-unstable-v1-protocol.h new file mode 100644 index 0000000..0d48fcd --- /dev/null +++ b/pointer-constraints-unstable-v1-protocol.h @@ -0,0 +1,615 @@ +/* Generated by wayland-scanner 1.25.0 */ + +#ifndef POINTER_CONSTRAINTS_UNSTABLE_V1_SERVER_PROTOCOL_H +#define POINTER_CONSTRAINTS_UNSTABLE_V1_SERVER_PROTOCOL_H + +#include +#include +#include "wayland-server.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct wl_client; +struct wl_resource; + +/** + * @page page_pointer_constraints_unstable_v1 The pointer_constraints_unstable_v1 protocol + * protocol for constraining pointer motions + * + * @section page_desc_pointer_constraints_unstable_v1 Description + * + * This protocol specifies a set of interfaces used for adding constraints to + * the motion of a pointer. Possible constraints include confining pointer + * motions to a given region, or locking it to its current position. + * + * In order to constrain the pointer, a client must first bind the global + * interface "wp_pointer_constraints" which, if a compositor supports pointer + * constraints, is exposed by the registry. Using the bound global object, the + * client uses the request that corresponds to the type of constraint it wants + * to make. See wp_pointer_constraints for more details. + * + * Warning! The protocol described in this file is experimental and backward + * incompatible changes may be made. Backward compatible changes may be added + * together with the corresponding interface version bump. Backward + * incompatible changes are done by bumping the version number in the protocol + * and interface names and resetting the interface version. Once the protocol + * is to be declared stable, the 'z' prefix and the version number in the + * protocol and interface names are removed and the interface version number is + * reset. + * + * @section page_ifaces_pointer_constraints_unstable_v1 Interfaces + * - @subpage page_iface_zwp_pointer_constraints_v1 - constrain the movement of a pointer + * - @subpage page_iface_zwp_locked_pointer_v1 - receive relative pointer motion events + * - @subpage page_iface_zwp_confined_pointer_v1 - confined pointer object + * @section page_copyright_pointer_constraints_unstable_v1 Copyright + * 
+ *
+ * Copyright © 2014      Jonas Ådahl
+ * Copyright © 2015      Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */ +struct wl_pointer; +struct wl_region; +struct wl_surface; +struct zwp_confined_pointer_v1; +struct zwp_locked_pointer_v1; +struct zwp_pointer_constraints_v1; + +#ifndef ZWP_POINTER_CONSTRAINTS_V1_INTERFACE +#define ZWP_POINTER_CONSTRAINTS_V1_INTERFACE +/** + * @page page_iface_zwp_pointer_constraints_v1 zwp_pointer_constraints_v1 + * @section page_iface_zwp_pointer_constraints_v1_desc Description + * + * The global interface exposing pointer constraining functionality. It + * exposes two requests: lock_pointer for locking the pointer to its + * position, and confine_pointer for locking the pointer to a region. + * + * The lock_pointer and confine_pointer requests create the objects + * wp_locked_pointer and wp_confined_pointer respectively, and the client can + * use these objects to interact with the lock. + * + * For any surface, only one lock or confinement may be active across all + * wl_pointer objects of the same seat. If a lock or confinement is requested + * when another lock or confinement is active or requested on the same surface + * and with any of the wl_pointer objects of the same seat, an + * 'already_constrained' error will be raised. + * @section page_iface_zwp_pointer_constraints_v1_api API + * See @ref iface_zwp_pointer_constraints_v1. + */ +/** + * @defgroup iface_zwp_pointer_constraints_v1 The zwp_pointer_constraints_v1 interface + * + * The global interface exposing pointer constraining functionality. It + * exposes two requests: lock_pointer for locking the pointer to its + * position, and confine_pointer for locking the pointer to a region. + * + * The lock_pointer and confine_pointer requests create the objects + * wp_locked_pointer and wp_confined_pointer respectively, and the client can + * use these objects to interact with the lock. + * + * For any surface, only one lock or confinement may be active across all + * wl_pointer objects of the same seat. If a lock or confinement is requested + * when another lock or confinement is active or requested on the same surface + * and with any of the wl_pointer objects of the same seat, an + * 'already_constrained' error will be raised. + */ +extern const struct wl_interface zwp_pointer_constraints_v1_interface; +#endif +#ifndef ZWP_LOCKED_POINTER_V1_INTERFACE +#define ZWP_LOCKED_POINTER_V1_INTERFACE +/** + * @page page_iface_zwp_locked_pointer_v1 zwp_locked_pointer_v1 + * @section page_iface_zwp_locked_pointer_v1_desc Description + * + * The wp_locked_pointer interface represents a locked pointer state. + * + * While the lock of this object is active, the wl_pointer objects of the + * associated seat will not emit any wl_pointer.motion events. + * + * This object will send the event 'locked' when the lock is activated. + * Whenever the lock is activated, it is guaranteed that the locked surface + * will already have received pointer focus and that the pointer will be + * within the region passed to the request creating this object. + * + * To unlock the pointer, send the destroy request. This will also destroy + * the wp_locked_pointer object. + * + * If the compositor decides to unlock the pointer the unlocked event is + * sent. See wp_locked_pointer.unlock for details. + * + * When unlocking, the compositor may warp the cursor position to the set + * cursor position hint. If it does, it will not result in any relative + * motion events emitted via wp_relative_pointer. + * + * If the surface the lock was requested on is destroyed and the lock is not + * yet activated, the wp_locked_pointer object is now defunct and must be + * destroyed. + * @section page_iface_zwp_locked_pointer_v1_api API + * See @ref iface_zwp_locked_pointer_v1. + */ +/** + * @defgroup iface_zwp_locked_pointer_v1 The zwp_locked_pointer_v1 interface + * + * The wp_locked_pointer interface represents a locked pointer state. + * + * While the lock of this object is active, the wl_pointer objects of the + * associated seat will not emit any wl_pointer.motion events. + * + * This object will send the event 'locked' when the lock is activated. + * Whenever the lock is activated, it is guaranteed that the locked surface + * will already have received pointer focus and that the pointer will be + * within the region passed to the request creating this object. + * + * To unlock the pointer, send the destroy request. This will also destroy + * the wp_locked_pointer object. + * + * If the compositor decides to unlock the pointer the unlocked event is + * sent. See wp_locked_pointer.unlock for details. + * + * When unlocking, the compositor may warp the cursor position to the set + * cursor position hint. If it does, it will not result in any relative + * motion events emitted via wp_relative_pointer. + * + * If the surface the lock was requested on is destroyed and the lock is not + * yet activated, the wp_locked_pointer object is now defunct and must be + * destroyed. + */ +extern const struct wl_interface zwp_locked_pointer_v1_interface; +#endif +#ifndef ZWP_CONFINED_POINTER_V1_INTERFACE +#define ZWP_CONFINED_POINTER_V1_INTERFACE +/** + * @page page_iface_zwp_confined_pointer_v1 zwp_confined_pointer_v1 + * @section page_iface_zwp_confined_pointer_v1_desc Description + * + * The wp_confined_pointer interface represents a confined pointer state. + * + * This object will send the event 'confined' when the confinement is + * activated. Whenever the confinement is activated, it is guaranteed that + * the surface the pointer is confined to will already have received pointer + * focus and that the pointer will be within the region passed to the request + * creating this object. It is up to the compositor to decide whether this + * requires some user interaction and if the pointer will warp to within the + * passed region if outside. + * + * To unconfine the pointer, send the destroy request. This will also destroy + * the wp_confined_pointer object. + * + * If the compositor decides to unconfine the pointer the unconfined event is + * sent. The wp_confined_pointer object is at this point defunct and should + * be destroyed. + * @section page_iface_zwp_confined_pointer_v1_api API + * See @ref iface_zwp_confined_pointer_v1. + */ +/** + * @defgroup iface_zwp_confined_pointer_v1 The zwp_confined_pointer_v1 interface + * + * The wp_confined_pointer interface represents a confined pointer state. + * + * This object will send the event 'confined' when the confinement is + * activated. Whenever the confinement is activated, it is guaranteed that + * the surface the pointer is confined to will already have received pointer + * focus and that the pointer will be within the region passed to the request + * creating this object. It is up to the compositor to decide whether this + * requires some user interaction and if the pointer will warp to within the + * passed region if outside. + * + * To unconfine the pointer, send the destroy request. This will also destroy + * the wp_confined_pointer object. + * + * If the compositor decides to unconfine the pointer the unconfined event is + * sent. The wp_confined_pointer object is at this point defunct and should + * be destroyed. + */ +extern const struct wl_interface zwp_confined_pointer_v1_interface; +#endif + +#ifndef ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM +#define ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM +/** + * @ingroup iface_zwp_pointer_constraints_v1 + * wp_pointer_constraints error values + * + * These errors can be emitted in response to wp_pointer_constraints + * requests. + */ +enum zwp_pointer_constraints_v1_error { + /** + * pointer constraint already requested on that surface + */ + ZWP_POINTER_CONSTRAINTS_V1_ERROR_ALREADY_CONSTRAINED = 1, +}; +#endif /* ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM */ + +#ifndef ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM_IS_VALID +#define ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_zwp_pointer_constraints_v1 + * Validate a zwp_pointer_constraints_v1 error value. + * + * @return true on success, false on error. + * @ref zwp_pointer_constraints_v1_error + */ +static inline bool +zwp_pointer_constraints_v1_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWP_POINTER_CONSTRAINTS_V1_ERROR_ALREADY_CONSTRAINED: + return version >= 1; + default: + return false; + } +} +#endif /* ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM_IS_VALID */ + +#ifndef ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM +#define ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM +/** + * @ingroup iface_zwp_pointer_constraints_v1 + * constraint lifetime + * + * These values represent different lifetime semantics. They are passed + * as arguments to the factory requests to specify how the constraint + * lifetimes should be managed. + */ +enum zwp_pointer_constraints_v1_lifetime { + /** + * the pointer constraint is defunct once deactivated + * + * A oneshot pointer constraint will never reactivate once it has + * been deactivated. See the corresponding deactivation event + * (wp_locked_pointer.unlocked and wp_confined_pointer.unconfined) + * for details. + */ + ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT = 1, + /** + * the pointer constraint may reactivate + * + * A persistent pointer constraint may again reactivate once it + * has been deactivated. See the corresponding deactivation event + * (wp_locked_pointer.unlocked and wp_confined_pointer.unconfined) + * for details. + */ + ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT = 2, +}; +#endif /* ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM */ + +#ifndef ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM_IS_VALID +#define ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM_IS_VALID +/** + * @ingroup iface_zwp_pointer_constraints_v1 + * Validate a zwp_pointer_constraints_v1 lifetime value. + * + * @return true on success, false on error. + * @ref zwp_pointer_constraints_v1_lifetime + */ +static inline bool +zwp_pointer_constraints_v1_lifetime_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT: + return version >= 1; + case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT: + return version >= 1; + default: + return false; + } +} +#endif /* ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM_IS_VALID */ + +/** + * @ingroup iface_zwp_pointer_constraints_v1 + * @struct zwp_pointer_constraints_v1_interface + */ +struct zwp_pointer_constraints_v1_interface { + /** + * destroy the pointer constraints manager object + * + * Used by the client to notify the server that it will no longer + * use this pointer constraints object. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * lock pointer to a position + * + * The lock_pointer request lets the client request to disable + * movements of the virtual pointer (i.e. the cursor), effectively + * locking the pointer to a position. This request may not take + * effect immediately; in the future, when the compositor deems + * implementation-specific constraints are satisfied, the pointer + * lock will be activated and the compositor sends a locked event. + * + * The protocol provides no guarantee that the constraints are ever + * satisfied, and does not require the compositor to send an error + * if the constraints cannot ever be satisfied. It is thus possible + * to request a lock that will never activate. + * + * There may not be another pointer constraint of any kind + * requested or active on the surface for any of the wl_pointer + * objects of the seat of the passed pointer when requesting a + * lock. If there is, an error will be raised. See general pointer + * lock documentation for more details. + * + * The intersection of the region passed with this request and the + * input region of the surface is used to determine where the + * pointer must be in order for the lock to activate. It is up to + * the compositor whether to warp the pointer or require some kind + * of user interaction for the lock to activate. If the region is + * null the surface input region is used. + * + * A surface may receive pointer focus without the lock being + * activated. + * + * The request creates a new object wp_locked_pointer which is used + * to interact with the lock as well as receive updates about its + * state. See the the description of wp_locked_pointer for further + * information. + * + * Note that while a pointer is locked, the wl_pointer objects of + * the corresponding seat will not emit any wl_pointer.motion + * events, but relative motion events will still be emitted via + * wp_relative_pointer objects of the same seat. wl_pointer.axis + * and wl_pointer.button events are unaffected. + * @param surface surface to lock pointer to + * @param pointer the pointer that should be locked + * @param region region of surface + * @param lifetime lock lifetime + */ + void (*lock_pointer)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id, + struct wl_resource *surface, + struct wl_resource *pointer, + struct wl_resource *region, + uint32_t lifetime); + /** + * confine pointer to a region + * + * The confine_pointer request lets the client request to confine + * the pointer cursor to a given region. This request may not take + * effect immediately; in the future, when the compositor deems + * implementation- specific constraints are satisfied, the pointer + * confinement will be activated and the compositor sends a + * confined event. + * + * The intersection of the region passed with this request and the + * input region of the surface is used to determine where the + * pointer must be in order for the confinement to activate. It is + * up to the compositor whether to warp the pointer or require some + * kind of user interaction for the confinement to activate. If the + * region is null the surface input region is used. + * + * The request will create a new object wp_confined_pointer which + * is used to interact with the confinement as well as receive + * updates about its state. See the the description of + * wp_confined_pointer for further information. + * @param surface surface to lock pointer to + * @param pointer the pointer that should be confined + * @param region region of surface + * @param lifetime confinement lifetime + */ + void (*confine_pointer)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id, + struct wl_resource *surface, + struct wl_resource *pointer, + struct wl_resource *region, + uint32_t lifetime); +}; + + +/** + * @ingroup iface_zwp_pointer_constraints_v1 + */ +#define ZWP_POINTER_CONSTRAINTS_V1_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_zwp_pointer_constraints_v1 + */ +#define ZWP_POINTER_CONSTRAINTS_V1_LOCK_POINTER_SINCE_VERSION 1 +/** + * @ingroup iface_zwp_pointer_constraints_v1 + */ +#define ZWP_POINTER_CONSTRAINTS_V1_CONFINE_POINTER_SINCE_VERSION 1 + +/** + * @ingroup iface_zwp_locked_pointer_v1 + * @struct zwp_locked_pointer_v1_interface + */ +struct zwp_locked_pointer_v1_interface { + /** + * destroy the locked pointer object + * + * Destroy the locked pointer object. If applicable, the + * compositor will unlock the pointer. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * set the pointer cursor position hint + * + * Set the cursor position hint relative to the top left corner + * of the surface. + * + * If the client is drawing its own cursor, it should update the + * position hint to the position of its own cursor. A compositor + * may use this information to warp the pointer upon unlock in + * order to avoid pointer jumps. + * + * The cursor position hint is double-buffered state, see + * wl_surface.commit. + * @param surface_x surface-local x coordinate + * @param surface_y surface-local y coordinate + */ + void (*set_cursor_position_hint)(struct wl_client *client, + struct wl_resource *resource, + wl_fixed_t surface_x, + wl_fixed_t surface_y); + /** + * set a new lock region + * + * Set a new region used to lock the pointer. + * + * The new lock region is double-buffered, see wl_surface.commit. + * + * For details about the lock region, see wp_locked_pointer. + * @param region region of surface + */ + void (*set_region)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *region); +}; + +#define ZWP_LOCKED_POINTER_V1_LOCKED 0 +#define ZWP_LOCKED_POINTER_V1_UNLOCKED 1 + +/** + * @ingroup iface_zwp_locked_pointer_v1 + */ +#define ZWP_LOCKED_POINTER_V1_LOCKED_SINCE_VERSION 1 +/** + * @ingroup iface_zwp_locked_pointer_v1 + */ +#define ZWP_LOCKED_POINTER_V1_UNLOCKED_SINCE_VERSION 1 + +/** + * @ingroup iface_zwp_locked_pointer_v1 + */ +#define ZWP_LOCKED_POINTER_V1_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_zwp_locked_pointer_v1 + */ +#define ZWP_LOCKED_POINTER_V1_SET_CURSOR_POSITION_HINT_SINCE_VERSION 1 +/** + * @ingroup iface_zwp_locked_pointer_v1 + */ +#define ZWP_LOCKED_POINTER_V1_SET_REGION_SINCE_VERSION 1 + +/** + * @ingroup iface_zwp_locked_pointer_v1 + * Sends an locked event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +zwp_locked_pointer_v1_send_locked(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, ZWP_LOCKED_POINTER_V1_LOCKED); +} + +/** + * @ingroup iface_zwp_locked_pointer_v1 + * Sends an unlocked event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +zwp_locked_pointer_v1_send_unlocked(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, ZWP_LOCKED_POINTER_V1_UNLOCKED); +} + +/** + * @ingroup iface_zwp_confined_pointer_v1 + * @struct zwp_confined_pointer_v1_interface + */ +struct zwp_confined_pointer_v1_interface { + /** + * destroy the confined pointer object + * + * Destroy the confined pointer object. If applicable, the + * compositor will unconfine the pointer. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * set a new confine region + * + * Set a new region used to confine the pointer. + * + * The new confine region is double-buffered, see + * wl_surface.commit. + * + * If the confinement is active when the new confinement region is + * applied and the pointer ends up outside of newly applied region, + * the pointer may warped to a position within the new confinement + * region. If warped, a wl_pointer.motion event will be emitted, + * but no wp_relative_pointer.relative_motion event. + * + * The compositor may also, instead of using the new region, + * unconfine the pointer. + * + * For details about the confine region, see wp_confined_pointer. + * @param region region of surface + */ + void (*set_region)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *region); +}; + +#define ZWP_CONFINED_POINTER_V1_CONFINED 0 +#define ZWP_CONFINED_POINTER_V1_UNCONFINED 1 + +/** + * @ingroup iface_zwp_confined_pointer_v1 + */ +#define ZWP_CONFINED_POINTER_V1_CONFINED_SINCE_VERSION 1 +/** + * @ingroup iface_zwp_confined_pointer_v1 + */ +#define ZWP_CONFINED_POINTER_V1_UNCONFINED_SINCE_VERSION 1 + +/** + * @ingroup iface_zwp_confined_pointer_v1 + */ +#define ZWP_CONFINED_POINTER_V1_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_zwp_confined_pointer_v1 + */ +#define ZWP_CONFINED_POINTER_V1_SET_REGION_SINCE_VERSION 1 + +/** + * @ingroup iface_zwp_confined_pointer_v1 + * Sends an confined event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +zwp_confined_pointer_v1_send_confined(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, ZWP_CONFINED_POINTER_V1_CONFINED); +} + +/** + * @ingroup iface_zwp_confined_pointer_v1 + * Sends an unconfined event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +zwp_confined_pointer_v1_send_unconfined(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, ZWP_CONFINED_POINTER_V1_UNCONFINED); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/protocols/wlr-layer-shell-unstable-v1.xml b/protocols/wlr-layer-shell-unstable-v1.xml new file mode 100644 index 0000000..d62fd51 --- /dev/null +++ b/protocols/wlr-layer-shell-unstable-v1.xml @@ -0,0 +1,390 @@ + + + + Copyright © 2017 Drew DeVault + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + + + + + Clients can use this interface to assign the surface_layer role to + wl_surfaces. Such surfaces are assigned to a "layer" of the output and + rendered with a defined z-depth respective to each other. They may also be + anchored to the edges and corners of a screen and specify input handling + semantics. This interface should be suitable for the implementation of + many desktop shell components, and a broad number of other applications + that interact with the desktop. + + + + + Create a layer surface for an existing surface. This assigns the role of + layer_surface, or raises a protocol error if another role is already + assigned. + + Creating a layer surface from a wl_surface which has a buffer attached + or committed is a client error, and any attempts by a client to attach + or manipulate a buffer prior to the first layer_surface.configure call + must also be treated as errors. + + After creating a layer_surface object and setting it up, the client + must perform an initial commit without any buffer attached. + The compositor will reply with a layer_surface.configure event. + The client must acknowledge it and is then allowed to attach a buffer + to map the surface. + + You may pass NULL for output to allow the compositor to decide which + output to use. Generally this will be the one that the user most + recently interacted with. + + Clients can specify a namespace that defines the purpose of the layer + surface. + + + + + + + + + + + + + + + + + These values indicate which layers a surface can be rendered in. They + are ordered by z depth, bottom-most first. Traditional shell surfaces + will typically be rendered between the bottom and top layers. + Fullscreen shell surfaces are typically rendered at the top layer. + Multiple surfaces can share a single layer, and ordering within a + single layer is undefined. + + + + + + + + + + + + + This request indicates that the client will not use the layer_shell + object any more. Objects that have been created through this instance + are not affected. + + + + + + + An interface that may be implemented by a wl_surface, for surfaces that + are designed to be rendered as a layer of a stacked desktop-like + environment. + + Layer surface state (layer, size, anchor, exclusive zone, + margin, interactivity) is double-buffered, and will be applied at the + time wl_surface.commit of the corresponding wl_surface is called. + + Attaching a null buffer to a layer surface unmaps it. + + Unmapping a layer_surface means that the surface cannot be shown by the + compositor until it is explicitly mapped again. The layer_surface + returns to the state it had right after layer_shell.get_layer_surface. + The client can re-map the surface by performing a commit without any + buffer attached, waiting for a configure event and handling it as usual. + + + + + Sets the size of the surface in surface-local coordinates. The + compositor will display the surface centered with respect to its + anchors. + + If you pass 0 for either value, the compositor will assign it and + inform you of the assignment in the configure event. You must set your + anchor to opposite edges in the dimensions you omit; not doing so is a + protocol error. Both values are 0 by default. + + Size is double-buffered, see wl_surface.commit. + + + + + + + + Requests that the compositor anchor the surface to the specified edges + and corners. If two orthogonal edges are specified (e.g. 'top' and + 'left'), then the anchor point will be the intersection of the edges + (e.g. the top left corner of the output); otherwise the anchor point + will be centered on that edge, or in the center if none is specified. + + Anchor is double-buffered, see wl_surface.commit. + + + + + + + Requests that the compositor avoids occluding an area with other + surfaces. The compositor's use of this information is + implementation-dependent - do not assume that this region will not + actually be occluded. + + A positive value is only meaningful if the surface is anchored to one + edge or an edge and both perpendicular edges. If the surface is not + anchored, anchored to only two perpendicular edges (a corner), anchored + to only two parallel edges or anchored to all edges, a positive value + will be treated the same as zero. + + A positive zone is the distance from the edge in surface-local + coordinates to consider exclusive. + + Surfaces that do not wish to have an exclusive zone may instead specify + how they should interact with surfaces that do. If set to zero, the + surface indicates that it would like to be moved to avoid occluding + surfaces with a positive exclusive zone. If set to -1, the surface + indicates that it would not like to be moved to accommodate for other + surfaces, and the compositor should extend it all the way to the edges + it is anchored to. + + For example, a panel might set its exclusive zone to 10, so that + maximized shell surfaces are not shown on top of it. A notification + might set its exclusive zone to 0, so that it is moved to avoid + occluding the panel, but shell surfaces are shown underneath it. A + wallpaper or lock screen might set their exclusive zone to -1, so that + they stretch below or over the panel. + + The default value is 0. + + Exclusive zone is double-buffered, see wl_surface.commit. + + + + + + + Requests that the surface be placed some distance away from the anchor + point on the output, in surface-local coordinates. Setting this value + for edges you are not anchored to has no effect. + + The exclusive zone includes the margin. + + Margin is double-buffered, see wl_surface.commit. + + + + + + + + + + Types of keyboard interaction possible for layer shell surfaces. The + rationale for this is twofold: (1) some applications are not interested + in keyboard events and not allowing them to be focused can improve the + desktop experience; (2) some applications will want to take exclusive + keyboard focus. + + + + + This value indicates that this surface is not interested in keyboard + events and the compositor should never assign it the keyboard focus. + + This is the default value, set for newly created layer shell surfaces. + + This is useful for e.g. desktop widgets that display information or + only have interaction with non-keyboard input devices. + + + + + Request exclusive keyboard focus if this surface is above the shell surface layer. + + For the top and overlay layers, the seat will always give + exclusive keyboard focus to the top-most layer which has keyboard + interactivity set to exclusive. If this layer contains multiple + surfaces with keyboard interactivity set to exclusive, the compositor + determines the one receiving keyboard events in an implementation- + defined manner. In this case, no guarantee is made when this surface + will receive keyboard focus (if ever). + + For the bottom and background layers, the compositor is allowed to use + normal focus semantics. + + This setting is mainly intended for applications that need to ensure + they receive all keyboard events, such as a lock screen or a password + prompt. + + + + + This requests the compositor to allow this surface to be focused and + unfocused by the user in an implementation-defined manner. The user + should be able to unfocus this surface even regardless of the layer + it is on. + + Typically, the compositor will want to use its normal mechanism to + manage keyboard focus between layer shell surfaces with this setting + and regular toplevels on the desktop layer (e.g. click to focus). + Nevertheless, it is possible for a compositor to require a special + interaction to focus or unfocus layer shell surfaces (e.g. requiring + a click even if focus follows the mouse normally, or providing a + keybinding to switch focus between layers). + + This setting is mainly intended for desktop shell components (e.g. + panels) that allow keyboard interaction. Using this option can allow + implementing a desktop shell that can be fully usable without the + mouse. + + + + + + + Set how keyboard events are delivered to this surface. By default, + layer shell surfaces do not receive keyboard events; this request can + be used to change this. + + This setting is inherited by child surfaces set by the get_popup + request. + + Layer surfaces receive pointer, touch, and tablet events normally. If + you do not want to receive them, set the input region on your surface + to an empty region. + + Keyboard interactivity is double-buffered, see wl_surface.commit. + + + + + + + This assigns an xdg_popup's parent to this layer_surface. This popup + should have been created via xdg_surface::get_popup with the parent set + to NULL, and this request must be invoked before committing the popup's + initial state. + + See the documentation of xdg_popup for more details about what an + xdg_popup is and how it is used. + + + + + + + When a configure event is received, if a client commits the + surface in response to the configure event, then the client + must make an ack_configure request sometime before the commit + request, passing along the serial of the configure event. + + If the client receives multiple configure events before it + can respond to one, it only has to ack the last configure event. + + A client is not required to commit immediately after sending + an ack_configure request - it may even ack_configure several times + before its next surface commit. + + A client may send multiple ack_configure requests before committing, but + only the last request sent before a commit indicates which configure + event the client really is responding to. + + + + + + + This request destroys the layer surface. + + + + + + The configure event asks the client to resize its surface. + + Clients should arrange their surface for the new states, and then send + an ack_configure request with the serial sent in this configure event at + some point before committing the new surface. + + The client is free to dismiss all but the last configure event it + received. + + The width and height arguments specify the size of the window in + surface-local coordinates. + + The size is a hint, in the sense that the client is free to ignore it if + it doesn't resize, pick a smaller size (to satisfy aspect ratio or + resize in steps of NxM pixels). If the client picks a smaller size and + is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the + surface will be centered on this axis. + + If the width or height arguments are zero, it means the client should + decide its own window dimension. + + + + + + + + + The closed event is sent by the compositor when the surface will no + longer be shown. The output may have been destroyed or the user may + have asked for it to be removed. Further changes to the surface will be + ignored. The client should destroy the resource after receiving this + event, and create a new surface if they so choose. + + + + + + + + + + + + + + + + + + + + + + Change the layer that the surface is rendered on. + + Layer is double-buffered, see wl_surface.commit. + + + + + diff --git a/protocols/wlr-output-power-management-unstable-v1.xml b/protocols/wlr-output-power-management-unstable-v1.xml new file mode 100644 index 0000000..a977839 --- /dev/null +++ b/protocols/wlr-output-power-management-unstable-v1.xml @@ -0,0 +1,128 @@ + + + + Copyright © 2019 Purism SPC + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + + + + This protocol allows clients to control power management modes + of outputs that are currently part of the compositor space. The + intent is to allow special clients like desktop shells to power + down outputs when the system is idle. + + To modify outputs not currently part of the compositor space see + wlr-output-management. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible changes + may be added together with the corresponding interface version bump. + Backward incompatible changes are done by bumping the version number in + the protocol and interface names and resetting the interface version. + Once the protocol is to be declared stable, the 'z' prefix and the + version number in the protocol and interface names are removed and the + interface version number is reset. + + + + + This interface is a manager that allows creating per-output power + management mode controls. + + + + + Create a output power management mode control that can be used to + adjust the power management mode for a given output. + + + + + + + + All objects created by the manager will still remain valid, until their + appropriate destroy request has been called. + + + + + + + This object offers requests to set the power management mode of + an output. + + + + + + + + + + + + + + Set an output's power save mode to the given mode. The mode change + is effective immediately. If the output does not support the given + mode a failed event is sent. + + + + + + + Report the power management mode change of an output. + + The mode event is sent after an output changed its power + management mode. The reason can be a client using set_mode or the + compositor deciding to change an output's mode. + This event is also sent immediately when the object is created + so the client is informed about the current power management mode. + + + + + + + This event indicates that the output power management mode control + is no longer valid. This can happen for a number of reasons, + including: + - The output doesn't support power management + - Another client already has exclusive power management mode control + for this output + - The output disappeared + + Upon receiving this event, the client should destroy this object. + + + + + + Destroys the output power management mode control object. + + + + diff --git a/util.c b/util.c new file mode 100644 index 0000000..51130af --- /dev/null +++ b/util.c @@ -0,0 +1,51 @@ +/* See LICENSE.dwm file for copyright and license details. */ +#include +#include +#include +#include +#include + +#include "util.h" + +void +die(const char *fmt, ...) { + va_list ap; + + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + + if (fmt[0] && fmt[strlen(fmt)-1] == ':') { + fputc(' ', stderr); + perror(NULL); + } else { + fputc('\n', stderr); + } + + exit(1); +} + +void * +ecalloc(size_t nmemb, size_t size) +{ + void *p; + + if (!(p = calloc(nmemb, size))) + die("calloc:"); + return p; +} + +int +fd_set_nonblock(int fd) { + int flags = fcntl(fd, F_GETFL); + if (flags < 0) { + perror("fcntl(F_GETFL):"); + return -1; + } + if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) { + perror("fcntl(F_SETFL):"); + return -1; + } + + return 0; +} diff --git a/util.h b/util.h new file mode 100644 index 0000000..226980d --- /dev/null +++ b/util.h @@ -0,0 +1,5 @@ +/* See LICENSE.dwm file for copyright and license details. */ + +void die(const char *fmt, ...); +void *ecalloc(size_t nmemb, size_t size); +int fd_set_nonblock(int fd); diff --git a/util.o b/util.o new file mode 100644 index 0000000000000000000000000000000000000000..f714080cd32dff34d6c44c7d30e1014ae7b4676e GIT binary patch literal 8696 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 literal 0 HcmV?d00001 diff --git a/wlr-layer-shell-unstable-v1-protocol.h b/wlr-layer-shell-unstable-v1-protocol.h new file mode 100644 index 0000000..dd34d59 --- /dev/null +++ b/wlr-layer-shell-unstable-v1-protocol.h @@ -0,0 +1,730 @@ +/* Generated by wayland-scanner 1.25.0 */ + +#ifndef WLR_LAYER_SHELL_UNSTABLE_V1_SERVER_PROTOCOL_H +#define WLR_LAYER_SHELL_UNSTABLE_V1_SERVER_PROTOCOL_H + +#include +#include +#include "wayland-server.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct wl_client; +struct wl_resource; + +/** + * @page page_wlr_layer_shell_unstable_v1 The wlr_layer_shell_unstable_v1 protocol + * @section page_ifaces_wlr_layer_shell_unstable_v1 Interfaces + * - @subpage page_iface_zwlr_layer_shell_v1 - create surfaces that are layers of the desktop + * - @subpage page_iface_zwlr_layer_surface_v1 - layer metadata interface + * @section page_copyright_wlr_layer_shell_unstable_v1 Copyright + * 
+ *
+ * Copyright © 2017 Drew DeVault
+ *
+ * Permission to use, copy, modify, distribute, and sell this
+ * software and its documentation for any purpose is hereby granted
+ * without fee, provided that the above copyright notice appear in
+ * all copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of
+ * the copyright holders not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ *
+ */ +struct wl_output; +struct wl_surface; +struct xdg_popup; +struct zwlr_layer_shell_v1; +struct zwlr_layer_surface_v1; + +#ifndef ZWLR_LAYER_SHELL_V1_INTERFACE +#define ZWLR_LAYER_SHELL_V1_INTERFACE +/** + * @page page_iface_zwlr_layer_shell_v1 zwlr_layer_shell_v1 + * @section page_iface_zwlr_layer_shell_v1_desc Description + * + * Clients can use this interface to assign the surface_layer role to + * wl_surfaces. Such surfaces are assigned to a "layer" of the output and + * rendered with a defined z-depth respective to each other. They may also be + * anchored to the edges and corners of a screen and specify input handling + * semantics. This interface should be suitable for the implementation of + * many desktop shell components, and a broad number of other applications + * that interact with the desktop. + * @section page_iface_zwlr_layer_shell_v1_api API + * See @ref iface_zwlr_layer_shell_v1. + */ +/** + * @defgroup iface_zwlr_layer_shell_v1 The zwlr_layer_shell_v1 interface + * + * Clients can use this interface to assign the surface_layer role to + * wl_surfaces. Such surfaces are assigned to a "layer" of the output and + * rendered with a defined z-depth respective to each other. They may also be + * anchored to the edges and corners of a screen and specify input handling + * semantics. This interface should be suitable for the implementation of + * many desktop shell components, and a broad number of other applications + * that interact with the desktop. + */ +extern const struct wl_interface zwlr_layer_shell_v1_interface; +#endif +#ifndef ZWLR_LAYER_SURFACE_V1_INTERFACE +#define ZWLR_LAYER_SURFACE_V1_INTERFACE +/** + * @page page_iface_zwlr_layer_surface_v1 zwlr_layer_surface_v1 + * @section page_iface_zwlr_layer_surface_v1_desc Description + * + * An interface that may be implemented by a wl_surface, for surfaces that + * are designed to be rendered as a layer of a stacked desktop-like + * environment. + * + * Layer surface state (layer, size, anchor, exclusive zone, + * margin, interactivity) is double-buffered, and will be applied at the + * time wl_surface.commit of the corresponding wl_surface is called. + * + * Attaching a null buffer to a layer surface unmaps it. + * + * Unmapping a layer_surface means that the surface cannot be shown by the + * compositor until it is explicitly mapped again. The layer_surface + * returns to the state it had right after layer_shell.get_layer_surface. + * The client can re-map the surface by performing a commit without any + * buffer attached, waiting for a configure event and handling it as usual. + * @section page_iface_zwlr_layer_surface_v1_api API + * See @ref iface_zwlr_layer_surface_v1. + */ +/** + * @defgroup iface_zwlr_layer_surface_v1 The zwlr_layer_surface_v1 interface + * + * An interface that may be implemented by a wl_surface, for surfaces that + * are designed to be rendered as a layer of a stacked desktop-like + * environment. + * + * Layer surface state (layer, size, anchor, exclusive zone, + * margin, interactivity) is double-buffered, and will be applied at the + * time wl_surface.commit of the corresponding wl_surface is called. + * + * Attaching a null buffer to a layer surface unmaps it. + * + * Unmapping a layer_surface means that the surface cannot be shown by the + * compositor until it is explicitly mapped again. The layer_surface + * returns to the state it had right after layer_shell.get_layer_surface. + * The client can re-map the surface by performing a commit without any + * buffer attached, waiting for a configure event and handling it as usual. + */ +extern const struct wl_interface zwlr_layer_surface_v1_interface; +#endif + +#ifndef ZWLR_LAYER_SHELL_V1_ERROR_ENUM +#define ZWLR_LAYER_SHELL_V1_ERROR_ENUM +enum zwlr_layer_shell_v1_error { + /** + * wl_surface has another role + */ + ZWLR_LAYER_SHELL_V1_ERROR_ROLE = 0, + /** + * layer value is invalid + */ + ZWLR_LAYER_SHELL_V1_ERROR_INVALID_LAYER = 1, + /** + * wl_surface has a buffer attached or committed + */ + ZWLR_LAYER_SHELL_V1_ERROR_ALREADY_CONSTRUCTED = 2, +}; +#endif /* ZWLR_LAYER_SHELL_V1_ERROR_ENUM */ + +#ifndef ZWLR_LAYER_SHELL_V1_ERROR_ENUM_IS_VALID +#define ZWLR_LAYER_SHELL_V1_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_zwlr_layer_shell_v1 + * Validate a zwlr_layer_shell_v1 error value. + * + * @return true on success, false on error. + * @ref zwlr_layer_shell_v1_error + */ +static inline bool +zwlr_layer_shell_v1_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWLR_LAYER_SHELL_V1_ERROR_ROLE: + return version >= 1; + case ZWLR_LAYER_SHELL_V1_ERROR_INVALID_LAYER: + return version >= 1; + case ZWLR_LAYER_SHELL_V1_ERROR_ALREADY_CONSTRUCTED: + return version >= 1; + default: + return false; + } +} +#endif /* ZWLR_LAYER_SHELL_V1_ERROR_ENUM_IS_VALID */ + +#ifndef ZWLR_LAYER_SHELL_V1_LAYER_ENUM +#define ZWLR_LAYER_SHELL_V1_LAYER_ENUM +/** + * @ingroup iface_zwlr_layer_shell_v1 + * available layers for surfaces + * + * These values indicate which layers a surface can be rendered in. They + * are ordered by z depth, bottom-most first. Traditional shell surfaces + * will typically be rendered between the bottom and top layers. + * Fullscreen shell surfaces are typically rendered at the top layer. + * Multiple surfaces can share a single layer, and ordering within a + * single layer is undefined. + */ +enum zwlr_layer_shell_v1_layer { + ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND = 0, + ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM = 1, + ZWLR_LAYER_SHELL_V1_LAYER_TOP = 2, + ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY = 3, +}; +#endif /* ZWLR_LAYER_SHELL_V1_LAYER_ENUM */ + +#ifndef ZWLR_LAYER_SHELL_V1_LAYER_ENUM_IS_VALID +#define ZWLR_LAYER_SHELL_V1_LAYER_ENUM_IS_VALID +/** + * @ingroup iface_zwlr_layer_shell_v1 + * Validate a zwlr_layer_shell_v1 layer value. + * + * @return true on success, false on error. + * @ref zwlr_layer_shell_v1_layer + */ +static inline bool +zwlr_layer_shell_v1_layer_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND: + return version >= 1; + case ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM: + return version >= 1; + case ZWLR_LAYER_SHELL_V1_LAYER_TOP: + return version >= 1; + case ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY: + return version >= 1; + default: + return false; + } +} +#endif /* ZWLR_LAYER_SHELL_V1_LAYER_ENUM_IS_VALID */ + +/** + * @ingroup iface_zwlr_layer_shell_v1 + * @struct zwlr_layer_shell_v1_interface + */ +struct zwlr_layer_shell_v1_interface { + /** + * create a layer_surface from a surface + * + * Create a layer surface for an existing surface. This assigns + * the role of layer_surface, or raises a protocol error if another + * role is already assigned. + * + * Creating a layer surface from a wl_surface which has a buffer + * attached or committed is a client error, and any attempts by a + * client to attach or manipulate a buffer prior to the first + * layer_surface.configure call must also be treated as errors. + * + * After creating a layer_surface object and setting it up, the + * client must perform an initial commit without any buffer + * attached. The compositor will reply with a + * layer_surface.configure event. The client must acknowledge it + * and is then allowed to attach a buffer to map the surface. + * + * You may pass NULL for output to allow the compositor to decide + * which output to use. Generally this will be the one that the + * user most recently interacted with. + * + * Clients can specify a namespace that defines the purpose of the + * layer surface. + * @param layer layer to add this surface to + * @param namespace namespace for the layer surface + */ + void (*get_layer_surface)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id, + struct wl_resource *surface, + struct wl_resource *output, + uint32_t layer, + const char *namespace); + /** + * destroy the layer_shell object + * + * This request indicates that the client will not use the + * layer_shell object any more. Objects that have been created + * through this instance are not affected. + * @since 3 + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); +}; + + +/** + * @ingroup iface_zwlr_layer_shell_v1 + */ +#define ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_shell_v1 + */ +#define ZWLR_LAYER_SHELL_V1_DESTROY_SINCE_VERSION 3 + +#ifndef ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM +#define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM +/** + * @ingroup iface_zwlr_layer_surface_v1 + * types of keyboard interaction possible for a layer shell surface + * + * Types of keyboard interaction possible for layer shell surfaces. The + * rationale for this is twofold: (1) some applications are not interested + * in keyboard events and not allowing them to be focused can improve the + * desktop experience; (2) some applications will want to take exclusive + * keyboard focus. + */ +enum zwlr_layer_surface_v1_keyboard_interactivity { + /** + * no keyboard focus is possible + * + * This value indicates that this surface is not interested in + * keyboard events and the compositor should never assign it the + * keyboard focus. + * + * This is the default value, set for newly created layer shell + * surfaces. + * + * This is useful for e.g. desktop widgets that display information + * or only have interaction with non-keyboard input devices. + */ + ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE = 0, + /** + * request exclusive keyboard focus + * + * Request exclusive keyboard focus if this surface is above the + * shell surface layer. + * + * For the top and overlay layers, the seat will always give + * exclusive keyboard focus to the top-most layer which has + * keyboard interactivity set to exclusive. If this layer contains + * multiple surfaces with keyboard interactivity set to exclusive, + * the compositor determines the one receiving keyboard events in + * an implementation- defined manner. In this case, no guarantee is + * made when this surface will receive keyboard focus (if ever). + * + * For the bottom and background layers, the compositor is allowed + * to use normal focus semantics. + * + * This setting is mainly intended for applications that need to + * ensure they receive all keyboard events, such as a lock screen + * or a password prompt. + */ + ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE = 1, + /** + * request regular keyboard focus semantics + * + * This requests the compositor to allow this surface to be + * focused and unfocused by the user in an implementation-defined + * manner. The user should be able to unfocus this surface even + * regardless of the layer it is on. + * + * Typically, the compositor will want to use its normal mechanism + * to manage keyboard focus between layer shell surfaces with this + * setting and regular toplevels on the desktop layer (e.g. click + * to focus). Nevertheless, it is possible for a compositor to + * require a special interaction to focus or unfocus layer shell + * surfaces (e.g. requiring a click even if focus follows the mouse + * normally, or providing a keybinding to switch focus between + * layers). + * + * This setting is mainly intended for desktop shell components + * (e.g. panels) that allow keyboard interaction. Using this option + * can allow implementing a desktop shell that can be fully usable + * without the mouse. + * @since 4 + */ + ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND = 2, +}; +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND_SINCE_VERSION 4 +#endif /* ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM */ + +#ifndef ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM_IS_VALID +#define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM_IS_VALID +/** + * @ingroup iface_zwlr_layer_surface_v1 + * Validate a zwlr_layer_surface_v1 keyboard_interactivity value. + * + * @return true on success, false on error. + * @ref zwlr_layer_surface_v1_keyboard_interactivity + */ +static inline bool +zwlr_layer_surface_v1_keyboard_interactivity_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE: + return version >= 1; + case ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE: + return version >= 1; + case ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND: + return version >= 4; + default: + return false; + } +} +#endif /* ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM_IS_VALID */ + +#ifndef ZWLR_LAYER_SURFACE_V1_ERROR_ENUM +#define ZWLR_LAYER_SURFACE_V1_ERROR_ENUM +enum zwlr_layer_surface_v1_error { + /** + * provided surface state is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SURFACE_STATE = 0, + /** + * size is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SIZE = 1, + /** + * anchor bitfield is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_ANCHOR = 2, + /** + * keyboard interactivity is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_KEYBOARD_INTERACTIVITY = 3, +}; +#endif /* ZWLR_LAYER_SURFACE_V1_ERROR_ENUM */ + +#ifndef ZWLR_LAYER_SURFACE_V1_ERROR_ENUM_IS_VALID +#define ZWLR_LAYER_SURFACE_V1_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_zwlr_layer_surface_v1 + * Validate a zwlr_layer_surface_v1 error value. + * + * @return true on success, false on error. + * @ref zwlr_layer_surface_v1_error + */ +static inline bool +zwlr_layer_surface_v1_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SURFACE_STATE: + return version >= 1; + case ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SIZE: + return version >= 1; + case ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_ANCHOR: + return version >= 1; + case ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_KEYBOARD_INTERACTIVITY: + return version >= 1; + default: + return false; + } +} +#endif /* ZWLR_LAYER_SURFACE_V1_ERROR_ENUM_IS_VALID */ + +#ifndef ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM +#define ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM +enum zwlr_layer_surface_v1_anchor { + /** + * the top edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP = 1, + /** + * the bottom edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM = 2, + /** + * the left edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT = 4, + /** + * the right edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT = 8, +}; +#endif /* ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM */ + +#ifndef ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM_IS_VALID +#define ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM_IS_VALID +/** + * @ingroup iface_zwlr_layer_surface_v1 + * Validate a zwlr_layer_surface_v1 anchor value. + * + * @return true on success, false on error. + * @ref zwlr_layer_surface_v1_anchor + */ +static inline bool +zwlr_layer_surface_v1_anchor_is_valid(uint32_t value, uint32_t version) { + uint32_t valid = 0; + if (version >= 1) + valid |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; + if (version >= 1) + valid |= ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; + if (version >= 1) + valid |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT; + if (version >= 1) + valid |= ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; + return (value & ~valid) == 0; +} +#endif /* ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM_IS_VALID */ + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * @struct zwlr_layer_surface_v1_interface + */ +struct zwlr_layer_surface_v1_interface { + /** + * sets the size of the surface + * + * Sets the size of the surface in surface-local coordinates. The + * compositor will display the surface centered with respect to its + * anchors. + * + * If you pass 0 for either value, the compositor will assign it + * and inform you of the assignment in the configure event. You + * must set your anchor to opposite edges in the dimensions you + * omit; not doing so is a protocol error. Both values are 0 by + * default. + * + * Size is double-buffered, see wl_surface.commit. + */ + void (*set_size)(struct wl_client *client, + struct wl_resource *resource, + uint32_t width, + uint32_t height); + /** + * configures the anchor point of the surface + * + * Requests that the compositor anchor the surface to the + * specified edges and corners. If two orthogonal edges are + * specified (e.g. 'top' and 'left'), then the anchor point will be + * the intersection of the edges (e.g. the top left corner of the + * output); otherwise the anchor point will be centered on that + * edge, or in the center if none is specified. + * + * Anchor is double-buffered, see wl_surface.commit. + */ + void (*set_anchor)(struct wl_client *client, + struct wl_resource *resource, + uint32_t anchor); + /** + * configures the exclusive geometry of this surface + * + * Requests that the compositor avoids occluding an area with + * other surfaces. The compositor's use of this information is + * implementation-dependent - do not assume that this region will + * not actually be occluded. + * + * A positive value is only meaningful if the surface is anchored + * to one edge or an edge and both perpendicular edges. If the + * surface is not anchored, anchored to only two perpendicular + * edges (a corner), anchored to only two parallel edges or + * anchored to all edges, a positive value will be treated the same + * as zero. + * + * A positive zone is the distance from the edge in surface-local + * coordinates to consider exclusive. + * + * Surfaces that do not wish to have an exclusive zone may instead + * specify how they should interact with surfaces that do. If set + * to zero, the surface indicates that it would like to be moved to + * avoid occluding surfaces with a positive exclusive zone. If set + * to -1, the surface indicates that it would not like to be moved + * to accommodate for other surfaces, and the compositor should + * extend it all the way to the edges it is anchored to. + * + * For example, a panel might set its exclusive zone to 10, so that + * maximized shell surfaces are not shown on top of it. A + * notification might set its exclusive zone to 0, so that it is + * moved to avoid occluding the panel, but shell surfaces are shown + * underneath it. A wallpaper or lock screen might set their + * exclusive zone to -1, so that they stretch below or over the + * panel. + * + * The default value is 0. + * + * Exclusive zone is double-buffered, see wl_surface.commit. + */ + void (*set_exclusive_zone)(struct wl_client *client, + struct wl_resource *resource, + int32_t zone); + /** + * sets a margin from the anchor point + * + * Requests that the surface be placed some distance away from + * the anchor point on the output, in surface-local coordinates. + * Setting this value for edges you are not anchored to has no + * effect. + * + * The exclusive zone includes the margin. + * + * Margin is double-buffered, see wl_surface.commit. + */ + void (*set_margin)(struct wl_client *client, + struct wl_resource *resource, + int32_t top, + int32_t right, + int32_t bottom, + int32_t left); + /** + * requests keyboard events + * + * Set how keyboard events are delivered to this surface. By + * default, layer shell surfaces do not receive keyboard events; + * this request can be used to change this. + * + * This setting is inherited by child surfaces set by the get_popup + * request. + * + * Layer surfaces receive pointer, touch, and tablet events + * normally. If you do not want to receive them, set the input + * region on your surface to an empty region. + * + * Keyboard interactivity is double-buffered, see + * wl_surface.commit. + */ + void (*set_keyboard_interactivity)(struct wl_client *client, + struct wl_resource *resource, + uint32_t keyboard_interactivity); + /** + * assign this layer_surface as an xdg_popup parent + * + * This assigns an xdg_popup's parent to this layer_surface. This + * popup should have been created via xdg_surface::get_popup with + * the parent set to NULL, and this request must be invoked before + * committing the popup's initial state. + * + * See the documentation of xdg_popup for more details about what + * an xdg_popup is and how it is used. + */ + void (*get_popup)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *popup); + /** + * ack a configure event + * + * When a configure event is received, if a client commits the + * surface in response to the configure event, then the client must + * make an ack_configure request sometime before the commit + * request, passing along the serial of the configure event. + * + * If the client receives multiple configure events before it can + * respond to one, it only has to ack the last configure event. + * + * A client is not required to commit immediately after sending an + * ack_configure request - it may even ack_configure several times + * before its next surface commit. + * + * A client may send multiple ack_configure requests before + * committing, but only the last request sent before a commit + * indicates which configure event the client really is responding + * to. + * @param serial the serial from the configure event + */ + void (*ack_configure)(struct wl_client *client, + struct wl_resource *resource, + uint32_t serial); + /** + * destroy the layer_surface + * + * This request destroys the layer surface. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * change the layer of the surface + * + * Change the layer that the surface is rendered on. + * + * Layer is double-buffered, see wl_surface.commit. + * @param layer layer to move this surface to + * @since 2 + */ + void (*set_layer)(struct wl_client *client, + struct wl_resource *resource, + uint32_t layer); +}; + +#define ZWLR_LAYER_SURFACE_V1_CONFIGURE 0 +#define ZWLR_LAYER_SURFACE_V1_CLOSED 1 + +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_CLOSED_SINCE_VERSION 1 + +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_ANCHOR_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_MARGIN_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_GET_POPUP_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_LAYER_SINCE_VERSION 2 + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * Sends an configure event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +zwlr_layer_surface_v1_send_configure(struct wl_resource *resource_, uint32_t serial, uint32_t width, uint32_t height) +{ + wl_resource_post_event(resource_, ZWLR_LAYER_SURFACE_V1_CONFIGURE, serial, width, height); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * Sends an closed event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +zwlr_layer_surface_v1_send_closed(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, ZWLR_LAYER_SURFACE_V1_CLOSED); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/wlr-output-power-management-unstable-v1-protocol.h b/wlr-output-power-management-unstable-v1-protocol.h new file mode 100644 index 0000000..93d6a58 --- /dev/null +++ b/wlr-output-power-management-unstable-v1-protocol.h @@ -0,0 +1,285 @@ +/* Generated by wayland-scanner 1.25.0 */ + +#ifndef WLR_OUTPUT_POWER_MANAGEMENT_UNSTABLE_V1_SERVER_PROTOCOL_H +#define WLR_OUTPUT_POWER_MANAGEMENT_UNSTABLE_V1_SERVER_PROTOCOL_H + +#include +#include +#include "wayland-server.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct wl_client; +struct wl_resource; + +/** + * @page page_wlr_output_power_management_unstable_v1 The wlr_output_power_management_unstable_v1 protocol + * Control power management modes of outputs + * + * @section page_desc_wlr_output_power_management_unstable_v1 Description + * + * This protocol allows clients to control power management modes + * of outputs that are currently part of the compositor space. The + * intent is to allow special clients like desktop shells to power + * down outputs when the system is idle. + * + * To modify outputs not currently part of the compositor space see + * wlr-output-management. + * + * Warning! The protocol described in this file is experimental and + * backward incompatible changes may be made. Backward compatible changes + * may be added together with the corresponding interface version bump. + * Backward incompatible changes are done by bumping the version number in + * the protocol and interface names and resetting the interface version. + * Once the protocol is to be declared stable, the 'z' prefix and the + * version number in the protocol and interface names are removed and the + * interface version number is reset. + * + * @section page_ifaces_wlr_output_power_management_unstable_v1 Interfaces + * - @subpage page_iface_zwlr_output_power_manager_v1 - manager to create per-output power management + * - @subpage page_iface_zwlr_output_power_v1 - adjust power management mode for an output + * @section page_copyright_wlr_output_power_management_unstable_v1 Copyright + * 
+ *
+ * Copyright © 2019 Purism SPC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */ +struct wl_output; +struct zwlr_output_power_manager_v1; +struct zwlr_output_power_v1; + +#ifndef ZWLR_OUTPUT_POWER_MANAGER_V1_INTERFACE +#define ZWLR_OUTPUT_POWER_MANAGER_V1_INTERFACE +/** + * @page page_iface_zwlr_output_power_manager_v1 zwlr_output_power_manager_v1 + * @section page_iface_zwlr_output_power_manager_v1_desc Description + * + * This interface is a manager that allows creating per-output power + * management mode controls. + * @section page_iface_zwlr_output_power_manager_v1_api API + * See @ref iface_zwlr_output_power_manager_v1. + */ +/** + * @defgroup iface_zwlr_output_power_manager_v1 The zwlr_output_power_manager_v1 interface + * + * This interface is a manager that allows creating per-output power + * management mode controls. + */ +extern const struct wl_interface zwlr_output_power_manager_v1_interface; +#endif +#ifndef ZWLR_OUTPUT_POWER_V1_INTERFACE +#define ZWLR_OUTPUT_POWER_V1_INTERFACE +/** + * @page page_iface_zwlr_output_power_v1 zwlr_output_power_v1 + * @section page_iface_zwlr_output_power_v1_desc Description + * + * This object offers requests to set the power management mode of + * an output. + * @section page_iface_zwlr_output_power_v1_api API + * See @ref iface_zwlr_output_power_v1. + */ +/** + * @defgroup iface_zwlr_output_power_v1 The zwlr_output_power_v1 interface + * + * This object offers requests to set the power management mode of + * an output. + */ +extern const struct wl_interface zwlr_output_power_v1_interface; +#endif + +/** + * @ingroup iface_zwlr_output_power_manager_v1 + * @struct zwlr_output_power_manager_v1_interface + */ +struct zwlr_output_power_manager_v1_interface { + /** + * get a power management for an output + * + * Create a output power management mode control that can be used + * to adjust the power management mode for a given output. + */ + void (*get_output_power)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id, + struct wl_resource *output); + /** + * destroy the manager + * + * All objects created by the manager will still remain valid, + * until their appropriate destroy request has been called. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); +}; + + +/** + * @ingroup iface_zwlr_output_power_manager_v1 + */ +#define ZWLR_OUTPUT_POWER_MANAGER_V1_GET_OUTPUT_POWER_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_output_power_manager_v1 + */ +#define ZWLR_OUTPUT_POWER_MANAGER_V1_DESTROY_SINCE_VERSION 1 + +#ifndef ZWLR_OUTPUT_POWER_V1_MODE_ENUM +#define ZWLR_OUTPUT_POWER_V1_MODE_ENUM +enum zwlr_output_power_v1_mode { + /** + * Output is turned off. + */ + ZWLR_OUTPUT_POWER_V1_MODE_OFF = 0, + /** + * Output is turned on, no power saving + */ + ZWLR_OUTPUT_POWER_V1_MODE_ON = 1, +}; +#endif /* ZWLR_OUTPUT_POWER_V1_MODE_ENUM */ + +#ifndef ZWLR_OUTPUT_POWER_V1_MODE_ENUM_IS_VALID +#define ZWLR_OUTPUT_POWER_V1_MODE_ENUM_IS_VALID +/** + * @ingroup iface_zwlr_output_power_v1 + * Validate a zwlr_output_power_v1 mode value. + * + * @return true on success, false on error. + * @ref zwlr_output_power_v1_mode + */ +static inline bool +zwlr_output_power_v1_mode_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWLR_OUTPUT_POWER_V1_MODE_OFF: + return version >= 1; + case ZWLR_OUTPUT_POWER_V1_MODE_ON: + return version >= 1; + default: + return false; + } +} +#endif /* ZWLR_OUTPUT_POWER_V1_MODE_ENUM_IS_VALID */ + +#ifndef ZWLR_OUTPUT_POWER_V1_ERROR_ENUM +#define ZWLR_OUTPUT_POWER_V1_ERROR_ENUM +enum zwlr_output_power_v1_error { + /** + * inexistent power save mode + */ + ZWLR_OUTPUT_POWER_V1_ERROR_INVALID_MODE = 1, +}; +#endif /* ZWLR_OUTPUT_POWER_V1_ERROR_ENUM */ + +#ifndef ZWLR_OUTPUT_POWER_V1_ERROR_ENUM_IS_VALID +#define ZWLR_OUTPUT_POWER_V1_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_zwlr_output_power_v1 + * Validate a zwlr_output_power_v1 error value. + * + * @return true on success, false on error. + * @ref zwlr_output_power_v1_error + */ +static inline bool +zwlr_output_power_v1_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case ZWLR_OUTPUT_POWER_V1_ERROR_INVALID_MODE: + return version >= 1; + default: + return false; + } +} +#endif /* ZWLR_OUTPUT_POWER_V1_ERROR_ENUM_IS_VALID */ + +/** + * @ingroup iface_zwlr_output_power_v1 + * @struct zwlr_output_power_v1_interface + */ +struct zwlr_output_power_v1_interface { + /** + * Set an outputs power save mode + * + * Set an output's power save mode to the given mode. The mode + * change is effective immediately. If the output does not support + * the given mode a failed event is sent. + * @param mode the power save mode to set + */ + void (*set_mode)(struct wl_client *client, + struct wl_resource *resource, + uint32_t mode); + /** + * destroy this power management + * + * Destroys the output power management mode control object. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); +}; + +#define ZWLR_OUTPUT_POWER_V1_MODE 0 +#define ZWLR_OUTPUT_POWER_V1_FAILED 1 + +/** + * @ingroup iface_zwlr_output_power_v1 + */ +#define ZWLR_OUTPUT_POWER_V1_MODE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_output_power_v1 + */ +#define ZWLR_OUTPUT_POWER_V1_FAILED_SINCE_VERSION 1 + +/** + * @ingroup iface_zwlr_output_power_v1 + */ +#define ZWLR_OUTPUT_POWER_V1_SET_MODE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_output_power_v1 + */ +#define ZWLR_OUTPUT_POWER_V1_DESTROY_SINCE_VERSION 1 + +/** + * @ingroup iface_zwlr_output_power_v1 + * Sends an mode event to the client owning the resource. + * @param resource_ The client's resource + * @param mode the output's new power management mode + */ +static inline void +zwlr_output_power_v1_send_mode(struct wl_resource *resource_, uint32_t mode) +{ + wl_resource_post_event(resource_, ZWLR_OUTPUT_POWER_V1_MODE, mode); +} + +/** + * @ingroup iface_zwlr_output_power_v1 + * Sends an failed event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +zwlr_output_power_v1_send_failed(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, ZWLR_OUTPUT_POWER_V1_FAILED); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xdg-shell-protocol.h b/xdg-shell-protocol.h new file mode 100644 index 0000000..86f0e22 --- /dev/null +++ b/xdg-shell-protocol.h @@ -0,0 +1,2374 @@ +/* Generated by wayland-scanner 1.25.0 */ + +#ifndef XDG_SHELL_SERVER_PROTOCOL_H +#define XDG_SHELL_SERVER_PROTOCOL_H + +#include +#include +#include "wayland-server.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct wl_client; +struct wl_resource; + +/** + * @page page_xdg_shell The xdg_shell protocol + * @section page_ifaces_xdg_shell Interfaces + * - @subpage page_iface_xdg_wm_base - create desktop-style surfaces + * - @subpage page_iface_xdg_positioner - child surface positioner + * - @subpage page_iface_xdg_surface - desktop user interface surface base interface + * - @subpage page_iface_xdg_toplevel - toplevel surface + * - @subpage page_iface_xdg_popup - short-lived, popup surfaces for menus + * @section page_copyright_xdg_shell Copyright + * 
+ *
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */ +struct wl_output; +struct wl_seat; +struct wl_surface; +struct xdg_popup; +struct xdg_positioner; +struct xdg_surface; +struct xdg_toplevel; +struct xdg_wm_base; + +#ifndef XDG_WM_BASE_INTERFACE +#define XDG_WM_BASE_INTERFACE +/** + * @page page_iface_xdg_wm_base xdg_wm_base + * @section page_iface_xdg_wm_base_desc Description + * + * The xdg_wm_base interface is exposed as a global object enabling clients + * to turn their wl_surfaces into windows in a desktop environment. It + * defines the basic functionality needed for clients and the compositor to + * create windows that can be dragged, resized, maximized, etc, as well as + * creating transient windows such as popup menus. + * @section page_iface_xdg_wm_base_api API + * See @ref iface_xdg_wm_base. + */ +/** + * @defgroup iface_xdg_wm_base The xdg_wm_base interface + * + * The xdg_wm_base interface is exposed as a global object enabling clients + * to turn their wl_surfaces into windows in a desktop environment. It + * defines the basic functionality needed for clients and the compositor to + * create windows that can be dragged, resized, maximized, etc, as well as + * creating transient windows such as popup menus. + */ +extern const struct wl_interface xdg_wm_base_interface; +#endif +#ifndef XDG_POSITIONER_INTERFACE +#define XDG_POSITIONER_INTERFACE +/** + * @page page_iface_xdg_positioner xdg_positioner + * @section page_iface_xdg_positioner_desc Description + * + * The xdg_positioner provides a collection of rules for the placement of a + * child surface relative to a parent surface. Rules can be defined to ensure + * the child surface remains within the visible area's borders, and to + * specify how the child surface changes its position, such as sliding along + * an axis, or flipping around a rectangle. These positioner-created rules are + * constrained by the requirement that a child surface must intersect with or + * be at least partially adjacent to its parent surface. + * + * See the various requests for details about possible rules. + * + * At the time of the request, the compositor makes a copy of the rules + * specified by the xdg_positioner. Thus, after the request is complete the + * xdg_positioner object can be destroyed or reused; further changes to the + * object will have no effect on previous usages. + * + * For an xdg_positioner object to be considered complete, it must have a + * non-zero size set by set_size, and a non-zero anchor rectangle set by + * set_anchor_rect. Passing an incomplete xdg_positioner object when + * positioning a surface raises an invalid_positioner error. + * @section page_iface_xdg_positioner_api API + * See @ref iface_xdg_positioner. + */ +/** + * @defgroup iface_xdg_positioner The xdg_positioner interface + * + * The xdg_positioner provides a collection of rules for the placement of a + * child surface relative to a parent surface. Rules can be defined to ensure + * the child surface remains within the visible area's borders, and to + * specify how the child surface changes its position, such as sliding along + * an axis, or flipping around a rectangle. These positioner-created rules are + * constrained by the requirement that a child surface must intersect with or + * be at least partially adjacent to its parent surface. + * + * See the various requests for details about possible rules. + * + * At the time of the request, the compositor makes a copy of the rules + * specified by the xdg_positioner. Thus, after the request is complete the + * xdg_positioner object can be destroyed or reused; further changes to the + * object will have no effect on previous usages. + * + * For an xdg_positioner object to be considered complete, it must have a + * non-zero size set by set_size, and a non-zero anchor rectangle set by + * set_anchor_rect. Passing an incomplete xdg_positioner object when + * positioning a surface raises an invalid_positioner error. + */ +extern const struct wl_interface xdg_positioner_interface; +#endif +#ifndef XDG_SURFACE_INTERFACE +#define XDG_SURFACE_INTERFACE +/** + * @page page_iface_xdg_surface xdg_surface + * @section page_iface_xdg_surface_desc Description + * + * An interface that may be implemented by a wl_surface, for + * implementations that provide a desktop-style user interface. + * + * It provides a base set of functionality required to construct user + * interface elements requiring management by the compositor, such as + * toplevel windows, menus, etc. The types of functionality are split into + * xdg_surface roles. + * + * Creating an xdg_surface does not set the role for a wl_surface. In order + * to map an xdg_surface, the client must create a role-specific object + * using, e.g., get_toplevel, get_popup. The wl_surface for any given + * xdg_surface can have at most one role, and may not be assigned any role + * not based on xdg_surface. + * + * A role must be assigned before any other requests are made to the + * xdg_surface object. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_surface state to take effect. + * + * Creating an xdg_surface from a wl_surface which has a buffer attached or + * committed is a client error, and any attempts by a client to attach or + * manipulate a buffer prior to the first xdg_surface.configure call must + * also be treated as errors. + * + * After creating a role-specific object and setting it up (e.g. by sending + * the title, app ID, size constraints, parent, etc), the client must + * perform an initial commit without any buffer attached. The compositor + * will reply with initial wl_surface state such as + * wl_surface.preferred_buffer_scale followed by an xdg_surface.configure + * event. The client must acknowledge it and is then allowed to attach a + * buffer to map the surface. + * + * Mapping an xdg_surface-based role surface is defined as making it + * possible for the surface to be shown by the compositor. Note that + * a mapped surface is not guaranteed to be visible once it is mapped. + * + * For an xdg_surface to be mapped by the compositor, the following + * conditions must be met: + * (1) the client has assigned an xdg_surface-based role to the surface + * (2) the client has set and committed the xdg_surface state and the + * role-dependent state to the surface + * (3) the client has committed a buffer to the surface + * + * A newly-unmapped surface is considered to have met condition (1) out + * of the 3 required conditions for mapping a surface if its role surface + * has not been destroyed, i.e. the client must perform the initial commit + * again before attaching a buffer. + * @section page_iface_xdg_surface_api API + * See @ref iface_xdg_surface. + */ +/** + * @defgroup iface_xdg_surface The xdg_surface interface + * + * An interface that may be implemented by a wl_surface, for + * implementations that provide a desktop-style user interface. + * + * It provides a base set of functionality required to construct user + * interface elements requiring management by the compositor, such as + * toplevel windows, menus, etc. The types of functionality are split into + * xdg_surface roles. + * + * Creating an xdg_surface does not set the role for a wl_surface. In order + * to map an xdg_surface, the client must create a role-specific object + * using, e.g., get_toplevel, get_popup. The wl_surface for any given + * xdg_surface can have at most one role, and may not be assigned any role + * not based on xdg_surface. + * + * A role must be assigned before any other requests are made to the + * xdg_surface object. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_surface state to take effect. + * + * Creating an xdg_surface from a wl_surface which has a buffer attached or + * committed is a client error, and any attempts by a client to attach or + * manipulate a buffer prior to the first xdg_surface.configure call must + * also be treated as errors. + * + * After creating a role-specific object and setting it up (e.g. by sending + * the title, app ID, size constraints, parent, etc), the client must + * perform an initial commit without any buffer attached. The compositor + * will reply with initial wl_surface state such as + * wl_surface.preferred_buffer_scale followed by an xdg_surface.configure + * event. The client must acknowledge it and is then allowed to attach a + * buffer to map the surface. + * + * Mapping an xdg_surface-based role surface is defined as making it + * possible for the surface to be shown by the compositor. Note that + * a mapped surface is not guaranteed to be visible once it is mapped. + * + * For an xdg_surface to be mapped by the compositor, the following + * conditions must be met: + * (1) the client has assigned an xdg_surface-based role to the surface + * (2) the client has set and committed the xdg_surface state and the + * role-dependent state to the surface + * (3) the client has committed a buffer to the surface + * + * A newly-unmapped surface is considered to have met condition (1) out + * of the 3 required conditions for mapping a surface if its role surface + * has not been destroyed, i.e. the client must perform the initial commit + * again before attaching a buffer. + */ +extern const struct wl_interface xdg_surface_interface; +#endif +#ifndef XDG_TOPLEVEL_INTERFACE +#define XDG_TOPLEVEL_INTERFACE +/** + * @page page_iface_xdg_toplevel xdg_toplevel + * @section page_iface_xdg_toplevel_desc Description + * + * This interface defines an xdg_surface role which allows a surface to, + * among other things, set window-like properties such as maximize, + * fullscreen, and minimize, set application-specific metadata like title and + * id, and well as trigger user interactive operations such as interactive + * resize and move. + * + * A xdg_toplevel by default is responsible for providing the full intended + * visual representation of the toplevel, which depending on the window + * state, may mean things like a title bar, window controls and drop shadow. + * + * Unmapping an xdg_toplevel means that the surface cannot be shown + * by the compositor until it is explicitly mapped again. + * All active operations (e.g., move, resize) are canceled and all + * attributes (e.g. title, state, stacking, ...) are discarded for + * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to + * the state it had right after xdg_surface.get_toplevel. The client + * can re-map the toplevel by performing a commit without any buffer + * attached, waiting for a configure event and handling it as usual (see + * xdg_surface description). + * + * Attaching a null buffer to a toplevel unmaps the surface. + * @section page_iface_xdg_toplevel_api API + * See @ref iface_xdg_toplevel. + */ +/** + * @defgroup iface_xdg_toplevel The xdg_toplevel interface + * + * This interface defines an xdg_surface role which allows a surface to, + * among other things, set window-like properties such as maximize, + * fullscreen, and minimize, set application-specific metadata like title and + * id, and well as trigger user interactive operations such as interactive + * resize and move. + * + * A xdg_toplevel by default is responsible for providing the full intended + * visual representation of the toplevel, which depending on the window + * state, may mean things like a title bar, window controls and drop shadow. + * + * Unmapping an xdg_toplevel means that the surface cannot be shown + * by the compositor until it is explicitly mapped again. + * All active operations (e.g., move, resize) are canceled and all + * attributes (e.g. title, state, stacking, ...) are discarded for + * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to + * the state it had right after xdg_surface.get_toplevel. The client + * can re-map the toplevel by performing a commit without any buffer + * attached, waiting for a configure event and handling it as usual (see + * xdg_surface description). + * + * Attaching a null buffer to a toplevel unmaps the surface. + */ +extern const struct wl_interface xdg_toplevel_interface; +#endif +#ifndef XDG_POPUP_INTERFACE +#define XDG_POPUP_INTERFACE +/** + * @page page_iface_xdg_popup xdg_popup + * @section page_iface_xdg_popup_desc Description + * + * A popup surface is a short-lived, temporary surface. It can be used to + * implement for example menus, popovers, tooltips and other similar user + * interface concepts. + * + * A popup can be made to take an explicit grab. See xdg_popup.grab for + * details. + * + * When the popup is dismissed, a popup_done event will be sent out, and at + * the same time the surface will be unmapped. See the xdg_popup.popup_done + * event for details. + * + * Explicitly destroying the xdg_popup object will also dismiss the popup and + * unmap the surface. Clients that want to dismiss the popup when another + * surface of their own is clicked should dismiss the popup using the destroy + * request. + * + * A newly created xdg_popup will be stacked on top of all previously created + * xdg_popup surfaces associated with the same xdg_toplevel. + * + * The parent of an xdg_popup must be mapped (see the xdg_surface + * description) before the xdg_popup itself. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_popup state to take effect. + * @section page_iface_xdg_popup_api API + * See @ref iface_xdg_popup. + */ +/** + * @defgroup iface_xdg_popup The xdg_popup interface + * + * A popup surface is a short-lived, temporary surface. It can be used to + * implement for example menus, popovers, tooltips and other similar user + * interface concepts. + * + * A popup can be made to take an explicit grab. See xdg_popup.grab for + * details. + * + * When the popup is dismissed, a popup_done event will be sent out, and at + * the same time the surface will be unmapped. See the xdg_popup.popup_done + * event for details. + * + * Explicitly destroying the xdg_popup object will also dismiss the popup and + * unmap the surface. Clients that want to dismiss the popup when another + * surface of their own is clicked should dismiss the popup using the destroy + * request. + * + * A newly created xdg_popup will be stacked on top of all previously created + * xdg_popup surfaces associated with the same xdg_toplevel. + * + * The parent of an xdg_popup must be mapped (see the xdg_surface + * description) before the xdg_popup itself. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_popup state to take effect. + */ +extern const struct wl_interface xdg_popup_interface; +#endif + +#ifndef XDG_WM_BASE_ERROR_ENUM +#define XDG_WM_BASE_ERROR_ENUM +enum xdg_wm_base_error { + /** + * given wl_surface has another role + */ + XDG_WM_BASE_ERROR_ROLE = 0, + /** + * xdg_wm_base was destroyed before children + */ + XDG_WM_BASE_ERROR_DEFUNCT_SURFACES = 1, + /** + * the client tried to map or destroy a non-topmost popup + */ + XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP = 2, + /** + * the client specified an invalid popup parent surface + */ + XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT = 3, + /** + * the client provided an invalid surface state + */ + XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE = 4, + /** + * the client provided an invalid positioner + */ + XDG_WM_BASE_ERROR_INVALID_POSITIONER = 5, + /** + * the client didn’t respond to a ping event in time + */ + XDG_WM_BASE_ERROR_UNRESPONSIVE = 6, +}; +#endif /* XDG_WM_BASE_ERROR_ENUM */ + +#ifndef XDG_WM_BASE_ERROR_ENUM_IS_VALID +#define XDG_WM_BASE_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_xdg_wm_base + * Validate a xdg_wm_base error value. + * + * @return true on success, false on error. + * @ref xdg_wm_base_error + */ +static inline bool +xdg_wm_base_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_WM_BASE_ERROR_ROLE: + return version >= 1; + case XDG_WM_BASE_ERROR_DEFUNCT_SURFACES: + return version >= 1; + case XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP: + return version >= 1; + case XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT: + return version >= 1; + case XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE: + return version >= 1; + case XDG_WM_BASE_ERROR_INVALID_POSITIONER: + return version >= 1; + case XDG_WM_BASE_ERROR_UNRESPONSIVE: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_WM_BASE_ERROR_ENUM_IS_VALID */ + +/** + * @ingroup iface_xdg_wm_base + * @struct xdg_wm_base_interface + */ +struct xdg_wm_base_interface { + /** + * destroy xdg_wm_base + * + * Destroy this xdg_wm_base object. + * + * Destroying a bound xdg_wm_base object while there are surfaces + * still alive created by this xdg_wm_base object instance is + * illegal and will result in a defunct_surfaces error. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * create a positioner object + * + * Create a positioner object. A positioner object is used to + * position surfaces relative to some parent surface. See the + * interface description and xdg_surface.get_popup for details. + */ + void (*create_positioner)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id); + /** + * create a shell surface from a surface + * + * This creates an xdg_surface for the given surface. While + * xdg_surface itself is not a role, the corresponding surface may + * only be assigned a role extending xdg_surface, such as + * xdg_toplevel or xdg_popup. It is illegal to create an + * xdg_surface for a wl_surface which already has an assigned role + * and this will result in a role error. + * + * This creates an xdg_surface for the given surface. An + * xdg_surface is used as basis to define a role to a given + * surface, such as xdg_toplevel or xdg_popup. It also manages + * functionality shared between xdg_surface based surface roles. + * + * See the documentation of xdg_surface for more details about what + * an xdg_surface is and how it is used. + */ + void (*get_xdg_surface)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id, + struct wl_resource *surface); + /** + * respond to a ping event + * + * A client must respond to a ping event with a pong request or + * the client may be deemed unresponsive. See xdg_wm_base.ping and + * xdg_wm_base.error.unresponsive. + * @param serial serial of the ping event + */ + void (*pong)(struct wl_client *client, + struct wl_resource *resource, + uint32_t serial); +}; + +#define XDG_WM_BASE_PING 0 + +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_PING_SINCE_VERSION 1 + +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_CREATE_POSITIONER_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_GET_XDG_SURFACE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_PONG_SINCE_VERSION 1 + +/** + * @ingroup iface_xdg_wm_base + * Sends an ping event to the client owning the resource. + * @param resource_ The client's resource + * @param serial pass this to the pong request + */ +static inline void +xdg_wm_base_send_ping(struct wl_resource *resource_, uint32_t serial) +{ + wl_resource_post_event(resource_, XDG_WM_BASE_PING, serial); +} + +#ifndef XDG_POSITIONER_ERROR_ENUM +#define XDG_POSITIONER_ERROR_ENUM +enum xdg_positioner_error { + /** + * invalid input provided + */ + XDG_POSITIONER_ERROR_INVALID_INPUT = 0, +}; +#endif /* XDG_POSITIONER_ERROR_ENUM */ + +#ifndef XDG_POSITIONER_ERROR_ENUM_IS_VALID +#define XDG_POSITIONER_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_xdg_positioner + * Validate a xdg_positioner error value. + * + * @return true on success, false on error. + * @ref xdg_positioner_error + */ +static inline bool +xdg_positioner_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_POSITIONER_ERROR_INVALID_INPUT: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_POSITIONER_ERROR_ENUM_IS_VALID */ + +#ifndef XDG_POSITIONER_ANCHOR_ENUM +#define XDG_POSITIONER_ANCHOR_ENUM +enum xdg_positioner_anchor { + XDG_POSITIONER_ANCHOR_NONE = 0, + XDG_POSITIONER_ANCHOR_TOP = 1, + XDG_POSITIONER_ANCHOR_BOTTOM = 2, + XDG_POSITIONER_ANCHOR_LEFT = 3, + XDG_POSITIONER_ANCHOR_RIGHT = 4, + XDG_POSITIONER_ANCHOR_TOP_LEFT = 5, + XDG_POSITIONER_ANCHOR_BOTTOM_LEFT = 6, + XDG_POSITIONER_ANCHOR_TOP_RIGHT = 7, + XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT = 8, +}; +#endif /* XDG_POSITIONER_ANCHOR_ENUM */ + +#ifndef XDG_POSITIONER_ANCHOR_ENUM_IS_VALID +#define XDG_POSITIONER_ANCHOR_ENUM_IS_VALID +/** + * @ingroup iface_xdg_positioner + * Validate a xdg_positioner anchor value. + * + * @return true on success, false on error. + * @ref xdg_positioner_anchor + */ +static inline bool +xdg_positioner_anchor_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_POSITIONER_ANCHOR_NONE: + return version >= 1; + case XDG_POSITIONER_ANCHOR_TOP: + return version >= 1; + case XDG_POSITIONER_ANCHOR_BOTTOM: + return version >= 1; + case XDG_POSITIONER_ANCHOR_LEFT: + return version >= 1; + case XDG_POSITIONER_ANCHOR_RIGHT: + return version >= 1; + case XDG_POSITIONER_ANCHOR_TOP_LEFT: + return version >= 1; + case XDG_POSITIONER_ANCHOR_BOTTOM_LEFT: + return version >= 1; + case XDG_POSITIONER_ANCHOR_TOP_RIGHT: + return version >= 1; + case XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_POSITIONER_ANCHOR_ENUM_IS_VALID */ + +#ifndef XDG_POSITIONER_GRAVITY_ENUM +#define XDG_POSITIONER_GRAVITY_ENUM +enum xdg_positioner_gravity { + XDG_POSITIONER_GRAVITY_NONE = 0, + XDG_POSITIONER_GRAVITY_TOP = 1, + XDG_POSITIONER_GRAVITY_BOTTOM = 2, + XDG_POSITIONER_GRAVITY_LEFT = 3, + XDG_POSITIONER_GRAVITY_RIGHT = 4, + XDG_POSITIONER_GRAVITY_TOP_LEFT = 5, + XDG_POSITIONER_GRAVITY_BOTTOM_LEFT = 6, + XDG_POSITIONER_GRAVITY_TOP_RIGHT = 7, + XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT = 8, +}; +#endif /* XDG_POSITIONER_GRAVITY_ENUM */ + +#ifndef XDG_POSITIONER_GRAVITY_ENUM_IS_VALID +#define XDG_POSITIONER_GRAVITY_ENUM_IS_VALID +/** + * @ingroup iface_xdg_positioner + * Validate a xdg_positioner gravity value. + * + * @return true on success, false on error. + * @ref xdg_positioner_gravity + */ +static inline bool +xdg_positioner_gravity_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_POSITIONER_GRAVITY_NONE: + return version >= 1; + case XDG_POSITIONER_GRAVITY_TOP: + return version >= 1; + case XDG_POSITIONER_GRAVITY_BOTTOM: + return version >= 1; + case XDG_POSITIONER_GRAVITY_LEFT: + return version >= 1; + case XDG_POSITIONER_GRAVITY_RIGHT: + return version >= 1; + case XDG_POSITIONER_GRAVITY_TOP_LEFT: + return version >= 1; + case XDG_POSITIONER_GRAVITY_BOTTOM_LEFT: + return version >= 1; + case XDG_POSITIONER_GRAVITY_TOP_RIGHT: + return version >= 1; + case XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_POSITIONER_GRAVITY_ENUM_IS_VALID */ + +#ifndef XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM +#define XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM +/** + * @ingroup iface_xdg_positioner + * constraint adjustments + * + * The constraint adjustment value define ways the compositor will adjust + * the position of the surface, if the unadjusted position would result + * in the surface being partly constrained. + * + * Whether a surface is considered 'constrained' is left to the compositor + * to determine. For example, the surface may be partly outside the + * compositor's defined 'work area', thus necessitating the child surface's + * position be adjusted until it is entirely inside the work area. + * + * The adjustments can be combined, according to a defined precedence: 1) + * Flip, 2) Slide, 3) Resize. + */ +enum xdg_positioner_constraint_adjustment { + /** + * don't move the child surface when constrained + * + * Don't alter the surface position even if it is constrained on + * some axis, for example partially outside the edge of an output. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE = 0, + /** + * move along the x axis until unconstrained + * + * Slide the surface along the x axis until it is no longer + * constrained. + * + * First try to slide towards the direction of the gravity on the x + * axis until either the edge in the opposite direction of the + * gravity is unconstrained or the edge in the direction of the + * gravity is constrained. + * + * Then try to slide towards the opposite direction of the gravity + * on the x axis until either the edge in the direction of the + * gravity is unconstrained or the edge in the opposite direction + * of the gravity is constrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1, + /** + * move along the y axis until unconstrained + * + * Slide the surface along the y axis until it is no longer + * constrained. + * + * First try to slide towards the direction of the gravity on the y + * axis until either the edge in the opposite direction of the + * gravity is unconstrained or the edge in the direction of the + * gravity is constrained. + * + * Then try to slide towards the opposite direction of the gravity + * on the y axis until either the edge in the direction of the + * gravity is unconstrained or the edge in the opposite direction + * of the gravity is constrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2, + /** + * invert the anchor and gravity on the x axis + * + * Invert the anchor and gravity on the x axis if the surface is + * constrained on the x axis. For example, if the left edge of the + * surface is constrained, the gravity is 'left' and the anchor is + * 'left', change the gravity to 'right' and the anchor to 'right'. + * + * If the adjusted position also ends up being constrained, the + * resulting position of the flip_x adjustment will be the one + * before the adjustment. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X = 4, + /** + * invert the anchor and gravity on the y axis + * + * Invert the anchor and gravity on the y axis if the surface is + * constrained on the y axis. For example, if the bottom edge of + * the surface is constrained, the gravity is 'bottom' and the + * anchor is 'bottom', change the gravity to 'top' and the anchor + * to 'top'. + * + * The adjusted position is calculated given the original anchor + * rectangle and offset, but with the new flipped anchor and + * gravity values. + * + * If the adjusted position also ends up being constrained, the + * resulting position of the flip_y adjustment will be the one + * before the adjustment. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8, + /** + * horizontally resize the surface + * + * Resize the surface horizontally so that it is completely + * unconstrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16, + /** + * vertically resize the surface + * + * Resize the surface vertically so that it is completely + * unconstrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32, +}; +#endif /* XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM */ + +#ifndef XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM_IS_VALID +#define XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM_IS_VALID +/** + * @ingroup iface_xdg_positioner + * Validate a xdg_positioner constraint_adjustment value. + * + * @return true on success, false on error. + * @ref xdg_positioner_constraint_adjustment + */ +static inline bool +xdg_positioner_constraint_adjustment_is_valid(uint32_t value, uint32_t version) { + uint32_t valid = 0; + if (version >= 1) + valid |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE; + if (version >= 1) + valid |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X; + if (version >= 1) + valid |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y; + if (version >= 1) + valid |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X; + if (version >= 1) + valid |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y; + if (version >= 1) + valid |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X; + if (version >= 1) + valid |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y; + return (value & ~valid) == 0; +} +#endif /* XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM_IS_VALID */ + +/** + * @ingroup iface_xdg_positioner + * @struct xdg_positioner_interface + */ +struct xdg_positioner_interface { + /** + * destroy the xdg_positioner object + * + * Notify the compositor that the xdg_positioner will no longer + * be used. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * set the size of the to-be positioned rectangle + * + * Set the size of the surface that is to be positioned with the + * positioner object. The size is in surface-local coordinates and + * corresponds to the window geometry. See + * xdg_surface.set_window_geometry. + * + * If a zero or negative size is set the invalid_input error is + * raised. + * @param width width of positioned rectangle + * @param height height of positioned rectangle + */ + void (*set_size)(struct wl_client *client, + struct wl_resource *resource, + int32_t width, + int32_t height); + /** + * set the anchor rectangle within the parent surface + * + * Specify the anchor rectangle within the parent surface that + * the child surface will be placed relative to. The rectangle is + * relative to the window geometry as defined by + * xdg_surface.set_window_geometry of the parent surface. + * + * When the xdg_positioner object is used to position a child + * surface, the anchor rectangle may not extend outside the window + * geometry of the positioned child's parent surface. + * + * If a negative size is set the invalid_input error is raised. + * @param x x position of anchor rectangle + * @param y y position of anchor rectangle + * @param width width of anchor rectangle + * @param height height of anchor rectangle + */ + void (*set_anchor_rect)(struct wl_client *client, + struct wl_resource *resource, + int32_t x, + int32_t y, + int32_t width, + int32_t height); + /** + * set anchor rectangle anchor + * + * Defines the anchor point for the anchor rectangle. The + * specified anchor is used derive an anchor point that the child + * surface will be positioned relative to. If a corner anchor is + * set (e.g. 'top_left' or 'bottom_right'), the anchor point will + * be at the specified corner; otherwise, the derived anchor point + * will be centered on the specified edge, or in the center of the + * anchor rectangle if no edge is specified. + * @param anchor anchor + */ + void (*set_anchor)(struct wl_client *client, + struct wl_resource *resource, + uint32_t anchor); + /** + * set child surface gravity + * + * Defines in what direction a surface should be positioned, + * relative to the anchor point of the parent surface. If a corner + * gravity is specified (e.g. 'bottom_right' or 'top_left'), then + * the child surface will be placed towards the specified gravity; + * otherwise, the child surface will be centered over the anchor + * point on any axis that had no gravity specified. If the gravity + * is not in the ‘gravity’ enum, an invalid_input error is + * raised. + * @param gravity gravity direction + */ + void (*set_gravity)(struct wl_client *client, + struct wl_resource *resource, + uint32_t gravity); + /** + * set the adjustment to be done when constrained + * + * Specify how the window should be positioned if the originally + * intended position caused the surface to be constrained, meaning + * at least partially outside positioning boundaries set by the + * compositor. The adjustment is set by constructing a bitmask + * describing the adjustment to be made when the surface is + * constrained on that axis. + * + * If no bit for one axis is set, the compositor will assume that + * the child surface should not change its position on that axis + * when constrained. + * + * If more than one bit for one axis is set, the order of how + * adjustments are applied is specified in the corresponding + * adjustment descriptions. + * + * The default adjustment is none. + * @param constraint_adjustment bit mask of constraint adjustments + */ + void (*set_constraint_adjustment)(struct wl_client *client, + struct wl_resource *resource, + uint32_t constraint_adjustment); + /** + * set surface position offset + * + * Specify the surface position offset relative to the position + * of the anchor on the anchor rectangle and the anchor on the + * surface. For example if the anchor of the anchor rectangle is at + * (x, y), the surface has the gravity bottom|right, and the offset + * is (ox, oy), the calculated surface position will be (x + ox, y + * + oy). The offset position of the surface is the one used for + * constraint testing. See set_constraint_adjustment. + * + * An example use case is placing a popup menu on top of a user + * interface element, while aligning the user interface element of + * the parent surface with some user interface element placed + * somewhere in the popup surface. + * @param x surface position x offset + * @param y surface position y offset + */ + void (*set_offset)(struct wl_client *client, + struct wl_resource *resource, + int32_t x, + int32_t y); + /** + * continuously reconstrain the surface + * + * When set reactive, the surface is reconstrained if the + * conditions used for constraining changed, e.g. the parent window + * moved. + * + * If the conditions changed and the popup was reconstrained, an + * xdg_popup.configure event is sent with updated geometry, + * followed by an xdg_surface.configure event. + * @since 3 + */ + void (*set_reactive)(struct wl_client *client, + struct wl_resource *resource); + /** + * + * + * Set the parent window geometry the compositor should use when + * positioning the popup. The compositor may use this information + * to determine the future state the popup should be constrained + * using. If this doesn't match the dimension of the parent the + * popup is eventually positioned against, the behavior is + * undefined. + * + * The arguments are given in the surface-local coordinate space. + * @param parent_width future window geometry width of parent + * @param parent_height future window geometry height of parent + * @since 3 + */ + void (*set_parent_size)(struct wl_client *client, + struct wl_resource *resource, + int32_t parent_width, + int32_t parent_height); + /** + * set parent configure this is a response to + * + * Set the serial of an xdg_surface.configure event this + * positioner will be used in response to. The compositor may use + * this information together with set_parent_size to determine what + * future state the popup should be constrained using. + * @param serial serial of parent configure event + * @since 3 + */ + void (*set_parent_configure)(struct wl_client *client, + struct wl_resource *resource, + uint32_t serial); +}; + + +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_ANCHOR_RECT_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_ANCHOR_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_GRAVITY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_OFFSET_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_REACTIVE_SINCE_VERSION 3 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_PARENT_SIZE_SINCE_VERSION 3 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_PARENT_CONFIGURE_SINCE_VERSION 3 + +#ifndef XDG_SURFACE_ERROR_ENUM +#define XDG_SURFACE_ERROR_ENUM +enum xdg_surface_error { + /** + * Surface was not fully constructed + */ + XDG_SURFACE_ERROR_NOT_CONSTRUCTED = 1, + /** + * Surface was already constructed + */ + XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED = 2, + /** + * Attaching a buffer to an unconfigured surface + */ + XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER = 3, + /** + * Invalid serial number when acking a configure event + */ + XDG_SURFACE_ERROR_INVALID_SERIAL = 4, + /** + * Width or height was zero or negative + */ + XDG_SURFACE_ERROR_INVALID_SIZE = 5, + /** + * Surface was destroyed before its role object + */ + XDG_SURFACE_ERROR_DEFUNCT_ROLE_OBJECT = 6, +}; +#endif /* XDG_SURFACE_ERROR_ENUM */ + +#ifndef XDG_SURFACE_ERROR_ENUM_IS_VALID +#define XDG_SURFACE_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_xdg_surface + * Validate a xdg_surface error value. + * + * @return true on success, false on error. + * @ref xdg_surface_error + */ +static inline bool +xdg_surface_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_SURFACE_ERROR_NOT_CONSTRUCTED: + return version >= 1; + case XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED: + return version >= 1; + case XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER: + return version >= 1; + case XDG_SURFACE_ERROR_INVALID_SERIAL: + return version >= 1; + case XDG_SURFACE_ERROR_INVALID_SIZE: + return version >= 1; + case XDG_SURFACE_ERROR_DEFUNCT_ROLE_OBJECT: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_SURFACE_ERROR_ENUM_IS_VALID */ + +/** + * @ingroup iface_xdg_surface + * @struct xdg_surface_interface + */ +struct xdg_surface_interface { + /** + * destroy the xdg_surface + * + * Destroy the xdg_surface object. An xdg_surface must only be + * destroyed after its role object has been destroyed, otherwise a + * defunct_role_object error is raised. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * assign the xdg_toplevel surface role + * + * This creates an xdg_toplevel object for the given xdg_surface + * and gives the associated wl_surface the xdg_toplevel role. + * + * See the documentation of xdg_toplevel for more details about + * what an xdg_toplevel is and how it is used. + */ + void (*get_toplevel)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id); + /** + * assign the xdg_popup surface role + * + * This creates an xdg_popup object for the given xdg_surface and + * gives the associated wl_surface the xdg_popup role. + * + * If null is passed as a parent, a parent surface must be + * specified using some other protocol, before committing the + * initial state. + * + * See the documentation of xdg_popup for more details about what + * an xdg_popup is and how it is used. + */ + void (*get_popup)(struct wl_client *client, + struct wl_resource *resource, + uint32_t id, + struct wl_resource *parent, + struct wl_resource *positioner); + /** + * set the new window geometry + * + * The window geometry of a surface is its "visible bounds" from + * the user's perspective. Client-side decorations often have + * invisible portions like drop-shadows which should be ignored for + * the purposes of aligning, placing and constraining windows. Note + * that in some situations, compositors may clip rendering to the + * window geometry, so the client should avoid putting functional + * elements outside of it. + * + * The window geometry is double-buffered state, see + * wl_surface.commit. + * + * When maintaining a position, the compositor should treat the (x, + * y) coordinate of the window geometry as the top left corner of + * the window. A client changing the (x, y) window geometry + * coordinate should in general not alter the position of the + * window. + * + * Once the window geometry of the surface is set, it is not + * possible to unset it, and it will remain the same until + * set_window_geometry is called again, even if a new subsurface or + * buffer is attached. + * + * If never set, the value is the full bounds of the surface, + * including any subsurfaces. This updates dynamically on every + * commit. This unset is meant for extremely simple clients. + * + * The arguments are given in the surface-local coordinate space of + * the wl_surface associated with this xdg_surface, and may extend + * outside of the wl_surface itself to mark parts of the subsurface + * tree as part of the window geometry. + * + * When applied, the effective window geometry will be the set + * window geometry clamped to the bounding rectangle of the + * combined geometry of the surface of the xdg_surface and the + * associated subsurfaces. + * + * The effective geometry will not be recalculated unless a new + * call to set_window_geometry is done and the new pending surface + * state is subsequently applied. + * + * The width and height of the effective window geometry must be + * greater than zero. Setting an invalid size will raise an + * invalid_size error. + */ + void (*set_window_geometry)(struct wl_client *client, + struct wl_resource *resource, + int32_t x, + int32_t y, + int32_t width, + int32_t height); + /** + * ack a configure event + * + * When a configure event is received, if a client commits the + * surface in response to the configure event, then the client must + * make an ack_configure request sometime before the commit + * request, passing along the serial of the configure event. + * + * For instance, for toplevel surfaces the compositor might use + * this information to move a surface to the top left only when the + * client has drawn itself for the maximized or fullscreen state. + * + * If the client receives multiple configure events before it can + * respond to one, it only has to ack the last configure event. + * Acking a configure event that was never sent raises an + * invalid_serial error. + * + * A client is not required to commit immediately after sending an + * ack_configure request - it may even ack_configure several times + * before its next surface commit. + * + * A client may send multiple ack_configure requests before + * committing, but only the last request sent before a commit + * indicates which configure event the client really is responding + * to. + * + * Sending an ack_configure request consumes the serial number sent + * with the request, as well as serial numbers sent by all + * configure events sent on this xdg_surface prior to the configure + * event referenced by the committed serial. + * + * It is an error to issue multiple ack_configure requests + * referencing a serial from the same configure event, or to issue + * an ack_configure request referencing a serial from a configure + * event issued before the event identified by the last + * ack_configure request for the same xdg_surface. Doing so will + * raise an invalid_serial error. + * @param serial the serial from the configure event + */ + void (*ack_configure)(struct wl_client *client, + struct wl_resource *resource, + uint32_t serial); +}; + +#define XDG_SURFACE_CONFIGURE 0 + +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1 + +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_GET_TOPLEVEL_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_GET_POPUP_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION 1 + +/** + * @ingroup iface_xdg_surface + * Sends an configure event to the client owning the resource. + * @param resource_ The client's resource + * @param serial serial of the configure event + */ +static inline void +xdg_surface_send_configure(struct wl_resource *resource_, uint32_t serial) +{ + wl_resource_post_event(resource_, XDG_SURFACE_CONFIGURE, serial); +} + +#ifndef XDG_TOPLEVEL_ERROR_ENUM +#define XDG_TOPLEVEL_ERROR_ENUM +enum xdg_toplevel_error { + /** + * provided value is not a valid variant of the resize_edge enum + */ + XDG_TOPLEVEL_ERROR_INVALID_RESIZE_EDGE = 0, + /** + * invalid parent toplevel + */ + XDG_TOPLEVEL_ERROR_INVALID_PARENT = 1, + /** + * client provided an invalid min or max size + */ + XDG_TOPLEVEL_ERROR_INVALID_SIZE = 2, +}; +#endif /* XDG_TOPLEVEL_ERROR_ENUM */ + +#ifndef XDG_TOPLEVEL_ERROR_ENUM_IS_VALID +#define XDG_TOPLEVEL_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_xdg_toplevel + * Validate a xdg_toplevel error value. + * + * @return true on success, false on error. + * @ref xdg_toplevel_error + */ +static inline bool +xdg_toplevel_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_TOPLEVEL_ERROR_INVALID_RESIZE_EDGE: + return version >= 1; + case XDG_TOPLEVEL_ERROR_INVALID_PARENT: + return version >= 1; + case XDG_TOPLEVEL_ERROR_INVALID_SIZE: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_TOPLEVEL_ERROR_ENUM_IS_VALID */ + +#ifndef XDG_TOPLEVEL_RESIZE_EDGE_ENUM +#define XDG_TOPLEVEL_RESIZE_EDGE_ENUM +/** + * @ingroup iface_xdg_toplevel + * edge values for resizing + * + * These values are used to indicate which edge of a surface + * is being dragged in a resize operation. + */ +enum xdg_toplevel_resize_edge { + XDG_TOPLEVEL_RESIZE_EDGE_NONE = 0, + XDG_TOPLEVEL_RESIZE_EDGE_TOP = 1, + XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM = 2, + XDG_TOPLEVEL_RESIZE_EDGE_LEFT = 4, + XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT = 5, + XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT = 6, + XDG_TOPLEVEL_RESIZE_EDGE_RIGHT = 8, + XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT = 9, + XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT = 10, +}; +#endif /* XDG_TOPLEVEL_RESIZE_EDGE_ENUM */ + +#ifndef XDG_TOPLEVEL_RESIZE_EDGE_ENUM_IS_VALID +#define XDG_TOPLEVEL_RESIZE_EDGE_ENUM_IS_VALID +/** + * @ingroup iface_xdg_toplevel + * Validate a xdg_toplevel resize_edge value. + * + * @return true on success, false on error. + * @ref xdg_toplevel_resize_edge + */ +static inline bool +xdg_toplevel_resize_edge_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_TOPLEVEL_RESIZE_EDGE_NONE: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_TOP: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_LEFT: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_RIGHT: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT: + return version >= 1; + case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_TOPLEVEL_RESIZE_EDGE_ENUM_IS_VALID */ + +#ifndef XDG_TOPLEVEL_STATE_ENUM +#define XDG_TOPLEVEL_STATE_ENUM +/** + * @ingroup iface_xdg_toplevel + * types of state on the surface + * + * The different state values used on the surface. This is designed for + * state values like maximized, fullscreen. It is paired with the + * configure event to ensure that both the client and the compositor + * setting the state can be synchronized. + * + * States set in this way are double-buffered, see wl_surface.commit. + */ +enum xdg_toplevel_state { + /** + * the surface is maximized + * the surface is maximized + * + * The surface is maximized. The window geometry specified in the + * configure event must be obeyed by the client, or the + * xdg_wm_base.invalid_surface_state error is raised. + * + * The client should draw without shadow or other decoration + * outside of the window geometry. + */ + XDG_TOPLEVEL_STATE_MAXIMIZED = 1, + /** + * the surface is fullscreen + * the surface is fullscreen + * + * The surface is fullscreen. The window geometry specified in + * the configure event is a maximum; the client cannot resize + * beyond it. For a surface to cover the whole fullscreened area, + * the geometry dimensions must be obeyed by the client. For more + * details, see xdg_toplevel.set_fullscreen. + */ + XDG_TOPLEVEL_STATE_FULLSCREEN = 2, + /** + * the surface is being resized + * the surface is being resized + * + * The surface is being resized. The window geometry specified in + * the configure event is a maximum; the client cannot resize + * beyond it. Clients that have aspect ratio or cell sizing + * configuration can use a smaller size, however. + */ + XDG_TOPLEVEL_STATE_RESIZING = 3, + /** + * the surface is now activated + * the surface is now activated + * + * Client window decorations should be painted as if the window + * is active. Do not assume this means that the window actually has + * keyboard or pointer focus. + */ + XDG_TOPLEVEL_STATE_ACTIVATED = 4, + /** + * the surface’s left edge is tiled + * + * The window is currently in a tiled layout and the left edge is + * considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the left edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_LEFT = 5, + /** + * the surface’s right edge is tiled + * + * The window is currently in a tiled layout and the right edge + * is considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the right edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_RIGHT = 6, + /** + * the surface’s top edge is tiled + * + * The window is currently in a tiled layout and the top edge is + * considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the top edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_TOP = 7, + /** + * the surface’s bottom edge is tiled + * + * The window is currently in a tiled layout and the bottom edge + * is considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the bottom edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_BOTTOM = 8, + /** + * surface repaint is suspended + * + * The surface is currently not ordinarily being repainted; for + * example because its content is occluded by another window, or + * its outputs are switched off due to screen locking. + * @since 6 + */ + XDG_TOPLEVEL_STATE_SUSPENDED = 9, + /** + * the surface’s left edge is constrained + * + * The left edge of the window is currently constrained, meaning + * it shouldn't attempt to resize from that edge. It can for + * example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_LEFT = 10, + /** + * the surface’s right edge is constrained + * + * The right edge of the window is currently constrained, meaning + * it shouldn't attempt to resize from that edge. It can for + * example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_RIGHT = 11, + /** + * the surface’s top edge is constrained + * + * The top edge of the window is currently constrained, meaning + * it shouldn't attempt to resize from that edge. It can for + * example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_TOP = 12, + /** + * the surface’s bottom edge is constrained + * + * The bottom edge of the window is currently constrained, + * meaning it shouldn't attempt to resize from that edge. It can + * for example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_BOTTOM = 13, +}; +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_TOP_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_SUSPENDED_SINCE_VERSION 6 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_LEFT_SINCE_VERSION 7 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_RIGHT_SINCE_VERSION 7 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_TOP_SINCE_VERSION 7 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_BOTTOM_SINCE_VERSION 7 +#endif /* XDG_TOPLEVEL_STATE_ENUM */ + +#ifndef XDG_TOPLEVEL_STATE_ENUM_IS_VALID +#define XDG_TOPLEVEL_STATE_ENUM_IS_VALID +/** + * @ingroup iface_xdg_toplevel + * Validate a xdg_toplevel state value. + * + * @return true on success, false on error. + * @ref xdg_toplevel_state + */ +static inline bool +xdg_toplevel_state_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_TOPLEVEL_STATE_MAXIMIZED: + return version >= 1; + case XDG_TOPLEVEL_STATE_FULLSCREEN: + return version >= 1; + case XDG_TOPLEVEL_STATE_RESIZING: + return version >= 1; + case XDG_TOPLEVEL_STATE_ACTIVATED: + return version >= 1; + case XDG_TOPLEVEL_STATE_TILED_LEFT: + return version >= 2; + case XDG_TOPLEVEL_STATE_TILED_RIGHT: + return version >= 2; + case XDG_TOPLEVEL_STATE_TILED_TOP: + return version >= 2; + case XDG_TOPLEVEL_STATE_TILED_BOTTOM: + return version >= 2; + case XDG_TOPLEVEL_STATE_SUSPENDED: + return version >= 6; + case XDG_TOPLEVEL_STATE_CONSTRAINED_LEFT: + return version >= 7; + case XDG_TOPLEVEL_STATE_CONSTRAINED_RIGHT: + return version >= 7; + case XDG_TOPLEVEL_STATE_CONSTRAINED_TOP: + return version >= 7; + case XDG_TOPLEVEL_STATE_CONSTRAINED_BOTTOM: + return version >= 7; + default: + return false; + } +} +#endif /* XDG_TOPLEVEL_STATE_ENUM_IS_VALID */ + +#ifndef XDG_TOPLEVEL_WM_CAPABILITIES_ENUM +#define XDG_TOPLEVEL_WM_CAPABILITIES_ENUM +enum xdg_toplevel_wm_capabilities { + /** + * show_window_menu is available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_WINDOW_MENU = 1, + /** + * set_maximized and unset_maximized are available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE = 2, + /** + * set_fullscreen and unset_fullscreen are available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN = 3, + /** + * set_minimized is available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_MINIMIZE = 4, +}; +#endif /* XDG_TOPLEVEL_WM_CAPABILITIES_ENUM */ + +#ifndef XDG_TOPLEVEL_WM_CAPABILITIES_ENUM_IS_VALID +#define XDG_TOPLEVEL_WM_CAPABILITIES_ENUM_IS_VALID +/** + * @ingroup iface_xdg_toplevel + * Validate a xdg_toplevel wm_capabilities value. + * + * @return true on success, false on error. + * @ref xdg_toplevel_wm_capabilities + */ +static inline bool +xdg_toplevel_wm_capabilities_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_TOPLEVEL_WM_CAPABILITIES_WINDOW_MENU: + return version >= 1; + case XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE: + return version >= 1; + case XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN: + return version >= 1; + case XDG_TOPLEVEL_WM_CAPABILITIES_MINIMIZE: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_TOPLEVEL_WM_CAPABILITIES_ENUM_IS_VALID */ + +/** + * @ingroup iface_xdg_toplevel + * @struct xdg_toplevel_interface + */ +struct xdg_toplevel_interface { + /** + * destroy the xdg_toplevel + * + * This request destroys the role surface and unmaps the surface; + * see "Unmapping" behavior in interface section for details. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * set the parent of this surface + * + * Set the "parent" of this surface. This surface should be + * stacked above the parent surface and all other ancestor + * surfaces. + * + * Parent surfaces should be set on dialogs, toolboxes, or other + * "auxiliary" surfaces, so that the parent is raised when the + * dialog is raised. + * + * Setting a null parent for a child surface unsets its parent. + * Setting a null parent for a surface which currently has no + * parent is a no-op. + * + * Only mapped surfaces can have child surfaces. Setting a parent + * which is not mapped is equivalent to setting a null parent. If a + * surface becomes unmapped, its children's parent is set to the + * parent of the now-unmapped surface. If the now-unmapped surface + * has no parent, its children's parent is unset. If the + * now-unmapped surface becomes mapped again, its parent-child + * relationship is not restored. + * + * The parent toplevel must not be one of the child toplevel's + * descendants, and the parent must be different from the child + * toplevel, otherwise the invalid_parent protocol error is raised. + */ + void (*set_parent)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *parent); + /** + * set surface title + * + * Set a short title for the surface. + * + * This string may be used to identify the surface in a task bar, + * window list, or other user interface elements provided by the + * compositor. + * + * The string must be encoded in UTF-8. + */ + void (*set_title)(struct wl_client *client, + struct wl_resource *resource, + const char *title); + /** + * set application ID + * + * Set an application identifier for the surface. + * + * The app ID identifies the general class of applications to which + * the surface belongs. The compositor can use this to group + * multiple surfaces together, or to determine how to launch a new + * application. + * + * For D-Bus activatable applications, the app ID is used as the + * D-Bus service name. + * + * The compositor shell will try to group application surfaces + * together by their app ID. As a best practice, it is suggested to + * select app ID's that match the basename of the application's + * .desktop file. For example, "org.freedesktop.FooViewer" where + * the .desktop file is "org.freedesktop.FooViewer.desktop". + * + * Like other properties, a set_app_id request can be sent after + * the xdg_toplevel has been mapped to update the property. + * + * See the desktop-entry specification [0] for more details on + * application identifiers and how they relate to well-known D-Bus + * names and .desktop files. + * + * [0] https://standards.freedesktop.org/desktop-entry-spec/ + */ + void (*set_app_id)(struct wl_client *client, + struct wl_resource *resource, + const char *app_id); + /** + * show the window menu + * + * Clients implementing client-side decorations might want to + * show a context menu when right-clicking on the decorations, + * giving the user a menu that they can use to maximize or minimize + * the window. + * + * This request asks the compositor to pop up such a window menu at + * the given position, relative to the local surface coordinates of + * the parent surface. There are no guarantees as to what menu + * items the window menu contains, or even if a window menu will be + * drawn at all. + * + * This request must be used in response to some sort of user + * action like a button press, key press, or touch down event. + * @param seat the wl_seat of the user event + * @param serial the serial of the user event + * @param x the x position to pop up the window menu at + * @param y the y position to pop up the window menu at + */ + void (*show_window_menu)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *seat, + uint32_t serial, + int32_t x, + int32_t y); + /** + * start an interactive move + * + * Start an interactive, user-driven move of the surface. + * + * This request must be used in response to some sort of user + * action like a button press, key press, or touch down event. The + * passed serial is used to determine the type of interactive move + * (touch, pointer, etc). + * + * The server may ignore move requests depending on the state of + * the surface (e.g. fullscreen or maximized), or if the passed + * serial is no longer valid. + * + * If triggered, the surface will lose the focus of the device + * (wl_pointer, wl_touch, etc) used for the move. It is up to the + * compositor to visually indicate that the move is taking place, + * such as updating a pointer cursor, during the move. There is no + * guarantee that the device focus will return when the move is + * completed. + * @param seat the wl_seat of the user event + * @param serial the serial of the user event + */ + void (*move)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *seat, + uint32_t serial); + /** + * start an interactive resize + * + * Start a user-driven, interactive resize of the surface. + * + * This request must be used in response to some sort of user + * action like a button press, key press, or touch down event. The + * passed serial is used to determine the type of interactive + * resize (touch, pointer, etc). + * + * The server may ignore resize requests depending on the state of + * the surface (e.g. fullscreen or maximized). + * + * If triggered, the client will receive configure events with the + * "resize" state enum value and the expected sizes. See the + * "resize" enum value for more details about what is required. The + * client must also acknowledge configure events using + * "ack_configure". After the resize is completed, the client will + * receive another "configure" event without the resize state. + * + * If triggered, the surface also will lose the focus of the device + * (wl_pointer, wl_touch, etc) used for the resize. It is up to the + * compositor to visually indicate that the resize is taking place, + * such as updating a pointer cursor, during the resize. There is + * no guarantee that the device focus will return when the resize + * is completed. + * + * The edges parameter specifies how the surface should be resized, + * and is one of the values of the resize_edge enum. Values not + * matching a variant of the enum will cause the + * invalid_resize_edge protocol error. The compositor may use this + * information to update the surface position for example when + * dragging the top left corner. The compositor may also use this + * information to adapt its behavior, e.g. choose an appropriate + * cursor image. + * @param seat the wl_seat of the user event + * @param serial the serial of the user event + * @param edges which edge or corner is being dragged + */ + void (*resize)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *seat, + uint32_t serial, + uint32_t edges); + /** + * set the maximum size + * + * Set a maximum size for the window. + * + * The client can specify a maximum size so that the compositor + * does not try to configure the window beyond this size. + * + * The width and height arguments are in window geometry + * coordinates. See xdg_surface.set_window_geometry. + * + * Values set in this way are double-buffered, see + * wl_surface.commit. + * + * The compositor can use this information to allow or disallow + * different states like maximize or fullscreen and draw accurate + * animations. + * + * Similarly, a tiling window manager may use this information to + * place and resize client windows in a more effective way. + * + * The client should not rely on the compositor to obey the maximum + * size. The compositor may decide to ignore the values set by the + * client and request a larger size. + * + * If never set, or a value of zero in the request, means that the + * client has no expected maximum size in the given dimension. As a + * result, a client wishing to reset the maximum size to an + * unspecified state can use zero for width and height in the + * request. + * + * Requesting a maximum size to be smaller than the minimum size of + * a surface is illegal and will result in an invalid_size error. + * + * The width and height must be greater than or equal to zero. + * Using strictly negative values for width or height will result + * in a invalid_size error. + */ + void (*set_max_size)(struct wl_client *client, + struct wl_resource *resource, + int32_t width, + int32_t height); + /** + * set the minimum size + * + * Set a minimum size for the window. + * + * The client can specify a minimum size so that the compositor + * does not try to configure the window below this size. + * + * The width and height arguments are in window geometry + * coordinates. See xdg_surface.set_window_geometry. + * + * Values set in this way are double-buffered, see + * wl_surface.commit. + * + * The compositor can use this information to allow or disallow + * different states like maximize or fullscreen and draw accurate + * animations. + * + * Similarly, a tiling window manager may use this information to + * place and resize client windows in a more effective way. + * + * The client should not rely on the compositor to obey the minimum + * size. The compositor may decide to ignore the values set by the + * client and request a smaller size. + * + * If never set, or a value of zero in the request, means that the + * client has no expected minimum size in the given dimension. As a + * result, a client wishing to reset the minimum size to an + * unspecified state can use zero for width and height in the + * request. + * + * Requesting a minimum size to be larger than the maximum size of + * a surface is illegal and will result in an invalid_size error. + * + * The width and height must be greater than or equal to zero. + * Using strictly negative values for width and height will result + * in a invalid_size error. + */ + void (*set_min_size)(struct wl_client *client, + struct wl_resource *resource, + int32_t width, + int32_t height); + /** + * maximize the window + * + * Maximize the surface. + * + * After requesting that the surface should be maximized, the + * compositor will respond by emitting a configure event. Whether + * this configure actually sets the window maximized is subject to + * compositor policies. The client must then update its content, + * drawing in the configured state. The client must also + * acknowledge the configure when committing the new content (see + * ack_configure). + * + * It is up to the compositor to decide how and where to maximize + * the surface, for example which output and what region of the + * screen should be used. + * + * If the surface was already maximized, the compositor will still + * emit a configure event with the "maximized" state. + * + * If the surface is in a fullscreen state, this request has no + * direct effect. It may alter the state the surface is returned to + * when unmaximized unless overridden by the compositor. + */ + void (*set_maximized)(struct wl_client *client, + struct wl_resource *resource); + /** + * unmaximize the window + * + * Unmaximize the surface. + * + * After requesting that the surface should be unmaximized, the + * compositor will respond by emitting a configure event. Whether + * this actually un-maximizes the window is subject to compositor + * policies. If available and applicable, the compositor will + * include the window geometry dimensions the window had prior to + * being maximized in the configure event. The client must then + * update its content, drawing it in the configured state. The + * client must also acknowledge the configure when committing the + * new content (see ack_configure). + * + * It is up to the compositor to position the surface after it was + * unmaximized; usually the position the surface had before + * maximizing, if applicable. + * + * If the surface was already not maximized, the compositor will + * still emit a configure event without the "maximized" state. + * + * If the surface is in a fullscreen state, this request has no + * direct effect. It may alter the state the surface is returned to + * when unmaximized unless overridden by the compositor. + */ + void (*unset_maximized)(struct wl_client *client, + struct wl_resource *resource); + /** + * set the window as fullscreen on an output + * + * Make the surface fullscreen. + * + * After requesting that the surface should be fullscreened, the + * compositor will respond by emitting a configure event. Whether + * the client is actually put into a fullscreen state is subject to + * compositor policies. The client must also acknowledge the + * configure when committing the new content (see ack_configure). + * + * The output passed by the request indicates the client's + * preference as to which display it should be set fullscreen on. + * If this value is NULL, it's up to the compositor to choose which + * display will be used to map this surface. + * + * If the surface doesn't cover the whole output, the compositor + * will position the surface in the center of the output and + * compensate with with border fill covering the rest of the + * output. The content of the border fill is undefined, but should + * be assumed to be in some way that attempts to blend into the + * surrounding area (e.g. solid black). + * + * If the fullscreened surface is not opaque, the compositor must + * make sure that other screen content not part of the same surface + * tree (made up of subsurfaces, popups or similarly coupled + * surfaces) are not visible below the fullscreened surface. + */ + void (*set_fullscreen)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *output); + /** + * unset the window as fullscreen + * + * Make the surface no longer fullscreen. + * + * After requesting that the surface should be unfullscreened, the + * compositor will respond by emitting a configure event. Whether + * this actually removes the fullscreen state of the client is + * subject to compositor policies. + * + * Making a surface unfullscreen sets states for the surface based + * on the following: * the state(s) it may have had before becoming + * fullscreen * any state(s) decided by the compositor * any + * state(s) requested by the client while the surface was + * fullscreen + * + * The compositor may include the previous window geometry + * dimensions in the configure event, if applicable. + * + * The client must also acknowledge the configure when committing + * the new content (see ack_configure). + */ + void (*unset_fullscreen)(struct wl_client *client, + struct wl_resource *resource); + /** + * set the window as minimized + * + * Request that the compositor minimize your surface. There is no + * way to know if the surface is currently minimized, nor is there + * any way to unset minimization on this surface. + * + * If you are looking to throttle redrawing when minimized, please + * instead use the wl_surface.frame event for this, as this will + * also work with live previews on windows in Alt-Tab, Expose or + * similar compositor features. + */ + void (*set_minimized)(struct wl_client *client, + struct wl_resource *resource); +}; + +#define XDG_TOPLEVEL_CONFIGURE 0 +#define XDG_TOPLEVEL_CLOSE 1 +#define XDG_TOPLEVEL_CONFIGURE_BOUNDS 2 +#define XDG_TOPLEVEL_WM_CAPABILITIES 3 + +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_CLOSE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION 4 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_WM_CAPABILITIES_SINCE_VERSION 5 + +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_PARENT_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_TITLE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_APP_ID_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SHOW_WINDOW_MENU_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_MOVE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_RESIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MAX_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MIN_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MAXIMIZED_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_UNSET_MAXIMIZED_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_FULLSCREEN_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_UNSET_FULLSCREEN_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MINIMIZED_SINCE_VERSION 1 + +/** + * @ingroup iface_xdg_toplevel + * Sends an configure event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +xdg_toplevel_send_configure(struct wl_resource *resource_, int32_t width, int32_t height, struct wl_array *states) +{ + wl_resource_post_event(resource_, XDG_TOPLEVEL_CONFIGURE, width, height, states); +} + +/** + * @ingroup iface_xdg_toplevel + * Sends an close event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +xdg_toplevel_send_close(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, XDG_TOPLEVEL_CLOSE); +} + +/** + * @ingroup iface_xdg_toplevel + * Sends an configure_bounds event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +xdg_toplevel_send_configure_bounds(struct wl_resource *resource_, int32_t width, int32_t height) +{ + wl_resource_post_event(resource_, XDG_TOPLEVEL_CONFIGURE_BOUNDS, width, height); +} + +/** + * @ingroup iface_xdg_toplevel + * Sends an wm_capabilities event to the client owning the resource. + * @param resource_ The client's resource + * @param capabilities array of 32-bit capabilities + */ +static inline void +xdg_toplevel_send_wm_capabilities(struct wl_resource *resource_, struct wl_array *capabilities) +{ + wl_resource_post_event(resource_, XDG_TOPLEVEL_WM_CAPABILITIES, capabilities); +} + +#ifndef XDG_POPUP_ERROR_ENUM +#define XDG_POPUP_ERROR_ENUM +enum xdg_popup_error { + /** + * tried to grab after being mapped + */ + XDG_POPUP_ERROR_INVALID_GRAB = 0, +}; +#endif /* XDG_POPUP_ERROR_ENUM */ + +#ifndef XDG_POPUP_ERROR_ENUM_IS_VALID +#define XDG_POPUP_ERROR_ENUM_IS_VALID +/** + * @ingroup iface_xdg_popup + * Validate a xdg_popup error value. + * + * @return true on success, false on error. + * @ref xdg_popup_error + */ +static inline bool +xdg_popup_error_is_valid(uint32_t value, uint32_t version) { + switch (value) { + case XDG_POPUP_ERROR_INVALID_GRAB: + return version >= 1; + default: + return false; + } +} +#endif /* XDG_POPUP_ERROR_ENUM_IS_VALID */ + +/** + * @ingroup iface_xdg_popup + * @struct xdg_popup_interface + */ +struct xdg_popup_interface { + /** + * remove xdg_popup interface + * + * This destroys the popup. Explicitly destroying the xdg_popup + * object will also dismiss the popup, and unmap the surface. + * + * If this xdg_popup is not the "topmost" popup, the + * xdg_wm_base.not_the_topmost_popup protocol error will be sent. + */ + void (*destroy)(struct wl_client *client, + struct wl_resource *resource); + /** + * make the popup take an explicit grab + * + * This request makes the created popup take an explicit grab. An + * explicit grab will be dismissed when the user dismisses the + * popup, or when the client destroys the xdg_popup. This can be + * done by the user clicking outside the surface, using the + * keyboard, or even locking the screen through closing the lid or + * a timeout. + * + * If the compositor denies the grab, the popup will be immediately + * dismissed. + * + * This request must be used in response to some sort of user + * action like a button press, key press, or touch down event. The + * serial number of the event should be passed as 'serial'. + * + * The parent of a grabbing popup must either be an xdg_toplevel + * surface or another xdg_popup with an explicit grab. If the + * parent is another xdg_popup it means that the popups are nested, + * with this popup now being the topmost popup. + * + * Nested popups must be destroyed in the reverse order they were + * created in, e.g. the only popup you are allowed to destroy at + * all times is the topmost one. + * + * When compositors choose to dismiss a popup, they may dismiss + * every nested grabbing popup as well. When a compositor dismisses + * popups, it will follow the same dismissing order as required + * from the client. + * + * If the topmost grabbing popup is destroyed, the grab will be + * returned to the parent of the popup, if that parent previously + * had an explicit grab. + * + * If the parent is a grabbing popup which has already been + * dismissed, this popup will be immediately dismissed. If the + * parent is a popup that did not take an explicit grab, an error + * will be raised. + * + * During a popup grab, the client owning the grab will receive + * pointer and touch events for all their surfaces as normal + * (similar to an "owner-events" grab in X11 parlance), while the + * top most grabbing popup will always have keyboard focus. + * @param seat the wl_seat of the user event + * @param serial the serial of the user event + */ + void (*grab)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *seat, + uint32_t serial); + /** + * recalculate the popup's location + * + * Reposition an already-mapped popup. The popup will be placed + * given the details in the passed xdg_positioner object, and a + * xdg_popup.repositioned followed by xdg_popup.configure and + * xdg_surface.configure will be emitted in response. Any + * parameters set by the previous positioner will be discarded. + * + * The passed token will be sent in the corresponding + * xdg_popup.repositioned event. The new popup position will not + * take effect until the corresponding configure event is + * acknowledged by the client. See xdg_popup.repositioned for + * details. The token itself is opaque, and has no other special + * meaning. + * + * If multiple reposition requests are sent, the compositor may + * skip all but the last one. + * + * If the popup is repositioned in response to a configure event + * for its parent, the client should send an + * xdg_positioner.set_parent_configure and possibly an + * xdg_positioner.set_parent_size request to allow the compositor + * to properly constrain the popup. + * + * If the popup is repositioned together with a parent that is + * being resized, but not in response to a configure event, the + * client should send an xdg_positioner.set_parent_size request. + * @param token reposition request token + * @since 3 + */ + void (*reposition)(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *positioner, + uint32_t token); +}; + +#define XDG_POPUP_CONFIGURE 0 +#define XDG_POPUP_POPUP_DONE 1 +#define XDG_POPUP_REPOSITIONED 2 + +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_REPOSITIONED_SINCE_VERSION 3 + +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_GRAB_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_REPOSITION_SINCE_VERSION 3 + +/** + * @ingroup iface_xdg_popup + * Sends an configure event to the client owning the resource. + * @param resource_ The client's resource + * @param x x position relative to parent surface window geometry + * @param y y position relative to parent surface window geometry + * @param width window geometry width + * @param height window geometry height + */ +static inline void +xdg_popup_send_configure(struct wl_resource *resource_, int32_t x, int32_t y, int32_t width, int32_t height) +{ + wl_resource_post_event(resource_, XDG_POPUP_CONFIGURE, x, y, width, height); +} + +/** + * @ingroup iface_xdg_popup + * Sends an popup_done event to the client owning the resource. + * @param resource_ The client's resource + */ +static inline void +xdg_popup_send_popup_done(struct wl_resource *resource_) +{ + wl_resource_post_event(resource_, XDG_POPUP_POPUP_DONE); +} + +/** + * @ingroup iface_xdg_popup + * Sends an repositioned event to the client owning the resource. + * @param resource_ The client's resource + * @param token reposition request token + */ +static inline void +xdg_popup_send_repositioned(struct wl_resource *resource_, uint32_t token) +{ + wl_resource_post_event(resource_, XDG_POPUP_REPOSITIONED, token); +} + +#ifdef __cplusplus +} +#endif + +#endif