DWM: ¡Un Window Manager de apenas 2149 líneas!

  • 3 Respuestas
  • 1402 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Conectado DtxdF

  • *
  • Moderador Global
  • Mensajes: 875
  • Actividad:
    100%
  • Country: 00
  • Reputación 17
  • Eres un auto y tienes dos opciones: Parar o Seguir
    • Ver Perfil
    • Mi repositorio de Github donde encontraras herramientas para tu trabajo.
    • Email

DWM: ¡Un Window Manager de apenas 2149 líneas!

  • en: Abril 24, 2020, 04:51:58 am
Cuando hablamos de un Window Manager (Manejador de Ventanas, en español), no referimos de ese componente del sistema que proporciona al usuario una Interfaz gráfica de usuario (GUI, por sus siglas en Inglés). Pese a que la elección en su mayoría es el Entorno  de Escritorio, Un WM tiene muchas más ventajas en cuanto al ahorro de tiempo y recursos.


Fuente oficial: dwm.suckless.org

DWM (Dynamic Window Manager), es un administrador de ventanas dinámico para X, éste puede controlar la forma en que se expresan las ventanas en tiempo de ejecución de forma arbitraria según lo decida el mismo usuario. DWM, puede aplicar el diseño con los siguientes métodos:

  • Stacking (conocidos también como flotantes): Este gestor de ventanas representan un símil del escritorio tradicional del que venimos viendo en Sistemas Operativos como Windows y OS X. Éstos apilan cada ventana una delante de otra dando el aspecto a varias hojas de papel unidas.
  • Tiling (conocidos también como de tipo mosaico): Éstos no superponen las ventanas al contrario de su hermano anterior, además de que usan un catalogo extendidos de atajos en el teclado ahorrando más tiempo (e incluso recursos). Los gestores de ventanas tipo tiling se nota la exclusividad del uso del teclado, mientras que el ratón ya es opcional.
  • Dynamic: Es el caso de DWM que permite alternar entre tipo "Stacking" o "Tiling" a decisión del usuario.

Una vez aclarado los aspectos principales para adentrarnos más en estos mundos, pasemos a la práctica...

Descarga:

Antes que nada, debemos tener instalado 'git', 'gcc' y 'make' para poder clonar el repositorio e instalar todo parsimonioso:

Debian y derivados:


Código: (bash) [Seleccionar]
sudo apt-get install git build-essential
O en caso de no tener 'sudo' instalado

Código: (bash) [Seleccionar]
su
apt-get install git build-essential

Archlinux y derivados:

Código: (bash) [Seleccionar]
sudo pacman -S git gcc make
O en caso de no tener 'sudo' instalado

Código: (bash) [Seleccionar]
su
pacman -S git gcc make

Ahora clonamos el repositorio:

Código: (bash) [Seleccionar]
git clone http://git.suckless.org/dwm
cd dwm

Tutorial:

Quiero aclarar que este tutorial está enfocado a los usuarios noveles, los que desean aprender más sobre estos mundillos tan hermosos y llenos de libertad. Pese a que tocaremos código en C, trataré de no hacer mención de qué significa cada cosa, en su lugar dejaré textos enlazados a los conceptos para no embotar el tema principal y dedicarme a la configuración y uso de DWM.


Una vez hemos descargado DWM, pasemos a la configuración, pero antes necesitaremos instalar un lanzador de aplicaciones. Tenemos dos opciones: dmenu ó rofi (mi preferido).

Instalación en Archlinux y derivados:

Código: (bash) [Seleccionar]
# dmenu
sudo pacman -S dmenu
# rofi
sudo pacman -S rofi

Instalación en Debian y derivados:

Código: (bash) [Seleccionar]
# dmenu
sudo apt-get install suckless-tools
# rofi
sudo apt-get install rofi

Esos programas nos van a permitir poder ejecutar aplicaciones (estilo un menú de un Entorno de Escritorio, pero será invocado cuando deseemos).

En el caso de Debian a mí me faltaron instalar algunas dependencias, pero para Arch no fue el caso. Instalación de las depencias en Debian:

Código: (bash) [Seleccionar]
sudo apt-get install libx11-dev libxinerama-dev
Importante: Si faltaron mencionar dependencias o en el caso de Arch, te faltaron dependencias, hazmelo saber para editar este documento y mencionarlas, todos te lo agradeceríamos.

