serhii.net

Qtile WM

Python tiling window manager, playing with it for a couple of days now.

It’s everything I expected from a tiling WM, except it’s completely configurable with Python, so basically unlimited options to do anything. Compared to my usual i3: speed is the same, documentation is a bit worse, but configuration is much more intuitive.

And it has a lot of stuff, I never heard of it but was surprised to learn it has a lot of widgets / layouts / etc., and it has  even a CLI-like shell qtile shell where you can use the standard bash commands to do stuff to anything (cd/ls/etc to layouts/groups/windows, run things like cd groups/F1/windows/213; down_opacity()).

Everything I customized in i3 via hacks can be done natively nicely and in python and I love it.

Important links

• Lazy objects — Qtile 0.1.dev50+g9c583ed.d20211208 documentation
• Built-in Layouts — Qtile 0.1.dev50+g9c583ed.d20211208 documentation
• Keys — Qtile 0.1.dev50+g9c583ed.d20211208 documentation

Notes

Checking configuration for errors before restarting

No easy way to check config for correctness I’ve found, but python3 config.py finds most errors.

Docu suggests python3 -m py_compile config.py but it returns no output regardless of errors. qtile shell’s test config also is quiet.

Layouts

A lot of them. Tried all. Favourites so far. Listed here: Built-in Layouts — Qtile 0.1.dev50+g9c583ed.d20211208 documentation

Main realization so far is that I’ve been using tiling WMs wrong, in i3 I kept manually splitting the window when I needed to have it split into smaller ones. Except that this should happen automatically, because I never want three windows side-by-side at the same time.

MonadTall / MonadWide

Probably my favourite one. Splits stuff nicely in one big and multiple smaller ones in a separate columns.

Added these bits to config:

Key([modkey], "i", lazy.layout.grow()),
Key([modkey], "m", lazy.layout.shrink()),
Key([modkey], "n", lazy.layout.normalize()),
Key([modkey], "o", lazy.layout.maximize()),

• <mod+o> toggles between how big/main is the highlighted window. If it’s the big window, it gets narrower or wider, if it’s one of the smaller ones in a column, each becomes the biggest/smallest in that column.
• <mod+i>/<mod+m> grows/shrinks the current window.
• <mod+n> ’normalizes’ everything by resetting the layout.

Column

Nice intuitive etc, has N columns, moving windows to left-right does what I expect, including creating newer columns, or splitting existing ones as the window “travels” through it.

Bsp

The tree-thingy that splits each thing into two, ad infinitum.

These bindings use mod3 which is the physical ctrl key, that move the splits with all windows inside them (not individual windows). They seem to be used only for that layout.

    Key([mod3], "j", lazy.layout.flip_down()),
    Key([mod3], "k", lazy.layout.flip_up()),
    Key([mod3], "h", lazy.layout.flip_left()),
    Key([mod3], "l", lazy.layout.flip_right()),

Other

Tile

Two stacks, one with N “main” windows (1, but configurable), and a second stack for all the other ones. See no added value compared to the Monad ones. But add_after_last=True makes the behaviour more intuitive to me.

Max

One single window, the rest are hidden behind it (as a stack), no configs, no way to signal if it’s the only window or there are more behind it.

TreeTab

Only layout that I can get to show the titles of the windows inside the stack. You get one stack and window titles on the right.

Meant for browsers like uzbl, and it emulates almost exactly the setup I have for qutebrowser.

Random

• From this¹ sample command:
  • Doing stuff based on different layout:

        layout = qtile.current_layout
    	group = qtile.current_group
    
    	if layout.name == 'monadtall':
    		layout.cmd_maximize()
    		if len(group.windows) != 2:
    			return
    

  • Using python and sound software engineering like creating a class to keep constants for commands

Config bits / settings

Getting Obsidian to run in a Dropdown/Scratchpad

One of those two worked: - calling Obsidian directly as binary (instead of my runner shell script) - Using config.Match()to identify it .

TODO

• Multiple screens/monitors
  • This shows how to detect number of screens and place groups in them: qtile-examples/groups.py at master · qtile/qtile-examples

    from libqtile.config import Screen
    from platforms import num_screens, hostname
    if num_screens[hostname] == 4:
    	from bars import chat_bar, main_bar, media_bar, code_bar
    	# ...
    	chat_screen = Screen(top=chat_bar)
    	# ...
    	screens = [main_screen, media_screen, code_screen, chat_screen]
    

• All my usual shortcuts (volume, screenshots, etc. etc.)
• I like the idea of splitting the configs in separate python files², especially for constants¹

