i3-glue 1.0.0__tar.gz

i3_glue-1.0.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: i3-glue
+Version: 1.0.0
+Summary: Glue open i3 windows together into stacked containers by WM class
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: i3ipc>=2.2
+
+# i3-glue
+Glue windows opened in i3wm together creating a tabbed container based on wm classes.
+
+AI-generated and unreviewed.
+
+## Motivation
+I am grizzled and grumpy. I don't want to move windows areound all the time, but I have too many windows to fit on my screen in fixed locations. I can just about handle putting similar windows together and toggling them.
+
+## Alternatives
+Use desktops. Manually arrange your windows into containers.
+
+## Usage
+Find a the class of thel windows you want to with `xprop WM_CLASS` (the second string) or
+`i3-msg -t get_tree`.
+
+Run i3-glue as a daemon.
+
+```sh
+i3-glue --glue obsidian,neovim
+i3-glue --glue obsidian,neovim --glue qutebrowser,signal
+i3-glue --glue obsidian,neovim --layout tabbed
+```
+
+Each `--glue` is a comma-separated list of X11 WM classes. Every open window whose
+
+## Flags
+
+- `--glue A,B[,C...]` — a group of WM classes to glue (repeatable, required)
+- `--layout` — `stacking` (default), `tabbed`, `splith`, `splitv`
+
+## Install (editable, via pipx)
+```sh
+pipx install --editable i3-glue
+```

i3_glue-1.0.0/README.md

@@ -0,0 +1,34 @@
+# i3-glue
+Glue windows opened in i3wm together creating a tabbed container based on wm classes.
+
+AI-generated and unreviewed.
+
+## Motivation
+I am grizzled and grumpy. I don't want to move windows areound all the time, but I have too many windows to fit on my screen in fixed locations. I can just about handle putting similar windows together and toggling them.
+
+## Alternatives
+Use desktops. Manually arrange your windows into containers.
+
+## Usage
+Find a the class of thel windows you want to with `xprop WM_CLASS` (the second string) or
+`i3-msg -t get_tree`.
+
+Run i3-glue as a daemon.
+
+```sh
+i3-glue --glue obsidian,neovim
+i3-glue --glue obsidian,neovim --glue qutebrowser,signal
+i3-glue --glue obsidian,neovim --layout tabbed
+```
+
+Each `--glue` is a comma-separated list of X11 WM classes. Every open window whose
+
+## Flags
+
+- `--glue A,B[,C...]` — a group of WM classes to glue (repeatable, required)
+- `--layout` — `stacking` (default), `tabbed`, `splith`, `splitv`
+
+## Install (editable, via pipx)
+```sh
+pipx install --editable i3-glue
+```

i3_glue-1.0.0/i3_glue/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

