Principal » Wiki » Software » KDE/Gnome/Xfce/WM

Awesome en Debian

1. Introducción
1.1. ¿Qué es?
1.2. Awesome en Debian
2. Awesome 2
2.1. Instalación
2.2. Configuración básica. awesomerc
2.3. A nuestro gusto: Fondo de pantalla, terminales, implementación del menú de aplicaciones
2.4. Widgets
2.4.1. Reloj
3. Awesome 3
3.1. Instalación
3.2. Configuración
3.2.1 rc.lua
3.2.1.1 Librerías
3.2.1.2 Variables y alias
3.2.1.3 Tecla modificadora.
3.2.1.4 Configuración de las Tags y layouts
3.2.1.5 Menú
3.2.1.6 Wibox
3.2.1.7 Atajos de teclado y teclas del ratón
3.2.1.8 Prompts
3.2.1.9 Reglas de aplicaciones.
3.2.2 Widgets
3.2.2.1 Vicious
3.2.2.2 Obvious
3.2.2.3 Bashets
3.2.2.4 Widgets de usuarios
3.2.3 Caracteristicas especiales.
3.2.3.1 Tags dinamicos
3.2.3.1.1 Eminent
3.2.3.1.2 Shifty
3.2.4 theme.lua
3.2.4.1 Colores
3.2.4.2 Fondo
3.2.4.3 Iconos
3.2.5 Ejemplos de configuración
3.2.5.1 rc.lua
3.2.5.2 theme.lua
3.2.5.3 otros
4. Awesome y el arranque del sistema
4.1. Iniciar Awesome sin gestor de identificación
4.2. Arranque con GDM
4.3. Awesome como Window Manager para kde
4.4. Awesome como Window Manager para Gnome
5. Pequeños trucos y consejos
6. Páginas web de interés y lanzamientos

1. Introducción

1.1. ¿Qué es?

Awesome es un gestor de ventanas con capacidad de utilizar tanto el modo tradicional (floating) como una distribución automática de las ventanas por la pantalla, como si de un mosaico se tratase. Es un gestor ligero y muy versátil, tanto en la antigua rama 2 como en la nueva rama 3 que viene con la gran novedad del uso del lenguaje de programación Lua en su configuración.

Según la página web de awesome

It's extremely fast, small, dynamic and heavily extensible using the Lua programming language. We provide an easily usable and very-well documented API to configure and define the behaviour of your window manager.

Algunas de sus características

  • Extensible, gracias al uso de Lua
  • Se hace uso de librerías XCB asíncronas, en sustitución de las Xlib, síncronas, lo que se traduce en una mayor rapidez.
  • Soporte para múltiples monitores (XRandR, Xinerama o Zaphod)
  • Todo se puede hacer con el teclado haciendo innecesario el uso del ratón
  • Uso de tags en lugar de workspaces dando más libertad a la distribución de las ventanas

Además, podemos encontrar una gran cantidad de documentación en la página web del proyecto y en su wiki. No es recomendable para usuarios que gusten de GUI's, dado que toda la configuración se realizará con ficheros de texto.

Conceptos relativos a Awesome y los "Tiling Window Manager"

Tags: Comparable a un "escritorio virtual". Es posible asignar a cada uno su propia distribución de las ventanas en la pantalla, y también podemos ejecutar un proceso en varios a la vez.

Layouts: Podemos describirlo como la forma en que las ventanas ocupan el espacio disponible. Disponibles en awesome 3 tenemos:

  • Tiled donde el espacio disponible se divide en las áreas master y stacking. En la primera se situará el proceso que demande nuestra atención más inmediata, y podemos dividirla en filas y/o columnas
  • Max cada proceso y/o ventana ocupará el máximo espacio disponible en la pantalla
  • Magnifier todas las ventanas del área stacking aparecen "detrás" del área master
  • Floating el sistema se comporta como un gestor de ventanas "no tiling"

Statusbar: Podemos situarla arriba, abajo, a la izquierda o a la derecha de la pantalla.

Screen: Cada monitor conectado al ordenador. Se numeran empezando por 1.

Client: Las ventanas.

Widgets: Los hay de varios tipos, desde simples cuadros de texto hasta iconos interactivos.

1.2. Awesome en Debian

Actualmente disponemos de awesome en las tres ramas principales de debian en distintas versiones:

Debian Stable

En Lenny disponemos de la versión 2.3.3-1

Debian Testing

En Squeeze ya disponemos de la rama 3, concretamente en la versión: 3.4.2-2

Debian Unstable

En Sid disponemos de la versión 3.4.2-3

Los cambios en las versiones de awesome se propagan con rapidez a los repositorios de Debian ya que Julien Danjou además de ser el principal desarrollador de awesome también es su mantenedor en nuestra distribución.

2. Awesome 2

2.1. Instalación

Debian Etch [Old Stable]

Debido a que Awesome no se encuentra en los paquetes de Debian Etch [Antigua rama estable de Debian] vamos a instalar desde "Backports" Y para ello abriremos una terminal ejecutando lo siguiente:

# nano /etc/apt/sources.list

Añadimos

# backports
deb http://www.backports.org/debian etch-backports main contrib

Descargamos en instalamos las llaves,

# wget -O - http://backports.org/debian/archive.key | apt-key add -

Listo, instalamos Awesome

# aptitude -t etch-backports install awesome

Debian Lenny [Actual rama estable de Debian]

# aptitude install awesome

2.2. Configuración básica .awesomerc

El fichero de configuración de awesome es .awesomerc Debería estar en ~/, pero la instalación de Awesome no lo hace por nosotros. Al iniciar Awesome, éste intenta leer ~/.awesomerc. Si no existe se ajusta a la configuración por defecto.

Lo que haremos será copiar el fichero que viene de ejemplo en el paquete a nuestro home

# cd /usr/share/doc/awesome
# ls

Descubrimos el fichero awesomerc.gz, tenemos que descomprimirlo.

# gzip -d awesomerc.gz

Ahora como usuario normal

$ cp awesomerc /home/usuario/.awesomerc

De nuevo, todo es mucho más fácil si trabajamos en Lenny. El fichero awesomerc se habrá creado en el directorio home del usuario, por lo que los pasos anteriores no serían necesarios.

Bueno, ya tenemos archivo de configuración para manejarlo a nuestro antojo. Vamos a investigarlo un poco:

# nano .awesomerc

Y lo que tendremos será lo siguiente:

screen 0
{
    # configuración de la pantalla actual
    styles
    {
        # estilo de la pantalla actual, aquí podremos cambiar los colores y el tipo de letra
    }
    tags
    {
        # espacios de trabajo,  aquí podemos ponerle nombre a cada escritorio, decidir cómo se comportarán las ventanas en cada uno (por ejemplo, podríamos asignar al escritorio 1 el modo tiling, y al 2 el modo flotante)
    }
    layouts
    {
        # configuración de los tipos de mosaicos disponibles, es decir, de qué manera se cubrirá la pantalla con las ventanas
    }
    statusbar mystatusbar
    {
        # configuración de la barra de estado de la pantalla actual
    }
}
rules
{
    # descripción de reglas, aquí podemos determinar, para cada aplicación, si se abrirá en modo flotante o no, en qué escritorio aparecerá al invocarla... Por ejemplo,
  rule { name = "MPlayer" float = true tags="1"}
indica que mplayer utilizará el modo flotante y se abrirá en el escritorio 1
}
mouse
{
    #Configuración del ratón
}
keys
{
    # teclas rápidas, o <em>hotkeys</em>
}

