En el vasto universo de los gestores de ventanas tipo mosaico, Qtile brilla con luz propia por su flexibilidad y la profunda capacidad de personalización que ofrece. Lejos de las interfaces prediseñadas y, a menudo, recargadas, Qtile invita a sus usuarios a ser los arquitectos de su propio entorno de trabajo. Pero, ¿qué pasa cuando la funcionalidad básica, como la gestión de redes inalámbricas, se siente un tanto rudimentaria o simplemente no encaja con tu flujo de trabajo optimizado? ¡Ahí es donde entra en juego la magia de crear tu propio widget de red Wi-Fi personalizado! ✨
Este artículo te guiará paso a paso en el desarrollo de un módulo de barra para Qtile que no solo mostrará el estado de tu conexión a internet, sino que también te permitirá interactuar con ella de una manera elegante y eficiente. Olvídate de abrir terminales o menús complejos; tu conectividad estará a un solo clic, justo donde la necesitas.
¿Por Qué Desarrollar un Widget de Red Propio?
La personalización en un gestor de ventanas como Qtile va mucho más allá de elegir un fondo de pantalla o un tema de colores. Se trata de moldear el entorno para que se adapte perfectamente a tus hábitos y necesidades. Si bien existen herramientas y complementos para la conectividad, a menudo son soluciones genéricas que pueden no integrarse a la perfección con la estética o la filosofía minimalista de Qtile. Un indicador Wi-Fi personalizado ofrece varias ventajas:
- Control Total: Tú decides qué información se muestra y cómo.
- Integración Estética: Diseña el componente para que coincida perfectamente con el resto de tu barra de estado.
- Eficiencia en el Flujo de Trabajo: Conecta o desconecta con un simple clic, sin distracciones.
- Aprendizaje y Satisfacción: Adquirirás conocimientos prácticos de Python y scripting, y disfrutarás de la satisfacción de haber creado algo funcional desde cero.
En esencia, estamos construyendo una pequeña pieza de software que te empodera. No solo estás usando un sistema operativo, lo estás diseñando para ti. Esto es la verdadera potencia de los entornos como Qtile.
Requisitos Previos: La Base de Nuestro Proyecto
Antes de sumergirnos en el código, asegúrate de tener lo siguiente en tu sistema:
- Qtile Instalado y Configurándose: Parece obvio, ¿verdad? Debes tener una instalación funcional de Qtile y estar cómodo editando su archivo de configuración,
config.py. - Conocimientos Básicos de Python: Nuestro módulo estará escrito en Python, el lenguaje nativo de Qtile. No necesitas ser un experto, pero familiarizarte con funciones, cadenas y la ejecución de comandos externos será de gran ayuda.
- NetworkManager y
nmcli: Este es el motor de nuestro módulo. NetworkManager es un servicio común para gestionar conexiones de red en distribuciones Linux.nmclies su interfaz de línea de comandos, que utilizaremos para consultar el estado y manipular las conexiones inalámbricas. Asegúrate de que NetworkManager esté activo y quenmclifuncione correctamente desde tu terminal. - Font Awesome o Fuentes con Iconos: Para darle ese toque de estilo, usaremos iconos. Font Awesome es una opción popular que puedes instalar fácilmente en tu sistema (por ejemplo,
sudo apt install fonts-font-awesomeen Debian/Ubuntu). notify-send: Una utilidad simple para enviar notificaciones de escritorio. La usaremos para dar feedback visual al usuario.
Si todo esto está en orden, ¡estamos listos para iniciar!
Conceptualizando Nuestro Elemento Gráfico: ¿Qué Queremos Ver y Hacer?
Imaginemos el comportamiento ideal de nuestro módulo de red. Queremos que nos muestre:
- Un icono representativo del estado de la conexión (conectado/desconectado).
- El nombre de la red (SSID) a la que estamos enlazados.
- Una indicación de la intensidad de la señal.
Y, lo que es crucial, deseamos que sea interactivo:
- Al hacer clic en el componente, queremos poder conectar o desconectar de una red. Para simplificar, nuestra primera versión permitirá desconectar si ya estamos enlazados, y intentar la conexión a una red preferida si estamos sin acceso.
Con esta visión en mente, el diseño se centrará en la claridad y la facilidad de uso.
Paso a Paso: La Creación de la Lógica Python
Nuestro primer objetivo es crear un script Python que pueda ser invocado por Qtile. Este script contendrá las funciones para obtener el estado de la red y para gestionarla. Guarda este código en una ubicación accesible, como ~/.config/qtile/scripts/wifi_widget_logic.py.
Comencemos importando los módulos necesarios y definiendo una red preferida para una conexión rápida cuando no haya un enlace activo.
import subprocess
import re
import os
# Define tu red Wi-Fi preferida aquí.
# Cuando hagas clic y no haya conexión, el widget intentará conectarse a esta red.
PREFERRED_NETWORK_SSID = "MiRedPrincipal" # ¡Cambia esto por tu SSID!
def run_command(command):
"""Ejecuta un comando de shell y devuelve su salida o None en caso de error."""
try:
return subprocess.check_output(command, text=True, stderr=subprocess.PIPE).strip()
except subprocess.CalledProcessError as e:
# print(f"Error al ejecutar el comando '{' '.join(command)}': {e.stderr}")
return None
except FileNotFoundError:
# print(f"Comando no encontrado: '{command[0]}'")
return None
def notify(title, message):
"""Envía una notificación de escritorio."""
subprocess.run(['notify-send', title, message])
def get_wifi_status():
"""
Obtiene el estado actual de la conexión Wi-Fi, incluyendo SSID y fuerza de señal.
Devuelve una cadena formateada para el widget de Qtile.
"""
output = run_command(['nmcli', '-t', '-f', 'DEVICE,STATE', 'device'])
if not output:
return "⚠️ Error de red" # Icono de advertencia
connected_device = None
for line in output.split('n'):
parts = line.split(':')
if len(parts) >= 2 and parts[1] == 'connected':
device_type_output = run_command(['nmcli', '-t', '-f', 'DEVICE,TYPE', 'device'])
if device_type_output:
for dev_line in device_type_output.split('n'):
dev_parts = dev_line.split(':')
if dev_parts[0] == parts[0] and dev_parts[1] == 'wifi':
connected_device = parts[0]
break
if connected_device:
break
if connected_device:
ssid_output = run_command(['nmcli', '-t', '-f', 'SSID', 'connection', 'show', '--active'])
ssid = ssid_output.split('n')[0] if ssid_output else "N/A"
# Intentar obtener la señal de 'nmcli dev wifi list'
wifi_list_output = run_command(['nmcli', '-t', '-f', 'SSID,SIGNAL', 'dev', 'wifi', 'list'])
signal = "0"
if wifi_list_output:
for line in wifi_list_output.split('n'):
parts = line.split(':')
if len(parts) >= 2 and parts[0] == ssid:
signal = parts[1] # SIGNAL percentage
break
# Icono de señal (Font Awesome Unicode) y detalles de la conexión
return f"📶 {ssid} ({signal}%)"
else:
# Icono de Wi-Fi para estado desconectado
return "🚰 Desconectado"
def toggle_wifi_connection():
"""
Cambia el estado de la conexión Wi-Fi: desconecta si está conectado,
conecta a PREFERRED_NETWORK_SSID si está desconectado.
"""
output = run_command(['nmcli', '-t', '-f', 'DEVICE,STATE', 'device'])
if not output:
notify("Qtile Wi-Fi", "Error al obtener el estado de la red.")
return
connected_device = None
for line in output.split('n'):
parts = line.split(':')
if len(parts) >= 2 and parts[1] == 'connected':
device_type_output = run_command(['nmcli', '-t', '-f', 'DEVICE,TYPE', 'device'])
if device_type_output:
for dev_line in device_type_output.split('n'):
dev_parts = dev_line.split(':')
if dev_parts[0] == parts[0] and dev_parts[1] == 'wifi':
connected_device = parts[0]
break
if connected_device:
break
if connected_device:
notify("Qtile Wi-Fi", f"Desconectando de {connected_device}...")
subprocess.run(['nmcli', 'device', 'disconnect', connected_device])
else:
if PREFERRED_NETWORK_SSID:
notify("Qtile Wi-Fi", f"Conectando a {PREFERRED_NETWORK_SSID}...")
# Asumiendo que la red ya está configurada en NetworkManager
subprocess.run(['nmcli', 'connection', 'up', PREFERRED_NETWORK_SSID])
else:
notify("Qtile Wi-Fi", "No hay una red preferida configurada para conectar.")
# En un entorno de desarrollo, podrías ejecutar esto para probar:
if __name__ == "__main__":
print(get_wifi_status())
# Para probar el toggle, necesitarías interactuar con el widget en Qtile.
Este script se encarga de toda la lógica. get_wifi_status consulta nmcli para determinar si hay una conexión activa y, de ser así, extrae el SSID y la intensidad de la señal. toggle_wifi_connection utiliza nmcli para desconectar de la red actual o intentar la conexión a tu SSID preferido. Las funciones run_command y notify son utilidades para hacer el código más limpio y robusto.
La capacidad de invocar comandos de sistema desde Python es una de las mayores fortalezas al personalizar entornos como Qtile. Nos permite interactuar con cualquier herramienta de línea de comandos existente, extendiendo infinitamente las posibilidades de nuestros módulos.
Integrando el Widget en la Configuración de Qtile (config.py)
Ahora que tenemos nuestra lógica de Python, es momento de insertarla en la barra de Qtile. Abre tu archivo config.py (generalmente en ~/.config/qtile/config.py).
Primero, necesitamos asegurarnos de que Qtile pueda encontrar nuestro script. Añade las siguientes líneas al principio de tu config.py, justo después de las importaciones estándar:
import os
import sys
# Añade la ruta a tu script personalizado
sys.path.append(os.path.expanduser('~/.config/qtile/scripts'))
# Importa las funciones de tu script
import wifi_widget_logic
Luego, localiza la definición de tus pantallas (screens) y la barra (bar.Bar). Dentro de la lista de widgets de la barra, añade una instancia de widget.GenPollText. Este widget es perfecto para ejecutar una función de Python periódicamente y mostrar su resultado.
from libqtile import widget, bar
from libqtile.config import Screen
# ... otras importaciones ...
screens = [
Screen(
top=bar.Bar(
[
# ... otros widgets que ya tengas ...
widget.GenPollText(
func=wifi_widget_logic.get_wifi_status,
update_interval=5, # Actualiza cada 5 segundos para mantener el estado al día
mouse_callbacks={'Button1': wifi_widget_logic.toggle_wifi_connection},
fmt='{}', # Nuestro script ya devuelve el formato final
# Opciones de estilo:
background="#262b35", # Un tono oscuro que contrasta
foreground="#cdd6f4", # Un color claro para el texto
font="Font Awesome 6 Free Solid", # Asegúrate de que esta fuente esté instalada para los iconos
fontsize=14,
padding=5,
),
# ... más widgets ...
],
24, # Altura de la barra
background="#1e1e2e", # Fondo general de la barra
opacity=0.9,
),
),
]
¡Atención al detalle! Asegúrate de que el nombre de la fuente (`font=”Font Awesome 6 Free Solid”`) sea correcto y que realmente tengas instalada esa fuente en tu sistema. Si no la tienes, los iconos se mostrarán como caracteres genéricos. Puedes usar también Noto Color Emoji u otra fuente que soporte los iconos Unicode que hemos utilizado (`📶`, `🚰`, `⚠️`).
Después de guardar ambos archivos, recarga Qtile (normalmente con Mod+r). Deberías ver tu nuevo componente de red aparecer en la barra. Haz clic en él y observa cómo interactúa con tu conexión inalámbrica, mostrando notificaciones en el proceso.
Mejoras y Funcionalidades Avanzadas
Este es un punto de partida robusto, pero el mundo de la personalización es infinito. Aquí hay algunas ideas para llevar tu módulo de conectividad al siguiente nivel:
- Selector de Redes Dinámico: En lugar de conectar a una red preferida fija, podrías integrar herramientas como Rofi o dmenu. Al hacer clic, estos lanzadores mostrarían una lista de redes disponibles (obtenidas con
nmcli dev wifi list), permitiéndote seleccionar y conectar a la deseada. Esto requeriría un script Python más complejo para interactuar con Rofi/dmenu y manejar las credenciales de la red. - Indicador Visual de Señal: Podrías usar varios iconos de Font Awesome para representar la intensidad de la señal (por ejemplo, tres barras para señal excelente, dos para buena, una para débil).
- Información Adicional: Muestra la dirección IP actual, la velocidad de descarga/subida, o el tipo de seguridad de la red.
- Gestión de Perfiles: Si trabajas desde varios lugares, puedes tener perfiles de conexión preestablecidos para un cambio rápido.
- Iconos Coloridos: Utiliza colores dinámicos para el icono o el texto según el estado de la conexión (verde para conectado, rojo para desconectado, amarillo para error).
Mi Perspectiva: El Poder de la Artesanía Digital
En un mundo donde la mayoría de los sistemas operativos nos ofrecen soluciones „listas para usar”, a menudo nos alejamos de la comprensión profunda de cómo funcionan las cosas. Desarrollar un elemento de barra personalizado en Qtile para algo tan fundamental como la conectividad Wi-Fi no es solo un ejercicio técnico; es una declaración de independencia digital. Es la diferencia entre ser un mero usuario de software y un creador de tu propio espacio de trabajo digital.
La comunidad de software libre y open source prospera precisamente en esta filosofía. Herramientas como Qtile te dan los ladrillos, el mortero y los planos básicos, pero la verdadera „casa” la construyes tú. Al hacerlo, no solo optimizas tu productividad, sino que también adquieres un conocimiento invaluable sobre tu sistema, sus capacidades y cómo manipularlo a tu antojo. Es un viaje que, una vez iniciado, es difícil de detener. La satisfacción de ver tu propia creación funcionando armoniosamente en tu entorno diario es incomparable.
Conclusión: Tu Conectividad, A Tu Manera
Hemos recorrido el camino desde la idea inicial hasta la implementación de un gestor Wi-Fi integrado en Qtile. Ahora tienes un módulo funcional, elegante y, lo más importante, ¡hecho por ti! Este es solo un ejemplo de cómo Qtile te permite ir más allá de las limitaciones preestablecidas y diseñar un entorno que no solo sea productivo, sino también un reflejo de tu ingenio y tus necesidades.
Te animo a experimentar con el código, a explorar las mejoras sugeridas y a no tener miedo de romper cosas (siempre puedes restaurar una copia de seguridad de tu config.py). Cada pequeño ajuste, cada nueva función que implementes, te acercará más a la configuración perfecta. ¡Disfruta de tu flamante y estilizado control de red Wi-Fi! 🚀