Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
X11:Wayland
wlrctl
wlrctl-0.2.2~0.obscpio
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File wlrctl-0.2.2~0.obscpio of Package wlrctl
07070100000000000081A400000000000000000000000164632F350000001C000000000000000000000000000000000000001A00000000wlrctl-0.2.2~0/.gitignorebuild compile_commands.json 07070100000001000081A400000000000000000000000164632F350000042D000000000000000000000000000000000000001700000000wlrctl-0.2.2~0/LICENSEMIT License Copyright (c) 2020 Ronan Pigott 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. 07070100000002000081A400000000000000000000000164632F35000005D9000000000000000000000000000000000000001900000000wlrctl-0.2.2~0/README.md# wlrctl wlrctl is a command line utility for miscellaneous wlroots Wayland extensions. At this time, wlrctl supports the foreign-toplevel-mangement (window/toplevel command), virtual-keyboard (keyboard command), and virtual-pointer (pointer command) protocols. Requires wlroots 0.13+ ## Installation There is an AUR package for wlrctl [here][aur-wlrctl]. And an openSUSE package [here][os-wlrctl]. Otherwise, build with meson/ninja e.g. $ meson setup --prefix=/usr/local build $ ninja -C build install ## Features and Examples wlrctl is still experimental, and has just a few basic features. Check the man page wlrctl(1) for full details. Some example uses are: $ wlrctl keyboard type 'Hello, world!' ... to type some text using a virtual keyboard. $ wlrctl pointer move 50 -70 ... to move the cursor 50 pixels right and 70 pixels up. $ wlrctl window focus firefox || swaymsg exec firefox ... to focus firefox if it is running, otherwise start firefox. $ wlrctl toplevel waitfor mpv state:fullscreen && makoctl dismiss ... to dismiss desktop notifications when mpv becomes fullscreen ## Contributing You can send patches to the [mailing list][list-wlrctl] or submit an issue on the [issue tracker][todo-wlrctl]. [aur-wlrctl]: https://aur.archlinux.org/packages/wlrctl [os-wlrctl]: https://build.opensuse.org/package/show/X11:Wayland/wlrctl [todo-wlrctl]: https://todo.sr.ht/~brocellous/wlrctl [list-wlrctl]: https://lists.sr.ht/~brocellous/public-inbox 07070100000003000081A400000000000000000000000164632F35000016AD000000000000000000000000000000000000002200000000wlrctl-0.2.2~0/ascii_raw_keymap.cconst char keymap_ascii_raw[] = "xkb_keymap {\n" "xkb_keycodes \"ascii\" {\n" " minimum = 8;\n" " maximum = 127;\n" "\n" " <BKSP> = 8;\n" " <TAB> = 9;\n" " <RTRN> = 10;\n" " <ESC> = 27;\n" " <SPCE> = 32;\n" " <EXCL> = 33;\n" " <QDBL> = 34;\n" " <HASH> = 35;\n" " <DOLL> = 36;\n" " <PCNT> = 37;\n" " <AMP> = 38;\n" " <APOS> = 39;\n" " <LPAR> = 40;\n" " <RPAR> = 41;\n" " <STAR> = 42;\n" " <PLUS> = 43;\n" " <COMM> = 44;\n" " <MIN> = 45;\n" " <PRD> = 46;\n" " <FWSL> = 47;\n" " <NUM0> = 48;\n" " <NUM1> = 49;\n" " <NUM2> = 50;\n" " <NUM3> = 51;\n" " <NUM4> = 52;\n" " <NUM5> = 53;\n" " <NUM6> = 54;\n" " <NUM7> = 55;\n" " <NUM8> = 56;\n" " <NUM9> = 57;\n" " <COLN> = 58;\n" " <SCLN> = 59;\n" " <LESS> = 60;\n" " <EQL> = 61;\n" " <GRTR> = 62;\n" " <QUES> = 63;\n" " <ATSN> = 64;\n" " <KEYA> = 65;\n" " <KEYB> = 66;\n" " <KEYC> = 67;\n" " <KEYD> = 68;\n" " <KEYE> = 69;\n" " <KEYF> = 70;\n" " <KEYG> = 71;\n" " <KEYH> = 72;\n" " <KEYI> = 73;\n" " <KEYJ> = 74;\n" " <KEYK> = 75;\n" " <KEYL> = 76;\n" " <KEYM> = 77;\n" " <KEYN> = 78;\n" " <KEYO> = 79;\n" " <KEYP> = 80;\n" " <KEYQ> = 81;\n" " <KEYR> = 82;\n" " <KEYS> = 83;\n" " <KEYT> = 84;\n" " <KEYU> = 85;\n" " <KEYV> = 86;\n" " <KEYW> = 87;\n" " <KEYX> = 88;\n" " <KEYY> = 89;\n" " <KEYZ> = 90;\n" " <LBRA> = 91;\n" " <BKSL> = 92;\n" " <RBRA> = 93;\n" " <CRCM> = 94;\n" " <UNDR> = 95;\n" " <GRV> = 96;\n" " <KEYa> = 97;\n" " <KEYb> = 98;\n" " <KEYc> = 99;\n" " <KEYd> = 100;\n" " <KEYe> = 101;\n" " <KEYf> = 102;\n" " <KEYg> = 103;\n" " <KEYh> = 104;\n" " <KEYi> = 105;\n" " <KEYj> = 106;\n" " <KEYk> = 107;\n" " <KEYl> = 108;\n" " <KEYm> = 109;\n" " <KEYn> = 110;\n" " <KEYo> = 111;\n" " <KEYp> = 112;\n" " <KEYq> = 113;\n" " <KEYr> = 114;\n" " <KEYs> = 115;\n" " <KEYt> = 116;\n" " <KEYu> = 117;\n" " <KEYv> = 118;\n" " <KEYw> = 119;\n" " <KEYx> = 120;\n" " <KEYy> = 121;\n" " <KEYz> = 122;\n" " <LBRC> = 123;\n" " <BAR> = 124;\n" " <RBRC> = 125;\n" " <TLDE> = 126;\n" "};\n" "\n" "xkb_types \"flat\" {\n" " virtual_modifiers NumLock;\n" "\n" " type \"ONE_LEVEL\" {\n" " modifiers =none;\n" " level_name[1] = \"Any\";\n" " };\n" " type \"TWO_LEVEL\" {\n" " modifiers = Shift;\n" " map[Shift] = Level2;\n" " level_name[Level1] = \"Base\";\n" " level_name[Level2] = \"Shift\";\n" " };\n" " type \"ALPHABETIC\" {\n" " modifiers = Shift+Lock;\n" " map[Shift] = Level2;\n" " map[Lock] = Level2;\n" " level_name[Level1] = \"Base\";\n" " level_name[Level2] = \"Caps\";\n" " };\n" " type \"KEYPAD\" {\n" " modifiers = Shift+NumLock;\n" " map[None] = Level1;\n" " map[Shift] = Level2;\n" " map[NumLock] = Level2;\n" " map[Shift+NumLock] = Level1;\n" " level_name[Level1] = \"Base\";\n" " level_name[Level2] = \"Number\";\n" " };\n" "};\n" "\n" "xkb_compatibility \"basic\" {\n" " virtual_modifiers NumLock;\n" "\n" " interpret.useModMapMods = AnyLevel;\n" " interpret.repeat = False;\n" " interpret.locking = False;\n" " interpret Shift_Lock+AnyOf(Shift+Lock) {\n" " action = LockMods(modifiers=Shift);\n" " };\n" "};\n" "\n" "xkb_symbols \"ascii\" {\n" " name[Group1]=\"ASCII RAW\";\n" "\n" " key <BKSP> {[ BackSpace ]};\n" " key <TAB> {[ Tab ]};\n" " key <RTRN> {[ Return ]};\n" " key <ESC> {[ Escape ]};\n" " key <SPCE> {[ space ]};\n" " key <EXCL> {[ exclam ]};\n" " key <QDBL> {[ quotedbl ]};\n" " key <HASH> {[ numbersign ]};\n" " key <DOLL> {[ dollar ]};\n" " key <PCNT> {[ percent ]};\n" " key <AMP> {[ ampersand ]};\n" " key <APOS> {[ apostrophe ]};\n" " key <LPAR> {[ parenleft ]};\n" " key <RPAR> {[ parenright ]};\n" " key <STAR> {[ asterisk ]};\n" " key <PLUS> {[ plus ]};\n" " key <COMM> {[ comma ]};\n" " key <MIN> {[ minus ]};\n" " key <PRD> {[ period ]};\n" " key <FWSL> {[ slash ]};\n" " key <NUM0> {[ 0 ]};\n" " key <NUM1> {[ 1 ]};\n" " key <NUM2> {[ 2 ]};\n" " key <NUM3> {[ 3 ]};\n" " key <NUM4> {[ 4 ]};\n" " key <NUM5> {[ 5 ]};\n" " key <NUM6> {[ 6 ]};\n" " key <NUM7> {[ 7 ]};\n" " key <NUM8> {[ 8 ]};\n" " key <NUM9> {[ 9 ]};\n" " key <COLN> {[ colon ]};\n" " key <SCLN> {[ semicolon ]};\n" " key <LESS> {[ less ]};\n" " key <EQL> {[ equal ]};\n" " key <GRTR> {[ greater ]};\n" " key <QUES> {[ question ]};\n" " key <ATSN> {[ at ]};\n" " key <KEYA> {[ A ]};\n" " key <KEYB> {[ B ]};\n" " key <KEYC> {[ C ]};\n" " key <KEYD> {[ D ]};\n" " key <KEYE> {[ E ]};\n" " key <KEYF> {[ F ]};\n" " key <KEYG> {[ G ]};\n" " key <KEYH> {[ H ]};\n" " key <KEYI> {[ I ]};\n" " key <KEYJ> {[ J ]};\n" " key <KEYK> {[ K ]};\n" " key <KEYL> {[ L ]};\n" " key <KEYM> {[ M ]};\n" " key <KEYN> {[ N ]};\n" " key <KEYO> {[ O ]};\n" " key <KEYP> {[ P ]};\n" " key <KEYQ> {[ Q ]};\n" " key <KEYR> {[ R ]};\n" " key <KEYS> {[ S ]};\n" " key <KEYT> {[ T ]};\n" " key <KEYU> {[ U ]};\n" " key <KEYV> {[ V ]};\n" " key <KEYW> {[ W ]};\n" " key <KEYX> {[ X ]};\n" " key <KEYY> {[ Y ]};\n" " key <KEYZ> {[ Z ]};\n" " key <LBRA> {[ bracketleft ]};\n" " key <BKSL> {[ backslash ]};\n" " key <RBRA> {[ bracketright ]};\n" " key <CRCM> {[ asciicircum ]};\n" " key <UNDR> {[ underscore ]};\n" " key <GRV> {[ grave ]};\n" " key <KEYa> {[ a ]};\n" " key <KEYb> {[ b ]};\n" " key <KEYc> {[ c ]};\n" " key <KEYd> {[ d ]};\n" " key <KEYe> {[ e ]};\n" " key <KEYf> {[ f ]};\n" " key <KEYg> {[ g ]};\n" " key <KEYh> {[ h ]};\n" " key <KEYi> {[ i ]};\n" " key <KEYj> {[ j ]};\n" " key <KEYk> {[ k ]};\n" " key <KEYl> {[ l ]};\n" " key <KEYm> {[ m ]};\n" " key <KEYn> {[ n ]};\n" " key <KEYo> {[ o ]};\n" " key <KEYp> {[ p ]};\n" " key <KEYq> {[ q ]};\n" " key <KEYr> {[ r ]};\n" " key <KEYs> {[ s ]};\n" " key <KEYt> {[ t ]};\n" " key <KEYu> {[ u ]};\n" " key <KEYv> {[ v ]};\n" " key <KEYw> {[ w ]};\n" " key <KEYx> {[ x ]};\n" " key <KEYy> {[ y ]};\n" " key <KEYz> {[ z ]};\n" " key <LBRC> {[ braceleft ]};\n" " key <BAR> {[ bar ]};\n" " key <RBRC> {[ braceright ]};\n" " key <TLDE> {[ asciitilde ]};\n" "};\n" "};\n"; 07070100000004000041ED00000000000000000000000164632F3500000000000000000000000000000000000000000000001B00000000wlrctl-0.2.2~0/completions07070100000005000041ED00000000000000000000000164632F3500000000000000000000000000000000000000000000001F00000000wlrctl-0.2.2~0/completions/zsh07070100000006000081A400000000000000000000000164632F350000070D000000000000000000000000000000000000002700000000wlrctl-0.2.2~0/completions/zsh/_wlrctl#compdef wlrctl local cmd="$0" typeset -A opt_args __wlrctl() { "$cmd" "$@" } local -a wlrcmd_keyboard _regex_words action 'keyboard action' \ 'type:Type an ascii string' wlrcmd_keyboard=("$reply[@]") local -a pointer_button _regex_words button 'pointer button' 'left' 'right' 'middle' \ 'extra' 'side' 'forward' 'back' pointer_button=("$reply[@]") local -a wlrcmd_pointer _regex_words action 'pointer action' \ 'click:Click a pointer button:$pointer_button' \ 'move:Move the cursor' \ 'scroll:Imitate a swipe scroll' wlrcmd_pointer=("$reply[@]") (( $+functions[_wlr_toplevel_attr] )) || _wlr_toplevel_attr() { local -a windows matchspecs windows=(${(@f)"$(__wlrctl toplevel list)"}) matchspecs=( app_id:${^windows%%: *} title:${^windows#*: } ) matchspecs+=( state:{{un,}minimized,{un,}maximized,{in,}active,{un,}fullscreen} ) _multi_parts ':' matchspecs } local -a wlrcmd_toplevel_attr=(/$'[^\0]#\0'/ ':_wlr_toplevel_attr' '#') local -a wlrcmd_toplevel _regex_words action 'toplevel action' 'maximize' 'minimize' 'focus' \ 'activate' 'fullscreen' 'close' 'list' 'find' 'wait' 'waitfor' wlrcmd_toplevel=( "$reply[@]" "$wlrcmd_toplevel_attr[@]" ) local -a wlrcmd_output _regex_words action 'output action' \ 'list:List the avaialble output names' wlrcmd_output=("$reply[@]") local -a wlrcmd _regex_words commands 'wlr command' \ 'keyboard:Control a virtual keyboard:$wlrcmd_keyboard' \ 'pointer:Control a virtual pointer:$wlrcmd_pointer' \ {window,toplevel}':Manage windows:$wlrcmd_toplevel' \ 'output:Manage outputs:$wlrcmd_output' wlrcmd=( /$'[^\0]#\0'/ "$reply[@]" ) _regex_arguments _wlrcmd "$wlrcmd[@]" _arguments -S \ '(-h --help)'{-h,--help}'[Show a help message and exit]' \ '(-v --version)'{-v,--version}'[Show a version number and exit]' \ '*::wlr command:= _wlrcmd' 07070100000007000041ED00000000000000000000000164632F3500000000000000000000000000000000000000000000001700000000wlrctl-0.2.2~0/include07070100000008000081A400000000000000000000000164632F350000026C000000000000000000000000000000000000002000000000wlrctl-0.2.2~0/include/common.h#ifndef WLRCTL_COMMON_H #define WLRCTL_COMMON_H #include <stdbool.h> enum wlrctl_command { WLRCTL_COMMAND_UNSPEC = 0, WLRCTL_COMMAND_KEYBOARD, WLRCTL_COMMAND_POINTER, WLRCTL_COMMAND_TOPLEVEL, WLRCTL_COMMAND_OUTPUT, }; struct wlrctl { // Globals struct wl_display *display; struct wl_registry *registry; struct wl_seat *seat; struct zwp_virtual_keyboard_manager_v1 *vkbd_mgr; struct zwlr_foreign_toplevel_manager_v1 *ftl_mgr; struct zwlr_virtual_pointer_manager_v1 *vp_mgr; struct zwlr_output_manager_v1 *output_mgr; // State bool running, failed; enum wlrctl_command cmd_type; void *cmd; }; #endif 07070100000009000081A400000000000000000000000164632F350000023A000000000000000000000000000000000000002200000000wlrctl-0.2.2~0/include/keyboard.h#ifndef WLRCTL_DEV_KEYBOARD_H #define WLRCTL_DEV_KEYBOARD_H enum keyboard_action { KEYBOARD_ACTION_UNSPEC = 0, KEYBOARD_ACTION_TYPE, }; struct wlrctl_keyboard_command { enum keyboard_action action; char *text; int mods_depressed; struct zwp_virtual_keyboard_v1 *device; struct xkb_context *xkb_context; struct { uint32_t format; uint32_t size; int fd; } keymap; struct wlrctl *state; }; void prepare_keyboard(struct wlrctl *state, int argc, char *argv[]); void run_keyboard(struct wlrctl *state); void destroy_keyboard(struct wlrctl *state); #endif 0707010000000A000081A400000000000000000000000164632F35000004E6000000000000000000000000000000000000002000000000wlrctl-0.2.2~0/include/output.h#ifndef WLRCTL_OUTPUT_H #define WLRCTL_OUTPUT_H enum output_action { OUTPUT_ACTION_LIST = 1, OUTPUT_ACTION_CONFIGURE, OUTPUT_ACTION_UNSPEC }; enum output_cfg_action { OUTPUT_CFG_ACTION_SHOW = 1, OUTPUT_CFG_ACTION_SET_MODE, OUTPUT_CFG_ACTION_SET_CUSTOM_MODE, OUTPUT_CFG_ACTION_SET_POSITION, OUTPUT_CFG_ACTION_SET_TRANSFORM, OUTPUT_CFG_ACTION_SET_SCALE, OUTPUT_CFG_ACTION_UNSPEC }; struct wlrctl_output_command { enum output_action action; char *ident; enum output_cfg_action cfg_action; struct wl_list heads; struct wlrctl *state; }; struct head_data { char name[24]; char model[16]; char make[56]; char serial[16]; char *description; int32_t x, y, width, height; struct wl_list modes; bool enabled; struct mode_data *current_mode; enum wl_output_transform transform; double scale; struct wl_list link; struct wlrctl_output_command *cmd; }; struct mode_data { int32_t width, height; int32_t refresh; bool preferred; struct head_data *head; struct wl_list link; //head_data::modes struct zwlr_output_mode_v1 *mode; }; void prepare_output(struct wlrctl *state, int argc, char **argv); void run_output(struct wlrctl *state); void stop_output(struct wlrctl *state); void destroy_output(struct wlrctl *state); #endif 0707010000000B000081A400000000000000000000000164632F3500000200000000000000000000000000000000000000002100000000wlrctl-0.2.2~0/include/pointer.h#ifndef WLRCTL_DEV_POINTER_H #define WLRCTL_DEV_POINTER_H enum pointer_action { POINTER_ACTION_UNSPEC = 0, POINTER_ACTION_CLICK, POINTER_ACTION_MOTION, POINTER_ACTION_SCROLL, }; struct wlrctl_pointer_command { enum pointer_action action; uint32_t button; wl_fixed_t dx, dy; struct zwlr_virtual_pointer_v1 *device; struct wlrctl *state; }; void prepare_pointer(struct wlrctl *state, int argc, char *argv[]); void run_pointer(struct wlrctl *state); void destroy_pointer(struct wlrctl *state); #endif 0707010000000C000081A400000000000000000000000164632F350000058B000000000000000000000000000000000000002200000000wlrctl-0.2.2~0/include/toplevel.h#ifndef WLRCTL_TOPLEVEL_H #define WLRCTL_TOPLEVEL_H enum toplevel_attr { TOPLEVEL_ATTR_UNSPEC = 0, TOPLEVEL_ATTR_APPID = 1<<1, TOPLEVEL_ATTR_TITLE = 1<<2, TOPLEVEL_ATTR_MAXIMIZED = 1<<3, TOPLEVEL_ATTR_MINIMIZED = 1<<4, TOPLEVEL_ATTR_ACTIVATED = 1<<5, TOPLEVEL_ATTR_FULLSCREEN = 1<<6, }; enum toplevel_action { TOPLEVEL_ACTION_UNSPEC = 0, TOPLEVEL_ACTION_ACTIVATE, TOPLEVEL_ACTION_CLOSE, TOPLEVEL_ACTION_FIND, TOPLEVEL_ACTION_FULLSCREEN, TOPLEVEL_ACTION_LIST, TOPLEVEL_ACTION_MAXIMIZE, TOPLEVEL_ACTION_MINIMIZE, TOPLEVEL_ACTION_WAIT, TOPLEVEL_ACTION_WAITFOR, }; struct toplevel_matchspec { unsigned int attrs; // toplevel attr struct wl_array app_ids; struct wl_array titles; // toplevel state bool maximized; bool minimized; bool activated; bool fullscreen; }; struct wlrctl_toplevel_command { enum toplevel_action action; struct toplevel_matchspec matchspec; struct wl_list toplevels; bool any; bool complete; int waiting; struct wlrctl *state; }; struct toplevel_data { char *app_id; char *title; struct wl_array state; struct zwlr_foreign_toplevel_handle_v1 *parent; struct wl_list link; struct wlrctl_toplevel_command *cmd; bool matched, done; }; void prepare_toplevel(struct wlrctl *state, int argc, char **argv); void run_toplevel(struct wlrctl *state); void stop_toplevel(struct wlrctl *state); void destroy_toplevel(struct wlrctl *state); #endif 0707010000000D000081A400000000000000000000000164632F35000000D8000000000000000000000000000000000000001E00000000wlrctl-0.2.2~0/include/util.h#ifndef WLRCTL_UTIL_H #define WLRCTL_UTIL_H struct token { const char *name; int value; }; int matchtok(const struct token tokens[], const char *name); int timestamp(); void die(const char *fmt, ...); #endif 0707010000000E000081A400000000000000000000000164632F35000012A5000000000000000000000000000000000000001A00000000wlrctl-0.2.2~0/keyboard.c#define _GNU_SOURCE #include <assert.h> #include <ctype.h> #include <fcntl.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #include <sys/stat.h> #include <unistd.h> #include <wayland-client.h> #include <xkbcommon/xkbcommon.h> #include "common.h" #include "keyboard.h" #include "util.h" #include "virtual-keyboard-unstable-v1-client-protocol.h" extern const char keymap_ascii_raw[]; static void get_keymap(struct wlrctl_keyboard_command *cmd) { int size = strlen(keymap_ascii_raw) + 1; #if defined(MEMFD_CREATE) int fd = memfd_create("keymap", 0); #elif defined(__FreeBSD__) // memfd_create on FreeBSD 13 is SHM_ANON without sealing support int fd = shm_open(SHM_ANON, O_RDWR, 0600); #else char name[] = "/tmp/keymap-XXXXXX"; int fd = mkstemp(name); unlink(name); #endif if(ftruncate(fd, size) < 0) { die("Could not allocate shm for keymap\n"); }; void *keymap_data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); strcpy(keymap_data, keymap_ascii_raw); munmap(keymap_data, size); cmd->keymap.format = WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1; cmd->keymap.fd = fd; cmd->keymap.size = size; } static void send_key(struct zwp_virtual_keyboard_v1 *kbd, char c) { zwp_virtual_keyboard_v1_key(kbd, timestamp(), c - 8, WL_KEYBOARD_KEY_STATE_PRESSED); zwp_virtual_keyboard_v1_key(kbd, timestamp(), c - 8, WL_KEYBOARD_KEY_STATE_RELEASED); } static void keyboard_type(struct wlrctl_keyboard_command *cmd, const char *text) { int len = strlen(text); for (int i = 0; i < len; i++) { send_key(cmd->device, text[i]); } } static void complete_keyboard(void *data, struct wl_callback *callback, uint32_t serial) { struct wlrctl *state = data; wl_callback_destroy(callback); state->running = false; destroy_keyboard(state); } static struct wl_callback_listener completed_listener = { .done = complete_keyboard }; static enum keyboard_action parse_action(const char *action) { static const struct token actions[] = { {"type", KEYBOARD_ACTION_TYPE}, {NULL, KEYBOARD_ACTION_UNSPEC} }; return matchtok(actions, action); } static bool is_ascii(const char str[]) { for (int i = 0; str[i] != '\0'; i++) { if (str[i] < 0) { return false; } } return true; } void prepare_keyboard(struct wlrctl *state, int argc, char *argv[]) { struct wlrctl_keyboard_command *cmd = calloc(1, sizeof (struct wlrctl_keyboard_command)); assert(cmd); if (argc == 0) { die("Missing keyboard action\n"); } char *action = argv[0]; cmd->action = parse_action(action); switch (cmd->action) { case KEYBOARD_ACTION_TYPE: if (argc < 2) { die("Missing text to type!\n"); } if (is_ascii(argv[1])) { cmd->mods_depressed = 0; cmd->text = strdup(argv[1]); } else { die("Only ascii strings are currently supported\n"); } if (argc >= 3 && strcmp(argv[2], "modifiers")) { die("Invalid argument: '%s'\n", argv[2]); } else if (argc == 3) { die("No modifiers provided\n"); } else if (argc == 4) { char *keys = (char *)malloc(strlen(argv[3]) + 1); strcpy(keys, argv[3]); char *key; key = strtok(keys, ","); while (key != NULL) { for (size_t i = 0; i < strlen(key); i++) { key[i] = toupper((unsigned char) key[i]); } if (strcmp(key, "SHIFT") == 0) { cmd->mods_depressed |= 1; } else if (strcmp(key, "CTRL") == 0) { cmd->mods_depressed |= 4; } else if (strcmp(key, "ALT") == 0) { cmd->mods_depressed |= 8; } else if (strcmp(key, "SUPER") == 0) { cmd->mods_depressed |= 64; } else { die("Unsupported modifier: '%s'\n", key); } key = strtok(NULL, ","); } free(keys); } else if (argc >= 5) { die("Invalid argument: '%s'\n", argv[4]); } break; case KEYBOARD_ACTION_UNSPEC: die("Unknown keyboard action: '%s'\n", action); break; } cmd->state = state; state->cmd = cmd; } void run_keyboard(struct wlrctl *state) { struct wlrctl_keyboard_command *cmd = state->cmd; cmd->device = zwp_virtual_keyboard_manager_v1_create_virtual_keyboard( state->vkbd_mgr, state->seat ); cmd->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); get_keymap(cmd); zwp_virtual_keyboard_v1_keymap(cmd->device, cmd->keymap.format, cmd->keymap.fd, cmd->keymap.size ); close(cmd->keymap.fd); switch (cmd->action) { case KEYBOARD_ACTION_TYPE: zwp_virtual_keyboard_v1_modifiers(cmd->device, cmd->mods_depressed, 0, 0, 0); keyboard_type(cmd, cmd->text); break; default: break; } struct wl_callback *callback = wl_display_sync(state->display); wl_callback_add_listener(callback, &completed_listener, state); } void destroy_keyboard(struct wlrctl *state) { struct wlrctl_keyboard_command *cmd = state->cmd; zwp_virtual_keyboard_v1_destroy(cmd->device); free(cmd); } 0707010000000F000081A400000000000000000000000164632F35000014FE000000000000000000000000000000000000001600000000wlrctl-0.2.2~0/main.c#include <assert.h> #include <getopt.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <xkbcommon/xkbcommon.h> #include <wayland-client.h> #include "common.h" #include "keyboard.h" #include "pointer.h" #include "toplevel.h" #include "output.h" #include "util.h" #include "virtual-keyboard-unstable-v1-client-protocol.h" #include "wlr-virtual-pointer-unstable-v1-client-protocol.h" #include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h" #include "wlr-output-management-unstable-v1-client-protocol.h" static void noop() {} static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) { struct wlrctl *state = data; // Bind wl_seat if (strcmp(interface, wl_seat_interface.name) == 0) { state->seat = wl_registry_bind( registry, name, &wl_seat_interface, 7 ); } // Bind zwp_virtual_keyboard_manager_v1 if (strcmp(interface, zwp_virtual_keyboard_manager_v1_interface.name) == 0) { if (state->cmd_type == WLRCTL_COMMAND_KEYBOARD) { state->vkbd_mgr = wl_registry_bind( registry, name, &zwp_virtual_keyboard_manager_v1_interface, 1 ); } } // Bind zwlr_virtual_pointer_manager_v1 if (strcmp(interface, zwlr_virtual_pointer_manager_v1_interface.name) == 0) { if (state->cmd_type == WLRCTL_COMMAND_POINTER) { state->vp_mgr = wl_registry_bind( registry, name, &zwlr_virtual_pointer_manager_v1_interface, 2 ); } } // Bind zwlr_foreign_toplevel_manager_v1 if (strcmp(interface, zwlr_foreign_toplevel_manager_v1_interface.name) == 0) { if (state->cmd_type == WLRCTL_COMMAND_TOPLEVEL) { state->ftl_mgr = wl_registry_bind( registry, name, &zwlr_foreign_toplevel_manager_v1_interface, 3 ); } } // Bind zwlr_output_manager_v1 if (strcmp(interface, zwlr_output_manager_v1_interface.name) == 0) { if (state->cmd_type == WLRCTL_COMMAND_OUTPUT) { state->output_mgr = wl_registry_bind( registry, name, &zwlr_output_manager_v1_interface, 2 ); } } } static const struct wl_registry_listener wl_registry_listener = { .global = registry_handle_global, .global_remove = noop, }; static bool prepare_command(struct wlrctl *state, int argc, char *argv[]) { char *command = argv[0]; static const struct token commands[] = { {"keyboard", WLRCTL_COMMAND_KEYBOARD}, {"pointer", WLRCTL_COMMAND_POINTER }, {"toplevel", WLRCTL_COMMAND_TOPLEVEL}, {"window", WLRCTL_COMMAND_TOPLEVEL}, {"output", WLRCTL_COMMAND_OUTPUT }, {NULL, WLRCTL_COMMAND_UNSPEC}, }; state->cmd_type = matchtok(commands, command); switch (state->cmd_type) { case WLRCTL_COMMAND_KEYBOARD: prepare_keyboard(state, argc - 1, argv + 1); break; case WLRCTL_COMMAND_POINTER: prepare_pointer(state, argc - 1, argv + 1); break; case WLRCTL_COMMAND_TOPLEVEL: prepare_toplevel(state, argc - 1, argv + 1); break; case WLRCTL_COMMAND_OUTPUT: prepare_output(state, argc - 1, argv + 1); break; case WLRCTL_COMMAND_UNSPEC: return false; } return true; } int main(int argc, char *argv[]) { struct wlrctl state = {0}; // Usage static struct option long_options[] = { {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'v'}, {0, 0, 0, 0} }; const char *usage = "Usage: wlrctl [options] [keyboard|pointer|toplevel] <action>\n" "\n" " -h, --help Show a help message and quit\n" " -v, --version Show a version number and quit\n" ; // Only allow options up front, so getopt doesn't // get mad about negative numbers int cmd_idx = 1; for ( ; cmd_idx < argc; cmd_idx++ ) { if (*argv[cmd_idx] != '-') { break; } } // Option args int c; while (true) { int optind = 0; c = getopt_long(cmd_idx, argv, "hv", long_options, &optind); if (c == -1) { break; } switch (c) { case 'h': puts(usage); return EXIT_SUCCESS; case 'v': printf("wlrctl v%s\n", WLRCTL_VERSION); return EXIT_SUCCESS; default: puts(usage); return EXIT_FAILURE; } } if (optind == argc) { puts(usage); return EXIT_FAILURE; } // Positional args if (!prepare_command(&state, argc - optind, argv + optind)) { fprintf(stderr, "Unknown command: '%s'\n", argv[optind]); puts(usage); return EXIT_FAILURE; } // Bind Globals state.running = true; state.display = wl_display_connect(NULL); assert(state.display); state.registry = wl_display_get_registry(state.display); wl_registry_add_listener(state.registry, &wl_registry_listener, &state); wl_display_roundtrip(state.display); switch (state.cmd_type) { case WLRCTL_COMMAND_KEYBOARD: if (!state.vkbd_mgr) { die("Virtual Keyboard interface not found!\n"); } run_keyboard(&state); break; case WLRCTL_COMMAND_POINTER: if (!state.vp_mgr) { die("Virtual Pointer interface not found!\n"); } run_pointer(&state); break; case WLRCTL_COMMAND_TOPLEVEL: if (!state.ftl_mgr) { die("Foreign Toplevel Management interface not found!\n"); } run_toplevel(&state); break; case WLRCTL_COMMAND_OUTPUT: if (!state.output_mgr) { die("Output Management interface not found!\n"); } run_output(&state); break; case WLRCTL_COMMAND_UNSPEC: // unreachable assert(false); } while (state.running) { if (wl_display_dispatch(state.display) < 0) { break; }; } return state.failed ? EXIT_FAILURE : EXIT_SUCCESS; } 07070100000010000081A400000000000000000000000164632F35000006C6000000000000000000000000000000000000001B00000000wlrctl-0.2.2~0/meson.buildproject( 'wlrctl', 'c', version: '0.2.2', license: 'MIT', default_options: [ 'c_std=c11', 'warning_level=2', 'werror=true', ], ) cc = meson.get_compiler('c') datadir = get_option('datadir') prefix = get_option('prefix') add_project_arguments('-Wno-unused-parameter', language: 'c') add_project_arguments('-Wno-missing-braces', language: 'c') version = '"@0@"'.format(meson.project_version()) add_project_arguments('-DWLRCTL_VERSION=@0@'.format(version), language: 'c') if cc.has_function('memfd_create') add_project_arguments('-DMEMFD_CREATE', language: 'c') endif xkbcommon = dependency('xkbcommon') wayland_client = dependency('wayland-client') subdir('protocol') src_files = [ 'main.c', 'ascii_raw_keymap.c', 'keyboard.c', 'pointer.c', 'toplevel.c', 'output.c', 'util.c', ] includes = include_directories('include') executable( 'wlrctl', files(src_files), dependencies: [ client_protos, wayland_client, xkbcommon, ], include_directories: [includes], install: true ) scdoc = dependency('scdoc', native: true, required: get_option('man-pages')) if scdoc.found() scdoc_cmd = find_program(scdoc.get_pkgconfig_variable('scdoc'), native: true) sh = find_program('sh', native: true) mandir = get_option('mandir') output = 'wlrctl.1' custom_target( output, input: 'wlrctl.1.scd', output: output, command: [sh, '-c', '@0@ < @INPUT@ > @1@'.format(scdoc_cmd.path(), output)], install: true, install_dir: '@0@/man1'.format(mandir) ) endif if get_option('zsh-completions') zsh_completions = files('completions/zsh/_wlrctl') zsh_install_dir = join_paths(datadir, 'zsh', 'site-functions') install_data(zsh_completions, install_dir: zsh_install_dir) endif # vim: set ts=4 sw=4: 07070100000011000081A400000000000000000000000164632F35000000C3000000000000000000000000000000000000002100000000wlrctl-0.2.2~0/meson_options.txtoption('zsh-completions', type: 'boolean', value: true, description: 'Install zsh shell completions.') option('man-pages', type: 'feature', value: 'auto', description: 'Install the manual page') 07070100000012000081A400000000000000000000000164632F35000028E4000000000000000000000000000000000000001800000000wlrctl-0.2.2~0/output.c#define _XOPEN_SOURCE 500 #include <assert.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <wayland-client.h> #include "common.h" #include "output.h" #include "util.h" #include "wlr-output-management-unstable-v1-client-protocol.h" static enum output_action parse_action(const char *action) { static const struct token actions[] = { {"list", OUTPUT_ACTION_LIST}, {NULL, OUTPUT_ACTION_CONFIGURE} }; return matchtok(actions, action); } static enum output_cfg_action parse_cfg_action(const char *action) { static const struct token actions[] = { {"show", OUTPUT_CFG_ACTION_SHOW}, {"set-mode", OUTPUT_CFG_ACTION_SET_MODE}, {"set-custom-mode", OUTPUT_CFG_ACTION_SET_CUSTOM_MODE}, {"set-position", OUTPUT_CFG_ACTION_SET_POSITION}, {"set-transform", OUTPUT_CFG_ACTION_SET_TRANSFORM}, {"set-scale", OUTPUT_CFG_ACTION_SET_SCALE}, {NULL, OUTPUT_CFG_ACTION_UNSPEC} }; return matchtok(actions, action); } static struct mode_data * mode_data_create(struct head_data *head_data) { struct mode_data *mode_data = calloc(1, sizeof (struct mode_data)); assert(mode_data); mode_data->head = head_data; wl_list_insert(&head_data->modes, &mode_data->link); return mode_data; } static void mode_data_destroy(struct mode_data *mode_data) { free(mode_data); } static void zwlr_output_mode_v1_handle_size( void *data, struct zwlr_output_mode_v1 *mode, int32_t width, int32_t height ) { struct mode_data *mode_data = data; mode_data->width = width; mode_data->height = height; } static void zwlr_output_mode_v1_handle_refresh( void *data, struct zwlr_output_mode_v1 *mode, int32_t refresh ) { struct mode_data *mode_data = data; mode_data->refresh = refresh; } static void zwlr_output_mode_v1_handle_preferred( void *data, struct zwlr_output_mode_v1 *mode ) { struct mode_data *mode_data = data; mode_data->preferred = true; } static void zwlr_output_mode_v1_handle_finished( void *data, struct zwlr_output_mode_v1 *mode ) { struct mode_data *mode_data = data; struct mode_data *other, *tmp; wl_list_for_each_safe(other, tmp, &mode_data->head->modes, link) { if (other == mode_data) { wl_list_remove(&other->link); mode_data_destroy(mode_data); } } } static struct zwlr_output_mode_v1_listener zwlr_output_mode_v1_listener = { .size = zwlr_output_mode_v1_handle_size, .refresh = zwlr_output_mode_v1_handle_refresh, .preferred = zwlr_output_mode_v1_handle_preferred, .finished = zwlr_output_mode_v1_handle_finished, }; static struct head_data * head_data_create(struct wlrctl_output_command *cmd) { struct head_data *head_data = calloc(1, sizeof (struct head_data)); assert(head_data); wl_list_init(&head_data->modes); wl_list_insert(&cmd->heads, &head_data->link); head_data->cmd = cmd; return head_data; } static void head_data_destroy(struct head_data *head_data) { free(head_data->description); free(head_data); } static void zwlr_output_head_v1_handle_name( void *data, struct zwlr_output_head_v1 *head, const char *name ) { struct head_data *head_data = data; strncpy(head_data->name, name, 24); head_data->name[24 - 1] = '\0'; } static void zwlr_output_head_v1_handle_make( void *data, struct zwlr_output_head_v1 *head, const char *make ) { struct head_data *head_data = data; strncpy(head_data->make, make, 56); head_data->make[56 - 1] = '\0'; } static void zwlr_output_head_v1_handle_model( void *data, struct zwlr_output_head_v1 *head, const char *model ) { struct head_data *head_data = data; strncpy(head_data->model, model, 16); head_data->model[16 - 1] = '\0'; } static void zwlr_output_head_v1_handle_serial_number( void *data, struct zwlr_output_head_v1 *head, const char *serial ) { struct head_data *head_data = data; strncpy(head_data->serial, serial, 16); head_data->serial[16 - 1] = '\0'; } static void wlrctl_output_head_v1_handle_physical_size( void *data, struct zwlr_output_head_v1 *head, int32_t width, int32_t height ) { struct head_data *head_data = data; head_data->width = width; head_data->height = height; } static void wlrctl_output_head_v1_handle_enabled( void *data, struct zwlr_output_head_v1 *head, int32_t enabled ) { struct head_data *head_data = data; head_data->enabled = enabled; } static void wlrctl_output_head_v1_handle_position( void *data, struct zwlr_output_head_v1 *head, int32_t x, int32_t y ) { struct head_data *head_data = data; head_data->x = x; head_data->y = y; } static void wlrctl_output_head_v1_handle_transform( void *data, struct zwlr_output_head_v1 *head, int32_t transform ) { struct head_data *head_data = data; head_data->transform = transform; } static void zwlr_output_head_v1_handle_description( void *data, struct zwlr_output_head_v1 *head, const char *description ) { struct head_data *head_data = data; head_data->description = strdup(description); } static void zwlr_output_head_v1_handle_scale( void *data, struct zwlr_output_head_v1 *head, wl_fixed_t scale ) { struct head_data *head_data = data; head_data->scale = wl_fixed_to_double(scale); } static void zwlr_output_head_v1_handle_finished( void *data, struct zwlr_output_head_v1 *head ) { struct head_data *head_data = data; struct head_data *other, *tmp; wl_list_for_each_safe(other, tmp, &head_data->cmd->heads, link) { if (other == head_data) { wl_list_remove(&other->link); head_data_destroy(other); } } } static void zwlr_output_head_v1_handle_mode( void *data, struct zwlr_output_head_v1 *head, struct zwlr_output_mode_v1 *mode ) { struct head_data *head_data = data; struct mode_data *mode_data = mode_data_create(head_data); mode_data->mode = mode; zwlr_output_mode_v1_add_listener( mode, &zwlr_output_mode_v1_listener, mode_data ); } static void zwlr_output_head_v1_handle_current_mode( void *data, struct zwlr_output_head_v1 *head, struct zwlr_output_mode_v1 *mode ) { struct head_data *head_data = data; struct mode_data *mode_data; wl_list_for_each(mode_data, &head_data->modes, link) { if (mode_data->mode == mode) { head_data->current_mode = mode_data; return; } } } static struct zwlr_output_head_v1_listener zwlr_output_head_v1_listener = { .name = zwlr_output_head_v1_handle_name, .description = zwlr_output_head_v1_handle_description, .physical_size = wlrctl_output_head_v1_handle_physical_size, .mode = zwlr_output_head_v1_handle_mode, .enabled = wlrctl_output_head_v1_handle_enabled, .current_mode = zwlr_output_head_v1_handle_current_mode, .position = wlrctl_output_head_v1_handle_position, .transform = wlrctl_output_head_v1_handle_transform, .scale = zwlr_output_head_v1_handle_scale, .finished = zwlr_output_head_v1_handle_finished, .make = zwlr_output_head_v1_handle_make, .model = zwlr_output_head_v1_handle_model, .serial_number = zwlr_output_head_v1_handle_serial_number, }; static void zwlr_output_manager_v1_handle_head( void *data, struct zwlr_output_manager_v1 *manager, struct zwlr_output_head_v1 *head ) { struct wlrctl *state = data; struct wlrctl_output_command *cmd = state->cmd; struct head_data *head_data = head_data_create(cmd); zwlr_output_head_v1_add_listener( head, &zwlr_output_head_v1_listener, head_data ); } static void zwlr_output_manager_v1_handle_finished( void *data, struct zwlr_output_manager_v1 *manager ) { struct wlrctl *state = data; state->running = false; destroy_output(state); } static void do_output_cfg_action(struct wlrctl_output_command *cmd, struct head_data *head_data ) { switch (cmd->cfg_action) { default: puts("Not implemented"); break; case OUTPUT_CFG_ACTION_UNSPEC: // unreachable assert(false); } } static void zwlr_output_manager_v1_handle_done(void *user_data, struct zwlr_output_manager_v1 *manager, uint32_t serial ) { struct wlrctl *state = user_data; struct wlrctl_output_command *cmd = state->cmd; struct head_data *data; switch (cmd->action) { case OUTPUT_ACTION_LIST: wl_list_for_each(data, &cmd->heads, link) { printf("%s \"%s %s\"", data->name, data->make, data->model); if (data->current_mode) { struct mode_data *mode = data->current_mode; printf(" (%dx%d %.3fHz)", mode->width, mode->height, mode->refresh / 1000.0); } else if (!data->enabled) { printf(" (disabled)"); } printf("\n"); } break; case OUTPUT_ACTION_CONFIGURE:; struct head_data *head_data = NULL; wl_list_for_each(data, &cmd->heads, link) { if (strcmp(data->name, cmd->ident) == 0) { head_data = data; } } if (head_data) { do_output_cfg_action(cmd, head_data); } else { die("No matching outputs\n"); } break; case OUTPUT_ACTION_UNSPEC: // unreachable assert(false); } } static struct zwlr_output_manager_v1_listener zwlr_output_manager_v1_listener = { .head = zwlr_output_manager_v1_handle_head, .done = zwlr_output_manager_v1_handle_done, .finished = zwlr_output_manager_v1_handle_finished, }; void prepare_output(struct wlrctl *state, int argc, char *argv[]) { struct wlrctl_output_command *cmd = calloc(1, sizeof (struct wlrctl_output_command)); assert(cmd); wl_list_init(&cmd->heads); if (argc == 0) { die("Missing output action or identifier\n"); } char *action = argv[0]; cmd->action = parse_action(action); if (cmd->action == OUTPUT_ACTION_CONFIGURE) { if (argc < 2 ) { cmd->cfg_action = OUTPUT_CFG_ACTION_SHOW; } else { cmd->cfg_action = parse_cfg_action(argv[1]); if (cmd->cfg_action == OUTPUT_CFG_ACTION_UNSPEC) { die("Unknown output configurataion '%s'\n", argv[1]); } } cmd->ident = strdup(argv[0]); } state->cmd = cmd; cmd->state = state; } void stop_output(struct wlrctl *state) { zwlr_output_manager_v1_stop(state->output_mgr); } void complete_output(void *data, struct wl_callback *callback, uint32_t serial) { struct wlrctl *state = data; // struct wlrctl_output_command *cmd = state->cmd; wl_callback_destroy(callback); stop_output(state); } void run_output(struct wlrctl *state) { // struct wlrctl_output_command *cmd = state->cmd; zwlr_output_manager_v1_add_listener( state->output_mgr, &zwlr_output_manager_v1_listener, state ); stop_output(state); } void destroy_output(struct wlrctl *state) { struct wlrctl_output_command *cmd = state->cmd; struct head_data *data, *tmp; wl_list_for_each_safe(data, tmp, &cmd->heads, link) { wl_list_remove(&data->link); head_data_destroy(data); } free(cmd->ident); free(cmd); } 07070100000013000081A400000000000000000000000164632F3500001409000000000000000000000000000000000000001900000000wlrctl-0.2.2~0/pointer.c#include <assert.h> #include <linux/input-event-codes.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <wayland-client.h> #include <wayland-util.h> #include "common.h" #include "pointer.h" #include "util.h" #include "wlr-virtual-pointer-unstable-v1-client-protocol.h" static enum pointer_action parse_action(const char *action) { static const struct token actions[] = { {"click", POINTER_ACTION_CLICK }, {"motion", POINTER_ACTION_MOTION}, {"move", POINTER_ACTION_MOTION}, {"scroll", POINTER_ACTION_SCROLL}, {NULL, POINTER_ACTION_UNSPEC} }; return matchtok(actions, action); } static uint32_t parse_button(const char *button) { static const struct token buttons[] = { {"left", BTN_LEFT }, {"right", BTN_RIGHT }, {"middle", BTN_MIDDLE }, {"extra", BTN_EXTRA }, {"side", BTN_SIDE }, {"forward", BTN_FORWARD}, {"back", BTN_BACK }, {NULL, 0} }; return matchtok(buttons, button); } static void parse_fixed(const char *d, wl_fixed_t *fixed) { char *end; int val = strtod(d, &end); if (end == d || *end){ die("Bad value: '%s'\n", d); } else { *fixed = wl_fixed_from_double(val); } } void prepare_pointer(struct wlrctl *state, int argc, char *argv[]) { struct wlrctl_pointer_command *cmd = calloc(1, sizeof (struct wlrctl_pointer_command)); assert(cmd); const char *action = argv[0]; cmd->action = parse_action(action); switch (cmd->action) { case POINTER_ACTION_CLICK: if (argc < 2) { cmd->button = BTN_LEFT; } else { const char *button = argv[1]; cmd->button = parse_button(button); if (!cmd->button) { die("Unknown button: '%s'\n", button); } } break; case POINTER_ACTION_MOTION: switch (argc) { case 1: break; case 2: parse_fixed(argv[1], &cmd->dx); break; case 3: parse_fixed(argv[1], &cmd->dx); parse_fixed(argv[2], &cmd->dy); break; default: die("Extra argument: '%s'\n", argv[3]); } break; case POINTER_ACTION_SCROLL: switch (argc) { case 1: break; case 2: parse_fixed(argv[1], &cmd->dy); break; case 3: parse_fixed(argv[1], &cmd->dy); parse_fixed(argv[2], &cmd->dx); break; default: die("Extra argument: '%s'\n", argv[3]); } break; case POINTER_ACTION_UNSPEC: die("Unknown pointer action: '%s'\n", action); } state->cmd = cmd; cmd->state = state; } static void complete_pointer(void *data, struct wl_callback *callback, uint32_t serial) { struct wlrctl *state = data; wl_callback_destroy(callback); state->running = false; destroy_pointer(state); } static struct wl_callback_listener completed_listener = { .done = complete_pointer }; static void pointer_press(struct zwlr_virtual_pointer_v1 *vptr, uint32_t button) { zwlr_virtual_pointer_v1_button(vptr, timestamp(), button, WL_POINTER_BUTTON_STATE_PRESSED); zwlr_virtual_pointer_v1_frame(vptr); } static void pointer_release(struct zwlr_virtual_pointer_v1 *vptr, uint32_t button) { zwlr_virtual_pointer_v1_button(vptr, timestamp(), button, WL_POINTER_BUTTON_STATE_RELEASED); zwlr_virtual_pointer_v1_frame(vptr); } static void pointer_move(struct zwlr_virtual_pointer_v1 *vptr, wl_fixed_t dx, wl_fixed_t dy) { if (!dx && !dy) { return; } else { zwlr_virtual_pointer_v1_motion(vptr, timestamp(), dx, dy); zwlr_virtual_pointer_v1_frame(vptr); } } static void pointer_scroll(struct zwlr_virtual_pointer_v1 *vptr, wl_fixed_t dy, wl_fixed_t dx) { if (!dx && !dy) { return; } if (dx) { zwlr_virtual_pointer_v1_axis_source(vptr, WL_POINTER_AXIS_SOURCE_FINGER); zwlr_virtual_pointer_v1_axis(vptr, timestamp(), WL_POINTER_AXIS_HORIZONTAL_SCROLL, dx); } if (dy) { zwlr_virtual_pointer_v1_axis_source(vptr, WL_POINTER_AXIS_SOURCE_FINGER); zwlr_virtual_pointer_v1_axis(vptr, timestamp(), WL_POINTER_AXIS_VERTICAL_SCROLL, dy); } zwlr_virtual_pointer_v1_frame(vptr); if (dx) { zwlr_virtual_pointer_v1_axis_source(vptr, WL_POINTER_AXIS_SOURCE_FINGER); zwlr_virtual_pointer_v1_axis_stop(vptr, timestamp(), WL_POINTER_AXIS_HORIZONTAL_SCROLL); } if (dy) { zwlr_virtual_pointer_v1_axis_source(vptr, WL_POINTER_AXIS_SOURCE_FINGER); zwlr_virtual_pointer_v1_axis_stop(vptr, timestamp(), WL_POINTER_AXIS_VERTICAL_SCROLL); } zwlr_virtual_pointer_v1_frame(vptr); } void run_pointer(struct wlrctl *state) { struct wlrctl_pointer_command *cmd = state->cmd; cmd->device = zwlr_virtual_pointer_manager_v1_create_virtual_pointer( state->vp_mgr, state->seat ); switch (cmd->action) { case POINTER_ACTION_CLICK: pointer_press(cmd->device, cmd->button); pointer_release(cmd->device, cmd->button); break; case POINTER_ACTION_MOTION: pointer_move(cmd->device, cmd->dx, cmd->dy); break; case POINTER_ACTION_SCROLL: pointer_scroll(cmd->device, cmd->dy, cmd->dx); break; case POINTER_ACTION_UNSPEC: // Unreachable assert(false); } struct wl_callback *callback = wl_display_sync(state->display); wl_callback_add_listener(callback, &completed_listener, state); } void destroy_pointer(struct wlrctl *state) { struct wlrctl_pointer_command *cmd = state->cmd; zwlr_virtual_pointer_v1_destroy(cmd->device); free(cmd); } 07070100000014000041ED00000000000000000000000164632F3500000000000000000000000000000000000000000000001800000000wlrctl-0.2.2~0/protocol07070100000015000081A400000000000000000000000164632F350000042D000000000000000000000000000000000000002400000000wlrctl-0.2.2~0/protocol/meson.build# wl_protocol_dir = wayland_protos.get_variable(pkgconfig: 'pkgdatadir') wayland_scanner = find_program('wayland-scanner') wayland_scanner_code = generator( wayland_scanner, output: '@BASENAME@-protocol.c', arguments: ['private-code', '@INPUT@', '@OUTPUT@'], ) wayland_scanner_client = generator( wayland_scanner, output: '@BASENAME@-client-protocol.h', arguments: ['client-header', '@INPUT@', '@OUTPUT@'], ) protocols = [ 'virtual-keyboard-unstable-v1.xml', 'wlr-virtual-pointer-unstable-v1.xml', 'wlr-foreign-toplevel-management-unstable-v1.xml', 'wlr-output-management-unstable-v1.xml', ] client_protos_src = [] client_protos_headers = [] foreach xml : protocols client_protos_src += wayland_scanner_code.process(xml) client_protos_headers += wayland_scanner_client.process(xml) endforeach lib_client_protos = static_library( 'client_protos', client_protos_src + client_protos_headers, dependencies: [wayland_client] ) client_protos = declare_dependency( link_with: lib_client_protos, sources: client_protos_headers, ) # vim: set ts=4 sw=4: 07070100000016000081A400000000000000000000000164632F3500001316000000000000000000000000000000000000003900000000wlrctl-0.2.2~0/protocol/virtual-keyboard-unstable-v1.xml<?xml version="1.0" encoding="UTF-8"?> <protocol name="virtual_keyboard_unstable_v1"> <copyright> Copyright © 2008-2011 Kristian Høgsberg Copyright © 2010-2013 Intel Corporation Copyright © 2012-2013 Collabora, Ltd. Copyright © 2018 Purism SPC Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. </copyright> <interface name="zwp_virtual_keyboard_v1" version="1"> <description summary="virtual keyboard"> The virtual keyboard provides an application with requests which emulate the behaviour of a physical keyboard. This interface can be used by clients on its own to provide raw input events, or it can accompany the input method protocol. </description> <request name="keymap"> <description summary="keyboard mapping"> Provide a file descriptor to the compositor which can be memory-mapped to provide a keyboard mapping description. Format carries a value from the keymap_format enumeration. </description> <arg name="format" type="uint" summary="keymap format"/> <arg name="fd" type="fd" summary="keymap file descriptor"/> <arg name="size" type="uint" summary="keymap size, in bytes"/> </request> <enum name="error"> <entry name="no_keymap" value="0" summary="No keymap was set"/> </enum> <request name="key"> <description summary="key event"> A key was pressed or released. The time argument is a timestamp with millisecond granularity, with an undefined base. All requests regarding a single object must share the same clock. Keymap must be set before issuing this request. State carries a value from the key_state enumeration. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity"/> <arg name="key" type="uint" summary="key that produced the event"/> <arg name="state" type="uint" summary="physical state of the key"/> </request> <request name="modifiers"> <description summary="modifier and group state"> Notifies the compositor that the modifier and/or group state has changed, and it should update state. The client should use wl_keyboard.modifiers event to synchronize its internal state with seat state. Keymap must be set before issuing this request. </description> <arg name="mods_depressed" type="uint" summary="depressed modifiers"/> <arg name="mods_latched" type="uint" summary="latched modifiers"/> <arg name="mods_locked" type="uint" summary="locked modifiers"/> <arg name="group" type="uint" summary="keyboard layout"/> </request> <request name="destroy" type="destructor" since="1"> <description summary="destroy the virtual keyboard keyboard object"/> </request> </interface> <interface name="zwp_virtual_keyboard_manager_v1" version="1"> <description summary="virtual keyboard manager"> A virtual keyboard manager allows an application to provide keyboard input events as if they came from a physical keyboard. </description> <enum name="error"> <entry name="unauthorized" value="0" summary="client not authorized to use the interface"/> </enum> <request name="create_virtual_keyboard"> <description summary="Create a new virtual keyboard"> Creates a new virtual keyboard associated to a seat. If the compositor enables a keyboard to perform arbitrary actions, it should present an error when an untrusted client requests a new keyboard. </description> <arg name="seat" type="object" interface="wl_seat"/> <arg name="id" type="new_id" interface="zwp_virtual_keyboard_v1"/> </request> </interface> </protocol> 07070100000017000081A400000000000000000000000164632F3500002D12000000000000000000000000000000000000004800000000wlrctl-0.2.2~0/protocol/wlr-foreign-toplevel-management-unstable-v1.xml<?xml version="1.0" encoding="UTF-8"?> <protocol name="wlr_foreign_toplevel_management_unstable_v1"> <copyright> Copyright © 2018 Ilia Bozhinov Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. The copyright holders make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. </copyright> <interface name="zwlr_foreign_toplevel_manager_v1" version="3"> <description summary="list and control opened apps"> The purpose of this protocol is to enable the creation of taskbars and docks by providing them with a list of opened applications and letting them request certain actions on them, like maximizing, etc. After a client binds the zwlr_foreign_toplevel_manager_v1, each opened toplevel window will be sent via the toplevel event </description> <event name="toplevel"> <description summary="a toplevel has been created"> This event is emitted whenever a new toplevel window is created. It is emitted for all toplevels, regardless of the app that has created them. All initial details of the toplevel(title, app_id, states, etc.) will be sent immediately after this event via the corresponding events in zwlr_foreign_toplevel_handle_v1. </description> <arg name="toplevel" type="new_id" interface="zwlr_foreign_toplevel_handle_v1"/> </event> <request name="stop"> <description summary="stop sending events"> Indicates the client no longer wishes to receive events for new toplevels. However the compositor may emit further toplevel_created events, until the finished event is emitted. The client must not send any more requests after this one. </description> </request> <event name="finished"> <description summary="the compositor has finished with the toplevel manager"> This event indicates that the compositor is done sending events to the zwlr_foreign_toplevel_manager_v1. The server will destroy the object immediately after sending this request, so it will become invalid and the client should free any resources associated with it. </description> </event> </interface> <interface name="zwlr_foreign_toplevel_handle_v1" version="3"> <description summary="an opened toplevel"> A zwlr_foreign_toplevel_handle_v1 object represents an opened toplevel window. Each app may have multiple opened toplevels. Each toplevel has a list of outputs it is visible on, conveyed to the client with the output_enter and output_leave events. </description> <event name="title"> <description summary="title change"> This event is emitted whenever the title of the toplevel changes. </description> <arg name="title" type="string"/> </event> <event name="app_id"> <description summary="app-id change"> This event is emitted whenever the app-id of the toplevel changes. </description> <arg name="app_id" type="string"/> </event> <event name="output_enter"> <description summary="toplevel entered an output"> This event is emitted whenever the toplevel becomes visible on the given output. A toplevel may be visible on multiple outputs. </description> <arg name="output" type="object" interface="wl_output"/> </event> <event name="output_leave"> <description summary="toplevel left an output"> This event is emitted whenever the toplevel stops being visible on the given output. It is guaranteed that an entered-output event with the same output has been emitted before this event. </description> <arg name="output" type="object" interface="wl_output"/> </event> <request name="set_maximized"> <description summary="requests that the toplevel be maximized"> Requests that the toplevel be maximized. If the maximized state actually changes, this will be indicated by the state event. </description> </request> <request name="unset_maximized"> <description summary="requests that the toplevel be unmaximized"> Requests that the toplevel be unmaximized. If the maximized state actually changes, this will be indicated by the state event. </description> </request> <request name="set_minimized"> <description summary="requests that the toplevel be minimized"> Requests that the toplevel be minimized. If the minimized state actually changes, this will be indicated by the state event. </description> </request> <request name="unset_minimized"> <description summary="requests that the toplevel be unminimized"> Requests that the toplevel be unminimized. If the minimized state actually changes, this will be indicated by the state event. </description> </request> <request name="activate"> <description summary="activate the toplevel"> Request that this toplevel be activated on the given seat. There is no guarantee the toplevel will be actually activated. </description> <arg name="seat" type="object" interface="wl_seat"/> </request> <enum name="state"> <description summary="types of states on the toplevel"> The different states that a toplevel can have. These have the same meaning as the states with the same names defined in xdg-toplevel </description> <entry name="maximized" value="0" summary="the toplevel is maximized"/> <entry name="minimized" value="1" summary="the toplevel is minimized"/> <entry name="activated" value="2" summary="the toplevel is active"/> <entry name="fullscreen" value="3" summary="the toplevel is fullscreen" since="2"/> </enum> <event name="state"> <description summary="the toplevel state changed"> This event is emitted immediately after the zlw_foreign_toplevel_handle_v1 is created and each time the toplevel state changes, either because of a compositor action or because of a request in this protocol. </description> <arg name="state" type="array"/> </event> <event name="done"> <description summary="all information about the toplevel has been sent"> This event is sent after all changes in the toplevel state have been sent. This allows changes to the zwlr_foreign_toplevel_handle_v1 properties to be seen as atomic, even if they happen via multiple events. </description> </event> <request name="close"> <description summary="request that the toplevel be closed"> Send a request to the toplevel to close itself. The compositor would typically use a shell-specific method to carry out this request, for example by sending the xdg_toplevel.close event. However, this gives no guarantees the toplevel will actually be destroyed. If and when this happens, the zwlr_foreign_toplevel_handle_v1.closed event will be emitted. </description> </request> <request name="set_rectangle"> <description summary="the rectangle which represents the toplevel"> The rectangle of the surface specified in this request corresponds to the place where the app using this protocol represents the given toplevel. It can be used by the compositor as a hint for some operations, e.g minimizing. The client is however not required to set this, in which case the compositor is free to decide some default value. If the client specifies more than one rectangle, only the last one is considered. The dimensions are given in surface-local coordinates. Setting width=height=0 removes the already-set rectangle. </description> <arg name="surface" type="object" interface="wl_surface"/> <arg name="x" type="int"/> <arg name="y" type="int"/> <arg name="width" type="int"/> <arg name="height" type="int"/> </request> <enum name="error"> <entry name="invalid_rectangle" value="0" summary="the provided rectangle is invalid"/> </enum> <event name="closed"> <description summary="this toplevel has been destroyed"> This event means the toplevel has been destroyed. It is guaranteed there won't be any more events for this zwlr_foreign_toplevel_handle_v1. The toplevel itself becomes inert so any requests will be ignored except the destroy request. </description> </event> <request name="destroy" type="destructor"> <description summary="destroy the zwlr_foreign_toplevel_handle_v1 object"> Destroys the zwlr_foreign_toplevel_handle_v1 object. This request should be called either when the client does not want to use the toplevel anymore or after the closed event to finalize the destruction of the object. </description> </request> <!-- Version 2 additions --> <request name="set_fullscreen" since="2"> <description summary="request that the toplevel be fullscreened"> Requests that the toplevel be fullscreened on the given output. If the fullscreen state and/or the outputs the toplevel is visible on actually change, this will be indicated by the state and output_enter/leave events. The output parameter is only a hint to the compositor. Also, if output is NULL, the compositor should decide which output the toplevel will be fullscreened on, if at all. </description> <arg name="output" type="object" interface="wl_output" allow-null="true"/> </request> <request name="unset_fullscreen" since="2"> <description summary="request that the toplevel be unfullscreened"> Requests that the toplevel be unfullscreened. If the fullscreen state actually changes, this will be indicated by the state event. </description> </request> <!-- Version 3 additions --> <event name="parent" since="3"> <description summary="parent change"> This event is emitted whenever the parent of the toplevel changes. No event is emitted when the parent handle is destroyed by the client. </description> <arg name="parent" type="object" interface="zwlr_foreign_toplevel_handle_v1" allow-null="true"/> </event> </interface> </protocol> 07070100000018000081A400000000000000000000000164632F3500005DFA000000000000000000000000000000000000003E00000000wlrctl-0.2.2~0/protocol/wlr-output-management-unstable-v1.xml<?xml version="1.0" encoding="UTF-8"?> <protocol name="wlr_output_management_unstable_v1"> <copyright> Copyright © 2019 Purism SPC Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. The copyright holders make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. </copyright> <description summary="protocol to configure output devices"> This protocol exposes interfaces to obtain and modify output device configuration. Warning! The protocol described in this file is experimental and backward incompatible changes may be made. Backward compatible changes may be added together with the corresponding interface version bump. Backward incompatible changes are done by bumping the version number in the protocol and interface names and resetting the interface version. Once the protocol is to be declared stable, the 'z' prefix and the version number in the protocol and interface names are removed and the interface version number is reset. </description> <interface name="zwlr_output_manager_v1" version="2"> <description summary="output device configuration manager"> This interface is a manager that allows reading and writing the current output device configuration. Output devices that display pixels (e.g. a physical monitor or a virtual output in a window) are represented as heads. Heads cannot be created nor destroyed by the client, but they can be enabled or disabled and their properties can be changed. Each head may have one or more available modes. Whenever a head appears (e.g. a monitor is plugged in), it will be advertised via the head event. Immediately after the output manager is bound, all current heads are advertised. Whenever a head's properties change, the relevant wlr_output_head events will be sent. Not all head properties will be sent: only properties that have changed need to. Whenever a head disappears (e.g. a monitor is unplugged), a wlr_output_head.finished event will be sent. After one or more heads appear, change or disappear, the done event will be sent. It carries a serial which can be used in a create_configuration request to update heads properties. The information obtained from this protocol should only be used for output configuration purposes. This protocol is not designed to be a generic output property advertisement protocol for regular clients. Instead, protocols such as xdg-output should be used. </description> <event name="head"> <description summary="introduce a new head"> This event introduces a new head. This happens whenever a new head appears (e.g. a monitor is plugged in) or after the output manager is bound. </description> <arg name="head" type="new_id" interface="zwlr_output_head_v1"/> </event> <event name="done"> <description summary="sent all information about current configuration"> This event is sent after all information has been sent after binding to the output manager object and after any subsequent changes. This applies to child head and mode objects as well. In other words, this event is sent whenever a head or mode is created or destroyed and whenever one of their properties has been changed. Not all state is re-sent each time the current configuration changes: only the actual changes are sent. This allows changes to the output configuration to be seen as atomic, even if they happen via multiple events. A serial is sent to be used in a future create_configuration request. </description> <arg name="serial" type="uint" summary="current configuration serial"/> </event> <request name="create_configuration"> <description summary="create a new output configuration object"> Create a new output configuration object. This allows to update head properties. </description> <arg name="id" type="new_id" interface="zwlr_output_configuration_v1"/> <arg name="serial" type="uint"/> </request> <request name="stop"> <description summary="stop sending events"> Indicates the client no longer wishes to receive events for output configuration changes. However the compositor may emit further events, until the finished event is emitted. The client must not send any more requests after this one. </description> </request> <event name="finished"> <description summary="the compositor has finished with the manager"> This event indicates that the compositor is done sending manager events. The compositor will destroy the object immediately after sending this event, so it will become invalid and the client should release any resources associated with it. </description> </event> </interface> <interface name="zwlr_output_head_v1" version="2"> <description summary="output device"> A head is an output device. The difference between a wl_output object and a head is that heads are advertised even if they are turned off. A head object only advertises properties and cannot be used directly to change them. A head has some read-only properties: modes, name, description and physical_size. These cannot be changed by clients. Other properties can be updated via a wlr_output_configuration object. Properties sent via this interface are applied atomically via the wlr_output_manager.done event. No guarantees are made regarding the order in which properties are sent. </description> <event name="name"> <description summary="head name"> This event describes the head name. The naming convention is compositor defined, but limited to alphanumeric characters and dashes (-). Each name is unique among all wlr_output_head objects, but if a wlr_output_head object is destroyed the same name may be reused later. The names will also remain consistent across sessions with the same hardware and software configuration. Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do not assume that the name is a reflection of an underlying DRM connector, X11 connection, etc. If the compositor implements the xdg-output protocol and this head is enabled, the xdg_output.name event must report the same name. The name event is sent after a wlr_output_head object is created. This event is only sent once per object, and the name does not change over the lifetime of the wlr_output_head object. </description> <arg name="name" type="string"/> </event> <event name="description"> <description summary="head description"> This event describes a human-readable description of the head. The description is a UTF-8 string with no convention defined for its contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 output via :1'. However, do not assume that the name is a reflection of the make, model, serial of the underlying DRM connector or the display name of the underlying X11 connection, etc. If the compositor implements xdg-output and this head is enabled, the xdg_output.description must report the same description. The description event is sent after a wlr_output_head object is created. This event is only sent once per object, and the description does not change over the lifetime of the wlr_output_head object. </description> <arg name="description" type="string"/> </event> <event name="physical_size"> <description summary="head physical size"> This event describes the physical size of the head. This event is only sent if the head has a physical size (e.g. is not a projector or a virtual device). </description> <arg name="width" type="int" summary="width in millimeters of the output"/> <arg name="height" type="int" summary="height in millimeters of the output"/> </event> <event name="mode"> <description summary="introduce a mode"> This event introduces a mode for this head. It is sent once per supported mode. </description> <arg name="mode" type="new_id" interface="zwlr_output_mode_v1"/> </event> <event name="enabled"> <description summary="head is enabled or disabled"> This event describes whether the head is enabled. A disabled head is not mapped to a region of the global compositor space. When a head is disabled, some properties (current_mode, position, transform and scale) are irrelevant. </description> <arg name="enabled" type="int" summary="zero if disabled, non-zero if enabled"/> </event> <event name="current_mode"> <description summary="current mode"> This event describes the mode currently in use for this head. It is only sent if the output is enabled. </description> <arg name="mode" type="object" interface="zwlr_output_mode_v1"/> </event> <event name="position"> <description summary="current position"> This events describes the position of the head in the global compositor space. It is only sent if the output is enabled. </description> <arg name="x" type="int" summary="x position within the global compositor space"/> <arg name="y" type="int" summary="y position within the global compositor space"/> </event> <event name="transform"> <description summary="current transformation"> This event describes the transformation currently applied to the head. It is only sent if the output is enabled. </description> <arg name="transform" type="int" enum="wl_output.transform"/> </event> <event name="scale"> <description summary="current scale"> This events describes the scale of the head in the global compositor space. It is only sent if the output is enabled. </description> <arg name="scale" type="fixed"/> </event> <event name="finished"> <description summary="the head has been destroyed"> The compositor will destroy the object immediately after sending this event, so it will become invalid and the client should release any resources associated with it. </description> </event> <!-- Version 2 additions --> <event name="make" since="2"> <description summary="head manufacturer"> This event describes the manufacturer of the head. This must report the same make as the wl_output interface does in its geometry event. Together with the model and serial_number events the purpose is to allow clients to recognize heads from previous sessions and for example load head-specific configurations back. It is not guaranteed this event will be ever sent. A reason for that can be that the compositor does not have information about the make of the head or the definition of a make is not sensible in the current setup, for example in a virtual session. Clients can still try to identify the head by available information from other events but should be aware that there is an increased risk of false positives. It is not recommended to display the make string in UI to users. For that the string provided by the description event should be preferred. </description> <arg name="make" type="string"/> </event> <event name="model" since="2"> <description summary="head model"> This event describes the model of the head. This must report the same model as the wl_output interface does in its geometry event. Together with the make and serial_number events the purpose is to allow clients to recognize heads from previous sessions and for example load head-specific configurations back. It is not guaranteed this event will be ever sent. A reason for that can be that the compositor does not have information about the model of the head or the definition of a model is not sensible in the current setup, for example in a virtual session. Clients can still try to identify the head by available information from other events but should be aware that there is an increased risk of false positives. It is not recommended to display the model string in UI to users. For that the string provided by the description event should be preferred. </description> <arg name="model" type="string"/> </event> <event name="serial_number" since="2"> <description summary="head serial number"> This event describes the serial number of the head. Together with the make and model events the purpose is to allow clients to recognize heads from previous sessions and for example load head- specific configurations back. It is not guaranteed this event will be ever sent. A reason for that can be that the compositor does not have information about the serial number of the head or the definition of a serial number is not sensible in the current setup. Clients can still try to identify the head by available information from other events but should be aware that there is an increased risk of false positives. It is not recommended to display the serial_number string in UI to users. For that the string provided by the description event should be preferred. </description> <arg name="serial_number" type="string"/> </event> </interface> <interface name="zwlr_output_mode_v1" version="2"> <description summary="output mode"> This object describes an output mode. Some heads don't support output modes, in which case modes won't be advertised. Properties sent via this interface are applied atomically via the wlr_output_manager.done event. No guarantees are made regarding the order in which properties are sent. </description> <event name="size"> <description summary="mode size"> This event describes the mode size. The size is given in physical hardware units of the output device. This is not necessarily the same as the output size in the global compositor space. For instance, the output may be scaled or transformed. </description> <arg name="width" type="int" summary="width of the mode in hardware units"/> <arg name="height" type="int" summary="height of the mode in hardware units"/> </event> <event name="refresh"> <description summary="mode refresh rate"> This event describes the mode's fixed vertical refresh rate. It is only sent if the mode has a fixed refresh rate. </description> <arg name="refresh" type="int" summary="vertical refresh rate in mHz"/> </event> <event name="preferred"> <description summary="mode is preferred"> This event advertises this mode as preferred. </description> </event> <event name="finished"> <description summary="the mode has been destroyed"> The compositor will destroy the object immediately after sending this event, so it will become invalid and the client should release any resources associated with it. </description> </event> </interface> <interface name="zwlr_output_configuration_v1" version="2"> <description summary="output configuration"> This object is used by the client to describe a full output configuration. First, the client needs to setup the output configuration. Each head can be either enabled (and configured) or disabled. It is a protocol error to send two enable_head or disable_head requests with the same head. It is a protocol error to omit a head in a configuration. Then, the client can apply or test the configuration. The compositor will then reply with a succeeded, failed or cancelled event. Finally the client should destroy the configuration object. </description> <enum name="error"> <entry name="already_configured_head" value="1" summary="head has been configured twice"/> <entry name="unconfigured_head" value="2" summary="head has not been configured"/> <entry name="already_used" value="3" summary="request sent after configuration has been applied or tested"/> </enum> <request name="enable_head"> <description summary="enable and configure a head"> Enable a head. This request creates a head configuration object that can be used to change the head's properties. </description> <arg name="id" type="new_id" interface="zwlr_output_configuration_head_v1" summary="a new object to configure the head"/> <arg name="head" type="object" interface="zwlr_output_head_v1" summary="the head to be enabled"/> </request> <request name="disable_head"> <description summary="disable a head"> Disable a head. </description> <arg name="head" type="object" interface="zwlr_output_head_v1" summary="the head to be disabled"/> </request> <request name="apply"> <description summary="apply the configuration"> Apply the new output configuration. In case the configuration is successfully applied, there is no guarantee that the new output state matches completely the requested configuration. For instance, a compositor might round the scale if it doesn't support fractional scaling. After this request has been sent, the compositor must respond with an succeeded, failed or cancelled event. Sending a request that isn't the destructor is a protocol error. </description> </request> <request name="test"> <description summary="test the configuration"> Test the new output configuration. The configuration won't be applied, but will only be validated. Even if the compositor succeeds to test a configuration, applying it may fail. After this request has been sent, the compositor must respond with an succeeded, failed or cancelled event. Sending a request that isn't the destructor is a protocol error. </description> </request> <event name="succeeded"> <description summary="configuration changes succeeded"> Sent after the compositor has successfully applied the changes or tested them. Upon receiving this event, the client should destroy this object. If the current configuration has changed, events to describe the changes will be sent followed by a wlr_output_manager.done event. </description> </event> <event name="failed"> <description summary="configuration changes failed"> Sent if the compositor rejects the changes or failed to apply them. The compositor should revert any changes made by the apply request that triggered this event. Upon receiving this event, the client should destroy this object. </description> </event> <event name="cancelled"> <description summary="configuration has been cancelled"> Sent if the compositor cancels the configuration because the state of an output changed and the client has outdated information (e.g. after an output has been hotplugged). The client can create a new configuration with a newer serial and try again. Upon receiving this event, the client should destroy this object. </description> </event> <request name="destroy" type="destructor"> <description summary="destroy the output configuration"> Using this request a client can tell the compositor that it is not going to use the configuration object anymore. Any changes to the outputs that have not been applied will be discarded. This request also destroys wlr_output_configuration_head objects created via this object. </description> </request> </interface> <interface name="zwlr_output_configuration_head_v1" version="2"> <description summary="head configuration"> This object is used by the client to update a single head's configuration. It is a protocol error to set the same property twice. </description> <enum name="error"> <entry name="already_set" value="1" summary="property has already been set"/> <entry name="invalid_mode" value="2" summary="mode doesn't belong to head"/> <entry name="invalid_custom_mode" value="3" summary="mode is invalid"/> <entry name="invalid_transform" value="4" summary="transform value outside enum"/> <entry name="invalid_scale" value="5" summary="scale negative or zero"/> </enum> <request name="set_mode"> <description summary="set the mode"> This request sets the head's mode. </description> <arg name="mode" type="object" interface="zwlr_output_mode_v1"/> </request> <request name="set_custom_mode"> <description summary="set a custom mode"> This request assigns a custom mode to the head. The size is given in physical hardware units of the output device. If set to zero, the refresh rate is unspecified. It is a protocol error to set both a mode and a custom mode. </description> <arg name="width" type="int" summary="width of the mode in hardware units"/> <arg name="height" type="int" summary="height of the mode in hardware units"/> <arg name="refresh" type="int" summary="vertical refresh rate in mHz or zero"/> </request> <request name="set_position"> <description summary="set the position"> This request sets the head's position in the global compositor space. </description> <arg name="x" type="int" summary="x position in the global compositor space"/> <arg name="y" type="int" summary="y position in the global compositor space"/> </request> <request name="set_transform"> <description summary="set the transform"> This request sets the head's transform. </description> <arg name="transform" type="int" enum="wl_output.transform"/> </request> <request name="set_scale"> <description summary="set the scale"> This request sets the head's scale. </description> <arg name="scale" type="fixed"/> </request> </interface> </protocol> 07070100000019000081A400000000000000000000000164632F3500001AEF000000000000000000000000000000000000003C00000000wlrctl-0.2.2~0/protocol/wlr-virtual-pointer-unstable-v1.xml<?xml version="1.0" encoding="UTF-8"?> <protocol name="wlr_virtual_pointer_unstable_v1"> <copyright> Copyright © 2019 Josef Gajdusek Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. </copyright> <interface name="zwlr_virtual_pointer_v1" version="2"> <description summary="virtual pointer"> This protocol allows clients to emulate a physical pointer device. The requests are mostly mirror opposites of those specified in wl_pointer. </description> <enum name="error"> <entry name="invalid_axis" value="0" summary="client sent invalid axis enumeration value" /> <entry name="invalid_axis_source" value="1" summary="client sent invalid axis source enumeration value" /> </enum> <request name="motion"> <description summary="pointer relative motion event"> The pointer has moved by a relative amount to the previous request. Values are in the global compositor space. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity"/> <arg name="dx" type="fixed" summary="displacement on the x-axis"/> <arg name="dy" type="fixed" summary="displacement on the y-axis"/> </request> <request name="motion_absolute"> <description summary="pointer absolute motion event"> The pointer has moved in an absolute coordinate frame. Value of x can range from 0 to x_extent, value of y can range from 0 to y_extent. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity"/> <arg name="x" type="uint" summary="position on the x-axis"/> <arg name="y" type="uint" summary="position on the y-axis"/> <arg name="x_extent" type="uint" summary="extent of the x-axis"/> <arg name="y_extent" type="uint" summary="extent of the y-axis"/> </request> <request name="button"> <description summary="button event"> A button was pressed or released. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity"/> <arg name="button" type="uint" summary="button that produced the event"/> <arg name="state" type="uint" enum="wl_pointer.button_state" summary="physical state of the button"/> </request> <request name="axis"> <description summary="axis event"> Scroll and other axis requests. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity"/> <arg name="axis" type="uint" enum="wl_pointer.axis" summary="axis type"/> <arg name="value" type="fixed" summary="length of vector in touchpad coordinates"/> </request> <request name="frame"> <description summary="end of a pointer event sequence"> Indicates the set of events that logically belong together. </description> </request> <request name="axis_source"> <description summary="axis source event"> Source information for scroll and other axis. </description> <arg name="axis_source" type="uint" enum="wl_pointer.axis_source" summary="source of the axis event"/> </request> <request name="axis_stop"> <description summary="axis stop event"> Stop notification for scroll and other axes. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity"/> <arg name="axis" type="uint" enum="wl_pointer.axis" summary="the axis stopped with this event"/> </request> <request name="axis_discrete"> <description summary="axis click event"> Discrete step information for scroll and other axes. This event allows the client to extend data normally sent using the axis event with discrete value. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity"/> <arg name="axis" type="uint" enum="wl_pointer.axis" summary="axis type"/> <arg name="value" type="fixed" summary="length of vector in touchpad coordinates"/> <arg name="discrete" type="int" summary="number of steps"/> </request> <request name="destroy" type="destructor" since="1"> <description summary="destroy the virtual pointer object"/> </request> </interface> <interface name="zwlr_virtual_pointer_manager_v1" version="2"> <description summary="virtual pointer manager"> This object allows clients to create individual virtual pointer objects. </description> <request name="create_virtual_pointer"> <description summary="Create a new virtual pointer"> Creates a new virtual pointer. The optional seat is a suggestion to the compositor. </description> <arg name="seat" type="object" interface="wl_seat" allow-null="true"/> <arg name="id" type="new_id" interface="zwlr_virtual_pointer_v1"/> </request> <request name="destroy" type="destructor" since="1"> <description summary="destroy the virtual pointer manager"/> </request> <!-- Version 2 additions --> <request name="create_virtual_pointer_with_output" since="2"> <description summary="Create a new virtual pointer"> Creates a new virtual pointer. The seat and the output arguments are optional. If the seat argument is set, the compositor should assign the input device to the requested seat. If the output argument is set, the compositor should map the input device to the requested output. </description> <arg name="seat" type="object" interface="wl_seat" allow-null="true"/> <arg name="output" type="object" interface="wl_output" allow-null="true"/> <arg name="id" type="new_id" interface="zwlr_virtual_pointer_v1"/> </request> </interface> </protocol> 0707010000001A000081A400000000000000000000000164632F3500002D82000000000000000000000000000000000000001A00000000wlrctl-0.2.2~0/toplevel.c#define _DEFAULT_SOURCE #include <assert.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <wayland-client.h> #include "common.h" #include "toplevel.h" #include "util.h" #include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h" static void noop() {} static enum toplevel_action parse_action(const char *action) { static const struct token actions[] = { {"activate", TOPLEVEL_ACTION_ACTIVATE }, {"close", TOPLEVEL_ACTION_CLOSE }, {"find", TOPLEVEL_ACTION_FIND }, {"focus", TOPLEVEL_ACTION_ACTIVATE }, {"fullscreen", TOPLEVEL_ACTION_FULLSCREEN}, {"list", TOPLEVEL_ACTION_LIST }, {"maximize", TOPLEVEL_ACTION_MAXIMIZE }, {"minimize", TOPLEVEL_ACTION_MINIMIZE }, {"wait", TOPLEVEL_ACTION_WAIT }, {"waitfor", TOPLEVEL_ACTION_WAITFOR }, {NULL, TOPLEVEL_ACTION_UNSPEC} }; return matchtok(actions, action); } static enum toplevel_attr parse_state(const char *state, bool *enabled){ static const struct token states[] = { {"maximized", TOPLEVEL_ATTR_MAXIMIZED }, {"minimized", TOPLEVEL_ATTR_MINIMIZED }, {"activated", TOPLEVEL_ATTR_ACTIVATED }, {"active", TOPLEVEL_ATTR_ACTIVATED }, {"focused", TOPLEVEL_ATTR_ACTIVATED }, {"fullscreen", TOPLEVEL_ATTR_FULLSCREEN}, {NULL, TOPLEVEL_ATTR_UNSPEC} }; if (strncmp(state, "-", 1) == 0) { *enabled = false; state += 1; } else if ( strncmp(state, "in", 2) == 0 || strncmp(state, "un", 2) == 0 ) { *enabled = false; state += 2; } else { *enabled = true; } return matchtok(states, state); } static void append(struct wl_array *arr, char *str) { char **p = wl_array_add(arr, sizeof (char *)); if (!p) { die("Could not allocate pointer for matchspec\n"); } else { *p = str; } } static bool contains_value(struct wl_array *arr, int value) { if (!value) { return false; } int *cursor; wl_array_for_each(cursor, arr) { if (*cursor == value) { return true; } } return false; } static bool contains_str(struct wl_array *arr, char *str) { if (!str) { return false; } char **cursor; wl_array_for_each(cursor, arr) { if (strcmp(str, *cursor) == 0) { return true; } } return false; } static void matchspec_init(struct toplevel_matchspec *matchspec) { wl_array_init(&matchspec->app_ids); wl_array_init(&matchspec->titles); } static void matchspec_release(struct toplevel_matchspec *matchspec) { wl_array_release(&matchspec->app_ids); wl_array_release(&matchspec->titles); } static void matchspec_add_match(struct toplevel_matchspec *matchspec, char *match) { char *value = match; char *attr = strsep(&value, ":"); if (!value) { matchspec->attrs |= TOPLEVEL_ATTR_APPID; append(&matchspec->app_ids, attr); return; } bool enabled = true; struct token attrs[] = { {"app-id", TOPLEVEL_ATTR_APPID }, {"app_id", TOPLEVEL_ATTR_APPID }, {"title", TOPLEVEL_ATTR_TITLE }, {"state", parse_state(value, &enabled)}, {NULL, TOPLEVEL_ATTR_UNSPEC} }; enum toplevel_attr pattr = matchtok(attrs, attr); switch (pattr) { case TOPLEVEL_ATTR_APPID: matchspec->attrs |= pattr; append(&matchspec->app_ids, value); return; case TOPLEVEL_ATTR_TITLE: matchspec->attrs |= pattr; append(&matchspec->titles, value); return; case TOPLEVEL_ATTR_MAXIMIZED: matchspec->attrs |= pattr; matchspec->maximized = enabled; break; case TOPLEVEL_ATTR_MINIMIZED: matchspec->attrs |= pattr; matchspec->minimized = enabled; break; case TOPLEVEL_ATTR_ACTIVATED: matchspec->attrs |= pattr; matchspec->activated = enabled; break; case TOPLEVEL_ATTR_FULLSCREEN: matchspec->attrs |= pattr; matchspec->fullscreen = enabled; break; case TOPLEVEL_ATTR_UNSPEC: default: die("Unknown attribute: '%s:%s'\n", attr, value); } return; } static bool is_matched(struct toplevel_data *data) { struct toplevel_matchspec *matchspec = &data->cmd->matchspec; if (matchspec->attrs & TOPLEVEL_ATTR_APPID) { if (!contains_str(&matchspec->app_ids, data->app_id)) { return false; } } if (matchspec->attrs & TOPLEVEL_ATTR_TITLE) { if (!contains_str(&matchspec->titles, data->title)) { return false; } } if (matchspec->attrs & TOPLEVEL_ATTR_MAXIMIZED) { if (contains_value(&data->state, ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MAXIMIZED) ^ matchspec->maximized) { return false; } } if (matchspec->attrs & TOPLEVEL_ATTR_MINIMIZED) { if (contains_value(&data->state, ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MINIMIZED) ^ matchspec->minimized) { return false; } } if (matchspec->attrs & TOPLEVEL_ATTR_ACTIVATED) { if (contains_value(&data->state, ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED) ^ matchspec->activated) { return false; } } if (matchspec->attrs & TOPLEVEL_ATTR_FULLSCREEN) { if (contains_value(&data->state, ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_FULLSCREEN) ^ matchspec->fullscreen) { return false; } } return true; } struct toplevel_data * toplevel_data_create(struct wlrctl_toplevel_command *cmd) { struct toplevel_data *data = calloc(1, sizeof (struct toplevel_data)); if (!data) { die("Failed to allocate toplevel data\n"); } wl_array_init(&data->state); data->cmd = cmd; wl_list_insert(&cmd->toplevels, &data->link); return data; } void toplevel_data_destroy(struct toplevel_data *data) { free(data->app_id); free(data->title); wl_array_release(&data->state); free(data); } static void zwlr_foreign_toplevel_handle_v1_handle_title(void *user_data, struct zwlr_foreign_toplevel_handle_v1 *toplevel, const char *title ) { struct toplevel_data *data = user_data; data->title = strdup(title); } static void zwlr_foreign_toplevel_handle_v1_handle_app_id(void *user_data, struct zwlr_foreign_toplevel_handle_v1 *toplevel, const char *app_id ) { struct toplevel_data *data = user_data; data->app_id = strdup(app_id); } static void zwlr_foreign_toplevel_handle_v1_handle_state(void *user_data, struct zwlr_foreign_toplevel_handle_v1 *toplevel, struct wl_array *state ) { struct toplevel_data *data = user_data; wl_array_copy(&data->state, state); } static void zwlr_foreign_toplevel_handle_v1_handle_done(void *user_data, struct zwlr_foreign_toplevel_handle_v1 *toplevel ) { struct toplevel_data *data = user_data; if (data->cmd->action != TOPLEVEL_ACTION_WAITFOR && data->done) { return; } else { data->done = true; } if (data->cmd->complete || !is_matched(data)) { return; } else { data->cmd->any = true; data->matched = true; } switch (data->cmd->action) { case TOPLEVEL_ACTION_MINIMIZE: zwlr_foreign_toplevel_handle_v1_set_minimized(toplevel); break; case TOPLEVEL_ACTION_MAXIMIZE: zwlr_foreign_toplevel_handle_v1_set_maximized(toplevel); break; case TOPLEVEL_ACTION_ACTIVATE: zwlr_foreign_toplevel_handle_v1_activate(toplevel, data->cmd->state->seat); data->cmd->complete = true; stop_toplevel(data->cmd->state); break; case TOPLEVEL_ACTION_FULLSCREEN: zwlr_foreign_toplevel_handle_v1_set_fullscreen(toplevel, NULL); break; case TOPLEVEL_ACTION_CLOSE: zwlr_foreign_toplevel_handle_v1_close(toplevel); break; case TOPLEVEL_ACTION_LIST: if (data->app_id) { printf("%s: %s\n", data->app_id, data->title ? data->title : ""); } break; case TOPLEVEL_ACTION_FIND: case TOPLEVEL_ACTION_WAITFOR: data->cmd->complete = true; stop_toplevel(data->cmd->state); break; case TOPLEVEL_ACTION_WAIT: data->cmd->waiting++; break; case TOPLEVEL_ACTION_UNSPEC: // unreachable assert(false); } } static void zwlr_foreign_toplevel_handle_v1_handle_closed( void *user_data, struct zwlr_foreign_toplevel_handle_v1 *toplevel) { struct toplevel_data *data = user_data; zwlr_foreign_toplevel_handle_v1_destroy(toplevel); if (data->cmd->complete || !data->matched) { return; } if (data->cmd->action == TOPLEVEL_ACTION_WAIT) { data->cmd->waiting--; if (data->cmd->waiting <= 0) { data->cmd->complete = true; stop_toplevel(data->cmd->state); } } } static void zwlr_foreign_toplevel_handle_v1_handle_parent( void *user_data, struct zwlr_foreign_toplevel_handle_v1 *toplevel, struct zwlr_foreign_toplevel_handle_v1 *parent) { struct toplevel_data *data = user_data; data->parent = parent; } static struct zwlr_foreign_toplevel_handle_v1_listener zwlr_foreign_toplevel_handle_v1_listener = { .title = zwlr_foreign_toplevel_handle_v1_handle_title, .app_id = zwlr_foreign_toplevel_handle_v1_handle_app_id, .output_enter = noop, .output_leave = noop, .state = zwlr_foreign_toplevel_handle_v1_handle_state, .done = zwlr_foreign_toplevel_handle_v1_handle_done, .closed = zwlr_foreign_toplevel_handle_v1_handle_closed, .parent = zwlr_foreign_toplevel_handle_v1_handle_parent, }; static void zwlr_foreign_toplevel_manager_v1_handle_toplevel( void *data, struct zwlr_foreign_toplevel_manager_v1 *manager, struct zwlr_foreign_toplevel_handle_v1 *toplevel ) { struct wlrctl *state = data; struct wlrctl_toplevel_command *cmd = state->cmd; struct toplevel_data *toplevel_data = toplevel_data_create(cmd); zwlr_foreign_toplevel_handle_v1_add_listener( toplevel, &zwlr_foreign_toplevel_handle_v1_listener, toplevel_data ); } static void zwlr_foreign_toplevel_manager_v1_handle_finished( void *data, struct zwlr_foreign_toplevel_manager_v1 *manager ) { struct wlrctl *state = data; state->running = false; destroy_toplevel(state); } static struct zwlr_foreign_toplevel_manager_v1_listener zwlr_foreign_toplevel_manager_v1_listener = { .toplevel = zwlr_foreign_toplevel_manager_v1_handle_toplevel, .finished = zwlr_foreign_toplevel_manager_v1_handle_finished, }; void prepare_toplevel(struct wlrctl *state, int argc, char *argv[]) { struct wlrctl_toplevel_command *cmd = calloc(1, sizeof (struct wlrctl_toplevel_command)); assert(cmd); wl_list_init(&cmd->toplevels); matchspec_init(&cmd->matchspec); if (argc == 0) { die("Missing toplevel action\n"); } char *action = argv[0]; cmd->action = parse_action(action); if (!cmd->action) { die("Unknown toplevel action: '%s'\n", action); } for (int i = 1; i < argc; i++) { matchspec_add_match(&cmd->matchspec, argv[i]); } state->cmd = cmd; cmd->state = state; } void stop_toplevel(struct wlrctl *state) { zwlr_foreign_toplevel_manager_v1_stop(state->ftl_mgr); } void complete_toplevel(void *data, struct wl_callback *callback, uint32_t serial) { struct wlrctl *state = data; struct wlrctl_toplevel_command *cmd = state->cmd; wl_callback_destroy(callback); if (cmd->action == TOPLEVEL_ACTION_WAITFOR || (cmd->action == TOPLEVEL_ACTION_WAIT && (cmd->waiting > 0))) { return; } if (!cmd->complete) { cmd->complete = true; cmd->state->failed = !cmd->any; stop_toplevel(state); } } static struct wl_callback_listener complete_listener = { .done = complete_toplevel }; void run_toplevel(struct wlrctl *state) { struct wlrctl_toplevel_command *cmd = state->cmd; zwlr_foreign_toplevel_manager_v1_add_listener( state->ftl_mgr, &zwlr_foreign_toplevel_manager_v1_listener, state ); if (cmd->action == TOPLEVEL_ACTION_LIST) { stop_toplevel(state); } else { struct wl_callback *complete = wl_display_sync(state->display); wl_callback_add_listener(complete, &complete_listener, state); } } void destroy_toplevel(struct wlrctl *state) { struct wlrctl_toplevel_command *cmd = state->cmd; matchspec_release(&cmd->matchspec); // Release toplevels struct toplevel_data *data, *tmp; wl_list_for_each_safe(data, tmp, &cmd->toplevels, link) { wl_list_remove(&data->link); toplevel_data_destroy(data); } free(cmd); } 0707010000001B000081A400000000000000000000000164632F3500000283000000000000000000000000000000000000001600000000wlrctl-0.2.2~0/util.c#define _POSIX_C_SOURCE 200112L #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> #include <time.h> #include "util.h" int matchtok(const struct token tokens[], const char *name) { const struct token *tok; for (tok = tokens; tok->name != NULL; tok++) { if (strcmp(tok->name, name) == 0) { break; } } return tok->value; } int timestamp() { struct timespec tp; clock_gettime(CLOCK_MONOTONIC, &tp); int ms = 1000 * tp.tv_sec + tp.tv_nsec / 1000000; return ms; } void die(const char *fmt, ...) { va_list args; va_start(args, fmt); vfprintf(stderr, fmt, args); va_end(args); exit(EXIT_FAILURE); } 0707010000001C000081A400000000000000000000000164632F3500000B6B000000000000000000000000000000000000001C00000000wlrctl-0.2.2~0/wlrctl.1.scdwlrctl(1) # NAME wlrctl - A command line utility for miscellaneous wlroots extensions # SYNOPSIS wlrctl [options...] [command] # OPTIONS *-h, --help* Show a help message and quit. *-v, --version* Show the wlrctl version and quit. # COMMANDS *keyboard* <action> Use a virtual keyboard. *pointer* <action> Use a virtual pointer device. *window|toplevel* <action> Use the foreign toplevel interface. *output* { <action> | <identifier> [config_action] } Use the output management interface. # KEYBOARD ACTIONS *type* <string> [modifiers ...] Send a string to be typed into the focused client *modifiers* <SHIFT,CTRL,ALT,SUPER> Comma-separated list of modifiers that will be depressed on the virtual keyboard while string is being typed. # POINTER ACTIONS *click* [button] Click a mouse button. If unspecified, clicks the default (left) button. *move* <dx> <dy> Move the cursor. _dx_ is the displacement in positive-right direction, _dy_ is the displacement in the positive-downward direction. Negative numbers are allowed. Units are pixels. *scroll* <dy> <dx> Scroll the cursor. _dy_ is the amount of vertical scroll, _dx_ is the amount of horizontal scroll. Negative numbers are allowed. # TOPLEVEL ACTIONS *minimize* [matches...] Instruct the compositor to minimize matching windows. *maximize* [matches...] Instruct the compositor to maximize matching windows. *fullscreen* [matches...] Instruct the compositor to fullscreen matching windows. *focus* [matches...] Instruct the compositor to focus matching windows. *find* [matches...] Exit with a successful return code iff there is at least one window matching the provided criteria. *wait* [matches...] Wait to return a successful return code until all the matching windows have closed. If there are no matches, exit with a failing return code immediately. *waitfor* [matches...] Wait to return a successful return code until there is at least one window that matches the requested criteria. # OUTPUT ACTIONS *list* List the names of all known outputs # TOPLEVEL MATCHSPEC A match is a colon separated attribute/value pair. e.g. To match a firefox window, a suitable match value is _app\_id:firefox_. You may give any number of match specifiers, and a window must match all of them to be considered. If the app\_id or title keys are specified more than once, a window may match any of the given values. Otherwise later key value pairs override previous ones. A match without a key is assumed to be an app_id, so just _firefox_ works in the example above. Currently supported attributes are: _app_id_, _title_, and _state_. Supported state values are: _maximized_, _minimized_, _active_, and _fullscreen_, and their negations: _unmaximized_, _unminimized_, _inactive_, and _unfullscreen_. You can also use a '-' prefix, for example _state:-fullscreen_. # AUTHOR Written by Ronan Pigott <rpigott@berkeley.edu> 07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!216 blocks
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
