initial commit
This commit is contained in:
sewn
commit
6cef260109
11 changed files with 1960 additions and 0 deletions
4
.gitignore
vendored
Normal file
4
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
mew
|
||||
config.h
|
||||
*.o
|
||||
*-protocol.*
|
||||
34
LICENSE
Normal file
34
LICENSE
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
MIT/X Consortium License
|
||||
|
||||
Copyright (c) 2023-2024 sewn <sewn@disroot.org>
|
||||
Copyright (c) 2015 Eric Pruitt <eric.pruitt@gmail.com>
|
||||
Copyright (c) 2024 Forrest Bushstone <fgb.1@protonmail.com>
|
||||
Copyright (c) 2018-2019 Henrik Nyman <h@nyymanni.com>
|
||||
Copyright (c) 2006-2019 Anselm R Garbe <anselm@garbe.ca>
|
||||
Copyright (c) 2006-2008 Sander van Dijk <a.h.vandijk@gmail.com>
|
||||
Copyright (c) 2006-2007 Michał Janeczek <janeczek@gmail.com>
|
||||
Copyright (c) 2007 Kris Maglione <jg@suckless.org>
|
||||
Copyright (c) 2009 Gottox <gottox@s01.de>
|
||||
Copyright (c) 2009 Markus Schnalke <meillo@marmaro.de>
|
||||
Copyright (c) 2009 Evan Gates <evan.gates@gmail.com>
|
||||
Copyright (c) 2010-2012 Connor Lane Smith <cls@lubutu.com>
|
||||
Copyright (c) 2014-2022 Hiltjo Posthuma <hiltjo@codemadness.org>
|
||||
Copyright (c) 2015-2019 Quentin Rameau <quinq@fifth.space>
|
||||
|
||||
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.
|
||||
69
Makefile
Normal file
69
Makefile
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
# mew - dynamic menu
|
||||
# See LICENSE file for copyright and license details.
|
||||
.POSIX:
|
||||
|
||||
# mew version
|
||||
VERSION = 1.0
|
||||
|
||||
# pkg-config
|
||||
PKG_CONFIG = pkg-config
|
||||
|
||||
# paths
|
||||
PREFIX = /usr/local
|
||||
MANPREFIX = $(PREFIX)/share/man
|
||||
|
||||
# includes and libs
|
||||
PKGS = fcft pixman-1 wayland-client xkbcommon
|
||||
INCS = `$(PKG_CONFIG) --cflags $(PKGS)`
|
||||
LIBS = `$(PKG_CONFIG) --libs $(PKGS)`
|
||||
|
||||
# flags
|
||||
EMCPPFLAGS = -D_POSIX_C_SOURCE=200809L -DVERSION=\"$(VERSION)\"
|
||||
EMCFLAGS = -pedantic -Wall $(INCS) $(EMCPPFLAGS) $(CFLAGS)
|
||||
LDLIBS = $(LIBS)
|
||||
|
||||
all: mew
|
||||
|
||||
.c.o:
|
||||
$(CC) -c $(EMCFLAGS) $<
|
||||
|
||||
config.h:
|
||||
cp config.def.h $@
|
||||
|
||||
mew.o: config.h wlr-layer-shell-unstable-v1-protocol.h xdg-shell-protocol.h
|
||||
|
||||
mew: wlr-layer-shell-unstable-v1-protocol.o xdg-shell-protocol.o mew.o
|
||||
$(CC) $(LDFLAGS) -o $@ wlr-layer-shell-unstable-v1-protocol.o xdg-shell-protocol.o mew.o $(LDLIBS)
|
||||
|
||||
WAYLAND_PROTOCOLS = `$(PKG_CONFIG) --variable=pkgdatadir wayland-protocols`
|
||||
WAYLAND_SCANNER = `$(PKG_CONFIG) --variable=wayland_scanner wayland-scanner`
|
||||
|
||||
xdg-shell-protocol.h:
|
||||
$(WAYLAND_SCANNER) client-header $(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
|
||||
xdg-shell-protocol.c:
|
||||
$(WAYLAND_SCANNER) private-code $(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
|
||||
|
||||
wlr-layer-shell-unstable-v1-protocol.h:
|
||||
$(WAYLAND_SCANNER) client-header wlr-layer-shell-unstable-v1.xml $@
|
||||
wlr-layer-shell-unstable-v1-protocol.c:
|
||||
$(WAYLAND_SCANNER) private-code wlr-layer-shell-unstable-v1.xml $@
|
||||
wlr-layer-shell-unstable-v1-protocol.o: xdg-shell-protocol.o
|
||||
|
||||
clean:
|
||||
rm -f mew *.o *-protocol.*
|
||||
|
||||
install: all
|
||||
mkdir -p $(DESTDIR)$(PREFIX)/bin
|
||||
cp -f mew mew-run $(DESTDIR)$(PREFIX)/bin
|
||||
chmod 755 $(DESTDIR)$(PREFIX)/bin/mew
|
||||
chmod 755 $(DESTDIR)$(PREFIX)/bin/mew-run
|
||||
mkdir -p $(DESTDIR)$(MANPREFIX)/man1
|
||||
sed "s/VERSION/$(VERSION)/g" < mew.1 > $(DESTDIR)$(MANPREFIX)/man1/mew.1
|
||||
chmod 644 $(DESTDIR)$(MANPREFIX)/man1/mew.1
|
||||
|
||||
uninstall:
|
||||
rm -f $(DESTDIR)$(PREFIX)/bin/mew\
|
||||
$(DESTDIR)$(PREFIX)/bin/mew-run\
|
||||
$(DESTDIR)$(MANPREFIX)/man1/mew.1
|
||||
|
||||
.PHONY: all clean install uninstall
|
||||
21
README.md
Normal file
21
README.md
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
# mew
|
||||
mew is a simple menu for Wayland.
|
||||
|
||||
## Building
|
||||
In order to build mew, ensure that you have the following dependencies:
|
||||
|
||||
* fcft
|
||||
* pkg-config
|
||||
* wayland
|
||||
* wayland-protocols
|
||||
* xkbcommon
|
||||
|
||||
Afterwards enter the following command to build and install mew
|
||||
(if necessary as root):
|
||||
```
|
||||
make
|
||||
make install
|
||||
```
|
||||
|
||||
# Usage
|
||||
See the man page for details.
|
||||
21
config.def.h
Normal file
21
config.def.h
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
/* See LICENSE file for copyright and license details. */
|
||||
/* Default settings; can be overriden by command line. */
|
||||
|
||||
static int top = 1; /* -b option; if 0, appear at bottom */
|
||||
static const char *fonts[] = { "monospace:size=10" }; /* -f option overrides fonts[0] */
|
||||
static const char *prompt = NULL; /* -p option; prompt to the left of input field */
|
||||
static uint32_t colors[][2] = {
|
||||
/* fg bg */
|
||||
[SchemeNorm] = { 0xbbbbbbff, 0x222222ff },
|
||||
[SchemeSel] = { 0xeeeeeeff, 0x005577ff },
|
||||
[SchemeOut] = { 0x000000ff, 0x00ffffff },
|
||||
};
|
||||
|
||||
/* -l option; if nonzero, use vertical list with given number of lines */
|
||||
static unsigned int lines = 0;
|
||||
|
||||
/*
|
||||
* Characters not considered part of a word while deleting words
|
||||
* for example: " /?\"&[]"
|
||||
*/
|
||||
static const char worddelimiters[] = " ";
|
||||
306
drwl.h
Normal file
306
drwl.h
Normal file
|
|
@ -0,0 +1,306 @@
|
|||
/*
|
||||
* drwl - https://codeberg.org/sewn/drwl
|
||||
* See LICENSE file for copyright and license details.
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <fcft/fcft.h>
|
||||
#include <pixman-1/pixman.h>
|
||||
|
||||
#define BETWEEN(X, A, B) ((A) <= (X) && (X) <= (B))
|
||||
|
||||
enum { ColFg, ColBg }; /* colorscheme index */
|
||||
|
||||
typedef struct {
|
||||
pixman_image_t *pix;
|
||||
struct fcft_font *font;
|
||||
uint32_t *scheme;
|
||||
} Drwl;
|
||||
|
||||
#define UTF_INVALID 0xFFFD
|
||||
#define UTF_SIZ 4
|
||||
|
||||
static const unsigned char utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0};
|
||||
static const unsigned char utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
|
||||
static const uint32_t utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000};
|
||||
static const uint32_t utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
|
||||
|
||||
static inline uint32_t
|
||||
utf8decodebyte(const char c, size_t *i)
|
||||
{
|
||||
for (*i = 0; *i < (UTF_SIZ + 1); ++(*i))
|
||||
if (((unsigned char)c & utfmask[*i]) == utfbyte[*i])
|
||||
return (unsigned char)c & ~utfmask[*i];
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline size_t
|
||||
utf8decode(const char *c, uint32_t *u)
|
||||
{
|
||||
size_t i, j, len, type;
|
||||
uint32_t udecoded;
|
||||
|
||||
*u = UTF_INVALID;
|
||||
udecoded = utf8decodebyte(c[0], &len);
|
||||
if (!BETWEEN(len, 1, UTF_SIZ))
|
||||
return 1;
|
||||
for (i = 1, j = 1; i < UTF_SIZ && j < len; ++i, ++j) {
|
||||
udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
|
||||
if (type)
|
||||
return j;
|
||||
}
|
||||
if (j < len)
|
||||
return 0;
|
||||
*u = udecoded;
|
||||
if (!BETWEEN(*u, utfmin[len], utfmax[len]) || BETWEEN(*u, 0xD800, 0xDFFF))
|
||||
*u = UTF_INVALID;
|
||||
for (i = 1; *u > utfmax[i]; ++i)
|
||||
;
|
||||
return len;
|
||||
}
|
||||
|
||||
static int
|
||||
drwl_init(void)
|
||||
{
|
||||
fcft_set_scaling_filter(FCFT_SCALING_FILTER_LANCZOS3);
|
||||
return fcft_init(FCFT_LOG_COLORIZE_AUTO, 0, FCFT_LOG_CLASS_ERROR);
|
||||
}
|
||||
|
||||
/*
|
||||
* Caller must call drwl_init before drwl_create, and
|
||||
* drwl_destroy on returned context after finalizing usage.
|
||||
*/
|
||||
static Drwl *
|
||||
drwl_create(void)
|
||||
{
|
||||
Drwl *drwl;
|
||||
|
||||
if (!(drwl = calloc(1, sizeof(Drwl))))
|
||||
return NULL;
|
||||
|
||||
return drwl;
|
||||
}
|
||||
|
||||
static void
|
||||
drwl_setfont(Drwl *drwl, struct fcft_font *font)
|
||||
{
|
||||
if (drwl)
|
||||
drwl->font = font;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returned font is set within the drawing context if given.
|
||||
* Caller must call drwl_destroy_font on returned font when done using it,
|
||||
* otherwise use drwl_destroy when instead given a drwl context.
|
||||
*/
|
||||
static struct fcft_font *
|
||||
drwl_load_font(Drwl *drwl, size_t fontcount,
|
||||
const char *fonts[static fontcount], const char *attributes)
|
||||
{
|
||||
struct fcft_font *font = fcft_from_name(fontcount, fonts, attributes);
|
||||
if (drwl)
|
||||
drwl_setfont(drwl, font);
|
||||
return font;
|
||||
}
|
||||
|
||||
static void
|
||||
drwl_destroy_font(struct fcft_font *font)
|
||||
{
|
||||
fcft_destroy(font);
|
||||
}
|
||||
|
||||
static inline pixman_color_t
|
||||
convert_color(uint32_t clr)
|
||||
{
|
||||
return (pixman_color_t){
|
||||
((clr >> 24) & 0xFF) * 0x101,
|
||||
((clr >> 16) & 0xFF) * 0x101,
|
||||
((clr >> 8) & 0xFF) * 0x101,
|
||||
(clr & 0xFF) * 0x101
|
||||
};
|
||||
}
|
||||
|
||||
static void
|
||||
drwl_setscheme(Drwl *drwl, uint32_t *scm)
|
||||
{
|
||||
if (drwl)
|
||||
drwl->scheme = scm;
|
||||
}
|
||||
|
||||
static inline int
|
||||
drwl_stride(unsigned int width)
|
||||
{
|
||||
return (((PIXMAN_FORMAT_BPP(PIXMAN_a8r8g8b8) * width + 7) / 8 + 4 - 1) & -4);
|
||||
}
|
||||
|
||||
/*
|
||||
* Caller must call drwl_finish_drawing when finished drawing.
|
||||
* Parameter stride can be calculated using drwl_stride.
|
||||
*/
|
||||
static void
|
||||
drwl_prepare_drawing(Drwl *drwl, unsigned int w, unsigned int h,
|
||||
uint32_t *bits, int stride)
|
||||
{
|
||||
pixman_region32_t clip;
|
||||
|
||||
if (!drwl)
|
||||
return;
|
||||
|
||||
drwl->pix = pixman_image_create_bits_no_clear(
|
||||
PIXMAN_a8r8g8b8, w, h, bits, stride);
|
||||
pixman_region32_init_rect(&clip, 0, 0, w, h);
|
||||
pixman_image_set_clip_region32(drwl->pix, &clip);
|
||||
pixman_region32_fini(&clip);
|
||||
}
|
||||
|
||||
static void
|
||||
drwl_rect(Drwl *drwl,
|
||||
int x, int y, unsigned int w, unsigned int h,
|
||||
int filled, int invert)
|
||||
{
|
||||
pixman_color_t clr;
|
||||
if (!drwl || !drwl->scheme || !drwl->pix)
|
||||
return;
|
||||
|
||||
clr = convert_color(drwl->scheme[invert ? ColBg : ColFg]);
|
||||
if (filled)
|
||||
pixman_image_fill_rectangles(PIXMAN_OP_SRC, drwl->pix, &clr, 1,
|
||||
&(pixman_rectangle16_t){x, y, w, h});
|
||||
else
|
||||
pixman_image_fill_rectangles(PIXMAN_OP_SRC, drwl->pix, &clr, 4,
|
||||
(pixman_rectangle16_t[4]){
|
||||
{ x, y, w, 1 },
|
||||
{ x, y + h - 1, w, 1 },
|
||||
{ x, y, 1, h },
|
||||
{ x + w - 1, y, 1, h }});
|
||||
}
|
||||
|
||||
static int
|
||||
drwl_text(Drwl *drwl,
|
||||
int x, int y, unsigned int w, unsigned int h,
|
||||
unsigned int lpad, const char *text, int invert)
|
||||
{
|
||||
int ty;
|
||||
int utf8charlen, render = x || y || w || h;
|
||||
long x_kern;
|
||||
uint32_t cp = 0, last_cp = 0;
|
||||
pixman_color_t clr;
|
||||
pixman_image_t *fg_pix = NULL;
|
||||
int noellipsis = 0;
|
||||
const struct fcft_glyph *glyph, *eg;
|
||||
int fcft_subpixel_mode = FCFT_SUBPIXEL_DEFAULT;
|
||||
|
||||
if (!drwl || (render && (!drwl->scheme || !w || !drwl->pix)) || !text || !drwl->font)
|
||||
return 0;
|
||||
|
||||
if (!render) {
|
||||
w = invert ? invert : ~invert;
|
||||
} else {
|
||||
clr = convert_color(drwl->scheme[invert ? ColBg : ColFg]);
|
||||
fg_pix = pixman_image_create_solid_fill(&clr);
|
||||
|
||||
drwl_rect(drwl, x, y, w, h, 1, !invert);
|
||||
|
||||
x += lpad;
|
||||
w -= lpad;
|
||||
}
|
||||
|
||||
if (render && (drwl->scheme[ColBg] & 0xFF) != 0xFF)
|
||||
fcft_subpixel_mode = FCFT_SUBPIXEL_NONE;
|
||||
|
||||
// U+2026 == …
|
||||
eg = fcft_rasterize_char_utf32(drwl->font, 0x2026, fcft_subpixel_mode);
|
||||
|
||||
while (*text) {
|
||||
utf8charlen = utf8decode(text, &cp);
|
||||
|
||||
glyph = fcft_rasterize_char_utf32(drwl->font, cp, fcft_subpixel_mode);
|
||||
if (!glyph)
|
||||
continue;
|
||||
|
||||
x_kern = 0;
|
||||
if (last_cp)
|
||||
fcft_kerning(drwl->font, last_cp, cp, &x_kern, NULL);
|
||||
last_cp = cp;
|
||||
|
||||
ty = y + (h - drwl->font->height) / 2 + drwl->font->ascent;
|
||||
|
||||
/* draw ellipsis if remaining text doesn't fit */
|
||||
if (!noellipsis && x_kern + glyph->advance.x + eg->advance.x > w && *(text + 1) != '\0') {
|
||||
if (drwl_text(drwl, 0, 0, 0, 0, 0, text, 0)
|
||||
- glyph->advance.x < eg->advance.x) {
|
||||
noellipsis = 1;
|
||||
} else {
|
||||
w -= eg->advance.x;
|
||||
pixman_image_composite32(
|
||||
PIXMAN_OP_OVER, fg_pix, eg->pix, drwl->pix, 0, 0, 0, 0,
|
||||
x + eg->x, ty - eg->y, eg->width, eg->height);
|
||||
}
|
||||
}
|
||||
|
||||
if ((x_kern + glyph->advance.x) > w)
|
||||
break;
|
||||
|
||||
x += x_kern;
|
||||
|
||||
if (render && pixman_image_get_format(glyph->pix) == PIXMAN_a8r8g8b8)
|
||||
// pre-rendered glyphs (eg. emoji)
|
||||
pixman_image_composite32(
|
||||
PIXMAN_OP_OVER, glyph->pix, NULL, drwl->pix, 0, 0, 0, 0,
|
||||
x + glyph->x, ty - glyph->y, glyph->width, glyph->height);
|
||||
else if (render)
|
||||
pixman_image_composite32(
|
||||
PIXMAN_OP_OVER, fg_pix, glyph->pix, drwl->pix, 0, 0, 0, 0,
|
||||
x + glyph->x, ty - glyph->y, glyph->width, glyph->height);
|
||||
|
||||
text += utf8charlen;
|
||||
x += glyph->advance.x;
|
||||
w -= glyph->advance.x;
|
||||
}
|
||||
|
||||
if (render)
|
||||
pixman_image_unref(fg_pix);
|
||||
|
||||
return x + (render ? w : 0);
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
drwl_font_getwidth(Drwl *drwl, const char *text)
|
||||
{
|
||||
if (!drwl || !drwl->font || !text)
|
||||
return 0;
|
||||
return drwl_text(drwl, 0, 0, 0, 0, 0, text, 0);
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
drwl_font_getwidth_clamp(Drwl *drwl, const char *text, unsigned int n)
|
||||
{
|
||||
unsigned int tmp = 0;
|
||||
if (drwl && drwl->font && text && n)
|
||||
tmp = drwl_text(drwl, 0, 0, 0, 0, 0, text, n);
|
||||
return tmp < n ? tmp : n;
|
||||
}
|
||||
|
||||
static void
|
||||
drwl_finish_drawing(Drwl *drwl)
|
||||
{
|
||||
if (drwl && drwl->pix)
|
||||
pixman_image_unref(drwl->pix);
|
||||
}
|
||||
|
||||
static void
|
||||
drwl_destroy(Drwl *drwl)
|
||||
{
|
||||
if (drwl->pix)
|
||||
pixman_image_unref(drwl->pix);
|
||||
if (drwl->font)
|
||||
drwl_destroy_font(drwl->font);
|
||||
free(drwl);
|
||||
}
|
||||
|
||||
static void
|
||||
drwl_fini(void)
|
||||
{
|
||||
fcft_fini();
|
||||
}
|
||||
35
mew-run
Executable file
35
mew-run
Executable file
|
|
@ -0,0 +1,35 @@
|
|||
#!/bin/sh
|
||||
|
||||
cachedir="${XDG_CACHE_HOME:-"$HOME/.cache"}"
|
||||
cache="$cachedir/mew_run"
|
||||
|
||||
[ -d "$cachedir" ] || mkdir -p "$cachedir"
|
||||
|
||||
uptodate() {
|
||||
[ -f "$cache" ] || return 1
|
||||
IFS=:
|
||||
for path in $PATH; do
|
||||
# non-POSIX
|
||||
test "$path" -nt "$cache" && return 1
|
||||
done
|
||||
return 0
|
||||
}
|
||||
|
||||
bins() {
|
||||
IFS=:
|
||||
for path in $PATH; do
|
||||
for bin in "$path"/*; do
|
||||
[ -x "$bin" ] && echo "${bin##*/}"
|
||||
done
|
||||
done
|
||||
}
|
||||
|
||||
path() {
|
||||
if uptodate; then
|
||||
cat "$cache"
|
||||
else
|
||||
bins | sort -u | tee "$cache"
|
||||
fi
|
||||
}
|
||||
|
||||
path | mew "$@" | ${SHELL:-"/bin/sh"} &
|
||||
152
mew.1
Normal file
152
mew.1
Normal file
|
|
@ -0,0 +1,152 @@
|
|||
.TH EMENU 1 mew\-VERSION
|
||||
.SH NAME
|
||||
mew \- menu for wayland
|
||||
.SH SYNOPSIS
|
||||
.B mew
|
||||
.RB [ \-biv ]
|
||||
.RB [ \-l
|
||||
.IR lines ]
|
||||
.RB [ \-p
|
||||
.IR prompt ]
|
||||
.RB [ \-f
|
||||
.IR font ]
|
||||
.RB [ \-nb
|
||||
.IR color ]
|
||||
.RB [ \-nf
|
||||
.IR color ]
|
||||
.RB [ \-sb
|
||||
.IR color ]
|
||||
.RB [ \-sf
|
||||
.IR color ]
|
||||
.P
|
||||
.BR mew-run " ..."
|
||||
.SH DESCRIPTION
|
||||
.B mew
|
||||
is an simple dynamic menu for Wayland that 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 mew terminates. Entering text will narrow the items to those
|
||||
matching the tokens in the input.
|
||||
.P
|
||||
.B mew-run
|
||||
is a script spawned by the compositor that lists programs in the user's $PATH and
|
||||
runs the result in their $SHELL.
|
||||
.SH OPTIONS
|
||||
.TP
|
||||
.B \-b
|
||||
appear at the bottom of the screen.
|
||||
.TP
|
||||
.B \-i
|
||||
matches menu items case insensitively.
|
||||
.TP
|
||||
.BI \-l " lines"
|
||||
lists item vertically, with the given number of lines.
|
||||
.TP
|
||||
.BI \-p " prompt"
|
||||
defines the prompt to be displayed to the left of the input field.
|
||||
.TP
|
||||
.BI \-f " font"
|
||||
defines the font.
|
||||
.TP
|
||||
.BI \-nb " color"
|
||||
defines the normal background color of the format:
|
||||
.IR #RRGGBB[FF]
|
||||
.TP
|
||||
.BI \-nf " color"
|
||||
defines the normal foreground color of the format:
|
||||
.IR #RRGGBB[FF]
|
||||
.TP
|
||||
.BI \-sb " color"
|
||||
defines the selected background color of the format:
|
||||
.IR #RRGGBB[FF]
|
||||
.TP
|
||||
.BI \-sf " color"
|
||||
defines the selected foreground color of the format:
|
||||
.IR #RRGGBB[FF]
|
||||
.TP
|
||||
.B \-v
|
||||
prints version information to stdout, then exits.
|
||||
.SH USAGE
|
||||
mew is completely controlled by the keyboard. Items are selected using the
|
||||
arrow keys, page up, page down, home, and end.
|
||||
.TP
|
||||
.B Tab
|
||||
Copy the selected item to the input field.
|
||||
.TP
|
||||
.B Return
|
||||
Confirm selection. Prints the selected item to stdout and exits, returning
|
||||
success.
|
||||
.TP
|
||||
.B Ctrl-Return
|
||||
Confirm selection. Prints the selected item to stdout and continues.
|
||||
.TP
|
||||
.B Shift\-Return
|
||||
Confirm input. Prints the input text to stdout and exits, returning success.
|
||||
.TP
|
||||
.B Escape
|
||||
Exit without selecting an item, returning failure.
|
||||
.TP
|
||||
.B Ctrl-Left
|
||||
Move cursor to the start of the current word
|
||||
.TP
|
||||
.B Ctrl-Right
|
||||
Move cursor to the end of the current word
|
||||
.TP
|
||||
.B C\-a
|
||||
Home
|
||||
.TP
|
||||
.B C\-b
|
||||
Left
|
||||
.TP
|
||||
.B C\-c
|
||||
Escape
|
||||
.TP
|
||||
.B C\-d
|
||||
Delete
|
||||
.TP
|
||||
.B C\-e
|
||||
End
|
||||
.TP
|
||||
.B C\-f
|
||||
Right
|
||||
.TP
|
||||
.B C\-g
|
||||
Escape
|
||||
.TP
|
||||
.B C\-h
|
||||
Backspace
|
||||
.TP
|
||||
.B C\-i
|
||||
Tab
|
||||
.TP
|
||||
.B C\-j
|
||||
Return
|
||||
.TP
|
||||
.B C\-J
|
||||
Shift-Return
|
||||
.TP
|
||||
.B C\-k
|
||||
Delete line right
|
||||
.TP
|
||||
.B C\-m
|
||||
Return
|
||||
.TP
|
||||
.B C\-M
|
||||
Shift-Return
|
||||
.TP
|
||||
.B C\-n
|
||||
Down
|
||||
.TP
|
||||
.B C\-p
|
||||
Up
|
||||
.TP
|
||||
.B C\-u
|
||||
Delete line left
|
||||
.TP
|
||||
.B C\-w
|
||||
Delete word left
|
||||
.TP
|
||||
.B C\-y
|
||||
Paste from Wayland clipboard
|
||||
.TP
|
||||
.B C\-Y
|
||||
Paste from Wayland clipboard
|
||||
921
mew.c
Normal file
921
mew.c
Normal file
|
|
@ -0,0 +1,921 @@
|
|||
/* See LICENSE file for copyright and license details. */
|
||||
#include <ctype.h>
|
||||
#include <locale.h>
|
||||
#include <poll.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <sys/timerfd.h>
|
||||
#include <wayland-client.h>
|
||||
#include <xkbcommon/xkbcommon.h>
|
||||
|
||||
#define MAX(A, B) ((A) > (B) ? (A) : (B))
|
||||
#define MIN(A, B) ((A) < (B) ? (A) : (B))
|
||||
#define BETWEEN(X, A, B) ((A) <= (X) && (X) <= (B))
|
||||
#define LENGTH(X) (sizeof (X) / sizeof (X)[0])
|
||||
|
||||
#include "drwl.h"
|
||||
#include "poolbuf.h"
|
||||
#include "wlr-layer-shell-unstable-v1-protocol.h"
|
||||
|
||||
#define TEXTW(X) (drwl_font_getwidth(drw, (X)) + lrpad)
|
||||
|
||||
enum { SchemeNorm, SchemeSel, SchemeOut }; /* color schemes */
|
||||
|
||||
struct item {
|
||||
char *text;
|
||||
struct item *left, *right;
|
||||
int out;
|
||||
};
|
||||
|
||||
static struct {
|
||||
struct wl_keyboard *wl_keyboard;
|
||||
struct xkb_context *xkb_context;
|
||||
struct xkb_keymap *xkb_keymap;
|
||||
struct xkb_state *xkb_state;
|
||||
|
||||
int repeat_delay;
|
||||
int repeat_period;
|
||||
int repeat_timer;
|
||||
enum wl_keyboard_key_state repeat_key_state;
|
||||
xkb_keysym_t repeat_sym;
|
||||
|
||||
int ctrl;
|
||||
int shift;
|
||||
} kbd;
|
||||
|
||||
static char text[BUFSIZ] = "";
|
||||
static int bh, mw, mh;
|
||||
static int inputw = 0, promptw;
|
||||
static int32_t scale = 1;
|
||||
static int lrpad; /* sum of left and right padding */
|
||||
static size_t cursor;
|
||||
static struct item *items = NULL;
|
||||
static struct item *matches, *matchend;
|
||||
static struct item *prev, *curr, *next, *sel;
|
||||
static int running = 1;
|
||||
|
||||
static struct wl_display *display;
|
||||
static struct wl_compositor *compositor;
|
||||
static struct wl_seat *seat;
|
||||
static struct wl_shm *shm;
|
||||
static struct wl_data_device_manager *data_device_manager;
|
||||
static struct wl_data_device *data_device;
|
||||
static struct wl_data_offer *data_offer;
|
||||
static struct zwlr_layer_shell_v1 *layer_shell;
|
||||
static struct zwlr_layer_surface_v1 *layer_surface;
|
||||
static struct wl_surface *surface;
|
||||
static struct wl_registry *registry;
|
||||
static Drwl *drw;
|
||||
|
||||
#include "config.h"
|
||||
|
||||
static int (*fstrncmp)(const char *, const char *, size_t) = strncmp;
|
||||
static char *(*fstrstr)(const char *, const char *) = strstr;
|
||||
|
||||
static void
|
||||
noop()
|
||||
{
|
||||
/* Space intentionally left blank */
|
||||
}
|
||||
|
||||
static void
|
||||
die(const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
vfprintf(stderr, fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
if (fmt[0] && fmt[strlen(fmt)-1] == ':') {
|
||||
fputc(' ', stderr);
|
||||
perror(NULL);
|
||||
} else {
|
||||
fputc('\n', stderr);
|
||||
}
|
||||
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
static void
|
||||
parse_color(uint32_t *dest, const char *src)
|
||||
{
|
||||
int len;
|
||||
|
||||
if (src[0] == '#')
|
||||
src++;
|
||||
len = strlen(src);
|
||||
if (len != 6 && len != 8)
|
||||
die("bad color: %s", src);
|
||||
|
||||
*dest = strtoul(src, NULL, 16);
|
||||
if (len == 6)
|
||||
*dest = (*dest << 8) | 0xFF;
|
||||
}
|
||||
|
||||
static void
|
||||
loadfonts(void)
|
||||
{
|
||||
char fontattrs[12];
|
||||
|
||||
drwl_destroy_font(drw->font);
|
||||
snprintf(fontattrs, sizeof(fontattrs), "dpi=%d", 96 * scale);
|
||||
if (!(drwl_load_font(drw, LENGTH(fonts), fonts, fontattrs)))
|
||||
die("no fonts could be loaded");
|
||||
|
||||
lrpad = drw->font->height;
|
||||
bh = drw->font->height + 2;
|
||||
lines = MAX(lines, 0);
|
||||
mh = (lines + 1) * bh;
|
||||
promptw = (prompt && *prompt) ? TEXTW(prompt) - lrpad / 4 : 0;
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
textw_clamp(const char *str, unsigned int n)
|
||||
{
|
||||
unsigned int w = drwl_font_getwidth_clamp(drw, str, n) + lrpad;
|
||||
return MIN(w, n);
|
||||
}
|
||||
|
||||
static void
|
||||
appenditem(struct item *item, struct item **list, struct item **last)
|
||||
{
|
||||
if (*last)
|
||||
(*last)->right = item;
|
||||
else
|
||||
*list = item;
|
||||
|
||||
item->left = *last;
|
||||
item->right = NULL;
|
||||
*last = item;
|
||||
}
|
||||
|
||||
static void
|
||||
calcoffsets(void)
|
||||
{
|
||||
int i, n;
|
||||
|
||||
if (lines > 0)
|
||||
n = lines * bh;
|
||||
else
|
||||
n = mw - (promptw + inputw + TEXTW("<") + TEXTW(">"));
|
||||
/* calculate which items will begin the next page and previous page */
|
||||
for (i = 0, next = curr; next; next = next->right)
|
||||
if ((i += (lines > 0) ? bh : textw_clamp(next->text, n)) > n)
|
||||
break;
|
||||
for (i = 0, prev = curr; prev && prev->left; prev = prev->left)
|
||||
if ((i += (lines > 0) ? bh : textw_clamp(prev->left->text, n)) > n)
|
||||
break;
|
||||
}
|
||||
|
||||
static void
|
||||
cleanup(void)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; items && items[i].text; ++i)
|
||||
free(items[i].text);
|
||||
free(items);
|
||||
|
||||
drwl_destroy(drw);
|
||||
drwl_fini();
|
||||
|
||||
wl_data_device_release(data_device);
|
||||
zwlr_layer_shell_v1_destroy(layer_shell);
|
||||
wl_shm_destroy(shm);
|
||||
wl_compositor_destroy(compositor);
|
||||
wl_registry_destroy(registry);
|
||||
wl_display_disconnect(display);
|
||||
}
|
||||
|
||||
static char *
|
||||
cistrstr(const char *h, const char *n)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if (!n[0])
|
||||
return (char *)h;
|
||||
|
||||
for (; *h; ++h) {
|
||||
for (i = 0; n[i] && tolower((unsigned char)n[i]) ==
|
||||
tolower((unsigned char)h[i]); ++i)
|
||||
;
|
||||
if (n[i] == '\0')
|
||||
return (char *)h;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int
|
||||
drawitem(struct item *item, int x, int y, int w)
|
||||
{
|
||||
if (item == sel)
|
||||
drwl_setscheme(drw, colors[SchemeSel]);
|
||||
else if (item->out)
|
||||
drwl_setscheme(drw, colors[SchemeOut]);
|
||||
else
|
||||
drwl_setscheme(drw, colors[SchemeNorm]);
|
||||
|
||||
return drwl_text(drw, x, y, w, bh, lrpad / 2, item->text, 0);
|
||||
}
|
||||
|
||||
static void
|
||||
drawmenu(void)
|
||||
{
|
||||
unsigned int curpos;
|
||||
struct item *item;
|
||||
int x = 0, y = 0, w;
|
||||
PoolBuf *buf;
|
||||
|
||||
if (!(buf = poolbuf_create(shm, mw, mh)))
|
||||
die("poolbuf_create:");
|
||||
|
||||
drwl_prepare_drawing(drw, mw, mh, buf->data, buf->stride);
|
||||
|
||||
drwl_setscheme(drw, colors[SchemeNorm]);
|
||||
drwl_rect(drw, 0, 0, mw, mh, 1, 1);
|
||||
|
||||
if (prompt && *prompt) {
|
||||
drwl_setscheme(drw, colors[SchemeSel]);
|
||||
x = drwl_text(drw, x, 0, promptw, bh, lrpad / 2, prompt, 0);
|
||||
}
|
||||
/* draw input field */
|
||||
w = (lines > 0 || !matches) ? mw - x : inputw;
|
||||
drwl_setscheme(drw, colors[SchemeNorm]);
|
||||
drwl_text(drw, x, 0, w, bh, lrpad / 2, text, 0);
|
||||
|
||||
curpos = TEXTW(text) - TEXTW(&text[cursor]);
|
||||
if ((curpos += lrpad / 2 - 1) < w) {
|
||||
drwl_setscheme(drw, colors[SchemeNorm]);
|
||||
drwl_rect(drw, x + curpos, 2, 2, bh - 4, 1, 0);
|
||||
}
|
||||
|
||||
if (lines > 0) {
|
||||
/* draw vertical list */
|
||||
for (item = curr; item != next; item = item->right)
|
||||
drawitem(item, x, y += bh, mw - x);
|
||||
} else if (matches) {
|
||||
/* draw horizontal list */
|
||||
x += inputw;
|
||||
w = TEXTW("<");
|
||||
if (curr->left) {
|
||||
drwl_setscheme(drw, colors[SchemeNorm]);
|
||||
drwl_text(drw, x, 0, w, bh, lrpad / 2, "<", 0);
|
||||
}
|
||||
x += w;
|
||||
for (item = curr; item != next; item = item->right)
|
||||
x = drawitem(item, x, 0, textw_clamp(item->text, mw - x - TEXTW(">")));
|
||||
if (next) {
|
||||
w = TEXTW(">");
|
||||
drwl_setscheme(drw, colors[SchemeNorm]);
|
||||
drwl_text(drw, mw - w, 0, w, bh, lrpad / 2, ">", 0);
|
||||
}
|
||||
}
|
||||
|
||||
drwl_finish_drawing(drw);
|
||||
wl_surface_set_buffer_scale(surface, scale);
|
||||
wl_surface_attach(surface, buf->wl_buf, 0, 0);
|
||||
wl_surface_damage_buffer(surface, 0, 0, mw, mh);
|
||||
poolbuf_destroy(buf);
|
||||
wl_surface_commit(surface);
|
||||
}
|
||||
|
||||
static void
|
||||
match(void)
|
||||
{
|
||||
static char **tokv = NULL;
|
||||
static int tokn = 0;
|
||||
|
||||
char buf[sizeof text], *s;
|
||||
int i, tokc = 0;
|
||||
size_t len, textsize;
|
||||
struct item *item, *lprefix, *lsubstr, *prefixend, *substrend;
|
||||
|
||||
strcpy(buf, text);
|
||||
/* separate input text into tokens to be matched individually */
|
||||
for (s = strtok(buf, " "); s; tokv[tokc - 1] = s, s = strtok(NULL, " "))
|
||||
if (++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv)))
|
||||
die("cannot realloc %zu bytes:", tokn * sizeof *tokv);
|
||||
len = tokc ? strlen(tokv[0]) : 0;
|
||||
|
||||
matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL;
|
||||
textsize = strlen(text) + 1;
|
||||
for (item = items; item && item->text; item++) {
|
||||
for (i = 0; i < tokc; i++)
|
||||
if (!fstrstr(item->text, tokv[i]))
|
||||
break;
|
||||
if (i != tokc) /* not all tokens match */
|
||||
continue;
|
||||
/* exact matches go first, then prefixes, then substrings */
|
||||
if (!tokc || !fstrncmp(text, item->text, textsize))
|
||||
appenditem(item, &matches, &matchend);
|
||||
else if (!fstrncmp(tokv[0], item->text, len))
|
||||
appenditem(item, &lprefix, &prefixend);
|
||||
else
|
||||
appenditem(item, &lsubstr, &substrend);
|
||||
}
|
||||
if (lprefix) {
|
||||
if (matches) {
|
||||
matchend->right = lprefix;
|
||||
lprefix->left = matchend;
|
||||
} else
|
||||
matches = lprefix;
|
||||
matchend = prefixend;
|
||||
}
|
||||
if (lsubstr) {
|
||||
if (matches) {
|
||||
matchend->right = lsubstr;
|
||||
lsubstr->left = matchend;
|
||||
} else
|
||||
matches = lsubstr;
|
||||
matchend = substrend;
|
||||
}
|
||||
curr = sel = matches;
|
||||
calcoffsets();
|
||||
}
|
||||
|
||||
static void
|
||||
insert(const char *str, ssize_t n)
|
||||
{
|
||||
if (strlen(text) + n > sizeof text - 1)
|
||||
return;
|
||||
/* move existing text out of the way, insert new text, and update cursor */
|
||||
memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0));
|
||||
if (n > 0)
|
||||
memcpy(&text[cursor], str, n);
|
||||
cursor += n;
|
||||
match();
|
||||
}
|
||||
|
||||
static size_t
|
||||
nextrune(int inc)
|
||||
{
|
||||
ssize_t n;
|
||||
|
||||
/* return location of next utf8 rune in the given direction (+1 or -1) */
|
||||
for (n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc)
|
||||
;
|
||||
return n;
|
||||
}
|
||||
|
||||
static void
|
||||
movewordedge(int dir)
|
||||
{
|
||||
if (dir < 0) { /* move cursor to the start of the word*/
|
||||
while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
|
||||
cursor = nextrune(-1);
|
||||
while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
|
||||
cursor = nextrune(-1);
|
||||
} else { /* move cursor to the end of the word */
|
||||
while (text[cursor] && strchr(worddelimiters, text[cursor]))
|
||||
cursor = nextrune(+1);
|
||||
while (text[cursor] && !strchr(worddelimiters, text[cursor]))
|
||||
cursor = nextrune(+1);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
paste(void)
|
||||
{
|
||||
int fds[2];
|
||||
ssize_t n;
|
||||
char buf[1024];
|
||||
|
||||
if (!data_offer)
|
||||
return;
|
||||
|
||||
if (pipe(fds) < 0)
|
||||
die("pipe");
|
||||
|
||||
wl_data_offer_receive(data_offer, "text/plain", fds[1]);
|
||||
close(fds[1]);
|
||||
|
||||
wl_display_roundtrip(display);
|
||||
|
||||
for (;;) {
|
||||
n = read(fds[0], buf, sizeof(buf));
|
||||
if (n <= 0)
|
||||
break;
|
||||
insert(buf, n);
|
||||
}
|
||||
close(fds[0]);
|
||||
|
||||
wl_data_offer_destroy(data_offer);
|
||||
}
|
||||
|
||||
static void
|
||||
keyboard_keypress(enum wl_keyboard_key_state state, xkb_keysym_t sym, int ctrl, int shift)
|
||||
{
|
||||
char buf[8];
|
||||
|
||||
if (state != WL_KEYBOARD_KEY_STATE_PRESSED)
|
||||
return;
|
||||
|
||||
if (ctrl) {
|
||||
switch (xkb_keysym_to_lower(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_BackSpace; break;
|
||||
case XKB_KEY_g: 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: /* fallthrough */
|
||||
case XKB_KEY_J: /* fallthrough */
|
||||
case XKB_KEY_m: /* fallthrough */
|
||||
case XKB_KEY_M: sym = XKB_KEY_Return; break;
|
||||
case XKB_KEY_n: sym = XKB_KEY_Right; break;
|
||||
case XKB_KEY_p: sym = XKB_KEY_Up; break;
|
||||
|
||||
case XKB_KEY_k: /* delete right */
|
||||
text[cursor] = '\0';
|
||||
match();
|
||||
goto draw;
|
||||
case XKB_KEY_u: /* delete left */
|
||||
insert(NULL, 0 - cursor);
|
||||
goto draw;
|
||||
case XKB_KEY_w: /* delete word */
|
||||
while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
|
||||
insert(NULL, nextrune(-1) - cursor);
|
||||
while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
|
||||
insert(NULL, nextrune(-1) - cursor);
|
||||
goto draw;
|
||||
case XKB_KEY_y: /* paste selection */
|
||||
case XKB_KEY_Y:
|
||||
paste();
|
||||
goto draw;
|
||||
case XKB_KEY_Left:
|
||||
case XKB_KEY_KP_Left:
|
||||
movewordedge(-1);
|
||||
goto draw;
|
||||
case XKB_KEY_Right:
|
||||
case XKB_KEY_KP_Right:
|
||||
movewordedge(+1);
|
||||
goto draw;
|
||||
case XKB_KEY_Return:
|
||||
case XKB_KEY_KP_Enter:
|
||||
break;
|
||||
case XKB_KEY_bracketleft:
|
||||
cleanup();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
switch (sym) {
|
||||
case XKB_KEY_Delete:
|
||||
case XKB_KEY_KP_Delete:
|
||||
if (text[cursor] == '\0')
|
||||
return;
|
||||
cursor = nextrune(+1);
|
||||
/* fallthrough */
|
||||
case XKB_KEY_BackSpace:
|
||||
if (cursor == 0)
|
||||
return;
|
||||
insert(NULL, nextrune(-1) - cursor);
|
||||
break;
|
||||
case XKB_KEY_End:
|
||||
case XKB_KEY_KP_End:
|
||||
if (text[cursor] != '\0') {
|
||||
cursor = strlen(text);
|
||||
break;
|
||||
}
|
||||
if (next) {
|
||||
/* jump to end of list and position items in reverse */
|
||||
curr = matchend;
|
||||
calcoffsets();
|
||||
curr = prev;
|
||||
calcoffsets();
|
||||
while (next && (curr = curr->right))
|
||||
calcoffsets();
|
||||
}
|
||||
sel = matchend;
|
||||
break;
|
||||
case XKB_KEY_Escape:
|
||||
cleanup();
|
||||
exit(EXIT_FAILURE);
|
||||
case XKB_KEY_Home:
|
||||
case XKB_KEY_KP_Home:
|
||||
if (sel == matches) {
|
||||
cursor = 0;
|
||||
break;
|
||||
}
|
||||
sel = curr = matches;
|
||||
calcoffsets();
|
||||
break;
|
||||
case XKB_KEY_Left:
|
||||
case XKB_KEY_KP_Left:
|
||||
if (cursor > 0 && (!sel || !sel->left || lines > 0)) {
|
||||
cursor = nextrune(-1);
|
||||
break;
|
||||
}
|
||||
if (lines > 0)
|
||||
return;
|
||||
/* fallthrough */
|
||||
case XKB_KEY_Up:
|
||||
case XKB_KEY_KP_Up:
|
||||
if (sel && sel->left && (sel = sel->left)->right == curr) {
|
||||
curr = prev;
|
||||
calcoffsets();
|
||||
}
|
||||
break;
|
||||
case XKB_KEY_Next:
|
||||
case XKB_KEY_KP_Next:
|
||||
if (!next)
|
||||
return;
|
||||
sel = curr = next;
|
||||
calcoffsets();
|
||||
break;
|
||||
case XKB_KEY_Prior:
|
||||
case XKB_KEY_KP_Prior:
|
||||
if (!prev)
|
||||
return;
|
||||
sel = curr = prev;
|
||||
calcoffsets();
|
||||
break;
|
||||
case XKB_KEY_Return:
|
||||
case XKB_KEY_KP_Enter:
|
||||
puts((sel && !shift) ? sel->text : text);
|
||||
if (!ctrl)
|
||||
running = 0;
|
||||
return;
|
||||
case XKB_KEY_Right:
|
||||
case XKB_KEY_KP_Right:
|
||||
if (text[cursor] != '\0') {
|
||||
cursor = nextrune(+1);
|
||||
break;
|
||||
}
|
||||
if (lines > 0)
|
||||
return;
|
||||
/* fallthrough */
|
||||
case XKB_KEY_Down:
|
||||
case XKB_KEY_KP_Down:
|
||||
if (sel && sel->right && (sel = sel->right) == next) {
|
||||
curr = next;
|
||||
calcoffsets();
|
||||
}
|
||||
break;
|
||||
case XKB_KEY_Tab:
|
||||
if (!sel)
|
||||
return;
|
||||
cursor = strnlen(sel->text, sizeof text - 1);
|
||||
memcpy(text, sel->text, cursor);
|
||||
text[cursor] = '\0';
|
||||
match();
|
||||
break;
|
||||
default:
|
||||
if (xkb_keysym_to_utf8(sym, buf, 8))
|
||||
insert(buf, strnlen(buf, 8));
|
||||
}
|
||||
draw:
|
||||
drawmenu();
|
||||
}
|
||||
|
||||
static void
|
||||
keyboard_handle_keymap(void *data, struct wl_keyboard *wl_keyboard,
|
||||
uint32_t format, int32_t fd, uint32_t size)
|
||||
{
|
||||
char *map_shm;
|
||||
|
||||
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
|
||||
die("unknown keymap");
|
||||
|
||||
map_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
|
||||
if (map_shm == MAP_FAILED)
|
||||
die("mmap:");
|
||||
|
||||
kbd.xkb_keymap = xkb_keymap_new_from_string(kbd.xkb_context, map_shm,
|
||||
XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
|
||||
munmap(map_shm, size);
|
||||
close(fd);
|
||||
|
||||
kbd.xkb_state = xkb_state_new(kbd.xkb_keymap);
|
||||
}
|
||||
|
||||
static void
|
||||
keyboard_handle_key(void *data, struct wl_keyboard *wl_keyboard,
|
||||
uint32_t serial, uint32_t time, uint32_t key, uint32_t _key_state)
|
||||
{
|
||||
struct itimerspec spec = { 0 };
|
||||
enum wl_keyboard_key_state key_state = _key_state;
|
||||
xkb_keysym_t sym = xkb_state_key_get_one_sym(kbd.xkb_state, key + 8);
|
||||
|
||||
keyboard_keypress(key_state, sym, kbd.ctrl, kbd.shift);
|
||||
|
||||
if (key_state == WL_KEYBOARD_KEY_STATE_PRESSED && kbd.repeat_period >= 0) {
|
||||
kbd.repeat_key_state = key_state;
|
||||
kbd.repeat_sym = sym;
|
||||
spec.it_value.tv_sec = kbd.repeat_delay / 1000;
|
||||
spec.it_value.tv_nsec = (kbd.repeat_delay % 1000) * 1000000l;
|
||||
}
|
||||
timerfd_settime(kbd.repeat_timer, 0, &spec, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
keyboard_handle_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)
|
||||
{
|
||||
xkb_state_update_mask(kbd.xkb_state,
|
||||
mods_depressed, mods_latched, mods_locked, 0, 0, group);
|
||||
kbd.ctrl = xkb_state_mod_name_is_active(kbd.xkb_state,
|
||||
XKB_MOD_NAME_CTRL,
|
||||
XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED);
|
||||
kbd.shift = xkb_state_mod_name_is_active(kbd.xkb_state,
|
||||
XKB_MOD_NAME_SHIFT,
|
||||
XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED);
|
||||
}
|
||||
|
||||
static void
|
||||
keyboard_repeat(void)
|
||||
{
|
||||
struct itimerspec spec = { 0 };
|
||||
|
||||
keyboard_keypress(kbd.repeat_key_state, kbd.repeat_sym, kbd.ctrl, kbd.shift);
|
||||
|
||||
spec.it_value.tv_sec = kbd.repeat_period / 1000;
|
||||
spec.it_value.tv_nsec = (kbd.repeat_period % 1000) * 1000000l;
|
||||
timerfd_settime(kbd.repeat_timer, 0, &spec, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
keyboard_handle_repeat_info(void *data, struct wl_keyboard *wl_keyboard,
|
||||
int32_t rate, int32_t delay)
|
||||
{
|
||||
kbd.repeat_delay = delay;
|
||||
kbd.repeat_period = rate >= 0 ? 1000 / rate : -1;
|
||||
}
|
||||
|
||||
static const struct wl_keyboard_listener keyboard_listener = {
|
||||
.keymap = keyboard_handle_keymap,
|
||||
.enter = noop,
|
||||
.leave = noop,
|
||||
.key = keyboard_handle_key,
|
||||
.modifiers = keyboard_handle_modifiers,
|
||||
.repeat_info = keyboard_handle_repeat_info,
|
||||
};
|
||||
|
||||
static void
|
||||
layer_surface_handle_configure(void *data, struct zwlr_layer_surface_v1 *surface,
|
||||
uint32_t serial, uint32_t width, uint32_t height)
|
||||
{
|
||||
mw = width * scale;
|
||||
mh = height * scale;
|
||||
inputw = mw / 3; /* input width: ~33% of monitor width */
|
||||
zwlr_layer_surface_v1_ack_configure(surface, serial);
|
||||
drawmenu();
|
||||
}
|
||||
|
||||
static void
|
||||
layer_surface_handle_closed(void *data, struct zwlr_layer_surface_v1 *surface)
|
||||
{
|
||||
running = 0;
|
||||
}
|
||||
|
||||
static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
|
||||
.configure = layer_surface_handle_configure,
|
||||
.closed = layer_surface_handle_closed,
|
||||
};
|
||||
|
||||
static void
|
||||
surface_handle_preferred_scale(void *data,
|
||||
struct wl_surface *wl_surface, int32_t factor)
|
||||
{
|
||||
scale = factor;
|
||||
loadfonts();
|
||||
zwlr_layer_surface_v1_set_size(layer_surface, 0, mh / scale);
|
||||
}
|
||||
|
||||
static const struct wl_surface_listener surface_listener = {
|
||||
.enter = noop,
|
||||
.leave = noop,
|
||||
.preferred_buffer_scale = surface_handle_preferred_scale,
|
||||
.preferred_buffer_transform = noop,
|
||||
};
|
||||
|
||||
static void
|
||||
data_device_handle_selection(void *data, struct wl_data_device *data_device,
|
||||
struct wl_data_offer *_data_offer)
|
||||
{
|
||||
data_offer = _data_offer;
|
||||
}
|
||||
|
||||
static const struct wl_data_device_listener data_device_listener = {
|
||||
.data_offer = noop,
|
||||
.selection = data_device_handle_selection,
|
||||
};
|
||||
|
||||
static void
|
||||
seat_handle_capabilities(void *data, struct wl_seat *wl_seat, enum wl_seat_capability caps)
|
||||
{
|
||||
if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD))
|
||||
return;
|
||||
|
||||
kbd.wl_keyboard = wl_seat_get_keyboard(seat);
|
||||
if (!(kbd.xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS)))
|
||||
die("xkb_context_new failed");
|
||||
if ((kbd.repeat_timer = timerfd_create(CLOCK_MONOTONIC, 0)) < 0)
|
||||
die("timerfd_create:");
|
||||
wl_keyboard_add_listener(kbd.wl_keyboard, &keyboard_listener, NULL);
|
||||
}
|
||||
|
||||
static const struct wl_seat_listener seat_listener = {
|
||||
.capabilities = seat_handle_capabilities,
|
||||
.name = noop,
|
||||
};
|
||||
|
||||
static void
|
||||
registry_handle_global(void *data, struct wl_registry *registry,
|
||||
uint32_t name, const char *interface, uint32_t version)
|
||||
{
|
||||
if (!strcmp(interface, wl_compositor_interface.name))
|
||||
compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 6);
|
||||
else if (!strcmp(interface, wl_shm_interface.name))
|
||||
shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
|
||||
else if (!strcmp(interface, zwlr_layer_shell_v1_interface.name))
|
||||
layer_shell = wl_registry_bind(registry, name,
|
||||
&zwlr_layer_shell_v1_interface, 1);
|
||||
else if (!strcmp(interface, wl_data_device_manager_interface.name))
|
||||
data_device_manager = wl_registry_bind(registry, name,
|
||||
&wl_data_device_manager_interface, 3);
|
||||
else if (!strcmp(interface, wl_seat_interface.name)) {
|
||||
seat = wl_registry_bind (registry, name, &wl_seat_interface, 4);
|
||||
wl_seat_add_listener(seat, &seat_listener, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static const struct wl_registry_listener registry_listener = {
|
||||
.global = registry_handle_global,
|
||||
.global_remove = noop,
|
||||
};
|
||||
|
||||
static void
|
||||
readstdin(void)
|
||||
{
|
||||
char *line = NULL;
|
||||
size_t i, itemsiz = 0, linesiz = 0;
|
||||
ssize_t len;
|
||||
|
||||
/* read each line from stdin and add it to the item list */
|
||||
for (i = 0; (len = getline(&line, &linesiz, stdin)) != -1; i++) {
|
||||
if (i + 1 >= itemsiz) {
|
||||
itemsiz += 256;
|
||||
if (!(items = realloc(items, itemsiz * sizeof(*items))))
|
||||
die("cannot realloc %zu bytes:", itemsiz * sizeof(*items));
|
||||
}
|
||||
if (line[len - 1] == '\n')
|
||||
line[len - 1] = '\0';
|
||||
if (!(items[i].text = strdup(line)))
|
||||
die("strdup:");
|
||||
|
||||
items[i].out = 0;
|
||||
}
|
||||
free(line);
|
||||
if (items)
|
||||
items[i].text = NULL;
|
||||
lines = MIN(lines, i);
|
||||
}
|
||||
|
||||
static void
|
||||
run(void)
|
||||
{
|
||||
struct pollfd pfds[] = {
|
||||
{ wl_display_get_fd(display), POLLIN },
|
||||
{ kbd.repeat_timer, POLLIN },
|
||||
};
|
||||
|
||||
match();
|
||||
drawmenu();
|
||||
|
||||
while (running) {
|
||||
if (wl_display_prepare_read(display) < 0)
|
||||
if (wl_display_dispatch_pending(display) < 0)
|
||||
die("wl_display_dispatch_pending:");
|
||||
|
||||
if (wl_display_flush(display) < 0)
|
||||
die("wl_display_flush:");
|
||||
|
||||
if (poll(pfds, LENGTH(pfds), -1) < 0) {
|
||||
wl_display_cancel_read(display);
|
||||
die("poll:");
|
||||
}
|
||||
|
||||
if (pfds[1].revents & POLLIN)
|
||||
keyboard_repeat();
|
||||
|
||||
if (!(pfds[0].revents & POLLIN)) {
|
||||
wl_display_cancel_read(display);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (wl_display_read_events(display) < 0)
|
||||
die("wl_display_read_events:");
|
||||
if (wl_display_dispatch_pending(display) < 0)
|
||||
die("wl_display_dispatch_pending:");
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
setup(void)
|
||||
{
|
||||
if (!(display = wl_display_connect(NULL)))
|
||||
die("failed to connect to wayland");
|
||||
|
||||
registry = wl_display_get_registry(display);
|
||||
wl_registry_add_listener(registry, ®istry_listener, NULL);
|
||||
wl_display_roundtrip(display);
|
||||
|
||||
if (!compositor)
|
||||
die("wl_compositor not available");
|
||||
if (!shm)
|
||||
die("wl_shm not available");
|
||||
if (!layer_shell)
|
||||
die("layer_shell not available");
|
||||
if (!data_device_manager)
|
||||
die("data_device_manager not available");
|
||||
|
||||
data_device = wl_data_device_manager_get_data_device(
|
||||
data_device_manager, seat);
|
||||
wl_data_device_add_listener(data_device, &data_device_listener, NULL);
|
||||
|
||||
drwl_init();
|
||||
if (!(drw = drwl_create()))
|
||||
die("cannot create drwl drawing context");
|
||||
loadfonts();
|
||||
|
||||
match();
|
||||
|
||||
surface = wl_compositor_create_surface(compositor);
|
||||
wl_surface_add_listener(surface, &surface_listener, NULL);
|
||||
|
||||
layer_surface = zwlr_layer_shell_v1_get_layer_surface(layer_shell,
|
||||
surface, NULL, ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, "mew");
|
||||
zwlr_layer_surface_v1_set_size(layer_surface, 0, mh);
|
||||
zwlr_layer_surface_v1_set_anchor(layer_surface,
|
||||
(top ? ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP : ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM ) |
|
||||
ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT);
|
||||
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, NULL);
|
||||
|
||||
wl_surface_commit(surface);
|
||||
wl_display_roundtrip(display);
|
||||
}
|
||||
|
||||
static void
|
||||
usage(void)
|
||||
{
|
||||
die("usage: mew [-biv] [-l lines] [-p prompt] [-f font]\n"
|
||||
" [-nb color] [-nf color] [-sb color] [-sf color]");
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 1; i < argc; i++) {
|
||||
/* these options take no arguments */
|
||||
if (!strcmp(argv[i], "-v")) {
|
||||
puts("mew-"VERSION);
|
||||
exit(0);
|
||||
} else if (!strcmp(argv[i], "-b"))
|
||||
top = 0;
|
||||
else if (!strcmp(argv[i], "-i")) {
|
||||
fstrncmp = strncasecmp;
|
||||
fstrstr = cistrstr;
|
||||
} else if (i + 1 == argc)
|
||||
usage();
|
||||
else if (!strcmp(argv[i], "-l"))
|
||||
lines = atoi(argv[++i]);
|
||||
else if (!strcmp(argv[i], "-p"))
|
||||
prompt = argv[++i];
|
||||
else if (!strcmp(argv[i], "-f"))
|
||||
fonts[0] = argv[++i];
|
||||
else if (!strcmp(argv[i], "-nb"))
|
||||
parse_color(&colors[SchemeNorm][ColBg], argv[++i]);
|
||||
else if (!strcmp(argv[i], "-nf"))
|
||||
parse_color(&colors[SchemeNorm][ColFg], argv[++i]);
|
||||
else if (!strcmp(argv[i], "-sb"))
|
||||
parse_color(&colors[SchemeSel][ColBg], argv[++i]);
|
||||
else if (!strcmp(argv[i], "-sf"))
|
||||
parse_color(&colors[SchemeSel][ColFg], argv[++i]);
|
||||
else
|
||||
usage();
|
||||
}
|
||||
|
||||
readstdin();
|
||||
#ifdef __OpenBSD__
|
||||
if (pledge("stdio rpath", NULL) == -1)
|
||||
die("pledge");
|
||||
#endif
|
||||
setup();
|
||||
run();
|
||||
cleanup();
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
112
poolbuf.h
Normal file
112
poolbuf.h
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
/*
|
||||
* poolbuf - https://codeberg.org/sewn/drwl
|
||||
* See LICENSE file for copyright and license details.
|
||||
*/
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/mman.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <wayland-client.h>
|
||||
|
||||
#include "drwl.h"
|
||||
|
||||
typedef struct {
|
||||
struct wl_buffer *wl_buf;
|
||||
int32_t stride;
|
||||
int32_t size;
|
||||
void *data;
|
||||
} PoolBuf;
|
||||
|
||||
#if defined(__linux__) || defined(___FreeBSD__)
|
||||
#ifdef __linux__
|
||||
#include <linux/memfd.h>
|
||||
#endif
|
||||
#define __POOLBUF_HAS_MEMFD_CREATE
|
||||
int memfd_create(const char *, unsigned);
|
||||
#else
|
||||
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
|
||||
create_shm(void)
|
||||
{
|
||||
char name[] = "/drwl-XXXXXX";
|
||||
int retries = 100;
|
||||
|
||||
do {
|
||||
randname(name + sizeof(name) - 7);
|
||||
--retries;
|
||||
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;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Caller must call poolbuf_destroy after finalizing usage */
|
||||
static PoolBuf *
|
||||
poolbuf_create(struct wl_shm *shm, int32_t width, int32_t height)
|
||||
{
|
||||
int fd;
|
||||
void *data;
|
||||
struct wl_shm_pool *shm_pool;
|
||||
struct wl_buffer *wl_buf;
|
||||
int32_t stride = drwl_stride(width);
|
||||
int32_t size = stride * height;
|
||||
PoolBuf *buf;
|
||||
|
||||
#ifdef __POOLBUF_HAS_MEMFD_CREATE
|
||||
fd = memfd_create("drwl-shm-buffer-pool",
|
||||
MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_NOEXEC_SEAL);
|
||||
#else
|
||||
fd = create_shm();
|
||||
#endif
|
||||
if (fd < 0)
|
||||
return NULL;
|
||||
|
||||
if ((ftruncate(fd, size)) < 0) {
|
||||
close(fd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
data = mmap(NULL, size,
|
||||
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
if (data == MAP_FAILED) {
|
||||
close(fd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
shm_pool = wl_shm_create_pool(shm, fd, size);
|
||||
wl_buf = wl_shm_pool_create_buffer(shm_pool, 0,
|
||||
width, height, stride, WL_SHM_FORMAT_ARGB8888);
|
||||
wl_shm_pool_destroy(shm_pool);
|
||||
close(fd);
|
||||
|
||||
buf = calloc(1, sizeof(PoolBuf));
|
||||
buf->wl_buf = wl_buf;
|
||||
buf->stride = stride;
|
||||
buf->size = size;
|
||||
buf->data = data;
|
||||
return buf;
|
||||
}
|
||||
|
||||
static void
|
||||
poolbuf_destroy(PoolBuf *buf)
|
||||
{
|
||||
wl_buffer_destroy(buf->wl_buf);
|
||||
munmap(buf->data, buf->size);
|
||||
free(buf);
|
||||
}
|
||||
285
wlr-layer-shell-unstable-v1.xml
Normal file
285
wlr-layer-shell-unstable-v1.xml
Normal file
|
|
@ -0,0 +1,285 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<protocol name="wlr_layer_shell_unstable_v1">
|
||||
<copyright>
|
||||
Copyright © 2017 Drew DeVault
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this
|
||||
software and its documentation for any purpose is hereby granted
|
||||
without fee, provided that the above copyright notice appear in
|
||||
all copies and that both that copyright notice and this permission
|
||||
notice appear in supporting documentation, and that the name of
|
||||
the copyright holders not be used in advertising or publicity
|
||||
pertaining to distribution of the software without specific,
|
||||
written prior permission. The copyright holders make no
|
||||
representations about the suitability of this software for any
|
||||
purpose. It is provided "as is" without express or implied
|
||||
warranty.
|
||||
|
||||
THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
||||
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
|
||||
AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
|
||||
THIS SOFTWARE.
|
||||
</copyright>
|
||||
|
||||
<interface name="zwlr_layer_shell_v1" version="1">
|
||||
<description summary="create surfaces that are layers of the desktop">
|
||||
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.
|
||||
</description>
|
||||
|
||||
<request name="get_layer_surface">
|
||||
<description summary="create a layer_surface from a surface">
|
||||
Create a layer surface for an existing surface. This assigns the role of
|
||||
layer_surface, or raises a protocol error if another role is already
|
||||
assigned.
|
||||
|
||||
Creating a layer surface from a wl_surface which has a buffer attached
|
||||
or committed is a client error, and any attempts by a client to attach
|
||||
or manipulate a buffer prior to the first layer_surface.configure call
|
||||
must also be treated as errors.
|
||||
|
||||
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.
|
||||
</description>
|
||||
<arg name="id" type="new_id" interface="zwlr_layer_surface_v1"/>
|
||||
<arg name="surface" type="object" interface="wl_surface"/>
|
||||
<arg name="output" type="object" interface="wl_output" allow-null="true"/>
|
||||
<arg name="layer" type="uint" enum="layer" summary="layer to add this surface to"/>
|
||||
<arg name="namespace" type="string" summary="namespace for the layer surface"/>
|
||||
</request>
|
||||
|
||||
<enum name="error">
|
||||
<entry name="role" value="0" summary="wl_surface has another role"/>
|
||||
<entry name="invalid_layer" value="1" summary="layer value is invalid"/>
|
||||
<entry name="already_constructed" value="2" summary="wl_surface has a buffer attached or committed"/>
|
||||
</enum>
|
||||
|
||||
<enum name="layer">
|
||||
<description summary="available layers for surfaces">
|
||||
These values indicate which layers a surface can be rendered in. They
|
||||
are ordered by z depth, bottom-most first. Traditional shell surfaces
|
||||
will typically be rendered between the bottom and top layers.
|
||||
Fullscreen shell surfaces are typically rendered at the top layer.
|
||||
Multiple surfaces can share a single layer, and ordering within a
|
||||
single layer is undefined.
|
||||
</description>
|
||||
|
||||
<entry name="background" value="0"/>
|
||||
<entry name="bottom" value="1"/>
|
||||
<entry name="top" value="2"/>
|
||||
<entry name="overlay" value="3"/>
|
||||
</enum>
|
||||
</interface>
|
||||
|
||||
<interface name="zwlr_layer_surface_v1" version="1">
|
||||
<description summary="layer metadata interface">
|
||||
An interface that may be implemented by a wl_surface, for surfaces that
|
||||
are designed to be rendered as a layer of a stacked desktop-like
|
||||
environment.
|
||||
|
||||
Layer surface state (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.
|
||||
</description>
|
||||
|
||||
<request name="set_size">
|
||||
<description summary="sets the size of the surface">
|
||||
Sets the size of the surface in surface-local coordinates. The
|
||||
compositor will display the surface centered with respect to its
|
||||
anchors.
|
||||
|
||||
If you pass 0 for either value, the compositor will assign it and
|
||||
inform you of the assignment in the configure event. You must set your
|
||||
anchor to opposite edges in the dimensions you omit; not doing so is a
|
||||
protocol error. Both values are 0 by default.
|
||||
|
||||
Size is double-buffered, see wl_surface.commit.
|
||||
</description>
|
||||
<arg name="width" type="uint"/>
|
||||
<arg name="height" type="uint"/>
|
||||
</request>
|
||||
|
||||
<request name="set_anchor">
|
||||
<description summary="configures the anchor point of the surface">
|
||||
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.
|
||||
</description>
|
||||
<arg name="anchor" type="uint" enum="anchor"/>
|
||||
</request>
|
||||
|
||||
<request name="set_exclusive_zone">
|
||||
<description summary="configures the exclusive geometry of this surface">
|
||||
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.
|
||||
</description>
|
||||
<arg name="zone" type="int"/>
|
||||
</request>
|
||||
|
||||
<request name="set_margin">
|
||||
<description summary="sets a margin from the anchor point">
|
||||
Requests that the surface be placed some distance away from the anchor
|
||||
point on the output, in surface-local coordinates. Setting this value
|
||||
for edges you are not anchored to has no effect.
|
||||
|
||||
The exclusive zone includes the margin.
|
||||
|
||||
Margin is double-buffered, see wl_surface.commit.
|
||||
</description>
|
||||
<arg name="top" type="int"/>
|
||||
<arg name="right" type="int"/>
|
||||
<arg name="bottom" type="int"/>
|
||||
<arg name="left" type="int"/>
|
||||
</request>
|
||||
|
||||
<request name="set_keyboard_interactivity">
|
||||
<description summary="requests keyboard events">
|
||||
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.
|
||||
</description>
|
||||
<arg name="keyboard_interactivity" type="uint"/>
|
||||
</request>
|
||||
|
||||
<request name="get_popup">
|
||||
<description summary="assign this layer_surface as an xdg_popup parent">
|
||||
This assigns an xdg_popup's parent to this layer_surface. This popup
|
||||
should have been created via xdg_surface::get_popup with the parent set
|
||||
to NULL, and this request must be invoked before committing the popup's
|
||||
initial state.
|
||||
|
||||
See the documentation of xdg_popup for more details about what an
|
||||
xdg_popup is and how it is used.
|
||||
</description>
|
||||
<arg name="popup" type="object" interface="xdg_popup"/>
|
||||
</request>
|
||||
|
||||
<request name="ack_configure">
|
||||
<description summary="ack a configure event">
|
||||
When a configure event is received, if a client commits the
|
||||
surface in response to the configure event, then the client
|
||||
must make an ack_configure request sometime before the commit
|
||||
request, passing along the serial of the configure event.
|
||||
|
||||
If the client receives multiple configure events before it
|
||||
can respond to one, it only has to ack the last configure event.
|
||||
|
||||
A client is not required to commit immediately after sending
|
||||
an ack_configure request - it may even ack_configure several times
|
||||
before its next surface commit.
|
||||
|
||||
A client may send multiple ack_configure requests before committing, but
|
||||
only the last request sent before a commit indicates which configure
|
||||
event the client really is responding to.
|
||||
</description>
|
||||
<arg name="serial" type="uint" summary="the serial from the configure event"/>
|
||||
</request>
|
||||
|
||||
<request name="destroy" type="destructor">
|
||||
<description summary="destroy the layer_surface">
|
||||
This request destroys the layer surface.
|
||||
</description>
|
||||
</request>
|
||||
|
||||
<event name="configure">
|
||||
<description summary="suggest a surface change">
|
||||
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.
|
||||
</description>
|
||||
<arg name="serial" type="uint"/>
|
||||
<arg name="width" type="uint"/>
|
||||
<arg name="height" type="uint"/>
|
||||
</event>
|
||||
|
||||
<event name="closed">
|
||||
<description summary="surface should be closed">
|
||||
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.
|
||||
</description>
|
||||
</event>
|
||||
|
||||
<enum name="error">
|
||||
<entry name="invalid_surface_state" value="0" summary="provided surface state is invalid"/>
|
||||
<entry name="invalid_size" value="1" summary="size is invalid"/>
|
||||
<entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/>
|
||||
</enum>
|
||||
|
||||
<enum name="anchor" bitfield="true">
|
||||
<entry name="top" value="1" summary="the top edge of the anchor rectangle"/>
|
||||
<entry name="bottom" value="2" summary="the bottom edge of the anchor rectangle"/>
|
||||
<entry name="left" value="4" summary="the left edge of the anchor rectangle"/>
|
||||
<entry name="right" value="8" summary="the right edge of the anchor rectangle"/>
|
||||
</enum>
|
||||
</interface>
|
||||
</protocol>
|
||||
Loading…
Add table
Add a link
Reference in a new issue