What’s missing

• How to have a sticky floating window? ³

You can star/unstar a search!

Really handy for summary/analysis-type searches, like for hashtags of things that may be reoccurring.

Additionally a “search” doesn’t stop once you click through files or through the folders, it’s still available in its own tab.

You can embed not just an entire document, but also part of it, like headers! The same mechanism as with linking, but I can’t figure out how the autocompletion is supposed to be used.

In any case, works the same way, page title and then # for headers and ^ for blocks, for which it will autogenerate a reference in the target file.

To trigger this you have to have the page name already filled in, it suggests stuff, but once you click on something or use tab it generates a link with it immediately. Best way I can figure out is to let it do this, and then replace the syntax around, the autocompletion gets triggered once you get it in a syntax like below: ^66eab0

![[Your page title#

Link

I can always replace return None with just return in #python. (Third way is omit a return completely.)

More about this: The Python return Statement: Usage and Best Practices – Real Python

In python, when doing regex on a multiline string:

• re.MULTILINE makes ^ and $ match on each line, not just begin/end of entire string.
• re.DOTALL makes . match newline (by default it doesn’t).

Obsidian can do advanced search: Obsidian search

• “X OR y -z”
• js-flavour regex
• Special search operators for files/paths, to search on lines/blocks/sections, tasks, tags

tag: #Tag is better than searching the tag by itself, as the latter might find tags inside code listings etc etc etc

I changed the templates I use to be more repetitive but hopefully with less chances for a note meant to be private to get published on my website.

Three types of notes I want to be able to create easily:

• Diensttagebuch (public)
• Jourrnal (public)
• Personal (private)

I don’t want the Personal ones to end up left in any of the folders parsed by obyde even by chance, and if they do I don’t want them converted, and if they do - shown.

Now I just create a note, it gets put into /, I give it a name, and then run one of the three templates. The templates take care of moving it to the correct folder and prefic

Now I have three identical templates, they move the note to the correct place, prefix the file with the datetime if needed, and add boilerplate frontmatter.

Public diensttagebuch note (<C-t>), puts it into /garden/it/ and prefixes with datetime:

<% tp.file.move("garden/it/"+tp.date.now("YYMMDD-HHmm")+" "+tp.file.title) %>---
title: "<% tp.file.title %>"
tags:
  - "zc"
  - "zc/it"
  - "<% tp.file.cursor() %>"
fulldate: <% tp.date.now("YYYY-MM-DDTHH:MM:SSZZ") %>
date: <% tp.date.now("YYYY-MM-DD") %>
layout: post
hidden: false
draft: false
---

Public journal note (<C-S-t>) is pretty much identical:

<% tp.file.move("garden/rl/"+tp.date.now("YYMMDD-HHmm")+" "+tp.file.title) %>---
title: "<% tp.file.title %>"
tags:
  - "zc"
  - "zc/rl"
  - "<% tp.file.cursor() %>"
fulldate: <% tp.date.now("YYYY-MM-DDTHH:MM:SSZZ") %>
date: <% tp.date.now("YYYY-MM-DD") %>
layout: post
hidden: false
draft: false
---

Notes not meant to be published (<C-t>) get put into /Personal , but also:

• Have no date in frontmatter, obyde should loudly error out if it sees them (which it should never)
• If they magically end up published, I put literally all “don’t pulbish me” parameters in the header.

Linking to blocks and headers in #obsidian

Is helpfully describeed in the autocomplete for [[:

• [[^to internal blocks (you have to type the title by yourself, like this)
• [[# for headers (Manually creating block references).
  • Can work even when linking from other pages!

EDIT 2021-12-07: You can do this from external pages too! Just autocompletion is not intuitive. See 211207-2015 Obsidian embedding parts of other document. ¹

Manually creating block references

When linking internally it autogenerates reference names, it seems. ^74ce58

Can I do this? ^myreference

Yes I can! Autocompletion even suggests/uses my reference!

Can _I_ do this? ^myreference

[Yes I can!](#^myreference)  Autocompletion even suggests/uses my reference!

When looking at a commit, clicking on “View the entire source for this file” symbol opens that file, and then one can navigate to folders etc as usual, they’ll all be from the current branch.

Hugo generates anchors from headers automatically ¹. Tested it - yes, except they’re lowercased and spaces get converted to - (which makes sense).

As a refresher, in HTML it’s

<h2 id="anchor">..</h2>
<a name="anchor"></a>

<a href="#anchor">anchor link </a>