Personal fork of the original bsptab with some changes made to make it fit my use cases better. If I don't make it incompatible with the original, I'll probably open a pull request or something eventually.
I wrote my changes in tabc-simple
, a simplified version of tabc without
automatic autoattaching or the xdotool key thing. I made this instead of making
changes in tabc
because it's easier with those features just removed since
working with tabbed
can be a little buggy. Might think about porting my
changes over to tabc later.
List of changes made:
- Disable automatic autoattach. It's a neat feature, but I don't want it, and I'd rather not have to disable it on every new tabbed container or deal with potential buggyness/slowdown from that.
- Remove the weird xdotool key workaround for tab order. It noticably slows it down and adds jank. This does mean that the ordering changes sometimes (i.e. when merging windows), which doesn't really bother me.
- Add
-n
flag to prependbspc query -N -n
on inputs. - Combine
tabbed-unsub
's behavior intotabbed-sub
.tabbed-unsub
isn't needed at all anymore. - Create
tabbed-sub-once
, which is just liketabbed-sub
, but it only reacts to the first node_add event and then dies. merge
combines two tabbed containers together completely.explode
detaches all windows from a tabbed container.- Replaced
autoattach
with set of functions for better control:autoattach
: enable autoattachnoautoattach
: disable autoattachtoggleautoattach
: toggle autoattach, just like originalautoattach
My sxhkdrc
lines:
# super + t base chord for all tabbed manipulation
# t (create) create new tabbed container on focused window
# r (detach) remove focused window from tabbed container
# shift + r (explode) remove all windows from tabbed container
# {h,j,k,l} (attach) move focused window into target tabbed container
# shift + {h,j,k,l} (merge) merge focused tabbed/window with target tabbed/window
super + t; t
tabc-simple create $(bspc query -N -n focused)
super + t; r
tabc-simple detach $(bspc query -N -n focused)
super + t; shift + r
tabc-simple explode $(bspc query -N -n focused)
super + t; {h,j,k,l}
tabc-simple attach $(bspc query -N -n focused) $(bspc query -N -n {west,south,north,east})
super + t; shift + {h,j,k,l}
tabc-simple merge $(bspc query -N -n focused) $(bspc query -N -n {west,south,north,east})
# spawn terminal into focused tabbed container
super + t; {super + , } z
tabc-simple create $(bspc query -N -n focused); \
alacritty --embed $(("$(bspc query -N -n focused)"))
# run rofi, attach run program into focused tabbed container
super + t; {super + , } space
tabc-simple create $(bspc query -N -n focused); \
tabbed-sub-once "$(bspc query -N -n focused)" & \
rofi -show run
bsptab is a collection of bash scripts for integrating tabbed, a tool from suckless to create tabbed containers in X environments, into bspwm, a tiling window manager based on binary space partitioning.
bspwm is an awesome WM, but it only does its job, which does it well: managing windows. However, bspwm is also extremely scriptable! With these scripts, you can easily organize windows into tabs, which is a really useful feature for many workflows.
This project is based on Bachhofer/tabc.
Please open an issue/pull request if you find any kind of bug, if you'd like to see any new features, or especially if you think any part of the code should be rewritten in a better way, since I am not a bash expert at all.
- Adds tabbed layouts to bspwm.
- Each tabbed container handles multiple windows, but not any more tabbed containers.
- Automatically attach new windows to tabbed containers.
- Only external scripts, doesn't modify original tabbed code.
bspwm
tabbed
bash
coreutils
awk
xwininfo
xprop
xdotool
- Use tabbed-flexipatch, a tabbed version that uses preprocessor directives to include patches, so you can easily select your favorite ones.
- In
config.h
, set the following option:
static int newposition = -1; // attach new windows at the end
- Also in
config.h
, configure each setting according to your preferences (e. g. appearance, keybindings...), and comment out keybindings for the following functions:focusonce
,spawn
,killclient
,fullscreen
.
- In
config.h
, set the following keybindings, which let you switch between tabs using Alt+[Tab#]. This is important because thedetach()
function intabc
usesxdotool
to perform these key combinations (if you prefer, you can also manually edit those lines in the script to match your keybindings):
{ Mod1Mask, XK_1, move, { .i = 0 } },
{ Mod1Mask, XK_2, move, { .i = 1 } },
{ Mod1Mask, XK_3, move, { .i = 2 } },
{ Mod1Mask, XK_4, move, { .i = 3 } },
{ Mod1Mask, XK_5, move, { .i = 4 } },
{ Mod1Mask, XK_6, move, { .i = 5 } },
{ Mod1Mask, XK_7, move, { .i = 6 } },
{ Mod1Mask, XK_8, move, { .i = 7 } },
{ Mod1Mask, XK_9, move, { .i = 8 } },
{ Mod1Mask, XK_0, move, { .i = 9 } }
inside
static Key keys[] = {
// ...
};
Just clone the repo and run make install
inside the repo directory.
If you are using a pacman-based distro (Arch, Manjaro...), you can use the AUR package (if you like it, please leave a vote ๐).
This script is used to manage tabbed containers (creating, attaching/detaching windows and toggling autoattach feature), as well as to launch helper daemons.
Run tabc <command>
.
Available commands:
create <wid>
Create a tabbed container and add window<wid>
. If<wid>
is a tabbed container, don't do anything. Also enable autoattaching new windows.attach <wid0> <wid1>
Attach window<wid0>
to tabbed container<wid1>
. If<wid0>
is a tabbed container, detach the active window and attach it to the new container. If<wid1>
is not a tabbed container, callcreate <wid1>
first.detach <wid>
Detach active window from tabbed container<wid>
. If<wid>
is not a tabbed container, don't do anything.autoattach <wid>
Toggle autoattach new windows to tabbed container<wid>
. If<wid>
is not a tabbed container, don't do anything.autod <classes>
Launch a daemon that creates a tabbed container for every new window which class is in<classes>
. This can be useful, for example, for file managers, so it and the opened file share a tabbed layout. It could be a good idea to include this command in yourbspwmrc
.refreshd
Launch a daemon that does its job as a workaround for a bug that makes the tab bar width not to be correctly adjusted sometimes when the size of the tabbed container changes. It could be a good idea to include this command in yourbspwmrc
.printclass <wid>
Print class of window<wid>
.
These two scripts are used to enable autoattach feature for tabbed containers. This means that, when a new window is added from the container (in bspwm terms, when a new window is the brother of the container), it is automatically attached to it.
You can use them running tabbed-sub <wid> &; tabbed-unsub <wid> &
, but you won't probably need it
since they are called from related tabc
commands.
It is really useful to run tabc
script through user-defined keybindings, so you can create tabbed
containers, attach/detach windows to them and toggle autoattach feature just using your keyboard.
Add the following lines to your sxhkdrc
:
# add to tabbed container
ctrl + alt + {Left,Down,Up,Right}
tabc attach $(bspc query -N -n) {$(bspc query -N -n west),$(bspc query -N -n south),$(bspc query -N -n north),$(bspc query -N -n east)}
# create/remove from tabbed container
super + z
id=$(bspc query -N -n); \
[[ "$(tabc printclass $id)" == "tabbed" ]] \
&& tabc detach $id \
|| tabc create $id
# toggle autoattach in tabbed container
super + shift + z
tabc autoattach $(bspc query -N -n)
tabc create
command
Open a Chromium window, create a tabbed container using a keyboard shortcut and open new windows as tabs.
tabc attach
command
Attach window (right) to a tabbed container (left) using a keyboard shortcut.
tabc detach
command
Detach a couple of windows from a tabbed container and then combine them to create a new container (again, using keyboard shortcuts).
tabc autoattach
command
Toggle autoattach function using a keyboard shortcut: first, it is enabled, so new windows appear as tabs; then, it is disabled, so new windows are placed as usual
tabc autod
command
Open an instance of pcmanfm-qt, and a tabbed container is automatically created, so every new window opened is added as a tab.
- Somehow fix a bug that makes the tab order to mess up when detaching a window.
- Put everything in a single file.
-
When detaching a window, focus next tab to detached (prev tab if it was the last one). -
Move common functions to a separate script file.