Ahora viene la parte buena, la configuración.

Para configurar DWM necesitamos abrir el archivo config.def.h con nuestro editor de texto preferido, En mi caso usaré Vim:

Código: (bash) [Seleccionar]
vim config.def.h

Comandos que se ejecutarán por defecto

Entre la línea 59-60 estarán los comandos que serán ejecutados por DWM y en unos momentos los empezaremos a cambiar.


Combinaciones del teclado

Entre la línea 62-97 encontraremos un listado de combincaciones del teclado. Mientras que en la imagen se aprecia tres dialogos de texto con unas flechas rojas, esas flechas específican lo siguiente:

  • Las primeras combinaciones: Con las "Primeras Combinaciones" me estoy refiriendo a las primeras teclas que llamarán a la variable. En la imagen apreciamos una Constante llamada MODKEY, ésa será la tecla principal y por defecto es "ALT" (más tarde veremos como cambiarla).
  • Las segundas combinaciones: Son las segundas teclas que usaremos, por ejemplo, si en la primera combinación se tiene solamente "MODKEY" (ALT) y en la segunda "XK_p", entonces sería básicamente "ALT+p"
  • La variable: Será el nombre que le pusimos en la imagen uno, a los comandos.

Agrego: también notamos que hay una extraña combinación de las "Primeras Combinaciones" en la fila dos, usando el carácter "Barra vertical". Éso se llama Operador OR, pero vamos a verlo mejor como un carácter para combinar teclas.

Agregando programas y combinaciones de teclas:

En la sección anterior pudimos entender un poco DWM, pero en esta sección aprenderemos a agregar programas con sus respectivas combinaciones de teclas. Comencemos.

Volvemos a las líneas 59-60 y modificamos la línea 59 sólo sí se desea cambiar dmenu por rofi (como fue mi caso). Quedando así:



dmenu cambiado a rofi

Cabe notar que cada vez que agregamos un comando necesitamos seguir la siguiente sintaxis:

Código: (c) [Seleccionar]
static const char *<nombre de la variable>[] = { "<programa>", NULL };
// o
static const char *<nombre de la variable>[] = { "<programa>", "<parámetro 3>", "<parámetro 2>", NULL };

Nota #1: Los signos '<' (menor qué) y '>' (mayor qué) no los usen, simplemente estoy indicando qué es lo que tienen que remplazar.
Nota #2: Los parámetros del programa pueden ser tantos como éste los requiera y deben ir separados por una ',' (coma) y entrecomillados.
Nota #3: Se debe colocar 'NULL' al final de la Cadena para indicar la finalización del array de caracteres.

Otra cosa, es modificar la Consola a ejecutar, que en mi caso será "URXVT":



URXVT

Compilamos:

Ahora para que nuestra configuración sea efectiva necesitamos copiar 'config.def.h' a 'config.h'. OJO, no es mover, sino copiar en la misma ruta:

Código: (bash) [Seleccionar]
cp -v config.def.h config.h
Antes de compilarlo, abrimos 'config.mk' y modificamos la última línea (la 38, para especificar). Cambiamos el valor de la MACRO 'CC', de 'cc' a 'gcc':


CC a GCC

Estamos cambiando el Compilador nativo a el Compilador GNU de C del GCC para evitar problemas, aunque no es necesariamente cierto lo que dije, ya que puede que compile perfectamente, pero para evitar incongruencias lo cambiamos. También puede que 'cc' sea un Enlace Simbólico a 'gcc', pero ya estas palabras se salen del tema.

Y por último, compilamos con las opciones que hemos hecho:


Código: (bash) [Seleccionar]
sudo make clean install

DWM compilado con éxto

Si no tenemos errores, tenemos compilado y listo para ser usado. Pero ahora falta un proceso más para poder usar DWM. Vamos a denominarlos: Método fácil y Método difícil.

Sobre el método fácil vamos a crear un archivo llamado ".xinitrc" en "$HOME" (nuestra carpeta de usuario) en el cual vamos a insertar el siguiente código:


Código: (bash) [Seleccionar]
exec dwm
Luego de hacer lo anterior, iniciamos las Xs e iniciando DWM ejecutando:

Código: (bash) [Seleccionar]
startx

