Xinitrc (Italiano)

From ArchWiki
Revision as of 21:40, 30 June 2012 by Umby213 (Talk | contribs) (link GRUB -> GRUB Legacy)

Jump to: navigation, search
Summary help replacing me
Una veduta d'insieme sulle configurazioni principali per il programma xinit (startx).
Related
Display Manager (Italiano)
Start X at boot (Italiano)
Xorg (Italiano)
xprofile

Il file ~/.xinitrc è uno shell script letto da xinit e startx. Viene tipicamente utilizzato per eseguire i window manager e altri programmi all'avvio di X, ad esempio demoni e configurazioni delle variabili d'ambiente. Il programma xinit viene utilizzato per avviare l'X Window System e funziona come un primo programma client su sistemi che non possono avviare direttamente X da /etc/init, o in ambienti che usano vari window manager. Il file ~/.xinitrc è quindi un modo semplice per avviare X, di solito in parallelo con l'avvio dello script startx direttamente da inittab.

Una delle funzioni principali di ~/.xinitrc è quello di dettare quale client per il sistema X Window sarà invocato da /usr/bin/startx e/o il programma /usr/bin/xinit a utente singolo. Ci sono molte altre configurazioni e comandi che possono essere aggiunti a ~/.xinitrc al fine di personalizzare ulteriormente il proprio sistema.

Per iniziare

/etc/skel/ contiene i file e le directory necessari a fornire valori predefiniti per gli account appena creati. (Il nome skel è derivato dalla parola skeleton, perché i file contenuti costituiscono la struttura di base per le home directory degli utenti.) Il pacchetto xorg-xinit provvederà a salvare in /etc/skel uno .xinitrc di esempio.

Note: ~/.xinitrc è un cosiddetto "dot" (.) file. Nei sistemi *nix, i file che sono preceduti da un punto (.) sono "nascosti" e non compaiono con un normale comando ls, di solito allo scopo di tenere ordinate le directory. I file nascosti possono essere visualizzati con ls -a. Il suffisso "rc" significa Run Commands e indica semplicemente che è un file di configurazione. Dal momento che controlla il modo in cui un programma viene eseguito, può inoltre (anche se storicamente inesatto) essere interpretato come "Run Control".

Copiare il file d'esempio /etc/skel/.xinitrc nella home directory:

$ cp /etc/skel/.xinitrc ~/

Quindi editare ~/.xinitrc e decommentare la riga corrispondente al proprio ambiente desktop. Per esempio, se si utilizza Xterm, sarà simile a questo:

#!/bin/sh
#
# ~/.xinitrc
#
# Executed by startx (run your window manager from here)

# exec gnome-session
# exec startkde
# exec startxfce4
# exec wmaker
# exec icewm
# exec blackbox
# exec fluxbox
# exec openbox-session
# ...or the Window Manager of your choice
exec xterm
Note: Assicurarsi di aver decommentato solo una riga exec in ~/.xinitrc.

Dopo aver editato .xinitrc si è pronti a lanciare X. Avviarlo da utente normale, non-root con:

$ startx

o

$ xinit

Il DE o WM scelto dovrebbe essersi avviato. È possibile provare la tastiera e la sua configurazione. Provare a spostare il mouse intorno per verificarne il funzionamento.

In caso di problemi con l'automount, provare ad utilizzare il seguente comando in ~/.xinitrc. Sostituire startxfce4 con il comando appropriato al window manager o desktop environment corrispondente.

exec ck-launch-session startxfce4
Note: Verificare di aver installato il pacchetto consolekit.

Il ck-launch-session garantirà che le variabili d'ambiente siano impostate correttamente avviando una sessione ConsoleKit pulita. ConsoleKit è un framework per tenere traccia dei vari utenti e sessioni presenti sul sistema. Fornisce un meccanismo con il quale i software reagiscono ai cambiamenti di uno qualsiasi di questi elementi o di uno qualsiasi dei metadati ad essi associati. Funziona in combinazione con D-Bus e altri strumenti.

File d'esempio

