path: root/config/qtile.org

#+title: My Qtile Config (Mocha)
#+author: Preston Pan
#+date: <2023-06-09 Fri>
#+description: a catppuccin qtile configuration written in emacs
#+html_head: <link rel="stylesheet" type="text/css" href="../style.css" />
* Goals
** We want the configuration to have efficient and ergonomic keybindings.
Commonly used keybindings should be two keys, less common ones should use more.
** We want it to work with other programs that it references.
For example, the qutebrowser and qtile configurations should not cause conflict
and they should have mutual consistency.
*** This will therefore make the configuration self sufficient.
** General enough that it will work for most purposes.
Specialized programs or tools should be in a separate section which will make
it easy to parse and remove.

* Configuration
** Imports and Definitions
All of this is also in the default configuration.
#+begin_src python :tangle config.py
from libqtile import bar, layout, widget
from libqtile.config import Click, Drag, Group, Key, Match, Screen
from libqtile.lazy import lazy
from libqtile.utils import guess_terminal
from libqtile import hook
from libqtile.backend.wayland import InputConfig

import os
import subprocess


mod = "mod4"
terminal = guess_terminal()
wl_import_rules = None
auto_minimize = True
wmname = "LG3D"
#+end_src
** Hex Colors
We then load the catppuccin colors for the bar and window borders.
#+begin_src python :tangle config.py
def get_colors():
    return [
        # Normal colors
        '#45475a',
        '#f38ba8',
        '#a6e3a1',
        '#f9e2af',
        '#89b4fa',
        '#f5c2e7',
        '#94e2d5',
        '#bac2de',

        # Bright colors
        '#585b70',
        '#f38ba8',
        '#a6e3a1',
        '#f9e2af',
        '#89b4fa',
        '#f5c2e7',
        '#94e2d5',
        '#a6adc8',

        # background
        '#1e1e2e',
        # foreground
        '#cdd6f4',
    ]

colors = get_colors()
#+end_src
** Keybindings
The _keys_ variable is going to be our final list of keybindings. We start by initializing it
wth our window manipulation bindings with vim keys:
*** Focus controls
Vi inspired keybindings to manipulate focus:
#+begin_src python :tangle config.py
keys = [
    Key([mod], "h", lazy.layout.left(), desc="Move focus to left"),
    Key([mod], "l", lazy.layout.right(), desc="Move focus to right"),
    Key([mod], "j", lazy.layout.down(), desc="Move focus down"),
    Key([mod], "k", lazy.layout.up(), desc="Move focus up"),
    Key([mod], "space", lazy.layout.next(), desc="Move window focus to other window"),

    Key([mod, "shift"], "h", lazy.layout.shuffle_left(), desc="Move window to the left"),
    Key([mod, "shift"], "l", lazy.layout.shuffle_right(), desc="Move window to the right"),
    Key([mod, "shift"], "j", lazy.layout.shuffle_down(), desc="Move window down"),
    Key([mod, "shift"], "k", lazy.layout.shuffle_up(), desc="Move window up"),

    Key([mod, "control"], "h", lazy.layout.grow_left(), desc="Grow window to the left"),
    Key([mod, "control"], "l", lazy.layout.grow_right(), desc="Grow window to the right"),
    Key([mod, "control"], "j", lazy.layout.grow_down(), desc="Grow window down"),
    Key([mod, "control"], "k", lazy.layout.grow_up(), desc="Grow window up"),
    Key([mod], "n", lazy.layout.normalize(), desc="Reset all window sizes"),
    Key(
        [mod, "shift"],
        "Return",
        lazy.layout.toggle_split(),
        desc="Toggle between split and unsplit sides of stack",
    ),
    Key([mod], "Tab", lazy.next_layout(), desc="Toggle between layouts"),
]
#+end_src
*** Quit/Restart
#+begin_src python :tangle config.py
keys.extend([
    Key([mod], "q", lazy.window.kill(), desc="Kill focused window"),
    Key([mod, "control"], "r", lazy.reload_config(), desc="Reload the config"),
    Key([mod, "control"], "q", lazy.shutdown(), desc="Shutdown Qtile"),
])
#+end_src
*** Programs
These are our keybindings for user programs.
#+begin_src python :tangle config.py
keys.extend([
    Key([mod], "r", lazy.spawncmd(), desc="Spawn a command using a prompt widget"),
    Key([mod], "Return", lazy.spawn(terminal), desc="Launch terminal"),
    Key([mod], "e", lazy.spawn("emacs"), desc="Run emacs"),
    Key([mod], "w", lazy.spawn("qutebrowser"), desc="Run Qutebrowser"),
    Key([mod], "f", lazy.spawn("firefox"), desc="Run Firefox"),
    Key([mod], "b", lazy.spawn("blender"), desc="Run Blender"),
    Key([mod], "p", lazy.spawn("krita"), desc="Run Krita"),
    Key([mod], "t", lazy.spawn("torbrowser-launcher"), desc="Run Tor Browser"),
    Key([mod], "i", lazy.spawn("emacsclient --eval \"(emacs-everywhere)\""), desc="Emacs Everywhere!"),
])
#+end_src
*** XF86
Now we need keybindings for the function keys:
#+begin_src python :tangle config.py
keys.extend([
    Key([], 'XF86AudioLowerVolume', lazy.spawn("pactl set-sink-volume @DEFAULT_SINK@ -5%")),
    Key([], 'XF86AudioRaiseVolume', lazy.spawn("pactl set-sink-volume @DEFAULT_SINK@ +5%")),
    Key([], 'XF86AudioMute', lazy.spawn("pactl set-sink-mute @DEFAULT_SINK@ toggle")),
    Key([], 'XF86MonBrightnessUp', lazy.spawn("light -A 10")),
    Key([], 'XF86MonBrightnessDown', lazy.spawn("light -U 10")),
    Key([], 'XF86AudioNext', lazy.spawn("mpc next")),
    Key([], 'XF86AudioPrev', lazy.spawn("mpc prev")),
    Key([], "XF86AudioPlay", lazy.spawn("mpc toggle"), desc="Play/Pause player"),
])
#+end_src
** Groups
Now we name our groups:
#+begin_src python :tangle config.py
groups = [Group(i) for i in "123456789"]