Mi DWM con modificaciones :-)

Quiero aclarar que cuando hagan todo esto por primera vez, no verán ningún fondo de pantalla, todo estará en negro, pero daré la explicación de cómo cambiar el fondo de pantalla en la sección 'avanzado'. Y por cierto, también verán una barra que indica los 'tags' de DWM.

Sobre el método "difícil", ya depende de nuestro gestor de sesiones, por suerte la mayoría de gestores los aceptaran (hablo del estándar de freedesktop.org), que en mi caso será LightDM. Lo único que debemos hacer es crear un "Archivo de Entrada de Escritorio" que irá ubicado en '/usr/share/xsessions':


Código: (text) [Seleccionar]
[Desktop Entry]
Encoding=UTF-8
Name=Dwm
Comment=Dynamic Window Manager
Exec=dwm-personalized
Icon=dwm.png
Type=XSession

Nota #1: El icono que nos trae el repositorio descargado llamado 'dwm.png'  lo copiamos a '/usr/share/pixmaps'
Nota #2: dwm-personalized es un script que crearemos a continuación.

Antes de iniciar DWM quizá queramos iniciar otras cosas, veamos mi archivo 'dwm-personalized':


Código: (bash) [Seleccionar]
#!/usr/bin/env sh

# No quiero la tecnología dpms (Display Power Management System)
xset -dpms
xset s off
xset s noblank

# Defino mi fondo de escritorio
nitrogen --set-centered /home/dtxdf/Pictures/BG-Desktop/bonito.jpg

# Remplazo el proceso actual por dwm
exec dwm

Yo lo tengo en '/usr/local/bin' que me parece ideal para este tipo de archivos:

Código: (bash) [Seleccionar]
sudo install --mode 755 dwm-personalized /usr/local/bin
Luego de hacer todo eso, al iniciar LightDM podremos cambiar la sesión a DWM para poder iniciarlo.

Combinaciones por defecto:

En esta sección les indicaré algunas combinaciones de teclas por defecto que quizá les sea de utilidad:

  • ALT+j y ALT+k: Desplazarse entre ventanas de izquierda o derecha
  • ALT+h y ALT+l: Aumentar/Disminuir el tamaño de las ventanas. El efecto se puede apreciar entre dos o más ventanas y se le aplica sólo a la ventana master.
  • ALT+SHIFT+q: Salir de DWM
  • ALT+p: Ejecutar dmenu o rofi
  • ALT+b: Mostrar u ocultar la barra de estado de DWM
  • ALT+[1-9]: Moverse entre tags (con [1-9] me refiero a un rango)
  • ALT+SHIFT+[1-9]: Mover la ventana a un tag específico
  • ALT+m: Modo monocle; coloca la ventana actual o master en pantalla completa
  • ALT+t: Modo mosaico
  • ALT+f: Modo flotante; Las vetanas nuevas se superponen como Windows, OS X o un Entorno de Escritorio
  • ALT+[Botón izquierdo del ratón]: Mantener presionado para que haga efecto; mover una ventana con el mouse, ésto coloca el orden en flotante
  • ALT+[Botón derecho del ratón]: Mantener presionado para que haga efecto; redimensionar una ventana
  • ALT+SHIFT+SPACE: Alternará al modo flotante de la ventana actual
  • ALT+SHIFT+c: Cerrar una ventana
  • ALT+SHIFT+d y ALT+SHIFT+i: Mover una ventana a master o stack
  • ALT+TAB: Desplazarse entre últimos tags que se haya indexado
  • ALT+ENTER: Alterna entre master o stack

Hay muchas combinaciones y pueden agregarle muchas más...

Trucos:

xev es una pequeña utilidad para imprimir los eventos de las X. Este programa nos ayudará a saber qué constante asignar a DWM. Manos a la obra:


xev en ejecución

Como se puede apreciar, en el apartado de 'state' podremos ver el código asignado a esa tecla, además de su constante, que en el último caso era 'Alt_L'.

Con este programa podremos saber qué clave asignar sin tener que buscar en los lugares más recónditos de la web o leer una documentación específica del mismo. Aunque una alternativa más rápida es:

Código: (bash) [Seleccionar]
xmodmap -pke


Mis tags