Quello che segue è un semplice file ~/.xinitrc d'esempio, compresi alcuni programmi in avvio automatico:

~/.xinitrc
#!/bin/sh

xrdb -merge ~/.Xresources         # aggiorna x resources db

xscreensaver -no-splash &         # avvia il demone di xscreensaver
xsetroot -cursor_name left_ptr &  # setta il cursore di X
sh ~/.fehbg &                     # setta lo sfondo con feh

exec openbox-session              # avvia il window manager

L'esempio che segue può essere utilizzato come modello per l'esecuzione di vari window manager, decommentando quello da utilizzare, ad es. Openbox:

~/.xinitrc
#!/bin/sh
#
# ~/.xinitrc
#
# Executed by startx (run your window manager from here)
#
# exec ion
# exec jwm
# exec wmaker
# exec startkde
# exec icewm
# exec pekwm
# exec blackbox
# exec /usr/bin/ratpoison
# exec gnome-session
# exec startfluxbox
# exec startxfce4
# exec xfce4-session
exec openbox-session
# exec startlxde

Anteporre exec è raccomandato in quanto sostituisce il processo corrente con il gestore, ma non è necessario se tutti i desktop/window manager aggiuntivi sono commentati come nell'esempio di cui sopra. Usare il percorso completo per il window manager o l'ambiente desktop quando possibile. È possibile ottenere il relativo percorso utilizzando type, ad es. type startkde.

Oltre agli esempi qui forniti, si può trovare un file standard in /etc/skel/.xinitrc fornito da xorg-xinit. Per utilizzarlo, è sufficiente copiarlo nella cartella home:

$ cp /etc/skel/.xinitrc ~/

Configurazione del file

Quando non viene utilizzato un display manager, è importante ricordare che la vita della sessione di X inizia e finisce con lo script .xinitrc. Ciò significa che una volta terminato lo script, X termina indipendentemente dai programmi che stanno ancora girando (compreso il gestore delle finestre). È importante perciò che la chiusura del gestore delle finestre e di X coincidano. Ciò può essere facilmente realizzato lanciando il gestore finestre come ultimo programma nello script.

Si noti che nel primo esempio di cui sopra, programmi come cairo-compmgr, xscreensaver, xsetroot e sh vengono eseguiti in background (con aggiunto il suffisso &). Altrimenti, lo script potrebbe fermarsi e attendere che ogni programma e demone termini prima di eseguire openbox-session. Notare inotre che openbox-session non è in background. Questo garantisce che lo script non si chiuderà prima di openbox stesso. Se si esegue lo script startx manualmente, terminare lo script significa terminare anche X e lascierà solo le console virtuali /etc/inittab che erano avviate.

Se si esegue il file da /etc/inittab e la riga è configurata su respawn invece di once, ~/.xinitrc verrà riavviato. In questo modo X può essere riavviato senza dover riavviare il computer.

Nelle sezioni seguenti verrà spiegato come configurare ~/.xinitrc per De e WM multipli.

Dalla riga di comando

Se si dispone di un ~/.xinitrc funzionante, ma si desidera provare altri WM/DE, è possibile farlo mediante l'esecuzione di xinit seguito dal percorso del window manager:

xinit /full/path/to/window-manager

Si noti che il percorso completo è richiesto. Opzionalmente, è possibile passare delle opzioni al server X con l'aggiunta di --, ad es.:

xinit /usr/bin/enlightenment -- -br +bs -dpi 96

Il file ~/.xinitrc seguente, mostra come avviare un particolare window manager con un argomento:

~/.xinitrc
#!/bin/sh
#
# ~/.xinitrc
#
# Executed by startx (run your window manager from here)

if [[ $1 == "fluxbox" ]]
then
  exec startfluxbox
elif [[ $1 == "scrotwm" ]]
then
  exec startscrotwm
else
  echo "Choose a window manager"
fi

Utilizzando questo esempio è possibile avviare fluxbox o scrotwm con il comando xinit fluxbox o xinit scrotwm.

All'avvio

