fvwm-window-search 1.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 580941b472f2b948d9f6d854a337a1d066646c7b3705986f76f3b429845026a3
-  data.tar.gz: 2e7b0a76b19a24514641ce603f35eee86f380bc8293c155014e80bfba9b24652
+  metadata.gz: 128a87d266fc2fa55f7a0a49e4754ff7026eeb13ea1e9db1c392fa5615e6e8ea
+  data.tar.gz: a4da76f60401c5cf6ed56069032b1014efd2224da4deaaf11a1ff4ac5e282870
 SHA512:
-  metadata.gz: e85229be05ab43082df6362ca7b4b72c5f57cfdca85835027c979f305d01c332d74d5fa6830338548e08beb0718b4b25f2cd382c03da4ff66b5bce7a05429d79
-  data.tar.gz: e9926afb792d151259ca4dadd48d6346da71437cbdc7642009392d08ff1e03a610b10b78e12475a58a6b901efb0551192d2977394e08e06aabdf51772e7c46e2
+  metadata.gz: a4892c1dde0908b82df3c249aa7768572de54622033286290f92ce0ea251ccbe881538a4a068b2c98a2e21a345bffabb8247b9633ed7ceeb3ee606ee6110246f
+  data.tar.gz: e51b7dd7ea7c4184003873004b34d46103a4a38c673ee8368f6aba3758730993ca3578f15c26dcc6af39e091153fa312c161cba4a0b4b1fad457de32275d0d97

data/Makefile

@@ -1,6 +1,8 @@
 out := _out
 dmenu := $(out)/dmenu
-dmenu.commit := 9b38fda6feda68f95754d5b8932b1a69471df960
+dmenu.commit := 1a13d0465d1a6f4f74bc5b07b04c9bd542f20ba6
+
+all: $(addprefix $(out)/, .dmenu.build activate winlist fontinfo)
 
 $(out)/.dmenu.build: $(out)/.dmenu.$(dmenu.commit) dmenu.patch
 	patch -d $(dmenu) -p1 < dmenu.patch
@@ -12,5 +14,15 @@ $(out)/.dmenu.$(dmenu.commit):
 	git -C $(dmenu) checkout $(dmenu.commit) -q
 	touch $@
 
+libs := x11
+LDFLAGS = $(shell pkg-config --libs $(libs))
+CFLAGS = -g -Wall -Werror $(shell pkg-config --cflags $(libs))
+$(out)/%: %.c lib.c
+	$(LINK.c) $< $(LOADLIBES) $(LDLIBS) -o $@
+
+$(out)/activate: libs += jansson
+$(out)/winlist: libs += jansson
+$(out)/fontinfo: libs += xft freetype2
+
 # an empty target to satisfy rubygems
 install:

data/README.md

@@ -5,24 +5,35 @@ Incremental window search & immediate switch to the selected window
 
     $ gem install fvwm-window-search
 