Podremos modificar los nombres de los tags (en la línea 25) a nuestro gusto (como es mi caso), no obstante si no se desea mover con los números del teclado, es mejor modificar el apartado de combinaciones de teclas.

Avanzado:

En esta sección les comparto unos scripts que uso con frecuencia para poder hacer mi vida más fácil, pero antes tengo que compartirles mi archivo de configuración para que puedan entender qué hace qué cosa:

Código: (text) [Seleccionar]
/* See LICENSE file for copyright and license details. */

/* appearance */
static const unsigned int borderpx  = 0;        /* border pixel of windows */
static const unsigned int snap      = 32;       /* snap pixel */
static const int showbar            = 0;        /* 0 means no bar */
static const int topbar             = 0;        /* 0 means bottom bar */
static const char *fonts[]          = { "Liberation Mono:size=10" };

static const char dmenufont[]       = "Liberation Mono:size=10";

static const char col_gray1[]       = "#222222";
static const char col_gray2[]       = "#444444";
static const char col_gray3[]       = "#bbbbbb";
static const char col_gray4[]       = "#eeeeee";
static const char col_cyan[]        = "#005577";

static const char *colors[][3]      = {
/*               fg         bg         border   */
[SchemeNorm] = { col_gray3, col_gray1, col_gray2 },
[SchemeSel]  = { col_gray4, col_cyan,  col_cyan  },
};

/* tagging */
static const char *tags[] = { "UXVT", "Firefox", "Documentación" };

static const Rule rules[] = {
/* xprop(1):
* WM_CLASS(STRING) = instance, class
* WM_NAME(STRING) = title
*/
/* class      instance    title       tags mask     isfloating   monitor */
{ NULL,     NULL,       NULL,       0,            0,           -1 }
};

/* layout(s) */
static const float mfact     = 0.55; /* factor of master area size [0.05..0.95] */
static const int nmaster     = 1;    /* number of clients in master area */
static const int resizehints = 1;    /* 1 means respect size hints in tiled resizals */

static const Layout layouts[] = {
/* symbol     arrange function */
{ "[]=",      tile },    /* first entry is default */
{ "><>",      NULL },    /* no layout function means floating behavior */
{ "[M]",      monocle },
};

/* key definitions */
#define MODKEY Mod1Mask
#define TAGKEYS(KEY,TAG) \
{ MODKEY,                       KEY,      view,           {.ui = 1 << TAG} }, \
{ MODKEY|ControlMask,           KEY,      toggleview,     {.ui = 1 << TAG} }, \
{ MODKEY|ShiftMask,             KEY,      tag,            {.ui = 1 << TAG} }, \
{ MODKEY|ControlMask|ShiftMask, KEY,      toggletag,      {.ui = 1 << TAG} },

/* helper for spawning shell commands in the pre dwm-5.0 fashion */
#define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }

/* commands */
static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */
//static const char *dmenucmd[] = { "dmenu_run", "-m", dmenumon, "-fn", dmenufont, "-nb", col_gray1, "-nf", col_gray3, "-sb", col_cyan, "-sf", col_gray4, NULL };
static const char *dmenucmd[] = { "rofi", "-show", "run", NULL };
static const char *termcmd[]  = { "urxvt", NULL };
static const char *firefox[] = { "firefox", NULL };
static const char *shutdown[] = { "power-script", "1", NULL }; // APAGAR
static const char *reboot[] = { "power-script", "2", NULL }; // REINICIAR
static const char *cancel[] = { "power-script", "3", NULL }; // CANCELAR
static const char *sessions[] = { "select-session", NULL }; // SELECCIONAR UNA SESIÓN DE TMUX
static const char *bam_connect[] = { "bam-connect", NULL }; // Para conectar el bam
static const char *bam_disconnect[] = { "bam-disconnect", NULL }; // Para desconectar el bam
static const char *screenshot[] = { "scrot-script", "mtpaint", NULL }; // Tomar una captura de pantalla