De todas formas, a parte de ser bastante intuitivo, se pueden consultar el man para tener más información acerca del archivo de configuración.

$ man awesome

Como estamos ansiosos por ver qué aspecto tiene awesome, reiniciamos y

$ startx

Si todo ha ido bien, nos encontraremos ante la configuración por defecto de Awesome. Es decir, no hay fondo de pantalla. Sólo una barra arriba con los nueve escritorios, un icono para cambiar la disposición de las ventanas (por ejemplo de modo "tiling" a modo flotante, esto ya lo hemos explicado), y el logo de Awesome, que nos muestra la página del manual.

Pero por ahora lo único que nos interesa es saber que la combinación de teclas "Mod4" + Return nos abre un terminal. Y es todo lo que necesitamos para poner a punto nuestro Awesome

Nota: "Mod4" suele ser la tecla de windows.

Podemos abrir varios terminales para comprobar en qué consiste un "tiling window manager" Para ejecutar aplicaciones /scripts antes que Awesome, debemos editar el archivo:

~/.xinitrc

Así, podriamos añadir lo siguiente:

#Script de inicialización de los widgets
~/.awesome/widget_init.sh
#Ejecución de Awesome
exec awesome

2.3. A nuestro gusto: Fondo de pantalla, terminales, implementación del menú de aplicaciones

Podemos pensar en poner un fondo de pantalla. Como siempre, hay múltiples opciones. Optamos por la instalación de feh

# aptitude install feh

Añadimos a ~/.xinitrc la línea

feh --bg-scale (aquí la ruta al fondo que queramos)

Otro aspecto importante a considerar es la elección de un terminal. Nos decantamos por urxvt, aunque hay muchas posibilidades (aterm, mrxvt, rxvt...)

# aptitude install rxvt-unicode

Awesome no sabe que queremos usar ese terminal en concreto. Para indicárselo nos vamos de nuevo a .awesomerc y sustituímos el terminal que viene por defecto (xterm) por urxvt. Es decir, donde antes teníamos

modkey = {"Mod4"}
key = "Return"
command = "spawn"
arg = "exec xterm"

Lo cambiamos por

modkey = {"Mod4"}
key = "Return"
command = "spawn"
arg = "exec urxvt"

y así en todas las ocasiones en las que se haga referencia al terminal. Para comprobar que hemos editado bien el fichero podemos hacer

$ awesome -k

Si todo ha ido bien, el sistema nos lo indica y podremos reiniciar para ver cómo ha quedado. Si no, te indica cuál es el error y toca volver a editar.

Supongamos que todo ha funcionado. Así,

$ startx

y nos encontraremos con un gestor de ventanas con fondo de pantalla y los colores a nuestro gusto. Pero quizás queremos terminales transparentes, u otro tipo de características. Necesitamos .Xdefaults. Si no existe lo creamos, y añadimos ahí lo que necesitemos

$ nano /home/usuario/.Xdefaults

Por ejemplo, para tener el terminal transparente y otras pequeñas funcionalidades,

Xft.antialias: true
!urxvt - setting
URxvt*background: #000000
URxvt*foreground: #ffffff
URxvt*scrollBar: false
URxvt*font: xft:Bitstream Vera Sans mono:size=9
URxvt*inheritPixmap: true
URxvt*termName: rxvt

Awesome-2.3 Nos ofrece la posibilidad de implementar un menú de aplicaciones. Como algunos notarán, hay muchas posibilidades para implementarlo, los desarrolladores nos proponen varios modos. A continuación trataremos el más sencillo.

Hará falta crear el siguiente archivo:

~/.awesome/menu

O con cualquier otro nombre que nos interese, siempre y cuando sepamos tenerlo en cuenta en los siguientes pasos. Un modo de crear dicho archivo puede ser:

$ cd ~/
$ mkdir .awesome
$ cd .awesome
$ touch menu

Una vez creado, debemos añadirle el nombre del binario de las aplicaciones que nos interesen. Por ejemplo:

xterm
iceweasel
gimp
ardour

Lo podemos hacer usando nuestro editor favorito. Por ejemplo:

$ nano ~/.awesome/menu

Ctrl+O para guardar, y Ctrl+X para salir

Por último, hará falta asociar dicho menú a una tecla rápida (hotkey) de nuestro entorno. Para ello, tendremos que añadir la siguiente configuración en la sección keys { ... } del archivo creado anteriormente ~/.awesomerc:

key {
   modkey = {"Mod4"}
   key = "p"
   command = "spawn"
   arg = "exec `cat ~/.awesome/menu | awesome-menu 'Ejecutar:'`"
}

2.4. Widgets.

Dado que hay infinidad de widgets posibles, puesto que hay infinidad de ideas para ello, tan solo se explicará el más básico de todos: El reloj.

2.4.1. Reloj

Lo primero que hay que hacer es añadir un espacio para el reloj en la barra de estado que tenemos en ~/.awesomerc:

screen 0
{
  statusbar mystatusbar {
    ...
    #Al final del apartado
    ...
    #Añadimos
    textbox clock {
      text_align = "right"
      align = "right"
      width = "100"
    }
    #Creando de este modo un recuadro de 100 píxeles al lado izquierdo de la barra de estado
  }
}

A continuación, hará falta ir rellenando dicho recuadro de forma automática y desde el principio del arranque de Awesome (por el simple hecho de no hacerlo manualmente) utilizando el siguiente script:

#!/bin/sh
#
while true
do
       if [ -S ~/.awesome_ctl.0 ]; then
               (while true
               do
                       # See 'man date' to see the possible replacements for the % fields.
                       # uncomment the following line for use with awesome 2.3
                       echo "0 widget_tell mystatusbar clock text "   " `date +\"%a, %b %d %I:%M %p\"`"
                       #echo "0 widget_tell clock"   " `date +\"%a, %b %d %I:%M %p\"`"
                       echo "" # an empty line flushes data inside awesome
                       sleep 1
               done) | awesome-client
       else
           sleep 1
       fi
done

Que por ejemplo podemos guardar en:

~/.awesome/widget_clock.sh

Posteriormente, tendremos que añadir la ejecución de dicho script en el archivo de inicialización de los widgets que se ha comentado anteriormente:

~/.awesome/widget_init.sh

Que será ejecutado automáticamente al inicio de la sesión tal y como se ha explicado, también, anteriormente.

Y así, sin más, tendremos un reloj que podremos configurar del modo que creamos conveniente con el buen uso de ~/.awesomerc.

3. Awesome 3

3.1 Instalación

Awesome 3 se encuentra actualmente en las ramas Testing [Squeeze] y Unstable [Sid] de Debian. Para su instalación basta con ejecutar:

aptitude install awesome

También podemos, al igual que se comentó para awesome 2, bajarnos el .tar.gz de la web, compilarlo e instalarlo. Algunas guías para eso pueden encontrarse aquí

Es aconsejable que instalemos también una aplicación capaz de poner en nuestro awesome un fondo de escritorio, p.e. feh.

aptitude install feh

Por último copiamos la configuración por defecto de awesome situada en /etc/xdg/awesome en nuestra home en la ruta ~/.config/awesome para poder modificarla para dejarla a nuestro gusto.

3.2 Configuración.

Los ficheros de configuración de awesome estan escritos en el lenguaje de programación lua. Conviene tener un pequeña base para configurarlo pero no es imprescindible conocerlo a fondo. También conviene tener una ligera idea de programación, pero los ficheros son bastante autoexplicativos para que no sea imprescindible.