-![A screenshot of running fvwm-window-search](https://raw.github.com/gromnitsky/fvwm-window-search/master/screnshot1.png)
+![demo](https://sigwait.tk/~alex/junk/fvwm-window-search-2.2.0.gif)
 
-* Should work w/ any X11 window manager.
-* Filtering by windows names/resources/classes.
+* Should work w/ most EWMH-compliant stackings X11 window managers.
+* Filter by window name/resource/class.
+* Optionally list windows from the current desktop only.
+* Preserve minimised/shaded window states.
 
 ## Reqs
 
-* Ruby
-* `xwininfo` & `xdotool` (`xorg-x11-utils` & `xdotool` Fedora pkgs)
+* Ruby 2.1+
+* `dnf install jansson-devel freetype-devel`
 
 ## Compilation
 
-Type `make`. This clones the dmenu repo, patches & builds it. It does
-not contravene w/ a system-installed dmenu.
+Type `make`. This clones the dmenu repo, patches & builds it. It
+doesn't interfere w/ a system-installed dmenu.
 
 ## Usage
 
-Run `fvwm-window-search`.
+~~~
+$ ./fvwm-window-search -h
+Usage: fvwm-window-search [options]
+    -c path                     an alternative path to conf.yaml
+    -d                          list windows from the current desktop only
+    -r                          switch to a window only when <Return> is pressed
+~~~
+
+To scroll in dmenu (using Up/Down/Home/End/PgUp/PgDown) without
+windows activation, hold <kbd>Shift</kbd>.
 
 To customise dmenu or filtering, create a yaml file
 `$XDG_CONFIG_HOME/fvwm-window-search/conf.yaml`, e.g.:
@@ -32,27 +43,32 @@ To customise dmenu or filtering, create a yaml file
 dmenu:
   fn: Monospace-12
   b: false
-  selhook-return-key-focus-only: true
-filter:
+  selection_hook_activation_return_key_only: true
+filter-out:
     name: ['System Monitor']
     resource: []
     class: []
 ~~~
 
 Subkeys in `dmenu` are the usual CLOs for
-[dmenu(1)][]. `selhook-return-key-focus-only` is a custom one, that
-enables window focusing on pressing Return only.
+[dmenu(1)][]. `selection_hook_activation_return_key_only` is an
+equivalent of `-r` CLO.
 
 [dmenu(1)]: https://manpages.debian.org/unstable/suckless-tools/dmenu.1.en.html
 
-`filter` key tells what windows should be filtered out. Each value in
-a subkey is an array of regexes. See the defaults in
+`filter-out` key tells what windows should be ignored. Each value in a
+subkey is an array of regexes. See the defaults at the top of
 `fvwm-window-search` file.
 
-## Bugs
+## Start-up time
+
+As a task switcher, the program must not only run fast, but also
+*start* fast. I managed to get it under 70ms on my laptop, when you
+run `./fvwm-window-search` directly from the repo.
 
-* Tested only w/ Ruby-2.7.0 & Fvwm3.
-* No distinction between normal & iconified windows.
+This is not the case with rubygems! The latter generates a stub script
+that invokes `./fvwm-window-search` file. This indirection may add
+~140ms of additional delay.
 
 ## License
 

data/activate.c

@@ -0,0 +1,161 @@
+#include <err.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+#include <libgen.h>
+#include <sys/utsname.h>
+
+#include <jansson.h>
+
+#include "lib.c"
+
+ulong str2id(const char *s) {
+    ulong id;
+    if (sscanf(s, "0x%lx", &id) != 1 &&
+        sscanf(s, "0X%lx", &id) != 1 &&
+        sscanf(s, "%lu", &id) != 1) return 0;
+    return id;
+}
+
+bool client_msg(Display *dpy, Window id, const char *msg,
+                unsigned long data0, unsigned long data1,
+                unsigned long data2, unsigned long data3,
+                unsigned long data4) {
+    XEvent event;
+    long mask = SubstructureRedirectMask | SubstructureNotifyMask;
+
+    event.xclient.type = ClientMessage;
+    event.xclient.serial = 0;
+    event.xclient.send_event = True;
+    event.xclient.message_type = XInternAtom(dpy, msg, False);
+    event.xclient.window = id;
+    event.xclient.format = 32;
+    event.xclient.data.l[0] = data0;
+    event.xclient.data.l[1] = data1;
+    event.xclient.data.l[2] = data2;
+    event.xclient.data.l[3] = data3;
+    event.xclient.data.l[4] = data4;
+
+    if (XSendEvent(dpy, DefaultRootWindow(dpy), False, mask, &event))
+      return true;
+    warnx("cannot send %s event", msg);
+    return false;
+}
+
+bool window_activate(Display *dpy, Window id) {
+  long desk = desktop(dpy, id);
+  if (-1 != desk) {
+    client_msg(dpy, DefaultRootWindow(dpy), "_NET_CURRENT_DESKTOP",
+               desk, 0, 0, 0, 0);
+  }
+
+  bool active = client_msg(dpy, id, "_NET_ACTIVE_WINDOW", 0, 0, 0, 0, 0);
+
+  const int _net_wm_state_rm = 0;
+  bool unshaded = client_msg(dpy, id, "_NET_WM_STATE", _net_wm_state_rm,
+                             myAtoms._NET_WM_STATE_SHADED, 0, 0, 0);
+
+  XMapRaised(dpy, id);
+  return active && unshaded;
+}
+
+bool window_center_mouse(Display *dpy, ulong id) {
+  XWindowAttributes attrs;
+  if (!XGetWindowAttributes(dpy, id, &attrs)) return false;
+  if (!XWarpPointer(dpy, 0, id, 0, 0, 0, 0, attrs.width/2, attrs.height/2))
+    return false;
+  XFlush(dpy);
+  return true;
+}
+
+// the result shout be freed
+char* config() {
+  char xdg_runtime_home[PATH_MAX-64];
+  if (getenv("XDG_RUNTIME_HOME")) {
+    snprintf(xdg_runtime_home, PATH_MAX-64, "%s", getenv("XDG_RUNTIME_HOME"));
+  } else {
+    struct utsname info;
+    uname(&info);
+    char *template = 0 == strcmp(info.sysname, "Linux") ? "/run/user/%d" : "/tmp/user/%d";
+    snprintf(xdg_runtime_home, PATH_MAX-64, template, getuid());
+  }
+  char *file = (char*)malloc(PATH_MAX);
+  snprintf(file, PATH_MAX, "%s/%s/%s",
+           xdg_runtime_home, "fvwm-window-search", "last_window.json");
+
+  char *dir = dirname(strdup(file));
+  if (!mkdir_p(dir, 0700)) {
+    warn("failed to create %s", dir);
+    return NULL;
+  }
+  free(dir);
+  return file;
+}
+
+void state_save(Display *dpy, Window id) {
+  char *file = config();
+  int fd = open(file, O_WRONLY | O_CREAT | O_TRUNC, 0600); if (-1 == fd) {
+    warn("failed to truncate %s", file);
+    return;
+  }
+  free(file);
+
+  WindowState ws = state(dpy, id);
+  json_t *o = json_object();
+  json_object_set_new(o, "id", json_integer(ws.id));
+  json_object_set_new(o, "_NET_WM_STATE_SHADED", json_boolean(ws._NET_WM_STATE_SHADED));
+  json_object_set_new(o, "_NET_WM_STATE_HIDDEN", json_boolean(ws._NET_WM_STATE_HIDDEN));
+
+  char *dump = json_dumps(o, JSON_COMPACT);
+  write(fd, dump, strlen(dump));
+  free(dump);
+  json_decref(o);
+
+  close(fd);
+}
+
+Window state_load(Display *dpy, Window  id_current) {
+  char *file = config();
+  json_t *root = json_load_file(file, 0, NULL);
+  free(file);
+  if (!root) return 0;
+
+  Window id = json_integer_value(json_object_get(root, "id"));
+  if (id == id_current) return id;
+
+  const int _net_wm_state_add = 1;
+  bool is_shaded = json_boolean_value(json_object_get(root, "_NET_WM_STATE_SHADED"));
+  if (is_shaded) client_msg(dpy, id, "_NET_WM_STATE", _net_wm_state_add,
+                            myAtoms._NET_WM_STATE_SHADED, 0, 0, 0);
+  bool is_hidden = json_boolean_value(json_object_get(root, "_NET_WM_STATE_HIDDEN"));
+  if (is_hidden) client_msg(dpy, id, "_NET_WM_STATE", _net_wm_state_add,
+                            myAtoms._NET_WM_STATE_HIDDEN, 0, 0, 0);
+
+  json_decref(root);
+  return id;
+}
+
+
+
+int main(int argc, char **argv) {
+  Display *dpy = XOpenDisplay(getenv("DISPLAY"));
+  if (!dpy) errx(1, "failed to open display %s", getenv("DISPLAY"));
+  if (argc != 2) errx(1, "usage: activate window-id");
+
+  mk_atoms(dpy);
+
+  ulong id = str2id(argv[1]);
+  if (!id) errx(1, "invalid window id: `%s`", argv[1]);
+
+  Window prev_id = state_load(dpy, id);
+  if (prev_id != id) state_save(dpy, id);
+
+  XSynchronize(dpy, True); // snake oil?
+  bool r = window_activate(dpy, id);
+  if (!r) return 1;
+  r = window_center_mouse(dpy, id);
+  return !r;
+}

data/activate.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+id=`echo "$1" | awk -F'|' '{print $NF} END { exit $NF == "" ? 1 : 0}'` || {
+    echo "usage: `basename "$0"` 'foo | bar | id'"
+    exit 1
+}
+
+__filename=`readlink -f "$0"`
+__dirname=`dirname "${__filename}"`
+
+# shellcheck disable=2086
+${__dirname}/_out/activate $id

data/dmenu.patch

@@ -14,19 +14,20 @@ index a03a95c..ee5cffb 100644
  $(OBJ): arg.h config.h config.mk drw.h
  
 diff --git a/config.def.h b/config.def.h
-index 1edb647..1920110 100644
+index 1edb647..65c831f 100644
 --- a/config.def.h
 +++ b/config.def.h
-@@ -21,3 +21,7 @@ static unsigned int lines      = 0;
+@@ -21,3 +21,8 @@ static unsigned int lines      = 0;
   * for example: " /?\"&[]"
   */
  static const char worddelimiters[] = " ";
 +
-+/* -selhook option; run a command on every selection */
++/* -selection_hook option; run a command on every selection */
 +static const char *selection_hook = NULL;
-+static int selection_hook_return_key_focus_only = 0;
++static int selection_hook_activation = 1;
++static int selection_hook_activation_return_key_only = 0;
 diff --git a/dmenu.c b/dmenu.c
-index 65f25ce..274668a 100644
+index 65f25ce..47a6b37 100644
 --- a/dmenu.c
 +++ b/dmenu.c
 @@ -304,6 +304,62 @@ movewordedge(int dir)
@@ -92,7 +93,45 @@ index 65f25ce..274668a 100644
  static void
  keypress(XKeyEvent *ev)
  {
-@@ -464,6 +520,7 @@ insert:
+@@ -410,6 +466,7 @@ insert:
+ 		insert(NULL, nextrune(-1) - cursor);
+ 		break;
+ 	case XK_End:
++		if (ev->state & ShiftMask) selection_hook_activation = 0;
+ 		if (text[cursor] != '\0') {
+ 			cursor = strlen(text);
+ 			break;
+@@ -429,6 +486,7 @@ insert:
+ 		cleanup();
+ 		exit(1);
+ 	case XK_Home:
++		if (ev->state & ShiftMask) selection_hook_activation = 0;
+ 		if (sel == matches) {
+ 			cursor = 0;
+ 			break;
+@@ -445,18 +503,21 @@ insert:
+ 			return;
+ 		/* fallthrough */
+ 	case XK_Up:
++		if (ev->state & ShiftMask) selection_hook_activation = 0;
+ 		if (sel && sel->left && (sel = sel->left)->right == curr) {
+ 			curr = prev;
+ 			calcoffsets();
+ 		}
+ 		break;
+ 	case XK_Next:
++		if (ev->state & ShiftMask) selection_hook_activation = 0;
+ 		if (!next)
+ 			return;
+ 		sel = curr = next;
+ 		calcoffsets();
+ 		break;
+ 	case XK_Prior:
++		if (ev->state & ShiftMask) selection_hook_activation = 0;
+ 		if (!prev)
+ 			return;
+ 		sel = curr = prev;
+@@ -464,6 +525,7 @@ insert:
  		break;
  	case XK_Return:
  	case XK_KP_Enter:
@@ -100,29 +139,40 @@ index 65f25ce..274668a 100644
  		puts((sel && !(ev->state & ShiftMask)) ? sel->text : text);
  		if (!(ev->state & ControlMask)) {
  			cleanup();
-@@ -572,6 +629,8 @@ run(void)
+@@ -481,6 +543,7 @@ insert:
+ 			return;
+ 		/* fallthrough */
+ 	case XK_Down:
++		if (ev->state & ShiftMask) selection_hook_activation = 0;
+ 		if (sel && sel->right && (sel = sel->right) == next) {
+ 			curr = next;
+ 			calcoffsets();
+@@ -572,6 +635,11 @@ run(void)
  			break;
  		case KeyPress:
  			keypress(&ev.xkey);
-+			if (!selection_hook_return_key_focus_only)
++			if (!selection_hook_activation_return_key_only &&
++				selection_hook_activation)
 +				selhook(selection_hook, sel);
++
++			selection_hook_activation = 1;
  			break;
  		case SelectionNotify:
  			if (ev.xselection.property == utf8)
-@@ -712,6 +771,8 @@ main(int argc, char *argv[])
+@@ -712,6 +780,8 @@ main(int argc, char *argv[])
  		else if (!strcmp(argv[i], "-i")) { /* case-insensitive item matching */
  			fstrncmp = strncasecmp;
  			fstrstr = cistrstr;
-+		} else if (!strcmp(argv[i], "-selhook-return-key-focus-only")) {
-+			selection_hook_return_key_focus_only = 1;
++		} else if (!strcmp(argv[i], "-selection_hook_activation_return_key_only")) {
++			selection_hook_activation_return_key_only = 1;
  		} else if (i + 1 == argc)
  			usage();
  		/* these options take one argument */
-@@ -733,6 +794,8 @@ main(int argc, char *argv[])
+@@ -733,6 +803,8 @@ main(int argc, char *argv[])
  			colors[SchemeSel][ColFg] = argv[++i];
  		else if (!strcmp(argv[i], "-w"))   /* embedding window id */
  			embed = argv[++i];
-+		else if (!strcmp(argv[i], "-selhook")) /* a command to run */
++		else if (!strcmp(argv[i], "-selection_hook")) /* a command to run */
 +			selection_hook = argv[++i];
  		else
  			usage();

data/fontinfo.c

@@ -0,0 +1,32 @@
+// Prints a triptych of 'screenWidth charWidth userTextWidth' to stdout.
+
+#include <stdbool.h>
+#include <err.h>
+#include <X11/Xft/Xft.h>
+#include "lib.c"
+
+long desktop_width(Display *dpy) {
+  u_char *prop_val = NULL;
+  ulong prop_size;
+  if (!prop(dpy, DefaultRootWindow(dpy), XA_CARDINAL, "_NET_DESKTOP_GEOMETRY", &prop_val, &prop_size))
+    return -1;
+
+  long r = ((long*)prop_val)[0];
+  free(prop_val);
+  return r;
+}
+
+int main(int argc, char **argv) {
+  Display *dpy = XOpenDisplay(getenv("DISPLAY"));
+  if (!dpy) errx(1, "failed to open display %s", getenv("DISPLAY"));
+  if (argc != 3) errx(1, "usage: fontinfo font text-string");
+
+  XftFont *font = XftFontOpenName(dpy, DefaultScreen(dpy), argv[1]);
+  if (!font) errx(1, "no font match");
+
+  XGlyphInfo info_text, info_char;
+  XftTextExtentsUtf8(dpy, font, (FcChar8*)"@", 1, &info_char);
+  XftTextExtentsUtf8(dpy, font, (FcChar8*)argv[2], strlen(argv[2]), &info_text);
+
+  printf("%ld %d %d\n", desktop_width(dpy), info_char.width, info_text.width);
+}

data/fvwm-window-search

@@ -1,38 +1,64 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env -S ruby --disable-gems
+# coding: utf-8
+# frozen_string_literal: true
 
-require_relative './lib'
-include FvwmWindowSearch
 require 'yaml'
-
-def options_load
-  xdg_config_home = ENV['XDG_CONFIG_HOME'] || File.expand_path('~/.config')
-  conf = File.join xdg_config_home, 'fvwm-window-search', 'conf.yaml'
-  r = File.read conf rescue nil
-  YAML.load r, conf rescue errx 1, "invalid config: #{$!}" if r
-end
+require 'json'
+require 'optparse'
+require 'shellwords'
 
 def options
   default = {
-    "dmenu" => {               # each key is a corresponding CL option
-      "selhook" => File.join(__dir__, "focus.sh %s"),
+    'dmenu' => { # each key corresponds to a dmenu CL option
       "fn" => "Monospace-10",
       "l" => 8,
       "b" => true,
       "i" => true,
+      'selection_hook' => File.join(__dir__, "activate.sh %s"),
+      'selection_hook_activation_return_key_only' => false,
     },
-    "filter" => {
+    "filter-out" => {
       "name" => [],
       "resource" => [],
       "class" => ['^Fvwm', '!^FvwmIdent$']
     }
   }
 
-  deep_merge(default, options_load || {})
+  args = options_command_line
+  file = options_config_file(args) || {}
+  deep_merge default, deep_merge(file, args)
+end
+
+def options_command_line
+  opt = { "dmenu" => {} }
+  OptionParser.new do |o|
+    o.on("-c path", "an alternative path to conf.yaml") { |v| opt["conf"] = v }
+    o.on('-d', 'list windows from the current desktop only') { opt['this_desk_only'] = true }
+    o.on("-r", "switch to a window only when <Return> is pressed") do
+      opt['dmenu']['selection_hook_activation_return_key_only'] = true
+    end
+  end.parse!
+  opt
+end
+
+def options_config_file opt
+  file = opt["conf"] || -> do
+    xdg_config_home = ENV['XDG_CONFIG_HOME'] || File.expand_path('~/.config')
+    File.join xdg_config_home, 'fvwm-window-search', 'conf.yaml'
+  end.call
+  r = File.read file rescue nil
+  YAML.safe_load(r, filename: file) rescue abort "invalid config: #{$!}" if r
+end
+
+def deep_merge first, second
+  merger = proc {|_,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+  first.merge(second, &merger)
 end
 
-def menu params, text
-  cmd = [File.join(__dir__, "_out/dmenu/dmenu")]
-  params = params.map do |k,v|
+def helper exe; File.join(__dir__, "_out/#{exe}"); end
+
+def dmenu_cmd params
+  [helper('dmenu/dmenu')] + params.map do |k,v|
     k = "-"+k
     if !!v == v
       v ? k : nil
@@ -40,25 +66,80 @@ def menu params, text
       [k,v]
     end
   end.reject(&:nil?).flatten.map(&:to_s)
-  IO.popen(cmd + params, 'w') { |ios| ios.puts text }
 end
 
-def main
-  ['xwininfo', 'xdotool'].each do |util|
-    errx 1, "no #{util} in PATH" unless which util
-  end
+def desired patterns, window
+  match = -> (type, value) {
+    include = patterns[type].select {|v| v[0] != '!'}
+    exclude = patterns[type].select {|v| v[0] == '!'}.map {|v| v[1..-1]}
+
+    exclude.each do |pattern|
+      return true if value.match pattern
+    end
+    include.each do |pattern|
+      return false if value.match pattern
+    end
+    true
+  }
+
+  match.call("class", window['class']) &&
+    match.call("resource", window['resource']) &&
+    match.call("name", window['name'])
+end
+
+def dmenu_max_text_len opt
+  cmd = "#{helper('fontinfo')} #{opt['dmenu']['fn'].shellescape} '@'"
+  desk_width, char_width = `#{cmd}`.split.map(&:to_i)
+  (desk_width - char_width*2) / char_width
+end
+
+def menu_line max_len, desk_indicator, w
+  desk = w['desk'] == -1 ? '*' : w['desk'].to_s
+  desktop = desk_indicator + desk
+  id = '0x'+w['id'].to_s(16)
+
+  c = ->(s, len) { s.size > len ? s[0...len-1] + '…' : s }
 
+  name_width = max_len - 4 - 10 - 10 - 9 - 4*3
+
+  "%-4s | %10s | %-#{name_width}s | %10s | %9s" % [
+    desktop,
+    c.call(w['class'], 10),
+    c.call(w['name'], name_width),
+    c.call(w['host'], 10),
+    c.call(id, 9)
+  ]
+end
+
+def main
   opt = options
-  begin
-    winlist = windows_filter opt["filter"], windows
-  rescue RegexpError
-    errx 1, "filter: #{$!}"
+  pp opt if $DEBUG
+
+  max_len = dmenu_max_text_len opt
+  dmenu = IO.popen(dmenu_cmd(opt['dmenu']), 'r+')
+
+  IO.popen(helper('winlist')).each_line do |line|
+    begin
+      w = JSON.parse line
+    rescue
+      dmenu.puts $!.to_s.gsub(/\n+/m, ' ') # let a user see an error
+      next
+    end
+
+    if opt['this_desk_only']
+      next unless w['desk_cur']
+      desk_indicator = ''
+    else
+      desk_indicator = w['desk_cur'] ? '→ ' : '  '
+    end
+
+    next unless desired opt['filter-out'], w
+
+    dmenu.puts menu_line(max_len, desk_indicator, w)
   end
-  winlist = winlist.map do |w|
-    "#{w.name} | #{w.class} | #{w.id}"
-  end.join "\n"
 
-  menu opt["dmenu"], winlist
+  dmenu.close
 end
 
-main
+# not __FILE__ == $0, for $0 points to a generated stub after `gem install ...`
+main unless defined? Minitest

data/lib.c

@@ -0,0 +1,97 @@
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+bool prop(Display *dpy, Window wid, Atom expected_type, const char *name,
+          u_char **result, ulong *size) {
+  Atom type;
+  int format;
+  ulong bytes_after;
+
+  Atom atom = XInternAtom(dpy, name, False);
+  int r = XGetWindowProperty(dpy, wid, atom, 0L, ~0L, False,
+                             expected_type, &type, &format,
+                             size, &bytes_after, result);
+  return r == Success && result;
+}
+
+long desktop(Display *dpy, Window wid) {
+  u_char *prop_val = NULL;
+  ulong prop_size;
+  if (!prop(dpy, wid, XA_CARDINAL, "_NET_WM_DESKTOP", &prop_val, &prop_size))
+    return -2;
+
+  long r = -1; // means a window is in a 'sticky' mode
+  if (prop_val) r = ((long*)prop_val)[0];
+  free(prop_val);
+  return r;
+}
+
+typedef struct {
+  bool _NET_WM_STATE_SHADED;
+  bool _NET_WM_STATE_HIDDEN;
+  Window id;
+} WindowState;
+
+typedef struct {
+  Atom _NET_WM_STATE_SHADED;
+  Atom _NET_WM_STATE_HIDDEN;
+  Atom UTF8_STRING;
+} MyAtoms;
+
+MyAtoms myAtoms;
+
+void mk_atoms(Display *dpy) {
+  myAtoms._NET_WM_STATE_SHADED = XInternAtom(dpy, "_NET_WM_STATE_SHADED", False);
+  myAtoms._NET_WM_STATE_HIDDEN = XInternAtom(dpy, "_NET_WM_STATE_HIDDEN", False);
+  myAtoms.UTF8_STRING = XInternAtom(dpy, "UTF8_STRING", False);
+}
+
+WindowState state(Display *dpy, Window id) {
+  WindowState r = { .id = id };
+  u_char *prop_val = NULL;
+  ulong prop_size;
+  if (!prop(dpy, id, XA_ATOM, "_NET_WM_STATE", &prop_val, &prop_size)) return r;
+
+  Atom *atoms = (Atom*)prop_val;
+  for (int idx = 0; idx < prop_size; idx++) {
+    if (atoms[idx] == myAtoms._NET_WM_STATE_SHADED) r._NET_WM_STATE_SHADED = true;
+    if (atoms[idx] == myAtoms._NET_WM_STATE_HIDDEN) r._NET_WM_STATE_HIDDEN = true;
+  }
+  XFree(prop_val);
+
+  return r;
+}
+
+bool mkdir_p(const char *s, mode_t mode) {
+  char *component = strdup(s);
+  char *p = component;
+
+  bool status = true;
+  while (*p && *p == '/') p++; // skip leading '/'
+
+  do {
+    while (*p && *p != '/') p++;
+
+    if (!*p)
+      p = NULL;
+    else
+      *p = '\0';
+
+    if (-1 == mkdir(component, mode) && errno != EEXIST) {
+      status = false;
+      break;
+    } else if (p) {
+      *p++ = '/';
+      while (*p && *p == '/') p++;
+    }
+
+  } while (p);
+
+  free(component);
+  return status;
+}

data/winlist.c

@@ -0,0 +1,116 @@
+/*
+  produces line-delimited JSON of currently managed windows by an X
+  window manager:
+
+  {"desk":0,"host":"hm76","name":"xterm","resource":"xterm","class":"XTerm","id":67108878}
+*/
+
+#include <err.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <math.h>
+
+#include <X11/Xutil.h>
+#include <jansson.h>
+
+#include "lib.c"
+
+typedef struct {
+  Window *ids;
+  ulong size;
+} WinList;
+
+// result (WinList.ids) should be freed
+WinList winlist(Display *dpy) {
+  WinList list = { .ids = NULL };
+  u_char *result;
+
+  if (!prop(dpy, DefaultRootWindow(dpy), XA_WINDOW, "_NET_CLIENT_LIST_STACKING",
+            &result, &list.size)) {
+    return list;
+  }
+
+  list.ids = (Window*)result;
+  return list;
+}
+
+// result should be freed
+char* wm_client_machine(Display *dpy, Window wid) {
+  u_char *prop_val = NULL;
+  ulong prop_size;
+  prop(dpy, wid, XA_STRING, "WM_CLIENT_MACHINE", &prop_val, &prop_size);
+  return prop_val ? (char*)prop_val : strdup("nil");
+}
+
+// result (XClassHint.*) should be freed
+XClassHint wm_class(Display *dpy, Window wid) {
+  XClassHint r = { .res_name = NULL };
+  XGetClassHint(dpy, wid, &r);
+  if (!r.res_name) r.res_name = strdup("nil");
+  if (!r.res_class) r.res_class = strdup("nil");
+  return r;
+}
+
+// result should be freed
+char* wm_name(Display *dpy, Window wid) {
+  u_char *prop_val = NULL;
+  ulong prop_size;
+
+  bool r = prop(dpy, wid, myAtoms.UTF8_STRING, "_NET_WM_NAME", &prop_val, &prop_size);
+  if (r && prop_val) return (char*)prop_val;
+
+  prop(dpy, wid, XA_STRING, "WM_NAME", &prop_val, &prop_size);
+  return prop_val ? (char*)prop_val : strdup("nil");
+}
+
+long desktop_current(Display *dpy) {
+  u_char *prop_val = NULL;
+  ulong prop_size;
+  long r = -1;
+  if (!prop(dpy, DefaultRootWindow(dpy), XA_CARDINAL, "_NET_CURRENT_DESKTOP",
+            &prop_val, &prop_size))
+    return r;
+
+  if (prop_val) r = ((long*)prop_val)[0];
+  free(prop_val);
+  return r;
+}
+
+
+
+int main() {
+  Display *dpy = XOpenDisplay(getenv("DISPLAY"));
+  if (!dpy) errx(1, "failed to open display %s", getenv("DISPLAY"));
+  mk_atoms(dpy);
+
+  WinList list = winlist(dpy);
+  for (long idx = list.size-1; idx >= 0; idx--) {
+    ulong wid = list.ids[idx];
+
+    char *host = wm_client_machine(dpy, wid);
+    char *name = wm_name(dpy, wid);
+    XClassHint rc = wm_class(dpy, wid);
+    long desk = desktop(dpy, wid);
+    bool is_desk_cur = desk < 0 || desk == desktop_current(dpy);
+
+    json_t *line = json_object();
+    json_object_set_new(line, "desk", json_integer(desk));
+    json_object_set_new(line, "desk_cur", json_boolean(is_desk_cur));
+    json_object_set_new(line, "host", json_string(host));
+    json_object_set_new(line, "name", json_string(name));
+    json_object_set_new(line, "resource", json_string(rc.res_name));
+    json_object_set_new(line, "class", json_string(rc.res_class));
+    json_object_set_new(line, "id", json_integer(wid));
+
+    char *dump = json_dumps(line, JSON_COMPACT);
+    printf("%s\n", dump);
+    free(dump);
+    json_decref(line);
+
+    free(host);
+    free(name);
+    free(rc.res_name);
+    free(rc.res_class);
+  }
+  XFree(list.ids);
+}

metadata

@@ -1,19 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: fvwm-window-search
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Alexander Gromnitsky
-autorequire: 
+autorequire:
 bindir: "."
 cert_chain: []
-date: 2020-07-19 00:00:00.000000000 Z
+date: 2021-04-10 00:00:00.000000000 Z
 dependencies: []
 description: |
-  Search for windows interactively using a patched dmenu utility.
-  Originally made for Fvwm, it's been fully rewritten to work out-of-the-box
-  with any window manager. Requires xdotool & xwininfo installed.
+  A window switcher: search for windows interactively using a patched
+  dmenu utility (the gem fetches & patches it during its installation).
+  This was originally made for Fvwm, but it's been rewritten to work with
+  any EWMH-compliant stacking window manager.
+
+  Requires a preinstalled jansson-devel C library.
+
+  It differs from rofi & co in that it activates (brings up) windows
+  _during_ the search.
 email: alexander.gromnitsky@gmail.com
 executables:
 - fvwm-window-search
@@ -24,15 +30,18 @@ files:
 - "./fvwm-window-search"
 - Makefile
 - README.md
+- activate.c
+- activate.sh
 - dmenu.patch
 - extconf.rb
-- focus.sh
-- lib.rb
+- fontinfo.c
+- lib.c
+- winlist.c
 homepage: https://github.com/gromnitsky/fvwm-window-search
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -40,15 +49,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
-summary: Interactive incremental windows search & selection for X Window
+summary: 'A window switcher: an interactive incremental windows search & selection
+  for X Window'
 test_files: []

data/focus.sh

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-id=`echo "$1" | awk -F'|' '{print $NF} END { exit $NF == "" ? 1 : 0}'` || {
-    echo "usage: `basename "$0"` 'name | class | id'"
-    exit 1
-}
-xdotool windowactivate "$id" mousemove --window "$id" 0 0

data/lib.rb

@@ -1,105 +0,0 @@
-module FvwmWindowSearch; end
-
-class FvwmWindowSearch::Window
-  def initialize xwininfo_line
-    @line = xwininfo_line.match(/^([x0-9a-f]+)\s+(["\(].+["\)]):\s+\((.*)\)\s+([x0-9+-]+)\s+([0-9+-]+)$/)
-    raise "invalid xwininfo line" unless @line
-    @dim = parse
-  end
-
-  def parse
-    dim = {}
-    if @line[4]
-      m4 = @line[4].match(/^([0-9]+)x([0-9]+)\+([0-9-]+)\+([0-9-]+)$/)
-      if m4
-        dim[:w] = m4[1].to_i
-        dim[:h] = m4[2].to_i
-        dim[:x_rel] = m4[3].to_i
-        dim[:y_rel] = m4[4].to_i
-      end
-    end
-
-    if @line[5]
-      m5 = @line[5].match(/^\+([0-9-]+)\+([0-9-]+)$/)
-      if m5
-        dim[:x] = m5[1].to_i
-        dim[:y] = m5[2].to_i
-      end
-    end
-
-    dim
-  end
-
-  def id; @line[1]; end
-
-  def name;
-    return unless @line[2]
-    @line[2] == '(has no name)' ? nil : @line[2][1..-2]
-  end
-
-  def resource; @line[3]&.split(' ')&.dig(0)&.slice(1..-2); end
-  def class;    @line[3]&.split(' ')&.dig(1)&.slice(1..-2); end
-  def width; @dim[:w]; end
-  def height; @dim[:h]; end
-  def x; @dim[:x]; end # an absolute upper-left X
-  def y; @dim[:y]; end # an absolute upper-left Y
-  def x_rel; @dim[:x_rel]; end
-  def y_rel; @dim[:y_rel]; end
-
-  def useful?
-    return false unless @line
-    return false if width == 0 || height == 0
-    return false if (x == x_rel) && (y == y_rel)
-    return false if x_rel > 0 || y_rel > 0
-    return false unless self.class
-    true
-  end
-
-  def inspect
-    "#<Window> id=#{id}, name=#{name}, resource=#{resource}, class=#{self.class}"
-  end
-end
-
-module FvwmWindowSearch
-  def windows
-  `xwininfo -root -tree`.split("\n")
-    .select {|v| v.match(/^\s*0x.+/)}
-    .map(&:strip)
-    .map {|v| Window.new(v)}
-    .select(&:useful?)
-  end
-
-  def windows_filter patterns, winlist
-    desired = -> (type, value) {
-      include = patterns[type].filter{|v| v[0] != '!'}
-      exclude = patterns[type].filter{|v| v[0] == '!'}.map {|v| v[1..-1]}
-
-      exclude.each do |pattern|
-        return true if value.match pattern
-      end
-      include.each do |pattern|
-        return false if value.match pattern
-      end
-      true
-    }
-
-    winlist.filter { |w| desired.call "class", w.class }
-      .filter{ |w| desired.call "resource", w.resource }
-      .filter{ |w| desired.call "name", w.name }
-  end
-
-  def deep_merge first, second
-    merger = proc { |_, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-    first.merge(second, &merger)
-  end
-
-  def errx exit_code, msg
-    $stderr.puts "#{File.basename $0} error: #{msg}"
-    exit exit_code
-  end
-
-  def which cmd
-    ENV['PATH'].split(File::PATH_SEPARATOR).map {|v| File.join v, cmd }
-      .find {|v| File.executable?(v) && !File.directory?(v) }
-  end
-end