#+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 = "kitty"
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(theme):
    if theme == "city-lights":
        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',
    ]
    elif theme == "gruvbox":
        return [
        # normal colors
        '#282828',
        '#cc241d',
        '#98971a',
        '#d79921',
        '#458588',
        '#b16286',
        '#689d6a',
        '#a89984',
        #bright colors
        '#928374',
        '#fb4934',
        '#b8bb26',
        '#fabd2f',
        '#83a598',
        '#d3869b',
        '#8ec07c',
        '#ebdbb2',
        # background
        '#282828',
        # foreground
        '#ebdbb2',
    ]

colors = get_colors("gruvbox")
#+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], "v", lazy.spawn("inkscape"), desc="Run Inkscape"),
    Key([mod], "g", lazy.spawn("gimp"), desc="Run GIMP"),
    Key([mod], "t", lazy.spawn("torbrowser-launcher"), desc="Run Tor Browser"),
    Key([mod], "i", lazy.spawn("emacsclient --eval \"(emacs-everywhere)\""), desc="Emacs Everywhere!"),
    Key([mod], "d", lazy.spawn("rofi -show run"), desc="rofi command launcher"),
])
#+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"),
    Key([], "Print", lazy.spawn("scrot '%Y-%m-%d-%s_screenshot_$wx$h.jpg' -e 'mv $f ~/img/scrot")),
])
#+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(border_focus=colors[2], border_normal=colors[0], border_width=4, margin=7),
    # layout.MonadWide(),
    # layout.RatioTile(),
    # layout.Tile(),
    # layout.TreeTab(),
    # layout.VerticalTile(),
    # layout.Zoomy(),
]
#+end_src
** Bar
Now we define our bar. I only have the need to see the time, current workspace, battery percentage,
and MPD. Also, you may need to manually change your font size depending on your screen.
#+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_colorsr=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_colorsr=["ff00ff", "000000", "ff00ff", "000000"]  # Borders are magenta
#         ),
#         bottom=bar.Gap(4),
#         left=bar.Gap(3),
#         right=bar.Gap(3),
#     ),
# ]

def pline(rl, fg, bg):
    if rl == 0:
        uc = ""
    else:
        uc = ""
    return widget.TextBox(text = uc,
                          padding = 0,
                          fontsize = 22,
                          foreground=fg,
                          background=bg)

screens = [
    Screen(
        wallpaper="~/.config/qtile/wallpaper",
        wallpaper_mode="fill",
        top=bar.Bar(
            [
                widget.CurrentLayoutIcon(
                    scale=0.75,
                    background=colors[3]
                ),
                pline(0, colors[3], colors[6]),
                widget.GroupBox(
                    highlight_method="block",
                    background=colors[6],
                    this_current_screen_border="#7daea3"
                ),
                pline(0, colors[6], colors[7]),
                widget.TaskList(
                    highlight_method="block",
                    max_title_width=300,
                    border="#d3869b",
                    padding=2,
                    background=colors[7]
                ),
                pline(0, colors[7], colors[0]),
                widget.Spacer(),

                pline(1, colors[2], colors[0]),
                widget.Net( # requires python-psutil
                    interface="wlp0s20f3",
                    format="📡 {total}",
                    update_interval=30,
                    background=colors[2]
                ),
                pline(1, colors[5], colors[2]),
                widget.Backlight(
                    format="💡 {percent:2.0%}",
                    backlight_name="intel_backlight",
                    background=colors[5]
                ),
                pline(1, colors[3], colors[5]),
                widget.Volume(
                    emoji=True,
                    background=colors[3]
                ),
                widget.Volume(
                    background=colors[3]
                ),
                pline(1, colors[4], colors[3]),
                widget.BatteryIcon(
                    background=colors[4]
                ),
                widget.Battery(
                    charge_char="now ",
                    discharge_char="left",
                    format="{percent:2.0%} {char}",
                    background=colors[4]
                    ),
                pline(1, colors[1], colors[4]),
                widget.Clock(
                    format="%Y-%m-%d %a %I:%M %p",
                    background=colors[1]
                ),
            ],
            26,
        ),
    ),
]
#+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