Podemos encontrar buena información sobre lua aquí.

Como hemos comentado los ficheros de configuración son bastante autoexplicativos y estan llenos de comentarios que serán ignorados por awesome, para reconocerlos o crearlos solo tenemos que empezar la linea con esta secuencia de caracteres:

--

3.2.1 rc.lua.

El rc.lua es el corazón de awesome vamos a desgranarlo por partes para facilitar su comprensión. Vamos a obviar ciertas partes de la configuración que no tenemos porque tocar.

3.2.1.1 Librerias.

La primera parte del rc.lua es donde definimos que caracteristicas opcionales de awesome vamos a implementar llamandolas con un require. Por defecto viene implementadas las siguientes:

-- Standard awesome library
require("awful")
require("awful.autofocus")
require("awful.rules")
-- Theme handling library
require("beautiful")
-- Notification library
require("naughty")

-- Load Debian menu entries
require("debian.menu")

Todas esta son necesarias excepto la referida al Debian menu. Podemos comentar esta si no queremos usarla. Para añadir una nueva libreria simplemente llamandola con require("libreria"). Veremos más adelante que otras librerias nos ofrece awesome.

3.2.1.2 Variables y alias.

En esta parte vamos a definir que programas por defecto vamos a usar, que tema veremos ademas podremos definir ciertos alias que nos pueden servir más adelante para definir atajos de teclado o otras cosas interesantes.

Un posible aspecto que puede tener esta sección es este:

-- {{{ Variable definitions

-- Variable with the config directory
confdir = awful.util.getdir("config")

-- Custom theme
beautiful.init( confdir.."/themes/oscur/theme.lua")

-- This is used later as the default terminal and editor to run.
terminal = "urxvt"
editor = os.getenv("EDITOR") or "nano"
editor_cmd = terminal .. " -e " .. editor
browser ="uzbl"

-- Aliases
install = terminal .. " -name install -e aptitude"
mixer = terminal .. " -name mixer -e alsamixer"
ncmpc = terminal .. " -name ncmpc -e ncmpc"
vim = terminal .. " -name vim -e vim"

Vamos a quedarnos con las cosas importante de este código:

  • Con la orden bautiful.init(rutaaltema) le decimos a awesome que tema vamos a usar (en este caso hemos creado una variable con el directorio con la función awful.util.getdir() y ponemos una ruta relativa.
  • Definimos que terminal vamos a usar con la variable terminal. En este caso vamos a utilizar urxvt
  • Definimos que navegador queremos como predeterminado con la variable browser
  • Definimos que editor queremos por defecto y la forma de lanzarlo con las variables editor y editor_cmd. En este caso nano.
  • Creamos unos alias que nos ayudaran después con los atajos de teclado y otra cositas utiles. P.e. creamos el alias install que nos permite abrir un terminal com aptitude.

Sobra decir que para para llamar concatenar variables en lua se utiliza la secuenca de caracteres ...

3.2.1.3 Tecla modificadora.

Una parte muy importante de un gestor de ventanas como awesome es que tecla vamos a usar como modificadora para poder usar todos los atajos de teclado que marcan el uso de este gestor enfocado al teclado. Por defecto tenemos la tecla Mod4, es decir, la tecla de windows o super. Pero teniendo en cuenta la distribución de nuestro teclado quizá nos sea más util otra tecla. Para cambiar esta tecla solo tenemos que modificar este trozo del rc.lua:

- Default modkey.
-- Usually, Mod4 is the key with a logo between Control and Alt.
-- If you do not like this or do not have such a key,
-- I suggest you to remap Mod4 to another key using xmodmap or other tools.
-- However, you can use another modifier like Mod1, but it may interact with others.
modkey = "Mod4"

3.2.1.4 Configuración de las Tags y layouts.

Ahora vamos a configurar el nombre de los tags asi como el layout por defecto que tendra cada uno. El código por defecto que nos presta awesome es este:

-- Table of layouts to cover with awful.layout.inc, order matters.
layouts =
{
    awful.layout.suit.tile,  --1
    awful.layout.suit.tile.left, --2
    awful.layout.suit.tile.bottom, --3
    awful.layout.suit.tile.top, --4
    awful.layout.suit.fair, --5
    awful.layout.suit.fair.horizontal, --6
    awful.layout.suit.spiral, --7
    awful.layout.suit.spiral.dwindle, --8
    awful.layout.suit.max, --9
    awful.layout.suit.max.fullscreen,  --10
    awful.layout.suit.magnifier, --11
    awful.layout.suit.floating --12
}
-- }}}

-- {{{ Tags
-- Define a tag table which hold all screen tags.
tags = {}
for s = 1, screen.count() do
    -- Each screen has its own tag table.
    tags[s] = awful.tag({ 1, 2, 3, 4, 5, 6, 7, 8, 9 }, s, layouts[1])
end
-- }}}

Como podemos observar se ha creado un array llamado layout donde definimos cuales queremos tener disponibles. Esto podemos modificarlo a nuestro gusto eliminando aquellos que no queramos. Después viene un trodo de código donde se asignan los nombres a las nueve tags y se asigna a cada una el primer layout.

Si queremos cambiar los nombres de las tags y además poner un layout diferente para cada una tendremos que modificar el código de la siguiente forma (solo voy a cambiar el código de la creación de los tags, asumimos que no se cambia el array layout):

-- {{{ Tags
-- Define a tag table which hold all screen tags.
tags = {}
tags.settings = {
    { name = "main",  layout = layouts[1]  },
    { name = "www", layout = layouts[9]  },
    { name = "im",   layout = layouts[1]  },
    { name = "doc",  layout = layouts[1]  },
    { name = "admin",    layout = layouts[3]  },
    { name = "multi",     layout = layouts[3]  },
    { name = "net",     layout = layouts[3]  },
    { name = "vbox",   layout = layouts[3]  },
    { name = "other", layout = layouts[1]  }
}

for s = 1, screen.count() do
    tags[s] = {}
    for i, v in ipairs(tags.settings) do
        tags[s][i] = tag({ name = v.name })
        tags[s][i].screen = s
        awful.tag.setproperty(tags[s][i], "layout", v.layout)
    end
    tags[s][1].selected = true
end
-- }}}

Como podemos observar creamos un nuevo array con el nombre de cada tag y su layout predeterminado, esta es la única parte de este código que es necesario personalizar a nuestro antojo, ya que una vez modificado el for creador de las tags dejandolo como el de arriba ya no es necesario tocarlo.

Como se puede observar es muy sencillo el código para definir esto, no voy a entrar en como se referencias elementos del array en lua ni como se realiza un for, si estais interesados en estos aspectos teneis que echarle un vistazo a la documentación de lua.

3.2.1.5 Menu.

Awesome nos provee de un mecanismo para crear y editar nuestros propios menus. Vamos a observar el código por defecto:

-- {{{ Menu
-- Create a laucher widget and a main menu
myawesomemenu = {
   { "manual", terminal .. " -e man awesome" },
   { "edit config", editor_cmd .. " " .. awful.util.getdir("config") .. "/rc.lua" },
   { "restart", awesome.restart },
   { "quit", awesome.quit }
}

mymainmenu = awful.menu({ items = { { "awesome", myawesomemenu, beautiful.awesome_icon },
                                    { "Debian", debian.menu.Debian_menu.Debian },
                                    { "open terminal", terminal }
                                  }
                        })

mylauncher = awful.widget.launcher({ image = image(beautiful.awesome_icon),
                                     menu = mymainmenu })
-- }}}

El código es muy sencillo y casi no merece explicación, como se puede observar lleva una jerarquia a la hora de crear los menus, tenemos ue empezar con los submenus usando un array como el de myawesomemenu en el código por defecto y después ir llamandolos en los menus inferiores.

Por último se crea el widget lanzador que lanzara el menu, donde dejamos que icono tendrá y que menu sera el superior.

3.2.1.6 Wibox

Y ahora llegamos a la creación de la barra de widgets de awesome. No se pretende explicar todo el código pero si como añadir un widget y cambiar de posición el wibox o cambiar la forma en que se ordenan los widgets. Tampoco vamos a abordar aquí como crear un widget, para ello existe una sección propia más abajo en este mismo documento. El código por defecto es este:

-- {{{ Wibox
-- Create a textclock widget
mytextclock = awful.widget.textclock({ align = "right" })

-- Create a systray
mysystray = widget({ type = "systray" })

-- Create a wibox for each screen and add it
mywibox = {}
mypromptbox = {}
mylayoutbox = {}
mytaglist = {}
mytaglist.buttons = awful.util.table.join(
                    awful.button({ }, 1, awful.tag.viewonly),
                    awful.button({ modkey }, 1, awful.client.movetotag),
                    awful.button({ }, 3, awful.tag.viewtoggle),
                    awful.button({ modkey }, 3, awful.client.toggletag),
                    awful.button({ }, 4, awful.tag.viewnext),
                    awful.button({ }, 5, awful.tag.viewprev)
                    )
mytasklist = {}
mytasklist.buttons = awful.util.table.join(
                     awful.button({ }, 1, function (c)
                                              if not c:isvisible() then
                                                  awful.tag.viewonly(c:tags()[1])
                                              end
                                              client.focus = c
                                              c:raise()
                                          end),
                     awful.button({ }, 3, function ()
                                              if instance then
                                                  instance:hide()
                                                  instance = nil
                                              else
                                                  instance = awful.menu.clients({ width=250 })
                                              end
                                          end),
                     awful.button({ }, 4, function ()
                                              awful.client.focus.byidx(1)
                                              if client.focus then client.focus:raise() end
                                          end),
                     awful.button({ }, 5, function ()
                                              awful.client.focus.byidx(-1)
                                              if client.focus then client.focus:raise() end
                                          end))

for s = 1, screen.count() do
    -- Create a promptbox for each screen
    mypromptbox[s] = awful.widget.prompt({ layout = awful.widget.layout.horizontal.leftright })
    -- Create an imagebox widget which will contains an icon indicating which layout we're using.
    -- We need one layoutbox per screen.
    mylayoutbox[s] = awful.widget.layoutbox(s)
    mylayoutbox[s]:buttons(awful.util.table.join(
                           awful.button({ }, 1, function () awful.layout.inc(layouts, 1) end),
                           awful.button({ }, 3, function () awful.layout.inc(layouts, -1) end),
                           awful.button({ }, 4, function () awful.layout.inc(layouts, 1) end),
                           awful.button({ }, 5, function () awful.layout.inc(layouts, -1) end)))
    -- Create a taglist widget
    mytaglist[s] = awful.widget.taglist(s, awful.widget.taglist.label.all, mytaglist.buttons)

    -- Create a tasklist widget
    mytasklist[s] = awful.widget.tasklist(function(c)
                                              return awful.widget.tasklist.label.currenttags(c, s)
                                          end, mytasklist.buttons)

    -- Create the wibox
    mywibox[s] = awful.wibox({ position = "top", screen = s })
    -- Add widgets to the wibox - order matters
    mywibox[s].widgets = {
        {
            mylauncher,
            mytaglist[s],
            mypromptbox[s],
            layout = awful.widget.layout.horizontal.leftright
        },
        mylayoutbox[s],
        mytextclock,
        s == 1 and mysystray or nil,
        mytasklist[s],
        layout = awful.widget.layout.horizontal.rightleft
    }
end
-- }}}

Ahora vamos a tocar las cosas que queramos modificar, empezando por la posición del wibos:

Para ello tenemos que buscar esta linea en el código:

-- Create the wibox
    mywibox[s] = awful.wibox({ position = "top", screen = s })

Como podemos observar para determinar en que posición queremos el wibox solo tenemos que modificar la variable position con uno de estos valores: top, bottom, right, left. No necesita mucha explicación que hace cada opción.

Ahora pasamos a añadir widgets, primero tendremos que declararlo (veremos como exactamente en la sección de widgets) y depués añadirlo al wibox.

Para declararlo solo tendremos que crearlo como el widget del reloj:

-- Create a textclock widget
mytextclock = awful.widget.textclock({ align = "right" })

Podemos situarlo al principio de la sección como en el código por defecto o justo antes de crear el wibox.

Después lo añadimos al wibox dentro de este código:

mywibox[s].widgets = {
        {
            mylauncher,
            mytaglist[s],
            mypromptbox[s],
            layout = awful.widget.layout.horizontal.leftright
        },
        mylayoutbox[s],
        mytextclock,
        s == 1 and mysystray or nil,
        mytasklist[s],
        layout = awful.widget.layout.horizontal.rightleft
    }

Ahí podemos observar como esta añadido el widget del reloj para que aparezca justo antes del layoutbox.

Observando el código de adicción de widgets también podemos observar claramente como podemos crear grupos de widgets y que se ordenen de diferente forma con la opción layout pudiendo ser distinta para cada grupo.

En el caso del código por defecto podemos observar que se crea un grupo que empieza desde la izquierda hacia la derecha con el lanzador del menu, la lista de tags y la caja de prompts y otro grupo que se crea de derecha izquierda con la lista de tareas, la bandeja del sistema el reloj y la caja de layouts donde se muestra que layout estamo utilizando en la tag activa.

3.2.1.7 Atajos de teclado y teclas del raton

No vamos a poner el código entero de los atajos de teclado por defecto, para ver la lista solo tenemos que ir aqui (subarticulo todavía en preparación)

Solo vamos a mostrar como crear los nuestros y donde podemos ubicarlos en el rc.lua.

La sintaxis para crear una atajo de teclado es la siguiente:

awful.key({modkey, "Shift"   }, "n",     function () awful.util.spawn("konqueror", false) end),

Como se puede observar es muy sencillo, primeros colocamos el modificador, esto es opcional, si queremos que la combinción no necesite el modificador solo tenemos que obviar esa parte dejandola en blanco, después podemos poner una segunda tecla opcional que modifique al modificador. Ya fuera de los corchetes colocamos el keysim (o keycode de esta forma "#123"). Después solo tenemos que sustituir konqueror por el programa que queramos lanzar (en el caso que pongamos un alias de los que hemos creado antes no debemos añadir comillas).

Otro ejempo sin modkey, sin segunda tecla y con keycode podría ser este:

awful.key({   }, "#121",     function () awful.util.spawn("amixer -q sset Master toggle", false) end),

Ahora pasaremos a mostrar como se realizan atajos para el ratón:

    awful.button({ }, 3, function () mymainmenu:toggle() end),

Como podemos ver es muy parecido a la forma de modificar las teclas, excepto que colocamos el numero del botón del raton en lugar del keysim o keycode.

El mejor lugar para ubicar estos atajos en el rc.lua es justo antes de los prompts.

3.2.1.8 Prompts

Una forma especial de atajo de teclado es que llama a un prompt. Estos prompts se puede usar para varias cosas, por defecto hay dos creados, uno para ejecutar aplicaciones y otro para ejecutar sentencias de lua:

    -- Prompt
    awful.key({ modkey },            "r",     function () mypromptbox[mouse.screen]:run() end),

    awful.key({ modkey }, "x",
              function ()
                  awful.prompt.run({ prompt = "Run Lua code: " },
                  mypromptbox[mouse.screen].widget,
                  awful.util.eval, nil,
                  awful.util.getdir("cache") .. "/history_eval")
              end)

Para explicar su sintaxi voy a utilizar un prompt muy útil que abre una dirección web en el navegador por defecto guardando un historial de las páginas abiertas:

      --uzbl prompt with history

    awful.key({ modkey },       "F5",    function ()
      awful.prompt.run({ prompt = "Browser: " },
      mypromptbox[mouse.screen].widget,
      function (host) awful.util.spawn( browser.. " " .. host, false) end,
      awful.completion.shell, awful.util.getdir("cache") .. "/history_browser")
       end),

Si nos fijamos bien la estructura es calcada al de los atajos de teclado hasta que llegamos a la parte de la function () donde usamos la orden awful.prompt.run () para crear el prompt con estos modificadores:

  • Primero con la variable prompt creamos el nombre que aparecera en el promptboxwidget.
  • Segundo creamos la orden a ejecutar al pulsar intro en el prompt:
    function (host) awful.util.spawn ( browser.. " ".. host, false) end,

    Es importante notar que la variable host contiene el texto que hemos escrito en el propio prompt.

  • El resto de la función sirve para crear una cache de las paginas abiertas (se guardan en el archivo ~/.cache/history_browser con autocompletado

Con este ejemplo podemos crear todos los prompts que nos sean necesarios.

3.2.1.9 Reglas de aplicaciones.

En esta sección vamos a hacer que las aplicaciones se dirijan a un tag determinada, sean floating y muchas opciones más muy interesantes para el manejo diario de awesome.

Empezamos mostrando el código que hay por defecto en el rc.lua:

-- {{{ Rules
awful.rules.rules = {
    -- All clients will match this rule.
    { rule = { },
      properties = { border_width = beautiful.border_width,
                     border_color = beautiful.border_normal,
                     focus = true,
                     keys = clientkeys,
                     buttons = clientbuttons } },
    { rule = { class = "MPlayer" },
      properties = { floating = true } },
    { rule = { class = "pinentry" },
      properties = { floating = true } },
    { rule = { class = "gimp" },
      properties = { floating = true } },
    -- Set Firefox to always map on tags number 2 of screen 1.
    -- { rule = { class = "Firefox" },
    --   properties = { tag = tags[1][2] } },
}
-- }}}

La sintaxi es muy sencilla y paso a describirla con un ejemplo de una aplicación real:

       { rule = { class = "Xmessage", instance = "xmessage", name = "xmessage" },
       properties = { floating = true } },
      { rule = { class = "Konqueror" },
       properties = { tag = tags[1][2],switchtotag = true } },
      { rule = { name = "uzbl" },
       properties = { tag = tags[1][2],switchtotag = true } },

Como se puede observar claramente podemos identificar la apliación a modificar tanto por nombre, instancia o clase. Una vez identificada solo tenemos que aplicar las propieades que queramos, podemos consultarlas algunas aquí.

La más importante es la propiedad tag donde definimos en que pantalla y tag de esta abrimos la aplicación. En eje ejemplo abrimos konqueror en la pantalla 1 y la tag 2.

3.2.2 Widgets

Los widgets son una maravillosa forma de extender las funciones de awesome de un forma sencilla y potente. Podemos presentar información sobre el sistema o el propio awesome en el wibox de una forma sencilla y limpia y con multiples formas y formatos. Realmente como podemos observar en nuestro rc.lua por defecto todo es un widget visualmente en awesome.

Antes de empezar a desgranar las diferentes soluciones creadas para gestionar los widgets vamos a comentar unos aspectos generales que se aplican a la mayoría de los elementos comentados después.

La sintaxi para crear un widget es sencilla, para ello se utiliza la función widget() dandole como argumentos el tipo de widget y opcionalmente un nombre para referirnos a ellos de esta forma:

spacer = widget({ type = "textbox", name = "spacer" })

En el ejemplo anterior hemos creado el widget spacer de tipo textbox y con nombre "spacer".

Después podemos otorgarle un valor de esta forma:

spacer.text = " "

En este ejemplo le hemos otorgado al widget de texto un espacio como valor.

Existe una forma generica de actualizar los widgets de forma periodica aunque las soluciones que se nos ofrecen en awesome se encargan de esto de forma más transparente y sencilla, un ejemplo:

mytimer = timer({ timeout = 30 })
mytimer:add_signal("timeout", function() mytextbox.text = "Hello awesome world!" end)
mytimer:start()

Hay varios tipos de widgets que podemos crear, algunos vienen por defecto y otros vienen otorgados por awful. Vamos a definirlos y dar algunas pautas sobre ellos.

Primero empezaremos por los tres que nos ofrece awesome por defecto:

  • textbox. Esto crea un widget cuyo contenido es un texto. Para modificar su valor sin usar ninguna de las ayudas sería así:
    widget.text = "valor"

    En awesome podemos cambiar el color del texto y otros valores usando el standard pango.

  • imagebox. Esto crea un widget cuyo contenido es una imagen que imlib2 pueda manejar. Para ajustar su valor lo haremos de la siguiente forma:
    widget.image = image("ruta a la imagen")
  • systray. Con este widget podemos crear una "bandeja del sistema". Un widget de este tipo viene predefinido en el rc.lua y normalmente no necesitaremos crear otro.

Los dos widgets que awful nos presta son considerablemente más elaborados visualmente:

  • Graph. Con la función awful.widget.graph podemos crear un grafico que se actualiza en el tiempo. Este es un ejemplo de su uso:
    mygraph = awful.widget.graph()
    mygraph:set_width(50)
    mygraph:set_background_color('#494B4F')
    mygraph:set_color('#FF5656')
    mygraph:set_gradient_colors({ '#FF5656', '#88A175', '#AECF96' })

    Para añadir datos al widget podemos usar la función add_value() de esta forma:

    mygraph:add_value(0.5)
  • Progressbar. Con la función awful.widget.progressbar se puede crear un barra de progreso que se actualice con los datos que le vayamos entregrando, un ejemplo de barra de progreso puede ser este:
    myprogressbar = awful.widget.progressbar()
    myprogressbar:set_width(8)
    myprogressbar:set_height(10)
    myprogressbar:set_vertical(true)
    myprogressbar:set_background_color('#494B4F')
    myprogressbar:set_color('#AECF96')
    myprogressbar:set_gradient_colors({ '#AECF96', '#88A175', '#FF5656' })

    Para añadir valores a la barra de progreso podemos usar la función set_value de esta forma:

    myprogressbar:set_value(0.5)

Por último vamos a hablar de la forma que podemos incluir acciones para los botones del raton en nuestros widgets de forma que solo afecten a ellos, lo haremos de la siguiente forma:

mytextbox:buttons(awful.util.table.join(
   awful.button({ }, 1, function () awful.util.spawn("echo Left mouse button pressed.") end)
))

En ese ejemplo hacemo que al pulsar el botón 1 del ratón sobre el widget se produzca el echo. Por supuesto podemos sustituir esa orden por la de nuestra elección.

Esto conbinado con los widgets imagebox nos permite crear lanzadores de aplicaciones si es de nuestro gusto.

3.2.2.1 Vicious

Vicious es la solución para crear y gestionar widgets realizada por Adrian C. (anrxc). Tiene como objetivo la modularidad y la sencillez. Los widgets vicious no dan otra cosa que datos que nosostros mismos hemos de manipular en el rc.lua para mostralos con el formato que deseemos. Realmente, al igual que awesome es un framework para crearnos nuestro propio wm, vicious es un framework para crearnos nuestros widgets.

La creación de widgets con vicious debe regirse por cuatro lineas maestras:

  • Modularidad.. Debemos poder usar solo los widgets que queramos y ignorar el resto.
  • Brevedad.. Los widgets deben ser pequeños 10+ lineas, deben procesar los datos y devolverlos sin formato, ya se formatearan en otros sitios, tales como el rc.lua
  • Ligeros.. No deben añadir carga excesiva al sistema, especialmente en los portátiles en modo batería.
  • Faciles.. Deben ser sencillos de instalar y no depender de librerias externas.

Pasamos ahora a la instalación en Debian de la librería vicious, para ello tenemos dos opciones:

Desde los repositorios

Para instalar vicious desde los repositorios solo tenemos que instalar el paquete awesome-extra con nuestro gestor de paquetes preferido, p.e.:

# aptitude install awesome-extra

Desde el git oficial

También podemos descargar vicious desde el git oficial creando y mantenido por anrxces su página personal, para ello solo tenemos que clonar el git en nuestro directorio de configuracion de awesome (tipicamente ~/.config/awesome/):

$ git clone http://git.sysphere.org/vicious
$ mv vicious ~/.config/awesome/

nota: Evidentemente debemos tener instalado git-core.

Para empezar a usarlo debemos decirle a awesome que cargue la librería vicious como hemos visto en esta sección. Para ello añadimos la siguiente linea:

require("vicious")

Una vez hemos hecho esto ya podemos empezar a usar vicious en nuestro awesome. Ahora vamos a describir los pasos para activar un widget de los que lleva predefinidos vicious en nuestro sistema. En este caso hemos elegido un widget de texto que nos dira la carga de la batería del sistema.

Primero, como hemos visto más atras en los consejos generales de la sección widgets tenemos que crear el widget de texto:

batwidget       = widget({ type = "textbox", name = "batwidget" })

Ahora pasamos a registrar el widget, veamos un ejemplo y pasemos a explicar la sintaxi en profundidad a continuación:

vicious.register(batwidget, vicious.widgets.bat, "$1", 23, "BAT1")

Como podemos ver la función encargada de cambiar el valor del widget se llama vicious.register() y admite unos parametros que vamos a detallar a continuación:

  1. Nombre del widget a modificar. En este parametro le decimos a la función en que widget de los creados vamos a colocar los datos que nos devuelva la función. Este parametro es obligatorio. En el caso del ejemplo le hemos dado el valor batwidget.
  2. Widget vicious usado. En este parametro le decimos a la función que widget vicious vamos a usar. Este parametro es obligatorio. En el ejemplo hemos usado el widget de la batería invocandole de esta forma: vicious.widgets.bat.
  3. Dato a usar y formato. En este parametro vamos a decidir cuales de los datos devueltos por el widget vamos a usar y como los formatearemos para presentarlos en nuestro awesome. Este es un parametro obligatorio. En el caso del ejemplo es: "$1".
  4. Frecuencia de actualización. Frecuencia de actualización en segundos para renovar el contenido del widget. Este parametro es opcional y si no se especifica el valor por defecto es "2". En este caso hemos puesto: 23.
  5. Parametros para el widget vicious Algunos de los widgets vicios necesitan algún parametro para funcionar, si es así este es el lugar donde colocarlo. Este es un parametro necesario para algunos widgets. En el caso del vicious.widgets.bat hemos de especificar la batería, en el ejemplo: "BAT1".

Ya solo quedaría añadir el widget al wibox como hemos visto en la sección wibox.

Vamos a profundizar un poco en lo que podemos hacer con el parametro tres de la función vicious.register(). Hemos visto anteriormente que en este parametro damos formato a los datos que recibimos del widget, los datos devueltos por la función se estructuran como en un array de elementos y nos podemos referir a cada uno de ellos con un numero. También podemos combinar texto con los varlores recibidos. Esto se ve claro en este ejemplo de parametro:

"Estado: $1 Carga: $2% Tiempo: $3"

Este ejemplo quedaría más o menos así en el wibox:

Estado: + Carga: 86% Tiempo: 01:15

También podemos cambiar colores y realizar cualquiera modificación que se nos ocurra. Pero una de las cosas más importantes que podemos hacer es colocar un función para poder hacer modificaciones complejas de los datos, notificaciones naughty y bastante más. Para ello solo tenemos que cambiar el parametro por una función con esta estructura:

function (widget, args)
...
...
...
end

Los parametros que nos devuelve el widget vicious se almacenan en la variable args y podemos referirnos a cada valor de la forma habitual args[1], args[2]...

Esto es un ejemplo de una función para un widget de batería donde se cambia el valor de un imagebox segun la carga y el estado de la batería además de mostrar una notificación naughty si llega a un nivel preocupante:

function (widget, args)
  if   args[1] == "⌁" then
    baticon.image=image(confdir.. "/icons/battery/ac.png")
  elseif args[1] == "+" then
    if args[2] == 100 then
      baticon.image=image(confdir.. "/icons/battery/ac.png")
      statebat = "Charged"
    elseif args[2] > 90 and args[2] < 100 then
      baticon.image=image(confdir.. "/icons/battery/char1.png")
    elseif args[2] > 80 and args[2] <= 90 then
      baticon.image=image(confdir.. "/icons/battery/char2.png")
    elseif args[2] > 70 and args[2] <= 80 then
      baticon.image=image(confdir.. "/icons/battery/char3.png")
    elseif args[2] > 60 and args[2] <= 70 then
      baticon.image=image(confdir.. "/icons/battery/char4.png")
    elseif args[2] > 50 and args[2] <= 60 then
      baticon.image=image(confdir.. "/icons/battery/char5.png")
    elseif args[2] > 40 and args[2] <= 50 then
      baticon.image=image(confdir.. "/icons/battery/char6.png")
    elseif args[2] > 30 and args[2] <= 40 then
      baticon.image=image(confdir.. "/icons/battery/char7.png")
    elseif args[2] > 20 and args[2] <= 30 then
      baticon.image=image(confdir.. "/icons/battery/char8.png")
    elseif args[2] > 10 and args[2] <= 20 then
      baticon.image=image(confdir.. "/icons/battery/char9.png")
    else
      baticon.image=image(confdir.. "/icons/battery/char10.png")
    end
  else
    if args[2] > 90 then
      baticon.image=image(confdir.. "/icons/battery/bat1.png")
    elseif args[2] > 80 and args[2] <= 90 then
      baticon.image=image(confdir.. "/icons/battery/bat2.png")
    elseif args[2] > 70 and args[2] <= 80 then
      baticon.image=image(confdir.. "/icons/battery/bat3.png")
    elseif args[2] > 60 and args[2] <= 70 then
      baticon.image=image(confdir.. "/icons/battery/bat4.png")
    elseif args[2] > 50 and args[2] <= 60 then
      baticon.image=image(confdir.. "/icons/battery/bat5.png")
    elseif args[2] > 40 and args[2] <= 50 then
      baticon.image=image(confdir.. "/icons/battery/bat6.png")
    elseif args[2] > 30 and args[2] <= 40 then
      baticon.image=image(confdir.. "/icons/battery/bat7.png")
    elseif args[2] > 20 and args[2] <= 30 then
      baticon.image=image(confdir.. "/icons/battery/bat8.png")
    elseif args[2] > 10 and args[2] <= 20 then
      baticon.image=image(confdir.. "/icons/battery/bat9.png")
    elseif args[2] > 5 and args[2] <= 10 then
      baticon.image=image(confdir.. "/icons/battery/bat10.png")
    else
      baticon.image=image(confdir.. "/icons/battery/bat11.png")
      naughty.notify({ title      = "Battery Warning"
                                , text       = "Battery low! "..args[2].."% left!"
                                , timeout    = 5
                                , position   = "top_right"
                                , fg         = beautiful.fg_focus
                                , bg         = beautiful.bg_focus
                           })
    end
  end
      end,

3.2.2.2 Obvious

3.2.2.3 Bashets

3.2.4 theme.lua

Editaremos ahora el archivo de tema, para ello nos movemos donde se encuentra nuestro archivo de Themes

$ cd /home/usuario/.config/awesome/themes/default

Entramos en el archivo de configuración

$ nano theme.lua

Nos encontraremos con lo siguiente

---------------------------
-- Default awesome theme --
---------------------------

theme = {}

theme.font          = "sans 8"

theme.bg_normal     = "#222222"
theme.bg_focus      = "#535d6c"
theme.bg_urgent     = "#ff0000"
theme.bg_minimize   = "#444444"

theme.fg_normal     = "#aaaaaa"
theme.fg_focus      = "#ffffff"
theme.fg_urgent     = "#ffffff"
theme.fg_minimize   = "#ffffff"

theme.border_width  = "1"
theme.border_normal = "#000000"
theme.border_focus  = "#535d6c"
theme.border_marked = "#91231c"

-- There are other variable sets
-- overriding the default one when
-- defined, the sets are:
-- [taglist|tasklist]_[bg|fg]_[focus|urgent]
-- titlebar_[bg|fg]_[normal|focus]
-- tooltip_[font|opacity|fg_color|bg_color|border_width|border_color]
-- mouse_finder_[color|timeout|animate_timeout|radius|factor]
-- Example:
--theme.taglist_bg_focus = "#ff0000"

-- Display the taglist squares
theme.taglist_squares_sel   = "/usr/share/awesome/themes/default/taglist/squarefw.png"
theme.taglist_squares_unsel = "/usr/share/awesome/themes/default/taglist/squarew.png"

theme.tasklist_floating_icon = "/usr/share/awesome/themes/default/tasklist/floatingw.png"

-- Variables set for theming the menu:
-- menu_[bg|fg]_[normal|focus]
-- menu_[border_color|border_width]
theme.menu_submenu_icon = "/usr/share/awesome/themes/default/submenu.png"
theme.menu_height = "15"
theme.menu_width  = "100"

-- You can add as many variables as
-- you wish and access them by using
-- beautiful.variable in your rc.lua
--theme.bg_widget = "#cc0000"

-- Define the image to load
theme.titlebar_close_button_normal = "/usr/share/awesome/themes/default/titlebar/close_normal.png"
theme.titlebar_close_button_focus  = "/usr/share/awesome/themes/default/titlebar/close_focus.png"

theme.titlebar_ontop_button_normal_inactive = "/usr/share/awesome/themes/default/titlebar/ontop_normal_inactive.png"
theme.titlebar_ontop_button_focus_inactive  = "/usr/share/awesome/themes/default/titlebar/ontop_focus_inactive.png"
theme.titlebar_ontop_button_normal_active = "/usr/share/awesome/themes/default/titlebar/ontop_normal_active.png"
theme.titlebar_ontop_button_focus_active  = "/usr/share/awesome/themes/default/titlebar/ontop_focus_active.png"

theme.titlebar_sticky_button_normal_inactive = "/usr/share/awesome/themes/default/titlebar/sticky_normal_inactive.png"
theme.titlebar_sticky_button_focus_inactive  = "/usr/share/awesome/themes/default/titlebar/sticky_focus_inactive.png"
theme.titlebar_sticky_button_normal_active = "/usr/share/awesome/themes/default/titlebar/sticky_normal_active.png"
theme.titlebar_sticky_button_focus_active  = "/usr/share/awesome/themes/default/titlebar/sticky_focus_active.png"

theme.titlebar_floating_button_normal_inactive = "/usr/share/awesome/themes/default/titlebar/floating_normal_inactive.png"
theme.titlebar_floating_button_focus_inactive  = "/usr/share/awesome/themes/default/titlebar/floating_focus_inactive.png"
theme.titlebar_floating_button_normal_active = "/usr/share/awesome/themes/default/titlebar/floating_normal_active.png"
theme.titlebar_floating_button_focus_active  = "/usr/share/awesome/themes/default/titlebar/floating_focus_active.png"

theme.titlebar_maximized_button_normal_inactive = "/usr/share/awesome/themes/default/titlebar/maximized_normal_inactive.png"
theme.titlebar_maximized_button_focus_inactive  = "/usr/share/awesome/themes/default/titlebar/maximized_focus_inactive.png"
theme.titlebar_maximized_button_normal_active = "/usr/share/awesome/themes/default/titlebar/maximized_normal_active.png"
theme.titlebar_maximized_button_focus_active  = "/usr/share/awesome/themes/default/titlebar/maximized_focus_active.png"

-- You can use your own command to set your wallpaper
theme.wallpaper_cmd = { "awsetbg /usr/share/awesome/themes/default/background.png" }

-- You can use your own layout icons like this:
theme.layout_fairh = "/usr/share/awesome/themes/default/layouts/fairhw.png"
theme.layout_fairv = "/usr/share/awesome/themes/default/layouts/fairvw.png"
theme.layout_floating  = "/usr/share/awesome/themes/default/layouts/floatingw.png"
theme.layout_magnifier = "/usr/share/awesome/themes/default/layouts/magnifierw.png"
theme.layout_max = "/usr/share/awesome/themes/default/layouts/maxw.png"
theme.layout_fullscreen = "/usr/share/awesome/themes/default/layouts/fullscreenw.png"
theme.layout_tilebottom = "/usr/share/awesome/themes/default/layouts/tilebottomw.png"
theme.layout_tileleft   = "/usr/share/awesome/themes/default/layouts/tileleftw.png"
theme.layout_tile = "/usr/share/awesome/themes/default/layouts/tilew.png"
theme.layout_tiletop = "/usr/share/awesome/themes/default/layouts/tiletopw.png"
theme.layout_spiral  = "/usr/share/awesome/themes/default/layouts/spiralw.png"
theme.layout_dwindle = "/usr/share/awesome/themes/default/layouts/dwindlew.png"

theme.awesome_icon = "/usr/share/awesome/icons/awesome16.png"

return theme
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80

La sección para editar los colores es:

theme.bg_normal     = "#222222"
theme.bg_focus      = "#535d6c"
theme.bg_urgent     = "#ff0000"
theme.bg_minimize   = "#444444"

theme.fg_normal     = "#aaaaaa"
theme.fg_focus      = "#ffffff"
theme.fg_urgent     = "#ffffff"
theme.fg_minimize   = "#ffffff"

theme.border_width  = "1"
theme.border_normal = "#000000"
theme.border_focus  = "#535d6c"
theme.border_marked = "#91231c"

Pueden probar cambiado esta configuración y dejando la sección de esta manera. Este es solo un ejemplo de colores para Awesome, recuerden que pueden cambiar los colores a su gusto y preferencias.

Cambiamos por lo siguiente:

theme.bg_normal     = "#ededed"
theme.bg_focus      = "#441717"
theme.bg_urgent     = "#ffffff"
theme.bg_minimize   = "#444444"

theme.fg_normal     = "#441717"
theme.fg_focus      = "#ffffff"
theme.fg_urgent     = "#441717"
theme.fg_minimize  =  "#111111"

theme.border_width  = "1"
theme.border_normal = "#ededed"
theme.border_focus  = "#ededed"
theme.border_marked = "#441717"

4. Awesome y el arranque del sistema

Éste es un aspecto importante en Awesome, dado que los widgets como el reloj deben que iniciarse automáticamente al hacerlo nuestro gestor de ventanas.

Para abordar este aspecto hemos de tener en cuenta si usamos gestor de identificación (gdm, kdm, xdm, slim) o no.

4.1. Iniciar awesome sin gestor de identificación

Editamos ~/.xinitrc. Si no existe, lo creamos, o podemos copiarlo de /etc/X11/xinit

$ cp /etc/X11/xinit/xinitrc /home/usuario/.xinitrc

(prefierimos tenerlo oculto)

$ nano ~/.xinitrc

Añadimos exec awesome

4.2. Arranque con GDM

Podemos utilitzar dos archivos para la inicialización de scripts:

/etc/gdm/PostLogin/Default
/etc/gdm/PreSession/Default

A priori, no hay mucha diferencia. Pero si nos paramos a pensarlo algo mejor, nos daremos cuenta que en el primero de ellos no disponemos de dos variables fundamentales: $GDMSESSION y/o $DESKTOP_SESSION.

En cambio con el segundo, sí. Dichas variables contienen el nombre del gestor de ventanas que se haya arrancado con GDM.

¿Para qué pueden servirnos dichas variables? Para poder utilizar dos gestores de ventanas en la misma máquina. ¿Por qué? Por qué si usamos Gnome, a pesar de tener Awesome instalado, los scripts de inicialización comentados antes se ejecutan igualmente y por lo tanto la inicialización de los scripts para Awesome no tienen por qué ser los mismos que nos pueden interesar en Gnome.

De este modo, para inicializar los widgets o scripts que nos interesen en Awesome es recomendable hacerlo usando el segundo archivo:

/etc/gdm/PreSession/Default

Añadiéndole las siguientes líneas al final del archivo:

if [ "$GDMSESSION" == "awesome" ]
then
~/.awesome/widget_init.sh
fi

Es importante tener en cuenta que ahora no hace falta usar:

exec awesome

Porque GDM es quien gestiona ese proceso.

4.3. Awesome como Window Manager para kde

Awesome puede, al igual que muchos otros manejadores de ventanas, ser el window manager que use por defecto un determinado escritorio. En este caso, vamos a hablar de como hacer de Awesome el manejador de ventanas de kde (probado en kde 4.2, aunque debería valer para la rama kde3).

Lo primero que tenemos que hacer es crear el directorio .kde/env/ si este no existiese. En él, crearemos un script (algo como window_manager.sh). Su contenido será:

KDEWM=/usr/bin/awesome

Guardamos, hacemos el pertinente chmod +x y reiniciamos sesión.

NOTA: Algunas aplicaciones intentarán "recordar" el comportamiento que tenían con kwin al ocupar el espacio en la pantalla, y pueden dar problemas con el tiling dinámico de awesome. Se recomienda hacer una limpia en el directorio de configuración de kde /home/usuario/.kde y dejar solo aquello que necesitemos (configuración de cuentas de kmail por ejemplo).

4.4. Awesome como Window Manager para Gnome

Awesome también se puede utilizar como el gestor de ventanas de Gnome.

Hacerlo es muy sencillo solamente creamos un archivo en nuestro home llamado .gnomerc, lo editamos y su contenido va a ser:

export WINDOW_MANAGER=/usr/bin/awesome

Reiniciamos el entorno grafico y listo.

Recuerda que la barra que contiene: aplicaciones, lugares y Sistema de gnome esta situada, (por defecto) en la parte superior de la pantalla, y la de awesome también, así que debemos mover alguna de las dos para tener ambas visibles.

5. Pequeños trucos y consejos

  • Cambiar el layout (disposición de ventanas): mantener pulsado mod4 y apretar espacio.
  • Mover ventanas (pasar una ventana al plano principal): mantener pulsado mod4 y arrastrar con el botón izquierdo del ratón.
  • Redimensionar ventanas (y recolocarlas de forma dinámica): mantener pulsado mod4 y arrastrar con el botón derecho del ratón.

6. Páginas web de interés y lanzamientos

Hasta la fecha, la lista de liberaciones de awesome, con sus nombres clave correspondientes, es

26 nov 2009 awesome 3.4.2 For The Restless
9 nov 2009 awesome 3.4.1 Ego Rock
20 oct 2009 awesome 3.4 Closing In
9 oct 2009 awesome 3.4-rc  Black Star
28 sep 2009 awesome 3.4-rc2 Piku
11 sep 2009 awesome 3.4-rc1 Uprising
7 sep 2009 awesome 3.3.4 Mercury
25 aug 2009 awesome 3.3.3 Firelight
27 jul 2009 awesome 3.3.2 Half Moon
18 jun 2009 awesome 3.3.1 Bionic
4 jun 2009 awesome 3.3 Stellar
26 may 2009 awesome 3.3-rc4 Breath
18 may 2009 awesome 3.3-rc3 Uniform
8 may 2009 awesome 3.3-rc2 Bad Boyfriend
1 may 2009 awesome 3.3-rc1 The Lightning Strike
4 apr 2009 awesome 3.2.1 Complicated
13 mar 2009 awesome 3.2 Accidental Babies
27 feb 2009 awesome 3.2-rc4 Faith
20 feb 2009 awesome 3.2-rc3 Chocolate
13 feb 2009 awesome 3.2-rc2 Hunting For Witches
6 feb 2009 awesome 3.2-rc1 Candyman
5 feb 2009 awesome 3.1.2 Nobody Came
8 jan 2009 awesome 3.1.1 Ring My Bell
12 dec 2008 awesome 3.1 Helicopter
5 dec 2008 awesome 3.1-rc5 Face
28 nov 2008 awesome 3.1-rc4 Seven Nation Army
21 nov 2008 awesome 3.1-rc3 When Doves Cry
14 nov 2008 awesome 3.1-rc2 When She Believes
7 nov 2008 awesome 3.1-rc1 The Golden Floor
18 sep 2008 awesome 3.0 Fake Plastic Trees
5 sep 2008 awesome 3.0-rc6 Elect The Dead
29 aug 2008 awesome 3.0-rc5 Marshals Are Dead
22 aug 2008 awesome 3.0-rc4 Scared Of Girls
15 aug 2008 awesome 3.0-rc3 Into The Groove
8 aug 2008 awesome 3.0-rc2 Wake Up Call
1 aug 2008 awesome 3.0-rc1 Time To Pretend

Puede ver el registro completo de versiones aquí.

Página del proyecto Awesome

‹ AftersteparribaComo instalar Entorno de Escritorio desde el Sistema Base. ›