static Key keys[] = {
/* modifier                     key        function        argument */
{ MODKEY,                       XK_Print,         spawn,          {.v = screenshot} },
{ MODKEY,                       XK_p,      spawn,          {.v = dmenucmd} },
{ MODKEY|ShiftMask,             XK_t,      spawn,          {.v = termcmd} },
{ MODKEY,              XK_F1,     spawn,        {.v = firefox} },
{ MODKEY|ShiftMask,             XK_s,      spawn,          {.v = shutdown} },
{ MODKEY|ShiftMask,             XK_r,      spawn,          {.v = reboot} },
{ MODKEY|ShiftMask,             XK_k,      spawn,          {.v = cancel} },
{ MODKEY,                       XK_s,      spawn,          {.v = sessions} },
{ MODKEY,                       XK_q,      spawn,          {.v = bam_connect} },
{ MODKEY,                       XK_w,      spawn,          {.v = bam_disconnect} },
{ MODKEY,                       XK_b,      togglebar,      {0} },
{ MODKEY,                       XK_j,      focusstack,     {.i = +1 } },
{ MODKEY,                       XK_k,      focusstack,     {.i = -1 } },
{ MODKEY,                       XK_i,      incnmaster,     {.i = +1 } },
{ MODKEY,                       XK_d,      incnmaster,     {.i = -1 } },
{ MODKEY,                       XK_h,      setmfact,       {.f = -0.05} },
{ MODKEY,                       XK_l,      setmfact,       {.f = +0.05} },
{ MODKEY,                       XK_Return, zoom,           {0} },
{ MODKEY,                       XK_Tab,    view,           {0} },
{ MODKEY|ShiftMask,             XK_c,      killclient,     {0} },
{ MODKEY,                       XK_t,      setlayout,      {.v = &layouts[0]} },
{ MODKEY,                       XK_f,      setlayout,      {.v = &layouts[1]} },
{ MODKEY,                       XK_m,      setlayout,      {.v = &layouts[2]} },
{ MODKEY,                       XK_space,  setlayout,      {0} },
{ MODKEY|ShiftMask,             XK_space,  togglefloating, {0} },
{ MODKEY,                       XK_0,      view,           {.ui = ~0 } },
{ MODKEY|ShiftMask,             XK_0,      tag,            {.ui = ~0 } },
{ MODKEY,                       XK_comma,  focusmon,       {.i = -1 } },
{ MODKEY,                       XK_period, focusmon,       {.i = +1 } },
{ MODKEY|ShiftMask,             XK_comma,  tagmon,         {.i = -1 } },
{ MODKEY|ShiftMask,             XK_period, tagmon,         {.i = +1 } },
TAGKEYS(                        XK_1,                      0)
TAGKEYS(                        XK_2,                      1)
TAGKEYS(                        XK_3,                      2)
TAGKEYS(                        XK_4,                      3)
TAGKEYS(                        XK_5,                      4)
TAGKEYS(                        XK_6,                      5)
TAGKEYS(                        XK_7,                      6)
TAGKEYS(                        XK_8,                      7)
TAGKEYS(                        XK_9,                      8)
{ MODKEY|ShiftMask,             XK_q,      quit,           {0} },
};

/* button definitions */
/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
static Button buttons[] = {
/* click                event mask      button          function        argument */
{ ClkLtSymbol,          0,              Button1,        setlayout,      {0} },
{ ClkLtSymbol,          0,              Button3,        setlayout,      {.v = &layouts[2]} },
{ ClkWinTitle,          0,              Button2,        zoom,           {0} },
{ ClkStatusText,        0,              Button2,        spawn,          {.v = termcmd } },
{ ClkClientWin,         MODKEY,         Button1,        movemouse,      {0} },
{ ClkClientWin,         MODKEY,         Button2,        togglefloating, {0} },
{ ClkClientWin,         MODKEY,         Button3,        resizemouse,    {0} },
{ ClkTagBar,            0,              Button1,        view,           {0} },
{ ClkTagBar,            0,              Button3,        toggleview,     {0} },
{ ClkTagBar,            MODKEY,         Button1,        tag,            {0} },
{ ClkTagBar,            MODKEY,         Button3,        toggletag,      {0} },
};

scrot-script

Dependencias: scrot zenity <programa extra para abrir la imagen> (en mi caso mtpaint)
Descripción: Tomar una captura de pantalla

Código: (bash) [Seleccionar]
#!/usr/bin/env sh

declare PROGRAM=$1
declare FILE_NAME=/tmp/scrot.png

