From awesome

Contents 1 Ambiente 2 File 3 Basi di Lua 4 Tipi di oggetti in awesome 4.1 Screen 4.2 Client 4.3 Tag 4.4 Widget 4.5 Titlebar 4.6 Statusbar 5 Costruiamo l'interfaccia 5.1 Creare i tag 5.2 Gestire i client 5.3 Creare i widget 5.4 Creare statusbar 5.5 Creare titlebar 5.6 Usare gli hooks 5.7 Creare le combinazioni di tasti 5.8 Eseguire comandi e script 6 Librerie Lua di awesome 6.1 awful 6.2 beautiful 6.3 eminent 6.4 wicked

[edit] Ambiente

awesome 3 utilizza un file di configurazione basato sul linguaggio Lua. Molte persone che utilizzavano awesome 2 piangeranno quando vedranno che il vecchio file in libconfuse è sparito, altri odieranno awesome 3 perchè non riescono a capire il file di configurazione ion.

Perchè Lua? Perchè offre più controllo. Permette di controllare più aspetti: stavate cercando di far fare ad awesome qualcosa in un determinato evento, e non eravate in grado di farlo. Ora siete in grado di fare qualsiasi cosa (nel campo di quello che può fare un window manager).

[edit] File

• ~/.config/awesome/rc.lua
• /etc/xdg/awesome/rc.lua

[edit] Basi di Lua