È possibile avere anche una scelta di gestori di finestre e di ambienti desktop all'avvio, usando solo .xinitrc e GRUB Legacy e nessun display manager. L'idea è quella di prendere vantaggio dal fatto che Arch non fa alcun uso particolare del sistema di runlevel. Il seguente .xinitrc testerà il runlevel corrente e avvierà Openbox e GNOME rispettivamente sui runlevel 5 e 4:

rl=$(runlevel | grep -o [0-6])

case $rl in
	4) exec gnome-session;;
	5) exec openbox-session;;
esac

Scegliere tra diversi runlevel è semplicemente una questione di clonazione delle entrate di GRUB e di aggiunta all'argomento kernel del runlevel desiderato. Inserendo il runlevel alla fine della linea "kernel" si indica che l'inittab di base sul runlevel 5 dovrà essere ignorato e sostituito con il runlevel desiderato, 4 in questo caso:

title  Arch Linux GNOME
root   (hd0,2)
kernel /boot/vmlinuz-linux root=/dev/sda1 ro 4
initrd /boot/initramfs-linux.img

Alla fine, bisogna assicurarsi che il file .xinitrc sia avviato effettivamente sul runlevel scelto. Usando i consigli da Start X at boot, si può editare il file inittab semplicemente lanciando startx sul runlevel desiderato che in cambio userà il proprio script .xinitrc:

x:45:once:/bin/su PREFERED_USER -l -c "/bin/bash --login -c startx >/dev/null 2>&1"

Da notare che "45" significa che ciò accade sia sul runlevel 4 che 5. La differenziazione finale tra 4 e 5 arrivera poi nel file .xinitrc come descritto sopra. Questo è preferibile rispetto al tentativo di differenziazione nel file inittab dal momento che ci atteniamo abbastanza vicino a utilizzare i vari file di configurazione così come erano destinati in principio.

Suggerimenti

Policykit e ConsoleKit

Svariate applicazioni di vari ambienti desktop richiedono che le PolicyKit e ConsoleKit siano attive, e produrranno degli errori in caso contrario. Un errore comune è l'impossibilità di accedere alle opzioni di spegnimento o riavvio dalle finestre del proprio ambiente desktop, come anche eventuali errori al montaggio di dispositivi usb o cd-rom senza permessi di root. I login manager più moderni avvieranno PolicyKit automaticamente, ma quando si usa solamente ~/.xinitrc con il comando startx lo si dovrebbe avviare in questa maniera:

exec ck-launch-session gnome-session
Nota: Assicurarsi di avere installato polkit e consolekit sul proprio sistema.
Nota: Se il proprio ~/.xinitrc arriva da /etc/skel/.xinitrc) si noterà che il frammento iniziale in /etc/X11/xinit/xinitrc.d include /etc/X11/xinit/xinitrc.d/30-bus che lancia dbus prima che che sia eseguito ck-launch-session. Questo causa un bug: FS#25031.

Un workaround temporaneo è modificare così il proprio ~/.xinitrc:

if [ -d /etc/X11/xinit/xinitrc.d ]; then
 for f in /etc/X11/xinit/xinitrc.d/*; do
   # Do not launch dbus before ConsoleKit (FS#25031)
   #[ -x "$f" ] && . "$f"
   [ "$f" -ne "/etc/X11/xinit/xinitrc.d/30-dbus" ] && [ -x "$f" ] && .  "$f"
 done
 unset f
fi
Questo lancerà dbus dopo Consolekit aggirando completamente il bug. Per maggiori informazioni fare riferimento alle pagine wiki: Window Manager e Desktop Environment.

Avviare per primo il WM

Se è necessario avviare il window manager prima del lancio di applicazioni aggiuntive, utilizzare il seguente metodo:

#!/bin/bash

openbox & wmpid=$!

urxvtd -q -f -o &
xscreensaver -no-splash &
fbpanel &

wait $wmpid

Con la prima riga openbox viene eseguito come un processo in background e memorizza immediatamente l'id del processo ($!) nella variabile wmpid. Nell'ultima riga, l'incorporazione di "wait" è utilizzata per attendere che termini il processo specificato da wmpid.

Link esterni