diff options
Diffstat (limited to 'main.c')
| -rw-r--r-- | main.c | 983 |
1 files changed, 983 insertions, 0 deletions
@@ -0,0 +1,983 @@ +#define _POSIX_C_SOURCE 200809L +#include <assert.h> +#include <ctype.h> +#include <cairo/cairo.h> +#include <errno.h> +#include <poll.h> +#include <stdbool.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <strings.h> +#include <time.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/timerfd.h> +#include <wayland-client.h> +#include <wayland-client-protocol.h> +#include <xkbcommon/xkbcommon.h> + +#include "pango.h" +#include "pool-buffer.h" +#include "wlr-layer-shell-unstable-v1-client-protocol.h" +#include "xdg-output-unstable-v1-client-protocol.h" + +struct menu_item { + char *text; + int width; + struct menu_item *next; // traverses all items + struct menu_item *left, *right; // traverses matching items +}; + +struct output { + struct menu_state *menu; + struct wl_output *output; + struct zxdg_output_v1 *xdg_output; + int32_t scale; +}; + +struct menu_state { + struct output *output; + char *output_name; + + struct wl_display *display; + struct wl_compositor *compositor; + struct wl_shm *shm; + struct wl_seat *seat; + struct wl_keyboard *keyboard; + struct zwlr_layer_shell_v1 *layer_shell; + struct zxdg_output_manager_v1 *output_manager; + + struct wl_surface *surface; + struct zwlr_layer_surface_v1 *layer_surface; + + struct xkb_context *xkb_context; + struct xkb_keymap *xkb_keymap; + struct xkb_state *xkb_state; + + struct pool_buffer buffers[2]; + struct pool_buffer *current; + + int width; + int height; + int padding; + int inputw; + int promptw; + int left_arrow, right_arrow; + + bool bottom; + int (*fstrncmp)(const char *, const char *, size_t); + char *font; + int lines; + char *prompt; + uint32_t background, foreground; + uint32_t promptbg, promptfg; + uint32_t selectionbg, selectionfg; + + char text[BUFSIZ]; + size_t cursor; + + int repeat_timer; + int repeat_delay; + int repeat_period; + enum wl_keyboard_key_state repeat_key_state; + xkb_keysym_t repeat_sym; + + bool run; + bool failure; + + struct menu_item *items; + struct menu_item *matches; + struct menu_item *selection; + struct menu_item *leftmost, *rightmost; +}; + +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); +} + +static void insert(struct menu_state *state, const char *s, ssize_t n); +static void match(struct menu_state *state); +static size_t nextrune(struct menu_state *state, int incr); + +int render_text(struct menu_state *state, cairo_t *cairo, const char *str, + int x, int y, int width, int height, + uint32_t foreground, uint32_t background, + int left_padding, int right_padding) { + + int text_width, text_height; + get_text_size(cairo, state->font, &text_width, &text_height, NULL, 1, str); + int text_y = (state->height / 2.0) - (text_height / 2.0); + + if (x + left_padding + text_width > width) { + return -1; + } else { + if (background) { + int bg_width = text_width + left_padding + right_padding; + cairo_set_source_u32(cairo, background); + cairo_rectangle(cairo, x, 0, bg_width, height); + cairo_fill(cairo); + } + + cairo_move_to(cairo, x + left_padding, text_y); + cairo_set_source_u32(cairo, foreground); + pango_printf(cairo, state->font, 1, str); + } + + return x + text_width + left_padding + right_padding; +} + +void scroll_matches(struct menu_state *state) { + if (!state->matches) { + return; + } + + // Calculate available space + int padding = state->padding; + int width = state->width - state->inputw - state->promptw + - state->left_arrow - state->right_arrow; + if (state->leftmost == NULL) { + state->leftmost = state->matches; + if (state->rightmost == NULL) { + int offs = 0; + struct menu_item *item; + for (item = state->matches; item->left != state->selection; item = item->right) { + offs += item->width + 2 * padding; + if (offs >= width) { + state->leftmost = item->left; + offs = width - offs; + } + } + } else { + int offs = 0; + struct menu_item *item; + for (item = state->rightmost; item; item = item->left) { + offs += item->width + 2 * padding; + if (offs >= width) { + state->leftmost = item->right; + break; + } + } + } + } + if (state->rightmost == NULL) { + state->rightmost = state->matches; + int offs = 0; + struct menu_item *item; + for (item = state->leftmost; item; item = item->right) { + offs += item->width + 2 * padding; + if (offs >= width) { + break; + } + state->rightmost = item; + } + } +} + +void render_to_cairo(struct menu_state *state, cairo_t *cairo) { + int width = state->width; + int height = state->height; + int padding = state->padding; + + int text_height; + get_text_size(cairo, state->font, NULL, &text_height, NULL, 1, ""); + int y = (height / 2.0) - (text_height / 2.0); + + cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE); + cairo_set_source_u32(cairo, state->background); + cairo_paint(cairo); + + int x = 0; + + // Draw prompt + if (state->prompt) { + state->promptw = render_text(state, cairo, state->prompt, + 0, y, state->width, state->height, + state->promptfg, state->promptbg, + padding, padding/2); + x += state->promptw; + } + + // Draw background + cairo_set_source_u32(cairo, state->background); + cairo_rectangle(cairo, x, 0, 300, height); + cairo_fill(cairo); + + // Draw input + render_text(state, cairo, state->text, + x, y, state->width, state->height, + state->foreground, 0, padding, padding); + + // Draw cursor + { + int cursor_width = 2; + int cursor_margin = 2; + int cursor_pos = x + padding + + text_width(cairo, state->font, state->text) + - text_width(cairo, state->font, &state->text[state->cursor]) + - cursor_width / 2; + cairo_rectangle(cairo, cursor_pos, cursor_margin, cursor_width, + state->height - 2 * cursor_margin); + cairo_fill(cairo); + } + + if (!state->matches) { + return; + } + + // Leave room for input + x += state->inputw; + + // Calculate scroll indicator widths + state->left_arrow = text_width(cairo, state->font, "<") + 2 * padding; + state->right_arrow = text_width(cairo, state->font, ">") + 2 * padding; + + // Remember scroll indicator position + int left_arrow_pos = x + padding; + x += state->left_arrow; + + // Draw matches + bool scroll_right = false; + struct menu_item *item; + for (item = state->leftmost; item; item = item->right) { + uint32_t bg_color = state->selection == item ? state->selectionbg : state->background; + uint32_t fg_color = state->selection == item ? state->selectionfg : state->foreground; + x = render_text(state, cairo, item->text, + x, y, width - state->right_arrow, height, + fg_color, bg_color, padding, padding); + if (x == -1) { + scroll_right = true; + break; + } + } + + // Draw left scroll indicator if necessary + if (state->leftmost != state->matches) { + cairo_move_to(cairo, left_arrow_pos, y); + pango_printf(cairo, state->font, 1, "<"); + } + + // Draw right scroll indicator if necessary + if (scroll_right) { + cairo_move_to(cairo, width - state->right_arrow + padding, y); + pango_printf(cairo, state->font, 1, ">"); + } +} + +void render_frame(struct menu_state *state) { + 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(state, cairo); + + int scale = state->output ? state->output->scale : 1; + state->current = get_next_buffer(state->shm, + state->buffers, state->width, state->height, scale); + if (!state->current) { + goto cleanup; + } + + cairo_t *shm = state->current->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); + + wl_surface_attach(state->surface, state->current->buffer, 0, 0); + wl_surface_damage(state->surface, 0, 0, state->width, state->height); + wl_surface_commit(state->surface); + +cleanup: + cairo_destroy(cairo); +} + +static void noop() { + // Do nothing +} + +static void surface_enter(void *data, struct wl_surface *surface, + struct wl_output *wl_output) { + struct menu_state *state = data; + state->output = wl_output_get_user_data(wl_output); + wl_surface_set_buffer_scale(state->surface, state->output->scale); + wl_surface_commit(state->surface); + render_frame(state); +} + +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 menu_state *state = data; + state->width = width; + state->height = height; + zwlr_layer_surface_v1_ack_configure(surface, serial); +} + +static void layer_surface_closed(void *data, + struct zwlr_layer_surface_v1 *surface) { + struct menu_state *state = data; + state->run = false; +} + +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 zxdg_output_v1 *xdg_output, + const char *name) { + struct output *output = data; + struct menu_state *state = output->menu; + char *outname = state->output_name; + if (!state->output && outname && strcmp(outname, name) == 0) { + state->output = output; + } +} + +struct wl_output_listener output_listener = { + .geometry = noop, + .mode = noop, + .done = noop, + .scale = output_scale, +}; + +static void keyboard_keymap(void *data, struct wl_keyboard *wl_keyboard, + uint32_t format, int32_t fd, uint32_t size) { + struct menu_state *state = data; + if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) { + close(fd); + state->run = false; + state->failure = true; + return; + } + char *map_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0); + if (map_shm == MAP_FAILED) { + close(fd); + state->run = false; + state->failure = true; + return; + } + state->xkb_keymap = xkb_keymap_new_from_string(state->xkb_context, + map_shm, XKB_KEYMAP_FORMAT_TEXT_V1, 0); + munmap(map_shm, size); + close(fd); + state->xkb_state = xkb_state_new(state->xkb_keymap); +} + +void keypress(struct menu_state *state, enum wl_keyboard_key_state key_state, + xkb_keysym_t sym) { + if (key_state != WL_KEYBOARD_KEY_STATE_PRESSED) { + return; + } + + bool ctrl = xkb_state_mod_name_is_active(state->xkb_state, + XKB_MOD_NAME_CTRL, + XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED); + bool shift = xkb_state_mod_name_is_active(state->xkb_state, + XKB_MOD_NAME_SHIFT, + XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED); + + char buf[8]; + size_t len = strlen(state->text); + switch (sym) { + case XKB_KEY_KP_Enter: + case XKB_KEY_Return: + if (shift) { + puts(state->text); + fflush(stdout); + state->run = false; + } else { + char *text = state->selection ? state->selection->text + : state->text; + puts(text); + fflush(stdout); + if (!ctrl) { + state->run = false; + } + } + break; + case XKB_KEY_Left: + if (state->cursor && (!state->selection || !state->selection->left)) { + state->cursor = nextrune(state, -1); + render_frame(state); + } + if (state->selection && state->selection->left) { + if (state->selection == state->leftmost) { + state->rightmost = state->selection->left; + state->leftmost = NULL; + } + state->selection = state->selection->left; + scroll_matches(state); + render_frame(state); + } + break; + case XKB_KEY_Right: + if (state->cursor < len) { + state->cursor = nextrune(state, +1); + render_frame(state); + } else if (state->cursor == len) { + if (state->selection && state->selection->right) { + if (state->selection == state->rightmost) { + state->leftmost = state->selection->right; + state->rightmost = NULL; + } + state->selection = state->selection->right; + scroll_matches(state); + render_frame(state); + } + } + break; + case XKB_KEY_Page_Up: + if (state->leftmost && state->leftmost->left) { + state->rightmost = state->leftmost->left; + state->leftmost = NULL; + scroll_matches(state); + state->selection = state->leftmost; + render_frame(state); + } + break; + case XKB_KEY_Page_Down: + if (state->rightmost && state->rightmost->right) { + state->leftmost = state->rightmost->right; + state->rightmost = NULL; + state->selection = state->leftmost; + scroll_matches(state); + render_frame(state); + } + break; + case XKB_KEY_Home: + if (state->selection == state->matches) { + if (state->cursor != 0) { + state->cursor = 0; + render_frame(state); + } + } else { + state->selection = state->matches; + state->leftmost = state->matches; + state->rightmost = NULL; + scroll_matches(state); + render_frame(state); + } + break; + case XKB_KEY_End: + if (state->cursor < len) { + state->cursor = len; + render_frame(state); + } else { + if (!state->selection || !state->selection->right) { + return; + } + while (state->selection && state->selection->right) { + state->selection = state->selection->right; + } + state->leftmost = NULL; + state->rightmost = state->selection; + scroll_matches(state); + render_frame(state); + } + break; + case XKB_KEY_BackSpace: + if (state->cursor > 0) { + insert(state, NULL, nextrune(state, -1) - state->cursor); + render_frame(state); + } + break; + case XKB_KEY_Delete: + if (state->cursor == len) { + return; + } + state->cursor = nextrune(state, +1); + insert(state, NULL, nextrune(state, -1) - state->cursor); + render_frame(state); + break; + case XKB_KEY_Tab: + if (!state->selection) { + return; + } + strncpy(state->text, state->selection->text, sizeof state->text); + state->cursor = strlen(state->text); + match(state); + render_frame(state); + break; + case XKB_KEY_Escape: + state->failure = true; + state->run = false; + break; + default: + if (xkb_keysym_to_utf8(sym, buf, 8)) { + insert(state, buf, strnlen(buf, 8)); + render_frame(state); + } + } +} + +void keyboard_repeat(struct menu_state *state) { + keypress(state, state->repeat_key_state, state->repeat_sym); + struct itimerspec spec = { 0 }; + spec.it_value.tv_sec = state->repeat_period / 1000; + spec.it_value.tv_nsec = (state->repeat_period % 1000) * 1000000l; + timerfd_settime(state->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 menu_state *state = data; + + enum wl_keyboard_key_state key_state = _key_state; + xkb_keysym_t sym = xkb_state_key_get_one_sym(state->xkb_state, key + 8); + keypress(state, key_state, sym); + + if (key_state == WL_KEYBOARD_KEY_STATE_PRESSED && state->repeat_period >= 0) { + state->repeat_key_state = key_state; + state->repeat_sym = sym; + + struct itimerspec spec = { 0 }; + spec.it_value.tv_sec = state->repeat_delay / 1000; + spec.it_value.tv_nsec = (state->repeat_delay % 1000) * 1000000l; + timerfd_settime(state->repeat_timer, 0, &spec, NULL); + } else if (key_state == WL_KEYBOARD_KEY_STATE_RELEASED) { + struct itimerspec spec = { 0 }; + timerfd_settime(state->repeat_timer, 0, &spec, NULL); + } +} + +static void keyboard_repeat_info(void *data, struct wl_keyboard *wl_keyboard, + int32_t rate, int32_t delay) { + struct menu_state *state = data; + state->repeat_delay = delay; + if (rate > 0) { + state->repeat_period = 1000 / rate; + } else { + state->repeat_period = -1; + } +} + +static void keyboard_modifiers(void *data, struct wl_keyboard *keyboard, + uint32_t serial, uint32_t mods_depressed, + uint32_t mods_latched, uint32_t mods_locked, + uint32_t group) { + struct menu_state *state = data; + xkb_state_update_mask(state->xkb_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 menu_state *state = data; + if (caps & WL_SEAT_CAPABILITY_KEYBOARD) { + state->keyboard = wl_seat_get_keyboard(seat); + wl_keyboard_add_listener(state->keyboard, &keyboard_listener, state); + } +} + +const struct wl_seat_listener seat_listener = { + .capabilities = seat_capabilities, + .name = noop, +}; + +struct zxdg_output_v1_listener xdg_output_listener = { + .logical_position = noop, + .logical_size = noop, + .done = noop, + .name = output_name, + .description = noop, +}; + +static void handle_global(void *data, struct wl_registry *registry, + uint32_t name, const char *interface, uint32_t version) { + struct menu_state *state = data; + if (strcmp(interface, wl_compositor_interface.name) == 0) { + state->compositor = wl_registry_bind(registry, name, + &wl_compositor_interface, 4); + } else if (strcmp(interface, wl_shm_interface.name) == 0) { + state->shm = wl_registry_bind(registry, name, &wl_shm_interface, 1); + } else if (strcmp(interface, wl_seat_interface.name) == 0) { + struct wl_seat *seat = wl_registry_bind(registry, name, + &wl_seat_interface, 4); + wl_seat_add_listener(seat, &seat_listener, state); + } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) { + state->layer_shell = wl_registry_bind(registry, name, + &zwlr_layer_shell_v1_interface, 1); + } else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) { + state->output_manager = wl_registry_bind(registry, name, + &zxdg_output_manager_v1_interface, 3); + } else if (strcmp(interface, wl_output_interface.name) == 0) { + struct output *output = calloc(1, sizeof(struct output)); + output->output = wl_registry_bind(registry, name, + &wl_output_interface, 3); + output->menu = state; + output->scale = 1; + wl_output_set_user_data(output->output, output); + wl_output_add_listener(output->output, &output_listener, output); + if (state->output_manager != NULL) { + output->xdg_output = zxdg_output_manager_v1_get_xdg_output( + state->output_manager, output->output); + zxdg_output_v1_add_listener(output->xdg_output, + &xdg_output_listener, output); + } + } +} + +static const struct wl_registry_listener registry_listener = { + .global = handle_global, + .global_remove = noop, +}; + +void insert(struct menu_state *state, const char *s, ssize_t n) { + if (strlen(state->text) + n > sizeof state->text - 1) { + return; + } + memmove(state->text + state->cursor + n, state->text + state->cursor, + sizeof state->text - state->cursor - MAX(n, 0)); + if (n > 0) { + memcpy(state->text + state->cursor, s, n); + } + state->cursor += n; + match(state); +} + +char * fstrstr(struct menu_state *state, const char *s, const char *sub) { + size_t len; + + for(len = strlen(sub); *s; s++) + if(!state->fstrncmp(s, sub, len)) + return (char *)s; + return NULL; +} + +void append_item(struct menu_item *item, struct menu_item **list, struct menu_item **last) { + if(!*last) + *list = item; + else + (*last)->right = item; + item->left = *last; + item->right = NULL; + *last = item; +} + +void match(struct menu_state *state) { + struct menu_item *item, *itemend, *lexact, *lprefix, *lsubstr, *exactend, *prefixend, *substrend; + + state->matches = NULL; + state->leftmost = NULL; + size_t len = strlen(state->text); + state->matches = lexact = lprefix = lsubstr = itemend = exactend = prefixend = substrend = NULL; + for (item = state->items; item; item = item->next) { + if (!state->fstrncmp(state->text, item->text, len + 1)) { + append_item(item, &lexact, &exactend); + } else if (!state->fstrncmp(state->text, item->text, len)) { + append_item(item, &lprefix, &prefixend); + } else if (fstrstr(state, item->text, state->text)) { + append_item(item, &lsubstr, &substrend); + } + } + + if (lexact) { + state->matches = lexact; + itemend = exactend; + } + if (lprefix) { + if (itemend) { + itemend->right = lprefix; + lprefix->left = itemend; + } else { + state->matches = lprefix; + } + itemend = prefixend; + } + if (lsubstr) { + if (itemend) { + itemend->right = lsubstr; + lsubstr->left = itemend; + itemend = substrend; + } else { + state->matches = lsubstr; + } + } + state->selection = state->matches; + state->leftmost = state->matches; + state->rightmost = NULL; + scroll_matches(state); +} + +size_t nextrune(struct menu_state *state, int incr) { + size_t n, len; + + len = strlen(state->text); + for(n = state->cursor + incr; n < len && (state->text[n] & 0xc0) == 0x80; n += incr); + return n; +} + +void read_stdin(struct menu_state *state) { + char buf[sizeof state->text], *p; + struct menu_item *item, **end; + + for(end = &state->items; fgets(buf, sizeof buf, stdin); *end = item, end = &item->next) { + if((p = strchr(buf, '\n'))) { + *p = '\0'; + } + item = malloc(sizeof *item); + if (!item) { + return; + } + + item->text = strdup(buf); + item->next = item->left = item->right = NULL; + + cairo_t *cairo = state->current->cairo; + item->width = text_width(cairo, state->font, item->text); + if (item->width > state->inputw) { + state->inputw = item->width; + } + } +} + +static void menu_init(struct menu_state *state) { + int height = get_font_height(state->font); + state->height = height + 2; + state->padding = height / 2; + + state->display = wl_display_connect(NULL); + if (!state->display) { + fprintf(stderr, "wl_display_connect: %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + state->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); + if (!state->xkb_context) { + fprintf(stderr, "xkb_context_new: %s\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + state->repeat_timer = timerfd_create(CLOCK_MONOTONIC, 0); + assert(state->repeat_timer >= 0); + + struct wl_registry *registry = wl_display_get_registry(state->display); + wl_registry_add_listener(registry, ®istry_listener, state); + wl_display_roundtrip(state->display); + assert(state->compositor != NULL); + assert(state->layer_shell != NULL); + assert(state->shm != NULL); + assert(state->output_manager != NULL); + + // Second roundtrip for xdg-output + wl_display_roundtrip(state->display); + + if (state->output_name && !state->output) { + fprintf(stderr, "Output %s not found\n", state->output_name); + exit(EXIT_FAILURE); + } +} + +static void menu_create_surface(struct menu_state *state) { + state->surface = wl_compositor_create_surface(state->compositor); + wl_surface_add_listener(state->surface, &surface_listener, state); + state->layer_surface = zwlr_layer_shell_v1_get_layer_surface( + state->layer_shell, + state->surface, + NULL, + ZWLR_LAYER_SHELL_V1_LAYER_TOP, + "menu" + ); + assert(state->layer_surface != NULL); + + uint32_t anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; + if (state->bottom) { + anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; + } else { + anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; + } + + zwlr_layer_surface_v1_set_anchor(state->layer_surface, anchor); + zwlr_layer_surface_v1_set_size(state->layer_surface, 0, state->height); + zwlr_layer_surface_v1_set_exclusive_zone(state->layer_surface, -1); + zwlr_layer_surface_v1_set_keyboard_interactivity(state->layer_surface, true); + zwlr_layer_surface_v1_add_listener(state->layer_surface, + &layer_surface_listener, state); + + wl_surface_commit(state->surface); + wl_display_roundtrip(state->display); +} + +bool parse_color(const char *color, uint32_t *result) { + if (color[0] == '#') { + ++color; + } + int len = strlen(color); + if ((len != 6 && len != 8) || !isxdigit(color[0]) || !isxdigit(color[1])) { + return false; + } + char *ptr; + uint32_t parsed = strtoul(color, &ptr, 16); + if (*ptr != '\0') { + return false; + } + *result = len == 6 ? ((parsed << 8) | 0xFF) : parsed; + return true; +} + +int main(int argc, char **argv) { + struct menu_state state = { + .fstrncmp = strncmp, + .font = "monospace 10", + .background = 0x222222ff, + .foreground = 0xbbbbbbff, + .promptbg = 0x005577ff, + .promptfg = 0xeeeeeeff, + .selectionbg = 0x005577ff, + .selectionfg = 0xeeeeeeff, + .run = true, + }; + + const char *usage = + "Usage: wmenu [-biv] [-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, "bhivf:l:o:p:N:n:M:m:S:s:")) != -1) { + switch (opt) { + case 'b': + state.bottom = true; + break; + case 'i': + state.fstrncmp = strncasecmp; + break; + case 'v': + puts("wmenu " VERSION); + exit(EXIT_SUCCESS); + case 'f': + state.font = optarg; + break; + case 'l': + // TODO + fputs("warning: -l unimplemented\n", stderr); + state.lines = atoi(optarg); + break; + case 'o': + state.output_name = optarg; + break; + case 'p': + state.prompt = optarg; + break; + case 'N': + if (!parse_color(optarg, &state.background)) { + fprintf(stderr, "Invalid background color: %s", optarg); + } + break; + case 'n': + if (!parse_color(optarg, &state.foreground)) { + fprintf(stderr, "Invalid foreground color: %s", optarg); + } + break; + case 'M': + if (!parse_color(optarg, &state.promptbg)) { + fprintf(stderr, "Invalid prompt background color: %s", optarg); + } + break; + case 'm': + if (!parse_color(optarg, &state.promptfg)) { + fprintf(stderr, "Invalid prompt foreground color: %s", optarg); + } + break; + case 'S': + if (!parse_color(optarg, &state.selectionbg)) { + fprintf(stderr, "Invalid selection background color: %s", optarg); + } + break; + case 's': + if (!parse_color(optarg, &state.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); + } + + menu_init(&state); + menu_create_surface(&state); + render_frame(&state); + + read_stdin(&state); + match(&state); + + struct pollfd fds[] = { + { wl_display_get_fd(state.display), POLLIN }, + { state.repeat_timer, POLLIN }, + }; + const int nfds = sizeof(fds) / sizeof(*fds); + + while (state.run) { + errno = 0; + do { + if (wl_display_flush(state.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(state.display) < 0) { + state.run = false; + } + } + + if (fds[1].revents & POLLIN) { + keyboard_repeat(&state); + } + } + + wl_display_disconnect(state.display); + + if (state.failure) { + return EXIT_FAILURE; + } + return EXIT_SUCCESS; +} |