clipmenu: Invert own_selections

own_selections right now is a little inverted from how it worked in
clipmenu 6. It only gates when clipserve starts, but clipserve always
owns PRIMARY and CLIPBOARD. That makes PRIMARY ownership unavoidable
which is not great with terminals that don't handle that well (like
urxvt).

Author: cdown

man/clipmenu.conf.5

@@ -33,7 +33,16 @@ together with own_selections. Default: 0.
 .TP
 .B own_selections
 Specifies which X11 selections (e.g., "clipboard" or "primary") clipmenud
-should actively own. Default: "clipboard".
+should actively own when
+.B own_clipboard
+is enabled. When a clip from one of these selections is stored, clipmenud uses
+clipserve to own those selections. This does not affect which selections are
+monitored; use
+.B selections
+for that. Default: "clipboard".
+If this is set to an empty value, it is treated as if
+.B own_clipboard
+was disabled.
 .TP
 .B selections
 Lists the X11 selections to monitor for changes. Valid values include

man/clipserve.1

@@ -3,11 +3,11 @@
 clipserve \- serve a selected clipboard entry to X11 selections
 .SH SYNOPSIS
 .B clipserve
-<hash>
+[\-s selection]... <hash>
 .SH DESCRIPTION
 .B clipserve
 serves the clipboard content identified by a hash from the clip store on the
-X11 selections (PRIMARY and CLIPBOARD).
+configured X11 selections. By default, it serves both PRIMARY and CLIPBOARD.
 
 This program is not usually invoked directly, but is instead called from inside
 other clipmenu applications.
@@ -16,8 +16,12 @@ other clipmenu applications.
 .B \-h, \--help
 Display the help message (invokes the manual page).
 .TP
-clipserve requires exactly one argument, which is the hexadecimal hash of the
-clipboard entry to be served.
+.B \-s, \--selection
+Specify a selection to serve. Valid values are "primary", "clipboard", and
+"secondary". This option may be repeated. If not provided, PRIMARY and
+CLIPBOARD are used.
+.TP
+clipserve requires a hexadecimal hash of the clipboard entry to be served.
 .SH CONFIGURATION
 See
 .BR clipmenu.conf (5).

src/clipmenu.c

@@ -20,7 +20,7 @@ static int _nonnull_ clipmenu_action(struct config *cfg, uint64_t hash) {
         expect(cs_make_newest(&cs, hash) == 0);
     }
 
-    run_clipserve(hash);
+    run_clipserve(hash, NULL);
     return 0;
 }
 

src/clipmenud.c

@@ -38,6 +38,15 @@ static struct cm_selections sels[CM_SEL_MAX];
 static Time last_disable_time = 0;
 static Time last_enable_time = 0;
 