i3_glue-1.0.0/i3_glue/main.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+i3-glue — keep similar i3 windows stacked together, by WM class.
+
+AI-generated. You probably don't want to use it. And yet it exists.
+
+Runs as a daemon: on start it stacks whatever matching windows are already
+open, then it watches the i3 event stream and folds each newly-opened window
+into its group as it appears. Similar windows pile into one stacked container
+so you can toggle between them instead of tiling them all on screen.
+
+Usage:
+    i3-glue --glue obsidian,neovim
+    i3-glue --glue obsidian,neovim --glue qutebrowser,signal
+    i3-glue --glue obsidian,neovim --layout tabbed
+    i3-glue --glue obsidian,neovim --once   # stack existing, then exit
+
+Each --glue takes a comma-separated list of WM classes. A window whose class
+is in a group is moved to sit with the other open members of that group.
+
+Flags:
+    --glue A,B[,C...]   a group of WM classes to keep together (repeatable)
+    --layout LAYOUT     tabbed (default), stacking, splith, splitv
+    --once              stack currently-open windows, then exit (no daemon)
+    --debug             print matched windows and the i3 commands sent
+
+Runtime deps: i3 (via i3ipc).
+"""
+
+import argparse
+import sys
+
+import i3ipc
+
+
+DEBUG = False
+MARK = "__i3_glue__"
+
+
+def die(msg, code=1):
+    print(f"i3-glue: {msg}", file=sys.stderr)
+    sys.exit(code)
+
+
+def info(msg):
+    print(f"[i3-glue] {msg}", file=sys.stderr, flush=True)
+
+
+def dbg(msg):
+    if DEBUG:
+        print(f"[i3-glue:debug] {msg}", file=sys.stderr, flush=True)
+
+
+def command(conn, cmd):
+    """Send an i3 command, log it in --debug, surface any failure."""
+    dbg(f"i3-msg: {cmd}")
+    for reply in conn.command(cmd):
+        if not reply.success:
+            info(f"command failed: {cmd!r}: {reply.error}")
+
+
+def parse_groups(raw_groups):
+    """Turn ['obsidian,neovim', ...] into [['obsidian', 'neovim'], ...] of
+    lowercased class names. Groups with fewer than 2 classes are dropped."""
+    groups = []
+    for raw in raw_groups:
+        classes = [c.strip().lower() for c in raw.split(",") if c.strip()]
+        if len(classes) < 2:
+            info(f"skip {raw!r}: a glue group needs at least 2 classes")
+            continue
+        groups.append(classes)
+    return groups
+
+
+def group_for_class(groups, wm_class):
+    wc = (wm_class or "").lower()
+    if not wc:
+        return None
+    for group in groups:
+        if wc in group:
+            return group
+    return None
+
+
+def members_of(tree, group):
+    """Open leaf windows whose class is in `group`, ordered so the listed class
+    order becomes the stack order."""
+    found = []
+    for con in tree.leaves():
+        wc = (con.window_class or "").lower()
+        if wc in group:
+            found.append((group.index(wc), con))
+    found.sort(key=lambda t: t[0])
+    return [con for _, con in found]
+
+
+def stack_together(conn, cons, layout):
+    """Move every con onto the first one and stack the shared container.
+    Targets containers by con_id, so it never steals focus."""
+    anchor = cons[0]
+    command(conn, f"[con_id={anchor.id}] mark --add {MARK}")
+    for con in cons[1:]:
+        command(conn, f"[con_id={con.id}] move container to mark {MARK}")
+    command(conn, f"[con_id={anchor.id}] layout {layout}")
+    command(conn, f"unmark {MARK}")
+
+
+def stack_existing(conn, groups, layout):
+    """First-run pass: stack whatever is already open, group by group."""
+    tree = conn.get_tree()
+    for group in groups:
+        cons = members_of(tree, group)
+        if DEBUG:
+            for con in cons:
+                dbg(f"  existing {','.join(group)}: con_id={con.id} "
+                    f"class={con.window_class!r} name={con.name!r}")
+        if len(cons) < 2:
+            continue
+        stack_together(conn, cons, layout)
+        info(f"glued {','.join(group)}: {len(cons)} windows -> {layout}")
+
+
+def window_class_of(conn, con):
+    """Class of a freshly-opened con. WM_CLASS is occasionally not set yet at
+    window::new time, so fall back to a fresh tree lookup by id."""
+    if con.window_class:
+        return con.window_class
+    found = conn.get_tree().find_by_id(con.id)
+    return found.window_class if found else None
+
+
+def make_on_new(conn, groups, layout):
+    def on_new(conn, event):
+        con = event.container
+        wm_class = window_class_of(conn, con)
+        group = group_for_class(groups, wm_class)
+        if group is None:
+            return
+        # Find already-open members of this group, other than the new window.
+        others = [c for c in members_of(conn.get_tree(), group) if c.id != con.id]
+        if not others:
+            dbg(f"new {wm_class!r}: first member of its group, leaving it")
+            return
+        dbg(f"new {wm_class!r} (con_id={con.id}): merging into "
+            f"con_id={others[0].id}")
+        stack_together(conn, [others[0], con], layout)
+        info(f"merged {wm_class} into {','.join(group)} group")
+
+    return on_new
+
+
+def cmd_daemon(argv):
+    global DEBUG
+    parser = argparse.ArgumentParser(
+        prog="i3-glue",
+        description="Keep similar i3 windows stacked together, by WM class.",
+    )
+    parser.add_argument(
+        "--glue", action="append", metavar="A,B", default=[],
+        help="comma-separated WM classes to keep together (repeatable)",
+    )
+    parser.add_argument(
+        "--layout", default="tabbed",
+        choices=["tabbed", "stacking", "splith", "splitv"],
+        help="layout for the glued container (default: tabbed)",
+    )
+    parser.add_argument(
+        "--once", action="store_true",
+        help="stack currently-open windows, then exit (no daemon)",
+    )
+    parser.add_argument("--debug", action="store_true", help="verbose output")
+    args = parser.parse_args(argv)
+
+    DEBUG = args.debug
+    groups = parse_groups(args.glue)
+    if not groups:
+        die("nothing to glue: pass at least one --glue A,B")
+
+    conn = i3ipc.Connection()
+    stack_existing(conn, groups, args.layout)
+    if args.once:
+        return
+
+    conn.on(i3ipc.Event.WINDOW_NEW, make_on_new(conn, groups, args.layout))
+    info("watching for new windows (ctrl-c to stop)")
+    try:
+        conn.main()
+    except KeyboardInterrupt:
+        pass
+
+
+# ---------- group-aware navigation ----------
+
+def glued_group(con):
+    """Nearest tabbed/stacked ancestor of `con` (the glued group it lives in),
+    or None if it isn't inside one."""
+    node = con
+    while node is not None:
+        if node.layout in ("tabbed", "stacked"):
+            return node
+        node = node.parent
+    return None
+
+
+def visible_leaf(con):
+    """A focusable leaf for `con`: itself if it's a window, else its first leaf."""
+    if con.window:
+        return con
+    leaves = con.leaves()
+    return leaves[0] if leaves else con
+
+
+def child_holding(group, target_id):
+    """Index of the group's child that contains the focused window."""
+    for i, child in enumerate(group.nodes):
+        if child.id == target_id or any(d.id == target_id for d in child.descendants()):
+            return i
+    return 0
+
+
+def cmd_toggle(argv):
+    """Flip focus to the next window within the current glued group (wraps)."""
+    conn = i3ipc.Connection()
+    focused = conn.get_tree().find_focused()
+    group = glued_group(focused)
+    if group is None or len(group.nodes) < 2:
+        return
+    i = child_holding(group, focused.id)
+    nxt = group.nodes[(i + 1) % len(group.nodes)]
+    command(conn, f"[con_id={visible_leaf(nxt).id}] focus")
+
+
+def cmd_focus(argv):
+    """Directional focus that treats a glued group as one unit. By focusing the
+    whole group container first, i3's `focus <dir>` steps over its inner tabs."""
+    if not argv or argv[0] not in ("left", "right", "up", "down"):
+        die("usage: i3-glue focus {left|right|up|down}")
+    direction = argv[0]
+    conn = i3ipc.Connection()
+    focused = conn.get_tree().find_focused()
+    group = glued_group(focused)
+    if group is not None:
+        command(conn, f"[con_id={group.id}] focus")
+    command(conn, f"focus {direction}")
+    # If nothing moved we may have left a non-leaf container focused; drop back
+    # into the group's visible window so focus is always on a real window.
+    now = conn.get_tree().find_focused()
+    if now is not None and not now.window:
+        command(conn, f"[con_id={visible_leaf(now).id}] focus")
+
+
+def main():
+    argv = sys.argv[1:]
+    if argv and argv[0] == "toggle":
+        return cmd_toggle(argv[1:])
+    if argv and argv[0] == "focus":
+        return cmd_focus(argv[1:])
+    return cmd_daemon(argv)
+
+
+if __name__ == "__main__":
+    main()

