X11: support copying text to CLIPBOARD

Use the right mouse button.
This commit is contained in:
Přemysl Eric Janouch 2022-08-25 06:06:19 +02:00
parent 6dad74f3c9
commit 172ceffa9e
Signed by: p
GPG Key ID: A0420B94F92B9493
1 changed files with 167 additions and 50 deletions

209
nncmpp.c
View File

@ -109,6 +109,7 @@ enum
// Elementary port of the TUI to X11. // Elementary port of the TUI to X11.
#ifdef WITH_X11 #ifdef WITH_X11
#include <X11/Xatom.h>
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <X11/keysym.h> #include <X11/keysym.h>
#include <X11/XKBlib.h> #include <X11/XKBlib.h>
@ -1152,6 +1153,9 @@ struct widget;
/// Draw a widget on the window /// Draw a widget on the window
typedef void (*widget_render_fn) (struct widget *self); typedef void (*widget_render_fn) (struct widget *self);
/// Extract the contents of container widgets
typedef struct widget *(*widget_sublayout_fn) (struct widget *self);
/// A minimal abstraction appropriate for both TUI and GUI widgets. /// A minimal abstraction appropriate for both TUI and GUI widgets.
/// Units for the widget's region are frontend-specific. /// Units for the widget's region are frontend-specific.
/// Having this as a linked list simplifies layouting and memory management. /// Having this as a linked list simplifies layouting and memory management.
@ -1165,6 +1169,7 @@ struct widget
int height; ///< Height, initialized by UI methods int height; ///< Height, initialized by UI methods
widget_render_fn on_render; ///< Render callback widget_render_fn on_render; ///< Render callback
widget_sublayout_fn on_sublayout; ///< Optional sublayout callback
chtype attrs; ///< Rendition, in Curses terms chtype attrs; ///< Rendition, in Curses terms
short id; ///< Post-layouting identification short id; ///< Post-layouting identification
@ -1362,6 +1367,7 @@ static struct app_context
XftDraw *xft_draw; ///< Xft rendering context XftDraw *xft_draw; ///< Xft rendering context
XftFont *xft_regular; ///< Regular font XftFont *xft_regular; ///< Regular font
XftFont *xft_bold; ///< Bold font XftFont *xft_bold; ///< Bold font
char *x11_selection; ///< CLIPBOARD selection
XRenderColor x_fg[ATTRIBUTE_COUNT]; ///< Foreground per attribute XRenderColor x_fg[ATTRIBUTE_COUNT]; ///< Foreground per attribute
XRenderColor x_bg[ATTRIBUTE_COUNT]; ///< Background per attribute XRenderColor x_bg[ATTRIBUTE_COUNT]; ///< Background per attribute
@ -1736,14 +1742,14 @@ app_invalidate (void)
} }
static void static void
app_flush_layout (struct layout *l) app_flush_layout_to (struct layout *l, int width, struct layout *dest)
{ {
hard_assert (l != NULL && l->head != NULL); hard_assert (l != NULL && l->head != NULL);
widget_redistribute (l->head, g.ui_width); widget_redistribute (l->head, width);
struct widget *last = g.widgets.tail; struct widget *last = dest->tail;
if (!last) if (!last)
g.widgets = *l; *dest = *l;
else else
{ {
// Assuming there is no unclaimed vertical space. // Assuming there is no unclaimed vertical space.
@ -1752,10 +1758,16 @@ app_flush_layout (struct layout *l)
last->next = l->head; last->next = l->head;
l->head->prev = last; l->head->prev = last;
g.widgets.tail = l->tail; dest->tail = l->tail;
} }
} }
static void
app_flush_layout (struct layout *l)
{
app_flush_layout_to (l, g.ui_width, &g.widgets);
}
static struct widget * static struct widget *
app_push (struct layout *l, struct widget *w) app_push (struct layout *l, struct widget *w)
{ {
@ -2041,7 +2053,7 @@ app_compute_scrollbar (struct tab *tab, long visible, long s)
return (struct scrollbar) { length, offset }; return (struct scrollbar) { length, offset };
} }
static struct widget * static struct layout
app_layout_row (struct tab *tab, int item_index) app_layout_row (struct tab *tab, int item_index)
{ {
int row_attrs = (item_index & 1) ? APP_ATTR (ODD) : APP_ATTR (EVEN); int row_attrs = (item_index & 1) ? APP_ATTR (ODD) : APP_ATTR (EVEN);
@ -2075,6 +2087,30 @@ app_layout_row (struct tab *tab, int item_index)
else else
*attrs |= row_attrs; *attrs |= row_attrs;
} }
return l;
}
// XXX: This isn't a very clean design, in that part of layouting
// is done during the rendering stage.
static struct widget *
app_sublayout_list (struct widget *list)
{
struct tab *tab = g.active_tab;
int to_show = MIN ((int) tab->item_count - tab->item_top,
list->height / g.ui_vunit);
struct layout l = {};
for (int row = 0; row < to_show; row++)
{
int item_index = tab->item_top + row;
struct layout subl = app_layout_row (tab, item_index);
app_flush_layout_to (&subl, list->width, &l);
}
LIST_FOR_EACH (struct widget, w, l.head)
{
w->x += list->x;
w->y += list->y;
}
return l.head; return l.head;
} }
@ -5124,29 +5160,11 @@ tui_make_scrollbar (chtype attrs)
static void static void
tui_render_list (struct widget *self) tui_render_list (struct widget *self)
{ {
struct tab *tab = g.active_tab; LIST_FOR_EACH (struct widget, w, self->on_sublayout (self))
int to_show =
MIN (app_visible_items (), (int) tab->item_count - tab->item_top);
for (int row = 0; row < to_show; row++)
{
int item_index = tab->item_top + row;
struct widget *head = app_layout_row (tab, item_index);
widget_redistribute (head, self->width);
int x = self->x;
int y = self->y + row * g.ui_vunit;
LIST_FOR_EACH (struct widget, w, head)
{
w->x += x;
w->y += y;
}
LIST_FOR_EACH (struct widget, w, head)
{ {
w->on_render (w); w->on_render (w);
free (w); free (w);
} }
}
} }
static struct widget * static struct widget *
@ -5156,6 +5174,7 @@ tui_make_list (void)
w->width = -1; w->width = -1;
w->height = g.active_tab->item_count; w->height = g.active_tab->item_count;
w->on_render = tui_render_list; w->on_render = tui_render_list;
w->on_sublayout = app_sublayout_list;
return w; return w;
} }
@ -5749,29 +5768,11 @@ x11_render_list (struct widget *self)
{ {
x11_render_padding (self); x11_render_padding (self);
struct tab *tab = g.active_tab; LIST_FOR_EACH (struct widget, w, self->on_sublayout (self))
int to_show =
MIN (app_visible_items (), (int) tab->item_count - tab->item_top);
for (int row = 0; row < to_show; row++)
{
int item_index = tab->item_top + row;
struct widget *head = app_layout_row (tab, item_index);
widget_redistribute (head, self->width);
int x = self->x;
int y = self->y + row * g.ui_vunit;
LIST_FOR_EACH (struct widget, w, head)
{
w->x += x;
w->y += y;
}
LIST_FOR_EACH (struct widget, w, head)
{ {
w->on_render (w); w->on_render (w);
free (w); free (w);
} }
}
} }
static struct widget * static struct widget *
@ -5779,6 +5780,7 @@ x11_make_list (void)
{ {
struct widget *w = xcalloc (1, sizeof *w + 1); struct widget *w = xcalloc (1, sizeof *w + 1);
w->on_render = x11_render_list; w->on_render = x11_render_list;
w->on_sublayout = app_sublayout_list;
return w; return w;
} }
@ -5862,6 +5864,7 @@ x11_destroy (void)
XftDrawDestroy (g.xft_draw); XftDrawDestroy (g.xft_draw);
XftFontClose (g.dpy, g.xft_regular); XftFontClose (g.dpy, g.xft_regular);
XftFontClose (g.dpy, g.xft_bold); XftFontClose (g.dpy, g.xft_bold);
cstr_set (&g.x11_selection, NULL);
poller_fd_reset (&g.x11_event); poller_fd_reset (&g.x11_event);
XCloseDisplay (g.dpy); XCloseDisplay (g.dpy);
@ -6035,6 +6038,57 @@ x11_init_pixmap (void)
= XRenderCreatePicture (g.dpy, g.x11_pixmap, format, 0, NULL); = XRenderCreatePicture (g.dpy, g.x11_pixmap, format, 0, NULL);
} }
static char *
x11_find_text (struct widget *list, int x, int y)
{
struct widget *target = NULL;
LIST_FOR_EACH (struct widget, w, list)
if (x >= w->x && x < w->x + w->width
&& y >= w->y && y < w->y + w->height)
target = w;
if (!target)
return NULL;
if (target->on_sublayout)
{
struct widget *sublist = target->on_sublayout (target);
char *result = x11_find_text (sublist, x, y);
LIST_FOR_EACH (struct widget, w, sublist)
free (w);
if (result)
return result;
}
return xstrdup (target->text);
}
// TODO: OSC 52 exists for terminals, so make it possible to enable that there.
static bool
x11_process_press (int x, int y, int button, int modifiers)
{
if (button != Button3)
goto out;
char *text = x11_find_text (g.widgets.head, x, y);
if (!text || !*(cstr_strip_in_place (text, " \t")))
{
free (text);
goto out;
}
cstr_set (&g.x11_selection, text);
XSetSelectionOwner (g.dpy, XInternAtom (g.dpy, "CLIPBOARD", False),
g.x11_window, CurrentTime);
cstr_set (&g.message,
xstrdup_printf ("Text copied to clipboard: %s", g.x11_selection));
poller_timer_set (&g.message_timer, 5000);
app_invalidate ();
return true;
out:
return app_process_mouse (TERMO_MOUSE_PRESS, x, y, button, modifiers);
}
static int static int
x11_state_to_modifiers (unsigned int state) x11_state_to_modifiers (unsigned int state)
{ {
@ -6079,14 +6133,66 @@ on_x11_input_event (XEvent *ev)
last_press_event = *ev; last_press_event = *ev;
if (ev->type == ButtonPress) if (ev->type == ButtonPress)
return app_process_mouse return x11_process_press (x, y, button, modifiers);
(TERMO_MOUSE_PRESS, x, y, button, modifiers);
if (ev->type == ButtonRelease) if (ev->type == ButtonRelease)
return app_process_mouse return app_process_mouse
(TERMO_MOUSE_RELEASE, x, y, button, modifiers); (TERMO_MOUSE_RELEASE, x, y, button, modifiers);
return false; return false;
} }
static void
on_x11_selection_request (XSelectionRequestEvent *ev)
{
Atom xa_targets = XInternAtom (g.dpy, "TARGETS", False);
Atom xa_compound_text = XInternAtom (g.dpy, "COMPOUND_TEXT", False);
Atom xa_utf8 = XInternAtom (g.dpy, "UTF8_STRING", False);
Atom targets[] = { xa_targets, XA_STRING, xa_compound_text, xa_utf8 };
bool ok = false;
Atom property = ev->property ? ev->property : ev->target;
if (!g.x11_selection)
goto out;
XICCEncodingStyle style = 0;
if ((ok = ev->target == xa_targets))
{
XChangeProperty (g.dpy, ev->requestor, property,
XA_ATOM, 32, PropModeReplace,
(const unsigned char *) targets, N_ELEMENTS (targets));
goto out;
}
else if (ev->target == XA_STRING)
style = XStringStyle;
else if (ev->target == xa_compound_text)
style = XCompoundTextStyle;
else if (ev->target == xa_utf8)
style = XUTF8StringStyle;
else
goto out;
// XXX: We let it crash us with BadLength, but we may, e.g., use INCR.
XTextProperty text = {};
if ((ok = !Xutf8TextListToTextProperty
(g.dpy, &g.x11_selection, 1, style, &text)))
{
XChangeProperty (g.dpy, ev->requestor, property,
text.encoding, text.format, PropModeReplace,
text.value, text.nitems);
}
XFree (text.value);
out:
XEvent response = {};
response.xselection.type = SelectionNotify;
// XXX: We should check it against the event causing XSetSelectionOwner().
response.xselection.time = ev->time;
response.xselection.requestor = ev->requestor;
response.xselection.selection = ev->selection;
response.xselection.target = ev->target;
response.xselection.property = ok ? property : None;
XSendEvent (g.dpy, ev->requestor, False, 0, &response);
}
static void static void
on_x11_event (XEvent *ev) on_x11_event (XEvent *ev)
{ {
@ -6115,6 +6221,12 @@ on_x11_event (XEvent *ev)
XftDrawChange (g.xft_draw, g.x11_pixmap); XftDrawChange (g.xft_draw, g.x11_pixmap);
app_invalidate (); app_invalidate ();
break; break;
case SelectionRequest:
on_x11_selection_request (&ev->xselectionrequest);
break;
case SelectionClear:
cstr_set (&g.x11_selection, NULL);
break;
case UnmapNotify: case UnmapNotify:
app_quit (); app_quit ();
break; break;
@ -6173,6 +6285,11 @@ on_x11_error (Display *dpy, XErrorEvent *event)
|| (event->error_code == BadDrawable && event->resourceid == g.x11_window)) || (event->error_code == BadDrawable && event->resourceid == g.x11_window))
return app_quit (), 0; return app_quit (), 0;
// XXX: The simplest possible way of discarding selection management errors.
// XCB would be a small win here, but it is a curse at the same time.
if (event->error_code == BadWindow && event->resourceid != g.x11_window)
return 0;
return x11_default_error_handler (dpy, event); return x11_default_error_handler (dpy, event);
} }