for i in groups:
    keys.extend(
        [
            Key(
                [mod],
                i.name,
                lazy.group[i.name].toscreen(),
                desc="Switch to group {}".format(i.name),
            ),
            Key(
                [mod, "shift"],
                i.name,
                lazy.window.togroup(i.name, switch_group=True),
                desc="Switch to & move focused window to group {}".format(i.name),
            ),
        ]
    )
#+end_src
** Layouts
This is our list of enabled layouts. You can enable more of them if you want.
#+begin_src python :tangle config.py
layouts = [
    layout.Columns(border_focus=colors[2], border_normal=colors[0], border_width=4, margin=7),
    layout.Max(),
    # Try more layouts by unleashing below layouts.
    # layout.Stack(num_stacks=2),
    # layout.Bsp(),
    # layout.Matrix(),
    # layout.MonadTall(),
    # layout.MonadWide(),
    # layout.RatioTile(),
    # layout.Tile(),
    # layout.TreeTab(),
    # layout.VerticalTile(),
    # layout.Zoomy(),
]
#+end_src
** Bar
#+begin_src python :tangle config.py
widget_defaults = dict(
    font="FiraCode Nerd Font",
    fontsize=16,
    padding=4,
    foreground=colors[17],
    background=colors[16],
)
extension_defaults = widget_defaults.copy()

screens = [
    Screen(
        top=bar.Bar(
            [
                # widget.CurrentLayout(),
                widget.GroupBox(active=colors[6], inactive=colors[15], this_current_screen_border=colors[4], highlight_color=colors[3]),
                widget.Prompt(),
                widget.WindowName(),
                widget.Chord(
                    chords_colors={
                        "launch": ("#ff0000", "#ffffff"),
                    },
                    name_transform=lambda name: name.upper(),
                ),
                # widget.StatusNotifier(),

                widget.Systray(),
                widget.Battery(charge_char="🔋", discharge_char="🔋", full_char="🔋", format="{char} {percent:2.0%}"),
                # widget.TextBox("|", foreground=colors[1]),
                widget.Sep(padding=16, size_percent=80, foreground=colors[1]),
                widget.Clock(format="🕒 %a %I:%M %p"),
                widget.Sep(padding=16, size_percent=80, foreground=colors[1]),
                widget.Mpd2(),
                widget.TextBox("  "),

            ],
            24,

            # border_width=[2, 0, 2, 0],  # Draw top and bottom borders
            # border_color=["ff00ff", "000000", "ff00ff", "000000"]  # Borders are magenta
        ),
        bottom=bar.Gap(4),
        left=bar.Gap(3),
        right=bar.Gap(3),
    ),
]
#+end_src
** Mouse
We configure the mouse to interact with floating windows.
#+begin_src python :tangle config.py
mouse = [
    Drag([mod], "Button1", lazy.window.set_position_floating(), start=lazy.window.get_position()),
    Drag([mod], "Button3", lazy.window.set_size_floating(), start=lazy.window.get_size()),
    Click([mod], "Button2", lazy.window.bring_to_front()),
]
#+end_src

Also, we need to toggle some options:
#+begin_src python :tangle config.py
dgroups_app_rules = []  # type: list
follow_mouse_focus = True
bring_front_click = False
cursor_warp = False
#+end_src

And then we add the applications that need to start in floating:
#+begin_src python :tangle config.py
floating_layout = layout.Floating(
    float_rules=[
        # Run the utility of `xprop` to see the wm class and name of an X client.
        *layout.Floating.default_float_rules,
        Match(wm_class="confirmreset"),  # gitk
        Match(wm_class="makebranch"),  # gitk
        Match(wm_class="maketag"),  # gitk
        Match(wm_class="ssh-askpass"),  # ssh-askpass
        Match(title="branchdialog"),  # gitk
        Match(title="pinentry"),  # GPG key password entry
    ]
)
#+end_src
** I have no idea what these are
but they work for some reason.
#+begin_src python :tangle config.py
auto_fullscreen = True
focus_on_window_activation = "smart"
reconfigure_screens = True
#+end_src
** Autostart
If we used wayland, then we must autostart here:
#+begin_src python :tangle config.py
@hook.subscribe.startup_once
def autostart():
   home = os.path.expanduser("~")
   subprocess.call([home + '/.config/qtile/autostart.sh'])
#+end_src
** Input Rules
in wayland, setxkbmap is not possible. Therefore:
#+begin_src python :tangle config.py
wl_input_rules = {
    "1267:12377:ELAN1300:00 04F3:3059 Touchpad": InputConfig(left_handed=True),
    "*": InputConfig(left_handed=True, pointer_accel=True),
    "type:keyboard": InputConfig(kb_options="caps:swapescape,compose:ralt"),
}
#+end_src