i3_glue-1.0.0/i3_glue.egg-info/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: i3-glue
+Version: 1.0.0
+Summary: Glue open i3 windows together into stacked containers by WM class
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: i3ipc>=2.2
+
+# i3-glue
+Glue windows opened in i3wm together creating a tabbed container based on wm classes.
+
+AI-generated and unreviewed.
+
+## Motivation
+I am grizzled and grumpy. I don't want to move windows areound all the time, but I have too many windows to fit on my screen in fixed locations. I can just about handle putting similar windows together and toggling them.
+
+## Alternatives
+Use desktops. Manually arrange your windows into containers.
+
+## Usage
+Find a the class of thel windows you want to with `xprop WM_CLASS` (the second string) or
+`i3-msg -t get_tree`.
+
+Run i3-glue as a daemon.
+
+```sh
+i3-glue --glue obsidian,neovim
+i3-glue --glue obsidian,neovim --glue qutebrowser,signal
+i3-glue --glue obsidian,neovim --layout tabbed
+```
+
+Each `--glue` is a comma-separated list of X11 WM classes. Every open window whose
+
+## Flags
+
+- `--glue A,B[,C...]` — a group of WM classes to glue (repeatable, required)
+- `--layout` — `stacking` (default), `tabbed`, `splith`, `splitv`
+
+## Install (editable, via pipx)
+```sh
+pipx install --editable i3-glue
+```

i3_glue-1.0.0/i3_glue.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+i3_glue/__init__.py
+i3_glue/main.py
+i3_glue.egg-info/PKG-INFO
+i3_glue.egg-info/SOURCES.txt
+i3_glue.egg-info/dependency_links.txt
+i3_glue.egg-info/entry_points.txt
+i3_glue.egg-info/requires.txt
+i3_glue.egg-info/top_level.txt

i3_glue-1.0.0/i3_glue.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

i3_glue-1.0.0/i3_glue.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+i3-glue = i3_glue.main:main

i3_glue-1.0.0/i3_glue.egg-info/requires.txt

@@ -0,0 +1 @@
+i3ipc>=2.2

i3_glue-1.0.0/i3_glue.egg-info/top_level.txt

@@ -0,0 +1 @@
+i3_glue

i3_glue-1.0.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = [ "setuptools>=68.0",]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "i3-glue"
+version = "1.0.0"
+description = "Glue open i3 windows together into stacked containers by WM class"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+dependencies = [ "i3ipc>=2.2",]
+
+[project.scripts]
+i3-glue = "i3_glue.main:main"
+
+[tool.setuptools]
+packages = [ "i3_glue",]

i3_glue-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+