pax_global_header00006660000000000000000000000064146314447410014522gustar00rootroot0000000000000052 comment=8b2381126319b8e50bcd697b6a7be5bf0ee7e226 wmenu-0.1.9/000077500000000000000000000000001463144474100126645ustar00rootroot00000000000000wmenu-0.1.9/.gitignore000066400000000000000000000000061463144474100146500ustar00rootroot00000000000000build wmenu-0.1.9/LICENSE000066400000000000000000000030361463144474100136730ustar00rootroot00000000000000MIT/X Consortium License © 2006-2019 Anselm R Garbe © 2006-2008 Sander van Dijk © 2006-2007 Michał Janeczek © 2007 Kris Maglione © 2009 Gottox © 2009 Markus Schnalke © 2009 Evan Gates © 2010-2012 Connor Lane Smith © 2014-2020 Hiltjo Posthuma © 2015-2019 Quentin Rameau © 2018-2019 Henrik Nyman © 2022 adnano 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. wmenu-0.1.9/README.md000066400000000000000000000007601463144474100141460ustar00rootroot00000000000000# wmenu wmenu is an efficient dynamic menu for Sway and wlroots based Wayland compositors. It provides a Wayland-native dmenu replacement which maintains the look and feel of dmenu. ## Installation Dependencies: - cairo - pango - wayland - xkbcommon - scdoc (optional) ``` $ meson build $ ninja -C build # ninja -C build install ``` ## Usage See wmenu(1) To use wmenu with Sway, you can add the following to your configuration file: ``` set $menu wmenu-run bindsym $mod+d exec $menu ``` wmenu-0.1.9/docs/000077500000000000000000000000001463144474100136145ustar00rootroot00000000000000wmenu-0.1.9/docs/meson.build000066400000000000000000000007451463144474100157640ustar00rootroot00000000000000scdoc_dep = dependency('scdoc', version: '>=1.9.2', native: true, required: false) if scdoc_dep.found() scdoc = find_program( scdoc_dep.get_pkgconfig_variable('scdoc'), native: true, ) mandir = get_option('mandir') docs = [ 'wmenu.1', ] foreach path : docs custom_target( path, output: path, input: '@0@.scd'.format(path), capture: true, feed: true, command: [scdoc], install: true, install_dir: '@0@/man1'.format(mandir) ) endforeach endif wmenu-0.1.9/docs/wmenu.1.scd000066400000000000000000000056231463144474100156070ustar00rootroot00000000000000WMENU(1) # NAME wmenu - dynamic menu for Wayland # SYNOPSIS *wmenu* [-biPv] \ [-f _font_] \ [-l _lines_] \ [-o _output_] \ [-p _prompt_] \ [-N _color_] [-n _color_] \ [-M _color_] [-m _color_] \ [-S _color_] [-s _color_] *wmenu-run* ... # DESCRIPTION *wmenu* is a dynamic menu for Wayland, which reads a list of newline-separated items from stdin. When the user selects an item and presses Return, their choice is printed to stdout and wmenu terminates. Entering text will narrow the items to those matching the tokens in the input. *wmenu-run* is a special invocation of wmenu which lists programs in the user's $PATH and runs the result. # OPTIONS *-b* wmenu appears at the bottom of the screen. *-i* wmenu matches menu items case insensitively. *-P* wmenu will not directly display the keyboard input, but instead replace it with asterisks. *-v* prints version information to stdout, then exits. *-f* _font_ defines the font used. For more information, see https://docs.gtk.org/Pango/type_func.FontDescription.from_string.html *-l* _lines_ wmenu lists items vertically, with the given number of lines. *-o* _output_ wmenu is displayed on the output with the given name. *-p* _prompt_ defines the prompt to be displayed to the left of the input field. *-N* _RRGGBB[AA]_ defines the normal background color. *-n* _RRGGBB[AA]_ defines the normal foreground color. *-M* _RRGGBB[AA]_ defines the prompt background color. *-m* _RRGGBB[AA]_ defines the prompt foreground color. *-S* _RRGGBB[AA]_ defines the selection background color. *-s* _RRGGBB[AA]_ defines the selection foreground color. # USAGE wmenu is completely controlled by the keyboard. Items are selected using the arrow keys, page up, page down, home, and end. *Tab* Copy the selected item to the input field. *Return* Confirm selection. Prints the selected item to stdout and exits, returning success. *Ctrl-Return* Confirm selection. Prints the selected item to stdout and continues. *Shift-Return* Confirm input. Prints the input text to stdout and exits, returning success. *Escape* Exit without selecting an item, returning failure. *Ctrl-Left* Move cursor to the start of the current word. *Ctrl-Right* Move cursor to the end of the current word. |[ *C-a* :< Home |[ *C-b* :< Left |[ *C-c* :< Escape |[ *C-d* :< Delete |[ *C-e* :< End |[ *C-f* :< Right |[ *C-g* :< Escape |[ *C-[* :< Escape |[ *C-h* :< Backspace |[ *C-i* :< Tab |[ *C-j* :< Return |[ *C-J* :< Shift-Return |[ *C-k* :< Delete line right |[ *C-m* :< Return |[ *C-M* :< Shift-Return |[ *C-n* :< Down |[ *C-p* :< Up |[ *C-u* :< Delete line left |[ *C-w* :< Delete word left |[ *C-Y* :< Paste from Wayland clipboard |[ *M-b* :< Move cursor to the start of the current word |[ *M-f* :< Move cursor to the end of the current word |[ *M-g* :< Home |[ *M-G* :< End |[ *M-h* :< Up |[ *M-j* :< Page down |[ *M-k* :< Page up |[ *M-l* :< Down wmenu-0.1.9/menu.c000066400000000000000000000361401463144474100140000ustar00rootroot00000000000000#define _POSIX_C_SOURCE 200809L #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "menu.h" #include "pango.h" #include "render.h" #include "wayland.h" // Creates and returns a new menu. struct menu *menu_create(menu_callback callback) { struct menu *menu = calloc(1, sizeof(struct menu)); menu->strncmp = strncmp; menu->font = "monospace 10"; menu->normalbg = 0x222222ff; menu->normalfg = 0xbbbbbbff; menu->promptbg = 0x005577ff; menu->promptfg = 0xeeeeeeff; menu->selectionbg = 0x005577ff; menu->selectionfg = 0xeeeeeeff; menu->callback = callback; return menu; } static void free_pages(struct menu *menu) { struct page *next = menu->pages; while (next) { struct page *page = next; next = page->next; free(page); } } static void free_item(struct item *item) { free(item->text); free(item); } static void free_items(struct menu *menu) { struct item *next = menu->items; while (next) { struct item *item = next; next = item->next; free_item(item); } } // Destroys the menu, freeing memory associated with it. void menu_destroy(struct menu *menu) { free_pages(menu); free_items(menu); free(menu); } static bool parse_color(const char *color, uint32_t *result) { if (color[0] == '#') { ++color; } size_t len = strlen(color); if ((len != 6 && len != 8) || !isxdigit(color[0]) || !isxdigit(color[1])) { return false; } char *ptr; uint32_t parsed = (uint32_t)strtoul(color, &ptr, 16); if (*ptr != '\0') { return false; } *result = len == 6 ? ((parsed << 8) | 0xFF) : parsed; return true; } // Parse menu options from command line arguments. void menu_getopts(struct menu *menu, int argc, char *argv[]) { const char *usage = "Usage: wmenu [-biPv] [-f font] [-l lines] [-o output] [-p prompt]\n" "\t[-N color] [-n color] [-M color] [-m color] [-S color] [-s color]\n"; int opt; while ((opt = getopt(argc, argv, "bhiPvf:l:o:p:N:n:M:m:S:s:")) != -1) { switch (opt) { case 'b': menu->bottom = true; break; case 'i': menu->strncmp = strncasecmp; break; case 'P': menu->passwd = true; break; case 'v': puts("wmenu " VERSION); exit(EXIT_SUCCESS); case 'f': menu->font = optarg; break; case 'l': menu->lines = atoi(optarg); break; case 'o': menu->output_name = optarg; break; case 'p': menu->prompt = optarg; break; case 'N': if (!parse_color(optarg, &menu->normalbg)) { fprintf(stderr, "Invalid background color: %s", optarg); } break; case 'n': if (!parse_color(optarg, &menu->normalfg)) { fprintf(stderr, "Invalid foreground color: %s", optarg); } break; case 'M': if (!parse_color(optarg, &menu->promptbg)) { fprintf(stderr, "Invalid prompt background color: %s", optarg); } break; case 'm': if (!parse_color(optarg, &menu->promptfg)) { fprintf(stderr, "Invalid prompt foreground color: %s", optarg); } break; case 'S': if (!parse_color(optarg, &menu->selectionbg)) { fprintf(stderr, "Invalid selection background color: %s", optarg); } break; case 's': if (!parse_color(optarg, &menu->selectionfg)) { fprintf(stderr, "Invalid selection foreground color: %s", optarg); } break; default: fprintf(stderr, "%s", usage); exit(EXIT_FAILURE); } } if (optind < argc) { fprintf(stderr, "%s", usage); exit(EXIT_FAILURE); } int height = get_font_height(menu->font); menu->line_height = height + 2; menu->height = menu->line_height; if (menu->lines > 0) { menu->height += menu->height * menu->lines; } menu->padding = height / 2; } // Add an item to the menu. void menu_add_item(struct menu *menu, char *text, bool sort) { struct item *new = calloc(1, sizeof(struct item)); if (!new) { return; } new->text = text; if (sort) { for (struct item **item = &menu->items; *item; item = &(*item)->next) { int result = strcmp(new->text, (*item)->text); if (result == 0) { free_item(new); return; } if (result < 0) { new->next = *item; *item = new; return; } } } if (menu->lastitem) { menu->lastitem->next = new; } else { menu->items = new; } menu->lastitem = new; } static void append_page(struct page *page, struct page **first, struct page **last) { if (*last) { (*last)->next = page; } else { *first = page; } page->prev = *last; page->next = NULL; *last = page; } static void page_items(struct menu *menu) { // Free existing pages while (menu->pages != NULL) { struct page *page = menu->pages; menu->pages = menu->pages->next; free(page); } if (!menu->matches) { return; } // Make new pages if (menu->lines > 0) { struct page *pages_end = NULL; struct item *item = menu->matches; while (item) { struct page *page = calloc(1, sizeof(struct page)); page->first = item; for (int i = 1; item && i <= menu->lines; i++) { item->page = page; page->last = item; item = item->next_match; } append_page(page, &menu->pages, &pages_end); } } else { // Calculate available space int max_width = menu->width - menu->inputw - menu->promptw - menu->left_arrow - menu->right_arrow; struct page *pages_end = NULL; struct item *item = menu->matches; while (item) { struct page *page = calloc(1, sizeof(struct page)); page->first = item; int total_width = 0; int items = 0; while (item) { total_width += item->width + 2 * menu->padding; if (total_width > max_width && items > 0) { break; } items++; item->page = page; page->last = item; item = item->next_match; } append_page(page, &menu->pages, &pages_end); } } } static const char *fstrstr(struct menu *menu, const char *s, const char *sub) { for (size_t len = strlen(sub); *s; s++) { if (!menu->strncmp(s, sub, len)) { return s; } } return NULL; } static void append_match(struct item *item, struct item **first, struct item **last) { if (*last) { (*last)->next_match = item; } else { *first = item; } item->prev_match = *last; item->next_match = NULL; *last = item; } static void match_items(struct menu *menu) { struct item *lexact = NULL, *exactend = NULL; struct item *lprefix = NULL, *prefixend = NULL; struct item *lsubstr = NULL, *substrend = NULL; char buf[sizeof menu->input], *tok; char **tokv = NULL; int i, tokc = 0; size_t tok_len; menu->matches = NULL; menu->matches_end = NULL; menu->sel = NULL; size_t input_len = strlen(menu->input); /* tokenize input by space for matching the tokens individually */ strcpy(buf, menu->input); tok = strtok(buf, " "); while (tok) { tokv = realloc(tokv, (tokc + 1) * sizeof *tokv); if (!tokv) { fprintf(stderr, "could not realloc %zu bytes", (tokc + 1) * sizeof *tokv); exit(EXIT_FAILURE); } tokv[tokc] = tok; tokc++; tok = strtok(NULL, " "); } tok_len = tokc ? strlen(tokv[0]) : 0; struct item *item; for (item = menu->items; item; item = item->next) { for (i = 0; i < tokc; i++) { if (!fstrstr(menu, item->text, tokv[i])) { /* token does not match */ break; } } if (i != tokc) { /* not all tokens match */ continue; } if (!tokc || !menu->strncmp(menu->input, item->text, input_len + 1)) { append_match(item, &lexact, &exactend); } else if (!menu->strncmp(tokv[0], item->text, tok_len)) { append_match(item, &lprefix, &prefixend); } else { append_match(item, &lsubstr, &substrend); } } free(tokv); if (lexact) { menu->matches = lexact; menu->matches_end = exactend; } if (lprefix) { if (menu->matches_end) { menu->matches_end->next_match = lprefix; lprefix->prev_match = menu->matches_end; } else { menu->matches = lprefix; } menu->matches_end = prefixend; } if (lsubstr) { if (menu->matches_end) { menu->matches_end->next_match = lsubstr; lsubstr->prev_match = menu->matches_end; } else { menu->matches = lsubstr; } menu->matches_end = substrend; } page_items(menu); if (menu->pages) { menu->sel = menu->pages->first; } } // Render menu items. void menu_render_items(struct menu *menu) { render_menu(menu); calc_widths(menu); match_items(menu); render_menu(menu); } static void insert(struct menu *menu, const char *text, ssize_t len) { if (strlen(menu->input) + len > sizeof menu->input - 1) { return; } memmove(menu->input + menu->cursor + len, menu->input + menu->cursor, sizeof menu->input - menu->cursor - MAX(len, 0)); if (len > 0 && text != NULL) { memcpy(menu->input + menu->cursor, text, len); } menu->cursor += len; } // Add pasted text to the menu input. void menu_paste(struct menu *menu, const char *text, ssize_t len) { insert(menu, text, len); } static size_t nextrune(struct menu *menu, int incr) { size_t n, len; len = strlen(menu->input); for(n = menu->cursor + incr; n < len && (menu->input[n] & 0xc0) == 0x80; n += incr); return n; } // Move the cursor to the beginning or end of the word, skipping over any preceding whitespace. static void movewordedge(struct menu *menu, int dir) { if (dir < 0) { // Move to beginning of word while (menu->cursor > 0 && menu->input[nextrune(menu, -1)] == ' ') { menu->cursor = nextrune(menu, -1); } while (menu->cursor > 0 && menu->input[nextrune(menu, -1)] != ' ') { menu->cursor = nextrune(menu, -1); } } else { // Move to end of word size_t len = strlen(menu->input); while (menu->cursor < len && menu->input[menu->cursor] == ' ') { menu->cursor = nextrune(menu, +1); } while (menu->cursor < len && menu->input[menu->cursor] != ' ') { menu->cursor = nextrune(menu, +1); } } } // Handle a keypress. void menu_keypress(struct menu *menu, enum wl_keyboard_key_state key_state, xkb_keysym_t sym) { if (key_state != WL_KEYBOARD_KEY_STATE_PRESSED) { return; } struct xkb_state *state = context_get_xkb_state(menu->context); bool ctrl = xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL, XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED); bool meta = xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT, XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED); bool shift = xkb_state_mod_name_is_active(state, XKB_MOD_NAME_SHIFT, XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED); size_t len = strlen(menu->input); if (ctrl) { // Emacs-style line editing bindings switch (sym) { case XKB_KEY_a: sym = XKB_KEY_Home; break; case XKB_KEY_b: sym = XKB_KEY_Left; break; case XKB_KEY_c: sym = XKB_KEY_Escape; break; case XKB_KEY_d: sym = XKB_KEY_Delete; break; case XKB_KEY_e: sym = XKB_KEY_End; break; case XKB_KEY_f: sym = XKB_KEY_Right; break; case XKB_KEY_g: sym = XKB_KEY_Escape; break; case XKB_KEY_bracketleft: sym = XKB_KEY_Escape; break; case XKB_KEY_h: sym = XKB_KEY_BackSpace; break; case XKB_KEY_i: sym = XKB_KEY_Tab; break; case XKB_KEY_j: case XKB_KEY_J: case XKB_KEY_m: case XKB_KEY_M: sym = XKB_KEY_Return; ctrl = false; break; case XKB_KEY_n: sym = XKB_KEY_Down; break; case XKB_KEY_p: sym = XKB_KEY_Up; break; case XKB_KEY_k: // Delete right menu->input[menu->cursor] = '\0'; match_items(menu); render_menu(menu); return; case XKB_KEY_u: // Delete left insert(menu, NULL, 0 - menu->cursor); match_items(menu); render_menu(menu); return; case XKB_KEY_w: // Delete word while (menu->cursor > 0 && menu->input[nextrune(menu, -1)] == ' ') { insert(menu, NULL, nextrune(menu, -1) - menu->cursor); } while (menu->cursor > 0 && menu->input[nextrune(menu, -1)] != ' ') { insert(menu, NULL, nextrune(menu, -1) - menu->cursor); } match_items(menu); render_menu(menu); return; case XKB_KEY_Y: // Paste clipboard if (!context_paste(menu->context)) { return; } match_items(menu); render_menu(menu); return; case XKB_KEY_Left: case XKB_KEY_KP_Left: movewordedge(menu, -1); render_menu(menu); return; case XKB_KEY_Right: case XKB_KEY_KP_Right: movewordedge(menu, +1); render_menu(menu); return; case XKB_KEY_Return: case XKB_KEY_KP_Enter: break; default: return; } } else if (meta) { // Emacs-style line editing bindings switch (sym) { case XKB_KEY_b: movewordedge(menu, -1); render_menu(menu); return; case XKB_KEY_f: movewordedge(menu, +1); render_menu(menu); return; case XKB_KEY_g: sym = XKB_KEY_Home; break; case XKB_KEY_G: sym = XKB_KEY_End; break; case XKB_KEY_h: sym = XKB_KEY_Up; break; case XKB_KEY_j: sym = XKB_KEY_Next; break; case XKB_KEY_k: sym = XKB_KEY_Prior; break; case XKB_KEY_l: sym = XKB_KEY_Down; break; default: return; } } char buf[8]; switch (sym) { case XKB_KEY_Return: case XKB_KEY_KP_Enter: if (shift) { menu->callback(menu, menu->input, true); } else { char *text = menu->sel ? menu->sel->text : menu->input; menu->callback(menu, text, !ctrl); } break; case XKB_KEY_Left: case XKB_KEY_KP_Left: case XKB_KEY_Up: case XKB_KEY_KP_Up: if (menu->sel && menu->sel->prev_match) { menu->sel = menu->sel->prev_match; render_menu(menu); } else if (menu->cursor > 0) { menu->cursor = nextrune(menu, -1); render_menu(menu); } break; case XKB_KEY_Right: case XKB_KEY_KP_Right: case XKB_KEY_Down: case XKB_KEY_KP_Down: if (menu->cursor < len) { menu->cursor = nextrune(menu, +1); render_menu(menu); } else if (menu->sel && menu->sel->next_match) { menu->sel = menu->sel->next_match; render_menu(menu); } break; case XKB_KEY_Prior: case XKB_KEY_KP_Prior: if (menu->sel && menu->sel->page->prev) { menu->sel = menu->sel->page->prev->first; render_menu(menu); } break; case XKB_KEY_Next: case XKB_KEY_KP_Next: if (menu->sel && menu->sel->page->next) { menu->sel = menu->sel->page->next->first; render_menu(menu); } break; case XKB_KEY_Home: case XKB_KEY_KP_Home: if (menu->sel == menu->matches) { menu->cursor = 0; render_menu(menu); } else { menu->sel = menu->matches; render_menu(menu); } break; case XKB_KEY_End: case XKB_KEY_KP_End: if (menu->cursor < len) { menu->cursor = len; render_menu(menu); } else { menu->sel = menu->matches_end; render_menu(menu); } break; case XKB_KEY_BackSpace: if (menu->cursor > 0) { insert(menu, NULL, nextrune(menu, -1) - menu->cursor); match_items(menu); render_menu(menu); } break; case XKB_KEY_Delete: case XKB_KEY_KP_Delete: if (menu->cursor == len) { return; } menu->cursor = nextrune(menu, +1); insert(menu, NULL, nextrune(menu, -1) - menu->cursor); match_items(menu); render_menu(menu); break; case XKB_KEY_Tab: if (!menu->sel) { return; } menu->cursor = strnlen(menu->sel->text, sizeof menu->input - 1); memcpy(menu->input, menu->sel->text, menu->cursor); menu->input[menu->cursor] = '\0'; match_items(menu); render_menu(menu); break; case XKB_KEY_Escape: menu->exit = true; menu->failure = true; break; default: if (xkb_keysym_to_utf8(sym, buf, 8)) { insert(menu, buf, strnlen(buf, 8)); match_items(menu); render_menu(menu); } } } wmenu-0.1.9/menu.h000066400000000000000000000044111463144474100140010ustar00rootroot00000000000000#ifndef WMENU_MENU_H #define WMENU_MENU_H #include #include #include #include struct menu; typedef void (*menu_callback)(struct menu *menu, char *text, bool exit); // A menu item. struct item { char *text; int width; struct item *next; // traverses all items struct item *prev_match; // previous matching item struct item *next_match; // next matching item struct page *page; // the page holding this item }; // A page of menu items. struct page { struct item *first; // first item in the page struct item *last; // last item in the page struct page *prev; // previous page struct page *next; // next page }; // Menu state. struct menu { // Whether the menu appears at the bottom of the screen bool bottom; // The function used to match menu items int (*strncmp)(const char *, const char *, size_t); // Whether the input is a password bool passwd; // The font used to display the menu char *font; // The number of lines to list items vertically int lines; // The name of the output to display on char *output_name; // The prompt displayed to the left of the input field char *prompt; // Normal colors uint32_t normalbg, normalfg; // Prompt colors uint32_t promptbg, promptfg; // Selection colors uint32_t selectionbg, selectionfg; struct wl_context *context; int width; int height; int line_height; int padding; int inputw; int promptw; int left_arrow; int right_arrow; char input[BUFSIZ]; size_t cursor; struct item *items; // list of all items struct item *lastitem; // last item in the list struct item *matches; // list of matching items struct item *matches_end; // last matching item struct item *sel; // selected item struct page *pages; // list of pages menu_callback callback; bool exit; bool failure; }; struct menu *menu_create(menu_callback callback); void menu_destroy(struct menu *menu); void menu_getopts(struct menu *menu, int argc, char *argv[]); void menu_add_item(struct menu *menu, char *text, bool sort); void menu_render_items(struct menu *menu); void menu_paste(struct menu *menu, const char *text, ssize_t len); void menu_keypress(struct menu *menu, enum wl_keyboard_key_state key_state, xkb_keysym_t sym); #endif wmenu-0.1.9/meson.build000066400000000000000000000023251463144474100150300ustar00rootroot00000000000000project( 'wmenu', 'c', version: '0.1.9', license: 'MIT', default_options: [ 'c_std=c11', 'warning_level=2', 'werror=true', ] ) cc = meson.get_compiler('c') add_project_arguments(cc.get_supported_arguments([ '-DVERSION="@0@"'.format(meson.project_version()), '-Wno-missing-field-initializers', '-Wno-unused-parameter', '-Wundef', '-Wvla', ]), language : 'c') cairo = dependency('cairo') pango = dependency('pango') pangocairo = dependency('pangocairo') wayland_client = dependency('wayland-client') wayland_protos = dependency('wayland-protocols') xkbcommon = dependency('xkbcommon') rt = cc.find_library('rt') subdir('protocols') subdir('docs') executable( 'wmenu', files( 'menu.c', 'pango.c', 'pool-buffer.c', 'render.c', 'wayland.c', 'wmenu.c', ), dependencies: [ cairo, client_protos, pango, pangocairo, rt, wayland_client, wayland_protos, xkbcommon, ], install: true, ) executable( 'wmenu-run', files( 'menu.c', 'pango.c', 'pool-buffer.c', 'render.c', 'wayland.c', 'wmenu-run.c', ), dependencies: [ cairo, client_protos, pango, pangocairo, rt, wayland_client, wayland_protos, xkbcommon, ], install: true, ) wmenu-0.1.9/pango.c000066400000000000000000000047031463144474100141400ustar00rootroot00000000000000#include #include #include #include #include #include #include "pango.h" int get_font_height(const char *fontstr) { PangoFontMap *fontmap = pango_cairo_font_map_get_default(); PangoContext *context = pango_font_map_create_context(fontmap); PangoFontDescription *desc = pango_font_description_from_string(fontstr); PangoFont *font = pango_font_map_load_font(fontmap, context, desc); if (font == NULL) { pango_font_description_free(desc); g_object_unref(context); return -1; } PangoFontMetrics *metrics = pango_font_get_metrics(font, NULL); int height = pango_font_metrics_get_height(metrics) / PANGO_SCALE; pango_font_metrics_unref(metrics); g_object_unref(font); pango_font_description_free(desc); g_object_unref(context); return height; } PangoLayout *get_pango_layout(cairo_t *cairo, const char *font, const char *text, double scale) { PangoLayout *layout = pango_cairo_create_layout(cairo); PangoAttrList *attrs = pango_attr_list_new(); pango_layout_set_text(layout, text, -1); pango_attr_list_insert(attrs, pango_attr_scale_new(scale)); PangoFontDescription *desc = pango_font_description_from_string(font); pango_layout_set_font_description(layout, desc); pango_layout_set_single_paragraph_mode(layout, 1); pango_layout_set_attributes(layout, attrs); pango_font_description_free(desc); pango_attr_list_unref(attrs); return layout; } void get_text_size(cairo_t *cairo, const char *font, int *width, int *height, int *baseline, double scale, const char *text) { PangoLayout *layout = get_pango_layout(cairo, font, text, scale); pango_cairo_update_layout(cairo, layout); pango_layout_get_pixel_size(layout, width, height); if (baseline) { *baseline = pango_layout_get_baseline(layout) / PANGO_SCALE; } g_object_unref(layout); } int text_width(cairo_t *cairo, const char *font, const char *text) { int text_width; get_text_size(cairo, font, &text_width, NULL, NULL, 1, text); return text_width; } void pango_printf(cairo_t *cairo, const char *font, double scale, const char *text) { PangoLayout *layout = get_pango_layout(cairo, font, text, scale); cairo_font_options_t *fo = cairo_font_options_create(); cairo_get_font_options(cairo, fo); pango_cairo_context_set_font_options(pango_layout_get_context(layout), fo); cairo_font_options_destroy(fo); pango_cairo_update_layout(cairo, layout); pango_cairo_show_layout(cairo, layout); g_object_unref(layout); } wmenu-0.1.9/pango.h000066400000000000000000000010461463144474100141420ustar00rootroot00000000000000#ifndef WMENU_PANGO_H #define WMENU_PANGO_H #include #include #include int get_font_height(const char *font); PangoLayout *get_pango_layout(cairo_t *cairo, const char *font, const char *text, double scale); void get_text_size(cairo_t *cairo, const char *font, int *width, int *height, int *baseline, double scale, const char *text); int text_width(cairo_t *cairo, const char *font, const char *text); void pango_printf(cairo_t *cairo, const char *font, double scale, const char *text); #endif wmenu-0.1.9/pool-buffer.c000066400000000000000000000064111463144474100152520ustar00rootroot00000000000000#define _POSIX_C_SOURCE 200809L #include #include #include #include #include #include #include #include #include #include #include #include #include "pool-buffer.h" static void randname(char *buf) { struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); long r = ts.tv_nsec; for (int i = 0; i < 6; ++i) { buf[i] = 'A'+(r&15)+(r&16)*2; r >>= 5; } } static int anonymous_shm_open(void) { char name[] = "/wmenu-XXXXXX"; int retries = 100; do { randname(name + strlen(name) - 6); --retries; // shm_open guarantees that O_CLOEXEC is set int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600); if (fd >= 0) { shm_unlink(name); return fd; } } while (retries > 0 && errno == EEXIST); return -1; } static int create_shm_file(off_t size) { int fd = anonymous_shm_open(); if (fd < 0) { return fd; } if (ftruncate(fd, size) < 0) { close(fd); return -1; } return fd; } static void buffer_release(void *data, struct wl_buffer *wl_buffer) { struct pool_buffer *buffer = data; buffer->busy = false; } static const struct wl_buffer_listener buffer_listener = { .release = buffer_release }; static struct pool_buffer *create_buffer(struct wl_shm *shm, struct pool_buffer *buf, int32_t width, int32_t height, int32_t scale, uint32_t format) { int32_t stride = width * scale * 4; int32_t size = stride * height * scale; int fd = create_shm_file(size); assert(fd != -1); void *data = mmap(NULL, (size_t)size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); struct wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size); buf->buffer = wl_shm_pool_create_buffer(pool, 0, width * scale, height * scale, stride, format); wl_shm_pool_destroy(pool); close(fd); buf->size = (size_t)size; buf->width = width; buf->height = height; buf->scale = scale; buf->data = data; buf->surface = cairo_image_surface_create_for_data(data, CAIRO_FORMAT_ARGB32, width * scale, height * scale, stride); cairo_surface_set_device_scale(buf->surface, scale, scale); buf->cairo = cairo_create(buf->surface); buf->pango = pango_cairo_create_context(buf->cairo); wl_buffer_add_listener(buf->buffer, &buffer_listener, buf); return buf; } void destroy_buffer(struct pool_buffer *buffer) { if (buffer->buffer) { wl_buffer_destroy(buffer->buffer); } if (buffer->cairo) { cairo_destroy(buffer->cairo); } if (buffer->surface) { cairo_surface_destroy(buffer->surface); } if (buffer->pango) { g_object_unref(buffer->pango); } if (buffer->data) { munmap(buffer->data, buffer->size); } memset(buffer, 0, sizeof(struct pool_buffer)); } struct pool_buffer *get_next_buffer(struct wl_shm *shm, struct pool_buffer pool[static 2], int32_t width, int32_t height, int32_t scale) { struct pool_buffer *buffer = NULL; for (size_t i = 0; i < 2; ++i) { if (pool[i].busy) { continue; } buffer = &pool[i]; } if (!buffer) { return NULL; } if (buffer->width != width || buffer->height != height || buffer->scale != scale) { destroy_buffer(buffer); } if (!buffer->buffer) { if (!create_buffer(shm, buffer, width, height, scale, WL_SHM_FORMAT_ARGB8888)) { return NULL; } } buffer->busy = true; return buffer; } wmenu-0.1.9/pool-buffer.h000066400000000000000000000011251463144474100152540ustar00rootroot00000000000000/* Taken from sway. MIT licensed */ #ifndef WMENU_POOL_BUFFER_H #define WMENU_POOL_BUFFER_H #include #include #include #include #include struct pool_buffer { struct wl_buffer *buffer; cairo_surface_t *surface; cairo_t *cairo; PangoContext *pango; size_t size; int32_t width, height, scale; bool busy; void *data; }; struct pool_buffer *get_next_buffer(struct wl_shm *shm, struct pool_buffer pool[static 2], int32_t width, int32_t height, int32_t scale); void destroy_buffer(struct pool_buffer *buffer); #endif wmenu-0.1.9/protocols/000077500000000000000000000000001463144474100147105ustar00rootroot00000000000000wmenu-0.1.9/protocols/meson.build000066400000000000000000000024351463144474100170560ustar00rootroot00000000000000wl_protocol_dir = wayland_protos.get_pkgconfig_variable('pkgdatadir') wayland_scanner_dep = dependency('wayland-scanner', required: false, native: true) if wayland_scanner_dep.found() wayland_scanner = find_program( wayland_scanner_dep.get_pkgconfig_variable('wayland_scanner'), native: true, ) else wayland_scanner = find_program('wayland-scanner', native: true) endif protocols = [ [wl_protocol_dir, 'stable/xdg-shell/xdg-shell.xml'], [wl_protocol_dir, 'staging/xdg-activation/xdg-activation-v1.xml'], ['wlr-layer-shell-unstable-v1.xml'], ] wl_protos_src = [] wl_protos_headers = [] foreach p : protocols xml = join_paths(p) wl_protos_src += custom_target( xml.underscorify() + '_protocol_c', input: xml, output: '@BASENAME@-protocol.c', command: [wayland_scanner, 'private-code', '@INPUT@', '@OUTPUT@'], ) wl_protos_headers += custom_target( xml.underscorify() + '_client_h', input: xml, output: '@BASENAME@-client-protocol.h', command: [wayland_scanner, 'client-header', '@INPUT@', '@OUTPUT@'], ) endforeach lib_client_protos = static_library( 'client_protos', wl_protos_src + wl_protos_headers, dependencies: wayland_client.partial_dependency(compile_args: true), ) client_protos = declare_dependency( link_with: lib_client_protos, sources: wl_protos_headers, ) wmenu-0.1.9/protocols/wlr-layer-shell-unstable-v1.xml000066400000000000000000000320711463144474100226170ustar00rootroot00000000000000 Copyright © 2017 Drew DeVault Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. The copyright holders make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Clients can use this interface to assign the surface_layer role to wl_surfaces. Such surfaces are assigned to a "layer" of the output and rendered with a defined z-depth respective to each other. They may also be anchored to the edges and corners of a screen and specify input handling semantics. This interface should be suitable for the implementation of many desktop shell components, and a broad number of other applications that interact with the desktop. Create a layer surface for an existing surface. This assigns the role of layer_surface, or raises a protocol error if another role is already assigned. Creating a layer surface from a wl_surface which has a buffer attached or committed is a client error, and any attempts by a client to attach or manipulate a buffer prior to the first layer_surface.configure call must also be treated as errors. You may pass NULL for output to allow the compositor to decide which output to use. Generally this will be the one that the user most recently interacted with. Clients can specify a namespace that defines the purpose of the layer surface. These values indicate which layers a surface can be rendered in. They are ordered by z depth, bottom-most first. Traditional shell surfaces will typically be rendered between the bottom and top layers. Fullscreen shell surfaces are typically rendered at the top layer. Multiple surfaces can share a single layer, and ordering within a single layer is undefined. An interface that may be implemented by a wl_surface, for surfaces that are designed to be rendered as a layer of a stacked desktop-like environment. Layer surface state (size, anchor, exclusive zone, margin, interactivity) is double-buffered, and will be applied at the time wl_surface.commit of the corresponding wl_surface is called. Sets the size of the surface in surface-local coordinates. The compositor will display the surface centered with respect to its anchors. If you pass 0 for either value, the compositor will assign it and inform you of the assignment in the configure event. You must set your anchor to opposite edges in the dimensions you omit; not doing so is a protocol error. Both values are 0 by default. Size is double-buffered, see wl_surface.commit. Requests that the compositor anchor the surface to the specified edges and corners. If two orthoginal edges are specified (e.g. 'top' and 'left'), then the anchor point will be the intersection of the edges (e.g. the top left corner of the output); otherwise the anchor point will be centered on that edge, or in the center if none is specified. Anchor is double-buffered, see wl_surface.commit. Requests that the compositor avoids occluding an area of the surface with other surfaces. The compositor's use of this information is implementation-dependent - do not assume that this region will not actually be occluded. A positive value is only meaningful if the surface is anchored to an edge, rather than a corner. The zone is the number of surface-local coordinates from the edge that are considered exclusive. Surfaces that do not wish to have an exclusive zone may instead specify how they should interact with surfaces that do. If set to zero, the surface indicates that it would like to be moved to avoid occluding surfaces with a positive excluzive zone. If set to -1, the surface indicates that it would not like to be moved to accommodate for other surfaces, and the compositor should extend it all the way to the edges it is anchored to. For example, a panel might set its exclusive zone to 10, so that maximized shell surfaces are not shown on top of it. A notification might set its exclusive zone to 0, so that it is moved to avoid occluding the panel, but shell surfaces are shown underneath it. A wallpaper or lock screen might set their exclusive zone to -1, so that they stretch below or over the panel. The default value is 0. Exclusive zone is double-buffered, see wl_surface.commit. Requests that the surface be placed some distance away from the anchor point on the output, in surface-local coordinates. Setting this value for edges you are not anchored to has no effect. The exclusive zone includes the margin. Margin is double-buffered, see wl_surface.commit. Set to 1 to request that the seat send keyboard events to this layer surface. For layers below the shell surface layer, the seat will use normal focus semantics. For layers above the shell surface layers, the seat will always give exclusive keyboard focus to the top-most layer which has keyboard interactivity set to true. Layer surfaces receive pointer, touch, and tablet events normally. If you do not want to receive them, set the input region on your surface to an empty region. Events is double-buffered, see wl_surface.commit. This assigns an xdg_popup's parent to this layer_surface. This popup should have been created via xdg_surface::get_popup with the parent set to NULL, and this request must be invoked before committing the popup's initial state. See the documentation of xdg_popup for more details about what an xdg_popup is and how it is used. When a configure event is received, if a client commits the surface in response to the configure event, then the client must make an ack_configure request sometime before the commit request, passing along the serial of the configure event. If the client receives multiple configure events before it can respond to one, it only has to ack the last configure event. A client is not required to commit immediately after sending an ack_configure request - it may even ack_configure several times before its next surface commit. A client may send multiple ack_configure requests before committing, but only the last request sent before a commit indicates which configure event the client really is responding to. This request destroys the layer surface. The configure event asks the client to resize its surface. Clients should arrange their surface for the new states, and then send an ack_configure request with the serial sent in this configure event at some point before committing the new surface. The client is free to dismiss all but the last configure event it received. The width and height arguments specify the size of the window in surface-local coordinates. The size is a hint, in the sense that the client is free to ignore it if it doesn't resize, pick a smaller size (to satisfy aspect ratio or resize in steps of NxM pixels). If the client picks a smaller size and is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the surface will be centered on this axis. If the width or height arguments are zero, it means the client should decide its own window dimension. The closed event is sent by the compositor when the surface will no longer be shown. The output may have been destroyed or the user may have asked for it to be removed. Further changes to the surface will be ignored. The client should destroy the resource after receiving this event, and create a new surface if they so choose. wmenu-0.1.9/render.c000066400000000000000000000153201463144474100143100ustar00rootroot00000000000000#define _POSIX_C_SOURCE 200809L #include #include #include #include "render.h" #include "menu.h" #include "pango.h" #include "pool-buffer.h" #include "wayland.h" // Calculate text widths. void calc_widths(struct menu *menu) { struct wl_context *context = menu->context; struct pool_buffer *current = context_get_current_buffer(context); cairo_t *cairo = current->cairo; // Calculate prompt width if (menu->prompt) { menu->promptw = text_width(cairo, menu->font, menu->prompt) + menu->padding + menu->padding/2; } else { menu->promptw = 0; } // Calculate scroll indicator widths menu->left_arrow = text_width(cairo, menu->font, "<") + 2 * menu->padding; menu->right_arrow = text_width(cairo, menu->font, ">") + 2 * menu->padding; // Calculate item widths and input area width for (struct item *item = menu->items; item; item = item->next) { item->width = text_width(cairo, menu->font, item->text); if (item->width > menu->inputw) { menu->inputw = item->width; } } } static void cairo_set_source_u32(cairo_t *cairo, uint32_t color) { cairo_set_source_rgba(cairo, (color >> (3*8) & 0xFF) / 255.0, (color >> (2*8) & 0xFF) / 255.0, (color >> (1*8) & 0xFF) / 255.0, (color >> (0*8) & 0xFF) / 255.0); } // Renders text to cairo. static int render_text(struct menu *menu, cairo_t *cairo, const char *str, int x, int y, int width, uint32_t bg_color, uint32_t fg_color, int left_padding, int right_padding) { int text_width, text_height; get_text_size(cairo, menu->font, &text_width, &text_height, NULL, 1, str); int text_y = (menu->line_height / 2.0) - (text_height / 2.0); if (width == 0) { width = text_width + left_padding + right_padding; } if (bg_color) { cairo_set_source_u32(cairo, bg_color); cairo_rectangle(cairo, x, y, width, menu->line_height); cairo_fill(cairo); } cairo_move_to(cairo, x + left_padding, y + text_y); cairo_set_source_u32(cairo, fg_color); pango_printf(cairo, menu->font, 1, str); return width; } // Renders the prompt message. static void render_prompt(struct menu *menu, cairo_t *cairo) { if (!menu->prompt) { return; } render_text(menu, cairo, menu->prompt, 0, 0, 0, menu->promptbg, menu->promptfg, menu->padding, menu->padding/2); } // Renders the input text. static void render_input(struct menu *menu, cairo_t *cairo) { char *censort = NULL; if (menu->passwd) { censort = calloc(1, sizeof(menu->input)); if (!censort) { return; } memset(censort, '*', strlen(menu->input)); } render_text(menu, cairo, menu->passwd ? censort : menu->input, menu->promptw, 0, 0, 0, menu->normalfg, menu->padding, menu->padding); if (censort) { free(censort); } } // Renders a cursor for the input field. static void render_cursor(struct menu *menu, cairo_t *cairo) { const int cursor_width = 2; const int cursor_margin = 2; int cursor_pos = menu->promptw + menu->padding + text_width(cairo, menu->font, menu->input) - text_width(cairo, menu->font, &menu->input[menu->cursor]) - cursor_width / 2; cairo_rectangle(cairo, cursor_pos, cursor_margin, cursor_width, menu->line_height - 2 * cursor_margin); cairo_fill(cairo); } // Renders a single menu item horizontally. static int render_horizontal_item(struct menu *menu, cairo_t *cairo, struct item *item, int x) { uint32_t bg_color = menu->sel == item ? menu->selectionbg : menu->normalbg; uint32_t fg_color = menu->sel == item ? menu->selectionfg : menu->normalfg; return render_text(menu, cairo, item->text, x, 0, 0, bg_color, fg_color, menu->padding, menu->padding); } // Renders a single menu item vertically. static int render_vertical_item(struct menu *menu, cairo_t *cairo, struct item *item, int x, int y) { uint32_t bg_color = menu->sel == item ? menu->selectionbg : menu->normalbg; uint32_t fg_color = menu->sel == item ? menu->selectionfg : menu->normalfg; render_text(menu, cairo, item->text, x, y, menu->width - x, bg_color, fg_color, menu->padding, 0); return menu->line_height; } // Renders a page of menu items horizontally. static void render_horizontal_page(struct menu *menu, cairo_t *cairo, struct page *page) { int x = menu->promptw + menu->inputw + menu->left_arrow; for (struct item *item = page->first; item != page->last->next_match; item = item->next_match) { x += render_horizontal_item(menu, cairo, item, x); } // Draw left and right scroll indicators if necessary if (page->prev) { cairo_move_to(cairo, menu->promptw + menu->inputw + menu->padding, 0); pango_printf(cairo, menu->font, 1, "<"); } if (page->next) { cairo_move_to(cairo, menu->width - menu->right_arrow + menu->padding, 0); pango_printf(cairo, menu->font, 1, ">"); } } // Renders a page of menu items vertically. static void render_vertical_page(struct menu *menu, cairo_t *cairo, struct page *page) { int x = menu->promptw; int y = menu->line_height; for (struct item *item = page->first; item != page->last->next_match; item = item->next_match) { y += render_vertical_item(menu, cairo, item, x, y); } } // Renders the menu to cairo. static void render_to_cairo(struct menu *menu, cairo_t *cairo) { // Render background cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE); cairo_set_source_u32(cairo, menu->normalbg); cairo_paint(cairo); // Render prompt and input render_prompt(menu, cairo); render_input(menu, cairo); render_cursor(menu, cairo); // Render selected page if (!menu->sel) { return; } if (menu->lines > 0) { render_vertical_page(menu, cairo, menu->sel->page); } else { render_horizontal_page(menu, cairo, menu->sel->page); } } // Renders a single frame of the menu. void render_menu(struct menu *menu) { struct wl_context *context = menu->context; cairo_surface_t *recorder = cairo_recording_surface_create( CAIRO_CONTENT_COLOR_ALPHA, NULL); cairo_t *cairo = cairo_create(recorder); cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST); cairo_font_options_t *fo = cairo_font_options_create(); cairo_set_font_options(cairo, fo); cairo_font_options_destroy(fo); cairo_save(cairo); cairo_set_operator(cairo, CAIRO_OPERATOR_CLEAR); cairo_paint(cairo); cairo_restore(cairo); render_to_cairo(menu, cairo); int scale = context_get_scale(context); struct pool_buffer *buffer = context_get_next_buffer(context, scale); if (!buffer) { goto cleanup; } cairo_t *shm = buffer->cairo; cairo_save(shm); cairo_set_operator(shm, CAIRO_OPERATOR_CLEAR); cairo_paint(shm); cairo_restore(shm); cairo_set_source_surface(shm, recorder, 0, 0); cairo_paint(shm); struct wl_surface *surface = context_get_surface(context); wl_surface_set_buffer_scale(surface, scale); wl_surface_attach(surface, buffer->buffer, 0, 0); wl_surface_damage(surface, 0, 0, menu->width, menu->height); wl_surface_commit(surface); cleanup: cairo_destroy(cairo); cairo_surface_destroy(recorder); } wmenu-0.1.9/render.h000066400000000000000000000002241463144474100143120ustar00rootroot00000000000000#ifndef WMENU_RENDER_H #define WMENU_RENDER_H #include "menu.h" void calc_widths(struct menu *menu); void render_menu(struct menu *menu); #endif wmenu-0.1.9/wayland.c000066400000000000000000000362451463144474100145010ustar00rootroot00000000000000#define _POSIX_C_SOURCE 200809L #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "menu.h" #include "pool-buffer.h" #include "wayland.h" #include "xdg-activation-v1-client-protocol.h" #include "wlr-layer-shell-unstable-v1-client-protocol.h" // A Wayland output. struct output { struct wl_context *context; struct wl_output *output; const char *name; // output name int32_t scale; // output scale struct output *next; // next output }; // Creates and returns a new output. static struct output *output_create(struct wl_context *context, struct wl_output *wl_output) { struct output *output = calloc(1, sizeof(struct output)); output->context = context; output->output = wl_output; output->scale = 1; return output; } // Keyboard state. struct keyboard { struct menu *menu; struct wl_keyboard *keyboard; struct xkb_context *context; struct xkb_keymap *keymap; struct xkb_state *state; int repeat_timer; int repeat_delay; int repeat_period; enum wl_keyboard_key_state repeat_key_state; xkb_keysym_t repeat_sym; }; // Creates and returns a new keyboard. static struct keyboard *keyboard_create(struct menu *menu, struct wl_keyboard *wl_keyboard) { struct keyboard *keyboard = calloc(1, sizeof(struct keyboard)); keyboard->menu = menu; keyboard->keyboard = wl_keyboard; keyboard->context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); assert(keyboard->context != NULL); keyboard->repeat_timer = timerfd_create(CLOCK_MONOTONIC, 0); assert(keyboard->repeat_timer != -1); return keyboard; } // Frees the keyboard. static void free_keyboard(struct keyboard *keyboard) { wl_keyboard_release(keyboard->keyboard); xkb_state_unref(keyboard->state); xkb_keymap_unref(keyboard->keymap); xkb_context_unref(keyboard->context); free(keyboard); } // Wayland context. struct wl_context { struct menu *menu; struct wl_display *display; struct wl_registry *registry; struct wl_compositor *compositor; struct wl_shm *shm; struct wl_seat *seat; struct wl_data_device_manager *data_device_manager; struct zwlr_layer_shell_v1 *layer_shell; struct output *output_list; struct xdg_activation_v1 *activation; struct keyboard *keyboard; struct wl_data_device *data_device; struct wl_surface *surface; struct zwlr_layer_surface_v1 *layer_surface; struct wl_data_offer *data_offer; struct output *output; struct pool_buffer buffers[2]; struct pool_buffer *current; }; // Returns the current output_scale. int context_get_scale(struct wl_context *context) { return context->output ? context->output->scale : 1; } // Returns the current buffer from the pool. struct pool_buffer *context_get_current_buffer(struct wl_context *context) { return context->current; } // Returns the next buffer from the pool. struct pool_buffer *context_get_next_buffer(struct wl_context *context, int scale) { struct menu *menu = context->menu; context->current = get_next_buffer(context->shm, context->buffers, menu->width, menu->height, scale); return context->current; } // Returns the Wayland surface for the context. struct wl_surface *context_get_surface(struct wl_context *context) { return context->surface; } // Returns the XKB state for the context. struct xkb_state *context_get_xkb_state(struct wl_context *context) { return context->keyboard->state; } // Returns the XDG activation object for the context. struct xdg_activation_v1 *context_get_xdg_activation(struct wl_context *context) { return context->activation; } // Retrieves pasted text from a Wayland data offer. bool context_paste(struct wl_context *context) { if (!context->data_offer) { return false; } int fds[2]; if (pipe(fds) == -1) { // Pipe failed return false; } wl_data_offer_receive(context->data_offer, "text/plain", fds[1]); close(fds[1]); wl_display_roundtrip(context->display); while (true) { char buf[1024]; ssize_t n = read(fds[0], buf, sizeof(buf)); if (n <= 0) { break; } menu_paste(context->menu, buf, n); } close(fds[0]); wl_data_offer_destroy(context->data_offer); context->data_offer = NULL; return true; } // Adds an output to the output list. static void context_add_output(struct wl_context *context, struct output *output) { output->next = context->output_list; context->output_list = output; } // Frees the outputs. static void free_outputs(struct wl_context *context) { struct output *next = context->output_list; while (next) { struct output *output = next; next = output->next; wl_output_destroy(output->output); free(output); } } // Destroys the Wayland context, freeing memory associated with it. static void context_destroy(struct wl_context *context) { wl_registry_destroy(context->registry); wl_compositor_destroy(context->compositor); wl_shm_destroy(context->shm); wl_seat_destroy(context->seat); wl_data_device_manager_destroy(context->data_device_manager); zwlr_layer_shell_v1_destroy(context->layer_shell); free_outputs(context); free_keyboard(context->keyboard); wl_data_device_destroy(context->data_device); wl_surface_destroy(context->surface); zwlr_layer_surface_v1_destroy(context->layer_surface); xdg_activation_v1_destroy(context->activation); wl_display_disconnect(context->display); free(context); } static void noop() { // Do nothing } static void surface_enter(void *data, struct wl_surface *surface, struct wl_output *wl_output) { struct wl_context *context = data; context->output = wl_output_get_user_data(wl_output); } static const struct wl_surface_listener surface_listener = { .enter = surface_enter, .leave = noop, }; static void layer_surface_configure(void *data, struct zwlr_layer_surface_v1 *surface, uint32_t serial, uint32_t width, uint32_t height) { struct wl_context *context = data; context->menu->width = width; context->menu->height = height; zwlr_layer_surface_v1_ack_configure(surface, serial); } static void layer_surface_closed(void *data, struct zwlr_layer_surface_v1 *surface) { struct wl_context *context = data; context->menu->exit = true; } static const struct zwlr_layer_surface_v1_listener layer_surface_listener = { .configure = layer_surface_configure, .closed = layer_surface_closed, }; static void output_scale(void *data, struct wl_output *wl_output, int32_t factor) { struct output *output = data; output->scale = factor; } static void output_name(void *data, struct wl_output *wl_output, const char *name) { struct output *output = data; output->name = name; struct wl_context *context = output->context; if (context->menu->output_name && strcmp(context->menu->output_name, name) == 0) { context->output = output; } } static const struct wl_output_listener output_listener = { .geometry = noop, .mode = noop, .done = noop, .scale = output_scale, .name = output_name, .description = noop, }; static void keyboard_keymap(void *data, struct wl_keyboard *wl_keyboard, uint32_t format, int32_t fd, uint32_t size) { struct keyboard *keyboard = data; assert(format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1); char *map_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0); assert(map_shm != MAP_FAILED); keyboard->keymap = xkb_keymap_new_from_string(keyboard->context, map_shm, XKB_KEYMAP_FORMAT_TEXT_V1, 0); munmap(map_shm, size); close(fd); keyboard->state = xkb_state_new(keyboard->keymap); } static void keyboard_repeat(struct keyboard *keyboard) { menu_keypress(keyboard->menu, keyboard->repeat_key_state, keyboard->repeat_sym); struct itimerspec spec = { 0 }; spec.it_value.tv_sec = keyboard->repeat_period / 1000; spec.it_value.tv_nsec = (keyboard->repeat_period % 1000) * 1000000l; timerfd_settime(keyboard->repeat_timer, 0, &spec, NULL); } static void keyboard_key(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t _key_state) { struct keyboard *keyboard = data; enum wl_keyboard_key_state key_state = _key_state; xkb_keysym_t sym = xkb_state_key_get_one_sym(keyboard->state, key + 8); menu_keypress(keyboard->menu, key_state, sym); if (key_state == WL_KEYBOARD_KEY_STATE_PRESSED && keyboard->repeat_period >= 0) { keyboard->repeat_key_state = key_state; keyboard->repeat_sym = sym; struct itimerspec spec = { 0 }; spec.it_value.tv_sec = keyboard->repeat_delay / 1000; spec.it_value.tv_nsec = (keyboard->repeat_delay % 1000) * 1000000l; timerfd_settime(keyboard->repeat_timer, 0, &spec, NULL); } else if (key_state == WL_KEYBOARD_KEY_STATE_RELEASED) { struct itimerspec spec = { 0 }; timerfd_settime(keyboard->repeat_timer, 0, &spec, NULL); } } static void keyboard_repeat_info(void *data, struct wl_keyboard *wl_keyboard, int32_t rate, int32_t delay) { struct keyboard *keyboard = data; keyboard->repeat_delay = delay; if (rate > 0) { keyboard->repeat_period = 1000 / rate; } else { keyboard->repeat_period = -1; } } static void keyboard_modifiers(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) { struct keyboard *keyboard = data; xkb_state_update_mask(keyboard->state, mods_depressed, mods_latched, mods_locked, 0, 0, group); } static const struct wl_keyboard_listener keyboard_listener = { .keymap = keyboard_keymap, .enter = noop, .leave = noop, .key = keyboard_key, .modifiers = keyboard_modifiers, .repeat_info = keyboard_repeat_info, }; static void seat_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps) { struct wl_context *context = data; if (caps & WL_SEAT_CAPABILITY_KEYBOARD) { struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(seat); struct keyboard *keyboard = keyboard_create(context->menu, wl_keyboard); wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, keyboard); context->keyboard = keyboard; } } static const struct wl_seat_listener seat_listener = { .capabilities = seat_capabilities, .name = noop, }; static void data_device_selection(void *data, struct wl_data_device *data_device, struct wl_data_offer *data_offer) { struct wl_context *context = data; context->data_offer = data_offer; } static const struct wl_data_device_listener data_device_listener = { .data_offer = noop, .enter = noop, .leave = noop, .motion = noop, .drop = noop, .selection = data_device_selection, }; static void handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) { struct wl_context *context = data; if (strcmp(interface, wl_compositor_interface.name) == 0) { context->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 4); } else if (strcmp(interface, wl_shm_interface.name) == 0) { context->shm = wl_registry_bind(registry, name, &wl_shm_interface, 1); } else if (strcmp(interface, wl_seat_interface.name) == 0) { context->seat = wl_registry_bind(registry, name, &wl_seat_interface, 4); wl_seat_add_listener(context->seat, &seat_listener, data); } else if (strcmp(interface, wl_data_device_manager_interface.name) == 0) { context->data_device_manager = wl_registry_bind(registry, name, &wl_data_device_manager_interface, 3); } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) { context->layer_shell = wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1); } else if (strcmp(interface, wl_output_interface.name) == 0) { struct wl_output *wl_output = wl_registry_bind(registry, name, &wl_output_interface, 4); struct output *output = output_create(context, wl_output); wl_output_set_user_data(wl_output, output); wl_output_add_listener(wl_output, &output_listener, output); context_add_output(context, output); } else if (strcmp(interface, xdg_activation_v1_interface.name) == 0) { context->activation = wl_registry_bind(registry, name, &xdg_activation_v1_interface, 1); } } static const struct wl_registry_listener registry_listener = { .global = handle_global, .global_remove = noop, }; // Connect to the Wayland display and run the menu. int menu_run(struct menu *menu) { struct wl_context *context = calloc(1, sizeof(struct wl_context)); context->menu = menu; menu->context = context; context->display = wl_display_connect(NULL); if (!context->display) { fprintf(stderr, "Failed to connect to display.\n"); exit(EXIT_FAILURE); } struct wl_registry *registry = wl_display_get_registry(context->display); wl_registry_add_listener(registry, ®istry_listener, context); wl_display_roundtrip(context->display); assert(context->compositor != NULL); assert(context->shm != NULL); assert(context->seat != NULL); assert(context->data_device_manager != NULL); assert(context->layer_shell != NULL); assert(context->activation != NULL); context->registry = registry; // Get data device for seat struct wl_data_device *data_device = wl_data_device_manager_get_data_device( context->data_device_manager, context->seat); wl_data_device_add_listener(data_device, &data_device_listener, context); context->data_device = data_device; // Second roundtrip for seat and output listeners wl_display_roundtrip(context->display); assert(context->keyboard != NULL); if (menu->output_name && !context->output) { fprintf(stderr, "Output %s not found\n", menu->output_name); exit(EXIT_FAILURE); } context->surface = wl_compositor_create_surface(context->compositor); wl_surface_add_listener(context->surface, &surface_listener, context); struct zwlr_layer_surface_v1 *layer_surface = zwlr_layer_shell_v1_get_layer_surface( context->layer_shell, context->surface, context->output ? context->output->output : NULL, ZWLR_LAYER_SHELL_V1_LAYER_TOP, "menu" ); assert(layer_surface != NULL); context->layer_surface = layer_surface; uint32_t anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; if (menu->bottom) { anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; } else { anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; } zwlr_layer_surface_v1_set_anchor(layer_surface, anchor); zwlr_layer_surface_v1_set_size(layer_surface, 0, menu->height); zwlr_layer_surface_v1_set_exclusive_zone(layer_surface, -1); zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface, true); zwlr_layer_surface_v1_add_listener(layer_surface, &layer_surface_listener, context); wl_surface_commit(context->surface); wl_display_roundtrip(context->display); menu_render_items(menu); struct pollfd fds[] = { { wl_display_get_fd(context->display), POLLIN }, { context->keyboard->repeat_timer, POLLIN }, }; const size_t nfds = sizeof(fds) / sizeof(*fds); while (!menu->exit) { errno = 0; do { if (wl_display_flush(context->display) == -1 && errno != EAGAIN) { fprintf(stderr, "wl_display_flush: %s\n", strerror(errno)); break; } } while (errno == EAGAIN); if (poll(fds, nfds, -1) < 0) { fprintf(stderr, "poll: %s\n", strerror(errno)); break; } if (fds[0].revents & POLLIN) { if (wl_display_dispatch(context->display) < 0) { menu->exit = true; } } if (fds[1].revents & POLLIN) { keyboard_repeat(context->keyboard); } } context_destroy(context); menu->context = NULL; if (menu->failure) { return EXIT_FAILURE; } return EXIT_SUCCESS; } wmenu-0.1.9/wayland.h000066400000000000000000000012051463144474100144720ustar00rootroot00000000000000#ifndef WMENU_WAYLAND_H #define WMENU_WAYLAND_H #include "menu.h" #include struct wl_context; int menu_run(struct menu *menu); int context_get_scale(struct wl_context *context); struct pool_buffer *context_get_current_buffer(struct wl_context *context); struct pool_buffer *context_get_next_buffer(struct wl_context *context, int scale); struct wl_surface *context_get_surface(struct wl_context *context); struct xkb_state *context_get_xkb_state(struct wl_context *context); struct xdg_activation_v1 *context_get_xdg_activation(struct wl_context *context); bool context_paste(struct wl_context *context); #endif wmenu-0.1.9/wmenu-run.c000066400000000000000000000040501463144474100147640ustar00rootroot00000000000000#define _POSIX_C_SOURCE 200809L #include #include #include #include #include #include "menu.h" #include "wayland.h" #include "xdg-activation-v1-client-protocol.h" static void read_items(struct menu *menu) { char *path = strdup(getenv("PATH")); for (char *p = strtok(path, ":"); p != NULL; p = strtok(NULL, ":")) { DIR *dir = opendir(p); if (dir == NULL) { continue; } for (struct dirent *ent = readdir(dir); ent != NULL; ent = readdir(dir)) { if (ent->d_name[0] == '.') { continue; } menu_add_item(menu, strdup(ent->d_name), true); } closedir(dir); } free(path); } struct command { struct menu *menu; char *text; bool exit; }; static void activation_token_done(void *data, struct xdg_activation_token_v1 *activation_token, const char *token) { struct command *cmd = data; xdg_activation_token_v1_destroy(activation_token); int pid = fork(); if (pid == 0) { setenv("XDG_ACTIVATION_TOKEN", token, true); char *argv[] = {"/bin/sh", "-c", cmd->text, NULL}; execvp(argv[0], (char**)argv); } else { if (cmd->exit) { cmd->menu->exit = true; } } } static const struct xdg_activation_token_v1_listener activation_token_listener = { .done = activation_token_done, }; static void exec_item(struct menu *menu, char *text, bool exit) { struct command *cmd = calloc(1, sizeof(struct command)); cmd->menu = menu; cmd->text = strdup(text); cmd->exit = exit; struct xdg_activation_v1 *activation = context_get_xdg_activation(menu->context); struct xdg_activation_token_v1 *activation_token = xdg_activation_v1_get_activation_token(activation); xdg_activation_token_v1_set_surface(activation_token, context_get_surface(menu->context)); xdg_activation_token_v1_add_listener(activation_token, &activation_token_listener, cmd); xdg_activation_token_v1_commit(activation_token); } int main(int argc, char *argv[]) { struct menu *menu = menu_create(exec_item); menu_getopts(menu, argc, argv); read_items(menu); int status = menu_run(menu); menu_destroy(menu); return status; } wmenu-0.1.9/wmenu.c000066400000000000000000000012451463144474100141650ustar00rootroot00000000000000#define _POSIX_C_SOURCE 200809L #include #include #include "menu.h" #include "wayland.h" static void read_items(struct menu *menu) { char buf[sizeof menu->input]; while (fgets(buf, sizeof buf, stdin)) { char *p = strchr(buf, '\n'); if (p) { *p = '\0'; } menu_add_item(menu, strdup(buf), false); } } static void print_item(struct menu *menu, char *text, bool exit) { puts(text); fflush(stdout); if (exit) { menu->exit = true; } } int main(int argc, char *argv[]) { struct menu *menu = menu_create(print_item); menu_getopts(menu, argc, argv); read_items(menu); int status = menu_run(menu); menu_destroy(menu); return status; }