+static bool has_owned_selections(void) {
+    for (size_t i = 0; i < CM_SEL_MAX; i++) {
+        if (cfg.owned_selections[i].active) {
+            return true;
+        }
+    }
+    return false;
+}
+
 enum clip_text_source {
     CLIP_TEXT_SOURCE_X,
     CLIP_TEXT_SOURCE_MALLOC,
@@ -349,8 +358,8 @@ static void incr_receive_finish(struct incr_transfer *it) {
     if (is_salient_text(ct.data)) {
         uint64_t hash = store_clip(&ct);
         maybe_trim();
-        if (cfg.owned_selections[sel].active && cfg.own_clipboard) {
-            run_clipserve(hash);
+        if (cfg.own_clipboard && has_owned_selections()) {
+            run_clipserve(hash, cfg.owned_selections);
         }
     } else {
         it_dbg(it, "Clipboard text is whitespace only, ignoring\n");
@@ -493,8 +502,8 @@ static int handle_property_notify(const XPropertyEvent *pe) {
              *  2. urxvt and some other terminal emulators will unhilight on
              *     PRIMARY ownership being taken away from them
              */
-            if (cfg.owned_selections[sel].active && cfg.own_clipboard) {
-                run_clipserve(hash);
+            if (cfg.own_clipboard && has_owned_selections()) {
+                run_clipserve(hash, cfg.owned_selections);
             }
         } else {
             dbg("Clipboard text is whitespace only, ignoring\n");

src/clipserve.c

@@ -18,6 +18,19 @@ static Atom incr_atom;
 
 static size_t chunk_size;
 
+static enum selection_type selection_name_to_type(const char *name) {
+    if (streq(name, "clipboard")) {
+        return CM_SEL_CLIPBOARD;
+    }
+    if (streq(name, "primary")) {
+        return CM_SEL_PRIMARY;
+    }
+    if (streq(name, "secondary")) {
+        return CM_SEL_SECONDARY;
+    }
+    return CM_SEL_INVALID;
+}
+
 /**
  * Start an INCR transfer.
  */
@@ -95,13 +108,15 @@ static void incr_send_chunk(const XPropertyEvent *pe) {
  * Serve clipboard content for all X11 selection requests until all selections
  * have been claimed by another application.
  */
-static void _nonnull_ serve_clipboard(uint64_t hash,
-                                      struct cs_content *content) {
+static void _nonnull_ serve_clipboard(uint64_t hash, struct cs_content *content,
+                                      const bool selection_active[CM_SEL_MAX]) {
     bool running = true;
     XEvent evt;
-    Atom targets, utf8_string, selections[2] = {XA_PRIMARY};
+    Atom targets, utf8_string;
+    Atom selection_atoms[CM_SEL_MAX];
     Window win;
     int remaining_selections;
+    size_t selection_atoms_len = 0;
 
     dpy = XOpenDisplay(NULL);
     expect(dpy);
@@ -114,25 +129,37 @@ static void _nonnull_ serve_clipboard(uint64_t hash,
     utf8_string = XInternAtom(dpy, "UTF8_STRING", False);
     incr_atom = XInternAtom(dpy, "INCR", False);
 
-    selections[1] = XInternAtom(dpy, "CLIPBOARD", False);
-    for (size_t i = 0; i < arrlen(selections); i++) {
+    if (selection_active[CM_SEL_PRIMARY]) {
+        selection_atoms[selection_atoms_len++] = XA_PRIMARY;
+    }
+    if (selection_active[CM_SEL_CLIPBOARD]) {
+        selection_atoms[selection_atoms_len++] =
+            XInternAtom(dpy, "CLIPBOARD", False);
+    }
+    if (selection_active[CM_SEL_SECONDARY]) {
+        selection_atoms[selection_atoms_len++] = XA_SECONDARY;
+    }
+
+    die_on(selection_atoms_len == 0, "No selections configured\n");
+
+    for (size_t i = 0; i < selection_atoms_len; i++) {
         bool success = false;
         for (int attempts = 0; attempts < 5; attempts++) {
-            XSetSelectionOwner(dpy, selections[i], win, CurrentTime);
+            XSetSelectionOwner(dpy, selection_atoms[i], win, CurrentTime);
 
             // According to ICCCM 2.1, a client acquiring a selection should
             // confirm success by verifying with GetSelectionOwner.
-            if (XGetSelectionOwner(dpy, selections[i]) == win) {
+            if (XGetSelectionOwner(dpy, selection_atoms[i]) == win) {
                 success = true;
                 break;
             }
         }
         if (!success) {
             die("Failed to set selection for %s\n",
-                XGetAtomName(dpy, selections[i]));
+                XGetAtomName(dpy, selection_atoms[i]));
         }
     }
-    remaining_selections = arrlen(selections);
+    remaining_selections = (int)selection_atoms_len;
 
     while (running) {
         XNextEvent(dpy, &evt);
@@ -202,12 +229,39 @@ static void _nonnull_ serve_clipboard(uint64_t hash,
 }
 
 int main(int argc, char *argv[]) {
-    die_on(argc != 2, "Usage: clipserve [hash]\n");
     _drop_(config_free) struct config cfg = setup("clipserve");
     exec_man_on_help(argc, argv);
 
+    bool selection_active[CM_SEL_MAX] = {0};
+    bool selection_set = false;
+    int argi = 1;
+    for (; argi < argc; argi++) {
+        if (streq(argv[argi], "--")) {
+            argi++;
+            break;
+        }
+        if (streq(argv[argi], "-s") || streq(argv[argi], "--selection")) {
+            die_on(argi + 1 >= argc,
+                   "Usage: clipserve [-s selection]... <hash>\n");
+            enum selection_type sel = selection_name_to_type(argv[++argi]);
+            die_on(sel == CM_SEL_INVALID, "Unknown selection: %s\n",
+                   argv[argi]);
+            selection_active[sel] = true;
+            selection_set = true;
+            continue;
+        }
+        break;
+    }
+
+    die_on(argi != argc - 1, "Usage: clipserve [-s selection]... <hash>\n");
+
+    if (!selection_set) {
+        selection_active[CM_SEL_PRIMARY] = true;
+        selection_active[CM_SEL_CLIPBOARD] = true;
+    }
+
     uint64_t hash;
-    expect(str_to_hex64(argv[1], &hash) == 0);
+    expect(str_to_hex64(argv[argi], &hash) == 0);
 
     _drop_(close) int content_dir_fd = open(get_cache_dir(&cfg), O_RDONLY);
     _drop_(close) int snip_fd =
@@ -221,7 +275,7 @@ int main(int argc, char *argv[]) {
     die_on(cs_content_get(&cs, hash, &content) < 0,
            "Hash " PRI_HASH " inaccessible\n", hash);
 
-    serve_clipboard(hash, &content);
+    serve_clipboard(hash, &content, selection_active);
 
     return 0;
 }

src/util.c

@@ -3,6 +3,7 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "config.h"
 #include "store.h"
 #include "util.h"
 
@@ -54,11 +55,27 @@ size_t snprintf_safe(char *buf, size_t len, const char *fmt, ...) {
 /**
  * Runs clipserve to handle selection requests for a hash in the clip store.
  */
-void run_clipserve(uint64_t hash) {
+#define CLIPSERVE_MAX_ARGS (CM_SEL_MAX * 2 + 3)
+
+void run_clipserve(uint64_t hash, const struct selection *selections) {
     char hash_str[CS_HASH_STR_MAX];
     snprintf(hash_str, sizeof(hash_str), PRI_HASH, hash);
 
-    const char *const cmd[] = {"clipserve", hash_str, NULL};
+    const char *cmd[CLIPSERVE_MAX_ARGS];
+    size_t cmd_idx = 0;
+    cmd[cmd_idx++] = "clipserve";
+    if (selections) {
+        for (size_t i = 0; i < CM_SEL_MAX; i++) {
+            if (!selections[i].active) {
+                continue;
+            }
+            expect(cmd_idx + 2 < CLIPSERVE_MAX_ARGS);
+            cmd[cmd_idx++] = "--selection";
+            cmd[cmd_idx++] = selections[i].name;
+        }
+    }
+    cmd[cmd_idx++] = hash_str;
+    cmd[cmd_idx++] = NULL;
     pid_t pid = fork();
     expect(pid >= 0);
 

src/util.h

@@ -8,6 +8,8 @@
 #include <stdlib.h>
 #include <unistd.h>
 
+struct selection;
+
 #define _drop_(x) __attribute__((__cleanup__(drop_##x)))
 #define _must_use_ __attribute__((warn_unused_result))
 #define _nonnull_ __attribute__((nonnull))
@@ -69,7 +71,7 @@ size_t _nonnull_ read_safe(int fd, char *buf, size_t count);
 size_t _printf_(3, 4)
     snprintf_safe(char *buf, size_t len, const char *fmt, ...);
 
-void run_clipserve(uint64_t hash);
+void run_clipserve(uint64_t hash, const struct selection *selections);
 
 /**
  * __attribute__((cleanup)) functions

tests/x_integration_tests

@@ -116,6 +116,7 @@ xsel -pc
 xsel -sc
 
 clipmenud &
+clipmenud_pid=$!
 settle
 
 # Should be empty
@@ -290,6 +291,37 @@ settle
 
 check_nr_clips 6
 
+# own_selections: default does not own PRIMARY
+kill "$clipmenud_pid"
+wait "$clipmenud_pid" || true
+pkill -x clipserve 2>/dev/null || true
+CM_OWN_CLIPBOARD=1 CM_OWN_SELECTIONS=clipboard clipmenud &
+clipmenud_pid=$!
+settle
+xsel -bc
+xsel -pc
+printf 'primary_stale' | xsel -p
+printf 'clip_default' | xsel -b
+settle
+[[ "$(xsel -bo)" == clip_default ]]
+primary_out=$(xsel -po 2>/dev/null || true)
+[[ "$primary_out" != clip_default ]]
+
+# own_selections: owns all listed selections
+kill "$clipmenud_pid"
+wait "$clipmenud_pid" || true
+pkill -x clipserve 2>/dev/null || true
+CM_OWN_CLIPBOARD=1 CM_OWN_SELECTIONS='clipboard primary' clipmenud &
+clipmenud_pid=$!
+settle
+xsel -bc
+xsel -pc
+printf 'primary_stale' | xsel -p
+printf 'own_both' | xsel -b
+settle
+[[ "$(xsel -bo)" == own_both ]]
+[[ "$(xsel -po)" == own_both ]]
+
 if (( _UNSHARED )); then
     umount -l /tmp
 fi