if [ ${#*} -lt 1 ];then
    zenity --error --text="Debes seleccionar un programa para que interactúe con la captura de pantalla." --no-wrap
    exit 1

fi

if [ -z "$(which $PROGRAM)" ];then
    zenity --error --text="Ha ocurrido un error, \"$PROGRAM\" no existe" --no-wrap
    exit 2

fi

rm -f "$FILE_NAME";scrot -s "$FILE_NAME" && command "$PROGRAM" "$FILE_NAME"

bam-connect

Dependencias: wvdial
Descripción: Conectar a Internet utilizando el bam

Código: (bash) [Seleccionar]
#!/usr/bin/env sh

sudo wvdial

bam-disconnect

Dependencias: wvdial
Descripción: Enviar una señal SIGTERM a wvdial para apagar la conexión con el bam

Código: (bash) [Seleccionar]
#!/usr/bin/env sh

sudo killall wvdial

select-session

Dependencias: tmux zenity urxvt
Descripción: Permite seleccionar una sesión de tmux que esté oculta y en ejecución.

Código: (bash) [Seleccionar]
#!/usr/bin/env bash

declare -x aux
declare -x aux_sessions
declare -x session_name
declare -x session_info
declare -x execute
declare -x val
let n=0

IFS_BAK=$IFS
IFS="
"

show_sessions() {
for i in $(tmux ls);do
echo -n "$i;"

done

}

tmux ls > /dev/null 2> /dev/null

if [ $? -eq 1 ];then
zenity --text="Por ahora no tiene sesiones en tmux Sr. DtxdF :3" --no-wrap --info
exit 1

fi

aux_sessions=$(show_sessions)
execute='zenity --list --column="Session" --column="Information" --title="Seleccione una sesión Sr. DtxdF"'

while [ true ];do
let n+=1

aux=$(echo $aux_sessions | cut -d ";" -f $n)

if [ -z "$aux" ];then
break

fi

session_name=$(echo $aux | cut -d ":" -f 1)
session_info=$(echo $aux | cut -d ":" -f 2 | sed "s/^ //")

execute="$execute \"$session_name\" \"$session_info\""

done

IFS=$IFS_BAK
val=$(sh -c "$execute")

if [ $? -eq 0 ];then
urxvt -e sh -c "tmux attach -t \"$val\""

fi

power-script

Dependencias: zenity
Descripción: Permite apagar, reiniciar el equipo, aunque también podría cancelar las operaciones antes mencionadas.

Código: (bash) [Seleccionar]
#!/usr/bin/env bash

let option=$1 2> /dev/null
let timeout=10
let timetoshut=10
declare -x cancelfile="/tmp/noshut"

write_error_msg() {
zenity --text="$1" --error --no-wrap

}

check_noshut() {
if [ -f "$cancelfile" ];then
rm -f "$cancelfile"
exit 0

fi

}

if [ "$option" -eq 0 ];then
write_error_msg "¡Debes escribir una opción!"
exit 1

fi

if [ "$option" -eq 1 ];then
zenity --warning --text="Su equipo se apagará dentro de $timetoshut segundo(s) Sr. DtxdF, por favor sea paciente" --timeout=$timeout --no-wrap
sleep $timetoshut
check_noshut
poweroff

elif [ "$option" -eq 2 ];then
zenity --warning --text="Su equipo se reiniciará dentro de $timetoshut segundo(s) Sr. DtxdF, por favor sea paciente" --timeout=$timeout --no-wrap
sleep $timetoshut
check_noshut
reboot

elif [ "$option" -eq 3 ];then
touch $cancelfile
zenity --info --text="El equipo no se apagará Sr. DtxdF, no se preocupe ;-)" --timeout=$timeout --no-wrap

else
write_error_msg "¡Opción no encontrada!"
exit 3


fi

exit 0

simple-nmap-script

Dependencias: nmap zenity
Descripción: Escanea la red en busca de objetivos vivos
Estado: Próximamente...

wifi-scan-script

Estado: Próximamente...

Notas:

Para cambiar el tema por defecto de 'rofi', tendremos que ejecutar:

Código: (bash) [Seleccionar]
rofi-theme-selector
Se nos abrirá una ventana:


rofi-theme-selector

Presionamos ENTER para seleccionar un tema; ALT+A para ajustarlo como predeterminado; con ESC salimos y hasta podemos hacer una búsqueda de un tema por su nombre.


Si eres como yo y utiliza un Bam para comunicarse con el mundo exterior te recuerdo que hay un post para usar como alternativa a wvdial. Otra cosa, es que necesitamos agregar lo siguiente a el fichero sudoers para que no sea necesario requerir contraseña al conectarse al Modem USB:

Código: (text) [Seleccionar]
Host_Alias SRV_DTXDF = localhost, dtxdf # Nombre del host de la máquina

User_Alias USR_DTXDF = dtxdf # Nombre de usuario, en mi caso es 'dtxdf'

Cmnd_Alias WVDIAL       = /usr/bin/wvdial
Cmnd_Alias KILL_WVDIAL  = /usr/bin/killall wvdial

# Permitimos que se ejecute sudo sin contraseña a wvidlal y 'killall wvdial'
USR_DTXDF SRV_DTXDF = NOPASSWD:WVDIAL
USR_DTXDF SRV_DTXDF = NOPASSWD:KILL_WVDIAL


Si se desea cambiar la "clave modificadora" (ALT, por defecto) en DWM, se tiene que modificar 'config.def.h' (que luego será pasado a config.h), tendremos que irnos a la línea 47 y cambiar la constante simbólica 'MODKEY' con su valor 'Mod1Mask' por 'Mod4Mask', por ejemplo, sería asignar la tecla de Windows.

Podemos hacerlo con tantas teclas nos permita en 'xmodmap':


Código: (bash) [Seleccionar]
xmodmap


La razón por la que tengamos que copiar 'config.def.h' a 'config.h' es porque la comunidad de DWM realiza parches para mejorar mucho más la experiencia de éste, entonces si se modifica 'config.def.h' en vez de 'config.h', no estaríamos sobreescribiendo la configuración que le hayamos hecho.


En LightDM tuve que configurar algún par de cosas para que funcionara perfectamente, lo comentaré aquí por si a alguien le pasa:

En la sección de LightDM '[Seat:*]', descomentaremos 'session-wrapper' para que cargue el archivo Xsession; en la sección '[LightDM]' descomentaremos y nos aseguraremos de que las rutas que se colocan ahí sean correctas y existan, ya que permitirá leer los Archivos de Entrada de Escritorio.

Espero que a alguien le sirva ;)


Si se desean más temas para rofi, pueden ir al siguiente repositorio: https://github.com/davatorium/rofi-themes


Conclusión:


~ DtxdF
« Última modificación: Abril 24, 2020, 01:15:38 pm por DtxdF »
Los seres humanos son robots, cuyo combustible es el afanado dinero.

Desconectado ???????

  • *
  • Underc0der
  • Mensajes: 242
  • Actividad:
    23.33%
  • Country: 00
  • Reputación 12
    • Ver Perfil

Re:DWM: ¡Un Window Manager de apenas 2149 líneas!

  • en: Abril 24, 2020, 02:21:33 pm
Excelente post amigo  ;D

Muy interesante el WM  :D :D

Saludos!
-Kirari
« Última modificación: Abril 24, 2020, 02:49:05 pm por Kirari »

Desconectado MSTR-KR

  • *
  • Underc0der
  • Mensajes: 8
  • Actividad:
    0%
  • Country: 00
  • Reputación 0
    • Ver Perfil

Re:DWM: ¡Un Window Manager de apenas 2149 líneas!

  • en: Abril 28, 2020, 10:25:38 pm
Excelente post, parce gracias por compartir su conocimiento, estare esperando mas tutos de arch jejejejejejeje

Me sirvio artisimo que viva arch!
« Última modificación: Abril 28, 2020, 10:36:17 pm por MSTR-KR »

Conectado DtxdF

  • *
  • Moderador Global
  • Mensajes: 875
  • Actividad:
    100%
  • Country: 00
  • Reputación 17
  • Eres un auto y tienes dos opciones: Parar o Seguir
    • Ver Perfil
    • Mi repositorio de Github donde encontraras herramientas para tu trabajo.
    • Email

Re:DWM: ¡Un Window Manager de apenas 2149 líneas!

  • en: Abril 28, 2020, 11:08:03 pm
Un placer @MSTR-KR , con gusto vendrán más  ;)

~ DtxdF
Los seres humanos son robots, cuyo combustible es el afanado dinero.