====== Qtile ======

Gestor de ventanas de mosaico (//tiling window manager//) escrito y configurable con [[informatica:programacion:python|Python]].

  * [[https://qtile.org/|Web oficial]]
  * [[https://github.com/qtile/qtile/|Repositorio de código]]
  * [[https://github.com/qtile/qtile/blob/master/CHANGELOG|Registro de cambios]]

<WRAP center round important 60%>
Las notas aquí recogidas se centran en la versión ''0.33.1'' de Qtile. Se puede consultar el registro de cambios desde [[https://docs.qtile.org/en/latest/manual/changelog.html|aquí]] (útil para comprobar novedades o cambios que rompen configuraciones antiguas).
</WRAP>

Para que Qtile pueda enviar notificaciones hay que instalar el módulo de Python dbus-fast (''python-dbus-fast'' en Arch Linux)

{{ https://qtile.org/images/screenshots/longerhv_hu1a89821f52d855b1686852be8340ee2c_1772593_1920x0_resize_q75_h2_box_3.webp |}}
===== Atajos de teclado =====

Configuración por defecto. La tecla ''mod'' se refiere a la tecla ''super'', la que suele tener la serigrafía del logo de Windows. Por defecto:

^                Atajo              ^ Acción ^
| ''mod'' + ''k''                   |  switch windows on the current stack  |
| ''mod'' + ''j''                   |  switch windows on the current stack  |
| ''mod'' + ''<space>''             | Cambia el foco del panel (en la disposición de stack) |
| ''mod'' + ''<tab>''               | Cambiar a la siguiente disposición  |
| ''mod'' + ''w''                   | Cerrar ventana |
| ''mod'' + ''<ctrl>'' + ''r''      | Reinicia Qtile con la nueva configuración |
| ''mod'' + ''<group name>''        | Moverse al grupo ''<group name>''  |
| ''mod'' + ''<shift>'' + ''<group name>'' | Enviar una ventana al grupo ''<group name>'' |
| ''mod'' + ''<enter>''             | Lanza el terminal configurado en ''libqtile.utils.guess_terminal'' |
| ''mod'' + ''r''                   | Lanzador de comandos |

Para personalizar los atajos de teclado, en el fichero ''config.py'', los configuramos en el array ''keys[]'':

<code python>
keys = [
    Key(["control", "mod1"], "t", lazy.spawn(terminal), desc="Lanzar terminal"),
]
</code>

El nombre de cada tecla está definido en el [[https://github.com/qtile/qtile/blob/master/libqtile/backend/x11/xkeysyms.py|código fuente]].

===== Arranque al inicio =====

Para ejecutarlo con el servidor X, podemos añadir al fichero ''.xinitrc'':

<code>
exec qtile start
</code>

Y podríamos lanzarlo entonces con ''startx''
===== Configuración =====

Para personalizar Qtile, se utilizará un fichero llamado ''config.py'' que situaremos en ''~/.config/qtile/''.

<WRAP center round info 60%>
El fichero de configuración por defecto más reciente se puede descargar del repositorio de GitHub en [[https://github.com/qtile/qtile/blob/master/libqtile/resources/default_config.py|libqtile/resources/default_config.py]]. 
</WRAP>

La configuración se hace en Python. Tras hacer cambios, antes de reiniciar Qtile, podemos probar si el fichero de configuración da algún error:

<code bash>
python -m py_compile ~/.config/qtile/config.py
</code>

Si no devuelve nada es que no ha habido ningún error y podremos reiniciar Qtile.

De todos modos, la recomendación es lanzar Qtile en un nueva sesión de X mediante Xephyr:

<code bash>
Xephyr -br -ac -noreset -screen 800x600 :1 &
</code>

Y lanzamos Qtile en esa sesión:

<code bash>
DISPLAY=:1 qtile &
</code>

==== Probar configuración ====

En Qtile recomiendan usar [[https://raw.githubusercontent.com/qtile/qtile/master/scripts/xephyr|este script]] que usa [[informatica:sistemas_operativos:linux:software:xephyr|Xephyr]]

==== Recargar configuración ====

<code>
qtile cmd-obj -o cmd -f reload_config
</code>

==== Reiniciar Qtile ====

<code>
qtile cmd-obj -o cmd -f restart
</code>

==== Atajos de teclado ==== 

Personalizar atajos de teclado:

<code python>
keys = [
    # Cerrar ventana con foco
    # Win + w
    Key(["control"], "w", lazy.window.kill(), desc="Cerrar ventana con foco"),
    
    # Mueve el foco de la ventana al siguiente panel
    # Alt + Tab 
    Key([mod1], "Tab", lazy.layout.next(),
        desc="Alternar foco"),
        
    # Alternar layouts
    # Win + Tab 
    Key([mod], "Tab", lazy.next_layout(), desc="Alternar layout"),
        
    # Lanzar un terminal
    # Ctrl + Alt + T 
    Key(["control", mod1], "t", lazy.spawn("urxvt"),

    # Moverse entre grupos
    Key(["control", mod1], "Right", lazy.screen.next_group(), 
        desc="Siguiente grupo"),
    Key(["control", mod1], "Left", lazy.screen.prev_group(), 
        desc="Anterior grupo"),

    # Captura de pantalla
    Key(
        [], "Print",
        lazy.spawn("scrot 'captura-%Y-%m-%d_$wx$h.png' -e 'mv $f ~/img/screenshots'"),
        desc="Captura de pantalla"
    ),
    
    # Captura de pantalla con selección
    Key(
        ["shift"], "Print",
        lazy.spawn("scrot -s 'captura-%Y-%m-%d_$wx$h.png' -e 'mv $f ~/img/screenshots'"),
        desc="Captura de pantalla"
    )
]
</code>
==== Autoarranque ====

Si queremos que se inicien algunas aplicaciones cuando lo haga Qtile, podemos crear un script en bash llamado, por ejemplo, ''autostart.sh'':

<code bash>
#!/bin/bash

# Fondo de pantalla
feh --bg-fill /home/pepito/wallpapers/img.png &

# Deshabilitar pitido
xset b off &

# Deshabilitar suspensión o pantalla en negro
xset -dpms; xset s off &
</code>

Le damos permisos de ejecución:

<code bash>
chmod +x ~/.config/qtile/autostart.sh
</code>

En el fichero de configuración de Qtile añadimos:

<code python>
import os 
import subprocess

from libqtile import hook

def autostart():
    home = os.path.expanduser('~')
    subprocess.Popen([home + '/.config/qtile/autostart.sh'])
</code>
===== Ventanas =====

La ventana es cada elemento que contiene una aplicación.

^ Función                         ^ Descripción ^
| ''lazy.window.kill()''          | Cierra la ventana con el foco  |
| ''lazy.layout.next()''          | Mueve el foco a la siguiente ventana de la pila  |
| ''lazy.layout.previous()''          | Mueve el foco a la anterior ventana de la pila  |
| ''lazy.window.togroup(%%"%%group_name%%"%%)''  | Mueve la ventana con el foco al grupo ''group_name''  |
| ''lazy.window.toggle_floating()''  | Alterna la ventana con el foco entre el modo flotante  |
| ''lazy.window.toggle_fullscreen()''  | Alterna entre el modo de pantalla completa la ventana con el foco  |

==== Reglas para ventanas flotantes ====

<code python>
floating_layout = layout.Floating(float_rules=[
    # Run the utility of `xprop` to see the wm class and name of an X client.
    Match(wm_class='confirm'),
    Match(wm_class='dialog'),
    Match(wm_class='download'),
    Match(wm_class='error'),
    Match(wm_class='file_progress'),
    Match(wm_class='notification'),
    Match(wm_class='splash'),
    Match(wm_class='toolbar'),
    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
])
</code>
===== Grupos =====

Un grupo es un contenedor de ventanas, como si fueran espacios de trabajo/escritorios virtuales.

Aparecen en la barra inferior. Por defecto son ''a'', ''s'', ''d'', ''f'', ''u'', ''i'', ''o'' y ''p''.

Para modificarlas:

<code python>
# Número de grupos y lista de parámetros
group_info = [
    ['1', 'www'],
    ['2', 'music'],
    ['3', 'docs'],
    ['4', 'video'],
    ['5', 'code']
]

# Instancia de los grupos
groups = [Group(name=i[0], label=i[1]) for i in group_info]

# Atajos de teclado por defecto para los grupos
for i in groups:
    keys.extend([
        # mod1 + letter of group = switch to group
        Key([mod], i.name, lazy.group[i.name].toscreen()),

        # mod1 + shift + letter of group = switch to & move focused window to group
        Key([mod, "shift"], i.name, lazy.window.togroup(i.name, switch_group=True)),
    ])
</code>

De esa manera, tras reiniciar Qtile, los grupos/espacios de trabajo se llamarán ''www'', ''music'', ''docs'', ''video'' y ''code''. Podremos acceder a cada uno de ellos mediante ''Mod'' + 1, para ''www''; ''Mod'' + 2 para ''music'', y así sucesivamente.

===== Widgets =====

Los widgets son pequeños dibujos que se muestran en la barra de usuario. Un widget puede mostrar texto, imágenes y dibujos. Además, un widget puede ser configurado para actualizarse por tiempo, eventos de ''dbus'', hooks, etc. y puede responder a eventos del ratón.

  * [[http://docs.qtile.org/en/latest/manual/ref/widgets.html|Built-in widgets]]
===== Disposiciones =====

Una disposición (//layout//) es un algoritmo para colocar las ventanas en un grupo. Como Qtile es un gestor de ventanas de mosaico, intenta usar el espacio de la forma más eficiente posible.

Por defecto, Qtile viene con las siguientes disposiciones:

  * **Floating**: Qtile no gestiona el espacio, cada ventana abierta puede ponerse donde se quiera con el ratón (''mod'' + botón izquierdo del ratón para mover la ventana).
  * **Bsp**: inspirado en [[https://github.com/baskerville/bspwm|bspwm]]
  * **Columns**: extensión de la disposición **stack**
  * **Matrix**: divide la pantalla en una matriz con celdas del mismo tamaño.
  * **Max**: cada ventana ocupa toda la pantalla.
  * **MonadTall**: emula el comportamiento por defecto del gestor XMonad.
  * **MonadThreeCol**: emula el comportamiento de la disposición ''ThreeColumns'' de XMonad.
  * **MonadWide**: emula el modo horizontal del gestor XMonad.
  * **RatioTile**: 
  * **Slice**:
  * **Spiral**: divide la pantalla en ventanas en forma de espiral. 
  * **Stack**: 
  * **Tile**: divide la pantalla en dos, una maestra que no se divide y otra que puede ir añadiendo paneles.
  * **TreeTab**: se comporta como **Max**, pero muestra unas pestañas en un panel lateral con las ventanas abiertas.
  * **VerticalTile**:
  * **Zoomy**:

Para tener la posibilidad de alternar entre layouts, los añadimos en el fichero de configuración:

<code python>
layouts = [
    layout.Bsp(),
    layout.Matrix(),
    layout.Columns(),
    layout.Max(),
    layout.Floating(),
    layout.MonadTall(
        border_focus="#bd93f9"
    ),
    layout.MonadWide(),
    layout.RatioTile(),
    layout.Slice(),
    layout.Stack(),
    layout.Tile(),
    layout.TreeTab()
    layout.VerticalTile(),
    layout.Zoomy(),
]
</code>

Para cambiar al vuelo de disposición, la combinación de teclas es ''mod'' + ''Tab''.

  * [[https://docs.qtile.org/en/latest/manual/ref/layouts.html|Documentación sobre los layouts]]

===== ScratchPad =====

ScratchPad es un tipo especial (y por defecto invisible) de grupo que actúa como contenedor para configuraciones DropDown.
===== Registro =====

Útil para saber si hay algún error con la configuración de Qtile, por ejemplo, el registro se lleva en ''~/.local/share/qtile/qtile.log''

===== Recursos =====

  * [[http://docs.qtile.org/en/latest/index.html|Documentación oficial]]
  * [[https://wiki.archlinux.org/index.php/Qtile|Qtile]] (Wiki ArchLinux)