---
weight: 4
title: "Configurando Qtile"
date: 2023-08-05T18:16:09+0200
draft: false
summary: "Notas sobre configuración de Qtile"
resources:
- name: "featured-image"
  src: "featured-image.png"
- name: "featured-image-preview"
  src: "featured-image-preview"
categories:
  - notes
tags:
  - qtile
  - python
  - windowmanager
---

{{< admonition type=warning title="Work in progress" open=true >}}

Estos apuntes de configuración del gestor de ventanas ___Qtile___ están **INCOMPLETOS**

{{< /admonition >}}


{{< admonition type=info title="Referencias" open=true >}}

- [Qtile examples](https://github.com/qtile/qtile-examples)
- [Configuracion de Dani Diaz](https://github.com/DaniDiazTech/Qtile-Config)
- [Autokey](https://blog.desdelinux.net/autokey-util-herramienta-automatizacion-tareas-gnu-linux/)

{{< /admonition >}}


## ACTUALIZACIÓN: La instalación de Qtile falla por las versiones de las dependencias

No funciona la instalación descrita más abajo en un entorno virtual y no funciona la instalación por paquetes del sistema (al menos en Linux Mint Vanessa). Las versiones de las dependencias son demasiado modernas.

Sólo he conseguido compilar una versión funcional de Qtile usando las fuentes de desarrollo, con la siguiente receta:

```bash
# Creamos el directorio de trabajo
mkdir <workPath>/qtile
cd <workPath>/qtile

# Creamos el entorno virtual, si usas pyenv esto te vale:
pyenv virtualenv system ve_qtile
pyenv local ve_qtile

# SI NO USAS pyenv haz esto, crearas el entorno virtual en el
# directorio <workPath>/qtile/venv
python -m venv venv
. ./venv/bin/activate

# Asegurate de estar en el entorno virtual que hayas creado y que lo tengas activo y haz:
pip install git+https://github.com/qtile/qtile@master
```

Con los pasos descritos tendrás un Qtile en el directorio
`<workPath>/qtile/venv/bin`, pero evidentemente sólo funciona con el
_virtualenv_ activado.

Tenenemos que crear un script para tu gestor de login gráfico favorito (yo uso Lightdm)

Como `root` nos creamos un script `launch_qtile` en `/usr/local/bin`, con el siguiente contenido (estoy suponiendo que no usas _pyenv_)

```bash
#!/bin/bash
source '/home/<user>/<workPath>/qtile/venv/bin/activate'

/home/<user>/<workPath>/qtile/bin/qtile start
```

Le damos permisos de ejecución con `chmod 755 launch_qtile` (ojo a los permisos para _all_ que si no son estos no le gusta a _Lightdm_)

También como `root` creamos el fichero `/usr/share/xsessions/qtile.desktop` con el contenido:

```bash
[Desktop Entry]
Name=Qtile
Comment=Qtile Session
Exec=launch_qtile
Type=Application
Keywords=wm;tiling
```

Y con esto tendremos Qtile disponible en _Lightdm_.


## Instalando Qtile en un virtualenv

Vamos a describir la instalación del _Qtile_ en un _virtualenv_ dedicado. Si te bajas la versión estable de _Qtile_ desde su [página web](http://qtile.org) en el paquete vienen un montón de script auxiliares que te permiten hacer la instalación aislada en un _virtualenv_ pero lo voy a hacer a mano para tenerlo controlado con `pyenv`.

* Creamos el _virtualenv_ `qtile` basado en la versión 3.10.0 que teniamos instalada previamente:

```bash
# Creamos el directorio de trabajo
mkdir <workPath>/qtile
cd <workPath>/qtile

# OPCIONAL: Descargamos el qtile estable de la página web
# sólo es necesario si quieres curiosear los scripts auxiliares
wget https://github.com/qtile/qtile/archive/v0.18.1.tar.gz
tar xvzf v0.18.1.tar.gz
rm v0.18.1.tar.gz

# Creamos el entorno virtual
pyenv virtualenv 3.10.0 qtile
pyenv local qtile
# Instalamos los paquetes iniciales (comunes a mis entornos)
pip install --upgrade pip setuptools wheel

# instalamos los requisitos
pip install --no-cache-dir xcffib
pip install --no-cache-dir cairocffi

# Instalamos la versión estable de qtile
pip install --no-cache-dir qtile
```

Con esto ya estamos listos, podríamos arrancar _Qtile_ con `qtile start`, pero no puede funcionar claro. Para que arranque correctamente, tenemos que lanzarlo en un servidor X. (ver el punto "[Lanzar Window Managers con Xephyr]")


## Configurar Qtile en _virtualenv_ para arrancer desde el _Lightdm_

Como `root` nos creamos un script `launch_qtile` en `/usr/local/bin`, con el siguiente contenido

```bash
#!/bin/bash
source '/home/user/.pyenv/versions/3.10.0/envs/qtile/bin/activate'
qtile start
```

Le damos permisos de ejecución con `chmod 755 launch_qtile` (ojo a los permisos para _all_ que si no son estos no le gusta a _Lightdm_)

También como `root` creamos el fichero `/usr/share/xsessions/qtile.desktop` con el contenido:

```bash
[Desktop Entry]
Name=Qtile
Comment=Qtile Session
Exec=launch_qtile
Type=Application
Keywords=wm;tiling
```

Y con esto tendremos Qtile disponible en _Lightdm_.

## Lanzar Window Managers con Xephyr

Para probar (o configurar) los _Window Managers_ sin salir de nuestra sesión de Mate podemos usar Xephyr, si no lo tienes instalado ejecuta:

```bash
sudo apt update
sudo apt install xserver-xephyr
```

Para lanzar un _Xserver_ usaríamos un comando como:

```bash
Xephyr -ac -screen 800x600 -br -reset -terminate 2> /dev/null :1 &
```

**-ac**

:    Autorizar conexiones de clientes indiscriminadamente (_disable access restrictions_)

**-screen**

:    Especificar la geometría de la pantalla.

**-br**

:    La ventana raiz tendrá fondo negro

**-reset**

:    Reset al terminar el último cliente

**-terminate**

:    Finalizar cuando se resetee el servidor

**2> /dev/null**

:    Mandar los mensajes de error al limbo (alias **NE** en nuestro pc)

**:1**

:    Arrancar el server en el DISPLAY=1

Asi que si queremos arrancar por ejemplo el _i3wm_ podríamos hacer un script con las siguientes lineas:

```bash
Xephyr -ac -screen 800x600 -br -reset -terminate 2> /dev/null :1 &
export DISPLAY=:1
qtile start
```

## Configuración de Qtile

La configuración de _Qtile_ reside en `~/.config/qtile/config.py`

### Configuración de programas en el arranque

Vamos a implementar la ejecución de programas en el arranque de nuestro _Qtile_.

Por un lado es necesario que importemos los módulos `os` y `subprocess` y desde el módulo `libqtile` necesitamos importar `hook`.

```python
import os
import subprocess

from libqtile import hook
```

Ahora podemos implementar la función `startup`

```python
@hook.subscribe.startup_once
def start_once():
    home = os.path.expanduser('~')
    subprocess.call([home + '/.local/bin/autostart'])
```

Con el decorador `@hook.subscribe` hemos hecho que la función
`start_once()` quede suscrita al evento `startup_once` que _Qtile_
genera, una sola vez, en el arranque ([ver
documentación](https://docs.qtile.org/en/latest/manual/config/hooks.html)).

El script `~/.local/bin/autostart` tiene el siguiente contenido:

```bash
#!/usr/bin/env bash
# ---
# Use "run program" to run it only if it is not already running
# Use "program &" to run it regardless
# ---

function run {
    if ! pgrep $1 > /dev/null ;
    then
        $@&
    fi
}

# run picom -CGb &
run nitrogen --restore &
# run megasync
# run xfce4-clipman
# run gammy
```


#### Programas que queremos lanzar en el arranque

**picom**

:    _picom_ es un window composer

     - [Compilar picom](https://dev.to/l04db4l4nc3r/compositors-in-linux-1hhb#picom)

**Nitrogen**

:    _[Nitrogen](https://github.com/l3ib/nitrogen)_ nos valdrá para gestionar los fondos de pantalla. Tenemos la última versión 1.6.1 disponible en los repos. Podemos instalar con `sudo apt install nitrogen`

**Rofi**

:    _rofi_ ya lo teníamos instalado. Es un sustito para _Dmenu_ que ya usamos en Mate

**gammy**

:    _[gammy](https://github.com/fushko/gammy)_ nos sirve para gestionar el brillo de la pantalla


**urxvt**

:    Un terminal con soporte UTF

**feh**

:    Un visor de imágenes para los fondos de pantalla (no está claro que sea necesario)


### Cambios variados

- Cambiamos el tamaño de letra para widgets a 16 puntos (lo vemos en la barra de estado)

{{< admonition type=danger title="pyenv" open=true >}}

Antes de arrancar Qtile parece que tenemos que asegurarnos de tener `pyenv global system` de lo contrario no veremos el entorno virtual de Qtile.

{{< /admonition >}}
