From 6dbcb7eda9b3d287a04296e445282614a387a47a Mon Sep 17 00:00:00 2001 From: project-repo Date: Sun, 8 Jan 2023 22:09:15 +0100 Subject: [PATCH] Release 2.0.0 This is a major release and includes BREAKING changes! Breaking Changes: * More intuitive switch of focus, next, prev and exchange (#20, 40 in Bugs.md) Cagebreak will probably still feel broadly the same though. * Remove -r flag - This is replaced by output configuration. * Socket disabled by default - The socket is enabled by invoking Cagebreak with the -e flag. * Socket permissions restricted to the user of the Cagebreak process (700) This may require modification of scripts interacting with the socket with different UIDs than the UID of the Cagebreak process. * Rename "Current frame" indicator to "Current tile" Changelog: * Move to wlr_scene * Add events displaying change over the socket * this enables scripting tools * Add support for scaling outputs (thanks to Oliver Friedmann) * Remove -r flag * Add rotation to output configuration * Add cursor enable|disable flag * Add input keyboard configuration * Custom path flag for configuration file * Restrict socket permissions to the user running cagebreak (700) * Fix Issue #31 (resolve some terminology) 38 in Bugs.md * Fix Issue #30 - 39 in Bugs.md * Fix Issue #20 - 40 in Bugs.md * Fix Issue #12 - 41 in Bugs.md (dump + events over socket) * Fix Bugs found via scan-build static analysis (42 - 45 in Bugs.md) * Fix Issue #33 - 46 in Bugs.md * Fix Issue #32 - 47 in Bugs.md * Fix Issue #16 - 48 in Bugs.md * Fix Issue #3 - 49 in Bugs.md (disabling keybinding interpretation for specific keyboards is now possible) * Fix Issue #26 - 50 in Bugs.md * Fix Issue #7 - 51 in Bugs.md (Change cursor to square while Cagebreak is waiting for a key) * Fix config bug for some commands - 52 in Bugs.md * Fix Issue #35 - 53 in Bugs.md (update to wlroots 0.16.1) * Improve FAQ.md (related to some Issues) * Disable outputs when unable to set any mode (crashed previously) * Add Code of Conduct * Print version number on startup --- Bugs.md | 462 +++++++++++- CODE_OF_CONDUCT.md | 15 + Changelog.md | 42 ++ FAQ.md | 60 ++ Hashes.md | 20 + README.md | 586 ++++++++++----- SECURITY.md | 62 +- cagebreak.c | 332 ++++++--- config.h.in | 5 + example_scripts/cb_script_header.sh | 18 + example_scripts/focus_follows_cursor.sh | 23 + example_scripts/show_workspace_views.sh | 25 + examples/config | 6 + fuzz/execl_override.c | 6 +- fuzz/fuzz-lib.c | 278 +++---- fuzz/fuzz-lib.h | 9 +- fuzz/fuzz-parse.c | 18 +- fuzz/meson.build | 5 +- idle_inhibit_v1.c | 10 +- idle_inhibit_v1.h | 2 + input.h | 6 +- input_manager.c | 303 ++++++-- input_manager.h | 22 +- ipc_server.c | 177 ++++- ipc_server.h | 6 + keybinding.c | 934 ++++++++++++++++++++---- keybinding.h | 130 ++-- libinput.c | 207 ++---- man/cagebreak-config.5.md | 63 +- man/cagebreak-socket.7.md | 606 +++++++++++++++ man/cagebreak.1.md | 14 +- meson.build | 68 +- meson_options.txt | 2 + message.c | 132 +++- message.h | 8 +- output.c | 914 ++++++++++------------- output.h | 33 +- pango.c | 3 + pango.h | 3 + parse.c | 201 +++-- parse.h | 5 +- render.c | 274 ------- render.h | 9 - seat.c | 440 ++++++----- seat.h | 11 +- server.c | 4 +- server.h | 18 +- signatures/1.9.1-cagebreak-config.sig | Bin 0 -> 566 bytes signatures/1.9.1-cagebreak.1.sig | Bin 0 -> 566 bytes signatures/1.9.1-cagebreak.sig | Bin 0 -> 566 bytes signatures/cagebreak-config.5.sig | Bin 566 -> 566 bytes signatures/cagebreak-socket.7.sig | Bin 0 -> 566 bytes signatures/cagebreak.1.sig | Bin 566 -> 566 bytes signatures/cagebreak.sig | Bin 566 -> 566 bytes util.c | 11 +- util.h | 3 + view.c | 265 ++----- view.h | 65 +- workspace.c | 74 +- workspace.h | 13 +- xdg_shell.c | 327 ++++----- xdg_shell.h | 15 +- xwayland.c | 105 +-- xwayland.h | 4 +- 64 files changed, 4813 insertions(+), 2646 deletions(-) create mode 100644 CODE_OF_CONDUCT.md create mode 100644 example_scripts/cb_script_header.sh create mode 100644 example_scripts/focus_follows_cursor.sh create mode 100644 example_scripts/show_workspace_views.sh create mode 100644 man/cagebreak-socket.7.md delete mode 100644 render.c delete mode 100644 render.h create mode 100644 signatures/1.9.1-cagebreak-config.sig create mode 100644 signatures/1.9.1-cagebreak.1.sig create mode 100644 signatures/1.9.1-cagebreak.sig create mode 100644 signatures/cagebreak-socket.7.sig diff --git a/Bugs.md b/Bugs.md index 822f3f6..25eeeca 100644 --- a/Bugs.md +++ b/Bugs.md @@ -591,7 +591,6 @@ without xwayland has been added to the release checklist. * github issue number: #23 * Fixed: 1.9.0 -``` Similar to djpohly/dwl#177. Xwayland works fine elsewhere: cage, hikari, kwinft, labwc, phoc, river, sway, wayfire. ``` $ cagebreak @@ -618,7 +617,6 @@ wayland-protocols-1.25 xwayland-devel-21.0.99.1.171 wlroots-0.15.1 ``` -``` ## Issue 34 @@ -652,3 +650,463 @@ This issue was not present in earlier releases. Cagebreak 1.9.0 broke the screen/movetoscreen functionality. This issue was not present in earlier releases. +## Issue 38 + + * github issue number: #31 + * Fixed: 2.0.0 + +Cagebreak terminology was unclear up to and including 1.9.1. + +The following are extracts from the github issue discussion: + +kinleyd: +``` +This isn't an issue per se, but concerns cagebreak terminology. +I won't try to cover the entire range of terms used but stick +to the ones that concern me at the moment: + +OK, so I get the use of the terms 'output', 'workspace' and 'tile'. + +So my question: In cagebreak, what exactly is a 'screen'? At the +moment, the use of nextscreen, prevscreen, movetoscreen, +movetonextscreen, movetoprevscreen all seem to suggest that +'screen' is the same as 'output'. If so, shouldn't all the +aforementioned commands have screen replaced with output? +eg. nextoutput, prevoutput, etc. +``` + +project-repo +``` +You make an interesting point. + +We have considered this and the tricky bit is that both output and *screen are +defined cagebreak commands. It would be difficult to merge these two +commands in a reasonable way (even with the freedom of breaking changes). + +Additionally, there is a sort of informal symmetry between output and input +we would like to maintain. + +Our current conclusion is that we will leave the commands unmodified. +The now ex-post defined distinction between output and *screen is that +the *screen stuff works with the natural number uniquely identifying the +output within a given cagebreak session (but not across sessions, "nextscreen" +and "prevscreen" do so internally by in-/decrementing this number), whereas +output always deals with an output name as does input with an input name. + +Please feel free to point out any other inconsistencies in cagebreak or better +solutions than outlined above in this issue. + +You can post your suggestions here. + +We will close this issue once 2.0.0 is released where the points mentioned above +will be outlined in the documentation. Please leave it open in +the mean time. Afterwards, you may open a new issue. + +cheers +project-repo +``` + +kinleyd: +``` +> Our current conclusion is that we will leave the commands unmodified. +> The now ex-post defined distinction between output and *screen is +> that the *screen stuff works with the natural number uniquely +> identifying the output within a given cagebreak session (but not +> across sessions, "nextscreen" and "prevscreen" do so internally +> by in-/decrementing this number), whereas output always deals +> with an output name as does input with an input name. + +That makes perfect sense. Additionally, I also realize that there +is the virtual display for which the concept of 'screen' as +distinct from 'output' is necessary as a screen could then be +a fraction of an output, or combine multiple outputs. + +> We will close this issue once 2.0.0 is released where the points +> mentioned above will be outlined in the documentation. Please +> leave it open in the mean time. Afterwards, you may open a new issue. + +Hey, I look forward to version 2.0.0! +``` + +project-repo: +``` +We have now modified the cagebreak-config man page on the development +branch to clarify the relationship of output and the screen family of +commands. + +Please let us know if anything can be improved in that regard. + +cheers +project-repo +``` + +## Issue 39 + + * github issue number: #30 + * Fixed: 2.0.0 + +Cagebreak 1.9.1 had an issue where clicks did not evoke +any response under some very specific circumstances. + +This was remediated by switching Cagebreak to `wlr_scene`. + +There was extensive discussion inside the github issue +but this is omitted here due to irrelevance. + +## Issue 40 + + * github issue number: #20 + * Fixed: 2.0.0 + +nor-0 proposed a more intuitive way to switch focus. This +is a breaking change and as such is introduced on a major +release. + +Details are described in the github issue discussion, which +is reproduced here: + +nor-0: +``` +Hello, + +I think switching focus is a bit confusing in some situations. +When focus is switched in a direction, it can end up diagonally +instead of the frame next to the previously focused one. +The minimal example for this is with four frames, but it +also applies in layouts with more than four of them. + +Let´s say I press the keybindings for these actions: +`vsplit`, `hsplit`, `focusright`, `hsplit`. +This leaves me with a layout of four simple quarters: + +> +-----+-----+ +> | 1 | 2 | +> +-----+-----+ +> | 3 | 4 | +> +-----+-----+ + +Now, using `focuslefton` frame 2 brings me to frame 3 instead +of one. Likewise, `focusright` on frame 3 brings me to frame +2 instead of frame 4. + +As soon as I resize a width, switching works as expected and +desired. The oddness however reappears whenever the vertical +frame edges are realigned. + +The same trouble happens when creating the layout with the +keybindings for `hsplit`, `vsplit`, `focusdown`, `vsplit`. +Now, focusing up from frame 3 brings me two frame 2 instead +of 1, and same with the symmetrical opposite again +(2 downwards is 3 instead of 4). Now resizing heights is what +helps until the horizontal edges are realigned. + +As said before, similar things occur with more complex layouts. +I use those much less frequently of course, but intuitive +navigation is even more important then. In these two minimal +examples, reaching the frames 1 and 4 is also often more +tedious then necessary. + +I understand this is due to the way the frames were created +and makes some sense in this regard. However, unless there +is some reason to keep this behavior (which disappears by +some resize options anyways), I´d suggest to change it to +be more intuitive. + +I imagine an approach for this could be to determine the +frames center point and then looking for an adjacent frame +in horizontal (vertical) direction from there when +`focusright` or `focusleft` (`focusdown` or `focusup`) is used. + +(Everything said about `focus[direction]` also applies to +`exchange[direction]`.) +``` + +project-repo: +``` +Thanks for the suggestion! Yes, I agree that the current implementation +is not a very satisfying solution... The reason it is handled like this +is simply because it was easiest to implement. Fortunately however, +changing this should not require too much coding since the +determination of the tile to jump to is handled globally by a single +function for each direction. + +I like your idea with considering the center of the frame and then +looking for the one adjacent to it which is at the height of the center, +since such a frame is always guaranteed to exist (unless we are at the +edge of the screen in which case there is nothing to jump to). +Of course, this would have to involve some kind of tie-breaking when +two adjacent frames share a border at the height of the center (which is +bound to occur often if you never resize the tiles). I'm currently +leaning towards simply taking the top/left one in this case (or some +similar scheme) but if anyone else has thoughts on this, we'd be glad to +hear! + +Some notes: + + * This would be a breaking change, so the version number would jump to 2.0.0. + * Also, due to limited developer capacity at the moment and + the ongoing porting of cagebreak to the wlr_scene API it may be a + while until we are able to implement this, so bear with us! + +cheers +project-repo +``` + +project-repo: +``` +We pushed some code to development implementing this in `ed5cca9`. +Sorry for not writing this much sooner. + +To anyone who reads this: This feature will remain on the development +branch for some time, partially due to some unresolved xwayland and +wlr_scene bugs and partially to allow breaking changes. So if anyone +would like to see something changed, please feel free to let us know! + +cheers +project-repo +``` + +## Issue 41 + + * github issue number: #12 + * Fixed: 2.0.0 + +kinleyd raised the issue of changing the focussed screen +on mouse hover. The Cagebreak philosophy is completely +keyboard-oriented and this feature request was denied. +However, this line of inquiry led to the idea of implementing +an ipc socket which would report key events and an information +dump functionality which would enable almost arbitrary scripting. + +Related Material: +- [cagebreak-config man page](man/cagebreak-config.md) +- [cagebreak-socket man page](man/cagebreak-socket.md) +- [scripting examples](https://github.com/project-repo/cagebreak/tree/development/example_scripts) + +The github issue discussion is partially reproduced below: + +kinleyd: +``` +While fully recognizing - and appreciating - Cagebreak's keyboard orientation, would it be possible to accommodate support for screen change on mouse over? This would help avoid a series of key presses on multi-screen setups and improve overall ergonomics. + +Thanks. +``` + +project-repo: +``` +As you correctly recognised, cagebreak is designed to be completely +keyboard-oriented. However, I understand that for the multi-monitor +setup you describe it may be useful to have some kind of +mouse-compositor interaction. To accommodate this, we are considering +implementing a command which allows to obtain the current cagebreak +state from the ipc socket, including the current cursor position. +That way, by implementing a script which listens for cursor events +and acts accordingly, it should be possible to implement the behaviour +you describe externally (provided #11 is implemented as intended). +What do you think? + +If you have any other ideas, don't hesitate to let us know! + +cheers +project-repo +``` + +project-repo +``` +There has been much talk about #12 and how it would improve all sorts of +use cases, once implemented. While much remains to be determined, we would +like to give an update. + +First, #12 is secondary in priority to #11, which is presumably easier +to implement and much clearer in its scope. + +Once implemented, cagebreak will communicate the state of at least the +following internal properties: + + * [ ] Current cursor position (allowing setting of the current screen + as per navigating screens question and suggestion #11 + * [ ] IDs for graphical programs along with position on screen + * [ ] IDs for tiles on particular screens + * [ ] Currently focussed tile, screen, etc. + * [ ] Events such as "new window", "screen split", etc. + +In which format this information will be provided is yet to be +determined, but we are considering at least the following: + + * full blob of data upon request via ipc socket + * partial information on events + +To improve user experience, the release of #12 will include examples of +how to use the new API over the socket for real world use cases, +analogous to the current example config. + + * [ ] Example script "Current screen follows cursor on click" + * [ ] Example script "Setup multi screen environment with graphical programs on + specific tiles" + +Note that this is just the current state of planning, +the final properties of cagebreak are specified in the man pages upon +release and cagebreak is provided as is, as specified in the LICENSE. + +cheers +project-repo +``` + +project-repo: +``` +Some but not all features mentioned in our previous comment have now been implemented on +the development branch. + +Information on current events is provided through the ipc socket +now. The types of events which are reported are still subject to change and the +feature is not yet documented but you may check it out nonetheless. Let +us know if there is any additional information you would like to obtain +for the different events. + +Current format displayed on the socket is as follows: + +'cg-ipc<4 bytes denoting message length>(:,:,...,:)' + +Consider it a proof of concept. + +A full dump of the current cagebreak state is not yet possible. + +Happy new year to you too! +cheers +project-repo +``` + +project-repo: +``` +We pushed some code to development implementing the dump +functionality. This should contain the information you require since it +gives you the view currently focussed by the pointer from which you can +deduce the output the cursor is currently hovering over by looking up +the output on which the view is placed. Note that this only works when +the cursor is actually hovering over a view (i.e. not when it is on an +empty tile). Alternatively, you could read the cursor coordinates and +compare these with the coordinates of the different outputs, though atm +the coordinates of the outputs are not dumped (we aim to add this later). + +To anyone who reads this: This feature will remain on the development +branch for some time, partially due to some unresolved xwayland and +wlr_scene bugs and partially to allow breaking changes +(removing/changing data outputted by dump and other information sent by +IPC). So if anyone would like to see something changed, please feel free +to let us know (either by posting here or opening a new issue)! + +cheers +project-repo +``` + +## Issue 42 + + * github issue number: N/A + * Fixed: 2.0.0 + +When Cagebreak exited due to an error on startup, it was possible for +memory leaks to occur since `server.modes` was not freed correctly. The +same applies to the variable `name` in `input_manager.c`. + +This bug was found using the scan-build utility. + +## Issue 43 + + * github issue number: N/A + * Fixed: 2.0.0 + +In `keybinding_move_view_to_cycle_output`, it was previously possible for a +null pointer dereference to occur, when no view to be moved was focussed. + +This bug was found using the scan-build utility. + +## Issue 44 + + * github issue number: N/A + * Fixed: 2.0.0 + +`cg_input_reset_libinput_device` was removed as it was unused code. + +This bug was found using the scan-build utility. + +## Issue 45 + + * github issue number: N/A + * Fixed: 2.0.0 + +Various memory leaks in `parse_message_config`, `full_screen_workspace` +and `server_show_info` were fixed. + +This bug was found using the scan-build utility. + +## Issue 46 + + * github issue number: #33 + * Fixed: 2.0.0 + +Cagebrak did not state in its FAQ how to use letters not found +on the current keyboards alphabet. + +## Issue 47 + + * github issue number: #32 + * Fixed: 2.0.0 + +Cagebreak did not state in its FAQ how programs can be launched. + +## Issue 48 + + * github issue number: #16 + * Fixed: 2.0.0 + +Cagebreak cursor sizes varied under some environmental circumstances. +Investigations showed that the cursor is set by the respective application +but environment variables are usually respected. This is now documented in +the FAQ. + +## Issue 49 + + * github issue number: #3 + * Fixed: 2.0.0 + +Cagebreak used to have no way to disable the interpretation of keybindings +for a specific keyboard, which was cumbersome for some applications. This +feature is now available + +## Issue 50 + + * github issue number: #26 + * Fixed: 2.0.0 + +Cagebreak used to have no way to hide the cursor. This is now possible. + +## Issue 51 + + * github issue number: #7 + * Fixed: 2.0.0 + +Cagebreak used to not change the cursor while waiting for a key. The cursor +is now a square in this state. + +## Issue 52 + + * github issue number: N/A + * Fixed: 2.0.0 + +Cagebreak did not correctly apply some simple commands if they were simply +written in the configuration file. + +Consider the example config file: + +``` +quit +``` + +Under these circumstances Cagebreak did not quit right after startup. + +## Issue 53 + + * github issue number: #35 + * Fixed: 2.0.0 + +Cagebreak did not build with wlroots 0.16.1 and this was adjusted. diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..f094d9a --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,15 @@ +# Code of Conduct + +As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, and other activities. + +We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion. + +Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct. + +Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team. + +This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. + +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting project-repo (See [SECURITY.md](SECURITY.md) for an e-mail contact.). + +This Code of Conduct is adapted from Curl, available at https://curl.se/docs/code-of-conduct.html and transitively the Contributor Covenant, version 1.1.0, available at https://contributor-covenant.org/version/1/1/0/ diff --git a/Changelog.md b/Changelog.md index ff24285..e469a6c 100644 --- a/Changelog.md +++ b/Changelog.md @@ -64,3 +64,45 @@ Adds libinput configuration and virtual keyboard and pointer support. - Add new cagebreak email contact gpg key - Add new project-repo AUR gpg key (relevant for cagebreak-pkgbuild) +## Release 2.0.0 + +This is a major release and includes BREAKING changes! + +Breaking Changes: + * More intuitive switch of focus, next, prev and exchange (#20, 40 in Bugs.md) + Cagebreak will probably still feel broadly the same though. + * Remove -r flag - This is replaced by output configuration. + * Socket disabled by default - The socket is enabled by invoking Cagebreak with the -e flag. + * Socket permissions restricted to the user of the Cagebreak process (700) + This may require modification of scripts interacting with the socket with + different UIDs than the UID of the Cagebreak process. + * Rename "Current frame" indicator to "Current tile" + +Changelog: + * Move to wlr_scene + * Add events displaying change over the socket + * this enables scripting tools + * Add support for scaling outputs (thanks to Oliver Friedmann) + * Remove -r flag + * Add rotation to output configuration + * Add cursor enable|disable flag + * Add input keyboard configuration + * Custom path flag for configuration file + * Restrict socket permissions to the user running cagebreak (700) + * Fix Issue #31 (resolve some terminology) 38 in Bugs.md + * Fix Issue #30 - 39 in Bugs.md + * Fix Issue #20 - 40 in Bugs.md + * Fix Issue #12 - 41 in Bugs.md (dump + events over socket) + * Fix Bugs found via scan-build static analysis (42 - 45 in Bugs.md) + * Fix Issue #33 - 46 in Bugs.md + * Fix Issue #32 - 47 in Bugs.md + * Fix Issue #16 - 48 in Bugs.md + * Fix Issue #3 - 49 in Bugs.md (disabling keybinding interpretation for specific keyboards is now possible) + * Fix Issue #26 - 50 in Bugs.md + * Fix Issue #7 - 51 in Bugs.md (Change cursor to square while Cagebreak is waiting for a key) + * Fix config bug for some commands - 52 in Bugs.md + * Fix Issue #35 - 53 in Bugs.md (update to wlroots 0.16.1) + * Improve FAQ.md (related to some Issues) + * Disable outputs when unable to set any mode (crashed previously) + * Add Code of Conduct + * Print version number on startup diff --git a/FAQ.md b/FAQ.md index 1077a69..d8918a0 100644 --- a/FAQ.md +++ b/FAQ.md @@ -5,6 +5,7 @@ * Check the man pages * [cagebreak config](man/cagebreak-config.5.md) (probably where you find the answer) * [cagebreak](man/cagebreak.1.md) (command line options etc.) + * [cagebreak-socket](man/cagebreak-socket.7.md) (socket information, mostly useful for scritping) * Check the rest of this FAQ * [Open an issue](https://github.com/project-repo/cagebreak/issues/new) or otherwise get in touch with the development team (See section Email Contact in [SECURITY.md](SECURITY.md)). @@ -25,6 +26,65 @@ Set the following environment variables to activate wayland support for firefox. +## How do I map characters which are not on the Keyboard? + +Suppose you want to use a command like `bind` for a character +which is likely not on your keyboard like "ы" - you should write +it as "Cyrillic_yeru". + +These names can be obtained by running xev and pressing the respective +key(s) (combinations). + +## How do I change the size of the cursor? + +The size and shape of the cursor is determined by the application, however, +most applications respect the environment variables `XCURSOR_SIZE` and +`XCURSOR_THEME` + +To change the cursor size, one could use: + +``` +export XCURSOR_SIZE=1 +``` + +If you are using an application which inherits its environment variables +from something outside the scope of the export (such as a daemon for +emacs might), you can usually specify your environment variables in +the applications respective configuration. + +## How is Cagebreak launched? + +The documentation says to start Cagebreak like any other binary. + +If you want to start Cagebreak on login, you can use your shells +equivalent of a `.bash_profile`. In BASH appending cagebreak +(given that it is installed in the path) to `.bash_profile` +is fine. + +If you want to start Cagebreak using systemd you could use a +service started on user login, though the development team once ran +into some issues with permissions for the services. + +Please note that Cagebreak does not solve the problem of +locking the screen or login in general. + +## How are applications launched in Cagebreak? + +There are multiple ways to launch external programs in cagebreak. + + * Using a terminal emulator is a perfectly valid way to launch + applications. If you want to be able to close the terminal + you used to start the program, you may use `&disown`, which should + be available in every shell. + * Using the `exec` command in the cagebreak config, it is possible to + launch programs when cagebreak is started. Moreover, as this command + can be combined with commands such as `bind`, it can be used to + create custom keybindings which execute external programs. (See also + the man page `cagebreak-config`). + * All commands mentioned previously are also available over the socket + which allows the creation of (arbitrary) keybindings on the fly and + a fortiori keybindings running arbitrary commands. + ## Which further resources are available? * [Arch Linux Wiki entry for Cagebreak](https://wiki.archlinux.org/title/Cagebreak) diff --git a/Hashes.md b/Hashes.md index 97d6217..627d428 100644 --- a/Hashes.md +++ b/Hashes.md @@ -1,5 +1,25 @@ # Hashes +2.0.0 cagebreak + + * sha 256: 45f88abdae03bbc7dad5734dd6fb1a00e1bf37d3e0c4016dad2fa3de832335cf + * sha 512: dc261a788ea1843e701f4fb6985200c4813113fda0f911bee4e3cc9b20fd082055e40e9fc60647128674a94ece75f4aa55d1faede8e94e6e1940b02d8a6de8e0 + +2.0.0 cagebreak.1 + + * sha 256: 0d96947c2054fb42b284b31cc4ea793944a4562509f5f00b7927d11d0046041d + * sha 512: 4f3eadc88680d994f9ebcf85be38626b7e95971bc3233d710613cee58496553e0bb1e65258956f8a50c633bdd4dbc5c0283826fd5b661e9de0092366cc47caae + +2.0.0 cagebreak-config.5 + + * sha 256: 4ee6ed443ce93cd6af3df49fe5e32244baeca04ca167993fb3d71970bf20939d + * sha 512: d6bf8f73ed8c9084b784653e88e1f149fbab35997f412f6c505972d3299a47bec1238aecd4334dd597bb32e46ced93f36d488badd25c6a8d61bdb73f3aea87ab + +2.0.0 cagebreak-socket.7 + + * sha 256: 682b3cc46ad059147b7d7ab814ac1831689511e31c0d6f2b91732e85244da99e + * sha 512: 92057e4cbbcec4f4dbd98f3a99cb4c450ef31aef557705e5f8f2927b53653149b232771b455f9b9ae8435a7351667a4e663b7d120b76a0bbb5c7ba04db551489 + 1.9.1 cagebreak * sha 256: 262c67170eb2a39174d40f97d940707029dca0b2b613b514a1cca29152a12665 diff --git a/README.md b/README.md index 3da2c16..1dba0b5 100644 --- a/README.md +++ b/README.md @@ -1,29 +1,81 @@ -# Cagebreak: A Wayland Tiling Compositor Inspired by Ratpoison +# Cagebreak: A Wayland Tiling Compositor -This is Cagebreak, a Wayland tiling compositor. +[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/6532/badge)](https://bestpractices.coreinfrastructure.org/projects/6532) [![Packaging status](https://repology.org/badge/tiny-repos/cagebreak.svg)](https://repology.org/project/cagebreak/versions) [![AUR package](https://repology.org/badge/version-for-repo/aur/cagebreak.svg?minversion=2.0.0)](https://repology.org/project/cagebreak/versions) -The goal of this project is to provide a successor to ratpoison for Wayland -users. However, this is no reimplementation of ratpoison. +## Quick Introduction -Should you like to know if a feature will be implemented, open an issue -or get in touch with the development team. +Cagebreak is a [Wayland](https://wayland.freedesktop.org/) tiling compositor +based on [Cage](https://github.com/Hjdskes/cage) and inspired by [ratpoison](https://www.nongnu.org/ratpoison/). -For documentation of Cagebreak, please see - * the man pages +### Purpose + +The goal of this project is to provide a successor to ratpoison for Wayland. +However, this is no reimplementation of ratpoison. + +#### New Features, Bugs and Contact Information + +Should you want to know if a feature will be implemented, file a bug or +get in touch, [open an issue](https://github.com/project-repo/cagebreak/issues/new) +or write an e-mail (See [SECURITY.md](SECURITY.md) for details.). + +The Roadmap section outlines what is planned for the future. + +#### Compatibility & Development Distribution + +Cagebreak supports [Arch Linux](https://archlinux.org/) and uses the libraries +(and software versions) as they are obtained through [pacman](https://wiki.archlinux.org/title/Pacman) +at the time of release. Any other use is out of scope. + +Most other setups probably work with a bit of luck. We +make no guarantees. + +### Quick Installation + +This assumes Arch Linux: + +1. Use the [cagebreak PKGBUILD](https://aur.archlinux.org/packages/cagebreak). +2. Add an example config such as [config](examples/config) to `$USER/.config/cagebreak/config` +3. Execute cagebreak like any other binary. + +See the [ArchWiki](https://wiki.archlinux.org/title/Cagebreak#Getting_started) for +details on getting started and the documentation for everything else. + +### Documentation + + * the rest of this file + * the man pages: * [cagebreak](man/cagebreak.1.md) * [configuration](man/cagebreak-config.5.md) - * also the [FAQ](FAQ.md) + * [socket](man/cagebreak-socket.7.md) + * the [FAQ](FAQ.md) + * [SECURITY.md](SECURITY.md) + +#### What's new? + +See the [Changelog](Changelog.md). + +### Uninstallation + +`pacman -R cagebreak` should be sufficient. + +### Contributing + + * Just [open an issue](https://github.com/project-repo/cagebreak/issues/new) and state your idea. + We will consider the proposal and get back to you. + * Don't open a pull request. We might not accept your code and + it would be sad to waste the effort. + * Respect the [Code of Conduct](CODE_OF_CONDUCT.md) (To date, we never + had to intervene - Keep it that way!) + +### Name Cagebreak is based on [Cage](https://github.com/Hjdskes/cage), a Wayland kiosk -compositor. - -Cagebreak is developed under Arch Linux and uses the libraries -as they are obtained through pacman. However, cagebreak should also work on -other distributions given the proper library versions. +compositor. Since it breaks the kiosk into tiles the name +Cagebreak seemed appropriate. ## Installation -If you are using archlinux, just use the PKGBUILDs from the aur: +On Arch Linux, just use the PKGBUILDs from the [AUR](https://aur.archlinux.org/): * Using [cagebreak](https://aur.archlinux.org/packages/cagebreak), Cagebreak is compiled on the target system (since release 1.3.0) @@ -37,17 +89,17 @@ See [cagebreak-pkgbuild](https://github.com/project-repo/cagebreak-pkgbuild) for There are different ways to obtain cagebreak source: - * git clone (for all releases) - * download release asset tarballs (starting at release 1.2.1) + * [git clone](https://github.com/project-repo/cagebreak) (for all releases) + * [download release asset tarballs](https://github.com/project-repo/cagebreak/releases) (starting at release 1.2.1) -### Verifying Source Code +#### Verifying Source Code There are corresponding methods of verifying that you obtained the correct code: * our git history includes signed tags for releases * release assets starting at release 1.2.1 contain a signature for the tarball -### Building Cagebreak +## Building Cagebreak You can build Cagebreak with the [meson](https://mesonbuild.com/) build system. It requires wayland, wlroots and xkbcommon to be installed. Note that Cagebreak is @@ -57,14 +109,14 @@ breaking changes as soon as they occur. Simply execute the following steps to build Cagebreak: ``` -$ meson build +$ meson setup build $ ninja -C build ``` #### Release Build By default, this builds a debug build. To build a release build, use `meson -build --buildtype=release`. +setup build --buildtype=release`. ##### Xwayland Support @@ -84,178 +136,129 @@ installed. Then, add `-Dman-pages=true` to the `meson` command. You can start Cagebreak by running `./build/cagebreak`. If you run it from within an existing X11 or Wayland session, it will open in a virtual output as a window in your existing session. If you run it in a TTY, it'll run with the -KMS+DRM backend. For more configuration options, see the man pages. +KMS+DRM backend. Note that a configuration file is required. For more +configuration options, see the man pages. -## Contributing to Cagebreak +Please see `example_scripts/` for example scripts and a basis to customize +from. -Cagebreak is currently developed to fit the needs of its creators. Should you -desire to implement a feature, please let us know in advance by opening -an issue. However, the feature set is intentionally limited (i.e. we removed -support for a desktop background) and will continue to be so in the future. +#### Usage Philosophy -Nonetheless, don't be intimidated by the (slightly lengthy) release checklist -or any other part of this file. Do what you can, open an issue and we will -collaborate toward a solution. +Cagebreak was originally built to suit the needs of its creators. This section outlines +how we intended some parts of cagebreak and might ease learning how to use cagebreak a +little bit. Please note that this does not replace the man pages or the FAQ. +Also, this is in no way intended as a guide on how cagebreak must be used but rather +as a source of inspiration and of explanations for why certain particularities. -### Branching Strategy and Versioning +1. Cagebreak is keyboard-based. Everything regarding cagebreak can be done + through the keyboard and it is our view that it should be. This does not mean + that pointers, touchpads and such are not available for the few applications + that do require them. -There exists a branch `development` to which all reasonable code -is comitted for final testing. +2. Cagebreak is a tiling compositor. Every view takes up as much screen space + as possible. We believe this is useful, as only very few programs are typically + necessary to complete a task. To manage multiple tasks concurrently, we use + workspaces. -Once `development` is ready for a release, it is merged into `master` (possibly via -a cherry-picked branch), creating a new release, which is tagged and signed. +3. Each task deserves its own workspace. Any given task (the sort of thing you + might find in your calendar or on your todo list) probably requires very few + views and ideally, these take up as much of the screen as possible. -All releases are tagged according to [semantic versioning](https://semver.org) guidelines. +> Combining 2. and 3. might look like this in practice: -In the past, our git history did not perfectly reflect this scheme. +> * Task 1: Edit introduction section for paper on X +> * Task 2: Coordinate event with person Y -### Releases +> * split screen vertically +> * open web browser or pdf viewer to read literature +> * focus next +> * open editor +> * change to a different workspace +> * split screen vertically +> * open calendar application +> * focus next +> * open chat application -The release checklist must be completely fulfilled in one run for a release to -occur. +> Now each task has its own workspace and switching between tasks is possible +> by switching between workspaces. - * [ ] `git checkout development` - * [ ] `git pull origin development` - * [ ] `git push origin development` - * [ ] `ninja -C build clang-format` makes no changes - * [ ] New version number determined according to [semantic versioning](https://semver.org) guidelines - * [ ] Relevant Documentation completed - * [ ] New features - * [ ] man pages - * [ ] man/cagebreak - * [ ] man/cagebreak-config - * [ ] Set EPOCH to release day in man generation in meson.build - * [ ] FAQ.md - * [ ] Changelog.md for major and minor releases but not patches - * [ ] Check features for SECURITY.md relevance (changes to socket scope - for example) - * [ ] Fixed bugs documented in Bugs.md - * [ ] Include issue description from github - * [ ] Testing - * [ ] Manual testing - * [ ] Libfuzzer testing - * [ ] Build version without xwayland support - * [ ] Version Number - * [ ] meson.build - * [ ] git tag - * [ ] man pages - * [ ] meson.build reproducible build versions are current archlinux libraries and gcc - * [ ] Cagebreak is reproducible on multiple machines - * [ ] Documented reproducible build artefacts - * [ ] Hashes of the artefacts in README.md - * [ ] Renamed previous signatures - * [ ] Created gpg signature of the artefacts - * [ ] `gpg --detach-sign -u keyid cagebreak` - * [ ] `gpg --detach-sign -u keyid cagebreak.1` - * [ ] `gpg --detach-sign -u keyid cagebreak-config.5` - * [ ] `git add` relevant files - * [ ] `git commit` - * [ ] `git push origin development` - * [ ] Determined commit and tag message (Start with "Release version_number\n\n") - * [ ] Mentioned fixed Bugs.md issues ("Fixed Issue n") - * [ ] Mentioned other important changes - * [ ] `git checkout master` - * [ ] `git merge --squash development` - * [ ] `git commit` and insert message - * [ ] `git tag -u keyid version HEAD` and insert message - * [ ] `git tag -v version` and check output - * [ ] `git push --tags origin master` - * [ ] `git checkout development` - * [ ] `git merge master` - * [ ] `git push --tags origin development` - * [ ] `git archive --prefix=cagebreak/ -o release_version.tar.gz tags/version .` - * [ ] Create release-artefacts_version.tar.gz - * [ ] `mkdir release-artefacts_version` - * [ ] `cp build/cagebreak release-artefacts_version/` - * [ ] `cp build/cagebreak.sig release-artefacts_version/` - * [ ] `cp build/cagebreak.1 release-artefacts_version/` - * [ ] `cp build/cagebreak.1.sig release-artefacts_version/` - * [ ] `cp build/cagebreak-config.5 release-artefacts_version/` - * [ ] `cp build/cagebreak-config.5.sig release-artefacts_version/` - * [ ] `cp LICENSE release-artefacts_version/` - * [ ] `cp README.md release-artefacts_version/` - * [ ] `cp SECURITY.md release-artefacts_version/` - * [ ] `cp FAQ.md release-artefacts_version/` - * [ ] `export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct) ; tar --sort=name --mtime= --owner=0 --group=0 --numeric-owner -czf release-artefacts_version.tar.gz release-artefacts_version` - * [ ] Checked archive - * [ ] tar -xvf release_version.tar.gz - * [ ] cd cagebreak - * [ ] meson build --buildtype=release - * [ ] ninja -C build - * [ ] gpg --verify ../signatures/cagebreak.sig build/cagebreak - * [ ] cd .. - * [ ] rm -rf cagebreak - * [ ] `gpg --detach-sign -u keyid release_version.tar.gz` - * [ ] `gpg --detach-sign -u keyid release-artefacts_version.tar.gz` - * [ ] Upload archives and signatures as release assets +> Note that, for example by using the socket, more advanced setups are +> possible. But the user is warned that excessive tweaking eats into the work +> to be done. -### Reproducible Builds +4. Use keybindings and terminal emulators for the right purpose. Given the + philosophy outlined above you probably launch the same few programs very + often and others are very rarely used. We believe that commonly + used programs should have their own keybindings together with the most + important cagebreak commands. All the rarely used programs should be launched + from a terminal emulator as they probably require special flags, environment + variables and file paths anyway. -Cagebreak offers reproducible builds given the exact library versions specified -in `meson.build`. Should a version mismatch occur, a warning will be emitted. We have -decided on this compromise to allow flexibility and security. In general we will -adapt the versions to the packages available under Arch Linux at the time of -release. +> In practice this means thinking about the applications and cagebreak commands +> you use and taking your keyboard layout into account when defining keybindings for +> your individual needs. -There are reproducibility issues up to and including release `1.2.0`. See -`Issue 5` in [Bugs.md](Bugs.md). +5. Cagebreak can't do everything, but with scripting you can do most things. + Through the socket and with a bit of scripting, you can use the internal state + of cagebreak in combination with cagebreak commands and the full power of + a scripting language of your choice to do almost whatever you want. -#### Reproducible Build Instructions +> Example scripts can be found in the repository under `example_scripts/`. -All hashes and signatures are provided for the following build instructions. +## Contributing -``` -meson build -Dxwayland=true -Dman-pages=true --buildtype=release -ninja -C build -``` + * Read this document. + * Just [open an issue](https://github.com/project-repo/cagebreak/issues/new) and state your feature request. + We will consider the proposal and get back to you. + * Don't open a pull request without asking first. We might not accept your + code and it would be sad to waste the effort. + * Respect the [Code of Conduct](CODE_OF_CONDUCT.md) (To date, we never + had to intervene - Please keep it that way!) -#### Hashes for Builds +### Good First Contributions -For every release after 1.0.5, hashes will be provided. + * Reviewing the project is always welcome. + * Read the code. + * Read the documentation. + * Test whether the documentation matches the code. + * Test Cagebreak in more esoteric setups (many monitors, for instance). + * Compile the code. + * Ideas on improving the testing and quality assurance are particularly + welcome. + * If you want, you can share your cagebreak scripts and we might include them + in the repository provided you agree to release them under MIT and we agree + with the use case and coding style. + * Iff you are happy with Cagebreak and use Arch Linux, you may vote for + [Cagebreak in the AUR](https://aur.archlinux.org/packages/cagebreak). + * The points above still apply. -For every release after 1.7.0, hashes will be provided for man pages too. +### Philosophy -See [Hashes.md](Hashes.md) +Cagebreak is currently developed to fit the needs of its creators. -#### GPG Signatures +The feature set is intentionally limited - we removed +support for a desktop background image for example. -For every release after 1.0.5, a GPG signature will be provided in `signatures`. +Nonetheless, don't be intimidated by any other part of this file. +Do your best and we will collaborate toward a solution. -The current signature is called `cagebreak.sig`, whereas all older signatures -will be named after their release version. +## Development -Due to errors in the release process, the releases 1.7.1 and 1.7.2 did not include the release -signatures in the appropriate folder of the git repository. However, signatures were provided -as release-artefacts at the time of release. The signatures were introduced into the -repository with 1.7.3. The integrity of cagebreak is still the same because the signatures were -provided as release-artefacts (which were themselves signed) and the hashes in README.md -are part of a signed release tag. +### Compatibility & Development Distribution -#### Signing Keys +Cagebreak supports [Arch Linux](https://archlinux.org/) and uses the libraries +(and software versions) as they are obtained through [pacman](https://wiki.archlinux.org/title/Pacman) +at the time of release. Any other use is out of scope. -All releases are signed by at least one of the following collection of -keys. +However, Cagebreak may also work on other distributions given the +proper library versions (Some package maintainers have done this and it +seems to work (To date, we dealt with a few Issues and never felt the +need to ask for the distribution the user was having the issue on.)). - * E79F6D9E113529F4B1FFE4D5C4F974D70CEC2C5B - * 4739D329C9187A1C2795C20A02ABFDEC3A40545F - * 7535AB89220A5C15A728B75F74104CC7DCA5D7A8 - * 827BC2320D535AEAD0540E6E2E66F65D99761A6F - * A88D7431E5BAAD0B6EAE550AC8D61D8BD4FA3C46 - * 8F872885968EB8C589A32E9539ACC012896D450F - * 896B92AF738C974E0065BF42F2576BD366156BB9 - * AA927AFD50AF7C6810E69FE8274F2C605359E31B - * BE2DED372287BC4EB2213E13A0C743848A638955 - * 0F3476E4B2404F95EC41600683D5810F7911B020 +[![Packaging status](https://repology.org/badge/vertical-allrepos/cagebreak.svg)](https://repology.org/project/cagebreak/versions) -Should we at any point retire a key, we will only replace it with keys signed -by at least one of the above collection. - -We registered project-repo.co and added mail addresses after release `1.3.0`. - -We now have a mail address and its key is signed by signing keys. See Security -Bugs for details. - -The full public keys can be found in `keys/` along with any revocation certificates. +You should use Arch Linux if you want to modify Cagebreak +for yourself. ### GCC and -fanalyzer @@ -298,7 +301,7 @@ Here is an example workflow: ``` rm -rf build -CC=clang meson build -Dfuzz=true -Db_sanitize=address,undefined -Db_lundef=false +CC=clang meson setup build -Dfuzz=true -Db_sanitize=address,undefined -Db_lundef=false ninja -C build/ mkdir build/fuzz_corpus cp examples/config build/fuzz_corpus/ @@ -316,35 +319,254 @@ Currently, there are memory leaks which do not seem to stem from our code but ra the code of wl-roots or some other library we depend on. We are working on the problem. In the meantime, add `-Db_detect-leaks=0` to the meson command to exclude memory leaks. +### Reproducible Builds + +Cagebreak offers reproducible builds given the exact library versions specified +in `meson.build`. Should a version mismatch occur, a warning will be emitted. We have +decided on this compromise to allow flexibility and security. In general we will +adapt the versions to the packages available under Arch Linux at the time of +release. + +There are reproducibility issues up to and including release `1.2.0`. See +`Issue 5` in [Bugs.md](Bugs.md). + +#### Reproducible Build Instructions + +All hashes and signatures are provided for the following build instructions. + +``` +meson setup build -Dxwayland=true -Dman-pages=true --buildtype=release +ninja -C build +``` + +#### Hashes for Builds + +For every release after 1.0.5, hashes will be provided. + +For every release after 1.7.0, hashes will be provided for man pages too. + +See [Hashes.md](Hashes.md) + +#### GPG Signatures + +For every release after 1.0.5, a GPG signature will be provided in `signatures`. + +The current signature is called `cagebreak.sig`, whereas all older signatures +will be named after their release version. + +Due to errors in the release process, the releases 1.7.1 and 1.7.2 did not include the release +signatures in the appropriate folder of the git repository. However, signatures were provided +as release-artefacts at the time of release. The signatures were introduced into the +repository with 1.7.3. The integrity of cagebreak is still the same because the signatures were +provided as release-artefacts (which were themselves signed) and the hashes in Hashes.md +are part of a signed release tag. + +#### Signing Keys + +All releases are signed by at least one of the following collection of +keys. + + * E79F6D9E113529F4B1FFE4D5C4F974D70CEC2C5B + * 4739D329C9187A1C2795C20A02ABFDEC3A40545F + * 7535AB89220A5C15A728B75F74104CC7DCA5D7A8 + * 827BC2320D535AEAD0540E6E2E66F65D99761A6F + * A88D7431E5BAAD0B6EAE550AC8D61D8BD4FA3C46 + * 8F872885968EB8C589A32E9539ACC012896D450F + * 896B92AF738C974E0065BF42F2576BD366156BB9 + * AA927AFD50AF7C6810E69FE8274F2C605359E31B + * BE2DED372287BC4EB2213E13A0C743848A638955 + * 0F3476E4B2404F95EC41600683D5810F7911B020 + +Should we at any point retire a key, we will only replace it with keys signed +by at least one of the above collection. + +We registered project-repo.co and added mail addresses after release `1.3.0`. + +We now have a mail address and its key is signed by signing keys. See Security +Bugs for details. + +The full public keys can be found in `keys/` along with any revocation certificates. + +### Versioning & Branching Strategy + +Cagebreak uses [semantic versioning](https://semver.org). + +There are three permanent branches in cagebreak: + + * `master` (for releases) + * `development` (for polishing code between releases) + * `hotfix` (for small emergent releases, usually up-to-date with master) + +Releases are merged to master as per the release procedure, with +reasonable exceptions as the situation requires. + +The release commit is tagged with the release version. + +In the past, our git history did not perfectly reflect this scheme. + +### Release Procedure + +The release procedure outlines the process for a release to occur. + + * [ ] `git checkout development` + * [ ] `git pull origin development` + * [ ] `git push origin development` + * [ ] New semantic version number determined + * [ ] Adjust version number + * [ ] meson.build + * [ ] git tag + * [ ] man pages + * [ ] README.md repology badges minversion + * [ ] Relevant Documentation completed + * [ ] New features + * [ ] man pages + * [ ] cagebreak + * [ ] cagebreak-config + * [ ] cagebreak-socket + * [ ] example config + * [ ] Set EPOCH to release day in man generation in meson.build + * [ ] FAQ.md + * [ ] Changelog.md for major and minor releases but not patches + * [ ] Check features for SECURITY.md relevance (changes to socket scope + for example) + * [ ] Synchronize any socket changes to cagebreak-socket man page + * [ ] Fixed bugs documented in Bugs.md + * [ ] Include issue discussion from github, where applicable + * [ ] Testing + * [ ] Manual testing + * [ ] Libfuzzer testing + * [ ] Build version without xwayland support + * [ ] meson.build reproducible build versions are current archlinux libraries and gcc + * [ ] wlr_xdg_shell version check + * [ ] `ninja -C build clang-format` makes no changes + * [ ] `ninja -C build scan-build` shows no issues + * [ ] Cagebreak is reproducible on multiple machines + * [ ] Documented reproducible build artefacts + * [ ] Hashes of the artefacts in Hashes.md + * [ ] Renamed previous signatures + * [ ] Created gpg signature of the artefacts + * [ ] `gpg --detach-sign -u keyid cagebreak` + * [ ] `gpg --detach-sign -u keyid cagebreak.1` + * [ ] `gpg --detach-sign -u keyid cagebreak-config.5` + * [ ] `gpg --detach-sign -u keyid cagebreak-socket.7` + * [ ] `git add` relevant files + * [ ] `git commit` + * [ ] `git push origin development` + * [ ] Determined commit and tag message (Start with "Release version_number\n\n") + * [ ] Mentioned fixed Bugs.md issues ("Fixed Issue n") + * [ ] Mentioned other important changes + * [ ] `git checkout master` + * [ ] `git merge --squash development` + * [ ] `git commit` and insert message + * [ ] `git tag -u keyid version HEAD` and insert message + * [ ] `git tag -v version` and check output + * [ ] `git push --tags origin master` + * [ ] `git checkout development` (merge to development depends on whether release was a hotfix) + * [ ] `git merge master` + * [ ] `git push --tags origin development` + * [ ] `git checkout hotfix` (hotfix is to be kept current with master after releases) + * [ ] `git merge master` + * [ ] `git push --tags origin hotfix` + * [ ] `git archive --prefix=cagebreak/ -o release_version.tar.gz tags/version .` + * [ ] Create release-artefacts_version.tar.gz + * [ ] `mkdir release-artefacts_version` + * [ ] `cp build/cagebreak release-artefacts_version/` + * [ ] `cp build/cagebreak.sig release-artefacts_version/` + * [ ] `cp build/cagebreak.1 release-artefacts_version/` + * [ ] `cp build/cagebreak.1.sig release-artefacts_version/` + * [ ] `cp build/cagebreak-config.5 release-artefacts_version/` + * [ ] `cp build/cagebreak-config.5.sig release-artefacts_version/` + * [ ] `cp build/cagebreak-socket.7 release-artefacts_version/` + * [ ] `cp build/cagebreak-socket.7.sig release-artefacts_version/` + * [ ] `cp LICENSE release-artefacts_version/` + * [ ] `cp README.md release-artefacts_version/` + * [ ] `cp SECURITY.md release-artefacts_version/` + * [ ] `cp FAQ.md release-artefacts_version/` + * [ ] `export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct) ; tar --sort=name --mtime= --owner=0 --group=0 --numeric-owner -czf release-artefacts_version.tar.gz release-artefacts_version` + * [ ] Checked archive + * [ ] tar -xvf release_version.tar.gz + * [ ] cd cagebreak + * [ ] meson setup build -Dxwayland=true -Dman-pages=true --buildtype=release + * [ ] ninja -C build + * [ ] gpg --verify ../signatures/cagebreak.sig build/cagebreak + * [ ] cd .. + * [ ] rm -rf cagebreak + * [ ] `gpg --detach-sign -u keyid release_version.tar.gz` + * [ ] `gpg --detach-sign -u keyid release-artefacts_version.tar.gz` + * [ ] Upload archives and signatures as release assets + +## Roadmap + +Cagebreak plans to do or keep doing the following things +in the future: + + * React to all issues. + * Add or modify features, which the authors find convenient or important. + * Improve the [OpenSSF Best Practices Badge Program](https://bestpractices.coreinfrastructure.org/en) level + +## Governance + +Cagebreak is managed by project-repo. + +Project-repo is a pseudonym of at least two individuals acting +as benevolent dictators for the project by the others mutual consent. + +The individuals comprising project-repo are not otherwise associated +by payment from any organisation or grant. + +For all intents and purposes consider project-repo as a single +benevolent dictator for life that happens to occupy at least two brains. + +### Roles + +There are members of project-repo and those who are not. + +There are no specific roles forced unto anyone. + +### Bus Factor + +The Bus Factor is a measure of how many people have to be +incapacitated for a project to be unable to continue. + +The current bus factor for Cagebreak is: 1 + +Project-repo could still react to issues (even confidential +e-mails) and fix easier issues if any one individual were +incapacitated. + +However, not all aspects of the code or release engineering +are fully resilient to the loss of any one individual. + +We strive to improve the Bus Factor to at least two in all +aspects of Cagebreak. + +### Governance Issues + +Anyone can use the information in [SECURITY.md](SECURITY.md) to +contact the members of project-repo and bring governance +issues to their attention. + ## Bugs -For any bug, please [create an -issue](https://github.com/project-repo/cagebreak/issues/new) on -[GitHub](https://github.com/project-rep/cagebreak). +For any bug, please [create an issue](https://github.com/project-repo/cagebreak/issues/new) on +[GitHub](https://github.com/project-repo/cagebreak). Fixed bugs are to be assigned a number and summarized inside Bugs.md for future reference independent of github, in case this service is unavailable. -Mail contact: `cagebreak @ project-repo . co` - -GPG Fingerprints: - - * B15B92642760E11FE002DE168708D42451A94AB5 - * F8DD9F8DD12B85A28F5827C4678E34D2E753AA3C - * 3ACEA46CCECD59E4C8222F791CBEB493681E8693 - -See [SECURITY.md](SECURITY.md) for details. - -## Changelog - -See [Changelog.md](Changelog.md) +For other means of contacting the Cagebreak authors and for security issues +see [SECURITY.md](SECURITY.md). ## Contributors * Aisha Tammy * [make man pages optional](https://github.com/project-repo/cagebreak/pull/4), released in 1.6.0 with slight modifications + * Oliver Friedmann + * [Add output scaling](https://github.com/project-repo/cagebreak/pull/34), released + in 2.0.0 with slight modifications ## License -Please see [LICENSE](https://github.com/project-repo/cagebreak/blob/master/LICENSE) +MIT, please see [LICENSE](https://github.com/project-repo/cagebreak/blob/master/LICENSE). + diff --git a/SECURITY.md b/SECURITY.md index 5f8ee2c..bd7c388 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -1,10 +1,13 @@ # Security -The main possibility for security bugs to occur in cagebreak is by privilege -escalation using the socket. Indeed, any program with access to the socket -immediately gains arbitrary code execution rights. As of right now, the socket -is world-writable. If you disagree with this threat model, you may contact -us via email (See section Email Contact below.) or [open an issue on github](https://github.com/project-repo/cagebreak/issues/new). +The main possibility for security bugs in cagebreak is by privilege +escalation through the socket. Any program with access to the socket +immediately gains arbitrary code execution rights. The socket +is restricted to the user of the cagebreak process (700) and has to +be explicitely enabled using the `-e` flag on invocation. + +If you disagree with this threat model, you may contact us via email (See +section Email Contact below.) or [open an issue on github](https://github.com/project-repo/cagebreak/issues/new). Should any problem with the github issue system arise or any other reason for (potentially confidential) contact with the Cagebreak authors appear, @@ -12,9 +15,9 @@ you may contact us via email (See section Email Contact below.). ## Supported Versions -The latest release always contains the latest bug fixes and features. -There are no official backports for security vulnerabilities. Builds -are reproducible under conditions outlined in [README.md](README.md). +The most recent release always contains the latest bug fixes and features. +There are no official backports for security vulnerabilities. +Builds are reproducible under conditions outlined in [README.md](README.md). ## Bug Reports @@ -25,20 +28,20 @@ is available below. ## Email Contact -Should you want to get in touch with the developers of cagebreak to report +If you want to get in touch with the developers of cagebreak to report a security vulnerability or anything else via email, contact `cagebreak @ project-repo . co`. -We will try to respond to everything that is not obvious spam. +We try to respond to everything that is not obvious spam. ### GPG-Encrypted Emails If you can, please encrypt your email with the appropriate GPG key found in `keys/` and sign your message with your own key. - * B15B92642760E11FE002DE168708D42451A94AB5 - * F8DD9F8DD12B85A28F5827C4678E34D2E753AA3C - * 3ACEA46CCECD59E4C8222F791CBEB493681E8693 +* B15B92642760E11FE002DE168708D42451A94AB5 +* F8DD9F8DD12B85A28F5827C4678E34D2E753AA3C +* 3ACEA46CCECD59E4C8222F791CBEB493681E8693 Note that our keys are signed by cagebreak signing keys. @@ -47,21 +50,23 @@ public key or provide the fingerprint and directions to obtain the key. ## Threat Model -Cagebreak is a wayland compositor, which is run by the user of the system +Cagebreak is a wayland compositor run by the user of the system and thus has access to whichever resources this user has access to. Cagebreak can restrict other programs in no way, because this would hamper usability (consider a web browser unable to write a downloaded file to disk -for instance). There is no transmission of information by cagebreak other -than to the screens, ipc and potentially other documented local channels. +for instance). + +There is no transmission of information by cagebreak other than to the +screens, ipc and potentially other documented local channels. ### STRIDE Threat List This is not a thorough analysis, just an overview of the ways in which cagebreak -has/does not have an attack surface. +has (no) attack surface. #### Spoofing -Not applicable - Using cagebreak already requires a login as a user. +Not applicable - Using Cagebreak already requires a login as a user. #### Tampering @@ -72,7 +77,7 @@ Not applicable - Cagebreak must allow system manipulation for user software. Not applicable - There are no prohibited operations (See Tampering above.). While cagebreak does send events over documented channels there is no logging activated by default, though, of course, this can be changed by the user -by logging socket output for example. +by logging socket output (if enabled) for example. #### Information Disclosure @@ -82,10 +87,25 @@ and any software run by the user may exfiltrate any data the user has access to. #### Denial of Service Not applicable - Cagebreak offers functionality to terminate itself, which is -available to all user software over the socket. +available to all user software over the socket if the socket is enabled. -#### Elevation of privilege +#### Elevation of Privilege Software may gain arbitrary code execution rights if it has access to the Cagebreak socket. Privilege escalation to root is unlikely since privileges are dropped before any user input is accepted. + +## GPG Keys of the Cagebreak Repository + +All Cagebreak project keys are found under keys/ in the cagebreak +repository (the public keys anyway). + +The most trusted keys of the Cagebreak project are its signing keys, +all signing keys are signed by at least one of its predecessors and at +least one non-expired signing key is used at the time of release to +sign the commit tag and the release code tarball. + +Signing keys are also used to lend credence to other keys in the Cagebreak +project, such as the keys for email correspondence and the key used in the +cagebreak-pkgbuild repository. + diff --git a/cagebreak.c b/cagebreak.c index 97f4f91..0c5c247 100644 --- a/cagebreak.c +++ b/cagebreak.c @@ -1,12 +1,8 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200812L +#define _DEFAULT_SOURCE #include "config.h" @@ -16,8 +12,10 @@ #include #include #include +#include #include #include +#include #include #include #include @@ -31,16 +29,19 @@ #include #include #include +#include +#include +#include #include #include -#if CG_HAS_XWAYLAND -#include -#endif +#include +#include #include #include #include #include #if CG_HAS_XWAYLAND +#include #include #endif @@ -53,6 +54,7 @@ #include "parse.h" #include "seat.h" #include "server.h" +#include "workspace.h" #include "xdg_shell.h" #if CG_HAS_XWAYLAND #include "xwayland.h" @@ -123,37 +125,21 @@ usage(FILE *file, const char *const cage) { fprintf(file, "Usage: %s [OPTIONS]\n" "\n" - " -r\t Rotate the output 90 degrees clockwise, specify up to three " - "times\n" -#ifdef DEBUG - " -D\t Turn on damage tracking debugging\n" -#endif - " -h\t Display this help message\n" - " -v\t Show the version number and exit\n" - " -s\t Show information about the current setup and exit\n", + " -c \t Load configuration file from \n" + " -e\t\t Enable socket\n" + " -h\t\t Display this help message\n" + " -s\t\t Show information about the current setup and exit\n" + " -v\t\t Show the version number and exit\n", cage); } static bool -parse_args(struct cg_server *server, int argc, char *argv[]) { +parse_args(struct cg_server *server, int argc, char *argv[], + char **config_path) { int c; -#ifdef DEBUG - while((c = getopt(argc, argv, "rDhvs")) != -1) { -#else - while((c = getopt(argc, argv, "rhvs")) != -1) { -#endif + server->enable_socket = false; + while((c = getopt(argc, argv, "c:hvse")) != -1) { switch(c) { - case 'r': - server->output_transform++; - if(server->output_transform > WL_OUTPUT_TRANSFORM_270) { - server->output_transform = WL_OUTPUT_TRANSFORM_NORMAL; - } - break; -#ifdef DEBUG - case 'D': - server->debug_damage_tracking = true; - break; -#endif case 'h': usage(stdout, argv[0]); return false; @@ -163,6 +149,15 @@ parse_args(struct cg_server *server, int argc, char *argv[]) { case 's': show_info = true; break; + case 'c': + if(optarg != NULL) { + *config_path = strdup(optarg); + optarg = NULL; + } + break; + case 'e': + server->enable_socket = true; + break; default: usage(stderr, argv[0]); return false; @@ -187,9 +182,28 @@ set_configuration(struct cg_server *server, config_file_path); return 1; } - char line[MAX_LINE_SIZE * sizeof(char)]; - for(unsigned int line_num = 1; - fgets(line, MAX_LINE_SIZE, config_file) != NULL; ++line_num) { + uint32_t line_length = 64; + char *line = calloc(line_length, sizeof(char)); + for(unsigned int line_num = 1;; ++line_num) { + while(true) { + if(fgets(line + strlen(line), line_length - strlen(line), + config_file) == NULL) { + break; + } + if(strcspn(line, "\n") != line_length - 1) { + break; + } + line_length *= 2; + line = reallocarray(line, line_length, sizeof(char)); + if(line == NULL) { + wlr_log(WLR_ERROR, "Could not allocate buffer for reading " + "configuration file."); + return 1; + } + } + if(strlen(line) == 0) { + break; + } line[strcspn(line, "\n")] = '\0'; if(*line != '\0' && *line != '#') { char *errstr; @@ -200,16 +214,22 @@ set_configuration(struct cg_server *server, if(errstr != NULL) { free(errstr); } + free(line); return -1; } } + memset(line, 0, line_length * sizeof(char)); } + free(line); fclose(config_file); return 0; } char * -get_config_file() { +get_config_file(char *udef_path) { + if(udef_path != NULL) { + return strdup(udef_path); + } const char *config_home_path = getenv("XDG_CONFIG_HOME"); char *addition = "/cagebreak/config"; if(config_home_path == NULL || config_home_path[0] == '\0') { @@ -236,25 +256,30 @@ main(int argc, char *argv[]) { struct wl_event_source *sigint_source = NULL; struct wl_event_source *sigterm_source = NULL; struct wl_event_source *sigalrm_source = NULL; + struct wl_event_source *sigpipe_source = NULL; struct wlr_backend *backend = NULL; struct wlr_compositor *compositor = NULL; + struct wlr_subcompositor *subcompositor = NULL; struct wlr_data_device_manager *data_device_manager = NULL; struct wlr_server_decoration_manager *server_decoration_manager = NULL; struct wlr_xdg_decoration_manager_v1 *xdg_decoration_manager = NULL; struct wlr_export_dmabuf_manager_v1 *export_dmabuf_manager = NULL; struct wlr_screencopy_manager_v1 *screencopy_manager = NULL; struct wlr_data_control_manager_v1 *data_control_manager = NULL; + struct wlr_viewporter *viewporter = NULL; + struct wlr_presentation *presentation = NULL; struct wlr_xdg_output_manager_v1 *output_manager = NULL; struct wlr_gamma_control_manager_v1 *gamma_control_manager = NULL; struct wlr_xdg_shell *xdg_shell = NULL; -#if CG_HAS_XWAYLAND - struct wlr_xwayland *xwayland = NULL; - struct wlr_xcursor_manager *xcursor_manager = NULL; -#endif + wl_list_init(&server.input_config); + wl_list_init(&server.output_config); + wl_list_init(&server.output_priorities); + int ret = 0; - if(!parse_args(&server, argc, argv)) { - return 1; + char *config_path = NULL; + if(!parse_args(&server, argc, argv, &config_path)) { + goto end; } #ifdef DEBUG @@ -263,25 +288,34 @@ main(int argc, char *argv[]) { wlr_log_init(WLR_ERROR, NULL); #endif - wl_list_init(&server.input_config); - wl_list_init(&server.output_config); - server.modes = malloc(4 * sizeof(char *)); if(!server.modes) { wlr_log(WLR_ERROR, "Error allocating mode array"); - return -1; + goto end; } /* Wayland requires XDG_RUNTIME_DIR to be set. */ if(!getenv("XDG_RUNTIME_DIR")) { - wlr_log(WLR_ERROR, "XDG_RUNTIME_DIR is not set in the environment"); - return 1; + wlr_log(WLR_INFO, "XDG_RUNTIME_DIR is not set in the environment"); } server.wl_display = wl_display_create(); if(!server.wl_display) { wlr_log(WLR_ERROR, "Cannot allocate a Wayland display"); - return 1; + free(server.modes); + server.modes = NULL; + goto end; + } + + server.xcursor_size = XCURSOR_SIZE; + const char *env_cursor_size = getenv("XCURSOR_SIZE"); + if(env_cursor_size && strlen(env_cursor_size) > 0) { + errno = 0; + char *end; + unsigned size = strtoul(env_cursor_size, &end, 10); + if(!*end && errno == 0) { + server.xcursor_size = size; + } } server.running = true; @@ -293,10 +327,12 @@ main(int argc, char *argv[]) { if(server.modes[0] == NULL || server.modes[1] == NULL || server.modes[2] == NULL) { wlr_log(WLR_ERROR, "Error allocating default modes"); - return 1; + goto end; } server.nws = 1; + server.views_curr_id = 1; + server.tiles_curr_id = 1; server.message_config.fg_color[0] = 0.0; server.message_config.fg_color[1] = 0.0; server.message_config.fg_color[2] = 0.0; @@ -317,6 +353,8 @@ main(int argc, char *argv[]) { wl_event_loop_add_signal(event_loop, SIGTERM, handle_signal, &server); sigalrm_source = wl_event_loop_add_signal(event_loop, SIGALRM, handle_signal, &server); + sigpipe_source = + wl_event_loop_add_signal(event_loop, SIGPIPE, handle_signal, &server); server.event_loop = event_loop; backend = wlr_backend_autocreate(server.wl_display); @@ -345,6 +383,7 @@ main(int argc, char *argv[]) { ret = 1; goto end; } + server.allocator = wlr_allocator_autocreate(server.backend, server.renderer); if(!server.allocator) { @@ -352,6 +391,7 @@ main(int argc, char *argv[]) { ret = 1; goto end; } + wlr_renderer_init_wl_display(server.renderer, server.wl_display); server.bg_color = (float[4]){0, 0, 0, 1}; @@ -365,6 +405,20 @@ main(int argc, char *argv[]) { goto end; } + if(ipc_init(&server) != 0) { + wlr_log(WLR_ERROR, "Failed to initialize IPC"); + ret = 1; + goto end; + } + + server.scene = wlr_scene_create(); + if(!server.scene) { + wlr_log(WLR_ERROR, "Unable to create scene"); + ret = 1; + goto end; + } + wlr_scene_attach_output_layout(server.scene, server.output_layout); + compositor = wlr_compositor_create(server.wl_display, server.renderer); if(!compositor) { wlr_log(WLR_ERROR, "Unable to create the wlroots compositor"); @@ -372,6 +426,13 @@ main(int argc, char *argv[]) { goto end; } + subcompositor = wlr_subcompositor_create(server.wl_display); + if(!subcompositor) { + wlr_log(WLR_ERROR, "Unable to create the wlroots subcompositor"); + ret = 1; + goto end; + } + data_device_manager = wlr_data_device_manager_create(server.wl_display); if(!data_device_manager) { wlr_log(WLR_ERROR, "Unable to create the data device manager"); @@ -420,7 +481,7 @@ main(int argc, char *argv[]) { &server.new_idle_inhibitor_v1); wl_list_init(&server.inhibitors); - xdg_shell = wlr_xdg_shell_create(server.wl_display); + xdg_shell = wlr_xdg_shell_create(server.wl_display, 3); if(!xdg_shell) { wlr_log(WLR_ERROR, "Unable to create the XDG shell interface"); ret = 1; @@ -451,6 +512,21 @@ main(int argc, char *argv[]) { wlr_server_decoration_manager_set_default_mode( server_decoration_manager, WLR_SERVER_DECORATION_MANAGER_MODE_SERVER); + viewporter = wlr_viewporter_create(server.wl_display); + if(!viewporter) { + wlr_log(WLR_ERROR, "Unable to create the viewporter interface"); + ret = 1; + goto end; + } + + presentation = wlr_presentation_create(server.wl_display, server.backend); + if(!presentation) { + wlr_log(WLR_ERROR, "Unable to create the presentation interface"); + ret = 1; + goto end; + } + wlr_scene_set_presentation(server.scene, presentation); + export_dmabuf_manager = wlr_export_dmabuf_manager_v1_create(server.wl_display); if(!export_dmabuf_manager) { @@ -474,6 +550,13 @@ main(int argc, char *argv[]) { goto end; } + if(!wlr_primary_selection_v1_device_manager_create(server.wl_display)) { + wlr_log(WLR_ERROR, + "Unable to create the primary selection device manager"); + ret = 1; + goto end; + } + gamma_control_manager = wlr_gamma_control_manager_v1_create(server.wl_display); if(!gamma_control_manager) { @@ -483,40 +566,32 @@ main(int argc, char *argv[]) { } #if CG_HAS_XWAYLAND - xwayland = wlr_xwayland_create(server.wl_display, compositor, true); - if(!xwayland) { + server.xwayland = wlr_xwayland_create(server.wl_display, compositor, true); + if(!server.xwayland) { wlr_log(WLR_ERROR, "Cannot create XWayland server"); ret = 1; goto end; } server.new_xwayland_surface.notify = handle_xwayland_surface_new; - wl_signal_add(&xwayland->events.new_surface, &server.new_xwayland_surface); + wl_signal_add(&server.xwayland->events.new_surface, + &server.new_xwayland_surface); - xcursor_manager = wlr_xcursor_manager_create(DEFAULT_XCURSOR, XCURSOR_SIZE); - if(!xcursor_manager) { - wlr_log(WLR_ERROR, "Cannot create XWayland XCursor manager"); - ret = 1; - goto end; - } - - if(setenv("DISPLAY", xwayland->display_name, true) < 0) { + if(setenv("DISPLAY", server.xwayland->display_name, true) < 0) { wlr_log_errno(WLR_ERROR, "Unable to set DISPLAY for XWayland.", "Clients may not be able to connect"); } else { wlr_log(WLR_DEBUG, "XWayland is running on display %s", - xwayland->display_name); + server.xwayland->display_name); } - if(!wlr_xcursor_manager_load(xcursor_manager, 1)) { - wlr_log(WLR_ERROR, "Cannot load XWayland XCursor theme"); - } - struct wlr_xcursor *xcursor = - wlr_xcursor_manager_get_xcursor(xcursor_manager, DEFAULT_XCURSOR, 1); + struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor( + server.seat->xcursor_manager, DEFAULT_XCURSOR, 1); + if(xcursor) { struct wlr_xcursor_image *image = xcursor->images[0]; - wlr_xwayland_set_cursor(xwayland, image->buffer, image->width * 4, - image->width, image->height, image->hotspot_x, - image->hotspot_y); + wlr_xwayland_set_cursor(server.xwayland, image->buffer, + image->width * 4, image->width, image->height, + image->hotspot_x, image->hotspot_y); } #endif @@ -537,13 +612,13 @@ main(int argc, char *argv[]) { wlr_log_errno(WLR_ERROR, "Unable to set WAYLAND_DISPLAY.", "Clients may not be able to connect"); } else { - wlr_log(WLR_DEBUG, - "Cagebreak " CG_VERSION " is running on Wayland display %s", + fprintf(stderr, + "Cagebreak " CG_VERSION " is running on Wayland display %s\n", socket); } #if CG_HAS_XWAYLAND - wlr_xwayland_set_seat(xwayland, server.seat->seat); + wlr_xwayland_set_seat(server.xwayland, server.seat->seat); #endif if(show_info) { @@ -557,14 +632,8 @@ main(int argc, char *argv[]) { exit(0); } - if(ipc_init(&server) != 0) { - wlr_log(WLR_ERROR, "Failed to initialize IPC"); - ret = 1; - goto end; - } - { // config_file should only be visible as long as it is valid - char *config_file = get_config_file(); + char *config_file = get_config_file(config_path); if(config_file == NULL) { wlr_log(WLR_ERROR, "Unable to get path to config file"); ret = 1; @@ -573,27 +642,35 @@ main(int argc, char *argv[]) { int conf_ret = set_configuration(&server, config_file); // Configurtion file not found - if(conf_ret == 1) { - char *default_conf = "/etc/xdg/cagebreak/config"; - wlr_log(WLR_ERROR, "Loading default configuration file: \"%s\"", - default_conf); - conf_ret = set_configuration(&server, default_conf); + if(conf_ret != 0) { + if(config_file == NULL) { + char *default_conf = "/etc/xdg/cagebreak/config"; + wlr_log(WLR_INFO, "Loading default configuration file: \"%s\"", + default_conf); + conf_ret = set_configuration(&server, default_conf); + } else { + conf_ret = 1; + } } - if(conf_ret != 0) { - free(config_file); + free(config_file); + if(conf_ret != 0 || !server.running) { ret = 1; goto end; } - free(config_file); } { - + struct wl_list tmp_list; + wl_list_init(&tmp_list); + wl_list_insert_list(&tmp_list, &server.outputs); + wl_list_init(&server.outputs); struct cg_output *output, *output_tmp; - wl_list_for_each_safe(output, output_tmp, &server.outputs, link) { + wl_list_for_each_safe(output, output_tmp, &tmp_list, link) { output_configure(&server, output); } + server.curr_output = + wl_container_of(server.outputs.next, server.curr_output, link); } /* Place the cursor to the top left of the output layout. */ @@ -601,21 +678,23 @@ main(int argc, char *argv[]) { wl_display_run(server.wl_display); -#if CG_HAS_XWAYLAND - wlr_xwayland_destroy(xwayland); - wlr_xcursor_manager_destroy(xcursor_manager); -#endif wl_display_destroy_clients(server.wl_display); end: + if(server.modes != NULL) { #if CG_HAS_FANALYZE #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wanalyzer-double-free" #endif - for(unsigned int i = 0; server.modes[i] != NULL; ++i) { - free(server.modes[i]); + for(unsigned int i = 0; server.modes[i] != NULL; ++i) { + free(server.modes[i]); + } + free(server.modes); + } + + if(config_path != NULL) { + free(config_path); } - free(server.modes); struct cg_output_config *output_config, *output_config_tmp; wl_list_for_each_safe(output_config, output_config_tmp, @@ -625,19 +704,52 @@ end: free(output_config); } - keybinding_list_free(server.keybindings); - wl_event_source_remove(sigint_source); - wl_event_source_remove(sigterm_source); - wl_event_source_remove(sigalrm_source); + struct cg_input_config *input_config, *input_config_tmp; + wl_list_for_each_safe(input_config, input_config_tmp, &server.input_config, + link) { + wl_list_remove(&input_config->link); + if(input_config->identifier != NULL) { + free(input_config->identifier); + } + free(input_config); + } + + if(server.keybindings != NULL) { + keybinding_list_free(server.keybindings); + } + + if(server.message_config.font != NULL) { + free(server.message_config.font); + } + server.running = false; + if(server.seat != NULL) { + seat_destroy(server.seat); + } +#if CG_HAS_XWAYLAND + if(server.xwayland != NULL) { + wlr_xwayland_destroy(server.xwayland); + } +#endif + + if(sigint_source != NULL) { + wl_event_source_remove(sigint_source); + wl_event_source_remove(sigterm_source); + wl_event_source_remove(sigalrm_source); + wl_event_source_remove(sigpipe_source); + } - seat_destroy(server.seat); /* This function is not null-safe, but we only ever get here with a proper wl_display. */ - wl_display_destroy(server.wl_display); - wlr_output_layout_destroy(server.output_layout); + if(server.wl_display != NULL) { + wl_display_destroy(server.wl_display); + } + if(server.output_layout != NULL) { + wlr_output_layout_destroy(server.output_layout); + } - free(server.input); - free(server.message_config.font); + if(server.input != NULL) { + free(server.input); + } pango_cairo_font_map_set_default(NULL); cairo_debug_reset_static_data(); FcFini(); diff --git a/config.h.in b/config.h.in index 8495284..a79a80c 100644 --- a/config.h.in +++ b/config.h.in @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_CONFIG_H #define CG_CONFIG_H @@ -6,4 +9,6 @@ #mesondefine CG_VERSION +#define MAX_NESTING_LEVEL 50 + #endif diff --git a/example_scripts/cb_script_header.sh b/example_scripts/cb_script_header.sh new file mode 100644 index 0000000..9533beb --- /dev/null +++ b/example_scripts/cb_script_header.sh @@ -0,0 +1,18 @@ +#!/bin/bash +# Copyright 2023, project-repo and the cagebreak contributors +# SPDX -License-Identifier: MIT + +named_pipe_send="$(mktemp -u)" +named_pipe_recv="$(mktemp -u)" +mkfifo "${named_pipe_send}" +mkfifo "${named_pipe_recv}" +nc -U "${CAGEBREAK_SOCKET}" < "${named_pipe_send}" > "${named_pipe_recv}"& +# The file descriptor 3 is set up to send commands to cagebreak and file +# descriptor 4 can be used to read events. Notice that events will pile up in +# file descriptor 4, so it is a good idea to continuously read from it or to +# clear it before starting a new transaction. +exec 3>"${named_pipe_send}" +exec 4<"${named_pipe_recv}" +# When the script exits, the os will clean up the pipe +rm "${named_pipe_recv}" +rm "${named_pipe_send}" diff --git a/example_scripts/focus_follows_cursor.sh b/example_scripts/focus_follows_cursor.sh new file mode 100644 index 0000000..79e2889 --- /dev/null +++ b/example_scripts/focus_follows_cursor.sh @@ -0,0 +1,23 @@ +#!/bin/bash +# Copyright 2023, project-repo and the cagebreak contributors +# SPDX -License-Identifier: MIT + +# This script uses the cagebreak socket to modify the compositor's behaviour in +# such a way that the currently focussed tile follows the cursor, i.e. that the +# currently focussed tile is always the one within which the cursor is located. + +# Start up the ipc link +source "$(dirname "${BASH_SOURCE[0]}")/cb_script_header.sh" + +while IFS= read -r -d $'\0' event +do + # Remove the cg-ipc header + event="${event:6}" + if [[ "$(echo "${event}" | jq ".event_name")" = "\"cursor_switch_tile\"" ]] + then + new_tile="$(echo "${event}"|jq -r ".new_tile")" + new_output_id="$(echo "${event}"|jq -r ".new_output_id")" + # Send the new tile to focus to cagebreak + echo -e "screen ${new_output_id}\nfocus_tile ${new_tile}" >&3 + fi +done <&4 diff --git a/example_scripts/show_workspace_views.sh b/example_scripts/show_workspace_views.sh new file mode 100644 index 0000000..3be9cbb --- /dev/null +++ b/example_scripts/show_workspace_views.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# Copyright 2020 - 2023, project-repo and the cagebreak contributors +# SPDX -License-Identifier: MIT + +# This script displays the process names of the views on the current workspace. + +# Start up the ipc link +source "$(dirname "${BASH_SOURCE[0]}")/cb_script_header.sh" + +echo "dump" >&3 + +while IFS= read -r -d $'\0' event +do + # Remove the cg-ipc header + event="${event:6}" + if [[ "$(echo "${event}" | jq ".event_name")" = "\"dump\"" ]] + then + curr_output="$(echo "${event}"|jq ".curr_output")" + curr_workspace="$(echo "${event}"|jq -r ".outputs.${curr_output}.curr_workspace")" + # Print the process names of the view on the current workspace. jq retrieves + # their PID and ps is then used to retrieve the process names. + (echo -n "message ";ps -o comm=Command -p $(echo "${event}"|jq -r ".outputs.${curr_output}.workspaces[$((curr_workspace-1))].views[].pid")|tail +2|sed ':a; N; $!ba; s/\n/||/g') >&3 + break + fi +done <&4 diff --git a/examples/config b/examples/config index e6a6cb5..d79a792 100644 --- a/examples/config +++ b/examples/config @@ -1,3 +1,5 @@ +# Copyright 2020 - 2023, project-repo and the cagebreak contributors +# SPDX -License-Identifier: MIT ###################### # General settings an key bindings ###################### @@ -41,6 +43,9 @@ definekey resize j resizedown definekey resize k resizeup definekey resize Escape setmode top +#unhide cursor (default) +cursor enable + ###################### #Workspaces ###################### @@ -95,6 +100,7 @@ definekey top XF86MonBrightnessUp exec xbacklight -inc 1 #output eDP-1 disable #output eDP-1 enable #output eDP-1 prio 1 +#output eDP-2 pos 0 0 res 1366x768 rate 60 scale 2.0 ##################### #Input configuration diff --git a/fuzz/execl_override.c b/fuzz/execl_override.c index 316cf1e..9fc9e6e 100644 --- a/fuzz/execl_override.c +++ b/fuzz/execl_override.c @@ -1,5 +1,7 @@ -/* This file is used by the fuzzer in order to prevent executing shell commands. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT +// This file is used by the fuzzer in order to prevent executing shell commands. + #define _GNU_SOURCE #include "../output.h" #include diff --git a/fuzz/fuzz-lib.c b/fuzz/fuzz-lib.c index c94dd8b..c159538 100644 --- a/fuzz/fuzz-lib.c +++ b/fuzz/fuzz-lib.c @@ -1,10 +1,5 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200812L @@ -35,8 +30,12 @@ #include #include #include +#include +#include +#include #include #include +#include #if CG_HAS_XWAYLAND #include #endif @@ -88,15 +87,6 @@ drop_permissions(void) { return true; } -static bool -parse_args(struct cg_server *server, int argc, char *argv[]) { - server->output_transform = WL_OUTPUT_TRANSFORM_NORMAL; -#ifdef DEBUG - server->debug_damage_tracking = false; -#endif - return true; -} - void cleanup() { server.running = false; @@ -120,13 +110,11 @@ cleanup() { seat_destroy(server.seat); /* This function is not null-safe, but we only ever get here with a proper wl_display. */ - wl_display_destroy(server.wl_display); wlr_output_layout_destroy(server.output_layout); } int LLVMFuzzerInitialize(int *argc, char ***argv) { - struct wl_event_loop *event_loop = NULL; struct wlr_backend *backend = NULL; struct wlr_compositor *compositor = NULL; struct wlr_data_device_manager *data_device_manager = NULL; @@ -135,13 +123,21 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { struct wlr_export_dmabuf_manager_v1 *export_dmabuf_manager = NULL; struct wlr_screencopy_manager_v1 *screencopy_manager = NULL; struct wlr_data_control_manager_v1 *data_control_manager = NULL; + struct wlr_viewporter *viewporter = NULL; + struct wlr_presentation *presentation = NULL; struct wlr_xdg_output_manager_v1 *output_manager = NULL; struct wlr_gamma_control_manager_v1 *gamma_control_manager = NULL; - int ret = 0; + struct wlr_xdg_shell *xdg_shell = NULL; +#if CG_HAS_XWAYLAND + struct wlr_xwayland *xwayland = NULL; +#endif + wl_list_init(&server.input_config); + wl_list_init(&server.output_config); + wl_list_init(&server.output_priorities); + wl_list_init(&server.outputs); + wl_list_init(&server.disabled_outputs); - if(!parse_args(&server, *argc, *argv)) { - return 1; - } + int ret = 0; #ifdef DEBUG wlr_log_init(WLR_DEBUG, NULL); @@ -149,33 +145,63 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { wlr_log_init(WLR_ERROR, NULL); #endif - wl_list_init(&server.input_config); + server.modes = malloc(4 * sizeof(char *)); + if(!server.modes) { + wlr_log(WLR_ERROR, "Error allocating mode array"); + goto end; + } /* Wayland requires XDG_RUNTIME_DIR to be set. */ if(!getenv("XDG_RUNTIME_DIR")) { - wlr_log(WLR_ERROR, "XDG_RUNTIME_DIR is not set in the environment"); - return 1; + wlr_log(WLR_INFO, "XDG_RUNTIME_DIR is not set in the environment"); } server.wl_display = wl_display_create(); if(!server.wl_display) { wlr_log(WLR_ERROR, "Cannot allocate a Wayland display"); - return 1; + free(server.modes); + server.modes = NULL; + goto end; + } + + server.xcursor_size = XCURSOR_SIZE; + const char *env_cursor_size = getenv("XCURSOR_SIZE"); + if(env_cursor_size && strlen(env_cursor_size) > 0) { + errno = 0; + char *end; + unsigned size = strtoul(env_cursor_size, &end, 10); + if(!*end && errno == 0) { + server.xcursor_size = size; + } } server.running = true; - server.modes = malloc(4 * sizeof(char *)); server.modes[0] = strdup("top"); server.modes[1] = strdup("root"); server.modes[2] = strdup("resize"); server.modes[3] = NULL; + if(server.modes[0] == NULL || server.modes[1] == NULL || + server.modes[2] == NULL) { + wlr_log(WLR_ERROR, "Error allocating default modes"); + goto end; + } server.nws = 1; - server.message_timeout = 2; + server.views_curr_id = 1; + server.tiles_curr_id = 1; + server.message_config.fg_color[0] = 0.0; + server.message_config.fg_color[1] = 0.0; + server.message_config.fg_color[2] = 0.0; + server.message_config.fg_color[3] = 1.0; - event_loop = wl_display_get_event_loop(server.wl_display); - server.event_loop = event_loop; + server.message_config.bg_color[0] = 0.9; + server.message_config.bg_color[1] = 0.85; + server.message_config.bg_color[2] = 0.85; + server.message_config.bg_color[3] = 1.0; + + server.message_config.display_time = 2; + server.message_config.font = strdup("pango:Monospace 10"); backend = wlr_multi_backend_create(server.wl_display); if(!backend) { @@ -201,11 +227,6 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { goto end; }; - if(!drop_permissions()) { - ret = 1; - goto end; - } - server.keybindings = keybinding_list_init(); if(server.keybindings == NULL || server.keybindings->keybindings == NULL) { wlr_log(WLR_ERROR, "Unable to allocate keybindings"); @@ -213,14 +234,13 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { goto end; } - wl_list_init(&server.output_config); - server.renderer = wlr_renderer_autocreate(backend); if(!server.renderer) { wlr_log(WLR_ERROR, "Unable to create the wlroots renderer"); ret = 1; goto end; } + server.allocator = wlr_allocator_autocreate(server.backend, server.renderer); if(!server.allocator) { @@ -228,16 +248,10 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { ret = 1; goto end; } + wlr_renderer_init_wl_display(server.renderer, server.wl_display); - server.bg_color = malloc(4 * sizeof(float)); - server.bg_color[0] = 0; - server.bg_color[1] = 0; - server.bg_color[2] = 0; - server.bg_color[3] = 1; - wl_list_init(&server.outputs); - wl_list_init(&server.disabled_outputs); - + server.bg_color = (float[4]){0, 0, 0, 1}; server.output_layout = wlr_output_layout_create(); if(!server.output_layout) { wlr_log(WLR_ERROR, "Unable to create output layout"); @@ -245,6 +259,27 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { goto end; } + if(ipc_init(&server) != 0) { + wlr_log(WLR_ERROR, "Failed to initialize IPC"); + ret = 1; + goto end; + } + + server.scene = wlr_scene_create(); + if(!server.scene) { + wlr_log(WLR_ERROR, "Unable to create scene"); + ret = 1; + goto end; + } + wlr_scene_attach_output_layout(server.scene, server.output_layout); + + compositor = wlr_compositor_create(server.wl_display, server.renderer); + if(!compositor) { + wlr_log(WLR_ERROR, "Unable to create the wlroots compositor"); + ret = 1; + goto end; + } + data_device_manager = wlr_data_device_manager_create(server.wl_display); if(!data_device_manager) { wlr_log(WLR_ERROR, "Unable to create the data device manager"); @@ -293,7 +328,7 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { &server.new_idle_inhibitor_v1); wl_list_init(&server.inhibitors); - xdg_shell = wlr_xdg_shell_create(server.wl_display); + xdg_shell = wlr_xdg_shell_create(server.wl_display, 3); if(!xdg_shell) { wlr_log(WLR_ERROR, "Unable to create the XDG shell interface"); ret = 1; @@ -324,6 +359,21 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { wlr_server_decoration_manager_set_default_mode( server_decoration_manager, WLR_SERVER_DECORATION_MANAGER_MODE_SERVER); + viewporter = wlr_viewporter_create(server.wl_display); + if(!viewporter) { + wlr_log(WLR_ERROR, "Unable to create the viewporter interface"); + ret = 1; + goto end; + } + + presentation = wlr_presentation_create(server.wl_display, server.backend); + if(!presentation) { + wlr_log(WLR_ERROR, "Unable to create the presentation interface"); + ret = 1; + goto end; + } + wlr_scene_set_presentation(server.scene, presentation); + export_dmabuf_manager = wlr_export_dmabuf_manager_v1_create(server.wl_display); if(!export_dmabuf_manager) { @@ -347,17 +397,17 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { goto end; } - gamma_control_manager = - wlr_gamma_control_manager_v1_create(server.wl_display); - if(!gamma_control_manager) { - wlr_log(WLR_ERROR, "Unable to create the gamma control manager"); + if(!wlr_primary_selection_v1_device_manager_create(server.wl_display)) { + wlr_log(WLR_ERROR, + "Unable to create the primary selection device manager"); ret = 1; goto end; } - compositor = wlr_compositor_create(server.wl_display, server.renderer); - if(!compositor) { - wlr_log(WLR_ERROR, "Unable to create the wlroots compositor"); + gamma_control_manager = + wlr_gamma_control_manager_v1_create(server.wl_display); + if(!gamma_control_manager) { + wlr_log(WLR_ERROR, "Unable to create the gamma control manager"); ret = 1; goto end; } @@ -372,13 +422,6 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { server.new_xwayland_surface.notify = handle_xwayland_surface_new; wl_signal_add(&xwayland->events.new_surface, &server.new_xwayland_surface); - xcursor_manager = wlr_xcursor_manager_create(DEFAULT_XCURSOR, XCURSOR_SIZE); - if(!xcursor_manager) { - wlr_log(WLR_ERROR, "Cannot create XWayland XCursor manager"); - ret = 1; - goto end; - } - if(setenv("DISPLAY", xwayland->display_name, true) < 0) { wlr_log_errno(WLR_ERROR, "Unable to set DISPLAY for XWayland.", "Clients may not be able to connect"); @@ -387,18 +430,15 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { xwayland->display_name); } - if(wlr_xcursor_manager_load(xcursor_manager, 1)) { - wlr_log(WLR_ERROR, "Cannot load XWayland XCursor theme"); - } - struct wlr_xcursor *xcursor = - wlr_xcursor_manager_get_xcursor(xcursor_manager, DEFAULT_XCURSOR, 1); + struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor( + server.seat->xcursor_manager, DEFAULT_XCURSOR, 1); + if(xcursor) { struct wlr_xcursor_image *image = xcursor->images[0]; wlr_xwayland_set_cursor(xwayland, image->buffer, image->width * 4, image->width, image->height, image->hotspot_x, image->hotspot_y); } - #endif const char *socket = wl_display_add_socket_auto(server.wl_display); @@ -418,42 +458,32 @@ LLVMFuzzerInitialize(int *argc, char ***argv) { wlr_log_errno(WLR_ERROR, "Unable to set WAYLAND_DISPLAY.", "Clients may not be able to connect"); } else { - wlr_log(WLR_DEBUG, - "Cagebreak " CG_VERSION " is running on Wayland display %s", + fprintf(stderr, + "Cagebreak " CG_VERSION " is running on Wayland display %s\n", socket); } +#if CG_HAS_XWAYLAND + wlr_xwayland_set_seat(xwayland, server.seat->seat); +#endif + + /* Place the cursor to the top left of the output layout. */ + wlr_cursor_warp(server.seat->cursor, NULL, 0, 0); + + if(!drop_permissions()) { + ret = 1; + goto end; + } + /* Place the cursor to the topl left of the output layout. */ wlr_cursor_warp(server.seat->cursor, NULL, 0, 0); atexit(cleanup); - // server.wl_display->run = 1; return 0; end: cleanup(); return ret; } -void -move_cursor(char *line, struct cg_server *server) { - return; // TODO - long del = 0; - char *delstr = strtok_r(NULL, ";", &line); - enum wlr_axis_orientation orientation = - (*(line++) == '0') ? WLR_AXIS_ORIENTATION_VERTICAL - : WLR_AXIS_ORIENTATION_HORIZONTAL; - if(delstr == NULL) { - return; - } - del = strtol(delstr, NULL, 10); - struct wlr_event_pointer_axis event = {.device = NULL, - .time_msec = 0, - .source = WLR_AXIS_SOURCE_WHEEL, - .orientation = orientation, - .delta = del * 15, - .delta_discrete = del}; - // TODO dispatch_cursor_axis(server->seat->cursor, &event); -} - void add_output_callback(struct wlr_backend *backend, void *data) { long *dims = data; @@ -485,73 +515,6 @@ create_output(char *line, struct cg_server *server) { wlr_multi_for_each_backend(server->backend, add_output_callback, dims); } -void -add_input_device_callback(struct wlr_backend *backend, void *data) { - enum wlr_input_device_type *type = data; - wlr_headless_add_input_device(backend, *type); -} - -void -create_input_device(char *line, struct cg_server *server) { - enum wlr_input_device_type type; - if(*line != '\0') { - if(strncmp(line, "kbd", 3) == 0) { - type = WLR_INPUT_DEVICE_KEYBOARD; - wlr_multi_for_each_backend(server->backend, - add_input_device_callback, &type); - } else if(strncmp(line, "ptr", 3) == 0) { - type = WLR_INPUT_DEVICE_POINTER; - wlr_multi_for_each_backend(server->backend, - add_input_device_callback, &type); - } else if(strncmp(line, "tch", 3) == 0) { - type = WLR_INPUT_DEVICE_TOUCH; - wlr_multi_for_each_backend(server->backend, - add_input_device_callback, &type); - } - } -} - -void -destroy_input_device(char *line, struct cg_server *server) { - long devn = 0; - if(line[0] != '\0') { - devn = strtol(line + 1, NULL, 10); - } - if(line != NULL) { - if(strncmp(line, "k", 1) == 0) { - if(wl_list_empty(&server->seat->keyboard_groups)) { - return; - } - devn = devn % wl_list_length(&server->seat->keyboard_groups); - struct cg_keyboard_group *group, *group_tmp; - wl_list_for_each_safe(group, group_tmp, - &server->seat->keyboard_groups, link) { - if(devn == 0) { - wl_list_remove(&group->link); - wlr_keyboard_group_destroy(group->wlr_group); - wl_event_source_remove(group->key_repeat_timer); - free(group); - break; - } - --devn; - } - } else if(strncmp(line, "p", 1) == 0) { - if(wl_list_empty(&server->input->devices)) { - return; - } - devn = devn % wl_list_length(&server->input->devices); - struct cg_input_device *dev, *dev_tmp; - wl_list_for_each_safe(dev, dev_tmp, &server->input->devices, link) { - if(devn == 0) { - dev->device_destroy.notify(&dev->device_destroy, NULL); - break; - } - --devn; - } - } - } -} - void destroy_output(char *line, struct cg_server *server) { if(wl_list_length(&server->outputs) < 2) { @@ -571,5 +534,4 @@ destroy_output(char *line, struct cg_server *server) { --outpn; } } - it->damage_destroy.notify(&it->damage_destroy, NULL); } diff --git a/fuzz/fuzz-lib.h b/fuzz/fuzz-lib.h index 7182a50..950f455 100644 --- a/fuzz/fuzz-lib.h +++ b/fuzz/fuzz-lib.h @@ -1,10 +1,5 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #ifndef CG_FUZZ_LIB_H #define CG_FUZZ_LIB_H diff --git a/fuzz/fuzz-parse.c b/fuzz/fuzz-parse.c index 8aded78..0fc060c 100644 --- a/fuzz/fuzz-parse.c +++ b/fuzz/fuzz-parse.c @@ -1,10 +1,5 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200812L @@ -38,7 +33,7 @@ set_configuration(struct cg_server *server, char *content) { (line = strtok_r(NULL, "\n", &content)) != NULL; ++line_num) { line[strcspn(line, "\n")] = '\0'; if(*line != '\0' && *line != '#') { - char *errstr; + char *errstr = NULL; server->running = true; if(parse_rc_line(server, line, &errstr) != 0) { if(errstr != NULL) { @@ -56,10 +51,9 @@ LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { if(size == 0) { return 0; } - int max_line_size = 256 > size ? size : 256; - char *str = malloc(sizeof(char) * max_line_size); - strncpy(str, (char *)data, max_line_size); - str[max_line_size - 1] = 0; + char *str = malloc(sizeof(char) * size); + strncpy(str, (char *)data, size); + str[size - 1] = 0; set_configuration(&server, str); free(str); keybinding_list_free(server.keybindings); diff --git a/fuzz/meson.build b/fuzz/meson.build index b5ba1be..01fdd3e 100644 --- a/fuzz/meson.build +++ b/fuzz/meson.build @@ -1,3 +1,6 @@ +# Copyright 2020 - 2023, project-repo and the cagebreak contributors +# SPDX -License-Identifier: MIT + fuzz_sources = [ 'fuzz-parse.c', 'fuzz-lib.c', @@ -19,7 +22,7 @@ endif override_lib = shared_library('execl_override', [ 'execl_override.c' ], - dependencies: [ pixman,cairo,pango,pangocairo ], + dependencies: [ cairo,pango,pangocairo ], install: false ) diff --git a/idle_inhibit_v1.c b/idle_inhibit_v1.c index 8ebc768..9bc3f7a 100644 --- a/idle_inhibit_v1.c +++ b/idle_inhibit_v1.c @@ -1,11 +1,5 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2019 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #include #include diff --git a/idle_inhibit_v1.h b/idle_inhibit_v1.h index cd1a58d..f0dce64 100644 --- a/idle_inhibit_v1.h +++ b/idle_inhibit_v1.h @@ -1,3 +1,5 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #ifndef CG_IDLE_INHIBIT_H #define CG_IDLE_INHIBIT_H diff --git a/input.h b/input.h index 0b6eb7e..f7877c5 100644 --- a/input.h +++ b/input.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef _CG_INPUT_H #define _CG_INPUT_H @@ -13,9 +16,6 @@ cg_input_configure_libinput_device(struct cg_input_device *device); void cg_input_apply_config(struct cg_input_config *config, struct cg_server *server); -bool -cg_input_reset_libinput_device(struct cg_input_device *device); - bool cg_libinput_device_is_builtin(struct cg_input_device *device); diff --git a/input_manager.c b/input_manager.c index 2157b43..29e4d1d 100644 --- a/input_manager.c +++ b/input_manager.c @@ -1,11 +1,5 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200812L @@ -16,7 +10,9 @@ #include "server.h" #include +#include #include +#include #include #include #include @@ -25,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -64,6 +61,7 @@ input_device_get_identifier(struct wlr_input_device *device) { char *identifier = malloc(len); if(!identifier) { wlr_log(WLR_ERROR, "Unable to allocate unique input device name"); + free(name); return NULL; } @@ -90,13 +88,217 @@ input_manager_handle_device_destroy(struct wl_listener *listener, void *data) { free(input_device); } -static void -handle_new_input(struct wl_listener *listener, void *data) { - struct cg_input_manager *input = - wl_container_of(listener, input, new_input); - struct cg_server *server = input->server; - struct wlr_input_device *device = data; +struct cg_input_config * +input_manager_create_empty_input_config() { + struct cg_input_config *cfg = calloc(1, sizeof(struct cg_input_config)); + if(cfg == NULL) { + return NULL; + } + /* Libinput devices */ + cfg->tap = INT_MIN; + cfg->tap_button_map = INT_MIN; + cfg->drag = INT_MIN; + cfg->drag_lock = INT_MIN; + cfg->dwt = INT_MIN; + cfg->send_events = INT_MIN; + cfg->click_method = INT_MIN; + cfg->middle_emulation = INT_MIN; + cfg->natural_scroll = INT_MIN; + cfg->accel_profile = INT_MIN; + cfg->pointer_accel = FLT_MIN; + cfg->scroll_factor = FLT_MIN; + cfg->scroll_button = INT_MIN; + cfg->scroll_method = INT_MIN; + cfg->left_handed = INT_MIN; + /*cfg->repeat_delay = INT_MIN; + cfg->repeat_rate = INT_MIN; + cfg->xkb_numlock = INT_MIN; + cfg->xkb_capslock = INT_MIN; + cfg->xkb_file_is_set = false; + wl_list_init(&cfg->tools);*/ + /* Keyboards */ + cfg->enable_keybindings = -1; + cfg->repeat_delay = -1; + cfg->repeat_rate = -1; + return cfg; +} + +/* cfg1 has precedence */ +struct cg_input_config * +input_manager_merge_input_configs(struct cg_input_config *cfg1, + struct cg_input_config *cfg2) { + struct cg_input_config *out_cfg = calloc(1, sizeof(struct cg_input_config)); + if(cfg1->identifier == NULL) { + if(cfg2->identifier != NULL) { + out_cfg->identifier = strdup(cfg2->identifier); + } + } else { + out_cfg->identifier = strdup(cfg1->identifier); + } + if(out_cfg == NULL) { + return NULL; + } + if(cfg1->tap == INT_MIN) { + out_cfg->tap = cfg2->tap; + } else { + out_cfg->tap = cfg1->tap; + } + if(cfg1->send_events == INT_MIN) { + out_cfg->send_events = cfg2->send_events; + } else { + out_cfg->send_events = cfg1->send_events; + } + if(cfg1->dwt == INT_MIN) { + out_cfg->dwt = cfg2->dwt; + } else { + out_cfg->dwt = cfg1->dwt; + } + if(cfg1->drag_lock == INT_MIN) { + out_cfg->drag_lock = cfg2->drag_lock; + } else { + out_cfg->drag_lock = cfg1->drag_lock; + } + if(cfg1->drag == INT_MIN) { + out_cfg->drag = cfg2->drag; + } else { + out_cfg->drag = cfg1->drag; + } + if(cfg1->tap_button_map == INT_MIN) { + out_cfg->tap_button_map = cfg2->tap_button_map; + } else { + out_cfg->tap_button_map = cfg1->tap_button_map; + } + if(cfg1->left_handed == INT_MIN) { + out_cfg->left_handed = cfg2->left_handed; + } else { + out_cfg->left_handed = cfg1->left_handed; + } + if(cfg1->scroll_method == INT_MIN) { + out_cfg->scroll_method = cfg2->scroll_method; + } else { + out_cfg->scroll_method = cfg1->scroll_method; + } + if(cfg1->scroll_button == INT_MIN) { + out_cfg->scroll_button = cfg2->scroll_button; + } else { + out_cfg->scroll_button = cfg1->scroll_button; + } + if(cfg1->scroll_factor == FLT_MIN) { + out_cfg->scroll_factor = cfg2->scroll_factor; + } else { + out_cfg->scroll_factor = cfg1->scroll_factor; + } + if(cfg1->pointer_accel == FLT_MIN) { + out_cfg->pointer_accel = cfg2->pointer_accel; + } else { + out_cfg->pointer_accel = cfg1->pointer_accel; + } + if(cfg1->accel_profile == INT_MIN) { + out_cfg->accel_profile = cfg2->accel_profile; + } else { + out_cfg->accel_profile = cfg1->accel_profile; + } + if(cfg1->natural_scroll == INT_MIN) { + out_cfg->natural_scroll = cfg2->natural_scroll; + } else { + out_cfg->natural_scroll = cfg1->natural_scroll; + } + if(cfg1->middle_emulation == INT_MIN) { + out_cfg->middle_emulation = cfg2->middle_emulation; + } else { + out_cfg->middle_emulation = cfg1->middle_emulation; + } + if(cfg1->click_method == INT_MIN) { + out_cfg->click_method = cfg2->click_method; + } else { + out_cfg->click_method = cfg1->click_method; + } + if(cfg1->enable_keybindings == -1) { + out_cfg->enable_keybindings = cfg2->enable_keybindings; + } else { + out_cfg->enable_keybindings = cfg1->enable_keybindings; + } + if(cfg1->repeat_delay == -1) { + out_cfg->repeat_delay = cfg2->repeat_delay; + } else { + out_cfg->repeat_delay = cfg1->repeat_delay; + } + if(cfg1->repeat_rate == -1) { + out_cfg->repeat_rate = cfg2->repeat_rate; + } else { + out_cfg->repeat_rate = cfg1->repeat_rate; + } + return out_cfg; +} + +void +apply_keyboard_group_config(struct cg_input_config *config, + struct cg_keyboard_group *group) { + if(config->enable_keybindings != -1) { + group->enable_keybindings = config->enable_keybindings; + } + int repeat_delay = 600, repeat_rate = 25; + if(config->repeat_delay != -1) { + repeat_delay = config->repeat_delay; + } + if(config->repeat_rate != -1) { + repeat_rate = config->repeat_rate; + } + wlr_keyboard_set_repeat_info(&group->wlr_group->keyboard, repeat_rate, + repeat_delay); +} + +void +cg_input_manager_configure_keyboard_group(struct cg_keyboard_group *group) { + struct cg_server *server = group->seat->server; + struct cg_input_config *tot_cfg = input_manager_create_empty_input_config(); + if(tot_cfg == NULL) { + return; + } + + struct cg_input_config *tmp_cfg, *config = NULL; + wl_list_for_each(config, &server->input_config, link) { + if(strcmp(config->identifier, group->identifier) == 0 || + strcmp(config->identifier, "*") == 0 || + (strncmp(config->identifier, "type:", 5) == 0 && + strcmp(config->identifier + 5, "keyboard") == 0)) { + tmp_cfg = tot_cfg; + if(tot_cfg->identifier == NULL || + strcmp(tot_cfg->identifier, "*") == 0 || + strcmp(config->identifier, group->identifier)) { + tot_cfg = input_manager_merge_input_configs(config, tot_cfg); + } else { + tot_cfg = input_manager_merge_input_configs(tot_cfg, config); + } + if(tmp_cfg->identifier != NULL) { + free(tmp_cfg->identifier); + } + free(tmp_cfg); + } + } + apply_keyboard_group_config(tot_cfg, group); + if(tot_cfg->identifier != NULL) { + free(tot_cfg->identifier); + } + free(tot_cfg); +} + +void +cg_input_manager_configure(struct cg_server *server) { + struct cg_input_device *device = NULL; + wl_list_for_each(device, &server->input->devices, link) { + cg_input_configure_libinput_device(device); + } + struct cg_keyboard_group *group = NULL; + wl_list_for_each(group, &server->seat->keyboard_groups, link) { + cg_input_manager_configure_keyboard_group(group); + } +} + +static void +new_input(struct cg_input_manager *input, struct wlr_input_device *device, + bool virtual) { struct cg_input_device *input_device = calloc(1, sizeof(struct cg_input_device)); if(!input_device) { @@ -105,9 +307,10 @@ handle_new_input(struct wl_listener *listener, void *data) { } device->data = input_device; + input_device->is_virtual = virtual; input_device->wlr_device = device; input_device->identifier = input_device_get_identifier(device); - input_device->server = server; + input_device->server = input->server; input_device->pointer = NULL; input_device->touch = NULL; @@ -118,39 +321,28 @@ handle_new_input(struct wl_listener *listener, void *data) { wl_signal_add(&device->events.destroy, &input_device->device_destroy); input_device->device_destroy.notify = input_manager_handle_device_destroy; - struct cg_seat *seat = server->seat; + struct cg_seat *seat = input->server->seat; seat_add_device(seat, input_device); } +static void +handle_new_input(struct wl_listener *listener, void *data) { + struct cg_input_manager *input = + wl_container_of(listener, input, new_input); + struct wlr_input_device *device = data; + + new_input(input, device, false); +} + void handle_virtual_keyboard(struct wl_listener *listener, void *data) { - struct cg_input_manager *input_manager = - wl_container_of(listener, input_manager, virtual_keyboard_new); + + struct cg_input_manager *input = + wl_container_of(listener, input, virtual_keyboard_new); struct wlr_virtual_keyboard_v1 *keyboard = data; - struct wlr_input_device *device = &keyboard->input_device; + struct wlr_input_device *device = &keyboard->keyboard.base; - struct cg_seat *seat = input_manager->server->seat; - - struct cg_input_device *input_device = - calloc(1, sizeof(struct cg_input_device)); - if(!input_device) { - wlr_log(WLR_ERROR, "could not allocate input device"); - return; - } - device->data = input_device; - - input_device->is_virtual = true; - input_device->wlr_device = device; - input_device->identifier = input_device_get_identifier(device); - wl_list_insert(&input_manager->devices, &input_device->link); - input_device->server = input_manager->server; - input_device->pointer = NULL; - input_device->touch = NULL; - - wl_signal_add(&device->events.destroy, &input_device->device_destroy); - input_device->device_destroy.notify = input_manager_handle_device_destroy; - - seat_add_device(seat, input_device); + new_input(input, device, true); } void @@ -159,34 +351,13 @@ handle_virtual_pointer(struct wl_listener *listener, void *data) { wl_container_of(listener, input_manager, virtual_pointer_new); struct wlr_virtual_pointer_v1_new_pointer_event *event = data; struct wlr_virtual_pointer_v1 *pointer = event->new_pointer; - struct wlr_input_device *device = &pointer->input_device; + struct wlr_input_device *device = &pointer->pointer.base; - struct cg_seat *seat = input_manager->server->seat; - - struct cg_input_device *input_device = - calloc(1, sizeof(struct cg_input_device)); - if(!input_device) { - wlr_log(WLR_ERROR, "could not allocate input device"); - return; - } - device->data = input_device; - - input_device->is_virtual = true; - input_device->wlr_device = device; - input_device->identifier = input_device_get_identifier(device); - wl_list_insert(&input_manager->devices, &input_device->link); - input_device->server = input_manager->server; - input_device->pointer = NULL; - input_device->touch = NULL; - - wl_signal_add(&device->events.destroy, &input_device->device_destroy); - input_device->device_destroy.notify = input_manager_handle_device_destroy; - - seat_add_device(seat, input_device); + new_input(input_manager, device, true); if(event->suggested_output) { - wlr_cursor_map_input_to_output(seat->cursor, device, - event->suggested_output); + wlr_cursor_map_input_to_output(input_manager->server->seat->cursor, + device, event->suggested_output); } } diff --git a/input_manager.h b/input_manager.h index 35318f6..1def1df 100644 --- a/input_manager.h +++ b/input_manager.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_INPUT_MANAGER_H #define CG_INPUT_MANAGER_H @@ -8,12 +11,19 @@ struct cg_input_manager * input_manager_create(struct cg_server *server); -struct cg_input_config * -input_device_get_config(struct cg_input_device *device); void input_manager_handle_device_destroy(struct wl_listener *listener, void *data); uint32_t input_manager_get_mouse_button(const char *name, char **error); +struct cg_input_config * +input_manager_create_empty_input_config(); +struct cg_input_config * +input_manager_merge_input_configs(struct cg_input_config *cfg1, + struct cg_input_config *cfg2); +void +cg_input_manager_configure(struct cg_server *server); +void +cg_input_manager_configure_keyboard_group(struct cg_keyboard_group *group); struct cg_input_manager { struct wl_list devices; @@ -50,6 +60,7 @@ enum cg_input_config_mapped_to { struct cg_input_config { char *identifier; + /* Libinput devices */ int accel_profile; struct calibration_matrix calibration_matrix; int click_method; @@ -92,13 +103,18 @@ struct cg_input_config { bool capturable; struct wlr_box region; + + /* Keyboards */ + int enable_keybindings; + int repeat_delay; + int repeat_rate; }; struct cg_input_device { char *identifier; struct cg_server *server; struct wlr_input_device *wlr_device; - struct wl_list link; + struct wl_list link; // input_manager::devices struct wl_listener device_destroy; bool is_virtual; diff --git a/ipc_server.c b/ipc_server.c index 7301867..c5295e7 100644 --- a/ipc_server.c +++ b/ipc_server.c @@ -1,27 +1,28 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200112L +#define _DEFAULT_SOURCE #include "ipc_server.h" #include "message.h" #include "parse.h" #include "server.h" +#include "util.h" #include #include #include #include +#include #include #include #include +static const char ipc_magic[] = {'c', 'g', '-', 'i', 'p', 'c'}; + +#define IPC_HEADER_SIZE sizeof(ipc_magic) + static void handle_display_destroy(struct wl_listener *listener, void *data) { struct cg_ipc_handle *ipc = wl_container_of(listener, ipc, display_destroy); @@ -43,6 +44,9 @@ handle_display_destroy(struct wl_listener *listener, void *data) { int ipc_init(struct cg_server *server) { + if(server->enable_socket == false) { + return 0; + } struct cg_ipc_handle *ipc = &server->ipc; ipc->socket = socket(AF_UNIX, SOCK_STREAM, 0); if(ipc->socket == -1) { @@ -96,6 +100,7 @@ ipc_init(struct cg_server *server) { return -1; } + chmod(ipc->sockaddr->sun_path, 0700); setenv("CAGEBREAK_SOCKET", ipc->sockaddr->sun_path, 1); wl_list_init(&ipc->client_list); @@ -109,6 +114,50 @@ ipc_init(struct cg_server *server) { return 0; } +int +ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) { + struct cg_ipc_client *client = data; + + if(mask & WL_EVENT_ERROR) { + ipc_client_disconnect(client); + return 0; + } + + if(mask & WL_EVENT_HANGUP) { + ipc_client_disconnect(client); + return 0; + } + + if(client->write_buffer_len <= 0) { + return 0; + } + + if(fcntl(client->fd, F_GETFD) == -1) { + return 0; + } + ssize_t written = + write(client->fd, client->write_buffer, client->write_buffer_len); + + if(written == -1 && errno == EAGAIN) { + return 0; + } else if(written == -1) { + wlr_log(WLR_ERROR, "Unable to send data from queue to IPC client"); + ipc_client_disconnect(client); + return 0; + } + + memmove(client->write_buffer, client->write_buffer + written, + client->write_buffer_len - written); + client->write_buffer_len -= written; + + if(client->write_buffer_len == 0 && client->writable_event_source) { + wl_event_source_remove(client->writable_event_source); + client->writable_event_source = NULL; + } + + return 0; +} + int ipc_handle_connection(int fd, uint32_t mask, void *data) { (void)fd; @@ -145,8 +194,8 @@ ipc_handle_connection(int fd, uint32_t mask, void *data) { close(client_fd); return 0; } - // +1 for \n and +1 for \0 - client->read_buffer = malloc(sizeof(char) * (MAX_LINE_SIZE + 2)); + client->read_buf_cap = 64; + client->read_buffer = calloc(client->read_buf_cap, sizeof(char)); client->read_buf_len = 0; client->read_discard = 0; client->server = server; @@ -154,7 +203,9 @@ ipc_handle_connection(int fd, uint32_t mask, void *data) { client->event_source = wl_event_loop_add_fd(server->event_loop, client_fd, WL_EVENT_READABLE, ipc_client_handle_readable, client); - client->writable_event_source = NULL; + client->writable_event_source = + wl_event_loop_add_fd(server->event_loop, client_fd, WL_EVENT_WRITABLE, + ipc_client_handle_writable, client); client->write_buffer_size = 128; client->write_buffer_len = 0; @@ -191,12 +242,22 @@ ipc_client_handle_readable(int client_fd, uint32_t mask, void *data) { return 0; } - int read_size = read_available < MAX_LINE_SIZE + 1 - client->read_buf_len - ? read_available - : MAX_LINE_SIZE + 1 - client->read_buf_len; + while(read_available + client->read_buf_len > + (int32_t)client->read_buf_cap - 1) { + client->read_buf_cap *= 2; + client->read_buffer = reallocarray(client->read_buffer, + client->read_buf_cap, sizeof(char)); + if(client->read_buffer == NULL) { + wlr_log(WLR_ERROR, "Unable to allocate buffer large enough to hold " + "client read data"); + ipc_client_disconnect(client); + return 0; + } + } // Append to buffer - ssize_t received = recv( - client_fd, client->read_buffer + client->read_buf_len, read_size, 0); + ssize_t received = + recv(client_fd, client->read_buffer + client->read_buf_len, + read_available, 0); if(received == -1) { wlr_log(WLR_ERROR, "Unable to receive data from IPC client"); ipc_client_disconnect(client); @@ -224,8 +285,12 @@ ipc_client_disconnect(struct cg_ipc_client *client) { wl_event_source_remove(client->writable_event_source); } wl_list_remove(&client->link); - free(client->write_buffer); - free(client->read_buffer); + if(client->write_buffer != NULL) { + free(client->write_buffer); + } + if(client->read_buffer != NULL) { + free(client->read_buffer); + } close(client->fd); free(client); } @@ -262,16 +327,78 @@ ipc_client_handle_command(struct cg_ipc_client *client) { } offset = (nl_pos - client->read_buffer) + 1; } - if(offset == 0) { - wlr_log(WLR_ERROR, "Line received was longer that %d, discarding it", - MAX_LINE_SIZE); - client->read_buf_len = 0; - client->read_discard = 1; - return; - } if(offset < client->read_buf_len) { memmove(client->read_buffer, client->read_buffer + offset, client->read_buf_len - offset); } client->read_buf_len -= offset; } + +void +ipc_send_event_client(struct cg_ipc_client *client, const char *payload, + uint32_t payload_length) { + char data[IPC_HEADER_SIZE]; + + memcpy(data, ipc_magic, sizeof(ipc_magic)); + + // +1 for terminating null character + while(client->write_buffer_len + IPC_HEADER_SIZE + payload_length + 1 >= + client->write_buffer_size) { + client->write_buffer_size *= 2; + } + + if(client->write_buffer_size > 4e6) { // 4 MB + wlr_log(WLR_ERROR, + "Client write buffer too big (%zu), disconnecting client", + client->write_buffer_size); + ipc_client_disconnect(client); + return; + } + + char *new_buffer = realloc(client->write_buffer, client->write_buffer_size); + if(!new_buffer) { + wlr_log(WLR_ERROR, "Unable to reallocate ipc client write buffer"); + ipc_client_disconnect(client); + return; + } + client->write_buffer = new_buffer; + + memcpy(client->write_buffer + client->write_buffer_len, data, + IPC_HEADER_SIZE); + client->write_buffer_len += IPC_HEADER_SIZE; + memcpy(client->write_buffer + client->write_buffer_len, payload, + payload_length); + client->write_buffer_len += payload_length; + memcpy(client->write_buffer + client->write_buffer_len, "\0", 1); + client->write_buffer_len += 1; +} + +void +ipc_send_event(struct cg_server *server, const char *fmt, ...) { + if(server->enable_socket == false) { + return; + } + if(wl_list_empty(&server->ipc.client_list)) { + return; + } + va_list args; + va_start(args, fmt); + char *msg = malloc_vsprintf_va_list(fmt, args); + if(msg == NULL) { + wlr_log(WLR_ERROR, "Unable to allocate memory for ipc event"); + va_end(args); + return; + } + va_end(args); + struct cg_ipc_client *it, *tmp; + uint32_t len = strlen(msg); + wl_list_for_each_safe(it, tmp, &server->ipc.client_list, link) { + if(it->writable_event_source == NULL) { + it->writable_event_source = wl_event_loop_add_fd( + server->event_loop, it->fd, WL_EVENT_WRITABLE, + ipc_client_handle_writable, it); + } + ipc_send_event_client(it, msg, len); + } + free(msg); +} diff --git a/ipc_server.h b/ipc_server.h index 60339df..2c66b83 100644 --- a/ipc_server.h +++ b/ipc_server.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_IPC_SERVER_H #define CG_IPC_SERVER_H @@ -21,6 +24,7 @@ struct cg_ipc_client { char *write_buffer; // The following is for storing data between event_loop calls uint16_t read_buf_len; + size_t read_buf_cap; uint8_t read_discard; // 1 if the current line is to be discarded char *read_buffer; }; @@ -33,6 +37,8 @@ struct cg_ipc_handle { struct sockaddr_un *sockaddr; }; +void +ipc_send_event(struct cg_server *server, const char *fmt, ...); int ipc_init(struct cg_server *server); int diff --git a/keybinding.c b/keybinding.c index ec83acc..0c96d4b 100644 --- a/keybinding.c +++ b/keybinding.c @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #define _POSIX_C_SOURCE 200809L #include @@ -6,8 +9,12 @@ #include #include #include +#include +#include #include #include +#include +#include #include #include "input.h" @@ -17,9 +24,12 @@ #include "output.h" #include "seat.h" #include "server.h" +#include "util.h" #include "view.h" #include "workspace.h" +char *keybinding_action_string[] = {FOREACH_KEYBINDING(GENERATE_STRING)}; + int keybinding_resize(struct keybinding_list *list) { if(list->length == list->capacity) { @@ -82,6 +92,10 @@ keybinding_free(struct keybinding *keybinding, bool recursive) { free(keybinding->data.m_cfg->font); } break; + case KEYBINDING_DISPLAY_MESSAGE: + if(keybinding->data.c != NULL) { + free(keybinding->data.c); + } default: break; } @@ -132,56 +146,79 @@ keybinding_list_free(struct keybinding_list *list) { free(list); } +// Returns whether x is between a and b (a exclusive, b exclusive) where +// anext; - while(it != tile && it->tile.x != tile->tile.x + tile->tile.width) { + int center = tile->tile.y + tile->tile.height / 2; + while(it != tile) { + if(it->tile.x == tile->tile.x + tile->tile.width) { + if(is_between_strict(it->tile.y, it->tile.y + it->tile.height, + center) || + it->tile.y + it->tile.height == center) { + return it; + } + } it = it->next; } - if(it == tile) { - return NULL; - } else { - return it; - } + return NULL; } struct cg_tile * find_left_tile(const struct cg_tile *tile) { - struct cg_tile *it = tile->prev; - while(it != tile && it->tile.x + it->tile.width != tile->tile.x) { - it = it->prev; - } - if(it == tile) { - return NULL; - } else { - return it; + struct cg_tile *it = tile->next; + int center = tile->tile.y + tile->tile.height / 2; + while(it != tile) { + if(it->tile.x + it->tile.width == tile->tile.x) { + if(is_between_strict(it->tile.y, it->tile.y + it->tile.height, + center) || + it->tile.y + it->tile.height == center) { + return it; + } + } + it = it->next; } + return NULL; } struct cg_tile * find_top_tile(const struct cg_tile *tile) { - struct cg_tile *it = tile->prev; - while(it != tile && it->tile.y + it->tile.height != tile->tile.y) { - it = it->prev; - } - if(it == tile) { - return NULL; - } else { - return it; + struct cg_tile *it = tile->next; + int center = tile->tile.x + tile->tile.width / 2; + while(it != tile) { + if(it->tile.y + it->tile.height == tile->tile.y) { + if(is_between_strict(it->tile.x, it->tile.x + it->tile.width, + center) || + it->tile.x + it->tile.width == center) { + return it; + } + } + it = it->next; } + return NULL; } struct cg_tile * find_bottom_tile(const struct cg_tile *tile) { struct cg_tile *it = tile->next; - while(it != tile && it->tile.y != tile->tile.y + tile->tile.height) { + int center = tile->tile.x + tile->tile.width / 2; + while(it != tile) { + if(it->tile.y == tile->tile.y + tile->tile.height) { + if(is_between_strict(it->tile.x, it->tile.x + it->tile.width, + center) || + it->tile.x + it->tile.width == center) { + return it; + } + } it = it->next; } - if(it == tile) { - return NULL; - } else { - return it; - } + return NULL; } void @@ -193,26 +230,21 @@ swap_tile(struct cg_tile *tile, return; } struct cg_view *tmp_view = tile->view; - tile->view = swap_tile->view; - swap_tile->view = tmp_view; - if(tile->view != NULL) { - view_maximize(tile->view, tile); - view_damage_whole(tile->view); - } else { - wlr_output_damage_add_box(tile->workspace->output->damage, &tile->tile); - } + struct cg_view *tmp_swap_view = swap_tile->view; + workspace_tile_update_view(tile, NULL); + workspace_tile_update_view(swap_tile, tmp_view); + workspace_tile_update_view(tile, tmp_swap_view); workspace_focus_tile( server->curr_output->workspaces[server->curr_output->curr_workspace], swap_tile); - if(swap_tile->view != NULL) { - view_maximize(swap_tile->view, swap_tile); - view_damage_whole(swap_tile->view); - } else { - wlr_output_damage_add_box(tile->workspace->output->damage, - &swap_tile->tile); - } - seat_set_focus(server->seat, swap_tile->view); + ipc_send_event( + tile->workspace->output->server, + "{\"event_name\":\"swap_tile\",\"tile_id\":%d,\"swap_" + "tile_id\":%d,\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d}", + tile->id, swap_tile->id, tile->workspace->num + 1, + tile->workspace->output->wlr_output->name, + output_get_num(tile->workspace->output)); } void @@ -267,13 +299,6 @@ focus_tile_bottom(struct cg_tile *tile) { focus_tile(tile, find_bottom_tile); } -// Returns whether x is between a and b (a exclusive, b exclusive) where -// atile.x + tile->tile.y - *get_coord(tile); @@ -355,18 +380,23 @@ resize(struct cg_tile *tile, const struct cg_tile *parent, int coord_offset, } } - int old_x = tile->tile.x, old_y = tile->tile.y; + int old_x = tile->tile.x, old_y = tile->tile.y, + old_height = tile->tile.height, old_width = tile->tile.width; *get_coord(tile) += coord_offset; *get_dim(tile) += dim_offset; - struct wlr_box damage_box = { - .x = old_x, - .y = old_y, - .width = tile->tile.x - old_x == 0 ? tile->tile.width : coord_offset, - .height = tile->tile.y == 0 ? tile->tile.height : coord_offset}; - wlr_output_damage_add_box(tile->workspace->output->damage, &damage_box); + if(tile->view != NULL) { view_maximize(tile->view, tile); } + ipc_send_event(tile->workspace->output->server, + "{\"event_name\":\"resize_tile\",\"tile_id\":%d,\"old_" + "dims\":\"[%d,%d,%d,%d]\",\"new_dims\":\"[%d,%d,%d,%d]\"," + "\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d}", + tile->id, old_x, old_y, old_height, old_width, tile->tile.x, + tile->tile.y, tile->tile.height, tile->tile.width, + tile->workspace->num + 1, + tile->workspace->output->wlr_output->name, + output_get_num(tile->workspace->output)); } int * @@ -420,17 +450,18 @@ resize_vertical(struct cg_tile *tile, struct cg_tile *parent, int y_offset, void resize_tile(struct cg_server *server, int hpixs, int vpixs) { struct cg_output *output = server->curr_output; - struct wlr_box *output_box = wlr_output_layout_get_box( - output->server->output_layout, output->wlr_output); + struct wlr_box output_box; + wlr_output_layout_get_box(output->server->output_layout, output->wlr_output, + &output_box); struct cg_tile *focused = output->workspaces[output->curr_workspace]->focused_tile; /* First do the horizontal adjustment */ - if(hpixs != 0 && focused->tile.width < output_box->width && - is_between_strict(0, output_box->width, focused->tile.width + hpixs)) { + if(hpixs != 0 && focused->tile.width < output_box.width && + is_between_strict(0, output_box.width, focused->tile.width + hpixs)) { int x_offset = 0; /* In case we are on the total right, move the left edge of the tile */ - if(focused->tile.x + focused->tile.width == output_box->width) { + if(focused->tile.x + focused->tile.width == output_box.width) { x_offset = -hpixs; } bool resize_allowed = @@ -440,10 +471,10 @@ resize_tile(struct cg_server *server, int hpixs, int vpixs) { } } /* Repeat for vertical */ - if(vpixs != 0 && focused->tile.height < output_box->height && - is_between_strict(0, output_box->height, focused->tile.height + vpixs)) { + if(vpixs != 0 && focused->tile.height < output_box.height && + is_between_strict(0, output_box.height, focused->tile.height + vpixs)) { int y_offset = 0; - if(focused->tile.y + focused->tile.height == output_box->height) { + if(focused->tile.y + focused->tile.height == output_box.height) { y_offset = -vpixs; } bool resize_allowed = @@ -456,37 +487,15 @@ resize_tile(struct cg_server *server, int hpixs, int vpixs) { void keybinding_workspace_fullscreen(struct cg_server *server) { - struct cg_view *current_view = seat_get_focus(server->seat); + output_make_workspace_fullscreen(server->curr_output, + server->curr_output->curr_workspace); struct cg_output *output = server->curr_output; - - /* We are focused on the background */ - if(current_view == NULL) { - struct cg_view *it = NULL; - wl_list_for_each(it, &output->workspaces[output->curr_workspace]->views, - link) { - if(view_is_visible(it)) { - current_view = it; - break; - } - } - } - - workspace_free_tiles(output->workspaces[output->curr_workspace]); - if(full_screen_workspace_tiles( - server->output_layout, output->wlr_output, - output->workspaces[output->curr_workspace]) != 0) { - wlr_log(WLR_ERROR, "Failed to allocate space for fullscreen workspace"); - return; - } - - struct cg_view *it_view; - wl_list_for_each(it_view, - &output->workspaces[output->curr_workspace]->views, link) { - it_view->tile = - output->workspaces[output->curr_workspace]->focused_tile; - } - - seat_set_focus(server->seat, current_view); + ipc_send_event(server, + "{\"event_name\":\"fullscreen\",\"tile_id\":%d," + "\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d}", + output->workspaces[output->curr_workspace]->focused_tile->id, + output->workspaces[output->curr_workspace]->num + 1, + output->wlr_output->name, output_get_num(output)); } // Switch to a differerent virtual terminal @@ -551,13 +560,15 @@ keybinding_split_output(struct cg_output *output, bool vertical) { wlr_log(WLR_ERROR, "Failed to allocate new tile for splitting"); return; } + new_tile->id = output->server->tiles_curr_id; + ++output->server->tiles_curr_id; new_tile->tile.x = new_x; new_tile->tile.y = new_y; new_tile->tile.width = x + width - new_x; new_tile->tile.height = y + height - new_y; new_tile->prev = curr_workspace->focused_tile; new_tile->next = curr_workspace->focused_tile->next; - new_tile->view = next_view; + workspace_tile_update_view(new_tile, next_view); new_tile->workspace = curr_workspace; curr_workspace->focused_tile->next->prev = new_tile; curr_workspace->focused_tile->next = new_tile; @@ -573,6 +584,13 @@ keybinding_split_output(struct cg_output *output, bool vertical) { if(original_view != NULL) { view_maximize(original_view, curr_workspace->focused_tile); } + ipc_send_event( + output->server, + "{\"event_name\":\"split\",\"tile_id\":%d,\"new_tile_id\":%d," + "\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d,\"vertical\":%d}", + curr_workspace->focused_tile->id, new_tile->id, curr_workspace->num + 1, + curr_workspace->output->wlr_output->name, + output_get_num(curr_workspace->output), vertical); } static void @@ -580,7 +598,18 @@ keybinding_close_view(struct cg_view *view) { if(view == NULL) { return; } + struct cg_output *outp = view->workspace->output; + uint32_t view_id = view->id; + uint32_t view_pid = view->impl->get_pid(view); + uint32_t tile_id = view->id; + uint32_t ws = view->workspace->num; view->impl->close(view); + ipc_send_event( + outp->server, + "{\"event_name\":\"close\",\"view_id\":%d,\"view_pid\":%d,\"tile_id\":" + "%d,\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d}", + view_id, view_pid, tile_id, ws + 1, outp->wlr_output->name, + output_get_num(outp)); } static void @@ -610,8 +639,10 @@ set_output(struct cg_server *server, struct cg_output *output) { } void -keybinding_cycle_outputs(struct cg_server *server, bool reverse) { +keybinding_cycle_outputs(struct cg_server *server, bool reverse, + bool trigger_event) { struct cg_output *output = NULL; + struct cg_output *old_output = server->curr_output; if(reverse) { output = wl_container_of(server->curr_output->link.prev, server->curr_output, link); @@ -627,36 +658,38 @@ keybinding_cycle_outputs(struct cg_server *server, bool reverse) { } } set_output(server, output); + if(trigger_event) { + ipc_send_event( + output->server, + "{\"event_name\":\"cycle_outputs\",\"old_output\":\"%s\",\"old_" + "output_id\":%d," + "\"new_output\":\"%s\",\"new_output_id\":%d,\"reverse\":%d}", + old_output->wlr_output->name, output_get_num(old_output), + output->wlr_output->name, output_get_num(output), reverse); + } } /* Cycle through views, whereby the workspace does not change */ void -keybinding_cycle_views(struct cg_server *server, bool reverse) { +keybinding_cycle_views(struct cg_server *server, bool reverse, bool ipc) { struct cg_workspace *curr_workspace = server->curr_output->workspaces[server->curr_output->curr_workspace]; struct cg_view *current_view = curr_workspace->focused_tile->view; - if(current_view == NULL) { - current_view = - wl_container_of(&curr_workspace->views, current_view, link); - } struct cg_view *it_view, *next_view = NULL; if(reverse) { - next_view = view_get_prev_view(current_view); - } else { - struct wl_list *it; - it = current_view->link.next; - while(it != ¤t_view->link) { - if(it == &curr_workspace->views) { - it = it->next; - continue; - } - it_view = wl_container_of(it, it_view, link); + wl_list_for_each(it_view, &curr_workspace->views, link) { + if(!view_is_visible(it_view)) { + next_view = it_view; + break; + } + } + } else { + wl_list_for_each_reverse(it_view, &curr_workspace->views, link) { if(!view_is_visible(it_view)) { next_view = it_view; break; } - it = it->next; } } @@ -664,12 +697,50 @@ keybinding_cycle_views(struct cg_server *server, bool reverse) { return; } - wlr_output_damage_add_box(curr_workspace->output->damage, - &curr_workspace->focused_tile->tile); - /* Prevent seat_set_focus from reordering the views */ - curr_workspace->focused_tile->view = wl_container_of( - next_view->link.prev, curr_workspace->focused_tile->view, link); seat_set_focus(server->seat, next_view); + if(ipc) { + ipc_send_event( + curr_workspace->output->server, + "{\"event_name\":\"cycle_views\",\"old_view_id\":%d,\"old_view_" + "pid\":%d," + "\"new_view_id\":%d,\"new_view_pid\":%d,\"tile_id\":%d," + "\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d}", + current_view->link.next == curr_workspace->views.next + ? -1 + : (int)current_view->id, + current_view->link.next == curr_workspace->views.next + ? -1 + : (int)current_view->impl->get_pid(current_view), + next_view == NULL ? -1 : (int)next_view->id, + next_view == NULL ? -1 : (int)next_view->impl->get_pid(next_view), + next_view->tile->id, curr_workspace->num + 1, + curr_workspace->output->wlr_output->name, + output_get_num(curr_workspace->output)); + } +} + +void +keybinding_focus_tile(struct cg_server *server, uint32_t tile_id) { + struct cg_output *output = server->curr_output; + struct cg_workspace *workspace = output->workspaces[output->curr_workspace]; + struct cg_tile *old_tile = workspace->focused_tile; + bool first = true; + for(struct cg_tile *tile = workspace->focused_tile; + first || tile != workspace->focused_tile; tile = tile->next) { + first = false; + if(tile->id == tile_id) { + workspace_focus_tile(workspace, tile); + struct cg_view *next_view = workspace->focused_tile->view; + seat_set_focus(server->seat, next_view); + ipc_send_event( + output->server, + "{\"event_name\":\"focus_tile\",\"old_tile_id\":%d,\"new_tile_" + "id\":%d,\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d}", + old_tile->id, workspace->focused_tile->id, workspace->num + 1, + output->wlr_output->name, output_get_num(output)); + break; + } + } } void @@ -677,13 +748,10 @@ keybinding_cycle_tiles(struct cg_server *server, bool reverse) { struct cg_output *output = server->curr_output; struct cg_workspace *workspace = output->workspaces[output->curr_workspace]; if(reverse) { - workspace_focus_tile(workspace, workspace->focused_tile->prev); + keybinding_focus_tile(server, workspace->focused_tile->prev->id); } else { - workspace_focus_tile(workspace, workspace->focused_tile->next); + keybinding_focus_tile(server, workspace->focused_tile->next->id); } - struct cg_view *next_view = workspace->focused_tile->view; - - seat_set_focus(server->seat, next_view); } int @@ -695,11 +763,16 @@ keybinding_switch_ws(struct cg_server *server, uint32_t ws) { return -1; } struct cg_output *output = server->curr_output; - output->curr_workspace = ws; + uint32_t old_ws = server->curr_output->curr_workspace; + workspace_focus(output, ws); seat_set_focus(server->seat, server->curr_output->workspaces[ws]->focused_tile->view); - wlr_output_damage_add_whole(output->damage); message_printf(server->curr_output, "Workspace %d", ws + 1); + ipc_send_event(output->server, + "{\"event_name\":\"switch_ws\",\"old_workspace\":%d," + "\"new_workspace\":%d,\"output\":\"%s\",\"output_id\":%d}", + old_ws + 1, ws + 1, output->wlr_output->name, + output_get_num(output)); return 0; } @@ -717,6 +790,430 @@ keybinding_show_time(struct cg_server *server) { free(msg); } +struct dyn_str { + uint32_t len; + uint32_t cur_pos; + char **str_arr; +}; + +/*Note that inp is in an invalid state after calling the function * and should + * no longer be used.*/ +char * +dyn_str_to_str(struct dyn_str *inp) { + char *outp = calloc(inp->len + 1, sizeof(char)); + if(outp == NULL) { + return NULL; + } + outp[inp->len] = '\0'; + uint32_t tmp_pos = 0; + for(uint32_t i = 0; i < inp->cur_pos; ++i) { + strcat(outp + tmp_pos, inp->str_arr[i]); + tmp_pos += strlen(inp->str_arr[i]); + free(inp->str_arr[i]); + } + free(inp->str_arr); + return outp; +} + +int +print_str(struct dyn_str *outp, const char *fmt, ...) { + va_list args; + va_start(args, fmt); + char *ret = malloc_vsprintf_va_list(fmt, args); + if(ret == NULL) { + return -1; + } + outp->str_arr[outp->cur_pos] = ret; + ++outp->cur_pos; + outp->len += strlen(ret); + return 0; +} + +void +print_modes(struct dyn_str *str, char **modes) { + uint32_t len = 0; + char **tmp = modes; + uint32_t nmemb = 0; + while(*tmp != NULL) { + len += strlen(*tmp); + ++nmemb; + ++tmp; + } + if(nmemb == 0) { + wlr_log(WLR_ERROR, + "This is a bug: Cagebreak has no valid modes. This should not " + "occur, since default modes are defined on startup."); + return; + } + /* We are assuming here that we have at least one mode, which is given by + * the initialization of cagebreak */ + char *modes_str = calloc(len + 3 * (nmemb - 1) + 1, sizeof(char)); + modes_str[len + nmemb - 1] = '\0'; + uint32_t tmp_pos = 0; + for(uint32_t i = 0; i < nmemb; ++i) { + if(i != 0) { + strcat(modes_str + tmp_pos, "\",\""); + tmp_pos += 3; + } + strcat(modes_str + tmp_pos, modes[i]); + tmp_pos += strlen(modes[i]); + } + print_str(str, "\"modes\":[\"%s\"],\n", modes_str); + free(modes_str); +} + +char * +print_view(struct cg_view *view) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t nmemb = 4; + outp_str.str_arr = calloc(nmemb, sizeof(char *)); + print_str(&outp_str, "\"id\": %d,\n", view->id); + print_str(&outp_str, "\"pid\": %d,\n", view->impl->get_pid(view)); + print_str(&outp_str, "\"coords\": {\"x\":%d,\"y\":%d},\n", view->ox, + view->oy); +#if CG_HAS_XWAYLAND + print_str(&outp_str, "\"type\": \"%s\"\n", + view->type == CG_XWAYLAND_VIEW ? "xwayland" : "xdg"); +#else + print_str(&outp_str, "\"type\": \"xdg\"\n"); +#endif + return dyn_str_to_str(&outp_str); +} + +char * +print_tile(struct cg_tile *tile) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t nmemb = 4; + outp_str.str_arr = calloc(nmemb, sizeof(char *)); + print_str(&outp_str, "\"id\": %d,\n", tile->id); + print_str(&outp_str, "\"coords\": {\"x\":%d,\"y\":%d},\n", tile->tile.x, + tile->tile.y); + print_str(&outp_str, "\"size\": {\"width\":%d,\"height\":%d},\n", + tile->tile.width, tile->tile.height); + print_str(&outp_str, "\"view_id\": %d\n", + tile->view == NULL ? -1 : (int)tile->view->id); + return dyn_str_to_str(&outp_str); +} + +char * +print_views(struct cg_workspace *ws) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t nviews = wl_list_length(&ws->views); + if(nviews == 0) { + return strdup("{}"); + } + outp_str.str_arr = calloc(2 * nviews - 1, sizeof(char *)); + struct cg_view *it; + uint32_t count = 0; + wl_list_for_each(it, &ws->views, link) { + if(count != 0) { + print_str(&outp_str, ","); + } + ++count; + char *view_str = print_view(it); + if(view_str != NULL) { + print_str(&outp_str, "{\n%s\n}", view_str); + free(view_str); + } + } + return dyn_str_to_str(&outp_str); +} + +char * +print_tiles(struct cg_workspace *ws) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t ntiles = 0; + bool first = true; + for(struct cg_tile *tile = ws->focused_tile; + first || tile != ws->focused_tile; tile = tile->next) { + first = false; + ++ntiles; + } + if(ntiles == 0) { + return strdup("{}"); + } + outp_str.str_arr = calloc(2 * ntiles - 1, sizeof(char *)); + first = true; + for(struct cg_tile *tile = ws->focused_tile; + first || tile != ws->focused_tile; tile = tile->next) { + if(first == false) { + print_str(&outp_str, ","); + } + first = false; + char *tile_str = print_tile(tile); + if(tile_str != NULL) { + print_str(&outp_str, "{\n%s\n}", tile_str); + free(tile_str); + } + } + return dyn_str_to_str(&outp_str); +} + +char * +print_workspace(struct cg_workspace *ws) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t nmemb = 6; + outp_str.str_arr = calloc(nmemb, sizeof(char *)); + print_str(&outp_str, "\"views\": ["); + char *views_str = print_views(ws); + if(views_str != NULL) { + print_str(&outp_str, "%s", views_str); + free(views_str); + } + print_str(&outp_str, "],"); + print_str(&outp_str, "\"tiles\": ["); + char *tiles_str = print_tiles(ws); + if(tiles_str != NULL) { + print_str(&outp_str, "%s", tiles_str); + free(tiles_str); + } + print_str(&outp_str, "]"); + return dyn_str_to_str(&outp_str); +} + +char * +print_workspaces(struct cg_output *outp) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + outp_str.str_arr = calloc((2 * outp->server->nws - 1) + 2, sizeof(char *)); + print_str(&outp_str, "\"workspaces\": ["); + for(int i = 0; i < outp->server->nws; ++i) { + if(i != 0) { + print_str(&outp_str, ","); + } + char *ws = print_workspace(outp->workspaces[i]); + if(ws != NULL) { + print_str(&outp_str, "{%s}", ws); + free(ws); + } + } + print_str(&outp_str, "]\n"); + return dyn_str_to_str(&outp_str); +} + +char * +print_output(struct cg_output *outp) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t nmemb = 8; + struct wlr_box outp_box; + wlr_output_layout_get_box(outp->server->output_layout, outp->wlr_output, + &outp_box); + outp_str.str_arr = calloc(nmemb, sizeof(char *)); + print_str(&outp_str, "\"%s\": {\n", outp->wlr_output->name); + print_str(&outp_str, "\"priority\": %d,\n", outp->priority); + print_str(&outp_str, "\"coords\": {\"x\":%d,\"y\":%d},\n", outp_box.x, + outp_box.y); + print_str(&outp_str, "\"size\": {\"width\":%d,\"height\":%d},\n", + outp->wlr_output->width, outp->wlr_output->height); + print_str(&outp_str, "\"refresh_rate\": %f,\n", + (float)outp->wlr_output->refresh / 1000.0); + print_str(&outp_str, "\"curr_workspace\": %d,\n", outp->curr_workspace + 1); + char *workspaces_str = print_workspaces(outp); + if(workspaces_str != NULL) { + print_str(&outp_str, "%s", workspaces_str); + free(workspaces_str); + } + print_str(&outp_str, "}"); + return dyn_str_to_str(&outp_str); +} + +char * +print_outputs(struct cg_server *server) { + uint32_t noutps = wl_list_length(&server->outputs); + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + outp_str.str_arr = calloc((2 * noutps - 1) + 2, sizeof(char *)); + print_str(&outp_str, "\"outputs\": {"); + struct cg_output *it; + uint32_t count = 0; + wl_list_for_each(it, &server->outputs, link) { + if(count != 0) { + print_str(&outp_str, ","); + } + ++count; + char *outp = print_output(it); + if(outp == NULL) { + continue; + } + print_str(&outp_str, "%s", outp); + free(outp); + } + print_str(&outp_str, "}\n"); + return dyn_str_to_str(&outp_str); +} + +char * +print_keyboard_group(struct cg_keyboard_group *grp) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t nmemb = 5; + outp_str.str_arr = calloc(nmemb, sizeof(char *)); + if(grp->identifier != NULL) { + print_str(&outp_str, "\"%s\": {\n", grp->identifier); + } else { + print_str(&outp_str, "\"NULL\": {\n"); + } + print_str(&outp_str, "\"commands_enabled\": %d,\n", + grp->enable_keybindings); + print_str(&outp_str, "\"repeat_delay\": %d,\n", + grp->wlr_group->keyboard.repeat_info.delay); + print_str(&outp_str, "\"repeat_rate\": %d\n", + grp->wlr_group->keyboard.repeat_info.rate); + print_str(&outp_str, "}"); + return dyn_str_to_str(&outp_str); +} + +char * +print_keyboard_groups(struct cg_server *server) { + uint32_t ninps = wl_list_length(&server->seat->keyboard_groups); + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + outp_str.str_arr = calloc((2 * ninps - 1) + 3, sizeof(char *)); + print_str(&outp_str, "\"keyboards\": {"); + struct cg_keyboard_group *it; + uint32_t count = 0; + wl_list_for_each(it, &server->seat->keyboard_groups, link) { + if(count != 0) { + print_str(&outp_str, ","); + } + ++count; + char *outp = print_keyboard_group(it); + if(outp == NULL) { + continue; + } + print_str(&outp_str, "%s", outp); + free(outp); + } + print_str(&outp_str, "}\n"); + return dyn_str_to_str(&outp_str); +} + +char * +print_input_device(struct cg_input_device *dev) { + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + uint32_t nmemb = 4; + outp_str.str_arr = calloc(nmemb, sizeof(char *)); + if(dev->identifier != NULL) { + print_str(&outp_str, "\"%s\": {\n", dev->identifier); + } else { + print_str(&outp_str, "\"NULL\": {\n"); + } + print_str(&outp_str, "\"is_virtual\": %d,\n", dev->is_virtual); + print_str( + &outp_str, "\"type\": \"%s\"\n", + dev->wlr_device->type == WLR_INPUT_DEVICE_POINTER ? "pointer" + : dev->wlr_device->type == WLR_INPUT_DEVICE_SWITCH ? "switch" + : dev->wlr_device->type == WLR_INPUT_DEVICE_TABLET_PAD ? "tablet pad" + : dev->wlr_device->type == WLR_INPUT_DEVICE_TABLET_TOOL ? "tablet tool" + : dev->wlr_device->type == WLR_INPUT_DEVICE_TOUCH ? "touch" + : dev->wlr_device->type == WLR_INPUT_DEVICE_KEYBOARD ? "keyboard" + : "unknown"); + print_str(&outp_str, "}"); + return dyn_str_to_str(&outp_str); +} + +char * +print_input_devices(struct cg_server *server) { + uint32_t ninps = wl_list_length(&server->input->devices); + struct dyn_str outp_str; + outp_str.len = 0; + outp_str.cur_pos = 0; + outp_str.str_arr = calloc((2 * ninps - 1) + 3, sizeof(char *)); + print_str(&outp_str, "\"input_devices\": {"); + struct cg_input_device *it; + uint32_t count = 0; + wl_list_for_each(it, &server->input->devices, link) { + if(count != 0) { + print_str(&outp_str, ","); + } + ++count; + char *outp = print_input_device(it); + if(outp == NULL) { + continue; + } + print_str(&outp_str, "%s", outp); + free(outp); + } + print_str(&outp_str, "}\n"); + return dyn_str_to_str(&outp_str); +} + +char * +get_mode_name(char **modes, unsigned int mode_nr) { + unsigned int i; + for(i = 0; i < mode_nr && modes[i] != NULL; ++i) { + } + if(modes[i] != NULL) { + return modes[i]; + } else { + return "NULL"; + } +} + +void +keybinding_dump(struct cg_server *server) { + struct dyn_str str; + str.len = 0; + str.cur_pos = 0; + uint32_t nmemb = 13; + str.str_arr = calloc(nmemb, sizeof(char *)); + + print_str(&str, "{\"event_name\":\"dump\","); + print_str(&str, "\"nws\":%d,\n", server->nws); + print_str(&str, "\"bg_color\":[%f,%f,%f],\n", server->bg_color[0], + server->bg_color[1], server->bg_color[2]); + print_str(&str, "\"views_curr_id\":%d,\n", server->views_curr_id); + print_str(&str, "\"tiles_curr_id\":%d,\n", server->tiles_curr_id); + print_str(&str, "\"curr_output\":\"%s\",\n", + server->curr_output->wlr_output->name); + print_str(&str, "\"default_mode\":\"%s\",\n", + get_mode_name(server->modes, server->seat->default_mode)); + print_modes(&str, server->modes); + char *outps_str = print_outputs(server); + if(outps_str != NULL) { + print_str(&str, "%s,", outps_str); + free(outps_str); + } + char *keyboards_str = print_keyboard_groups(server); + if(keyboards_str != NULL) { + print_str(&str, "%s,", keyboards_str); + free(keyboards_str); + } + char *input_dev_str = print_input_devices(server); + if(input_dev_str != NULL) { + print_str(&str, "%s,", input_dev_str); + free(input_dev_str); + } + print_str(&str, "\"cursor_coords\":{\"x\":%f,\"y\":%f}\n", + server->seat->cursor->x, server->seat->cursor->y); + print_str(&str, "}"); + + char *send_str = dyn_str_to_str(&str); + if(send_str == NULL) { + wlr_log(WLR_ERROR, "Unable to create output string for \"dump\"."); + } + ipc_send_event(server, send_str); + free(send_str); +} + void keybinding_show_info(struct cg_server *server) { char *msg = server_show_info(server); @@ -739,6 +1236,7 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) { if(wl_list_length(&server->outputs) <= 1) { return; } + struct cg_output *old_outp = server->curr_output; struct cg_view *view = server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view; @@ -746,34 +1244,49 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) { wl_list_remove(&view->link); server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view = NULL; - keybinding_cycle_views(server, false); - view_damage_whole(view); + keybinding_cycle_views(server, false, false); if(server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view == NULL) { seat_set_focus(server->seat, NULL); } } - keybinding_cycle_outputs(server, false); + keybinding_cycle_outputs(server, reverse, false); if(view != NULL) { - wl_list_insert(&server->curr_output - ->workspaces[server->curr_output->curr_workspace] - ->views, - &view->link); - server->curr_output->workspaces[server->curr_output->curr_workspace] - ->focused_tile->view = view; - view->workspace = server->curr_output - ->workspaces[server->curr_output->curr_workspace]; - view->tile = view->workspace->focused_tile; - view_maximize(view, view->tile); + struct cg_workspace *ws = + server->curr_output + ->workspaces[server->curr_output->curr_workspace]; + wl_list_insert(&ws->views, &view->link); + wlr_scene_node_reparent(&view->scene_tree->node, ws->scene); + workspace_tile_update_view(ws->focused_tile, view); + view->workspace = ws; seat_set_focus(server->seat, view); } + int id = -1; + int pid = -1; + if(view != NULL) { + id = view->id; + pid = view->impl->get_pid(view); + } + ipc_send_event( + server, + "{\"event_name\":\"move_view_to_cycle_output\",\"view_id\":%d,\"view_" + "pid\":%d,\"old_output\":\"%s\",\"old_output_id\":%d,\"new_output\":\"%" + "s\",\"new_output_id\":%d,\"old_tile_id\":%d,\"new_tile_id\":%d}", + id, pid, old_outp->wlr_output->name, output_get_num(old_outp), + server->curr_output->wlr_output->name, + output_get_num(server->curr_output), + old_outp->workspaces[old_outp->curr_workspace]->focused_tile->id, + server->curr_output->workspaces[server->curr_output->curr_workspace] + ->focused_tile->id); } void keybinding_set_nws(struct cg_server *server, int nws) { struct cg_output *output; + unsigned int old_nws = server->nws; + server->nws = nws; wl_list_for_each(output, &server->outputs, link) { - for(unsigned int i = nws; i < server->nws; ++i) { + for(unsigned int i = nws; i < old_nws; ++i) { struct cg_view *view, *tmp; wl_list_for_each_safe(view, tmp, &output->workspaces[i]->views, link) { @@ -798,8 +1311,9 @@ keybinding_set_nws(struct cg_server *server, int nws) { return; } output->workspaces = new_workspaces; - for(int i = server->nws; i < nws; ++i) { + for(int i = old_nws; i < nws; ++i) { output->workspaces[i] = full_screen_workspace(output); + output->workspaces[i]->num = i; if(!output->workspaces[i]) { wlr_log(WLR_ERROR, "Failed to allocate additional workspaces"); return; @@ -810,14 +1324,17 @@ keybinding_set_nws(struct cg_server *server, int nws) { } if(output->curr_workspace >= nws) { - output->curr_workspace = nws - 1; + output->curr_workspace = 0; + workspace_focus(output, nws - 1); } } - server->nws = nws; seat_set_focus( server->seat, server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view); + ipc_send_event(server, + "{\"event_name\":\"set_nws\",\"old_nws\":%d,\"new_nws\":%d}", + old_nws, server->nws); } void @@ -834,27 +1351,53 @@ keybinding_definemode(struct cg_server *server, char *mode) { server->modes[length] = NULL; server->modes[length - 1] = strdup(mode); + ipc_send_event(server, "{\"event_name\":\"definemode\",\"mode\":\"%s\"}", + mode); } void keybinding_definekey(struct cg_server *server, struct keybinding *kb) { keybinding_list_push(server->keybindings, kb); + ipc_send_event(server, + "{\"event_name\":\"definekey\",\"modifiers\":%d,\"key\":" + "%d,\"command\":\"%s\"}", + kb->modifiers, kb->key, + keybinding_action_string[kb->action]); } void keybinding_set_background(struct cg_server *server, float *bg) { + ipc_send_event(server, + "{\"event_name\":\"background\",\"old_bg\":[%f,%f,%f]," + "\"new_bg\":[%f,%f,%f]}", + server->bg_color[0], server->bg_color[1], + server->bg_color[2], bg[0], bg[1], bg[2]); server->bg_color[0] = bg[0]; server->bg_color[1] = bg[1]; server->bg_color[2] = bg[2]; + struct cg_output *it = NULL; + wl_list_for_each(it, &server->outputs, link) { + wlr_scene_rect_set_color(it->bg, server->bg_color); + } + wl_list_for_each(it, &server->disabled_outputs, link) { + wlr_scene_rect_set_color(it->bg, server->bg_color); + } } void keybinding_switch_output(struct cg_server *server, int output) { + struct cg_output *old_outp = server->curr_output; struct cg_output *it; int count = 1; wl_list_for_each(it, &server->outputs, link) { if(count == output) { set_output(server, it); + ipc_send_event(server, + "{\"event_name\":\"switch_output\",\"old_output\":" + "\"%s\",\"old_output_id\":%d,\"new_output\":\"%s\"," + "\"new_output_id\":%d}", + old_outp->wlr_output->name, output_get_num(old_outp), + it->wlr_output->name, output_get_num(it)); return; } ++count; @@ -865,14 +1408,17 @@ keybinding_switch_output(struct cg_server *server, int output) { void keybinding_move_view_to_output(struct cg_server *server, int output_num) { + struct cg_output *old_outp = server->curr_output; struct cg_view *view = server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view; if(view != NULL) { + workspace_tile_update_view( + server->curr_output->workspaces[server->curr_output->curr_workspace] + ->focused_tile, + NULL); wl_list_remove(&view->link); - server->curr_output->workspaces[server->curr_output->curr_workspace] - ->focused_tile->view = NULL; - keybinding_cycle_views(server, false); + keybinding_cycle_views(server, false, false); if(server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view == NULL) { seat_set_focus(server->seat, NULL); @@ -885,14 +1431,25 @@ keybinding_move_view_to_output(struct cg_server *server, int output_num) { ->workspaces[server->curr_output->curr_workspace]; view->workspace = ws; wl_list_insert(&ws->views, &view->link); - ws->focused_tile->view = view; - view_maximize(view, ws->focused_tile); + wlr_scene_node_reparent(&view->scene_tree->node, ws->scene); + workspace_tile_update_view(ws->focused_tile, view); seat_set_focus(server->seat, view); } + int view_id = -1; + if(view != NULL) { + view_id = view->id; + } + ipc_send_event( + server, + "{\"event_name\":\"move_view_to_output\",\"view_id\":%d,\"old_" + "output\":\"%s\",\"new_output\":\"%s\"}", + view_id, old_outp->wlr_output->name, + server->curr_output->wlr_output->name); } void keybinding_move_view_to_workspace(struct cg_server *server, uint32_t ws) { + uint32_t old_ws = server->curr_output->curr_workspace; struct cg_view *view = server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view; @@ -900,7 +1457,7 @@ keybinding_move_view_to_workspace(struct cg_server *server, uint32_t ws) { wl_list_remove(&view->link); server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view = NULL; - keybinding_cycle_views(server, false); + keybinding_cycle_views(server, false, false); if(server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view == NULL) { seat_set_focus(server->seat, NULL); @@ -913,10 +1470,18 @@ keybinding_move_view_to_workspace(struct cg_server *server, uint32_t ws) { ->workspaces[server->curr_output->curr_workspace]; view->workspace = ws; wl_list_insert(&ws->views, &view->link); - ws->focused_tile->view = view; - view_maximize(view, ws->focused_tile); + wlr_scene_node_reparent(&view->scene_tree->node, ws->scene); + workspace_tile_update_view(ws->focused_tile, view); seat_set_focus(server->seat, view); } + ipc_send_event(server, + "{\"event_name\":\"move_view_to_ws\",\"view_id\":%d," + "\"old_workspace\":%d,\"new_workspace\":%d," + "\"output\":\"%s\",\"output_id\":%d,\"view_pid\":%d}", + view == NULL ? -1 : (int)view->id, old_ws + 1, ws + 1, + server->curr_output->wlr_output->name, + output_get_num(server->curr_output), + view == NULL ? 0 : view->impl->get_pid(view)); } void @@ -965,12 +1530,20 @@ keybinding_configure_output(struct cg_server *server, wl_list_for_each_safe(output, tmp_output, &server->outputs, link) { if(strcmp(config->output_name, output->wlr_output->name) == 0) { output_configure(server, output); + ipc_send_event(output->server, + "{\"event_name\":\"configure_output\",\"output\":\"%" + "s\",\"output_id\":%d}", + cfg->output_name, output_get_num(output)); return; } } wl_list_for_each_safe(output, tmp_output, &server->disabled_outputs, link) { if(strcmp(config->output_name, output->wlr_output->name) == 0) { output_configure(server, output); + ipc_send_event( + output->server, + "{\"event_name\":\"configure_output\",\"output\":\"%s\"}", + cfg->output_name); return; } } @@ -979,7 +1552,24 @@ keybinding_configure_output(struct cg_server *server, void keybinding_configure_input(struct cg_server *server, struct cg_input_config *cfg) { - cg_input_apply_config(cfg, server); + struct cg_input_config *tcfg = input_manager_create_empty_input_config(); + if(tcfg == NULL) { + wlr_log(WLR_ERROR, + "Could not allocate temporary empty input configuration."); + return; + } + struct cg_input_config *ocfg = input_manager_merge_input_configs(cfg, tcfg); + free(tcfg); + if(ocfg == NULL) { + wlr_log(WLR_ERROR, + "Could not allocate input configuration for merging."); + return; + } + wl_list_insert(&server->input_config, &ocfg->link); + cg_input_manager_configure(server); + ipc_send_event(server, + "{\"event_name\":\"configure_input\",\"input\":\"%s\"}", + cfg->identifier); } void @@ -1004,11 +1594,20 @@ keybinding_configure_message(struct cg_server *server, server->message_config.fg_color[2] = config->fg_color[2]; server->message_config.fg_color[3] = config->fg_color[3]; } + ipc_send_event(server, "{\"event_name\":\"configure_message\"}"); } void -keybinding_configure_input_dev(struct cg_server *server, - struct cg_input_config *cfg) {} +set_cursor(bool enabled, struct cg_seat *seat) { + if(enabled == true) { + seat->enable_cursor = true; + wlr_xcursor_manager_set_cursor_image(seat->xcursor_manager, + DEFAULT_XCURSOR, seat->cursor); + } else { + seat->enable_cursor = false; + wlr_cursor_set_image(seat->cursor, NULL, 0, 0, 0, 0, 0, 0); + } +} /* Hint: see keybinding.h for details on "data" */ int @@ -1017,9 +1616,13 @@ run_action(enum keybinding_action action, struct cg_server *server, switch(action) { case KEYBINDING_QUIT: display_terminate(server); + server->running = false; break; case KEYBINDING_CHANGE_TTY: return keybinding_switch_vt(server->backend, data.u); + case KEYBINDING_CURSOR: + set_cursor(data.i, server->seat); + break; case KEYBINDING_LAYOUT_FULLSCREEN: keybinding_workspace_fullscreen(server); break; @@ -1041,13 +1644,13 @@ run_action(enum keybinding_action action, struct cg_server *server, } } break; case KEYBINDING_CYCLE_VIEWS: - keybinding_cycle_views(server, data.b); + keybinding_cycle_views(server, data.b, true); break; case KEYBINDING_CYCLE_TILES: keybinding_cycle_tiles(server, data.b); break; case KEYBINDING_CYCLE_OUTPUT: - keybinding_cycle_outputs(server, data.b); + keybinding_cycle_outputs(server, data.b, true); break; case KEYBINDING_SWITCH_WORKSPACE: keybinding_switch_ws(server, data.u); @@ -1056,9 +1659,22 @@ run_action(enum keybinding_action action, struct cg_server *server, keybinding_switch_output(server, data.u); break; case KEYBINDING_SWITCH_MODE: + if(data.u != server->seat->default_mode) { + wlr_seat_pointer_notify_clear_focus(server->seat->seat); + if(server->seat->enable_cursor == true) { + wlr_xcursor_manager_set_cursor_image( + server->seat->xcursor_manager, "dot_box_mask", + server->seat->cursor); + } + } server->seat->mode = data.u; break; case KEYBINDING_SWITCH_DEFAULT_MODE: + ipc_send_event(server, + "{\"event_name\":\"switch_default_mode\",\"old_mode\":" + "\"%s\",\"mode\":\"%s\"}", + get_mode_name(server->modes, server->seat->default_mode), + get_mode_name(server->modes, data.u)); server->seat->mode = data.u; server->seat->default_mode = data.u; break; @@ -1067,6 +1683,9 @@ run_action(enum keybinding_action action, struct cg_server *server, case KEYBINDING_SHOW_TIME: keybinding_show_time(server); break; + case KEYBINDING_DUMP: + keybinding_dump(server); + break; case KEYBINDING_SHOW_INFO: keybinding_show_info(server); break; @@ -1165,6 +1784,9 @@ run_action(enum keybinding_action action, struct cg_server *server, server->curr_output->workspaces[server->curr_output->curr_workspace] ->focused_tile->view); break; + case KEYBINDING_FOCUS_TILE: + keybinding_focus_tile(server, data.u); + break; default: { wlr_log(WLR_ERROR, "run_action was called with a value not present in \"enum " diff --git a/keybinding.h b/keybinding.h index ebbfae9..872f12d 100644 --- a/keybinding.h +++ b/keybinding.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef KEYBINDING_H #define KEYBINDING_H @@ -10,57 +13,87 @@ struct cg_server; +#define FOREACH_KEYBINDING(KEYBINDING) \ + KEYBINDING(KEYBINDING_RUN_COMMAND, \ + exec) /* data.c is the string to execute */ \ + KEYBINDING(KEYBINDING_CLOSE_VIEW, close) \ + KEYBINDING(KEYBINDING_SPLIT_VERTICAL, vsplit) \ + KEYBINDING(KEYBINDING_SPLIT_HORIZONTAL, hsplit) \ + KEYBINDING(KEYBINDING_CHANGE_TTY, switchvt) /*data.u is the desired tty*/ \ + KEYBINDING(KEYBINDING_LAYOUT_FULLSCREEN, only) \ + KEYBINDING(KEYBINDING_CYCLE_VIEWS, \ + cycle_views) /* data.b is 0 if forward, 1 if reverse */ \ + KEYBINDING(KEYBINDING_CYCLE_TILES, \ + cycle_tiles) /* data.b is 0 if forward, 1 if reverse */ \ + KEYBINDING(KEYBINDING_CYCLE_OUTPUT, \ + cycle_outputs) /* data.b is 0 if forward, 1 if reverse */ \ + KEYBINDING(KEYBINDING_CONFIGURE_OUTPUT, \ + output) /* data.o_cfg is the desired output */ \ + \ + KEYBINDING(KEYBINDING_CONFIGURE_MESSAGE, \ + configure_message) /* data.m_cfg is the desired config */ \ + KEYBINDING(KEYBINDING_CONFIGURE_INPUT, \ + input) /* data.i_cfg is the desired input configuration */ \ + \ + KEYBINDING(KEYBINDING_QUIT, quit) \ + KEYBINDING(KEYBINDING_NOOP, abort) \ + KEYBINDING(KEYBINDING_SWITCH_OUTPUT, \ + screen) /* data.u is the desired output */ \ + KEYBINDING(KEYBINDING_SWITCH_WORKSPACE, \ + workspace) /* data.u is the desired workspace */ \ + KEYBINDING(KEYBINDING_SWITCH_MODE, mode) /* data.u is the desired mode */ \ + KEYBINDING(KEYBINDING_SWITCH_DEFAULT_MODE, \ + setmode) /* data.u is the desired mode */ \ + KEYBINDING( \ + KEYBINDING_RESIZE_TILE_HORIZONTAL, \ + resize_tile_horizontal) /* data.i is the number of pixels to add */ \ + \ + KEYBINDING( \ + KEYBINDING_RESIZE_TILE_VERTICAL, \ + resize_tile_vertical) /* data.i is the number of pixels to add to */ \ + \ + KEYBINDING(KEYBINDING_MOVE_VIEW_TO_WORKSPACE, \ + movetoworkspace) /* data.u is the desired workspace */ \ + KEYBINDING(KEYBINDING_MOVE_VIEW_TO_OUTPUT, \ + movetoscreen) /* data.u is the desired output */ \ + KEYBINDING(KEYBINDING_MOVE_VIEW_TO_CYCLE_OUTPUT, \ + move_view_to_cycle_output) /* data.b is 0 if forward, 1 if */ \ + \ + KEYBINDING(KEYBINDING_DUMP, dump) \ + KEYBINDING(KEYBINDING_SHOW_TIME, time) \ + KEYBINDING(KEYBINDING_SHOW_INFO, show_info) \ + KEYBINDING(KEYBINDING_DISPLAY_MESSAGE, message) \ + KEYBINDING(KEYBINDING_CURSOR, cursor) \ + \ + KEYBINDING(KEYBINDING_SWAP_LEFT, exchangeleft) \ + KEYBINDING(KEYBINDING_SWAP_RIGHT, exchangeright) \ + KEYBINDING(KEYBINDING_SWAP_TOP, exchangeup) \ + KEYBINDING(KEYBINDING_SWAP_BOTTOM, exchangedown) \ + \ + KEYBINDING(KEYBINDING_FOCUS_LEFT, focusleft) \ + KEYBINDING(KEYBINDING_FOCUS_RIGHT, focusright) \ + KEYBINDING(KEYBINDING_FOCUS_TOP, focusup) \ + KEYBINDING(KEYBINDING_FOCUS_BOTTOM, focusdown) \ + KEYBINDING(KEYBINDING_FOCUS_TILE, focus_tile) \ + \ + KEYBINDING(KEYBINDING_DEFINEKEY, \ + definekey) /* data.kb is the keybinding definition */ \ + KEYBINDING(KEYBINDING_BACKGROUND, \ + background) /* data.color is the background color */ \ + KEYBINDING(KEYBINDING_DEFINEMODE, \ + definemode) /* data.c is the mode name */ \ + KEYBINDING(KEYBINDING_WORKSPACES, \ + workspaces) /* data.i is the number of workspaces */ + +#define GENERATE_ENUM(ENUM, NAME) ENUM, +#define GENERATE_STRING(STRING, NAME) #NAME, + /* Important: if you add a keybinding which uses data.c or requires "free" * to be called, don't forget to add it to the function "keybinding_list_free" * in keybinding.c */ -enum keybinding_action { - KEYBINDING_RUN_COMMAND, // data.c is the string to execute - KEYBINDING_CLOSE_VIEW, - KEYBINDING_SPLIT_VERTICAL, - KEYBINDING_SPLIT_HORIZONTAL, - KEYBINDING_CHANGE_TTY, // data.u is the desired tty - KEYBINDING_LAYOUT_FULLSCREEN, - KEYBINDING_CYCLE_VIEWS, // data.b is 0 if forward, 1 if reverse - KEYBINDING_CYCLE_TILES, // data.b is 0 if forward, 1 if reverse - KEYBINDING_CYCLE_OUTPUT, // data.b is 0 if forward, 1 if reverse - KEYBINDING_CONFIGURE_OUTPUT, // data.o_cfg is the desired output - // configuration - KEYBINDING_CONFIGURE_MESSAGE, // data.m_cfg is the desired config - KEYBINDING_CONFIGURE_INPUT, // data.i_cfg is the desired input - // configuration - KEYBINDING_QUIT, - KEYBINDING_NOOP, - KEYBINDING_SWITCH_OUTPUT, // data.u is the desired output - KEYBINDING_SWITCH_WORKSPACE, // data.u is the desired workspace - KEYBINDING_SWITCH_MODE, // data.u is the desired mode - KEYBINDING_SWITCH_DEFAULT_MODE, // data.u is the desired mode - KEYBINDING_RESIZE_TILE_HORIZONTAL, // data.i is the number of pixels to add - // to the current width - KEYBINDING_RESIZE_TILE_VERTICAL, // data.i is the number of pixels to add to - // the current height - KEYBINDING_MOVE_VIEW_TO_WORKSPACE, // data.u is the desired workspace - KEYBINDING_MOVE_VIEW_TO_OUTPUT, // data.u is the desired output - KEYBINDING_MOVE_VIEW_TO_CYCLE_OUTPUT, // data.b is 0 if forward, 1 if - // reverse - KEYBINDING_SHOW_TIME, - KEYBINDING_SHOW_INFO, - KEYBINDING_DISPLAY_MESSAGE, +enum keybinding_action { FOREACH_KEYBINDING(GENERATE_ENUM) }; - KEYBINDING_SWAP_LEFT, - KEYBINDING_SWAP_RIGHT, - KEYBINDING_SWAP_TOP, - KEYBINDING_SWAP_BOTTOM, - - KEYBINDING_FOCUS_LEFT, - KEYBINDING_FOCUS_RIGHT, - KEYBINDING_FOCUS_TOP, - KEYBINDING_FOCUS_BOTTOM, - - KEYBINDING_DEFINEKEY, // data.kb is the keybinding definition - KEYBINDING_BACKGROUND, // data.color is the background color - KEYBINDING_DEFINEMODE, // data.c is the mode name - KEYBINDING_WORKSPACES, // data.i is the number of workspaces -}; +extern char *keybinding_action_string[]; union keybinding_params { char *c; @@ -94,7 +127,8 @@ keybinding_list_push(struct keybinding_list *list, void keybinding_list_free(struct keybinding_list *list); void -keybinding_cycle_outputs(struct cg_server *server, bool reverse); +keybinding_cycle_outputs(struct cg_server *server, bool reverse, + bool trigger_event); struct keybinding ** find_keybinding(const struct keybinding_list *list, const struct keybinding *keybinding); diff --git a/libinput.c b/libinput.c index 2510857..dcb9d1f 100644 --- a/libinput.c +++ b/libinput.c @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #include "input.h" #include "input_manager.h" #include "output.h" @@ -262,89 +265,70 @@ input_device_get_type(struct cg_input_device *device) { void apply_config_to_device(struct cg_input_config *config, struct cg_input_device *input_device) { - if(!wlr_input_device_is_libinput(input_device->wlr_device)) { - return; - } - struct libinput_device *device = - wlr_libinput_get_device_handle(input_device->wlr_device); - if(config->mapped_to_output && - !output_by_name_or_id(config->mapped_to_output, input_device->server)) { - wlr_log(WLR_DEBUG, - "'%s' is mapped to offline output '%s'; disabling input", - config->identifier, config->mapped_to_output); - set_send_events(device, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED); - } else if(config->send_events != INT_MIN) { - set_send_events(device, config->send_events); - } else { - // Have to reset to the default mode here, otherwise if ic->send_events - // is unset and a mapped output just came online after being disabled, - // we'd remain stuck sending no events. - set_send_events( - device, - libinput_device_config_send_events_get_default_mode(device)); - } - - if(config->tap != INT_MIN) { - set_tap(device, config->tap); - } - if(config->tap_button_map != INT_MIN) { - set_tap_button_map(device, config->tap_button_map); - } - if(config->drag != INT_MIN) { - set_tap_drag(device, config->drag); - } - if(config->drag_lock != INT_MIN) { - set_tap_drag_lock(device, config->drag_lock); - } - if(config->pointer_accel != FLT_MIN) { - set_accel_speed(device, config->pointer_accel); - } - if(config->accel_profile != INT_MIN) { - set_accel_profile(device, config->accel_profile); - } - if(config->natural_scroll != INT_MIN) { - set_natural_scroll(device, config->natural_scroll); - } - if(config->left_handed != INT_MIN) { - set_left_handed(device, config->left_handed); - } - if(config->click_method != INT_MIN) { - set_click_method(device, config->click_method); - } - if(config->middle_emulation != INT_MIN) { - set_middle_emulation(device, config->middle_emulation); - } - if(config->scroll_method != INT_MIN) { - set_scroll_method(device, config->scroll_method); - } - if(config->scroll_button != INT_MIN) { - set_scroll_button(device, config->scroll_button); - } - if(config->dwt != INT_MIN) { - set_dwt(device, config->dwt); - } - if(config->calibration_matrix.configured) { - set_calibration_matrix(device, config->calibration_matrix.matrix); - } -} - -void -cg_input_apply_config(struct cg_input_config *config, - struct cg_server *server) { - struct cg_input_device *device = NULL; - wl_list_for_each(device, &server->input->devices, link) { - if(strcmp(config->identifier, device->identifier) != 0 && - strcmp(config->identifier, "*") != 0) { - continue; + if(wlr_input_device_is_libinput(input_device->wlr_device)) { + struct libinput_device *device = + wlr_libinput_get_device_handle(input_device->wlr_device); + if(config->mapped_to_output && + !output_by_name_or_id(config->mapped_to_output, + input_device->server)) { + wlr_log(WLR_DEBUG, + "'%s' is mapped to offline output '%s'; disabling input", + config->identifier, config->mapped_to_output); + set_send_events(device, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED); + } else if(config->send_events != INT_MIN) { + set_send_events(device, config->send_events); + } else { + // Have to reset to the default mode here, otherwise if + // ic->send_events is unset and a mapped output just came online + // after being disabled, we'd remain stuck sending no events. + set_send_events( + device, + libinput_device_config_send_events_get_default_mode(device)); } - const char *device_type = input_device_get_type(device); - if(strncmp(config->identifier, "type:", 5) == 0 && - strcmp(config->identifier + 5, device_type) != 0) { - continue; + if(config->tap != INT_MIN) { + set_tap(device, config->tap); + } + if(config->tap_button_map != INT_MIN) { + set_tap_button_map(device, config->tap_button_map); + } + if(config->drag != INT_MIN) { + set_tap_drag(device, config->drag); + } + if(config->drag_lock != INT_MIN) { + set_tap_drag_lock(device, config->drag_lock); + } + if(config->pointer_accel != FLT_MIN) { + set_accel_speed(device, config->pointer_accel); + } + if(config->accel_profile != INT_MIN) { + set_accel_profile(device, config->accel_profile); + } + if(config->natural_scroll != INT_MIN) { + set_natural_scroll(device, config->natural_scroll); + } + if(config->left_handed != INT_MIN) { + set_left_handed(device, config->left_handed); + } + if(config->click_method != INT_MIN) { + set_click_method(device, config->click_method); + } + if(config->middle_emulation != INT_MIN) { + set_middle_emulation(device, config->middle_emulation); + } + if(config->scroll_method != INT_MIN) { + set_scroll_method(device, config->scroll_method); + } + if(config->scroll_button != INT_MIN) { + set_scroll_button(device, config->scroll_button); + } + if(config->dwt != INT_MIN) { + set_dwt(device, config->dwt); + } + if(config->calibration_matrix.configured) { + set_calibration_matrix(device, config->calibration_matrix.matrix); } - apply_config_to_device(config, device); } } @@ -354,71 +338,16 @@ cg_input_configure_libinput_device(struct cg_input_device *input_device) { struct cg_input_config *config = NULL; wl_list_for_each(config, &server->input_config, link) { - if(strcmp(config->identifier, input_device->identifier) != 0 && - strcmp(config->identifier, "*") != 0) { - continue; - } - const char *device_type = input_device_get_type(input_device); - if(!(strncmp(config->identifier, "type:", 5) && - strcmp(config->identifier + 5, device_type) == 0)) { - continue; + if(strcmp(config->identifier, input_device->identifier) == 0 || + strcmp(config->identifier, "*") == 0 || + (strncmp(config->identifier, "type:", 5) == 0 && + strcmp(config->identifier + 5, device_type) == 0)) { + apply_config_to_device(config, input_device); } - apply_config_to_device(config, input_device); } } -bool -cg_input_reset_libinput_device(struct cg_input_device *input_device) { - if(!wlr_input_device_is_libinput(input_device->wlr_device)) { - return false; - } - - struct libinput_device *device = - wlr_libinput_get_device_handle(input_device->wlr_device); - wlr_log(WLR_DEBUG, "cg_input_reset_libinput_device(%s)", - input_device->identifier); - bool changed = false; - - changed |= set_send_events( - device, libinput_device_config_send_events_get_default_mode(device)); - changed |= - set_tap(device, libinput_device_config_tap_get_default_enabled(device)); - changed |= set_tap_button_map( - device, libinput_device_config_tap_get_default_button_map(device)); - changed |= set_tap_drag( - device, libinput_device_config_tap_get_default_drag_enabled(device)); - changed |= set_tap_drag_lock( - device, - libinput_device_config_tap_get_default_drag_lock_enabled(device)); - changed |= set_accel_speed( - device, libinput_device_config_accel_get_default_speed(device)); - changed |= set_accel_profile( - device, libinput_device_config_accel_get_default_profile(device)); - changed |= set_natural_scroll( - device, - libinput_device_config_scroll_get_default_natural_scroll_enabled( - device)); - changed |= set_left_handed( - device, libinput_device_config_left_handed_get_default(device)); - changed |= set_click_method( - device, libinput_device_config_click_get_default_method(device)); - changed |= set_middle_emulation( - device, - libinput_device_config_middle_emulation_get_default_enabled(device)); - changed |= set_scroll_method( - device, libinput_device_config_scroll_get_default_method(device)); - changed |= set_scroll_button( - device, libinput_device_config_scroll_get_default_button(device)); - changed |= - set_dwt(device, libinput_device_config_dwt_get_default_enabled(device)); - - float matrix[6]; - libinput_device_config_calibration_get_default_matrix(device, matrix); - changed |= set_calibration_matrix(device, matrix); - return changed; -} - bool cg_libinput_device_is_builtin(struct cg_input_device *cg_device) { if(!wlr_input_device_is_libinput(cg_device->wlr_device)) { diff --git a/man/cagebreak-config.5.md b/man/cagebreak-config.5.md index 541e713..a93734f 100644 --- a/man/cagebreak-config.5.md +++ b/man/cagebreak-config.5.md @@ -1,4 +1,4 @@ -cagebreak-config(5) "Version 1.9.1" "Cagebreak Manual" +cagebreak-config(5) "Version 2.0.0" "Cagebreak Manual" # NAME @@ -17,6 +17,10 @@ are parsed sequentially but independently from the rest of the file. Each line starting with a "#" is a comment. +Note that nesting of commands is limited to 50 times, though lines +are arbitrarily long in practice, though a reasonable limit of 4Mb has +been set. + See *KEY DEFINITIONS* for details on modifier keys and *MODES* for details on modes. @@ -48,7 +52,7 @@ definekey root Close current window - This may be useful for windows of applications which do not offer any method of closing them. -configure_message [font |[f|b]g_color b> |display_time ] +*configure_message [font |[f|b]g_color b> |display_time ]* Configure message characteristics - - font sets - is @@ -75,6 +79,11 @@ configure_message bg_color 1.0 0.0 0.0 1.0 configure_message display_time 4 ``` +*cursor [enable|disable]* + Enable or disable cursor + This simply hides the cursor. Pointing and clicking is + still possible. + *definekey * Bind to execute if pressed in - *definekey* is a more general version of *bind*. @@ -89,6 +98,9 @@ definemode foo definekey foo C-t abort ``` +*dump* + Triggers the *dump* event, see *cagebreak-socket(7)* for details + *escape * Set to switch to root mode to execute one command @@ -170,10 +182,13 @@ definekey top mode root Enable or disable disable-while-typing for specified input device - *event enabled|disabled|disabled_on_external_mouse* + *events enabled|disabled|disabled_on_external_mouse* Enable or disable send_events for specified input device - Disabling send_events disables the input device. + *keybindings [enabled|disabled]* + Enable or disable keybinding interpretation for a specific keyboard. + *left_handed enabled|disabled* Enable or disable left handed mode for specified input device @@ -200,6 +215,12 @@ definekey top mode root *scroll_method none|two_finger|edge|on_button_down* Change scroll method for specified input device + *repeat_delay * + Repeat delay in ms for keyboards only + + *repeat_rate * + Repeat rate in 1/s for keyboards only + *tap enabled|disabled* Enable or disable tap for specified input device @@ -218,31 +239,37 @@ message *movetonextscreen* Move currently focused window to next screen + See *output* for differences between screen and output. *movetoprevscreen* Move currently focused window to previous screen + See *output* for differences between screen and output. *movetoscreen * Move currently focused window to -th screen + See *output* for differences between screen and output. *movetoworkspace * Move currently focused window to -th workspace + See *output* for differences between screen and output. *next* Focus next window in current tile *nextscreen* Focus next screen + See *output* for differences between screen and output. *only* Remove all splits and make current window fill the entire screen -*output [[pos res x rate ] | enable | disable | prio ]* +*output [[pos res x rate [scale ]] | enable | disable | prio | rotate ]* Configure output "" - - and are the position of the monitor in pixels. The top-left monitor should have the coordinates 0 0. - and specify the resolution in pixels. - sets the refresh rate of the monitor (often this is 50 or 60). + - sets the output scale (default is 1.0) - enable and disable enable or disable . Note that if is the only enabled output, *output disable* has no effect. @@ -252,6 +279,30 @@ message to set priorities for outputs, where >= 1. The larger is, the higher the priority is, that is to say, the earlier the output will appear in the list of outputs. + - rotate is used to rotate the output by ` mod 4 x 90` degrees + counter-clockwise. + +``` +# Don't rotate +output DP-1 rotate 0 + +# rotate 90 degrees counter-clockwise +output DP-1 rotate 1 + +# rotate 180 degrees counter-clockwise +output DP-1 rotate 2 + +# rotate 270 degrees counter-clockwise +output DP-1 rotate 3 +``` + + *output* and the *screen* family of commands are similar in that they + both deal with monitors on some level. + - *output* addresses outputs by their name and is vaguely symmetric + to *input*. + - Any *screen* command deals with the number identifying a + monitor within a Cagebreak session either explicitly or + implicitly (i.e. the commands containing next and prev). *prev* Focus previous window in current tile @@ -276,6 +327,7 @@ message *screen * Change to -th screen + See *output* for differences between screen and output. *show_info* Display information about the current setup - In particular, print the identifiers @@ -355,6 +407,7 @@ is used. # SEE ALSO *cagebreak(1)* +*cagebreak-socket(7)* # BUGS @@ -370,7 +423,7 @@ GPG Fingerprints: # LICENSE -Copyright (c) 2020-2022 The Cagebreak authors +Copyright (c) 2020-2023 The Cagebreak authors Copyright (c) 2018-2020 Jente Hidskes diff --git a/man/cagebreak-socket.7.md b/man/cagebreak-socket.7.md new file mode 100644 index 0000000..d21ce84 --- /dev/null +++ b/man/cagebreak-socket.7.md @@ -0,0 +1,606 @@ +cagebreak-socket(7) "Version 2.0.0" "Cagebreak Manual" + +# NAME + +*cagebreak-socket* — Cagebreak socket + +# SYNOPSIS + +*ipc-socket-capable-tool \$CAGEBREAK_SOCKET* + +# DESCRIPTION + +The cagebreak socket is an ipc socket. + +The socket is enabled if cagebreak is invoked with the `-e` flag. + +The socket accepts cagebreak commands as input (see *cagebreak-config(5)* for more information). + +Events are provided as output as specified in this man page. + +## EVENTS + +Events have a general structure as follows: + +``` +"cg-ipc"json object depending on the eventNULL +``` + +Here is an example of how this works using *only* as a command sent over the socket. + +``` +only +cg-ipc{"event_name":"fullscreen","tile_id":2,"workspace":1,"output":"eDP-1"} +``` + +This documentation describes the trigger for the events, the keys and the data +type of the values of each event. + +*background* + - Trigger: *background* command + - JSON + - event_name: "background" + - old_bg: list of three floating point numbers denoting the old background in rgb + - new_bg: list of three floating point numbers denoting the new background in rgb + +``` +background 0 1.0 0 +cg-ipc{"event_name":"background","old_bg":[0.000000,1.000000,1.000000],"new_bg":[0.000000,1.000000,0.000000]} +``` + +*close* + - Trigger: *close* command + - JSON + - event_name: "close" + - view_id: view id as an integer + - tile_id: tile id as an integer + - view_pid: pid of the process + - workspace: workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +close +cg-ipc{"event_name":"close","view_id":47,"view_pid":30456,"tile_id":47,"workspace":1,"output":"eDP-1","output_id":1} +``` + +*configure_input* + - Trigger: *input* command + - JSON + - event_name: "configure_input" + - input: the input as a string, as per cagebreak-config(5) + +``` +input * accel_profile flat +cg-ipc{"event_name":"configure_input","input":"*"} +``` + +*configure_message* + - Trigger: *configure_message* command + - JSON + - event_name: "configure_message" + +``` +configure_message fg_color 1.0 1.0 0 0 +cg-ipc{"event_name":"configure_message"} +``` + +*configure_output* + - Trigger: *output* command + - JSON + - event_name: "configure_output" + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +output eDP-1 rotate 0 +cg-ipc{"event_name":"configure_output","output":"eDP-1","output_id":1} +``` + +*cursor_switch_tile* + - Trigger: Cursor crosses the border between tiles + - JSON + - event_name: "cursor_switch_tile" + - old_output: name of the old output as a string + - old_output_id: old output id as an integer + - old_tile: number of the old tile as an integer + - new_output: name of the new output as a string + - new_output_id: new output id as an integer + - new_tile: number of the new tile as an integer + +``` +# Cursor switches tile +cg-ipc{"event_name":"cursor_switch_tile","old_output":"eDP-1","old_output_id":1,"old_tile":2,"new_output":"eDP-1","new_output_id":1,"new_tile":3} +``` + +*cycle_outputs* + - Trigger: *nextscreen* and *prevscreen* commands + - JSON + - event_name: "cycle_outputs" + - old_output: old output name as string + - old_output_id: old output id as an integer + - new_output: new output name as string + - new_output_id: new output id as an integer + - reverse: "0" if *nextscreen* or "1" if *prevscreen* + +``` +nextscreen +cg-ipc{"event_name":"cycle_outputs","old_output":"eDP-1","old_output_id":1,"new_output":"HDMI-A-1","new_output_id":2,"reverse":0} +``` + +*cycle_views* + - Trigger: *next* and *prev* commands + - JSON + - event_name: "cycle_views" + - old_view_id: old view id as an integer + - old_view_pid: pid of old view + - new_view_id: new view id as an interger + - new_view_pid: pid of new view + - tile_id: tile id as an integer + - workspace: workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +next +cg-ipc{"event_name":"cycle_views","old_view_id":11,"old_view_pid":32223,"new_view_id":4,"old_view_pid";53221,"tile_id":13,"workspace":1,"output":"eDP-1","output_id":1} +``` + +*definekey* + - Trigger: *definekey* command + - JSON + - event_name: "definekey" + - modifiers: number denoting the modifier as described below + - 0: no modifier + - 1: shift + - 2: alt + - 3: ctrl + - 4: logo key + - 5: modifier 2 + - 6: modifier 3 + - 7: modifier 5 + - key: key as a number + - command: command as a string - CAVEAT: This is an internal representation of + commands which is not in one-to-one correspondance with the commands available in the config file. The differences are as follows: + - "cycle_tiles": represents any *exchange* command (e.g. *exchangeright*) + - "cycle_views": represents both the *next* and the *prev* command + - "cycle_outputs": represents *nextscreen*, *movetoprevscreen* and *prevscreen* commands + - "resize_tile_vertical": represents *resizedown* and *resizeup* commands + - "resize_tile_horizontal": represents *resizeleft* and *resizeright* commands + +``` +definemode foo +cg-ipc{"event_name":"definemode","mode":"foo"} +definekey foo e only +cg-ipc{"event_name":"definekey","modifiers":0,"key":101,"command":"only"} +``` + +*definemode* + - Trigger: *definemode* command + - JSON + - event_name: "definemode" + - mode: name of mode as string + +``` +definemode foo +cg-ipc{"event_name":"definemode","mode":"foo"} +``` + +*destroy_output* + - Trigger: removal of an output + - JSON + - event_name: "destroy_output" + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +# remove output from the device +cg-ipc{"event_name":"destroy_output","output":"HDMI-A-1","output_id":2} +``` + +*dump* + - Trigger: *dump* command + - JSON + - event_name: "dump" + - nws: number of workspaces as an integer + - bg_color: list of three floating point numbers denoting the new background in rgb + - views_curr_id: id of the currently focussed view as an integer + - tiles_curr_id: id of the currently focussed tile as in integer + - curr_output: current output as a string + - default_mode: name of the default mode as a string + - modes: list of names of modes as strings + - outputs: object of objects for each output + - output name as string + - priority: priority as per *output* prio in *cagebreak-config(5)* or default + - coords: object of x and y coordinates of output + - size: object of width and height as integers + - refresh_rate: refresh rate as float + - curr_workspace: current workspace as an integer + - workspaces: list of objects for each workspace + - views: list of objects for each view + - id: view id as an integer + - pid: pid of the process which opened the view as an integer + - coords: object of x and y coordinates + - type: ["xdg"|"xwayland"] + - tiles: list of objects for all tiles + - id: tile id as an integer + - coords: object of x and y coordinates + - size: object of width and height + - view: view id as an integer + - keyboards: object of objects for each keyboard group + - keyboard name as a string + - commands_enabled: 0 if keybindings are disabled for the keyboard, 1 otherwise + - repeat_delay: repeat delay in milliseconds as an integer + - repeat_rate: repeat rate in 1/sec as an integer + - input_devices: object of objects for each keyboard + - identifier for a keyboard as a string + - is_virtual: 1 if virtual, 0 otherwise + - type: [keyboard|pointer|switch] + - cursor_coords: object of x and y coordinates + +``` +dump +cg-ipc{"event_name":"dump","nws":1, +"bg_color":[0.000000,0.000000,0.000000], +"views_curr_id":80, +"tiles_curr_id":8, +"curr_output":"eDP-1", +"default_mode":"top", +"modes":["top","root","resize"], +"outputs": {"eDP-1": { +"priority": -1, +"coords": {"x":0,"y":0}, +"size": {"width":2560,"height":1440}, +"refresh_rate": 60.012000, +"curr_workspace": 0, +"workspaces": [{"views": [{ +"id": 16, +"pid": 2505, +"coords": {"x":0,"y":0}, +"type": "xwayland" + +},{ +"id": 72, +"pid": 11243, +"coords": {"x":0,"y":0}, +"type": "xdg" + +},{ +"id": 56, +"pid": 6700, +"coords": {"x":1280,"y":0}, +"type": "xdg" + +}],"tiles": [{ +"id": 6, +"coords": {"x":0,"y":0}, +"size": {"width":1280,"height":1440}, +"view": 78 + +},{ +"id": 7, +"coords": {"x":1280,"y":0}, +"size": {"width":1280,"height":1440}, +"view": 42 + +}]}] +}} +,"keyboards": {"0:1:Power_Button": { +"commands_enabled": 1, +"repeat_delay": 600, +"repeat_rate": 25 +}} +,"input_devices": {"6058:20564:ThinkPad_Extra_Buttons": { +"is_virtual": 0, +"type": "switch", +},"6058:20564:ThinkPad_Extra_Buttons": { +"is_virtual": 0, +"type": "keyboard", +},"2:10:TPPS/2_Elan_TrackPoint": { +"is_virtual": 0, +"type": "pointer", +},"1:1:AT_Translated_Set_2_keyboard": { +"is_virtual": 0, +"type": "keyboard", +},"0:0:sof-hda-dsp_Headphone": { +"is_virtual": 0, +"type": "keyboard", +},"1739:52619:SYNA8004:00_06CB:CD8B_Touchpad": { +"is_virtual": 0, +"type": "pointer", +},"1739:52619:SYNA8004:00_06CB:CD8B_Mouse": { +"is_virtual": 0, +"type": "pointer", +},"0:3:Sleep_Button": { +"is_virtual": 0, +"type": "keyboard", +},"0:5:Lid_Switch": { +"is_virtual": 0, +"type": "switch", +},"0:6:Video_Bus": { +"is_virtual": 0, +"type": "keyboard", +},"0:1:Power_Button": { +"is_virtual": 0, +"type": "keyboard", +}} +,"cursor_coords":{"x":972.821761,"y":670.836215} +} +``` + +*focus_tile* + - Trigger: *focus* command + - JSON + - event_name: "focus_tile" + - old_tile_id: old tile id as an integer + - new_tile_id: new tile id as an integer + - workspace: workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +focus +cg-ipc{"event_name":"focus_tile","old_tile_id":14,"new_tile_id":13,"workspace":1,"output":"eDP-1","output_id":1} +``` + +*fullscreen* + - Trigger: *only* command + - JSON + - event_name: "fullscreen" + - tile_id: tile id as an integer + - workspace: workspace number as an integer + - output: output as a string + - output_id: id of the output as an integer + +``` +only +cg-ipc{"event_name":"fullscreen","tile_id":3,"workspace":1,"output":"eDP-1","output_id":1} +``` + +*move_view_to_cycle_output* + - Trigger: *movetonextscreen* and similar commands + - JSON + - event_name: "move_view_to_cycle_output" + - view_id: view id as an integer + - view_pid: pid of the process + - old_output: name of the old output as a string + - old_output_id: old output id as an integer + - new_output: name of the new output as a string + - old_output_id: old output id as an integer + +``` +movetonextscreen +cg-ipc{"event_name":"cycle_outputs","old_output":"eDP-1","new_output":"HDMI-A-1","reverse":0} +cg-ipc{"event_name":"move_view_to_cycle_output","view_id":11,"view_pid":43123,"old_output":"eDP-1","old_output_id":1,"new_output":"HDMI-A-1","new_output_id":2} +``` + +*move_view_to_output* + - Trigger: *movetoscreen* command + - JSON + - event_name: "move_view_to_output" + - view_id: view id as an integer + - old_output: old output name as string + - new_output: new output name as string + +``` +movetoscreen 2 +cg-ipc{"event_name":"switch_output","old_output":"eDP-1","new_output":"HDMI-A-1"} +cg-ipc{"event_name":"move_view_to_output","view_id":78,"old_output":"eDP-1","new_output":"HDMI-A-1"} +``` + +*move_view_to_ws* + - Trigger: *movetoworkspace* command + - JSON + - event_name: "move_view_to_ws" + - view_id: view id as an integer + - old_workspace: old workspace number as an integer + - new_workspace: new workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + - view_pid: pid of the process + +``` +movetoworkspace 1 +cg-ipc{"event_name":"switch_ws","old_workspace":1,"new_workspace":1,"output":"eDP-1"} +cg-ipc{"event_name":"move_view_to_ws","view_id":43,"old_workspace":0,"new_workspace":0,"output":"eDP-1","output_id":1,"view_pid":64908} +``` + +*new_output* + - Trigger: a new output is physically attached + - JSON + - event_name: "new_output" + - output: new output name as a string + - output_id: id of the new output as an integer + - priority: priority as per *output* prio in *cagebreak-config(5)* or default + +``` +# a new output is attached +cg-ipc{"event_name":"new_output","output":"HDMI-A-1","output_id":2,"priority":-1} +``` + +*resize_tile* + - Trigger: the *resize* family of commands + - JSON + - event_name: "resize_tile" + - tile_id: tile id as an integer + - old_dims: list of coordinates [x coordinate of lower left corner, y coordinate of lower left corner, x coordinate of upper right corner, y coordinate of upper right corner] + - new_dims: list of coordinate [x coordinate of lower left corner, y coordinate of lower left corner, x coordinate of upper right corner, y coordinate of upper right corner] + - workspace: workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +resizeleft +cg-ipc{"event_name":"resize_tile","tile_id":14,"old_dims":"[1280,0,1440,1280]","new_dims":"[1270,0,1440,1290]","workspace":1,"output":"eDP-1","output_id":1} +cg-ipc{"event_name":"resize_tile","tile_id":13,"old_dims":"[0,0,1440,1280]","new_dims":"[0,0,1440,1270]","workspace":1,"output":"eDP-1","output_id":1} +``` + +*set_nws* + - Trigger: *workspaces* command + - JSON + - event_name: "set_nws" + - old_nws: old number of workspaces as an integer + - new_nws: new number of workspaces as an integer + +``` +workspaces 2 +cg-ipc{"event_name":"set_nws","old_nws":1,"new_nws":2} +``` + +*split* + - Trigger: *split* command + - JSON + - event_name: "split" + - tile_id: old tile id as an integer + - new_tile_id: new tile id as an integer + - workspace: workspace number as an integer + - output: output as a string + - output_id: id of the output as an integer + - vertical: 0 if horizontal split, 1 if not + +``` +hsplit +cg-ipc{"event_name":"split","tile_id":11,"new_tile_id":12,"workspace":1,"output":"eDP-1","output_id":1,"vertical":0} +``` + +*swap_tile* + - Trigger: the *exchange* family of commands + - JSON + - event_name: "swap_tile" + - tile_id: previous tile id as an integer + - tile_pid: pid of previous tile + - swap_tile_id: swap tile id as an integer + - swap_tile_pid: pid of swap tile + - workspace: workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +exchangeright +cg-ipc{"event_name":"swap_tile","tile_id":1,"tile_pid":53478,"swap_tile_id":3,"swap_tile_pid":98234,"workspace":1,"output":"eDP-1"} +``` + +*switch_default_mode* + - Trigger: *setmode* command + - JSON + - event_name: "switch_default_mode" + - old_mode: old mode name + - mode: new mode name + +``` +setmode top +cg-ipc{"event_name":"switch_default_mode","old_mode":"top","mode":"root"} +``` + +switch_output + - Trigger. *screen* command + - JSON + - event_name: "switch_output" + - old_output: name of the old output as a string + - old_output_id: old output id as an integer + - new_output: name of the new output as a string + - new_output_id: new output id as an integer + +``` +screen 2 +cg-ipc{"event_name":"switch_output","old_output":"eDP-1","old_output_id":1,"new_output":"HDMI-A-1","new_output_id":2} +``` + +switch_ws + - Trigger: *workspace* command + - JSON + - event_name: "switch_ws" + - old_workspace: old workspace number as an integer + - new_workspace: new workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + +``` +workspace 2 +cg-ipc{"event_name":"switch_ws","old_workspace":1,"new_workspace":2,"output":"eDP-1","output_id":1} +``` + +*view_map* + - Trigger: view is opened by a process + - JSON + - event_name: "view_map" + - view_id: view id as an integer + - tile_id: tile id as an integer + - workspace: workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + - view_pid: pid of the process + +``` +# process opens a view +cg-ipc{"event_name":"view_map","view_id":28,"tile_id":14,"workspace":1,"output":"eDP-1","output_id":1,"view_pid":39827} +``` + +*view_unmap* + - Trigger: view is closed by a process + - JSON + - event_name: "view_unmap" + - view_id: view id as an integer + - tile_id: tile id as an integer + - workspace: workspace number as an integer + - output: name of the output as a string + - output_id: id of the output as an integer + - view_pid: pid of the process + +``` +# view is closed by the process +cg-ipc{"event_name":"view_unmap","view_id":24,"tile_id":13,"workspace":1,"output":"eDP-1","output_id":1,"view_pid":39544} +``` + +## SECURITY + +The socket has to be explicitly enabled using the `-e` flag. + +The socket is restricted to the user for reading, writing and execution (700). + +All user software can execute arbitrary code while the cagebreak socket is running. + +## EXAMPLES + +*nc -U $CAGEBREAK_SOCKET* + +*ncat -U $CAGEBREAK_SOCKET* + +# SEE ALSO + +*cagebreak(1)* +*cagebreak-config(5)* + +# BUGS + +See GitHub Issues: + +Mail contact: `cagebreak @ project-repo . co` + +GPG Fingerprints: + +- B15B92642760E11FE002DE168708D42451A94AB5 +- F8DD9F8DD12B85A28F5827C4678E34D2E753AA3C +- 3ACEA46CCECD59E4C8222F791CBEB493681E8693 + +# LICENSE + +Copyright (c) 2022 - 2023 The Cagebreak authors + +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/man/cagebreak.1.md b/man/cagebreak.1.md index 7ef7963..7feccc1 100644 --- a/man/cagebreak.1.md +++ b/man/cagebreak.1.md @@ -1,4 +1,4 @@ -cagebreak(1) "Version 1.9.1" "Cagebreak Manual" +cagebreak(1) "Version 2.0.0" "Cagebreak Manual" # NAME @@ -32,12 +32,15 @@ are displayed in a message box at the top right of the screen. # OPTIONS +*-c * + Load configuration file from + +*-e* + Enable socket + *-h* Display help message and exit -*-r* - Rotate the output 90 degrees clockwise, can be specified up to three times - *-s* Show all available inputs and outputs @@ -68,6 +71,7 @@ are displayed in a message box at the top right of the screen. # SEE ALSO *cagebreak-config(5)* +*cagebreak-socket(7)* # BUGS @@ -83,7 +87,7 @@ GPG Fingerprints: # LICENSE -Copyright (c) 2020-2022 The Cagebreak authors +Copyright (c) 2020-2023 The Cagebreak authors Copyright (c) 2018-2020 Jente Hidskes diff --git a/meson.build b/meson.build index 172741f..9d2913f 100644 --- a/meson.build +++ b/meson.build @@ -1,10 +1,11 @@ -project('cagebreak', 'c', - version: '1.9.1', - license: 'MIT', - default_options: [ - 'c_std=c11', - 'warning_level=3', - ], +# Copyright 2020 - 2023, project-repo and the cagebreak contributors +# SPDX -License-Identifier: MIT +project( + 'cagebreak', + 'c', +version : '2.0.0', +license : 'MIT', +default_options : ['c_std=c11', 'warning_level=3'] ) add_project_arguments( @@ -53,12 +54,11 @@ if is_freebsd ) endif -wlroots = dependency('wlroots', version: ['>=0.14.1', '< 0.16.0']) +wlroots = dependency('wlroots', version: ['>=0.16.1', '< 0.17.0']) wayland_protos = dependency('wayland-protocols', version: '>=1.14') wayland_server = dependency('wayland-server') wayland_cursor = dependency('wayland-cursor') wayland_client = dependency('wayland-client') -pixman = dependency('pixman-1') xkbcommon = dependency('xkbcommon') cairo = dependency('cairo') pango = dependency('pango') @@ -132,7 +132,6 @@ cagebreak_source_strings = [ 'workspace.c', 'output.c', 'parse.c', - 'render.c', 'seat.c', 'util.c', 'view.c', @@ -150,7 +149,6 @@ cagebreak_header_strings = [ 'workspace.h', 'output.h', 'parse.h', - 'render.h', 'seat.h', 'server.h', 'util.h', @@ -194,7 +192,6 @@ cagebreak_dependencies_dict = { 'libinput': [libinput,true], 'libevdev': [libevdev,true], 'libudev': [libudev,true], - 'pixman': [pixman,true], 'pango': [pango,true], 'cairo': [cairo,true], 'pangocairo': [pangocairo,true], @@ -206,16 +203,15 @@ reproducible_build_versions = { 'wayland_server': '1.19.0', 'wayland_client': '1.21.0', 'wayland_cursor': '1.21.0', - 'wlroots': '0.15.1', - 'xkbcommon': '1.4.1', - 'fontconfig': '2.14.0', - 'libinput': '1.21.0', - 'libevdev': '1.12.1', - 'libudev': '251', - 'pixman': '0.40.0', - 'pango': '1.50.8', + 'wlroots': '0.16.1', + 'xkbcommon': '1.5.0', + 'fontconfig': '2.14.1', + 'libinput': '1.22.0', + 'libevdev': '1.13.0', + 'libudev': '252', + 'pango': '1.50.12', 'cairo': '1.17.6', - 'pangocairo': '1.50.8', + 'pangocairo': '1.50.12', 'math': '-1' } @@ -229,11 +225,11 @@ foreach name, dep : cagebreak_dependencies_dict if reproducible_build_versions[name] != '-1' if dep[1] == false if dep[0].version() < reproducible_build_versions[name] - warning('The installed version of "' + name + '" on your machine (' + dep[0].version() + ') is older than the one used to generate the binary specified in the README section "Reproducible Builds" (' + reproducible_build_versions[name] + '). It is recommended to use an up-to-date version for compiling cagebreak.' + warning('The installed version of "' + name + '" on your machine (' + dep[0].version() + ') is older than the one used to generate the binary specified in Hashes.md (' + reproducible_build_versions[name] + '). It is recommended to use an up-to-date version for compiling cagebreak.' ) endif elif reproducible_build_versions[name] != dep[0].version() - warning('The installed version of "' + name + '" on your machine (' + dep[0].version() + ') differs from the one used to generate the binary specified in the README section "Reproducible Builds" (' + reproducible_build_versions[name] + '). Cagebreak does not guarantee a reproducible build for this configuration.' + warning('The installed version of "' + name + '" on your machine (' + dep[0].version() + ') differs from the one used to generate the binary specified in Hashes.md (' + reproducible_build_versions[name] + '). Cagebreak does not guarantee a reproducible build for this configuration.' ) break endif @@ -241,12 +237,12 @@ foreach name, dep : cagebreak_dependencies_dict endforeach reproducible_build_compiler = 'gcc' -reproducible_build_compiler_version = '12.1.0' +reproducible_build_compiler_version = '12.2.0' if cc.get_id() != reproducible_build_compiler - warning('The compiler "' + cc.get_id() + '" differs from the one used to generate to binary specified in the README section "Reproducible Builds" (' + reproducible_build_compiler + ').') + warning('The compiler "' + cc.get_id() + '" differs from the one used to generate to binary specified in Hashes.md (' + reproducible_build_compiler + ').') elif cc.version() != reproducible_build_compiler_version - warning('The version of ' + cc.get_id() + ' (' + cc.version() + ') differs from the one used to generate the binary specified in the README section "Reproducible Builds" ' + reproducible_build_compiler_version + '.') + warning('The version of ' + cc.get_id() + ' (' + cc.version() + ') differs from the one used to generate the binary specified in Hashes.md ' + reproducible_build_compiler_version + '.') endif executable( @@ -262,15 +258,18 @@ install_data('examples/config', install_dir : '/etc/xdg/cagebreak') if get_option('man-pages') scdoc = find_program('scdoc') + secssinceepoch = 1673193959 + shcommand = 'export SOURCE_DATE_EPOCH=' + secssinceepoch.to_string() + ' ; @0@ < @INPUT@'.format(scdoc.path()) sh = find_program('sh') mandir1 = join_paths(get_option('mandir'), 'man1') mandir5 = join_paths(get_option('mandir'), 'man5') + mandir7 = join_paths(get_option('mandir'), 'man7') cagebreak_man = custom_target('cagebreak_man', output : 'cagebreak.1', input : 'man/cagebreak.1.md', - capture : true, - command : [sh, '-c', 'export SOURCE_DATE_EPOCH=1658688233 ; @0@ < @INPUT@'.format(scdoc.path())], + capture : true, + command : [sh, '-c', shcommand], install: true, install_dir: mandir1 ) @@ -278,11 +277,20 @@ if get_option('man-pages') cagebreak_man = custom_target('cagebreak_config_man', output : 'cagebreak-config.5', input : 'man/cagebreak-config.5.md', - capture : true, - command : [sh, '-c', 'export SOURCE_DATE_EPOCH=1658688233 ; @0@ < @INPUT@'.format(scdoc.path())], + capture : true, + command : [sh, '-c', shcommand], install: true, install_dir: mandir5 ) + + cagebreak_man = custom_target('cagebreak_socket_man', + output : 'cagebreak-socket.7', + input : 'man/cagebreak-socket.7.md', + capture : true, + command : [sh, '-c', shcommand], + install: true, + install_dir: mandir7 + ) endif if get_option('fuzz') diff --git a/meson_options.txt b/meson_options.txt index b6dcb79..6d4a787 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -1,3 +1,5 @@ +# Copyright 2020 - 2023, project-repo and the cagebreak contributors +# SPDX -License-Identifier: MIT option('xwayland', type: 'boolean', value: 'false', description: 'Enable support for X11 applications') option('man-pages', type: 'boolean', value: 'false', description: 'Build man pages (requires pandoc)') option('fuzz', type: 'boolean', value: 'false', description: 'Enable building fuzzer targets') diff --git a/message.c b/message.c index 9e600bb..f0c2c64 100644 --- a/message.c +++ b/message.c @@ -1,11 +1,20 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #include #include #include +#include #include +#include #include +#include +#include +#include #include #include #include +#include #include #include "message.h" @@ -14,6 +23,67 @@ #include "server.h" #include "util.h" +struct msg_buffer { + struct wlr_buffer base; + void *data; + uint32_t format; + size_t stride; +}; + +static void +msg_buffer_destroy(struct wlr_buffer *wlr_buffer) { + struct msg_buffer *buffer = wl_container_of(wlr_buffer, buffer, base); + free(buffer->data); + free(buffer); +} + +static bool +msg_buffer_begin_data_ptr_access(struct wlr_buffer *wlr_buffer, uint32_t flags, + void **data, uint32_t *format, + size_t *stride) { + struct msg_buffer *buffer = wl_container_of(wlr_buffer, buffer, base); + if(data != NULL) { + *data = (void *)buffer->data; + } + if(format != NULL) { + *format = buffer->format; + } + if(stride != NULL) { + *stride = buffer->stride; + } + return true; +} + +static void +msg_buffer_end_data_ptr_access(struct wlr_buffer *wlr_buffer) { + // This space is intentionally left blank +} + +static const struct wlr_buffer_impl msg_buffer_impl = { + .destroy = msg_buffer_destroy, + .begin_data_ptr_access = msg_buffer_begin_data_ptr_access, + .end_data_ptr_access = msg_buffer_end_data_ptr_access, +}; + +static struct msg_buffer * +msg_buffer_create(uint32_t width, uint32_t height, uint32_t stride) { + struct msg_buffer *buffer = calloc(1, sizeof(*buffer)); + if(buffer == NULL) { + return NULL; + } + + wlr_buffer_init(&buffer->base, &msg_buffer_impl, width, height); + buffer->format = DRM_FORMAT_ARGB8888; + buffer->stride = stride; + + buffer->data = malloc(buffer->stride * height); + if(buffer->data == NULL) { + free(buffer); + return NULL; + } + + return buffer; +} cairo_subpixel_order_t to_cairo_subpixel_order(const enum wl_output_subpixel subpixel) { switch(subpixel) { @@ -31,12 +101,11 @@ to_cairo_subpixel_order(const enum wl_output_subpixel subpixel) { return CAIRO_SUBPIXEL_ORDER_DEFAULT; } -struct wlr_texture * +struct msg_buffer * create_message_texture(const char *string, const struct cg_output *output) { const int WIDTH_PADDING = 8; const int HEIGHT_PADDING = 2; - struct wlr_texture *texture; double scale = output->wlr_output->scale; int width = 0; int height = 0; @@ -75,7 +144,6 @@ create_message_texture(const char *string, const struct cg_output *output) { float *bg_col = output->server->message_config.bg_color; cairo_set_source_rgba(cairo, bg_col[0], bg_col[1], bg_col[2], bg_col[3]); cairo_paint(cairo); - PangoContext *pango = pango_cairo_create_context(cairo); float *fg_col = output->server->message_config.fg_color; cairo_set_source_rgba(cairo, fg_col[0], fg_col[1], fg_col[2], fg_col[3]); cairo_set_line_width(cairo, 2); @@ -89,13 +157,22 @@ create_message_texture(const char *string, const struct cg_output *output) { cairo_surface_flush(surface); unsigned char *data = cairo_image_surface_get_data(surface); int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); - texture = - wlr_texture_from_pixels(output->server->renderer, DRM_FORMAT_ARGB8888, - stride, width, height, data); + + struct msg_buffer *buf = msg_buffer_create(width, height, stride); + void *data_ptr; + + if(!wlr_buffer_begin_data_ptr_access(&buf->base, + WLR_BUFFER_DATA_PTR_ACCESS_WRITE, + &data_ptr, NULL, NULL)) { + wlr_log(WLR_ERROR, "Failed to get pointer access to message buffer"); + return NULL; + } + memcpy(data_ptr, data, stride * height); + wlr_buffer_end_data_ptr_access(&buf->base); + cairo_surface_destroy(surface); - g_object_unref(pango); cairo_destroy(cairo); - return texture; + return buf; } #if CG_HAS_FANALYZE @@ -111,8 +188,8 @@ message_set_output(struct cg_output *output, const char *string, free(box); return; } - message->message = create_message_texture(string, output); - if(!message->message) { + struct msg_buffer *buf = create_message_texture(string, output); + if(!buf) { wlr_log(WLR_ERROR, "Could not create message texture"); free(box); free(message); @@ -121,8 +198,9 @@ message_set_output(struct cg_output *output, const char *string, message->position = box; wl_list_insert(&output->messages, &message->link); - int width = message->message->width; - int height = message->message->height; + double scale = output->wlr_output->scale; + int width = buf->base.width / scale; + int height = buf->base.height / scale; message->position->width = width; message->position->height = height; switch(align) { @@ -148,7 +226,23 @@ message_set_output(struct cg_output *output, const char *string, default: break; } - wlr_output_damage_add_box(output->damage, message->position); + + struct wlr_scene_output *scene_output = + wlr_scene_get_scene_output(output->server->scene, output->wlr_output); + if(scene_output == NULL) { + return; + } + message->message = + wlr_scene_buffer_create(&scene_output->scene->tree, &buf->base); + wlr_scene_node_raise_to_top(&message->message->node); + wlr_scene_node_set_enabled(&message->message->node, true); + struct wlr_box outp_box; + wlr_output_layout_get_box(output->server->output_layout, output->wlr_output, + &outp_box); + wlr_scene_buffer_set_dest_size(message->message, width, height); + wlr_scene_node_set_position(&message->message->node, + message->position->x + outp_box.x, + message->position->y + outp_box.y); } void @@ -168,10 +262,11 @@ message_printf(struct cg_output *output, const char *fmt, ...) { free(buffer); return; } - struct wlr_box *output_box = wlr_output_layout_get_box( - output->server->output_layout, output->wlr_output); + struct wlr_box output_box; + wlr_output_layout_get_box(output->server->output_layout, output->wlr_output, + &output_box); - box->x = output_box->width; + box->x = output_box.width; box->y = 0; box->width = 0; box->height = 0; @@ -205,9 +300,10 @@ message_clear(struct cg_output *output) { struct cg_message *message, *tmp; wl_list_for_each_safe(message, tmp, &output->messages, link) { wl_list_remove(&message->link); - wlr_output_damage_add_box(output->damage, message->position); - wlr_texture_destroy(message->message); + struct wlr_buffer *buf = message->message->buffer; + wlr_scene_node_destroy(&message->message->node); free(message->position); + buf->impl->destroy(buf); free(message); } } diff --git a/message.h b/message.h index b1081ab..25bf692 100644 --- a/message.h +++ b/message.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef MESSAGE_H #define MESSAGE_H @@ -6,7 +9,7 @@ struct cg_output; struct wlr_box; -struct wlr_texture; +struct wlr_buffer; enum cg_message_align { CG_MESSAGE_TOP_LEFT, @@ -25,7 +28,8 @@ struct cg_message_config { struct cg_message { struct wlr_box *position; - struct wlr_texture *message; + struct wlr_scene_buffer *message; + struct wl_surface *surface; struct wl_list link; }; diff --git a/output.c b/output.c index 90f1f7e..b36d724 100644 --- a/output.c +++ b/output.c @@ -1,14 +1,7 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2020 Jente Hidskes - * Copyright (C) 2019 The Sway authors - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT -#define _POSIX_C_SOURCE 200112L +#define _POSIX_C_SOURCE 200809L #include "config.h" #include @@ -21,11 +14,12 @@ #if WLR_HAS_X11_BACKEND #include #endif +#include #include #include #include #include -#include +#include #include #include #include @@ -36,7 +30,6 @@ #include "keybinding.h" #include "message.h" #include "output.h" -#include "render.h" #include "seat.h" #include "server.h" #include "util.h" @@ -46,327 +39,395 @@ #include "xwayland.h" #endif -static void -output_for_each_surface(struct cg_output *output, - cg_surface_iterator_func_t iterator, void *user_data); - -struct surface_iterator_data { - cg_surface_iterator_func_t user_iterator; - void *user_data; - - struct cg_output *output; - - /* Output-local coordinates. */ - double ox, oy; -}; - -static bool -intersects_with_output(struct cg_output *output, - const struct wlr_output_layout *output_layout, - const struct wlr_box *surface_box) { - /* Since the surface_box's x- and y-coordinates are already output local, - * the x- and y-coordinates of this box need to be 0 for this function to - * work correctly. */ - struct wlr_box output_box = {0}; - wlr_output_effective_resolution(output->wlr_output, &output_box.width, - &output_box.height); - - struct wlr_box intersection; - return wlr_box_intersection(&intersection, &output_box, surface_box); -} - -static void -output_for_each_surface_iterator(struct wlr_surface *surface, int sx, int sy, - void *user_data) { - struct surface_iterator_data *data = user_data; - struct cg_output *output = data->output; - - if(!wlr_surface_has_buffer(surface)) { - return; - } - - struct wlr_box surface_box = { - .x = data->ox + sx + surface->sx, - .y = data->oy + sy + surface->sy, - .width = surface->current.width, - .height = surface->current.height, - }; - - if(!intersects_with_output(output, output->server->output_layout, - &surface_box)) { - return; - } - - data->user_iterator(data->output, surface, &surface_box, data->user_data); -} - void -output_surface_for_each_surface(struct cg_output *output, - struct wlr_surface *surface, double ox, - double oy, cg_surface_iterator_func_t iterator, - void *user_data) { - struct surface_iterator_data data = { - .user_iterator = iterator, - .user_data = user_data, - .output = output, - .ox = ox, - .oy = oy, - }; - - wlr_surface_for_each_surface(surface, output_for_each_surface_iterator, - &data); -} - -static void -output_view_for_each_surface(struct cg_output *output, struct cg_view *view, - cg_surface_iterator_func_t iterator, - void *user_data) { - struct surface_iterator_data data = { - .user_iterator = iterator, - .user_data = user_data, - .output = output, - .ox = view->ox, - .oy = view->oy, - }; - - view_for_each_surface(view, output_for_each_surface_iterator, &data); -} - -void -output_view_for_each_popup(struct cg_output *output, struct cg_view *view, - cg_surface_iterator_func_t iterator, - void *user_data) { - struct surface_iterator_data data = { - .user_iterator = iterator, - .user_data = user_data, - .output = output, - .ox = view->ox, - .oy = view->oy, - }; - - view_for_each_popup(view, output_for_each_surface_iterator, &data); -} - -void -output_drag_icons_for_each_surface(struct cg_output *output, - struct wl_list *drag_icons, - cg_surface_iterator_func_t iterator, - void *user_data) { - struct cg_drag_icon *drag_icon; - wl_list_for_each(drag_icon, drag_icons, link) { - if(drag_icon->wlr_drag_icon->mapped) { - double ox = drag_icon->lx; - double oy = drag_icon->ly; - wlr_output_layout_output_coords(output->server->output_layout, - output->wlr_output, &ox, &oy); - output_surface_for_each_surface(output, - drag_icon->wlr_drag_icon->surface, - ox, oy, iterator, user_data); - } - } -} - -static void -output_for_each_surface(struct cg_output *output, - cg_surface_iterator_func_t iterator, void *user_data) { - struct cg_view *view; - wl_list_for_each_reverse( - view, &output->workspaces[output->curr_workspace]->views, link) { - output_view_for_each_surface(output, view, iterator, user_data); - } - - wl_list_for_each_reverse( - view, &output->workspaces[output->curr_workspace]->unmanaged_views, - link) { - output_view_for_each_surface(output, view, iterator, user_data); - } - - output_drag_icons_for_each_surface( - output, &output->server->seat->drag_icons, iterator, user_data); -} - -struct send_frame_done_data { - struct timespec when; -}; - -static void -send_frame_done_iterator(struct cg_output *output, struct wlr_surface *surface, - struct wlr_box *box, void *user_data) { - struct send_frame_done_data *data = user_data; - wlr_surface_send_frame_done(surface, &data->when); -} - -static void -send_frame_done(struct cg_output *output, struct send_frame_done_data *data) { - output_for_each_surface(output, send_frame_done_iterator, data); -} - -struct damage_data { - bool whole; -}; - -static void -count_surface_iterator(struct cg_output *output, struct wlr_surface *surface, - struct wlr_box *_box, void *data) { - size_t *n = data; - (*n)++; -} - -static bool -scan_out_primary_view(struct cg_output *output) { +output_clear(struct cg_output *output) { struct cg_server *server = output->server; - struct wlr_output *wlr_output = output->wlr_output; + wlr_output_layout_remove(server->output_layout, output->wlr_output); - if(!wl_list_empty(&output->messages)) { - return false; + if(server->running && server->curr_output == output && + wl_list_length(&server->outputs) > 1) { + keybinding_cycle_outputs(server, false, true); } - struct cg_drag_icon *drag_icon; - wl_list_for_each(drag_icon, &server->seat->drag_icons, link) { - if(drag_icon->wlr_drag_icon->mapped) { - return false; + wl_list_remove(&output->link); + + message_clear(output); + + struct cg_view *view, *view_tmp; + if(server->running) { + for(unsigned int i = 0; i < server->nws; ++i) { + + bool first = true; + for(struct cg_tile *tile = output->workspaces[i]->focused_tile; + first || output->workspaces[i]->focused_tile != tile; + tile = tile->next) { + first = false; + workspace_tile_update_view(tile, NULL); + } + struct cg_workspace *ws = + server->curr_output + ->workspaces[server->curr_output->curr_workspace]; + wl_list_for_each_safe(view, view_tmp, &output->workspaces[i]->views, + link) { + wl_list_remove(&view->link); + if(wl_list_empty(&server->outputs)) { + view->impl->destroy(view); + } else { + wl_list_insert(&ws->views, &view->link); + wlr_scene_node_reparent(&view->scene_tree->node, ws->scene); + view->workspace = ws; + view->tile = ws->focused_tile; + if(server->seat->focused_view == NULL) { + seat_set_focus(server->seat, view); + } + } + } + wl_list_for_each_safe( + view, view_tmp, &output->workspaces[i]->unmanaged_views, link) { + wl_list_remove(&view->link); + if(wl_list_empty(&server->outputs)) { + view->impl->destroy(view); + } else { + wl_list_insert(&ws->unmanaged_views, &view->link); + wlr_scene_node_reparent(&view->scene_tree->node, ws->scene); + view->workspace = ws; + view->tile = ws->focused_tile; + } + } } } +} - struct cg_workspace *ws = output->workspaces[output->curr_workspace]; - if(ws->focused_tile->next != ws->focused_tile) { - return false; - } - - struct cg_view *view = ws->focused_tile->view; - if(view == NULL || view->wlr_surface == NULL) { - return false; - } - - size_t n_surfaces = 0; - output_view_for_each_surface(output, view, count_surface_iterator, - &n_surfaces); - if(n_surfaces > 1) { - return false; - } - -#if CG_HAS_XWAYLAND - if(view->type == CG_XWAYLAND_VIEW) { - struct cg_xwayland_view *xwayland_view = xwayland_view_from_view(view); - if(!wl_list_empty(&xwayland_view->xwayland_surface->children) || - !wl_list_empty(&view->workspace->unmanaged_views)) { - return false; +int +output_get_num(const struct cg_output *output) { + struct cg_output *it; + int count = 1; + wl_list_for_each(it, &output->server->outputs, link) { + if(strcmp(output->wlr_output->name, it->wlr_output->name) == 0) { + return count; } + ++count; } -#endif - - struct wlr_surface *surface = view->wlr_surface; - - if(!surface->buffer) { - return false; - } - - if((float)surface->current.scale != wlr_output->scale || - surface->current.transform != wlr_output->transform) { - return false; - } - - wlr_output_attach_buffer(wlr_output, &surface->buffer->base); - if(!wlr_output_test(wlr_output)) { - return false; - } - return wlr_output_commit(wlr_output); + return -1; } static void -damage_surface_iterator(struct cg_output *output, struct wlr_surface *surface, - struct wlr_box *box, void *user_data) { - struct wlr_output *wlr_output = output->wlr_output; - struct damage_data *data = (struct damage_data *)user_data; - bool whole = data->whole; +output_destroy(struct cg_output *output) { + struct cg_server *server = output->server; + char *outp_name = strdup(output->wlr_output->name); + int outp_num = output_get_num(output); - scale_box(box, output->wlr_output->scale); + wl_list_remove(&output->destroy.link); + wl_list_remove(&output->mode.link); + wl_list_remove(&output->commit.link); + wl_list_remove(&output->frame.link); - if(whole) { - wlr_output_damage_add_box(output->damage, box); - } else if(pixman_region32_not_empty(&surface->buffer_damage)) { - pixman_region32_t damage; - pixman_region32_init(&damage); - wlr_surface_get_effective_damage(surface, &damage); + output_clear(output); - if(ceil(wlr_output->scale) > surface->current.scale) { - /* When scaling up a surface it'll become - blurry, so we need to expand the damage - region. */ - wlr_region_expand(&damage, &damage, - ceil(wlr_output->scale) - surface->current.scale); - } - pixman_region32_translate(&damage, box->x, box->y); - wlr_output_damage_add(output->damage, &damage); - pixman_region32_fini(&damage); + /*Important: due to unfortunate events, "workspace" and "output->workspace" + * have nothing in common. The former is the workspace of a single output, + * whereas the latter is the workspace of the outputs.*/ + for(unsigned int i = 0; i < server->nws; ++i) { + workspace_free(output->workspaces[i]); + } + free(output->workspaces); + + free(output); + + if(outp_name != NULL) { + ipc_send_event(server, + "{\"event_name\":\"destroy_output\",\"output\":\"%s\"," + "\"output_id\":%d}", + outp_name, outp_num); + free(outp_name); + } else { + wlr_log(WLR_ERROR, + "Failed to allocate memory for output name in output_destroy"); + } + if(wl_list_empty(&server->outputs)) { + wl_display_terminate(server->wl_display); } } -void -output_damage_surface(struct cg_output *output, struct wlr_surface *surface, - double ox, double oy, bool whole) { - struct damage_data data = { - .whole = whole, - }; - - output_surface_for_each_surface(output, surface, ox, oy, - damage_surface_iterator, &data); +static void +handle_output_destroy(struct wl_listener *listener, void *data) { + struct cg_output *output = wl_container_of(listener, output, destroy); + output_destroy(output); } static void -handle_output_damage_frame(struct wl_listener *listener, void *data) { - struct cg_output *output = wl_container_of(listener, output, damage_frame); - struct send_frame_done_data frame_data = {0}; - +handle_output_frame(struct wl_listener *listener, void *data) { + struct cg_output *output = wl_container_of(listener, output, frame); if(!output->wlr_output->enabled) { return; } + struct wlr_scene_output *scene_output = + wlr_scene_get_scene_output(output->server->scene, output->wlr_output); + if(scene_output == NULL) { + return; + } + wlr_scene_output_commit(scene_output); - bool scanned_out = scan_out_primary_view(output); + struct timespec now = {0}; + clock_gettime(CLOCK_MONOTONIC, &now); + wlr_scene_output_send_frame_done(scene_output, &now); +} - if(scanned_out && !output->last_scanned_out_view) { - wlr_log(WLR_DEBUG, "Scanning out primary view"); - } - if(output->last_scanned_out_view && !scanned_out) { - wlr_log(WLR_DEBUG, "Stopping primary view scan out"); - wlr_output_damage_add_whole(output->damage); - output->last_scanned_out_view = NULL; - } - if(output->last_scanned_out_view && - output->last_scanned_out_view != seat_get_focus(output->server->seat)) { - wlr_output_damage_add_whole(output->damage); - } - if(scanned_out) { - output->last_scanned_out_view = - output->workspaces[output->curr_workspace]->focused_tile->view; +static int +output_set_mode(struct wlr_output *output, int width, int height, + float refresh_rate) { + int mhz = (int)(refresh_rate * 1000); + + if(wl_list_empty(&output->modes)) { + wlr_log(WLR_DEBUG, "Assigning custom mode to %s", output->name); + wlr_output_set_custom_mode(output, width, height, + refresh_rate > 0 ? mhz : 0); + return 0; } - if(scanned_out) { - goto frame_done; + struct wlr_output_mode *mode, *best = NULL; + wl_list_for_each(mode, &output->modes, link) { + if(mode->width == width && mode->height == height) { + if(mode->refresh == mhz) { + best = mode; + break; + } + if(best == NULL || mode->refresh > best->refresh) { + best = mode; + } + } + } + if(!best) { + wlr_log(WLR_ERROR, "Configured mode for %s not available", + output->name); + wlr_log(WLR_INFO, "Picking preferred mode instead"); + best = wlr_output_preferred_mode(output); + } else { + wlr_log(WLR_DEBUG, "Assigning configured mode to %s", output->name); + } + wlr_output_set_mode(output, best); + wlr_output_commit(output); + if(!wlr_output_test(output)) { + wlr_log(WLR_ERROR, + "Unable to assign configured mode to %s, picking arbitrary " + "available mode", + output->name); + struct wlr_output_mode *mode; + wl_list_for_each(mode, &output->modes, link) { + if(mode == best) { + continue; + } + wlr_output_set_mode(output, mode); + wlr_output_commit(output); + if(wlr_output_test(output)) { + break; + } + } + if(!wlr_output_test(output)) { + return 1; + } + } + return 0; +} + +void +output_insert(struct cg_server *server, struct cg_output *output) { + struct cg_output *it, *prev_it = NULL; + bool first = true; + wl_list_for_each(it, &server->outputs, link) { + if(it->priority < output->priority) { + if(first == true) { + wl_list_insert(&server->outputs, &output->link); + } else { + wl_list_insert(it->link.prev, &output->link); + } + return; + } + first = false; + prev_it = it; + } + if(prev_it == NULL) { + wl_list_insert(&server->outputs, &output->link); + } else { + wl_list_insert(&prev_it->link, &output->link); + } +} + +void +output_apply_config(struct cg_server *server, struct cg_output *output, + struct cg_output_config *config) { + struct wlr_output *wlr_output = output->wlr_output; + + if(output->wlr_output->enabled) { + wlr_output_layout_remove(server->output_layout, wlr_output); } - bool needs_frame; - pixman_region32_t damage; - pixman_region32_init(&damage); - if(!wlr_output_damage_attach_render(output->damage, &needs_frame, - &damage)) { - wlr_log(WLR_ERROR, "Cannot make damage output current"); - goto damage_finish; + if(config->priority != -1) { + output->priority = config->priority; } - if(!needs_frame) { - wlr_output_rollback(output->wlr_output); - goto damage_finish; + if(config->angle != -1) { + wlr_output_set_transform(wlr_output, config->angle); + } + if(config->scale != -1) { + wlr_log(WLR_INFO, "Setting output scale to %f", config->scale); + wlr_output_set_scale(wlr_output, config->scale); + } + if(config->pos.x != -1) { + if(output_set_mode(wlr_output, config->pos.width, config->pos.height, + config->refresh_rate) != 0) { + wlr_log(WLR_ERROR, "Setting output mode failed, disabling output."); + output_clear(output); + wl_list_insert(&server->disabled_outputs, &output->link); + wlr_output_enable(wlr_output, false); + wlr_output_commit(wlr_output); + return; + } + wlr_output_layout_add(server->output_layout, wlr_output, config->pos.x, + config->pos.y); + /* Since the size of the output may have changed, we + * reinitialize all workspaces with a fullscreen layout */ + for(unsigned int i = 0; i < output->server->nws; ++i) { + output_make_workspace_fullscreen(output, i); + } + } else { + wlr_output_layout_add_auto(server->output_layout, wlr_output); + + struct wlr_output_mode *preferred_mode = + wlr_output_preferred_mode(wlr_output); + if(preferred_mode) { + wlr_output_set_mode(wlr_output, preferred_mode); + } + } + /* Refuse to disable the only output */ + if(config->status == OUTPUT_DISABLE && + wl_list_length(&server->outputs) > 1) { + output_clear(output); + wl_list_insert(&server->disabled_outputs, &output->link); + wlr_output_enable(wlr_output, false); + wlr_output_commit(wlr_output); + } else { + wl_list_remove(&output->link); + output_insert(server, output); + wlr_output_enable(wlr_output, true); + wlr_output_commit(wlr_output); } - output_render(output, &damage); + if(output->bg != NULL) { + wlr_scene_node_destroy(&output->bg->node); + output->bg = NULL; + } + struct wlr_scene_output *scene_output = + wlr_scene_get_scene_output(output->server->scene, output->wlr_output); + if(scene_output == NULL) { + return; + } + output->bg = wlr_scene_rect_create( + &scene_output->scene->tree, output->wlr_output->width, + output->wlr_output->height, server->bg_color); + struct wlr_box box; + wlr_output_layout_get_box(server->output_layout, output->wlr_output, &box); + wlr_scene_node_set_position(&output->bg->node, box.x, box.y); + wlr_scene_node_lower_to_bottom(&output->bg->node); +} -damage_finish: - pixman_region32_fini(&damage); +struct cg_output_config * +empty_output_config() { + struct cg_output_config *cfg = calloc(1, sizeof(struct cg_output_config)); + if(cfg == NULL) { + wlr_log(WLR_ERROR, "Could not allocate output configuration."); + return NULL; + } -frame_done: - clock_gettime(CLOCK_MONOTONIC, &frame_data.when); - send_frame_done(output, &frame_data); + cfg->status = OUTPUT_DEFAULT; + cfg->pos.x = -1; + cfg->pos.y = -1; + cfg->pos.width = -1; + cfg->pos.height = -1; + cfg->output_name = NULL; + cfg->refresh_rate = 0; + cfg->priority = -1; + cfg->scale = -1; + cfg->angle = -1; + + return cfg; +} + +/* cfg1 has precedence over cfg2 */ +struct cg_output_config * +merge_output_configs(struct cg_output_config *cfg1, + struct cg_output_config *cfg2) { + struct cg_output_config *out_cfg = empty_output_config(); + if(cfg1->status == out_cfg->status) { + out_cfg->status = cfg2->status; + } else { + out_cfg->status = cfg1->status; + } + if(cfg1->pos.x == out_cfg->pos.x) { + out_cfg->pos.x = cfg2->pos.x; + out_cfg->pos.y = cfg2->pos.y; + out_cfg->pos.width = cfg2->pos.width; + out_cfg->pos.height = cfg2->pos.height; + } else { + out_cfg->pos.x = cfg1->pos.x; + out_cfg->pos.y = cfg1->pos.y; + out_cfg->pos.width = cfg1->pos.width; + out_cfg->pos.height = cfg1->pos.height; + } + if(cfg1->output_name == NULL) { + if(cfg2->output_name == NULL) { + out_cfg->output_name = NULL; + } else { + out_cfg->output_name = strdup(cfg2->output_name); + } + } else { + out_cfg->output_name = strdup(cfg1->output_name); + } + if(cfg1->refresh_rate == out_cfg->refresh_rate) { + out_cfg->refresh_rate = cfg2->refresh_rate; + } else { + out_cfg->refresh_rate = cfg1->refresh_rate; + } + if(cfg1->priority == out_cfg->priority) { + out_cfg->priority = cfg2->priority; + } else { + out_cfg->priority = cfg1->priority; + } + if(cfg1->scale == out_cfg->scale) { + out_cfg->scale = cfg2->scale; + } else { + out_cfg->scale = cfg1->scale; + } + if(cfg1->angle == out_cfg->angle) { + out_cfg->status = cfg2->angle; + } else { + out_cfg->angle = cfg1->angle; + } + return out_cfg; +} + +void +output_configure(struct cg_server *server, struct cg_output *output) { + struct cg_output_config *tot_config = empty_output_config(); + struct cg_output_config *config; + wl_list_for_each(config, &server->output_config, link) { + if(strcmp(config->output_name, output->wlr_output->name) == 0) { + if(tot_config == NULL) { + return; + } + struct cg_output_config *prev_config = tot_config; + tot_config = merge_output_configs(config, tot_config); + if(prev_config->output_name != NULL) { + free(prev_config->output_name); + } + free(prev_config); + } + } + if(tot_config != NULL) { + output_apply_config(server, output, tot_config); + } + free(tot_config->output_name); + free(tot_config); } static void @@ -408,203 +469,35 @@ handle_output_mode(struct wl_listener *listener, void *data) { } void -output_clear(struct cg_output *output) { +output_make_workspace_fullscreen(struct cg_output *output, int ws) { struct cg_server *server = output->server; - wlr_output_layout_remove(server->output_layout, output->wlr_output); + struct cg_view *current_view = seat_get_focus(server->seat); - if(server->running && server->curr_output == output && - wl_list_length(&server->outputs) > 1) { - keybinding_cycle_outputs(server, false); - } - - wl_list_remove(&output->link); - - message_clear(output); - - struct cg_view *view, *view_tmp; - if(server->running) { - for(unsigned int i = 0; i < server->nws; ++i) { - - bool first = true; - for(struct cg_tile *tile = output->workspaces[i]->focused_tile; - first || output->workspaces[i]->focused_tile != tile; - tile = tile->next) { - first = false; - tile->view = NULL; - } - wl_list_for_each_safe(view, view_tmp, &output->workspaces[i]->views, - link) { - wl_list_remove(&view->link); - if(wl_list_empty(&server->outputs)) { - view->impl->destroy(view); - } else { - wl_list_insert( - &server->curr_output - ->workspaces[server->curr_output->curr_workspace] - ->views, - &view->link); - view->workspace = - server->curr_output - ->workspaces[server->curr_output->curr_workspace]; - view->tile = - server->curr_output - ->workspaces[server->curr_output->curr_workspace] - ->focused_tile; - if(server->seat->focused_view == NULL) { - seat_set_focus(server->seat, view); - } - } - } - wl_list_for_each_safe( - view, view_tmp, &output->workspaces[i]->unmanaged_views, link) { - wl_list_remove(&view->link); - if(wl_list_empty(&server->outputs)) { - view->impl->destroy(view); - } else { - wl_list_insert( - &server->curr_output - ->workspaces[server->curr_output->curr_workspace] - ->unmanaged_views, - &view->link); - view->workspace = - server->curr_output - ->workspaces[server->curr_output->curr_workspace]; - view->tile = - server->curr_output - ->workspaces[server->curr_output->curr_workspace] - ->focused_tile; - } - } - } - } -} - -static void -output_destroy(struct cg_output *output) { - struct cg_server *server = output->server; - - wl_list_remove(&output->destroy.link); - wl_list_remove(&output->mode.link); - wl_list_remove(&output->commit.link); - wl_list_remove(&output->damage_frame.link); - wl_list_remove(&output->damage_destroy.link); - - output_clear(output); - - /*Important: due to unfortunate events, "workspace" and "output->workspace" - * have nothing in common. The former is the workspace of a single output, - * whereas the latter is the workspace of the outputs.*/ - for(unsigned int i = 0; i < server->nws; ++i) { - workspace_free(output->workspaces[i]); - } - free(output->workspaces); - - free(output); - - if(wl_list_empty(&server->outputs)) { - wl_display_terminate(server->wl_display); - } -} - -static void -handle_output_damage_destroy(struct wl_listener *listener, void *data) { - struct cg_output *output = - wl_container_of(listener, output, damage_destroy); - output_destroy(output); -} - -static void -handle_output_destroy(struct wl_listener *listener, void *data) { - struct cg_output *output = wl_container_of(listener, output, destroy); - wlr_output_damage_destroy(output->damage); - output_destroy(output); -} - -struct cg_output_config * -output_find_config(struct cg_server *server, struct wlr_output *output) { - struct cg_output_config *config; - wl_list_for_each(config, &server->output_config, link) { - if(strcmp(config->output_name, output->name) == 0) { - return config; - } - } - return NULL; -} - -static void -output_set_mode(struct wlr_output *output, int width, int height, - float refresh_rate) { - int mhz = (int)(refresh_rate * 1000); - - if(wl_list_empty(&output->modes)) { - wlr_log(WLR_DEBUG, "Assigning custom mode to %s", output->name); - wlr_output_set_custom_mode(output, width, height, - refresh_rate > 0 ? mhz : 0); - return; - } - - struct wlr_output_mode *mode, *best = NULL; - wl_list_for_each(mode, &output->modes, link) { - if(mode->width == width && mode->height == height) { - if(mode->refresh == mhz) { - best = mode; + if(current_view == NULL || ws != output->curr_workspace) { + struct cg_view *it = NULL; + wl_list_for_each(it, &output->workspaces[ws]->views, link) { + if(view_is_visible(it)) { + current_view = it; break; } - if(best == NULL || mode->refresh > best->refresh) { - best = mode; - } } } - if(!best) { - wlr_log(WLR_ERROR, "Configured mode for %s not available", - output->name); - wlr_log(WLR_INFO, "Picking preferred mode instead"); - best = wlr_output_preferred_mode(output); - } else { - wlr_log(WLR_DEBUG, "Assigning configured mode to %s", output->name); - } - wlr_output_set_mode(output, best); -} -void -output_configure(struct cg_server *server, struct cg_output *output) { - struct wlr_output *wlr_output = output->wlr_output; - struct cg_output_config *config = output_find_config(server, wlr_output); - /* Refuse to disable the only output */ - if(config != NULL && config->status == OUTPUT_DISABLE && - wl_list_length(&server->outputs) == 1) { + workspace_free_tiles(output->workspaces[ws]); + if(full_screen_workspace_tiles(server->output_layout, output->wlr_output, + output->workspaces[ws], + &server->tiles_curr_id) != 0) { + wlr_log(WLR_ERROR, "Failed to allocate space for fullscreen workspace"); return; } - if(output->wlr_output->enabled) { - wlr_output_layout_remove(server->output_layout, wlr_output); + + struct cg_view *it_view; + wl_list_for_each(it_view, &output->workspaces[ws]->views, link) { + it_view->tile = output->workspaces[ws]->focused_tile; } - if(config == NULL || config->status == OUTPUT_ENABLE) { - wlr_output_layout_add_auto(server->output_layout, wlr_output); - - struct wlr_output_mode *preferred_mode = - wlr_output_preferred_mode(wlr_output); - if(preferred_mode) { - wlr_output_set_mode(wlr_output, preferred_mode); - } - wl_list_remove(&output->link); - wl_list_insert(&server->outputs, &output->link); - wlr_output_enable(wlr_output, true); - wlr_output_commit(wlr_output); - } else if(config->status == OUTPUT_DISABLE) { - output_clear(output); - wl_list_insert(&server->disabled_outputs, &output->link); - wlr_output_enable(wlr_output, false); - wlr_output_commit(wlr_output); - } else { - wl_list_remove(&output->link); - wl_list_insert(&server->outputs, &output->link); - output_set_mode(wlr_output, config->pos.width, config->pos.height, - config->refresh_rate); - wlr_output_layout_add(server->output_layout, wlr_output, config->pos.x, - config->pos.y); - wlr_output_enable(wlr_output, true); - wlr_output_commit(wlr_output); + if(ws == output->curr_workspace) { + seat_set_focus(server->seat, current_view); } } @@ -631,24 +524,19 @@ handle_new_output(struct wl_listener *listener, void *data) { output->wlr_output = wlr_output; output->server = server; - output->damage = wlr_output_damage_create(wlr_output); output->last_scanned_out_view = NULL; - output->mode.notify = handle_output_mode; - wl_signal_add(&wlr_output->events.mode, &output->mode); - output->commit.notify = handle_output_commit; - wl_signal_add(&wlr_output->events.commit, &output->commit); - output->destroy.notify = handle_output_destroy; - wl_signal_add(&wlr_output->events.destroy, &output->destroy); - output->damage_frame.notify = handle_output_damage_frame; - wl_signal_add(&output->damage->events.frame, &output->damage_frame); - output->damage_destroy.notify = handle_output_damage_destroy; - wl_signal_add(&output->damage->events.destroy, &output->damage_destroy); - - wlr_output_set_transform(wlr_output, server->output_transform); + struct cg_output_priorities *it; + int prio = -1; + wl_list_for_each(it, &server->output_priorities, link) { + if(strcmp(output->wlr_output->name, it->ident) == 0) { + prio = it->priority; + } + } + output->priority = prio; + wlr_output_set_transform(wlr_output, WL_OUTPUT_TRANSFORM_NORMAL); output->workspaces = NULL; - output->curr_workspace = 0; wl_list_init(&output->messages); if(!wlr_xcursor_manager_load(server->seat->xcursor_manager, @@ -658,9 +546,8 @@ handle_new_output(struct wl_listener *listener, void *data) { wlr_output->name, wlr_output->scale); } - wl_list_insert(&server->outputs, &output->link); + output_insert(server, output); output_configure(server, output); - wlr_output_damage_add_whole(output->damage); output->workspaces = malloc(server->nws * sizeof(struct cg_workspace *)); for(unsigned int i = 0; i < server->nws; ++i) { @@ -669,10 +556,14 @@ handle_new_output(struct wl_listener *listener, void *data) { wlr_log(WLR_ERROR, "Failed to allocate workspaces for output"); return; } + output->workspaces[i]->num = i; wl_list_init(&output->workspaces[i]->views); wl_list_init(&output->workspaces[i]->unmanaged_views); } + wlr_scene_node_raise_to_top(&output->workspaces[0]->scene->node); + workspace_focus(output, 0); + /* We are the first output. Set the current output to this one. */ if(server->curr_output == NULL) { server->curr_output = output; @@ -680,20 +571,21 @@ handle_new_output(struct wl_listener *listener, void *data) { wlr_xcursor_manager_set_cursor_image(server->seat->xcursor_manager, DEFAULT_XCURSOR, server->seat->cursor); wlr_cursor_warp(server->seat->cursor, NULL, 0, 0); + + output->destroy.notify = handle_output_destroy; + wl_signal_add(&wlr_output->events.destroy, &output->destroy); + output->frame.notify = handle_output_frame; + wl_signal_add(&wlr_output->events.frame, &output->frame); + output->commit.notify = handle_output_commit; + wl_signal_add(&wlr_output->events.commit, &output->commit); + output->mode.notify = handle_output_mode; + wl_signal_add(&wlr_output->events.mode, &output->mode); + ipc_send_event(server, + "{\"event_name\":\"new_output\",\"output\":\"%s\",\"output_" + "id\":%d,\"priority\":%d}", + output->wlr_output->name, output_get_num(output), + output->priority); } #if CG_HAS_FANALYZE #pragma GCC diagnostic pop #endif - -void -output_set_window_title(struct cg_output *output, const char *title) { - struct wlr_output *wlr_output = output->wlr_output; - - if(wlr_output_is_wl(wlr_output)) { - wlr_wl_output_set_title(wlr_output, title); -#if WLR_HAS_X11_BACKEND - } else if(wlr_output_is_x11(wlr_output)) { - wlr_x11_output_set_title(wlr_output, title); -#endif - } -} diff --git a/output.h b/output.h index ca44a6b..0a255df 100644 --- a/output.h +++ b/output.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_OUTPUT_H #define CG_OUTPUT_H @@ -7,19 +10,17 @@ struct cg_server; struct cg_view; struct wlr_output; -struct wlr_output_damage; struct wlr_surface; struct cg_output { struct cg_server *server; struct wlr_output *wlr_output; - struct wlr_output_damage *damage; + struct wlr_scene_rect *bg; struct wl_listener mode; struct wl_listener commit; struct wl_listener destroy; - struct wl_listener damage_frame; - struct wl_listener damage_destroy; + struct wl_listener frame; struct cg_workspace **workspaces; struct wl_list messages; int curr_workspace; @@ -42,7 +43,9 @@ struct cg_output_config { struct wlr_box pos; char *output_name; float refresh_rate; + float scale; int priority; + int angle; // enum wl_output_transform, -1 signifies "unspecified" struct wl_list link; // cg_server::output_config }; @@ -56,23 +59,9 @@ handle_new_output(struct wl_listener *listener, void *data); void output_configure(struct cg_server *server, struct cg_output *output); void -output_surface_for_each_surface(struct cg_output *output, - struct wlr_surface *surface, double ox, - double oy, cg_surface_iterator_func_t iterator, - void *user_data); -void -output_view_for_each_popup(struct cg_output *output, struct cg_view *view, - cg_surface_iterator_func_t iterator, - void *user_data); -void -output_drag_icons_for_each_surface(struct cg_output *output, - struct wl_list *drag_icons, - cg_surface_iterator_func_t iterator, - void *user_data); -void -output_damage_surface(struct cg_output *output, struct wlr_surface *surface, - double ox, double oy, bool whole); -void output_set_window_title(struct cg_output *output, const char *title); - +void +output_make_workspace_fullscreen(struct cg_output *output, int ws); +int +output_get_num(const struct cg_output *output); #endif diff --git a/pango.c b/pango.c index e9d04d3..c513f97 100644 --- a/pango.c +++ b/pango.c @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #include #include #include diff --git a/pango.h b/pango.h index fed8371..30f2865 100644 --- a/pango.h +++ b/pango.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef _SWAY_PANGO_H #define _SWAY_PANGO_H #include diff --git a/parse.c b/parse.c index 92a8943..d250439 100644 --- a/parse.c +++ b/parse.c @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #define _POSIX_C_SOURCE 200812L #include @@ -75,12 +78,13 @@ parse_key(struct keybinding *keybinding, const char *key_def, char **errstr) { int parse_command(struct cg_server *server, struct keybinding *keybinding, - char *saveptr, char **errstr); + char *saveptr, char **errstr, int nesting_level); /* Parse a keybinding definition and return it if successful, else return NULL */ struct keybinding * -parse_keybinding(struct cg_server *server, char **saveptr, char **errstr) { +parse_keybinding(struct cg_server *server, char **saveptr, char **errstr, + int nesting_level) { struct keybinding *keybinding = malloc(sizeof(struct keybinding)); if(keybinding == NULL) { *errstr = log_error( @@ -93,7 +97,8 @@ parse_keybinding(struct cg_server *server, char **saveptr, char **errstr) { free(keybinding); return NULL; } - if(parse_command(server, keybinding, *saveptr, errstr) != 0) { + if(parse_command(server, keybinding, *saveptr, errstr, nesting_level + 1) != + 0) { free(keybinding); return NULL; } @@ -116,9 +121,28 @@ parse_float(char **saveptr, const char *delim) { } } +int +parse_uint(char **saveptr, const char *delim) { + char *uint_str = strtok_r(NULL, delim, saveptr); + if(uint_str == NULL) { + wlr_log(WLR_ERROR, "Expected a non-negative integer, got nothing"); + return -1; + } + long uint = strtol(uint_str, NULL, 10); + if(uint >= 0 && uint <= INT_MAX) { + return uint; + } else { + wlr_log(WLR_ERROR, + "Error parsing non-negative integer. Must be a number larger " + "or equal to 0 and less or equal to %d", + INT_MAX); + return -1; + } +} + struct cg_input_config * parse_input_config(char **saveptr, char **errstr) { - struct cg_input_config *cfg = calloc(1, sizeof(struct cg_input_config)); + struct cg_input_config *cfg = input_manager_create_empty_input_config(); char *value = NULL; char *ident = NULL; if(cfg == NULL) { @@ -127,28 +151,6 @@ parse_input_config(char **saveptr, char **errstr) { goto error; } - cfg->tap = INT_MIN; - cfg->tap_button_map = INT_MIN; - cfg->drag = INT_MIN; - cfg->drag_lock = INT_MIN; - cfg->dwt = INT_MIN; - cfg->send_events = INT_MIN; - cfg->click_method = INT_MIN; - cfg->middle_emulation = INT_MIN; - cfg->natural_scroll = INT_MIN; - cfg->accel_profile = INT_MIN; - cfg->pointer_accel = FLT_MIN; - cfg->scroll_factor = FLT_MIN; - cfg->scroll_button = INT_MIN; - cfg->scroll_method = INT_MIN; - cfg->left_handed = INT_MIN; - /*cfg->repeat_delay = INT_MIN; - cfg->repeat_rate = INT_MIN; - cfg->xkb_numlock = INT_MIN; - cfg->xkb_capslock = INT_MIN; - cfg->xkb_file_is_set = false; - wl_list_init(&cfg->tools);*/ - ident = strtok_r(NULL, " ", saveptr); if(ident == NULL) { @@ -341,6 +343,32 @@ parse_input_config(char **saveptr, char **errstr) { "Invalid option \"%s\" to setting \"tap_button_map\"", value); goto error; } + } else if(strcmp(setting, "keybindings") == 0) { + if(strcmp(value, "enabled") == 0) { + cfg->enable_keybindings = true; + } else if(strcmp(value, "disabled") == 0) { + cfg->enable_keybindings = false; + } else { + *errstr = log_error( + "Invalid option \"%s\" to setting \"keybindings\"", value); + goto error; + } + } else if(strcmp(setting, "repeat_delay") == 0) { + cfg->repeat_delay = parse_uint(saveptr, " "); + if(cfg->repeat_delay < 0) { + *errstr = log_error("Invalid option \"%s\" to setting " + "\"repeat_delay\", expected positive integer", + value); + goto error; + } + } else if(strcmp(setting, "repeat_rate") == 0) { + cfg->repeat_rate = parse_uint(saveptr, " "); + if(cfg->repeat_rate < 0) { + *errstr = log_error("Invalid option \"%s\" to setting " + "\"repeat_rate\", expected positive integer", + value); + goto error; + } } else { *errstr = log_error("Invalid option to command \"input\""); goto error; @@ -365,8 +393,10 @@ error: } struct keybinding * -parse_bind(struct cg_server *server, char **saveptr, char **errstr) { - struct keybinding *keybinding = parse_keybinding(server, saveptr, errstr); +parse_bind(struct cg_server *server, char **saveptr, char **errstr, + int nesting_level) { + struct keybinding *keybinding = + parse_keybinding(server, saveptr, errstr, nesting_level); if(keybinding == NULL) { wlr_log(WLR_ERROR, "Could not parse keybinding for \"bind\"."); return NULL; @@ -376,7 +406,8 @@ parse_bind(struct cg_server *server, char **saveptr, char **errstr) { } struct keybinding * -parse_definekey(struct cg_server *server, char **saveptr, char **errstr) { +parse_definekey(struct cg_server *server, char **saveptr, char **errstr, + int nesting_level) { char *mode = strtok_r(NULL, " ", saveptr); if(mode == NULL) { *errstr = @@ -388,7 +419,8 @@ parse_definekey(struct cg_server *server, char **saveptr, char **errstr) { *errstr = log_error("Unknown mode \"%s\"", mode); return NULL; } - struct keybinding *keybinding = parse_keybinding(server, saveptr, errstr); + struct keybinding *keybinding = + parse_keybinding(server, saveptr, errstr, nesting_level); if(keybinding == NULL) { wlr_log(WLR_ERROR, "Could not parse keybinding for \"definekey\""); return NULL; @@ -454,6 +486,21 @@ parse_escape(char **saveptr, char **errstr) { return keybinding; } +int +parse_cursor(char **saveptr, char **errstr) { + if(strcmp(*saveptr, "enable") == 0) { + return 1; + } else if(strcmp(*saveptr, "disable") == 0) { + return 0; + } else { + wlr_log(WLR_ERROR, + "Invalid option \"%s\" for \"cursor\". Expected \"enable\" or " + "\"disable\".", + *saveptr); + return -1; + } +} + char * parse_definemode(char **saveptr, char **errstr) { char *mode = strtok_r(NULL, " ", saveptr); @@ -481,25 +528,6 @@ parse_workspaces(char **saveptr, char **errstr) { return nws; } -int -parse_uint(char **saveptr, const char *delim) { - char *uint_str = strtok_r(NULL, delim, saveptr); - if(uint_str == NULL) { - wlr_log(WLR_ERROR, "Expected a non-negative integer, got nothing"); - return -1; - } - long uint = strtol(uint_str, NULL, 10); - if(uint >= 0 && uint <= INT_MAX) { - return uint; - } else { - wlr_log(WLR_ERROR, - "Error parsing non-negative integer. Must be a number larger " - "or equal to 0 and less or equal to %d", - INT_MAX); - return -1; - } -} - int parse_output_config_keyword(char *key_str, enum output_status *status) { if(key_str == NULL) { @@ -509,6 +537,10 @@ parse_output_config_keyword(char *key_str, enum output_status *status) { *status = OUTPUT_DEFAULT; } else if(strcmp(key_str, "prio") == 0) { *status = OUTPUT_DEFAULT; + } else if(strcmp(key_str, "rotate") == 0) { + *status = OUTPUT_DEFAULT; + } else if(strcmp(key_str, "scale") == 0) { + *status = OUTPUT_DEFAULT; } else if(strcmp(key_str, "enable") == 0) { *status = OUTPUT_ENABLE; } else if(strcmp(key_str, "disable") == 0) { @@ -532,6 +564,8 @@ parse_output_config(char **saveptr, char **errstr) { cfg->output_name = NULL; cfg->refresh_rate = 0; cfg->priority = -1; + cfg->scale = -1; + cfg->angle = -1; char *name = strtok_r(NULL, " ", saveptr); if(name == NULL) { *errstr = @@ -550,6 +584,19 @@ parse_output_config(char **saveptr, char **errstr) { return cfg; } + if(strcmp(key_str, "rotate") == 0) { + uint32_t angle = parse_uint(saveptr, " "); + // 360 degrees is equivalent to 0 degrees + cfg->angle = angle % 4; + if(cfg->angle < 0) { + *errstr = + log_error("Error parsing option rotate for output %s", name); + goto error; + } + cfg->output_name = strdup(name); + return cfg; + } + if(strcmp(key_str, "prio") == 0) { cfg->priority = parse_uint(saveptr, " "); if(cfg->priority < 0) { @@ -562,6 +609,19 @@ parse_output_config(char **saveptr, char **errstr) { return cfg; } + if(strcmp(key_str, "scale") == 0) { + cfg->scale = parse_float(saveptr, " "); + if(cfg->scale <= 0.0) { + *errstr = + log_error("Error parsing scale of output configuration for " + "output %s, expected positive float", + name); + goto error; + } + cfg->output_name = strdup(name); + return cfg; + } + cfg->pos.x = parse_uint(saveptr, " "); if(cfg->pos.x < 0) { *errstr = log_error( @@ -692,6 +752,9 @@ parse_message_config(char **saveptr, char **errstr) { return cfg; error: + if(cfg != NULL) { + free(cfg); + } wlr_log(WLR_ERROR, "Message configuration must be of the form " "'configure_message '"); return NULL; @@ -699,8 +762,13 @@ error: int parse_command(struct cg_server *server, struct keybinding *keybinding, - char *saveptr, char **errstr) { + char *saveptr, char **errstr, int nesting_level) { char *action = strtok_r(NULL, " ", &saveptr); + if(nesting_level >= MAX_NESTING_LEVEL) { + *errstr = + log_error("Nesting level of commands is too deep. Giving up."); + return -1; + } if(action == NULL) { *errstr = log_error("Expexted an action to parse, got none."); return -1; @@ -712,10 +780,29 @@ parse_command(struct cg_server *server, struct keybinding *keybinding, keybinding->action = KEYBINDING_SPLIT_HORIZONTAL; } else if(strcmp(action, "quit") == 0) { keybinding->action = KEYBINDING_QUIT; + } else if(strcmp(action, "dump") == 0) { + keybinding->action = KEYBINDING_DUMP; } else if(strcmp(action, "show_info") == 0) { keybinding->action = KEYBINDING_SHOW_INFO; } else if(strcmp(action, "close") == 0) { keybinding->action = KEYBINDING_CLOSE_VIEW; + } else if(strcmp(action, "focus_tile") == 0) { + keybinding->action = KEYBINDING_FOCUS_TILE; + char *nws_str = strtok_r(NULL, " ", &saveptr); + if(nws_str == NULL) { + *errstr = log_error( + "Expected argument for \"focus_tile\" action, got none."); + return -1; + } + + long tile_id = strtol(nws_str, NULL, 10); + if(tile_id < 1) { + *errstr = log_error( + "Tile id for focus_tile must be a positive integer. Got %l\n", + tile_id); + return -1; + } + keybinding->data.u = tile_id; } else if(strcmp(action, "focus") == 0) { keybinding->action = KEYBINDING_CYCLE_TILES; keybinding->data.b = false; @@ -899,13 +986,15 @@ parse_command(struct cg_server *server, struct keybinding *keybinding, keybinding->data.u = (unsigned int)mode_idx; } else if(strcmp(action, "bind") == 0) { keybinding->action = KEYBINDING_DEFINEKEY; - keybinding->data.kb = parse_bind(server, &saveptr, errstr); + keybinding->data.kb = + parse_bind(server, &saveptr, errstr, nesting_level); if(keybinding->data.kb == NULL) { return -1; } } else if(strcmp(action, "definekey") == 0) { keybinding->action = KEYBINDING_DEFINEKEY; - keybinding->data.kb = parse_definekey(server, &saveptr, errstr); + keybinding->data.kb = + parse_definekey(server, &saveptr, errstr, nesting_level); if(keybinding->data.kb == NULL) { return -1; } @@ -921,6 +1010,12 @@ parse_command(struct cg_server *server, struct keybinding *keybinding, if(keybinding->data.kb == NULL) { return -1; } + } else if(strcmp(action, "cursor") == 0) { + keybinding->action = KEYBINDING_CURSOR; + keybinding->data.i = parse_cursor(&saveptr, errstr); + if(keybinding->data.i < 0) { + return -1; + } } else if(strcmp(action, "definemode") == 0) { keybinding->action = KEYBINDING_DEFINEMODE; keybinding->data.c = parse_definemode(&saveptr, errstr); @@ -970,7 +1065,7 @@ parse_rc_line(struct cg_server *server, char *line, char **errstr) { free(saveptr); return -1; } - if(parse_command(server, keybinding, saveptr, errstr) != 0) { + if(parse_command(server, keybinding, saveptr, errstr, 1) != 0) { wlr_log(WLR_ERROR, "Error parsing command."); free(keybinding); free(saveptr); diff --git a/parse.h b/parse.h index 798d732..4e38ea9 100644 --- a/parse.h +++ b/parse.h @@ -1,9 +1,10 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef PARSE_H #define PARSE_H -#define MAX_LINE_SIZE 256 - #include struct cg_server; diff --git a/render.c b/render.c deleted file mode 100644 index 53ed0ea..0000000 --- a/render.c +++ /dev/null @@ -1,274 +0,0 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2020 Jente Hidskes - * Copyright (C) 2019 The Sway authors - * - * See the LICENSE file accompanying this file. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "message.h" -#include "output.h" -#include "seat.h" -#include "server.h" -#include "util.h" -#include "view.h" -#include "workspace.h" - -static void -scissor_output(struct wlr_output *output, pixman_box32_t *rect, - struct wlr_renderer *renderer) { - - struct wlr_box box = { - .x = rect->x1, - .y = rect->y1, - .width = rect->x2 - rect->x1, - .height = rect->y2 - rect->y1, - }; - - int output_width, output_height; - wlr_output_transformed_resolution(output, &output_width, &output_height); - enum wl_output_transform transform = - wlr_output_transform_invert(output->transform); - wlr_box_transform(&box, &box, transform, output_width, output_height); - - wlr_renderer_scissor(renderer, &box); -} - -struct render_data { - pixman_region32_t *damage; - int tile_width, tile_height; -}; - -static void -render_texture(struct wlr_output *wlr_output, pixman_region32_t *output_damage, - struct wlr_texture *texture, const struct wlr_box *box, - const float matrix[static 9], struct wlr_renderer *renderer) { - pixman_region32_t damage; - pixman_region32_init(&damage); - pixman_region32_union_rect(&damage, &damage, box->x, box->y, box->width, - box->height); - pixman_region32_intersect(&damage, &damage, output_damage); - if(!pixman_region32_not_empty(&damage)) { - goto damage_finish; - } - - int nrects; - pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects); - for(int i = 0; i < nrects; i++) { - scissor_output(wlr_output, &rects[i], renderer); - wlr_render_texture_with_matrix(renderer, texture, matrix, 1.0F); - } - -damage_finish: - pixman_region32_fini(&damage); -} - -static void -render_surface_iterator(struct cg_output *output, struct wlr_surface *surface, - struct wlr_box *box, void *user_data) { - struct render_data *data = user_data; - struct wlr_output *wlr_output = output->wlr_output; - pixman_region32_t *output_damage = data->damage; - - struct wlr_texture *texture = wlr_surface_get_texture(surface); - if(!texture) { - wlr_log(WLR_DEBUG, "Cannot obtain surface texture"); - return; - } - - scale_box(box, wlr_output->scale); - - float matrix[9]; - enum wl_output_transform transform = - wlr_output_transform_invert(surface->current.transform); - wlr_matrix_project_box(matrix, box, transform, 0.0F, - wlr_output->transform_matrix); - - if(data->tile_width != 0) { - box->width = - box->width > data->tile_width ? data->tile_width : box->width; - } - if(data->tile_height != 0) { - box->height = - box->height > data->tile_height ? data->tile_height : box->height; - } - render_texture(wlr_output, output_damage, texture, box, matrix, - output->server->renderer); -} - -static void -render_drag_icons(struct cg_output *output, pixman_region32_t *damage, - struct wl_list *drag_icons) { - struct render_data data = { - .damage = damage, - .tile_width = 0, - .tile_height = 0, - }; - output_drag_icons_for_each_surface(output, drag_icons, - render_surface_iterator, &data); -} - -/** - * Render all toplevels without descending into popups. - */ -static void -render_view_toplevels(struct cg_view *view, struct cg_output *output, - pixman_region32_t *damage) { - struct render_data data = { - .damage = damage, - .tile_width = 0, - .tile_height = 0, - }; - struct cg_tile *view_tile = view_get_tile(view); - if(view_tile != NULL) { - if(view_tile->tile.width != view->wlr_surface->current.width || - view_tile->tile.height != view->wlr_surface->current.height) { - view_damage_whole(view); - } - data.tile_width = view_tile->tile.width; - data.tile_height = view_tile->tile.height; - } - - double ox, oy; - ox = view->ox; - oy = view->oy; - output_surface_for_each_surface(output, view->wlr_surface, ox, oy, - render_surface_iterator, &data); -} - -static void -render_popup_iterator(struct cg_output *output, struct wlr_surface *surface, - struct wlr_box *box, void *data) { - /* Render this popup's surface. */ - render_surface_iterator(output, surface, box, data); - - /* Render this popup's child toplevels. */ - output_surface_for_each_surface(output, surface, box->x, box->y, - render_surface_iterator, data); -} - -static void -render_view_popups(struct cg_view *view, struct cg_output *output, - pixman_region32_t *damage) { - struct render_data data = { - .damage = damage, - .tile_width = 0, - .tile_height = 0, - }; - output_view_for_each_popup(output, view, render_popup_iterator, &data); -} - -void -output_render(struct cg_output *output, pixman_region32_t *damage) { - struct cg_server *server = output->server; - struct wlr_output *wlr_output = output->wlr_output; - - struct wlr_renderer *renderer = output->server->renderer; - if(!renderer) { - wlr_log(WLR_DEBUG, "Expected the output backend to have a renderer"); - return; - } - - wlr_renderer_begin(renderer, wlr_output->width, wlr_output->height); - - if(!pixman_region32_not_empty(damage)) { - wlr_log(WLR_DEBUG, "Output isn't damaged but needs a buffer swap"); - goto renderer_end; - } - -#ifdef DEBUG - if(server->debug_damage_tracking) { - wlr_renderer_clear(renderer, (float[]){1.0F, 0.0F, 0.0F, 1.0F}); - } -#endif - - int nrects; - pixman_box32_t *rects = pixman_region32_rectangles(damage, &nrects); - for(int i = 0; i < nrects; i++) { - scissor_output(wlr_output, &rects[i], renderer); - wlr_renderer_clear(renderer, server->bg_color); - } - - bool first = true; - for(struct cg_tile *tile = - output->workspaces[output->curr_workspace]->focused_tile; - first || - tile != output->workspaces[output->curr_workspace]->focused_tile; - tile = tile->next) { - first = false; - /* Only render visible views */ - if(tile->view != NULL) { - render_view_toplevels(tile->view, output, damage); - } - } - - struct cg_view *view; - wl_list_for_each_reverse( - view, &output->workspaces[output->curr_workspace]->unmanaged_views, - link) { - render_view_toplevels(view, output, damage); - } - - struct cg_view *focused_view = seat_get_focus(server->seat); - if(focused_view != NULL) { - render_view_popups(focused_view, output, damage); - } - - struct cg_message *message; - wl_list_for_each_reverse(message, &output->messages, link) { - float matrix[9]; - wlr_matrix_project_box(matrix, message->position, - WL_OUTPUT_TRANSFORM_NORMAL, 0.0F, - wlr_output->transform_matrix); - render_texture(output->wlr_output, damage, message->message, - message->position, matrix, renderer); - } - render_drag_icons(output, damage, &server->seat->drag_icons); - -renderer_end: - /* Draw software cursor in case hardware cursors aren't - available. This is a no-op when they are. */ - wlr_output_render_software_cursors(wlr_output, damage); - wlr_renderer_scissor(renderer, NULL); - wlr_renderer_end(renderer); - - int output_width, output_height; - wlr_output_transformed_resolution(wlr_output, &output_width, - &output_height); - - pixman_region32_t frame_damage; - pixman_region32_init(&frame_damage); - - enum wl_output_transform transform = - wlr_output_transform_invert(wlr_output->transform); - wlr_region_transform(&frame_damage, &output->damage->current, transform, - output_width, output_height); - -#ifdef DEBUG - if(server->debug_damage_tracking) { - pixman_region32_union_rect(&frame_damage, &frame_damage, 0, 0, - output_width, output_height); - } -#endif - - wlr_output_set_damage(wlr_output, &frame_damage); - pixman_region32_fini(&frame_damage); - - if(!wlr_output_commit(wlr_output)) { - wlr_log(WLR_ERROR, "Could not commit output"); - } -} diff --git a/render.h b/render.h deleted file mode 100644 index 0a883bd..0000000 --- a/render.h +++ /dev/null @@ -1,9 +0,0 @@ -#ifndef CG_RENDER_H -#define CG_RENDER_H - -struct cg_output; - -void -output_render(struct cg_output *output, pixman_region32_t *damage); - -#endif diff --git a/seat.c b/seat.c index 5449aa4..a3e09a0 100644 --- a/seat.c +++ b/seat.c @@ -1,13 +1,7 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT -#define _POSIX_C_SOURCE 200112L +#define _POSIX_C_SOURCE 200812L #include "config.h" @@ -17,13 +11,14 @@ #include #include #include +#include #include #include #include #include #include +#include #include -#include #include #include #include @@ -46,69 +41,6 @@ static void drag_icon_update_position(struct cg_drag_icon *drag_icon); -/* XDG toplevels may have nested surfaces, such as popup windows for context - * menus or tooltips. This function tests if any of those are underneath the - * coordinates lx and ly (in output Layout Coordinates). If so, it sets the - * surface pointer to that wlr_surface and the sx and sy coordinates to the - * coordinates relative to that surface's top-left corner. */ -static bool -view_at(const struct cg_view *view, double lx, double ly, - struct wlr_surface **surface, double *sx, double *sy) { - struct wlr_box *output_layout_box = wlr_output_layout_get_box( - view->server->output_layout, view->workspace->output->wlr_output); - if(output_layout_box == NULL) { - return false; - } - - double view_sx = lx - view->ox - output_layout_box->x; - double view_sy = ly - view->oy - output_layout_box->y; - - double _sx, _sy; - struct wlr_surface *_surface = - view_wlr_surface_at(view, view_sx, view_sy, &_sx, &_sy); - if(_surface != NULL) { - *sx = _sx; - *sy = _sy; - *surface = _surface; - return true; - } - - return false; -} - -/* If desktop_view_at returns a view, there is also a - * surface. There cannot be a surface without a view, either. It's - * both or nothing. */ -static struct cg_view * -desktop_view_at(const struct cg_server *server, double lx, double ly, - struct wlr_surface **surface, double *sx, double *sy) { - struct cg_view *view; - wl_list_for_each( - view, - &server->curr_output->workspaces[server->curr_output->curr_workspace] - ->unmanaged_views, - link) { - if(view_at(view, lx, ly, surface, sx, sy)) { - return view; - } - } - - bool first = true; - for(struct cg_tile *tile = - server->curr_output->workspaces[server->curr_output->curr_workspace] - ->focused_tile; - first || - server->curr_output->workspaces[server->curr_output->curr_workspace] - ->focused_tile != tile; - tile = tile->next) { - first = false; - if(tile->view != NULL && view_at(tile->view, lx, ly, surface, sx, sy)) { - return tile->view; - } - } - return NULL; -} - static void update_capabilities(const struct cg_seat *seat) { uint32_t caps = 0; @@ -125,7 +57,8 @@ update_capabilities(const struct cg_seat *seat) { wlr_seat_set_capabilities(seat->seat, caps); /* Hide cursor if the seat doesn't have pointer capability. */ - if((caps & WL_SEAT_CAPABILITY_POINTER) == 0) { + if(((caps & WL_SEAT_CAPABILITY_POINTER) == 0) || + seat->enable_cursor == false) { wlr_cursor_set_image(seat->cursor, NULL, 0, 0, 0, 0, 0, 0); } else { wlr_xcursor_manager_set_cursor_image(seat->xcursor_manager, @@ -141,13 +74,12 @@ remove_touch(struct cg_seat *seat, struct cg_touch *touch) { wlr_cursor_detach_input_device(seat->cursor, touch->device->wlr_device); --seat->num_touch; free(touch); - - update_capabilities(seat); } static void new_touch(struct cg_seat *seat, struct cg_input_device *input_device) { struct wlr_input_device *device = input_device->wlr_device; + struct wlr_touch *wlr_touch = wlr_touch_from_input_device(device); struct cg_touch *touch = calloc(1, sizeof(struct cg_touch)); if(!touch) { wlr_log(WLR_ERROR, "Cannot allocate touch"); @@ -160,10 +92,10 @@ new_touch(struct cg_seat *seat, struct cg_input_device *input_device) { input_device->touch = touch; ++seat->num_touch; - if(device->output_name != NULL) { + if(wlr_touch->output_name != NULL) { struct cg_output *output; wl_list_for_each(output, &seat->server->outputs, link) { - if(strcmp(device->output_name, output->wlr_output->name) == 0) { + if(strcmp(wlr_touch->output_name, output->wlr_output->name) == 0) { wlr_cursor_map_input_to_output(seat->cursor, device, output->wlr_output); break; @@ -180,13 +112,12 @@ remove_pointer(struct cg_seat *seat, struct cg_pointer *pointer) { wlr_cursor_detach_input_device(seat->cursor, pointer->device->wlr_device); --seat->num_pointers; free(pointer); - - update_capabilities(seat); } static void new_pointer(struct cg_seat *seat, struct cg_input_device *input_device) { struct wlr_input_device *device = input_device->wlr_device; + struct wlr_pointer *wlr_pointer = wlr_pointer_from_input_device(device); struct cg_pointer *pointer = calloc(1, sizeof(struct cg_pointer)); if(!pointer) { wlr_log(WLR_ERROR, "Cannot allocate pointer"); @@ -199,10 +130,11 @@ new_pointer(struct cg_seat *seat, struct cg_input_device *input_device) { input_device->pointer = pointer; ++seat->num_pointers; - if(device->output_name != NULL) { + if(wlr_pointer->output_name != NULL) { struct cg_output *output; wl_list_for_each(output, &seat->server->outputs, link) { - if(strcmp(device->output_name, output->wlr_output->name) == 0) { + if(strcmp(wlr_pointer->output_name, output->wlr_output->name) == + 0) { wlr_cursor_map_input_to_output(seat->cursor, device, output->wlr_output); break; @@ -214,8 +146,7 @@ new_pointer(struct cg_seat *seat, struct cg_input_device *input_device) { static int handle_keyboard_repeat(void *data) { struct cg_keyboard_group *cg_group = data; - struct wlr_keyboard *wlr_device = - cg_group->wlr_group->input_device->keyboard; + struct wlr_keyboard *wlr_device = &cg_group->wlr_group->keyboard; if(cg_group->repeat_keybinding != NULL) { if(wlr_device->repeat_info.rate > 0) { if(wl_event_source_timer_update( @@ -234,9 +165,9 @@ handle_keyboard_repeat(void *data) { static void handle_modifier_event(struct wlr_input_device *device, struct cg_seat *seat) { - wlr_seat_set_keyboard(seat->seat, device); - wlr_seat_keyboard_notify_modifiers(seat->seat, - &device->keyboard->modifiers); + struct wlr_keyboard *keyboard = wlr_keyboard_from_input_device(device); + wlr_seat_set_keyboard(seat->seat, keyboard); + wlr_seat_keyboard_notify_modifiers(seat->seat, &keyboard->modifiers); wlr_idle_notify_activity(seat->server->idle, seat->seat); } @@ -256,24 +187,50 @@ static bool handle_command_key_bindings(struct cg_server *server, xkb_keysym_t sym, uint32_t modifiers, uint32_t mode, struct cg_keyboard_group *group) { + if(group->enable_keybindings == false) { + return false; + } struct keybinding **keybinding = find_keybinding( server->keybindings, &(struct keybinding){.key = sym, .mode = mode, .modifiers = modifiers}); - server->seat->mode = - server->seat - ->default_mode; // Return to mode we are currently in by default + if(server->seat->mode != server->seat->default_mode) { + server->seat->mode = + server->seat + ->default_mode; // Return to mode we are currently in by default + double sx, sy; + struct wlr_seat *wlr_seat = server->seat->seat; + struct wlr_surface *surface = NULL; + + struct wlr_scene_node *node = wlr_scene_node_at( + &server->scene->tree.node, server->seat->cursor->x, + server->seat->cursor->y, &sx, &sy); + if(server->seat->enable_cursor) { + wlr_xcursor_manager_set_cursor_image(server->seat->xcursor_manager, + "left_ptr", + server->seat->cursor); + if(node && node->type == WLR_SCENE_NODE_BUFFER) { + struct wlr_scene_surface *scene_surface = + wlr_scene_surface_from_buffer( + wlr_scene_buffer_from_node(node)); + if(scene_surface != NULL) { + surface = scene_surface->surface; + } + wlr_seat_pointer_notify_enter(wlr_seat, surface, sx, sy); + } + } + } + if(keybinding) { wlr_log( WLR_DEBUG, "Recognized keybinding pressed (key: %d, mode: %d, modifiers: %d)", sym, mode, modifiers); - if(group->wlr_group->input_device->keyboard->repeat_info.delay > 0) { + if(group->wlr_group->keyboard.repeat_info.delay > 0) { group->repeat_keybinding = keybinding; - if(wl_event_source_timer_update(group->key_repeat_timer, - group->wlr_group->input_device - ->keyboard->repeat_info.delay) < - 0) { + if(wl_event_source_timer_update( + group->key_repeat_timer, + group->wlr_group->keyboard.repeat_info.delay) < 0) { wlr_log(WLR_DEBUG, "failed to set key repeat timer"); } } @@ -315,27 +272,25 @@ key_is_modifier(const xkb_keysym_t key) { static void handle_key_event(struct cg_keyboard_group *group, struct cg_seat *seat, void *data) { - struct wlr_event_keyboard_key *event = data; - struct wlr_input_device *device = group->wlr_group->input_device; + struct wlr_keyboard_key_event *event = data; + struct wlr_keyboard *keyboard = &group->wlr_group->keyboard; /* Translate from libinput keycode to an xkbcommon keycode. */ xkb_keycode_t keycode = event->keycode + 8; const xkb_keysym_t *syms; - int nsyms = - xkb_state_key_get_syms(device->keyboard->xkb_state, keycode, &syms); + int nsyms = xkb_state_key_get_syms(keyboard->xkb_state, keycode, &syms); bool handled = false; for(int i = 0; i < nsyms; ++i) { if(event->state == WL_KEYBOARD_KEY_STATE_PRESSED && !key_is_modifier(syms[i])) { - uint32_t modifiers = wlr_keyboard_get_modifiers(device->keyboard); + uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard); /* Get the consumed_modifiers and remove them from the modifier list */ xkb_mod_mask_t consumed_modifiers = - xkb_state_key_get_consumed_mods2(device->keyboard->xkb_state, - keycode, + xkb_state_key_get_consumed_mods2(keyboard->xkb_state, keycode, XKB_CONSUMED_MODE_GTK); if(handle_command_key_bindings(seat->server, syms[i], modifiers & ~consumed_modifiers, @@ -349,7 +304,7 @@ handle_key_event(struct cg_keyboard_group *group, struct cg_seat *seat, if(!handled) { /* Otherwise, we pass it along to the client. */ - wlr_seat_set_keyboard(seat->seat, device); + wlr_seat_set_keyboard(seat->seat, keyboard); wlr_seat_keyboard_notify_key(seat->seat, event->time_msec, event->keycode, event->state); } @@ -368,18 +323,32 @@ static void handle_keyboard_group_modifiers(struct wl_listener *listener, void *_data) { struct cg_keyboard_group *group = wl_container_of(listener, group, modifiers); - handle_modifier_event(group->wlr_group->input_device, group->seat); + handle_modifier_event(&group->wlr_group->keyboard.base, group->seat); +} + +static bool +repeat_info_match(struct wlr_keyboard *a, struct wlr_keyboard *b) { + return a->repeat_info.rate == b->repeat_info.rate && + a->repeat_info.delay == b->repeat_info.delay; } static void -cg_keyboard_group_add(struct wlr_input_device *device, struct cg_seat *seat) { - struct wlr_keyboard *wlr_keyboard = device->keyboard; - struct cg_keyboard_group *group; - wl_list_for_each(group, &seat->keyboard_groups, link) { - struct wlr_keyboard_group *wlr_group = group->wlr_group; - if(wlr_keyboard_group_add_keyboard(wlr_group, wlr_keyboard)) { - wlr_log(WLR_DEBUG, "Adding keyboard to existing group."); - return; +cg_keyboard_group_add(struct cg_input_device *input_device, + struct cg_seat *seat) { + struct wlr_input_device *device = input_device->wlr_device; + struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(device); + // Virtual devices should not be grouped + if(!input_device->is_virtual) { + struct cg_keyboard_group *group; + wl_list_for_each(group, &seat->keyboard_groups, link) { + struct wlr_keyboard_group *wlr_group = group->wlr_group; + if(wlr_keyboard_keymaps_match(wlr_keyboard->keymap, + wlr_group->keyboard.keymap) && + repeat_info_match(wlr_keyboard, &wlr_group->keyboard) && + wlr_keyboard_group_add_keyboard(wlr_group, wlr_keyboard)) { + wlr_log(WLR_DEBUG, "Adding keyboard to existing group."); + return; + } } } /* This is reached if and only if the keyboard could not be inserted into @@ -399,10 +368,15 @@ cg_keyboard_group_add(struct wlr_input_device *device, struct cg_seat *seat) { cg_group->wlr_group->data = cg_group; wlr_keyboard_set_keymap(&cg_group->wlr_group->keyboard, - device->keyboard->keymap); + wlr_keyboard->keymap); wlr_keyboard_set_repeat_info(&cg_group->wlr_group->keyboard, - device->keyboard->repeat_info.rate, - device->keyboard->repeat_info.delay); + wlr_keyboard->repeat_info.rate, + wlr_keyboard->repeat_info.delay); + if(input_device->identifier != NULL) { + cg_group->identifier = strdup(input_device->identifier); + } else { + cg_group->identifier = NULL; + } wlr_log(WLR_DEBUG, "Created keyboard group."); wlr_keyboard_group_add_keyboard(cg_group->wlr_group, wlr_keyboard); @@ -418,12 +392,17 @@ cg_keyboard_group_add(struct wlr_input_device *device, struct cg_seat *seat) { seat->server->event_loop, handle_keyboard_repeat, cg_group); cg_group->modifiers.notify = handle_keyboard_group_modifiers; + cg_group->enable_keybindings = true; + cg_input_manager_configure_keyboard_group(cg_group); return; cleanup: if(cg_group && cg_group->wlr_group) { wlr_keyboard_group_destroy(cg_group->wlr_group); } + if(cg_group && cg_group->identifier) { + free(cg_group->identifier); + } free(cg_group); } @@ -445,16 +424,15 @@ new_keyboard(struct cg_seat *seat, struct cg_input_device *input_device) { return; } - wlr_keyboard_set_keymap(device->keyboard, keymap); + wlr_keyboard_set_keymap(wlr_keyboard_from_input_device(device), keymap); xkb_keymap_unref(keymap); xkb_context_unref(context); - wlr_keyboard_set_repeat_info(device->keyboard, 25, 600); - cg_keyboard_group_add(device, seat); + cg_keyboard_group_add(input_device, seat); ++seat->num_keyboards; - wlr_seat_set_keyboard(seat->seat, device); + wlr_seat_set_keyboard(seat->seat, wlr_keyboard_from_input_device(device)); } void @@ -481,19 +459,46 @@ seat_add_device(struct cg_seat *seat, struct cg_input_device *device) { update_capabilities(seat); } +static void +destroy_empty_wlr_keyboard_group(void *data) { + wlr_keyboard_group_destroy(data); +} + void remove_keyboard(struct cg_seat *seat, struct cg_input_device *keyboard) { if(!keyboard) { return; } struct wlr_seat *wlr_seat = seat->seat; - struct wlr_keyboard *wlr_keyboard = keyboard->wlr_device->keyboard; - if(keyboard->wlr_device->keyboard->group) { - wlr_keyboard_group_remove_keyboard(wlr_keyboard->group, wlr_keyboard); - } - if(wlr_seat_get_keyboard(wlr_seat) == wlr_keyboard) { - wlr_seat_set_keyboard(wlr_seat, NULL); + struct wlr_keyboard *wlr_keyboard = + wlr_keyboard_from_input_device(keyboard->wlr_device); + struct wlr_keyboard_group *wlr_group = wlr_keyboard->group; + if(wlr_group) { + wlr_keyboard_group_remove_keyboard(wlr_group, wlr_keyboard); + + if(wl_list_empty(&wlr_group->devices)) { + wlr_log(WLR_DEBUG, "Destroying empty keyboard group %p", + (void *)wlr_group); + struct cg_keyboard_group *group = wlr_group->data; + if(wlr_seat_get_keyboard(wlr_seat) == &wlr_group->keyboard) { + wlr_seat_set_keyboard(wlr_seat, NULL); + } + wlr_group->data = NULL; + wl_list_remove(&group->link); + wl_list_remove(&group->key.link); + wl_list_remove(&group->modifiers.link); + if(group->identifier != NULL) { + free(group->identifier); + } + free(group); + + // To prevent use-after-free conditions when handling key events, + // defer freeing the wlr_keyboard_group until idle + wl_event_loop_add_idle(seat->server->event_loop, + destroy_empty_wlr_keyboard_group, wlr_group); + } } + --seat->num_keyboards; } @@ -544,6 +549,9 @@ handle_request_set_selection(struct wl_listener *listener, void *data) { static void handle_request_set_cursor(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, request_set_cursor); + if(seat->enable_cursor == false || seat->mode != seat->default_mode) { + return; + } struct wlr_seat_pointer_request_set_cursor_event *event = data; struct wlr_surface *focused_surface = event->seat_client->seat->pointer_state.focused_surface; @@ -565,21 +573,25 @@ handle_request_set_cursor(struct wl_listener *listener, void *data) { static void handle_touch_down(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, touch_down); - struct wlr_event_touch_down *event = data; + struct wlr_touch_down_event *event = data; double lx, ly; - wlr_cursor_absolute_to_layout_coords(seat->cursor, event->device, event->x, - event->y, &lx, &ly); + wlr_cursor_absolute_to_layout_coords(seat->cursor, &event->touch->base, + event->x, event->y, &lx, &ly); double sx, sy; - struct wlr_surface *surface; - struct cg_view *view = - desktop_view_at(seat->server, lx, ly, &surface, &sx, &sy); + struct wlr_scene_node *node = + wlr_scene_node_at(&seat->server->scene->tree.node, lx, ly, &sx, &sy); uint32_t serial = 0; - if(view) { - serial = wlr_seat_touch_notify_down( - seat->seat, surface, event->time_msec, event->touch_id, sx, sy); + if(node && node->type == WLR_SCENE_NODE_BUFFER) { + struct wlr_scene_surface *scene_surface = + wlr_scene_surface_from_buffer(wlr_scene_buffer_from_node(node)); + if(scene_surface != NULL) { + serial = wlr_seat_touch_notify_down( + seat->seat, scene_surface->surface, event->time_msec, + event->touch_id, sx, sy); + } } if(serial && wlr_seat_touch_num_points(seat->seat) == 1) { @@ -594,7 +606,7 @@ handle_touch_down(struct wl_listener *listener, void *data) { static void handle_touch_up(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, touch_up); - struct wlr_event_touch_up *event = data; + struct wlr_touch_up_event *event = data; if(!wlr_seat_touch_get_point(seat->seat, event->touch_id)) { return; @@ -607,24 +619,29 @@ handle_touch_up(struct wl_listener *listener, void *data) { static void handle_touch_motion(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, touch_motion); - struct wlr_event_touch_motion *event = data; + struct wlr_touch_motion_event *event = data; if(!wlr_seat_touch_get_point(seat->seat, event->touch_id)) { return; } double lx, ly; - wlr_cursor_absolute_to_layout_coords(seat->cursor, event->device, event->x, - event->y, &lx, &ly); + wlr_cursor_absolute_to_layout_coords(seat->cursor, &event->touch->base, + event->x, event->y, &lx, &ly); double sx, sy; - struct wlr_surface *surface; - struct cg_view *view = - desktop_view_at(seat->server, lx, ly, &surface, &sx, &sy); + struct wlr_scene_node *node = + wlr_scene_node_at(&seat->server->scene->tree.node, lx, ly, &sx, &sy); - if(view) { - wlr_seat_touch_point_focus(seat->seat, surface, event->time_msec, - event->touch_id, sx, sy); + if(node && node->type == WLR_SCENE_NODE_BUFFER) { + struct wlr_scene_surface *scene_surface = + wlr_scene_surface_from_buffer(wlr_scene_buffer_from_node(node)); + if(scene_surface != NULL) { + + wlr_seat_touch_point_focus(seat->seat, scene_surface->surface, + event->time_msec, event->touch_id, sx, + sy); + } wlr_seat_touch_notify_motion(seat->seat, event->time_msec, event->touch_id, sx, sy); } else { @@ -651,7 +668,7 @@ handle_cursor_frame(struct wl_listener *listener, void *_data) { static void handle_cursor_axis(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, cursor_axis); - struct wlr_event_pointer_axis *event = data; + struct wlr_pointer_axis_event *event = data; wlr_seat_pointer_notify_axis(seat->seat, event->time_msec, event->orientation, event->delta, @@ -662,7 +679,7 @@ handle_cursor_axis(struct wl_listener *listener, void *data) { static void handle_cursor_button(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, cursor_button); - struct wlr_event_pointer_button *event = data; + struct wlr_pointer_button_event *event = data; wlr_seat_pointer_notify_button(seat->seat, event->time_msec, event->button, event->state); @@ -675,18 +692,24 @@ process_cursor_motion(struct cg_seat *seat, uint32_t time) { struct wlr_seat *wlr_seat = seat->seat; struct wlr_surface *surface = NULL; - struct cg_view *view = desktop_view_at(seat->server, seat->cursor->x, - seat->cursor->y, &surface, &sx, &sy); + struct wlr_scene_node *node = + wlr_scene_node_at(&seat->server->scene->tree.node, seat->cursor->x, + seat->cursor->y, &sx, &sy); - if(!view) { - wlr_seat_pointer_clear_focus(wlr_seat); - } else { + if(node && node->type == WLR_SCENE_NODE_BUFFER) { + struct wlr_scene_surface *scene_surface = + wlr_scene_surface_from_buffer(wlr_scene_buffer_from_node(node)); + if(scene_surface != NULL) { + surface = scene_surface->surface; + } wlr_seat_pointer_notify_enter(wlr_seat, surface, sx, sy); bool focus_changed = wlr_seat->pointer_state.focused_surface != surface; if(!focus_changed && time > 0) { wlr_seat_pointer_notify_motion(wlr_seat, time, sx, sy); } + } else { + wlr_seat_pointer_clear_focus(wlr_seat); } struct cg_drag_icon *drag_icon; @@ -695,15 +718,54 @@ process_cursor_motion(struct cg_seat *seat, uint32_t time) { } wlr_idle_notify_activity(seat->server->idle, seat->seat); + + /* Check if cursor switched tile */ + struct wlr_output *c_outp = wlr_output_layout_output_at( + seat->server->output_layout, seat->cursor->x, seat->cursor->y); + struct cg_output *cg_outp = NULL; + wl_list_for_each(cg_outp, &seat->server->outputs, link) { + if(cg_outp->wlr_output == c_outp) { + break; + } + } + struct cg_tile *c_tile; + bool first = true; + for(c_tile = cg_outp->workspaces[cg_outp->curr_workspace]->focused_tile; + first || + c_tile != cg_outp->workspaces[cg_outp->curr_workspace]->focused_tile; + c_tile = c_tile->next) { + first = false; + double ox = seat->cursor->x, oy = seat->cursor->y; + wlr_output_layout_output_coords(seat->server->output_layout, c_outp, + &ox, &oy); + if(c_tile->tile.x <= ox && c_tile->tile.y <= oy && + c_tile->tile.x + c_tile->tile.width >= ox && + c_tile->tile.y + c_tile->tile.height >= oy) { + break; + } + } + if(seat->cursor_tile != NULL && seat->cursor_tile != c_tile) { + ipc_send_event(seat->server, + "{\"event_name\":\"cursor_switch_tile\",\"old_output\":" + "\"%s\",\"old_output_id\":%d," + "\"old_tile\":%d,\"new_output\":\"%s\",\"new_output_" + "id\":%d,\"new_tile\":%d}", + seat->cursor_tile->workspace->output->wlr_output->name, + output_get_num(seat->cursor_tile->workspace->output), + seat->cursor_tile->id, c_outp->name, + output_get_num(cg_outp), c_tile->id); + } + seat->cursor_tile = c_tile; } static void handle_cursor_motion_absolute(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, cursor_motion_absolute); - struct wlr_event_pointer_motion_absolute *event = data; + struct wlr_pointer_motion_absolute_event *event = data; - wlr_cursor_warp_absolute(seat->cursor, event->device, event->x, event->y); + wlr_cursor_warp_absolute(seat->cursor, &event->pointer->base, event->x, + event->y); process_cursor_motion(seat, event->time_msec); wlr_idle_notify_activity(seat->server->idle, seat->seat); } @@ -711,34 +773,20 @@ handle_cursor_motion_absolute(struct wl_listener *listener, void *data) { static void handle_cursor_motion(struct wl_listener *listener, void *data) { struct cg_seat *seat = wl_container_of(listener, seat, cursor_motion); - struct wlr_event_pointer_motion *event = data; + struct wlr_pointer_motion_event *event = data; - wlr_cursor_move(seat->cursor, event->device, event->delta_x, + wlr_cursor_move(seat->cursor, &event->pointer->base, event->delta_x, event->delta_y); process_cursor_motion(seat, event->time_msec); wlr_idle_notify_activity(seat->server->idle, seat->seat); } -static void -drag_icon_damage(struct cg_drag_icon *drag_icon) { - struct cg_output *output; - wl_list_for_each(output, &drag_icon->seat->server->outputs, link) { - struct wlr_box *output_layout_box = wlr_output_layout_get_box( - output->server->output_layout, output->wlr_output); - output_damage_surface(output, drag_icon->wlr_drag_icon->surface, - drag_icon->lx - output_layout_box->x, - drag_icon->ly - output_layout_box->y, true); - } -} - static void drag_icon_update_position(struct cg_drag_icon *drag_icon) { struct wlr_drag_icon *wlr_icon = drag_icon->wlr_drag_icon; struct cg_seat *seat = drag_icon->seat; struct wlr_touch_point *point; - drag_icon_damage(drag_icon); - switch(wlr_icon->drag->grab_type) { case WLR_DRAG_GRAB_KEYBOARD: return; @@ -755,8 +803,8 @@ drag_icon_update_position(struct cg_drag_icon *drag_icon) { drag_icon->ly = seat->touch_ly; break; } - - drag_icon_damage(drag_icon); + wlr_scene_node_set_position(&drag_icon->scene_tree->node, drag_icon->lx, + drag_icon->ly); } static void @@ -764,9 +812,9 @@ handle_drag_icon_destroy(struct wl_listener *listener, void *_data) { struct cg_drag_icon *drag_icon = wl_container_of(listener, drag_icon, destroy); - drag_icon_damage(drag_icon); wl_list_remove(&drag_icon->link); wl_list_remove(&drag_icon->destroy.link); + wlr_scene_node_destroy(&drag_icon->scene_tree->node); free(drag_icon); } @@ -789,7 +837,6 @@ handle_request_start_drag(struct wl_listener *listener, void *data) { return; } - // TODO: tablet grabs wlr_log(WLR_DEBUG, "Ignoring start_drag request: " "could not validate pointer/touch serial %" PRIu32, @@ -812,6 +859,12 @@ handle_start_drag(struct wl_listener *listener, void *data) { } drag_icon->seat = seat; drag_icon->wlr_drag_icon = wlr_drag_icon; + drag_icon->scene_tree = wlr_scene_subsurface_tree_create( + &seat->server->scene->tree, wlr_drag_icon->surface); + if(!drag_icon->scene_tree) { + free(drag_icon); + return; + } drag_icon->destroy.notify = handle_drag_icon_destroy; wl_signal_add(&wlr_drag_icon->events.destroy, &drag_icon->destroy); @@ -831,6 +884,9 @@ handle_destroy(struct wl_listener *listener, void *_data) { wl_list_remove(&group->link); wlr_keyboard_group_destroy(group->wlr_group); wl_event_source_remove(group->key_repeat_timer); + if(group->identifier) { + free(group->identifier); + } free(group); } @@ -865,6 +921,7 @@ seat_create(struct cg_server *server, struct wlr_backend *backend) { return NULL; } + seat->enable_cursor = true; seat->seat = wlr_seat_create(server->wl_display, "seat0"); if(!seat->seat) { wlr_log(WLR_ERROR, "Cannot allocate seat0"); @@ -885,7 +942,8 @@ seat_create(struct cg_server *server, struct wlr_backend *backend) { wlr_cursor_attach_output_layout(seat->cursor, server->output_layout); if(!seat->xcursor_manager) { - seat->xcursor_manager = wlr_xcursor_manager_create(NULL, XCURSOR_SIZE); + seat->xcursor_manager = + wlr_xcursor_manager_create(NULL, server->xcursor_size); if(!seat->xcursor_manager) { wlr_log(WLR_ERROR, "Cannot create XCursor manager"); wlr_cursor_destroy(seat->cursor); @@ -971,8 +1029,10 @@ seat_set_focus(struct cg_seat *seat, struct cg_view *view) { /* Focusing the background */ if(view == NULL) { - server->curr_output->workspaces[server->curr_output->curr_workspace] - ->focused_tile->view = NULL; + workspace_tile_update_view( + server->curr_output->workspaces[server->curr_output->curr_workspace] + ->focused_tile, + NULL); seat->focused_view = NULL; if(prev_view != NULL) { view_activate(prev_view, false); @@ -985,24 +1045,18 @@ seat_set_focus(struct cg_seat *seat, struct cg_view *view) { if(view->type != CG_XWAYLAND_VIEW || xwayland_view_should_manage(view)) #endif { - /* Always resize the view, even if prev_view == view */ struct cg_workspace *curr_workspace = server->curr_output ->workspaces[server->curr_output->curr_workspace]; - view_maximize(view, curr_workspace->focused_tile); - if(!view_is_visible(view)) { - wl_list_remove(&view->link); - if(curr_workspace->focused_tile->view != NULL) { - wl_list_insert(&curr_workspace->focused_tile->view->link, - &view->link); - } else { - wl_list_insert(curr_workspace->views.prev, &view->link); - } - curr_workspace->focused_tile->view = view; - } + workspace_tile_update_view(curr_workspace->focused_tile, view); + wl_list_remove(&curr_workspace->views); + wl_list_insert(&view->link, &curr_workspace->views); } #if CG_HAS_XWAYLAND + if(view->type == CG_XWAYLAND_VIEW) { + wlr_xwayland_set_seat(server->xwayland, seat->seat); + } if(view->type == CG_XWAYLAND_VIEW && !xwayland_view_should_manage(view)) { const struct cg_xwayland_view *xwayland_view = xwayland_view_from_view(view); @@ -1021,10 +1075,6 @@ seat_set_focus(struct cg_seat *seat, struct cg_view *view) { } view_activate(view, true); - char *title = view_get_title(view); - - output_set_window_title(server->curr_output, title); - free(title); struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(wlr_seat); wlr_seat_keyboard_end_grab(wlr_seat); @@ -1037,5 +1087,11 @@ seat_set_focus(struct cg_seat *seat, struct cg_view *view) { NULL); } + wlr_scene_node_raise_to_top(&view->scene_tree->node); process_cursor_motion(seat, -1); + struct wlr_box box; + wlr_output_layout_get_box(server->output_layout, + view->workspace->output->wlr_output, &box); + wlr_scene_node_set_position(&view->workspace->output->bg->node, box.x, + box.y); } diff --git a/seat.h b/seat.h index 9331042..e44d808 100644 --- a/seat.h +++ b/seat.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_SEAT_H #define CG_SEAT_H @@ -11,6 +14,8 @@ struct cg_input_device; struct wlr_seat; struct wlr_xcursor_manager; struct wlr_backend; +struct wlr_surface; +struct cg_input_config; #define DEFAULT_XCURSOR "left_ptr" #define XCURSOR_SIZE 24 @@ -26,7 +31,9 @@ struct cg_seat { uint16_t num_pointers; uint16_t num_touch; + bool enable_cursor; struct wlr_cursor *cursor; + struct cg_tile *cursor_tile; struct wlr_xcursor_manager *xcursor_manager; struct wl_listener cursor_motion; struct wl_listener cursor_motion_absolute; @@ -60,6 +67,8 @@ struct cg_seat { struct cg_keyboard_group { struct wlr_keyboard_group *wlr_group; struct cg_seat *seat; + char *identifier; + int enable_keybindings; struct wl_listener key; struct wl_listener modifiers; @@ -85,6 +94,7 @@ struct cg_drag_icon { struct wl_list link; // seat::drag_icons struct cg_seat *seat; struct wlr_drag_icon *wlr_drag_icon; + struct wlr_scene_tree *scene_tree; /* The drag icon has a position in layout coordinates. */ double lx, ly; @@ -104,5 +114,4 @@ void seat_add_device(struct cg_seat *seat, struct cg_input_device *device); void seat_remove_device(struct cg_seat *seat, struct cg_input_device *device); - #endif diff --git a/server.c b/server.c index e554a3c..292d0b0 100644 --- a/server.c +++ b/server.c @@ -25,7 +25,6 @@ display_terminate(struct cg_server *server) { if(server == NULL) { return; } - server->running = false; wl_display_terminate(server->wl_display); } @@ -58,14 +57,15 @@ server_show_info(struct cg_server *server) { struct cg_input_device *input; wl_list_for_each(input, &server->input->devices, link) { if(!input_str) { + free(output_str); return NULL; } input_str_tmp = input_str; if(strcmp(input->identifier, "") != 0) { input_str = malloc_vsprintf("%s\t * %s\n", input_str, input->identifier); + free(input_str_tmp); } - free(input_str_tmp); } char *ret = malloc_vsprintf("Outputs:\n%sInputs:\n%s", output_str, input_str); diff --git a/server.h b/server.h index a5139f6..39d26f4 100644 --- a/server.h +++ b/server.h @@ -23,8 +23,6 @@ struct cg_server { struct cg_seat *seat; struct cg_input_manager *input; struct wlr_backend *backend; - struct wlr_renderer *renderer; - struct wlr_allocator *allocator; struct wlr_idle *idle; struct wlr_idle_inhibit_manager_v1 *idle_inhibit_v1; struct wl_listener new_idle_inhibitor_v1; @@ -35,11 +33,17 @@ struct cg_server { struct wl_list outputs; struct cg_output *curr_output; struct wl_listener new_output; + struct wl_list output_priorities; + + struct wlr_renderer *renderer; + struct wlr_allocator *allocator; + struct wlr_scene *scene; struct wl_listener xdg_toplevel_decoration; struct wl_listener new_xdg_shell_surface; #if CG_HAS_XWAYLAND struct wl_listener new_xwayland_surface; + struct wlr_xwayland *xwayland; #endif struct keybinding_list *keybindings; @@ -47,18 +51,16 @@ struct cg_server { struct wl_list input_config; struct cg_message_config message_config; - enum wl_output_transform output_transform; - struct cg_ipc_handle ipc; + bool enable_socket; bool running; char **modes; uint16_t nws; - uint16_t message_timeout; float *bg_color; -#ifdef DEBUG - bool debug_damage_tracking; -#endif + uint32_t views_curr_id; + uint32_t tiles_curr_id; + uint32_t xcursor_size; }; void diff --git a/signatures/1.9.1-cagebreak-config.sig b/signatures/1.9.1-cagebreak-config.sig new file mode 100644 index 0000000000000000000000000000000000000000..7349ebcab4fa32168646d48f892bcd5596a3192f GIT binary patch literal 566 zcmV-60?GY}0y6{v0SEvc79j+_E$ufVhrCX*AwCnJ$3ujQV~JG-0%GJlF#rk)5TM6H zgo9>tYPA>a(B~!^>{#QM`;&Ks#9hY(iZU4k8V6+u7a|13x%(-a?xh zLZT+17sI6;Yl3Skve`me;ImzqMO%Nfz*_*j=t~S|@K%n0#0NbXgkj#=x5*t~E*td> zNsM2jL{#={Bdk~eU_)i&_fvD~)?ev)>^6K7LzObD45@&;A})&qQ@XPnzCINxvO<-* zySrj>7^!e`*Lhscg7zUkdY|RmIVN4{I&Y1nI3Z&s9wXm-)?w`T$TD7wS9-*n2Ih8f z7n87;Q?0k}@?xs0ERWIHqsFuyTyY*{aUC%woI;%z)|TCJTe)&s2`moz3V$2xSc%j7 zvnbt(W;`v}rVnBu2lRdjuw69ser;oE0!icWuHt>9l)6xjE$X=uzfI6;iT{2}M8AY& zN8^@X)bFtcg{lXgR8lKqAEmGmuW==XG;gd&N@P^`3QO02-OK2kOH|?%qrzo)?b=h- zLh29(45Y1EW*LgG2ZUJRpB;GzT&+AoDqtJK&?b#Fz!dA3T=Q*~6g{~PAu|j%4q>qt zPQv)iwo%o;{K47J($(o$abbd_zvjg|)+SN8uc~J{bP<+f7PT!o81aUMd)X(zx~6zV EzrwKw%m4rY literal 0 HcmV?d00001 diff --git a/signatures/1.9.1-cagebreak.1.sig b/signatures/1.9.1-cagebreak.1.sig new file mode 100644 index 0000000000000000000000000000000000000000..e0a399bb986388fd35276fee09dbbf5ccac80832 GIT binary patch literal 566 zcmV-60?GY}0y6{v0SEvc79j+_E$ufVhrCX*AwCnJ$3ujQV~JG-0%GJlIRFX?5TM6H zgo|>`7|>GzW7G(eSg*~ zfTkz5Du3Oxjr6A1SZMx6YqzyeL8>)${n*zq2@$+z+J;KQM4^NB5B3)kO z>RmD9m{g=l-qrqVTr{j0XbFR{36~j$KY4j1xz41Oo2Vj~id<#<^pP=9l77((z>Y}f z+Nlu;%gUVse4ClfeV!n)#wmm|emr9DTr%OD;}Dvw8xOoAOJF9LFR%^=fB^LWYSLm@ z7qV{#W4*=i8c$wEVN;|H6Xg7@17m+ztOd1C-(Gr?7qs#$<$N;tVtSq_R4^uk*y;#v EW5~}ALjV8( literal 0 HcmV?d00001 diff --git a/signatures/1.9.1-cagebreak.sig b/signatures/1.9.1-cagebreak.sig new file mode 100644 index 0000000000000000000000000000000000000000..1813ed2426494a05f625ea4b7e3ab605ed4f8601 GIT binary patch literal 566 zcmV-60?GY}0y6{v0SEvc79j+_E$ufVhrCX*AwCnJ$3ujQV~JG-0%GJlH2?|;5TM6H zgo9ROudEg(73sF&{gAji%Mu!6xkWxIWi z-X<6Kgywn!hlTI#HRgK1`mwQd$H+9}mG=U&vNudZ*V%%pxZlNm488bpS@LB`3Iwz5 zQfkURVaPvFZA7GjUH&*>tqqgYtYQ0R1yz8m6XN(Oav;*5?Hp@THH2QuS*CNSqsVA~rE25)((-C@m%&1q>FB6Hq+*7!hLQ7L-+aLe)L5=S@ z$}y!zJmcmxsze_~47z#*o3tIBtDYb{+^mM!!_Dn;NVQi9%kp2?o0 z;h~`W_|OhSJ+%VWaWW;tck(^G zYhYe|dhWE0y_I%{W=xhBVuv;ixd=11gw)#^XtEH=c<`aXy*w(q)v5d$L(FlsEnd%m_B1OJ9|G zY+G(nU5L4jyR49Qq0+4q-T5>j0WD1rAO@3Vl5v+30OlLqNij*hoj~ECUMrZkGFI}X E$89nRGynhq literal 0 HcmV?d00001 diff --git a/signatures/cagebreak-config.5.sig b/signatures/cagebreak-config.5.sig index 7349ebcab4fa32168646d48f892bcd5596a3192f..0e839de1d6a4029c6b1906c9b74962341d1add5f 100644 GIT binary patch delta 543 zcmV+)0^t3&1hxc_B7bAMFjW8w2@s&iLxhTBiB$yI5C3TFTqwb9Ki}LpPi*fLRb5H1 zvac3^UBA@Q>V*g>Sy+c~ZYJPe;2%icduM2=ZCpUKiGi+%-Y_)ax-qjxOo zq6>!{+qCvC$n=I!VGiUy_Kv7qMDAD76Y>Z9A^SZ|3G>CD`G0ZlB~PxHYJfzPlFA)(3`EYRhr{CN4KHkJrUF;l|Z=jV#O4tH032lNT}+^Fx`cZ!~0A zZ_hmik$O{Sw|$G~w|NnsMeWfjr6m#Aq3t;a6tX4VNm7BwD%7j*JOSUtOGy5z4szY{ z0dV$QkUy`z8h>f|+|8lql6*k2E&Jl}bP*6S;BJhV++xYzq1p`KCDOd1gj}w#^ONc( zlrsLhNjf8ff-5~@w7ykjN59t?Bqgj8HEzSo2e{92L??nPk@|LHu~uTo7aBnmT_Q~e z=$T&kQ|su|58pow=6|PunNu)C$1u5po!I)nYJZlM{C_HE9)z0kM}k45Z8dji9bL_r ziL4a>UFDl@2~vN)41xxj>0Wkv89j=;{oGKX^A~tQ>S74ILHP>WV@`i(UJnzI_6ghU zGvSviq^gF9-;B}ZwsE4*kBy9-<)XZK{!@-*&hgGuZ9r%P+u`LAa@MFpzhROnVSl9{ hsv$bv!x-`~Zv;-NFU=S$l8pQwI)z=^;i1$CI#S6`5aj>> delta 543 zcmV+)0^t3&1hxc_B7b7!J23zX2@s&iLxhTBiB)A$5CD_%RyBr2k!jrc>_N3Qrn zd=f*IGOP@#fV?6uivv@-vl_lW6)CbpmAbpTVsRL$aC6srT+M>^AwGJa<=QzWUFkY+ zjifjsVUdc>Lr=5}xwldzXlt+(&;VydbvkI~qp#JT2I!4`Lt(^nM7iT{QE4ZDVNy zN#pRY;(er)x=@WR>bViWP0(tI|9(qEzl3B*qtPQv)iwo%o;{K47J($(o$abbd_zvjg| h)+SN8uNbOlI&=}1VivV6IT-PVg?rg2z`CY*MZew(0Q~>} diff --git a/signatures/cagebreak-socket.7.sig b/signatures/cagebreak-socket.7.sig new file mode 100644 index 0000000000000000000000000000000000000000..6c5048b79c2991fa9f1d0e86234926ebacf415f9 GIT binary patch literal 566 zcmV-60?GY}0y6{v0SEvc79j+_E$ufVhrCX*AwCnJ$3ujQV~JG-0%N-{SpW(N5TM6H zgo@`h?n#LyK;!8^ONVafw0hZ759^be#Y5vvgbS%8( zr6n3>4_q-c_!#_23y|DeU*kv5#txLZxT816ne-fd-!;@V;T)X~gqMQ{iX%R67+OZ_ zI`x>h8*Sip|C8?buduzg8~y&`13b(lX32~JcTXu(TM$EK5w8pCL~ymwj?-6S)3yQ^ zB*#VzH%Kmu$?vl9b~bh7$E4ik!qrRt$Ed4TMQN}|OR6HW?UYr*g7DUnhJMgBw;nM* z1>Y0>*+l8s3*`{~IuLZXCSx|G<46>Ui8}k4@w0lPHpzL@@HTt9xFCK2;ANwxC`qm- zWjihvK~{&;PJ11k>O7vH*!jup2amsEe-67?M@iEJ1yQ=4ZQ%9d->9I;7X~(e5o?4y zPz7~!Orl)9PT|fOh`DE5V3_3~g3U@K`&jwfN_lbvSoDS4|7>tfbJbo97H7iFZAB`% z5U31S9^%K6x>%xCS((x^bfuuSTMjPZOQ+J!`*!ce7GUO z?As)9nZcoKyA>hlqBPC+$qBrL$?4S7HT$MGCAy3F?Ir8Z6hS>oQjwU<$y--2)xBBg zfKT`j8tN|YtvSI(xo}IO?>#DuJbdcngI4H~7WO^9Fd2xhI`RoId;=@YV5|dvbu@V1 EVY~ho;{X5v literal 0 HcmV?d00001 diff --git a/signatures/cagebreak.1.sig b/signatures/cagebreak.1.sig index e0a399bb986388fd35276fee09dbbf5ccac80832..3dfee2837dfb06f16aeb167a6ad00914d94a8ed8 100644 GIT binary patch delta 543 zcmV+)0^t3&1hxc_B7bAMFi-#r2@s&iLxhTBiB*>o5C3*G;_yuX=QbNI>wWbf;)=1j zo`_sXJfKg~LxkjcK2|gO@w(3t7D2fz$4FxmgqPdmLAK^p=Ut4cKto=)(C@X9jgNO0 z)aZ@0$fE^zeS@aY(ChcRo+90j;`2*SUd5g($W)9b7WjRqgMXQ7XT>a!Vyi|qy%J}} zn8W{>yZ5z6sm1~6hjbltL)R0afGVZzS8Iy$REgPr$@A&>1V8Kua9un+@!OYd`CJbl zfV2{f6TOwO=+Bo{F7U)}iYX9O;G{r%Qa#Mx$RoI0LS01r79>goe$xC5rDK_%+mN_R zRIAXfa|?yz9)Aa=LK$>VoSDpS9nb;?HncTuFe5#w9^UTC3Fg4xT0))>f^nGv1>5Jc zlc>$*36Gn8epysrROb;f%5#&9>!%P2kjR9x+W&VcdM0=BX?z$}-Tk?Um?cJa?|kMG zJ)Dws2n8H}|GDO+{Da!A1Bd$9NggHZ}3ILXX`N{g=8+J_HN1azWvA-$!xv$D{& h1B>8w&=?UmXiALLW{}eU!ULXWLCw+HcEAhM3uxUz6C(fs delta 543 zcmV+)0^t3&1hxc_B7b7!J2?Of2@s&iLxhTBiB$;Z5C3CIiYi}VZUk@rlFi%(5Z+s9 z;7*dSC%qB30#iT|^DEQjml6wdbH!J18V_hGA=&?v1+8xU-KTK-aDDk1|2K)t9w0t4 z@j>J+rfBQ1s`5%QHaGZ?5x9L#?4k)qBzAmpsg2!!V4@cdT7O@S(o33~m1+f{XBk^r zS6yol`ot%o&PYy2aUqAh@3P`si3(|47U2AnMxW30zY}f+Nlu;%gUVse4ClfeV!n)#wmm|emr9D zTr%OD;}Dvw8xOoAOJF9LFR%^=fB^LWYSLm@7qV{#W4*=i8c$wEVN;|H6Xg7@17m+z htOd1C-xywclNYq|EaiMM_hNdUDO4~fgV^c_ZDao^2y_4d diff --git a/signatures/cagebreak.sig b/signatures/cagebreak.sig index 1813ed2426494a05f625ea4b7e3ab605ed4f8601..93517d0a5f58e4bcf66f09efccfcb8761670e9f0 100644 GIT binary patch delta 543 zcmV+)0^t3&1hxc_B7bAMFiZdn2@s&iLxhTBiB-XN5CEbD?kEzR4=bDqnBJ9d-G8X< z7noaHb@4b^Ejf~{H*ZK2Hfz>its(dZ<9(TxI`D||g~_`q6?(VP&I;_aXYnzEVm7=o zn{M!|EHe)bvjU#x5Miae)dDN0WhRy}`L19+QGsFtXSi~F_kWc*;{Z|T@JYtBFt1Ut ze3tP1ic<@=bXE|tFjb@O^@j>Qv6WvI^^WnC@-WB;Dz3m!*2DUX8&N4z<{JZD~aiCN5^sx9~MxcE=Iqs zf1H`We4FM6f`4s3vn-m(X=THfsc8;$G))sWg=etoxMdq!V=q%DJW!h(CAiuIRJ(XD z{FW=tIhg$B#!s;h$LmArjjt06H65ts#YOZrFj49!lhxYubf$=ik@!S;R}ONM=skK6Yjyb&Kq$nr-{b+x zY=cKV$th1ir4hb6?9Lf6k3y(_%5azjqq~UcP2f;<^+*2)PIG+ZO)Wo>H+A)SD85>g zw_hk(P4oeW@SZjvNW-0{+~+(hZ~p hNcuxxAQ(mv+VW-^oa-L%m^QMExNP*R*$BgmdKqx72l)U1 delta 543 zcmV+)0^t3&1hxc_B7b7!J2e0b2@s&iLxhTBiB*Cs5C2kfzEETm2p)N&+?5zZ;sYvI z>(v1V8)TJp6_9YKfvX(fGnEZoE`tj6jZ)Xj)7`G$8by96F$1pq)aK^MW-RWH+E7tgj!0WC$a@+dU=ei_#y$#AJBvRo^oqkPj5 zdV9>MSJN*OiGRJ^Q@EExOH*dsAOG_~jqf?iF{MU4(ns*#bf*k6}^lNN)|m zA*On(%6D{YEnQfaE%ZSuMc^b-g5G+b$)2O(p`j$HfO9@KKJ{xZlvR1f#Pmh!3g4Kz zegm<3WUCku0y)(9&<;dBwF1>~G9|-z@;$w4U|xNC?tiq5y_I%{W=xhBVuv;ixd=11gw)#^XtE zH=c<`aXy*w(q)v5d$L(FlsEnd%m_B1OJ9|GY+G(nU5L4jyR49Qq0+4q-T5>j0WD1r hAO@3Vk{EH95&-5K+(|J>yq!Sdp #include "util.h" +#include #include int diff --git a/util.h b/util.h index 01e403e..ef3f532 100644 --- a/util.h +++ b/util.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_UTIL_H #define CG_UTIL_H diff --git a/view.c b/view.c index 0bbd03b..74c31b8 100644 --- a/view.c +++ b/view.c @@ -1,11 +1,5 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200809L @@ -15,9 +9,11 @@ #include #include #include -#include +#include +#include #include +#include "ipc_server.h" #include "output.h" #include "seat.h" #include "server.h" @@ -49,127 +45,6 @@ view_get_prev_view(struct cg_view *view) { return prev; } -void -view_damage_child(struct cg_view_child *child, bool whole) { - if(child->view != NULL) { - view_damage_part(child->view); - } -} - -static void -view_child_handle_commit(struct wl_listener *listener, void *_data) { - struct cg_view_child *child = wl_container_of(listener, child, commit); - view_damage_child(child, false); -} - -static void -subsurface_create(struct cg_view_child *parent, struct cg_view *view, - struct wlr_subsurface *wlr_subsurface); - -static void -view_child_handle_new_subsurface(struct wl_listener *listener, void *data) { - struct cg_view_child *child = - wl_container_of(listener, child, new_subsurface); - struct wlr_subsurface *wlr_subsurface = data; - subsurface_create(child, child->view, wlr_subsurface); -} - -void -view_child_finish(struct cg_view_child *child) { - if(!child) { - return; - } - - if(child->view != NULL) { - view_damage_child(child, true); - } - - struct cg_view_child *subchild, *tmpchild; - wl_list_for_each_safe(subchild, tmpchild, &child->children, parent_link) { - subchild->parent = NULL; - wl_list_remove(&subchild->parent_link); - } - - wl_list_remove(&child->link); - if(child->parent != NULL) { - wl_list_remove(&child->parent_link); - } - wl_list_remove(&child->commit.link); - wl_list_remove(&child->new_subsurface.link); -} - -void -view_child_init(struct cg_view_child *child, struct cg_view_child *parent, - struct cg_view *view, struct wlr_surface *wlr_surface) { - child->view = view; - child->parent = parent; - if(parent != NULL) { - wl_list_insert(&parent->children, &child->parent_link); - } - child->wlr_surface = wlr_surface; - wl_list_init(&child->children); - - child->commit.notify = view_child_handle_commit; - wl_signal_add(&wlr_surface->events.commit, &child->commit); - child->new_subsurface.notify = view_child_handle_new_subsurface; - wl_signal_add(&wlr_surface->events.new_subsurface, &child->new_subsurface); - - wl_list_insert(&view->children, &child->link); -} - -static void -subsurface_destroy(struct cg_view_child *child) { - if(!child) { - return; - } - - struct cg_subsurface *subsurface = (struct cg_subsurface *)child; - wl_list_remove(&subsurface->destroy.link); - view_child_finish(&subsurface->view_child); - free(subsurface); -} - -static void -subsurface_handle_destroy(struct wl_listener *listener, void *_data) { - struct cg_subsurface *subsurface = - wl_container_of(listener, subsurface, destroy); - struct cg_view_child *view_child = (struct cg_view_child *)subsurface; - subsurface_destroy(view_child); -} - -static void -subsurface_create(struct cg_view_child *parent, struct cg_view *view, - struct wlr_subsurface *wlr_subsurface) { - struct cg_subsurface *subsurface = calloc(1, sizeof(struct cg_subsurface)); - if(!subsurface) { - return; - } - - view_child_init(&subsurface->view_child, parent, view, - wlr_subsurface->surface); - subsurface->view_child.destroy = subsurface_destroy; - subsurface->wlr_subsurface = wlr_subsurface; - - subsurface->destroy.notify = subsurface_handle_destroy; - wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy); -} - -static void -handle_new_subsurface(struct wl_listener *listener, void *data) { - struct cg_view *view = wl_container_of(listener, view, new_subsurface); - struct wlr_subsurface *wlr_subsurface = data; - subsurface_create(NULL, view, wlr_subsurface); -} - -char * -view_get_title(const struct cg_view *view) { - const char *title = view->impl->get_title(view); - if(!title) { - return NULL; - } - return strndup(title, strlen(title)); -} - bool view_is_primary(const struct cg_view *view) { return view->impl->is_primary(view); @@ -195,28 +70,6 @@ view_is_visible(const struct cg_view *view) { return view_get_tile(view) != NULL; } -void -view_damage(struct cg_view *view, bool whole) { - struct cg_tile *view_tile = view_get_tile(view); - if(view_tile != NULL && - (view->wlr_surface->current.width != view_tile->tile.width || - view->wlr_surface->current.height != view_tile->tile.height)) { - view_maximize(view, view_tile); - } - output_damage_surface(view->workspace->output, view->wlr_surface, view->ox, - view->oy, whole); -} - -void -view_damage_part(struct cg_view *view) { - view_damage(view, false); -} - -void -view_damage_whole(struct cg_view *view) { - view_damage(view, true); -} - void view_activate(struct cg_view *view, bool activate) { if(view != NULL) { @@ -228,45 +81,42 @@ void view_maximize(struct cg_view *view, struct cg_tile *tile) { view->ox = tile->tile.x; view->oy = tile->tile.y; + struct wlr_box box; + wlr_output_layout_get_box(view->server->output_layout, + view->workspace->output->wlr_output, &box); + wlr_scene_node_set_position(&view->scene_tree->node, view->ox + box.x, + view->oy + box.y); view->impl->maximize(view, tile->tile.width, tile->tile.height); view->tile = tile; -} - -void -view_for_each_surface(struct cg_view *view, - wlr_surface_iterator_func_t iterator, void *data) { - view->impl->for_each_surface(view, iterator, data); -} - -void -view_for_each_popup(struct cg_view *view, wlr_surface_iterator_func_t iterator, - void *data) { - if(!view->impl->for_each_popup) { - return; - } - view->impl->for_each_popup(view, iterator, data); + wlr_scene_node_raise_to_top(&view->scene_tree->node); } void view_unmap(struct cg_view *view) { + + uint32_t id = view->id; + uint32_t tile_id = 0; + uint32_t ws = view->workspace->num; + char *output_name = view->workspace->output->wlr_output->name; + int output_id = output_get_num(view->workspace->output); + pid_t pid = view->impl->get_pid(view); /* If the view is not mapped, do nothing */ if(view->wlr_surface == NULL) { return; } - struct cg_view_child *child, *tmp; - wl_list_for_each_safe(child, tmp, &view->children, link) { - child->destroy(child); + if(view->tile == NULL) { + tile_id = -1; + } else { + tile_id = view->tile->id; } + + wlr_scene_node_destroy(&view->scene_tree->node); + #if CG_HAS_XWAYLAND if((view->type != CG_XWAYLAND_VIEW || xwayland_view_should_manage(view))) #endif { - struct cg_tile *view_tile = view_get_tile(view); - if(view_tile != NULL) { - wlr_output_damage_add_box(view_tile->workspace->output->damage, - &view_tile->tile); - } struct cg_view *prev = view_get_prev_view(view); if(view == view->server->seat->focused_view) { seat_set_focus(view->server->seat, prev); @@ -276,19 +126,13 @@ view_unmap(struct cg_view *view) { seat_set_focus(view->server->seat, view->server->seat->focused_view); } - view_tile = view_get_tile(view); + struct cg_tile *view_tile = view_get_tile(view); if(view_tile != NULL) { - wlr_output_damage_add_box(view_tile->workspace->output->damage, - &view_tile->tile); - view_tile->view = prev; - if(prev != NULL) { - view_maximize(prev, view_tile); - } + workspace_tile_update_view(view_tile, prev); } } #if CG_HAS_XWAYLAND else { - view_damage_whole(view); if(view->server->seat->seat->keyboard_state.focused_surface == NULL || view->server->seat->seat->keyboard_state.focused_surface == view->wlr_surface) { @@ -300,8 +144,12 @@ view_unmap(struct cg_view *view) { wl_list_remove(&view->link); - wl_list_remove(&view->new_subsurface.link); view->wlr_surface = NULL; + ipc_send_event( + view->workspace->server, + "{\"event_name\":\"view_unmap\",\"view_id\":%d,\"tile_id\":%d," + "\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d,\"view_pid\":%d}", + id, tile_id, ws + 1, output_name, output_id, pid); } void @@ -310,21 +158,12 @@ view_map(struct cg_view *view, struct wlr_surface *surface, struct cg_output *output = ws->output; view->wlr_surface = surface; - struct wlr_subsurface *subsurface; - wl_list_for_each(subsurface, &view->wlr_surface->current.subsurfaces_above, - current.link) { - subsurface_create(NULL, view, subsurface); + view->scene_tree = wlr_scene_subsurface_tree_create(ws->scene, surface); + if(!view->scene_tree) { + wl_resource_post_no_memory(surface->resource); + return; } - - wl_list_for_each(subsurface, &view->wlr_surface->current.subsurfaces_below, - current.link) { - subsurface_create(NULL, view, subsurface); - } - - view->new_subsurface.notify = handle_new_subsurface; - wl_signal_add(&view->wlr_surface->events.new_subsurface, - &view->new_subsurface); - + view->scene_tree->node.data = view; view->workspace = ws; #if CG_HAS_XWAYLAND @@ -332,14 +171,30 @@ view_map(struct cg_view *view, struct wlr_surface *surface, their own (x,y) coordinates in handle_wayland_surface_map. */ if(view->type == CG_XWAYLAND_VIEW && !xwayland_view_should_manage(view)) { wl_list_insert(&ws->unmanaged_views, &view->link); + struct wlr_box box; + wlr_output_layout_get_box(view->server->output_layout, + view->workspace->output->wlr_output, &box); + wlr_scene_node_set_position(&view->scene_tree->node, view->ox + box.x, + view->oy + box.y); } else #endif { - view->tile = view->workspace->focused_tile; - view_maximize(view, view->tile); wl_list_insert(&ws->views, &view->link); } seat_set_focus(output->server->seat, view); + int tile_id = 0; + if(view->tile == NULL) { + tile_id = -1; + } else { + tile_id = view->tile->id; + } + ipc_send_event( + output->server, + "{\"event_name\":\"view_map\",\"view_id\":%d,\"tile_id\":%d," + "\"workspace\":%d,\"output\":\"%s\",\"output_id\":%d,\"view_pid\":%d}", + view->id, tile_id, view->workspace->num + 1, + view->workspace->output->wlr_output->name, + output_get_num(view->workspace->output), view->impl->get_pid(view)); } void @@ -363,12 +218,6 @@ view_init(struct cg_view *view, enum cg_view_type type, view->server = server; view->type = type; view->impl = impl; - - wl_list_init(&view->children); -} - -struct wlr_surface * -view_wlr_surface_at(const struct cg_view *view, double sx, double sy, - double *sub_x, double *sub_y) { - return view->impl->wlr_surface_at(view, sx, sy, sub_x, sub_y); + view->id = server->views_curr_id; + ++server->views_curr_id; } diff --git a/view.h b/view.h index 62a1f32..99e3e65 100644 --- a/view.h +++ b/view.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_VIEW_H #define CG_VIEW_H @@ -5,7 +8,7 @@ #include #include -#include +#include struct cg_server; struct wlr_box; @@ -20,10 +23,10 @@ enum cg_view_type { struct cg_view { struct cg_workspace *workspace; struct cg_server *server; - struct wl_list link; // server::views - struct wl_list children; // cg_view_child::link + struct wl_list link; // server::views struct wlr_surface *wlr_surface; struct cg_tile *tile; + struct wlr_scene_tree *scene_tree; /* The view has a position in output coordinates. */ int ox, oy; @@ -31,48 +34,18 @@ struct cg_view { enum cg_view_type type; const struct cg_view_impl *impl; - struct wl_listener new_subsurface; + uint32_t id; }; struct cg_view_impl { - char *(*get_title)(const struct cg_view *view); + pid_t (*get_pid)(const struct cg_view *view); bool (*is_primary)(const struct cg_view *view); void (*activate)(struct cg_view *view, bool activate); void (*close)(struct cg_view *view); void (*maximize)(struct cg_view *view, int width, int height); void (*destroy)(struct cg_view *view); - void (*for_each_surface)(struct cg_view *view, - wlr_surface_iterator_func_t iterator, void *data); - void (*for_each_popup)(struct cg_view *view, - wlr_surface_iterator_func_t iterator, void *data); - struct wlr_surface *(*wlr_surface_at)(const struct cg_view *view, double sx, - double sy, double *sub_x, - double *sub_y); }; -struct cg_view_child { - struct cg_view *view; - struct cg_view_child *parent; - struct wl_list children; - struct wlr_surface *wlr_surface; - struct wl_list link; - struct wl_list parent_link; - - struct wl_listener commit; - struct wl_listener new_subsurface; - - void (*destroy)(struct cg_view_child *child); -}; - -struct cg_subsurface { - struct cg_view_child view_child; - struct wlr_subsurface *wlr_subsurface; - - struct wl_listener destroy; -}; - -char * -view_get_title(const struct cg_view *view); struct cg_tile * view_get_tile(const struct cg_view *view); bool @@ -80,20 +53,8 @@ view_is_primary(const struct cg_view *view); bool view_is_visible(const struct cg_view *view); void -view_damage_part(struct cg_view *view); -void -view_damage_whole(struct cg_view *view); -void -view_damage_child(struct cg_view_child *view, bool whole); -void view_activate(struct cg_view *view, bool activate); void -view_for_each_surface(struct cg_view *view, - wlr_surface_iterator_func_t iterator, void *data); -void -view_for_each_popup(struct cg_view *view, wlr_surface_iterator_func_t iterator, - void *data); -void view_unmap(struct cg_view *view); void view_maximize(struct cg_view *view, struct cg_tile *tile); @@ -105,16 +66,6 @@ view_destroy(struct cg_view *view); void view_init(struct cg_view *view, enum cg_view_type type, const struct cg_view_impl *impl, struct cg_server *server); - -struct wlr_surface * -view_wlr_surface_at(const struct cg_view *view, double sx, double sy, - double *sub_x, double *sub_y); - -void -view_child_finish(struct cg_view_child *child); -void -view_child_init(struct cg_view_child *child, struct cg_view_child *parent, - struct cg_view *view, struct wlr_surface *wlr_surface); struct cg_view * view_get_prev_view(struct cg_view *view); diff --git a/workspace.c b/workspace.c index 1b701e8..1caff0d 100644 --- a/workspace.c +++ b/workspace.c @@ -1,24 +1,34 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2019 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200809L #include #include #include +#include #include #include "message.h" #include "output.h" +#include "seat.h" #include "server.h" +#include "view.h" #include "workspace.h" +void +workspace_tile_update_view(struct cg_tile *tile, struct cg_view *view) { + if(tile->view != NULL) { + wlr_scene_node_set_enabled(&tile->view->scene_tree->node, false); + tile->view->tile = NULL; + } + tile->view = view; + if(view != NULL) { + view_maximize(view, tile); + wlr_scene_node_set_enabled(&view->scene_tree->node, true); + } +} + #if CG_HAS_FANALYZE #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak" @@ -26,7 +36,8 @@ int full_screen_workspace_tiles(struct wlr_output_layout *layout, struct wlr_output *output, - struct cg_workspace *workspace) { + struct cg_workspace *workspace, + uint32_t *tiles_curr_id) { workspace->focused_tile = calloc(1, sizeof(struct cg_tile)); if(!workspace->focused_tile) { return -1; @@ -36,10 +47,13 @@ full_screen_workspace_tiles(struct wlr_output_layout *layout, workspace->focused_tile->prev = workspace->focused_tile; workspace->focused_tile->tile.x = 0; workspace->focused_tile->tile.y = 0; - struct wlr_box *output_box = wlr_output_layout_get_box(layout, output); - workspace->focused_tile->tile.width = output_box->width; - workspace->focused_tile->tile.height = output_box->height; - workspace->focused_tile->view = NULL; + struct wlr_box output_box; + wlr_output_layout_get_box(layout, output, &output_box); + workspace->focused_tile->tile.width = output_box.width; + workspace->focused_tile->tile.height = output_box.height; + workspace_tile_update_view(workspace->focused_tile, NULL); + workspace->focused_tile->id = *tiles_curr_id; + ++(*tiles_curr_id); return 0; } #if CG_HAS_FANALYZE @@ -52,9 +66,18 @@ full_screen_workspace(struct cg_output *output) { if(!workspace) { return NULL; } + struct wlr_scene_output *scene_output = + wlr_scene_get_scene_output(output->server->scene, output->wlr_output); + if(scene_output == NULL) { + free(workspace); + return NULL; + } workspace->server = output->server; + workspace->num = -1; + workspace->scene = wlr_scene_tree_create(&scene_output->scene->tree); if(full_screen_workspace_tiles(output->server->output_layout, - output->wlr_output, workspace) != 0) { + output->wlr_output, workspace, + &output->server->tiles_curr_id) != 0) { free(workspace); return NULL; } @@ -72,13 +95,18 @@ workspace_focus_tile(struct cg_workspace *ws, struct cg_tile *tile) { } box->x = tile->tile.x + tile->tile.width / 2; box->y = tile->tile.y + tile->tile.height / 2; - message_printf_pos(ws->output, box, CG_MESSAGE_CENTER, "Current frame"); + message_printf_pos(ws->output, box, CG_MESSAGE_CENTER, "Current tile"); } void workspace_free_tiles(struct cg_workspace *workspace) { workspace->focused_tile->prev->next = NULL; while(workspace->focused_tile != NULL) { + if(workspace->output->server->running && + workspace->output->server->seat->cursor_tile == + workspace->focused_tile) { + workspace->output->server->seat->cursor_tile = NULL; + } struct cg_tile *next = workspace->focused_tile->next; free(workspace->focused_tile); workspace->focused_tile = next; @@ -90,3 +118,19 @@ workspace_free(struct cg_workspace *workspace) { workspace_free_tiles(workspace); free(workspace); } + +void +workspace_focus(struct cg_output *outp, int ws) { + if(ws >= outp->server->nws) { + wlr_log(WLR_ERROR, + "Attempt to focus workspace %d, but only %d workspaces are " + "available.", + ws, outp->server->nws); + return; + } + wlr_scene_node_place_above( + &outp->bg->node, &outp->workspaces[outp->curr_workspace]->scene->node); + wlr_scene_node_place_above(&outp->workspaces[ws]->scene->node, + &outp->bg->node); + outp->curr_workspace = ws; +} diff --git a/workspace.h b/workspace.h index 0e8f91f..e0f2473 100644 --- a/workspace.h +++ b/workspace.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_WORKSPACE_H #define CG_WORKSPACE_H @@ -12,6 +15,7 @@ struct cg_tile { struct cg_view *view; struct cg_tile *next; struct cg_tile *prev; + uint32_t id; }; struct cg_workspace { @@ -19,8 +23,10 @@ struct cg_workspace { struct wl_list views; struct wl_list unmanaged_views; struct cg_output *output; + struct wlr_scene_tree *scene; struct cg_tile *focused_tile; + uint32_t num; }; struct cg_workspace * @@ -28,12 +34,17 @@ full_screen_workspace(struct cg_output *output); int full_screen_workspace_tiles(struct wlr_output_layout *layout, struct wlr_output *output, - struct cg_workspace *workspace); + struct cg_workspace *workspace, + uint32_t *tiles_curr_id); void workspace_free_tiles(struct cg_workspace *workspace); void workspace_free(struct cg_workspace *workspace); void workspace_focus_tile(struct cg_workspace *ws, struct cg_tile *tile); +void +workspace_focus(struct cg_output *outp, int ws); +void +workspace_tile_update_view(struct cg_tile *tile, struct cg_view *view); #endif diff --git a/xdg_shell.c b/xdg_shell.c index 6b9b074..fc251c7 100644 --- a/xdg_shell.c +++ b/xdg_shell.c @@ -1,17 +1,13 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2019 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT #define _POSIX_C_SOURCE 200809L +#include #include #include #include +#include #include #include #include @@ -24,8 +20,29 @@ #include "workspace.h" #include "xdg_shell.h" +static struct cg_view * +popup_get_view(struct wlr_xdg_popup *popup) { + while(true) { + if(popup->parent == NULL || + !wlr_surface_is_xdg_surface(popup->parent)) { + return NULL; + } + struct wlr_xdg_surface *xdg_surface = + wlr_xdg_surface_from_wlr_surface(popup->parent); + switch(xdg_surface->role) { + case WLR_XDG_SURFACE_ROLE_TOPLEVEL: + return xdg_surface->data; + case WLR_XDG_SURFACE_ROLE_POPUP: + popup = xdg_surface->popup; + break; + case WLR_XDG_SURFACE_ROLE_NONE: + return NULL; + } + } +} + static void -xdg_decoration_handle_destroy(struct wl_listener *listener, void *_data) { +xdg_decoration_handle_destroy(struct wl_listener *listener, void *data) { struct cg_xdg_decoration *xdg_decoration = wl_container_of(listener, xdg_decoration, destroy); @@ -53,100 +70,25 @@ xdg_decoration_handle_request_mode(struct wl_listener *listener, void *_data) { #endif static void -xdg_popup_destroy(struct cg_view_child *child) { - if(!child) { - return; - } - - view_damage_child(child, true); - struct cg_xdg_popup *popup = (struct cg_xdg_popup *)child; - wl_list_remove(&popup->destroy.link); - wl_list_remove(&popup->map.link); - wl_list_remove(&popup->unmap.link); - wl_list_remove(&popup->new_popup.link); - view_child_finish(&popup->view_child); - free(popup); -} - -static void -handle_xdg_popup_map(struct wl_listener *listener, void *_data) { - struct cg_xdg_popup *popup = wl_container_of(listener, popup, map); - view_damage_whole(popup->view_child.view); -} - -static void -handle_xdg_popup_unmap(struct wl_listener *listener, void *_data) { - struct cg_xdg_popup *popup = wl_container_of(listener, popup, unmap); - view_damage_whole(popup->view_child.view); -} - -static void -handle_xdg_popup_destroy(struct wl_listener *listener, void *_data) { - struct cg_xdg_popup *popup = wl_container_of(listener, popup, destroy); - struct cg_view_child *view_child = (struct cg_view_child *)popup; - xdg_popup_destroy(view_child); -} - -static void -xdg_popup_create(struct cg_view *view, struct wlr_xdg_popup *wlr_popup); - -static void -popup_handle_new_xdg_popup(struct wl_listener *listener, void *data) { - struct cg_xdg_popup *popup = wl_container_of(listener, popup, new_popup); - struct wlr_xdg_popup *wlr_popup = data; - xdg_popup_create(popup->view_child.view, wlr_popup); -} - -static void -popup_unconstrain(struct cg_xdg_popup *popup) { - struct cg_view *view = popup->view_child.view; - struct wlr_box *popup_box = &popup->wlr_popup->geometry; +popup_unconstrain(struct cg_view *view, struct wlr_xdg_popup *popup) { + struct wlr_box *popup_box = &popup->current.geometry; struct wlr_output_layout *output_layout = view->server->output_layout; - struct wlr_box *view_output_box = wlr_output_layout_get_box( - output_layout, view->workspace->output->wlr_output); + struct wlr_box view_output_box; + wlr_output_layout_get_box( + output_layout, view->workspace->output->wlr_output, &view_output_box); struct wlr_output *wlr_output = wlr_output_layout_output_at( - output_layout, view_output_box->x + view->ox + popup_box->x, - view_output_box->y + view->oy + popup_box->y); - struct wlr_box *output_box = - wlr_output_layout_get_box(output_layout, wlr_output); + output_layout, view_output_box.x + view->ox + popup_box->x, + view_output_box.y + view->oy + popup_box->y); + struct wlr_box output_box; + wlr_output_layout_get_box(output_layout, wlr_output, &output_box); struct wlr_box output_toplevel_box = {.x = -view->ox, .y = -view->oy, - .width = output_box->width, - .height = output_box->height}; + .width = output_box.width, + .height = output_box.height}; - wlr_xdg_popup_unconstrain_from_box(popup->wlr_popup, &output_toplevel_box); -} - -static void -xdg_popup_create(struct cg_view *view, struct wlr_xdg_popup *wlr_popup) { - struct cg_xdg_popup *popup = calloc(1, sizeof(struct cg_xdg_popup)); - if(!popup) { - return; - } - - popup->wlr_popup = wlr_popup; - view_child_init(&popup->view_child, NULL, view, wlr_popup->base->surface); - popup->view_child.destroy = xdg_popup_destroy; - popup->destroy.notify = handle_xdg_popup_destroy; - wl_signal_add(&wlr_popup->base->events.destroy, &popup->destroy); - popup->map.notify = handle_xdg_popup_map; - wl_signal_add(&wlr_popup->base->events.map, &popup->map); - popup->unmap.notify = handle_xdg_popup_unmap; - wl_signal_add(&wlr_popup->base->events.unmap, &popup->unmap); - popup->new_popup.notify = popup_handle_new_xdg_popup; - wl_signal_add(&wlr_popup->base->events.new_popup, &popup->new_popup); - - popup_unconstrain(popup); -} - -static void -handle_new_xdg_popup(struct wl_listener *listener, void *data) { - struct cg_xdg_shell_view *xdg_shell_view = - wl_container_of(listener, xdg_shell_view, new_popup); - struct wlr_xdg_popup *wlr_popup = data; - xdg_popup_create(&xdg_shell_view->view, wlr_popup); + wlr_xdg_popup_unconstrain_from_box(popup, &output_toplevel_box); } static struct cg_xdg_shell_view * @@ -159,27 +101,29 @@ xdg_shell_view_from_const_view(const struct cg_view *view) { return (const struct cg_xdg_shell_view *)view; } -static char * -get_title(const struct cg_view *view) { - const struct cg_xdg_shell_view *xdg_shell_view = - xdg_shell_view_from_const_view(view); - return xdg_shell_view->xdg_surface->toplevel->title; +static pid_t +get_pid(const struct cg_view *view) { + pid_t pid; + struct wl_client *client = + wl_resource_get_client(view->wlr_surface->resource); + wl_client_get_credentials(client, &pid, NULL, NULL); + return pid; } static bool is_primary(const struct cg_view *view) { const struct cg_xdg_shell_view *xdg_shell_view = xdg_shell_view_from_const_view(view); - struct wlr_xdg_surface *parent = + struct wlr_xdg_toplevel *parent = xdg_shell_view->xdg_surface->toplevel->parent; - /* FIXME: role is 0? */ - return parent == NULL; /*&& role == WLR_XDG_SURFACE_ROLE_TOPLEVEL */ + return parent == NULL; } static void activate(struct cg_view *view, bool activate) { struct cg_xdg_shell_view *xdg_shell_view = xdg_shell_view_from_view(view); - wlr_xdg_toplevel_set_activated(xdg_shell_view->xdg_surface, activate); + wlr_xdg_toplevel_set_activated(xdg_shell_view->xdg_surface->toplevel, + activate); } static void @@ -187,17 +131,18 @@ close(struct cg_view *view) { struct cg_xdg_shell_view *xdg_shell_view = xdg_shell_view_from_view(view); struct wlr_xdg_surface *surface = xdg_shell_view->xdg_surface; if(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) { - wlr_xdg_toplevel_send_close(surface); + wlr_xdg_toplevel_send_close(surface->toplevel); } } static void maximize(struct cg_view *view, int width, int height) { struct cg_xdg_shell_view *xdg_shell_view = xdg_shell_view_from_view(view); - wlr_xdg_toplevel_set_size(xdg_shell_view->xdg_surface, width, height); + wlr_xdg_toplevel_set_size(xdg_shell_view->xdg_surface->toplevel, width, + height); enum wlr_edges edges = WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM; - wlr_xdg_toplevel_set_tiled(xdg_shell_view->xdg_surface, edges); + wlr_xdg_toplevel_set_tiled(xdg_shell_view->xdg_surface->toplevel, edges); } static void @@ -206,47 +151,25 @@ destroy(struct cg_view *view) { free(xdg_shell_view); } -static void -for_each_surface(struct cg_view *view, wlr_surface_iterator_func_t iterator, - void *data) { - struct cg_xdg_shell_view *xdg_shell_view = xdg_shell_view_from_view(view); - wlr_xdg_surface_for_each_surface(xdg_shell_view->xdg_surface, iterator, - data); -} - -static void -for_each_popup(struct cg_view *view, wlr_surface_iterator_func_t iterator, - void *data) { - struct cg_xdg_shell_view *xdg_shell_view = xdg_shell_view_from_view(view); - wlr_xdg_surface_for_each_popup_surface(xdg_shell_view->xdg_surface, - iterator, data); -} - -static struct wlr_surface * -wlr_surface_at(const struct cg_view *view, double sx, double sy, double *sub_x, - double *sub_y) { - const struct cg_xdg_shell_view *xdg_shell_view = - xdg_shell_view_from_const_view(view); - return wlr_xdg_surface_surface_at(xdg_shell_view->xdg_surface, sx, sy, - sub_x, sub_y); -} - static void handle_xdg_shell_surface_request_fullscreen(struct wl_listener *listener, void *data) { struct cg_xdg_shell_view *xdg_shell_view = wl_container_of(listener, xdg_shell_view, request_fullscreen); - struct wlr_xdg_toplevel_set_fullscreen_event *event = data; - wlr_xdg_toplevel_set_fullscreen(xdg_shell_view->xdg_surface, - event->fullscreen); -} -static void -handle_xdg_shell_surface_commit(struct wl_listener *listener, void *_data) { - struct cg_xdg_shell_view *xdg_shell_view = - wl_container_of(listener, xdg_shell_view, commit); - struct cg_view *view = &xdg_shell_view->view; - view_damage_part(view); + /** + * Certain clients do not like figuring out their own window geometry if + * they display in fullscreen mode, so we set it here. + */ + struct wlr_box layout_box; + wlr_output_layout_get_box(xdg_shell_view->view.server->output_layout, NULL, + &layout_box); + wlr_xdg_toplevel_set_size(xdg_shell_view->xdg_surface->toplevel, + layout_box.width, layout_box.height); + + wlr_xdg_toplevel_set_fullscreen( + xdg_shell_view->xdg_surface->toplevel, + xdg_shell_view->xdg_surface->toplevel->requested.fullscreen); } static void @@ -255,9 +178,6 @@ handle_xdg_shell_surface_unmap(struct wl_listener *listener, void *_data) { wl_container_of(listener, xdg_shell_view, unmap); struct cg_view *view = &xdg_shell_view->view; - wl_list_remove(&xdg_shell_view->new_popup.link); - wl_list_remove(&xdg_shell_view->commit.link); - view_unmap(view); } @@ -267,17 +187,9 @@ handle_xdg_shell_surface_map(struct wl_listener *listener, void *_data) { wl_container_of(listener, xdg_shell_view, map); struct cg_view *view = &xdg_shell_view->view; - xdg_shell_view->commit.notify = handle_xdg_shell_surface_commit; - wl_signal_add(&xdg_shell_view->xdg_surface->surface->events.commit, - &xdg_shell_view->commit); - xdg_shell_view->new_popup.notify = handle_new_xdg_popup; - wl_signal_add(&xdg_shell_view->xdg_surface->events.new_popup, - &xdg_shell_view->new_popup); - view_map(view, xdg_shell_view->xdg_surface->surface, view->server->curr_output ->workspaces[view->server->curr_output->curr_workspace]); - view_damage_whole(view); } static void @@ -295,17 +207,13 @@ handle_xdg_shell_surface_destroy(struct wl_listener *listener, void *_data) { view_destroy(view); } -static const struct cg_view_impl xdg_shell_view_impl = { - .get_title = get_title, - .is_primary = is_primary, - .activate = activate, - .close = close, - .maximize = maximize, - .destroy = destroy, - .for_each_surface = for_each_surface, - .for_each_popup = for_each_popup, - .wlr_surface_at = wlr_surface_at, -}; +static const struct cg_view_impl xdg_shell_view_impl = {.get_pid = get_pid, + .is_primary = + is_primary, + .activate = activate, + .close = close, + .maximize = maximize, + .destroy = destroy}; void handle_xdg_shell_surface_new(struct wl_listener *listener, void *data) { @@ -313,31 +221,72 @@ handle_xdg_shell_surface_new(struct wl_listener *listener, void *data) { wl_container_of(listener, server, new_xdg_shell_surface); struct wlr_xdg_surface *xdg_surface = data; - if(xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) { - return; + switch(xdg_surface->role) { + case WLR_XDG_SURFACE_ROLE_TOPLEVEL:; + struct cg_xdg_shell_view *xdg_shell_view = + calloc(1, sizeof(struct cg_xdg_shell_view)); + if(!xdg_shell_view) { + wlr_log(WLR_ERROR, "Failed to allocate XDG Shell view"); + return; + } + + view_init(&xdg_shell_view->view, CG_XDG_SHELL_VIEW, + &xdg_shell_view_impl, server); + + xdg_shell_view->xdg_surface = xdg_surface; + + xdg_shell_view->map.notify = handle_xdg_shell_surface_map; + wl_signal_add(&xdg_surface->events.map, &xdg_shell_view->map); + xdg_shell_view->unmap.notify = handle_xdg_shell_surface_unmap; + wl_signal_add(&xdg_surface->events.unmap, &xdg_shell_view->unmap); + xdg_shell_view->destroy.notify = handle_xdg_shell_surface_destroy; + wl_signal_add(&xdg_surface->events.destroy, &xdg_shell_view->destroy); + xdg_shell_view->request_fullscreen.notify = + handle_xdg_shell_surface_request_fullscreen; + wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen, + &xdg_shell_view->request_fullscreen); + + xdg_surface->data = xdg_shell_view; + break; + case WLR_XDG_SURFACE_ROLE_POPUP:; + struct wlr_xdg_popup *popup = xdg_surface->popup; + struct cg_view *view = popup_get_view(popup); + if(view == NULL) { + return; + } + + struct wlr_scene_tree *parent_scene_tree = NULL; + struct wlr_xdg_surface *parent = + wlr_xdg_surface_from_wlr_surface(popup->parent); + switch(parent->role) { + case WLR_XDG_SURFACE_ROLE_TOPLEVEL:; + parent_scene_tree = view->scene_tree; + break; + case WLR_XDG_SURFACE_ROLE_POPUP: + parent_scene_tree = parent->data; + break; + case WLR_XDG_SURFACE_ROLE_NONE: + break; + } + if(parent_scene_tree == NULL) { + return; + } + + struct wlr_scene_tree *popup_scene_tree = + wlr_scene_xdg_surface_create(parent_scene_tree, xdg_surface); + if(popup_scene_tree == NULL) { + wlr_log(WLR_ERROR, + "Failed to allocate scene-graph node for XDG popup"); + return; + } + + popup_unconstrain(view, popup); + + xdg_surface->data = popup_scene_tree; + break; + case WLR_XDG_SURFACE_ROLE_NONE: + assert(false); // unreachable } - - struct cg_xdg_shell_view *xdg_shell_view = - calloc(1, sizeof(struct cg_xdg_shell_view)); - if(!xdg_shell_view) { - wlr_log(WLR_ERROR, "Failed to allocate XDG Shell view"); - return; - } - view_init(&xdg_shell_view->view, CG_XDG_SHELL_VIEW, &xdg_shell_view_impl, - server); - - xdg_shell_view->xdg_surface = xdg_surface; - - xdg_shell_view->map.notify = handle_xdg_shell_surface_map; - wl_signal_add(&xdg_surface->events.map, &xdg_shell_view->map); - xdg_shell_view->unmap.notify = handle_xdg_shell_surface_unmap; - wl_signal_add(&xdg_surface->events.unmap, &xdg_shell_view->unmap); - xdg_shell_view->destroy.notify = handle_xdg_shell_surface_destroy; - wl_signal_add(&xdg_surface->events.destroy, &xdg_shell_view->destroy); - xdg_shell_view->request_fullscreen.notify = - handle_xdg_shell_surface_request_fullscreen; - wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen, - &xdg_shell_view->request_fullscreen); } void diff --git a/xdg_shell.h b/xdg_shell.h index 601134b..e066208 100644 --- a/xdg_shell.h +++ b/xdg_shell.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_XDG_SHELL_H #define CG_XDG_SHELL_H @@ -10,19 +13,7 @@ struct cg_xdg_shell_view { struct wl_listener destroy; struct wl_listener unmap; struct wl_listener map; - struct wl_listener commit; struct wl_listener request_fullscreen; - struct wl_listener new_popup; -}; - -struct cg_xdg_popup { - struct cg_view_child view_child; - struct wlr_xdg_popup *wlr_popup; - - struct wl_listener destroy; - struct wl_listener map; - struct wl_listener unmap; - struct wl_listener new_popup; }; struct cg_xdg_decoration { diff --git a/xwayland.c b/xwayland.c index 98d0803..f601a0f 100644 --- a/xwayland.c +++ b/xwayland.c @@ -1,11 +1,6 @@ -/* - * Cagebreak: A Wayland tiling compositor. - * - * Copyright (C) 2020-2022 The Cagebreak Authors - * Copyright (C) 2018-2020 Jente Hidskes - * - * See the LICENSE file accompanying this file. - */ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #include "config.h" #include @@ -44,11 +39,11 @@ xwayland_view_should_manage(const struct cg_view *view) { return !xwayland_surface->override_redirect; } -static char * -get_title(const struct cg_view *view) { - const struct cg_xwayland_view *xwayland_view = - xwayland_view_from_const_view(view); - return xwayland_view->xwayland_surface->title; +static pid_t +get_pid(const struct cg_view *view) { + struct wlr_xwayland_surface *surf = + wlr_xwayland_surface_from_wlr_surface(view->wlr_surface); + return surf->pid; } static bool @@ -64,6 +59,10 @@ static void activate(struct cg_view *view, bool activate) { struct cg_xwayland_view *xwayland_view = xwayland_view_from_view(view); wlr_xwayland_surface_activate(xwayland_view->xwayland_surface, activate); + if(activate) { + wlr_xwayland_surface_restack(xwayland_view->xwayland_surface, NULL, + XCB_STACK_MODE_ABOVE); + } } static void @@ -75,35 +74,25 @@ close(struct cg_view *view) { static void maximize(struct cg_view *view, int width, int height) { struct cg_xwayland_view *xwayland_view = xwayland_view_from_view(view); - struct cg_output *output = view->workspace->output; - - struct wlr_box *box = wlr_output_layout_get_box( - view->server->output_layout, view->workspace->output->wlr_output); - struct wlr_xwayland_surface_size_hints *hints = - xwayland_view->xwayland_surface->size_hints; + xcb_size_hints_t *hints = xwayland_view->xwayland_surface->size_hints; if(hints != NULL && hints->flags & PMaxSize) { if(width > hints->max_width) { - wlr_output_damage_add_box(output->damage, - &(struct wlr_box){.x = view->ox + box->x, - .y = view->oy + box->y, - .width = width, - .height = height}); width = hints->max_width; } if(height > hints->max_height) { - wlr_output_damage_add_box(output->damage, - &(struct wlr_box){.x = view->ox + box->x, - .y = view->oy + box->y, - .width = width, - .height = height}); height = hints->max_height; } } - wlr_xwayland_surface_configure(xwayland_view->xwayland_surface, view->ox, - view->oy, width, height); + struct wlr_box output_box; + wlr_output_layout_get_box(view->server->output_layout, + view->server->curr_output->wlr_output, + &output_box); + wlr_xwayland_surface_configure(xwayland_view->xwayland_surface, + view->ox + output_box.x, + view->oy + output_box.y, width, height); wlr_xwayland_surface_set_maximized(xwayland_view->xwayland_surface, true); } @@ -113,18 +102,6 @@ destroy(struct cg_view *view) { free(xwayland_view); } -static void -for_each_surface(struct cg_view *view, wlr_surface_iterator_func_t iterator, - void *data) { - wlr_surface_for_each_surface(view->wlr_surface, iterator, data); -} - -static struct wlr_surface * -wlr_surface_at(const struct cg_view *view, double sx, double sy, double *sub_x, - double *sub_y) { - return wlr_surface_surface_at(view->wlr_surface, sx, sy, sub_x, sub_y); -} - static void handle_xwayland_surface_request_fullscreen(struct wl_listener *listener, void *data) { @@ -136,33 +113,12 @@ handle_xwayland_surface_request_fullscreen(struct wl_listener *listener, xwayland_surface->fullscreen); } -static void -handle_xwayland_surface_commit(struct wl_listener *listener, void *_data) { - struct cg_xwayland_view *xwayland_view = - wl_container_of(listener, xwayland_view, commit); - struct cg_view *view = &xwayland_view->view; - /* xwayland surface has moved */ - if(xwayland_view->xwayland_surface->x != view->ox || - xwayland_view->xwayland_surface->y != view->oy) { - output_damage_surface(view->workspace->output, view->wlr_surface, - view->ox, view->oy, true); - view->ox = xwayland_view->xwayland_surface->x; - view->oy = xwayland_view->xwayland_surface->y; - output_damage_surface(view->workspace->output, view->wlr_surface, - view->ox, view->oy, true); - } else { - view_damage_part(view); - } -} - static void handle_xwayland_surface_unmap(struct wl_listener *listener, void *_data) { struct cg_xwayland_view *xwayland_view = wl_container_of(listener, xwayland_view, unmap); struct cg_view *view = &xwayland_view->view; - wl_list_remove(&xwayland_view->commit.link); - view_unmap(view); } @@ -171,21 +127,18 @@ handle_xwayland_surface_map(struct wl_listener *listener, void *_data) { struct cg_xwayland_view *xwayland_view = wl_container_of(listener, xwayland_view, map); struct cg_view *view = &xwayland_view->view; - if(!xwayland_view_should_manage(view)) { - view->ox = xwayland_view->xwayland_surface->x; - view->oy = xwayland_view->xwayland_surface->y; + struct wlr_output_layout *output_layout = view->server->output_layout; + struct wlr_box output_box; + wlr_output_layout_get_box( + output_layout, view->server->curr_output->wlr_output, &output_box); + view->ox = xwayland_view->xwayland_surface->x - output_box.x; + view->oy = xwayland_view->xwayland_surface->y - output_box.y; } - xwayland_view->commit.notify = handle_xwayland_surface_commit; - wl_signal_add(&xwayland_view->xwayland_surface->surface->events.commit, - &xwayland_view->commit); - view_map(view, xwayland_view->xwayland_surface->surface, view->server->curr_output ->workspaces[view->server->curr_output->curr_workspace]); - - view_damage_whole(view); } static void @@ -204,16 +157,12 @@ handle_xwayland_surface_destroy(struct wl_listener *listener, void *_data) { } static const struct cg_view_impl xwayland_view_impl = { - .get_title = get_title, + .get_pid = get_pid, .is_primary = is_primary, .activate = activate, .close = close, .maximize = maximize, .destroy = destroy, - .for_each_surface = for_each_surface, - /* XWayland doesn't have a separate popup iterator. */ - .for_each_popup = NULL, - .wlr_surface_at = wlr_surface_at, }; void diff --git a/xwayland.h b/xwayland.h index 4dfaac4..cde30c5 100644 --- a/xwayland.h +++ b/xwayland.h @@ -1,3 +1,6 @@ +// Copyright 2020 - 2023, project-repo and the cagebreak contributors +// SPDX -License-Identifier: MIT + #ifndef CG_XWAYLAND_H #define CG_XWAYLAND_H @@ -10,7 +13,6 @@ struct cg_xwayland_view { struct wl_listener destroy; struct wl_listener unmap; struct wl_listener map; - struct wl_listener commit; struct wl_listener request_fullscreen; };