Abbiamo parlato di Lua; quindi prima di tutto imparate Lua. Non volete? Allora fate a meno di usare awesome 3 e smettete di leggere. (Oppure procuratevi il file di configurazione dall'archivio dei sorgenti o da qualcuno, e dategli una ritoccata, perchè non potete fare altro senza la conoscenza del lua).

Per le persone che stanno ancora leggendo, Lua è un linguaggio semplice. In altre parole, se non avete familiarità coi linguaggi di programmazione, i.e. se non conoscete oggetti, metodi e parametri, beh, vi troverete un poco spaesati leggendo questa pagina; andate a imparare un po' di basi della programmazione e tornate!

Non sto chiedendo geni dell'informatica: awesome 3 è ideato per le persone che hanno un minimo di background informatico. Comunque qualsiasi persona, se abbastanza motivata, può imparare le basi che servono a configurare e controllare awesome.

Il miglior modo per imparare Lua è quello di dedicare un paio d'ore alla lettura di Programming In Lua, che da un'anteprima di quello che è possibile realizzare in Lua. Non esitare ad aggiungere ai Preferiti una pagina così importante: parla di controllo del flusso, espressioni, ecc. Questo dovrebbe aiutare : è una pessima idea cercare a proposito della sintassi "for" quando stai scrivendo linee di codice.

[edit] Tipi di oggetti in awesome

Per le persone che non hanno mai usato awesome, qui sono spiegati gli oggetti messi a disposizione, che è necessario manipolare.

[edit] Screen

Non c'è un vero e proprio schermo in awesome, ma parleremo dopo degli oggetti di questo tipo. Uno screen è un monitor fisico collegato al vostro computer. Sono rappresentati da un indice che parte da 1.

[edit] Client

Un client è una finestra. Credo di essere stato chiaro.

[edit] Tag

Un tag è qualcosa come un workspace/desktop, anche se il concetto è meno rigido. Ogni client ha almeno un tag assegnato. Ogni screen ha almeno un tag. In qualsiasi momento, su uno screen, poteve vedere un qualsiasi numero di tag. Facendo a meno di osservare almeno un tag, nasconderai tutti i client. Osservando uno o più tag contemporaneamente, saranno visibili tutti i client che ogni tag possiede.

[edit] Widget

I widget sono oggetti che visualizzano qualcosa su uno screen. Ci sono molti tipi di widget. Per esempio c'è il tipo textbox che stampa un testo su uno screen. Ci sono anche i widget iconbox che visualizzano un'icona su uno screen.

[edit] Titlebar

Una titlebar è una barra che è intorno ad un client e attaccata ad esso. Potete inserire dei widget in essa.

[edit] Statusbar

Una statusbar è una barra fissata al bordo di uno screen. Anche qui, potete inserire dei widget all'interno.

[edit] Costruiamo l'interfaccia

Per costruire la nostra interfaccia, dobbiamo usare le funzioni e i metodi messi a disposizione da awesome: qualsiasi cosa è riportata nella Documentazione delle API Lua e nel manuale di awesomerc(5). Leggeteli. Rappresentano la documentazione alla quale dovete riferirvi. Vi ripeto: leggeteli; qualsiasi cosa è documentata in quella pagina di manuale o nella luadoc.

Quale pagina di manuale? ... awesomerc(5). Ottimo. Mi stavate seguendo.

[edit] Creare i tag

Se avviate awesome senza esegure alcuna operazione con lua, vi ritroverete con 0 tag; questo è fatale. Awesome ha bisogno di almeno un tag.

Per prima cosa, dobbiamo creare un tag. Come possiamo farlo? Vediamo i tag() nella documentazione, e la funzione per creare tag nella pagina del manuale. Dice che il parametro della funzione dev'essere una tabella con almeno un nome come parametro. Facciamolo.

mytagone = tag({ name = "one" })

mytag è un nuovo oggetto di tipo tag, il suo nome è one. Se vogliamo impostargli un layout di default, dobbiamo aggiungere una chiava/valore all'interno della tabella, come spiegato nella documentazione.

mytagtwo = tag({name = "two", layout = "floating" })

Ora, noi abbiamo un secondo tag: il suo nome è two, e di default lui gestisce i client con lo schema floating, che come suggerisce il nome, rende i client liberi.

Creare oggetti è divertente, ma per il momento privo di utilità. Ricorda ogni screen deve avere almeno un tag. Quindi dobbiamo aggiungere questi tag che abbiamo creato al nostro primo screen. L'attributo screen di un tag lo fa per noi, dobbiamo solo assegnare il numero dello screen che desideriamo.

mytagone.screen = 1

Ora abbiamo aggiunto il tag allo screen #1. Se abbiamo un secondo screen (multi-head: Zaphod, Xinerama o XRandR sono identici per awesome), dobbiamo aggiungere un secondo tag a questo screen:

mytagtwo.screen = 2

E se avessimo 3 screen, dobbiamo... beh, spero abbiate capito il concetto.

Se volete conoscere quanti screen avete, potete usare la funzione screen.count().

Potete gestire la visualizzazione del tag con l'attributo selected. Se volete vedere il tag one:

mytagone.selected = true

Se volete nasconderlo, ovviamente dovete settare il valore su false.

Potete gestire tutte le impostazioni del tag con i suoi attributi. Guardate la documentazione,

[edit] Gestire i client

Qualche volta, vorrete prendere gli oggetti di tipo client. Sono veramente utili nelle funzioni hook, delle quali ne parleremo dopo.

Un client è un oggetto con dei metodi, come i tag e altro. Decidiamo che la variabile c è il nostro oggetto client. Per esempio, se vogliamo rendere un client libero dobbiamo usare l'attributo floating in questo modo:

c.floating = true

Alcuni metodi ritornano valori che possono essere usati dopo per delle analisi. Se vogliamo sapere se un client è libero possiamo prendere l'attributo floating:

is_client_floating = c.floating

La variabile is_client_floating ora contiene un valore booleano: true se il client è libero o false se non lo è.

Possiamo combinare queste 2 funzioni per creare una funzione: questa funzione imposterà lo stato libero del client su true se non lo è già, oppure su falso se lo è.

function client_floating_toggle(c)
    if c then
        c.floating = not c.floating
    end
end

Possiamo anche usare questa funzione per spostare un client su un determinato tag:

function client_tag_with_tag_one(c)
    if c then
        local t = c:tags()
        table.insert(t, one)
        c:tags(t)
    end
end

[edit] Creare i widget

I widget sono piccoli oggetti che possono essere disposti nelle titlebar o nelle statusbar. Come i tag, se non li aggiungete da qualche parte, sono completamente inutili. Per creare un widget usate la funzione widget():

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

Ora mytextbox contiene un oggetto di tipo textbox. Potete usare diversi attributi con diversi tipi di widget, il prossimo inserisce un testo in una textbox.

mytextbox.text = "Hello, world!

[edit] Creare statusbar

Le statusbar sono contenitori di widget che possono essere disposti in alto, in basso, a sinistra o a destra di uno screen.

Primo, create la statusbar:

mystatusbar = statusbar({ position = "top", name = "mystatusbar" })

mystatusbar è una variabile che contiene un oggetto statusbar. Abbiamo dato a position il valore top, che posizionerà la barra in alto allo screen. Ovviamente, non l'abbiamo aggiunta allo screen, per ora è un oggetto inutile. Quindi facciamo:

mystatusbar.screen = 1

La nostra statusbar sarà ora visibile in alto allo screen. Bene, non fa niente ma è davvero utile. Aggiungiamo qualche widget!

-- Crea una textbox
mytextbox = widget({ type = "textbox", name = "mytextbox" })
-- Imposta un testo nella textbox
mytextbox.text = "Hello, world!"
-- Crea una statusbar
mystatusbar = statusbar({ position = "top", name = "mystatusbar" })
-- Aggiunge le widgets alla statusbar
mystatusbar:widgets({ mytextbox })
-- Aggiunge la statusbar allo screen #1
mystatusbar.screen = 1

E voilà. Ora abbiamo una statusbar nuova di zecca in alto allo schermo che visualizza Hello, world!. Usando questo metodo, potete settare un bel po' di widget sulla statusbar prima di avviare awesome, nel vostro file di configurazione.

[edit] Creare titlebar

Come detto prima, le titlebar sono come le statusbar ma le titlebar si trovano intorno ad una finestra. Per creare una titlebar, sapete cosa fare:

mytitlebar = titlebar({ position = "top" })

Quindi, probabilmente vorreste inserire dei widget all'interno. Funziona come nelle statusbar:

mytitlebartitle = widget({ type = "textbox", name = "mytitlebartitle" })
mytitlebar:widgets({ mytitlebartitle })

Una titlebar dev'essere aggiunta a un oggetto client. Possiamo ottenere la finestra in primo piano: è contenuta nella variabile client.focus. Facciamo questo:

-- Prendi la finestra in primo piano
c = client.focus
-- Imposta una titlebar per quella finestra
c.titlebar = mytitlebar

Ora, la finestra in primo piano ha una carina titlebar in alto! Ma non c'è nulla all'interno. No, aspetto! Ricorda, nelle titlebar noi possiamo sempre aggiungere una widget di tipo textbox. Possiamo ora stampare il nome del client su di essa:

mytitlebartitle.text = c.name

L'attributo name è una stringa che contiene il nome del client, e noi inseriamo il testo in una widget. Ora la titlebar visualizza il titolo del client.

Ricorda: una titlebar è un oggetto, e un client è un altro oggetto. Vuol dire che dovrai creare una titlebar per ogni client a cui vuoi assegnarla.

[edit] Usare gli hooks

Con quello che abbiamo visto prima, potete costruire una bella interfaccia. Comunque, immagine di voler aggiornare il titolo visualizzato nella titlebar di un client: non potete. Aspetta! Qui c'è la soluzione: gli hooks.

Con gli hooks, potete definire funzioni che sono richiamate al seguito di un evento. Provate con un esempio.

Quando un nuovo client appare nello screen, awesome esegue la funzione collegata gestita dall'hook. Questa funzione è chiamata passando il nuovo client come argomento. Questo è un esempio:

function hook_manage(c)
    if c.name:find("mplayer") then
        c.floating = true
    end
end

In primo luogo, abbiamo definito una funzione hook_manage, con un argomento chiamato c, che sarà il cliente. Quindi, cerchiamo di trovare la stringa "mplayer" nel nome del client, e se c'è, impostiamo lo stato libero al client.

 awful.hooks.manage.register(hook_manage)

Poi, con quella chiamta, definiamo che la funzione chiamata per ogni nuovo client che arriva è hook_manage.

Ci sono molti hooks che potete usare e definire: focus, unfocus, manage, unmanage, mouseover, arrange, titleupdate, urgent, timer, … Consultate il manuale per altre informazioni.

[edit] Creare le combinazioni di tasti

A volte può essere utile mappare alcune azioni ad una serie di tasti, che sono spesso più facili da premere rispetto Mod-shift-ctrl-x. Nell'esempio seguente è possibile digitare Ctrl-f e DOPO premere "a" invece di premere tutti i tasti nello stesso momento.

 -- Crea una lista di scorciatoie da tastiera che possono essere aggiunte quando viene premuto Ctrl-f
 keybind_ctrl_f = {} 
  
 function keychain_ctrl_f_add() 
     for k, v in pairs(keybind_ctrl_f) do 
         v:add() 
     end 
 end 
 
 function keychain_ctrl_f_remove() 
     for k, v in pairs(keybind_ctrl_f) do 
         v:remove() 
     end 
 end 
 
 table.insert(keybind_ctrl_f, keybinding({}, "a", function () 
     mytextbox.text = "You pressed a!"
     keychain_ctrl_f_remove() 
 end)) 
 
 table.insert(keybind_ctrl_f, keybinding({ "Mod4" }, "b", function () 
     mytextbox.text = "You pressed Mod4 + b!"
     keychain_ctrl_f_remove() 
 end)) 
 
 table.insert(keybind_ctrl_f, keybinding({}, "Escape", keychain_ctrl_f_remove)) 
 
 keybinding({ "Control" }, "f", keychain_ctrl_f_add):add()

[edit] Eseguire comandi e script

Potete eseguire comandi e script inseriti nella configurazione base di lua. Qui un esempio di funzione che prende come parametro un comando e ritorna un risultato. Questa è utile per esempio per visualizzare qualcosa nelle textbox.

-- Esegui il comando e ritorna il suo risultato. Probabilmente non volete eseguire
-- comandi che hanno una sola linea come output
function execute_command(command)
   local fh = io.popen(command)
   local str = ""
   for i in fh:lines() do
      str = str .. i
   end
   io.close(fh)
   return str
end

Qui un esempio che inserisce /proc/loadavg in mytextbox:

 mytextbox.text = " " .. execute_command("cat /proc/loadavg") .. " "

[edit] Librerie Lua di awesome

[edit] awful

awful è la libreria predefinita per interagire con awesome, come le azioni del mouse o le scorciatoie da tastiera.

[edit] beautiful

Beautiful è la libreria per gestire il tema di awesome.

[edit] eminent

Eminent è una libreria Lua che permette di gestire i tag dinamicamente. Con gestire i tag dinamicamente intendo dire che il numero di tag che avrete non è predefinito, potete assegnare specifici nomi ai tag, ma semplicemente andando nel prossimo tag o nell'ultimo potrete aggiungere un tag, permettendovi di adattarvi alla situazione senza cambiare la vostra configurazione per avere più o meno tag.

[edit] wicked

Wicked è una libreria Lua per awesome che fornisce molti widget, come il widget per MPD, utilizzo della CPU, memoria, ecc.